astrox_macros 0.2.2

add user management and canister relation management for canister
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

#[macro_export]
macro_rules! inject_canister_users {
    () => {
        thread_local! {
          pub static USER: RefCell<User> = RefCell::new(User::default());
        }

        use astrox_macros::user::User;
        use ic_cdk::caller;
        use ic_cdk::export::Principal;
        use ic_cdk::{id, trap};
        use std::cell::RefCell;

        /* owner relative methods */
        #[inline(always)]
        pub fn owner_guard() -> Result<(), String> {
            let caller = caller();
            let ret = is_owner(caller);
            if ret {
                Ok(())
            } else {
                trap(&format!("{} unauthorized", caller));
            }
        }

        pub fn is_owner(user_id: Principal) -> bool {
            USER.with(|b| b.borrow().is_owner(user_id))
        }

        pub fn owners_set(users: BTreeMap<Principal, String>) {
            USER.with(|s| s.borrow_mut().owners_set(users));
        }

        pub fn owners() -> Option<BTreeMap<Principal, String>> {
            USER.with(|s| s.borrow().owners())
        }


        pub fn owner_add(user_id: Principal) {
            USER.with(|s| s.borrow_mut().owner_add(user_id.to_text(), user_id));
        }


        pub fn owner_add_with_name(name: String, user_id: Principal) {
            USER.with(|s| s.borrow_mut().owner_add(name, user_id));
        }


        pub fn owner_remove(user_id: Principal) {
            USER.with(|s| s.borrow_mut().owner_remove(user_id));
        }

        /* user relative methods */
        #[inline(always)]
        pub fn user_guard() -> Result<(), String> {
            let caller = caller();
            let ret = USER.with(|b| b.borrow().is_user(caller));
            if ret {
                Ok(())
            } else {
                trap(&format!("{} unauthorized", caller));
            }
        }

        pub fn users_set(users: BTreeMap<Principal, String>)  {
            USER.with(|s| s.borrow_mut().users_set(users));
        }


        pub fn users() -> Option<BTreeMap<Principal, String>> {
            USER.with(|s| s.borrow().users())
        }

        pub fn user_add(user_id: Principal) {
            USER.with(|s| s.borrow_mut().user_add(user_id.to_text(), user_id));
        }


        pub fn user_add_with_name(name: String, user_id: Principal) {
            USER.with(|s| s.borrow_mut().user_add(name, user_id));
        }

        pub fn user_remove(user_id: Principal) {
            USER.with(|s| s.borrow_mut().user_remove(user_id));
        }

        /* op relative methods */
        #[inline(always)]
        pub fn op_guard() -> Result<(), String> {
            let caller = caller();
            let ret = USER.with(|b| b.borrow().is_op(caller));
            if ret {
                Ok(())
            } else {
                trap(&format!("{} unauthorized", caller));
            }
        }

        pub fn ops_set(users: BTreeMap<Principal, String>)  {
            USER.with(|s| s.borrow_mut().ops_set(users));
        }

        pub fn ops() -> Option<BTreeMap<Principal, String>> {
            USER.with(|s| s.borrow().ops())
        }


        pub fn op_add(user_id: Principal) {
            USER.with(|s| s.borrow_mut().op_add(user_id.to_text(), user_id));
        }


        pub fn op_add_with_name(name: String, user_id: Principal) {
            USER.with(|s| s.borrow_mut().op_add(name, user_id));
        }

        pub fn op_remove(user_id: Principal) {
            USER.with(|s| s.borrow_mut().op_remove(user_id));
        }


        pub fn users_pre_upgrade() -> User {
            USER.with(|s| s.take().into())
        }

        pub fn users_post_upgrade(stable_state: User) {
            USER.with(|s| s.replace(stable_state));
        }
    };
}