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
132
133

use chrono::prelude::*;
use serde::{Deserialize, Serialize};
pub use serde_json::Value;

pub type ListDocuments = Vec<ListDocument>;

pub type ListItems = Vec<ListItem>;
#[derive(Serialize, Deserialize, Debug)]
pub struct ItemLite {
    pub website: String,
    pub username: String,
    pub password: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetItem {
    pub uuid: String,
    #[serde(alias = "templateUuid")]
    pub template_uuid: String,
    pub trashed: String,
    #[serde(alias = "createdAt")]
    #[serde(with = "date_format")]
    pub create_at: DateTime<Local>,
    #[serde(alias = "updatedAt")]
    #[serde(with = "date_format")]
    pub update_at: DateTime<Local>,
    #[serde(alias = "changerUuid")]
    pub changer_uuid: String,
    #[serde(alias = "itemVersion")]
    pub item_version: usize,
    #[serde(alias = "vaultUuid")]
    pub vault_uuid: String,
    pub details: Value, // this field is a serde_json::Value because its content would change depend on the queried item.
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Account {
    pub uuid: String,
    pub name: String,
    #[serde(alias = "type")]
    pub type_: String,
    pub state: String,
    pub avatar: String,
    pub domain: String,
    #[serde(alias = "attrVersion")]
    pub attr_version: usize,
    #[serde(alias = "createdAt")]
    #[serde(with = "date_format")]
    pub create_at: DateTime<Local>,
    #[serde(alias = "baseAvatarURL")]
    pub base_avatar_url: String,
    #[serde(alias = "baseAttachmentURL")]
    pub base_attachment_url: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateDocument {
    pub uuid: String,
    #[serde(alias = "createdAt")]
    #[serde(with = "date_format")]
    pub create_at: DateTime<Local>,
    #[serde(alias = "updatedAt")]
    #[serde(with = "date_format")]
    pub update_at: DateTime<Local>,
    #[serde(alias = "vaultUuid")]
    pub vault_uuid: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ListDocument {
    pub uuid: String,
    #[serde(alias = "templateUuid")]
    pub template_uuid: String,
    #[serde(alias = "createdAt")]
    #[serde(with = "date_format")]
    pub create_at: DateTime<Local>,
    #[serde(alias = "updatedAt")]
    #[serde(with = "date_format")]
    pub update_at: DateTime<Local>,
    #[serde(alias = "itemVersion")]
    pub item_version: usize,
    #[serde(alias = "vaultUuid")]
    pub vault_uuid: String,
    pub overview: Value, // this field is a serde_json::Value because its content would change depend on the queried item.
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ListItem {
    pub uuid: String,
    #[serde(alias = "templateUuid")]
    pub template_uuid: String,
    pub trashed: String,
    #[serde(alias = "createdAt")]
    #[serde(with = "date_format")]
    pub create_at: DateTime<Local>,
    #[serde(alias = "updatedAt")]
    #[serde(with = "date_format")]
    pub update_at: DateTime<Local>,
    #[serde(alias = "changerUuid")]
    pub changer_uuid: String,
    #[serde(alias = "itemVersion")]
    pub item_version: usize,
    #[serde(alias = "vaultUuid")]
    pub vault_uuid: String,
    pub overview: Value, // this field is a serde_json::Value because its content would change depend on the queried item.
}

//this mod helped to deserialize json string to chrono::DateTime.
//And it was copied from StackOverflow!
mod date_format {
    use chrono::{DateTime, Local, TimeZone};
    use serde::{self, Deserialize, Deserializer, Serializer};

    const FORMAT: &'static str = "%Y-%m-%dT%H:%M:%S%.f%Z";

    pub fn serialize<S>(date: &DateTime<Local>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let s = format!("{}", date.format(FORMAT));
        serializer.serialize_str(&s)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<Local>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Local
            .datetime_from_str(&s, FORMAT)
            .map_err(serde::de::Error::custom)
    }
}