webchain-rs 0.22.1

Webchain Network secure account management core libary
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! # Addressbook utils
pub mod error;

use self::error::AddressbookError;
use core::Address;
use glob::glob;
use serde_json;
use std::fs::remove_file;
use std::fs::File;
use std::path::{Path, PathBuf};

/// Addressbook Service
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AddressbookStorage {
    dir: PathBuf,
}

impl AddressbookStorage {
    /// Initialize new addressbook service for a dir
    pub fn new(dir: PathBuf) -> AddressbookStorage {
        AddressbookStorage { dir }
    }

    /// Read addressbook files
    pub fn read_json(path: &Path) -> Result<serde_json::Value, AddressbookError> {
        match File::open(path) {
            Ok(f) => serde_json::from_reader(f)
                .or_else(|_| Err(AddressbookError::IO("Can't read address file".to_string()))),
            Err(_) => Err(AddressbookError::IO("Can't open adress file".to_string())),
        }
    }

    /// List all entries in the addressbook
    pub fn list(&self) -> Vec<serde_json::Value> {
        let files = glob(&format!("{}/*.json", &self.dir.to_str().unwrap())).unwrap();

        files
            .filter(|x| x.is_ok())
            .map(|x| AddressbookStorage::read_json(x.unwrap().as_path()))
            .filter(|x| x.is_ok())
            .map(|x| x.unwrap())
            .collect()
    }

    /// Validate addressbook entry structure
    pub fn validate(&self, entry: &serde_json::Value) -> Result<(), AddressbookError> {
        if !entry.is_object() {
            return Err(AddressbookError::InvalidAddress(
                "Invalid data format".to_string(),
            ));
        }
        let addr = match entry.get("address") {
            Some(addr) => addr,
            None => {
                return Err(AddressbookError::InvalidAddress(
                    "Missing address".to_string(),
                ))
            }
        };
        if !addr.is_string() {
            return Err(AddressbookError::InvalidAddress(
                "Invalid address format".to_string(),
            ));
        }
        match addr.as_str().unwrap().parse::<Address>() {
            Ok(_) => {}
            Err(_) => {
                return Err(AddressbookError::InvalidAddress(
                    "Can't parse address".to_string(),
                ))
            }
        }
        Ok(())
    }

    /// Add new address entry to addressbook storage
    pub fn add(&self, entry: &serde_json::Value) -> Result<(), AddressbookError> {
        self.validate(entry)?;
        let addr = entry
            .get("address")
            .expect("Expect address for addressbook entry")
            .as_str()
            .expect("Expect address be convertible to a string");
        let mut filename: PathBuf = self.dir.clone();
        filename.push(format!("{}.json", addr));
        let mut f = File::create(filename.as_path()).unwrap();
        match serde_json::to_writer_pretty(&mut f, entry) {
            Ok(_) => Ok(()),
            Err(_) => Err(AddressbookError::IO(format!(
                "Can't write address {}",
                addr
            ))),
        }
    }

    /// Edit address entry in addressbook storage (address cannot change)
    pub fn edit(&self, entry: &serde_json::Value) -> Result<(), AddressbookError> {
        self.validate(entry)?;
        let addr = entry
            .get("address")
            .expect("Expect id for addressbook entry")
            .as_str()
            .expect("Expect id be convertible to a string");
        let mut filename: PathBuf = self.dir.clone();
        filename.push(format!("{}.json", addr));
        let mut f = File::create(filename.as_path()).unwrap();
        match serde_json::to_writer_pretty(&mut f, entry) {
            Ok(_) => Ok(()),
            Err(_) => Err(AddressbookError::IO(format!(
                "Can't write address {}",
                addr
            ))),
        }
    }

    /// Delete address entry in addressbook storage (address cannot change)
    pub fn delete(&self, entry: &serde_json::Value) -> Result<(), AddressbookError> {
        let addr = entry
            .as_str()
            .expect("Expect address be convertible to a string");
        let mut filename: PathBuf = self.dir.clone();
        filename.push(format!("{}.json", addr));
        match remove_file(filename) {
            Ok(_) => Ok(()),
            Err(_) => Err(AddressbookError::IO(format!(
                "Can't delete file for address {}",
                addr
            ))),
        }
    }
}