crcnt_rbac 0.1.8

CRCNT RBAC Component
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

use {crate::role::RoleId,
     crcnt_ddd::value::{CreateAt,
                        Creator,
                        Deleted,
                        EntityId,
                        Owner,
                        StrIr,
                        UpdateAt,
                        Updater,
                        UtcDateTime},
     crcnt_ddd_macros::Domain,
     mysql_common::value::{convert::{ConvIr,
                                     FromValue,
                                     FromValueError},
                           Value}};

#[doc(hidden)]
#[derive(Domain)]
#[domain_commands(entity, store)]
#[domain_store(params_extractor = "crate::params_extractor", table_name = "t_rbac_operator")]
struct __Operator__ {
  id:            EntityId,
  #[domain_value(optional = true)]
  profile_id:    String,
  name:          String,
  #[domain_value(enums = "LoginName|Email|Mobile")]
  name_type:     String,
  password:      String,
  #[domain_value(enums = "Active|Inactive|NeedChangePwd")]
  status:        String,
  #[domain_value(optional = true)]
  last_login_at: UtcDateTime,
  failed_times:  u8,
  #[domain_value(skip_new_type = true)]
  owner:         Owner,
  #[domain_value(skip_new_type = true)]
  creator:       Creator,
  #[domain_value(skip_new_type = true)]
  updater:       Updater,
  #[domain_value(skip_new_type = true)]
  create_at:     CreateAt,
  #[domain_value(skip_new_type = true)]
  update_at:     UpdateAt,
  #[domain_value(skip_new_type = true)]
  deleted:       Deleted,
}

#[doc(hidden)]
#[derive(Domain)]
#[domain_commands(entity, store)]
#[domain_store(params_extractor = "crate::params_extractor", table_name = "t_rbac_role_operator")]
struct __RoleOperator__ {
  id:          EntityId,
  #[domain_value(skip_new_type = true)]
  operator_id: OperatorId,
  #[domain_value(skip_new_type = true)]
  role_id:     RoleId,
  #[domain_value(skip_new_type = true)]
  owner:       Owner,
  #[domain_value(skip_new_type = true)]
  create_at:   CreateAt,
}

impl FromValue for OperatorId {
  type Intermediate = StrIr;
}
impl ConvIr<OperatorId> for StrIr {
  fn new(v: Value) -> Result<Self, FromValueError> {
    let bytes = Vec::<u8>::from_value_opt(v)?;
    Ok(StrIr { bytes })
  }

  fn commit(self) -> OperatorId {
    let creator = String::from_utf8_lossy(&self.bytes).to_string();
    OperatorId(EntityId::new(creator))
  }

  fn rollback(self) -> Value { Value::from(self.bytes) }
}

impl OperatorPassword {
  pub fn change_me() -> Self { OperatorPassword::new("ChangeMe!") }
}

#[cfg(test)]
mod test {
  use {super::*,
       ulid::Ulid};

  struct Store;

  impl OperatorEntityCRUDStmt for Store {}

  impl OperatorEntityCRUDExec for Store {}
  #[test]
  fn test() {
    let operator = OperatorEntity::builder().id(EntityId::new(Ulid::new()).into())
                                            .profile_id("M01".into())
                                            .name("admin".into())
                                            .name_type(OperatorNameType::LoginName)
                                            .password("12345".into())
                                            .status(OperatorStatus::Active)
                                            .last_login_at(UtcDateTime::now().into())
                                            .failed_times(0u8.into())
                                            .owner("CNT".into())
                                            .creator("--".into())
                                            .updater("--".into())
                                            .create_at(CreateAt::now())
                                            .update_at(UpdateAt::now())
                                            .deleted(true.into())
                                            .build();
    println!("test: {:?}", operator);
    println!("select sql: {}", Store.stmt_select_operator_entity());
  }
}