Permitted

1import NonFungibleToken from 0x1d7e57aa55817448
2
3access(all) contract Permitted {
4    access(all) entitlement Administrator
5
6    access(all) let StoragePath: StoragePath
7    access(all) let PublicPath: PublicPath
8
9    access(all) event PermittedType(_ type: String, _ permitted: Bool, _ message: String)
10    access(all) event PermittedUUID(_ uuid: UInt64, _ permitted: Bool, _ message: String)
11    access(all) event PermittedTypeRemoved(_ type: Type)
12
13    access(all) resource Manager {
14        access(account) let permitted: {Type: Bool}
15        access(account) let permittedUUID: {UInt64: Bool}
16
17        access(all) view fun isPermitted(_ nft: &{NonFungibleToken.NFT}): Bool {
18            let t = nft.getType()
19            return (self.permitted[t] == nil || self.permitted[t]!) && (self.permittedUUID[nft.uuid] == nil || self.permittedUUID[nft.uuid]!)
20        }
21
22        access(Administrator) fun setPermittedType(_ t: Type, _ b: Bool, _ s: String) {
23            self.permitted[t] = b
24
25            let manager = Permitted.getReasonManager()
26            manager.setReason(t, s)
27
28            emit PermittedType(t.identifier, b, s)
29        }
30
31        access(Administrator) fun removeType(_ t: Type) {
32            self.permitted.remove(key: t)
33            emit PermittedTypeRemoved(t)
34        }
35
36        access(Administrator) fun setPermittedUUID(_ uuid: UInt64, _ b: Bool, _ s: String) {
37            self.permittedUUID[uuid] = b
38
39            emit PermittedUUID(uuid, b, s)
40        }
41
42        access(all) view fun getAll(): {Type: Bool} {
43            return self.permitted
44        }
45
46        init() {
47            self.permitted = {}
48            self.permittedUUID = {}
49        }
50    }
51
52    access(all) view fun isPermitted(_ nft: &{NonFungibleToken.NFT}): Bool {
53        return self.account.storage.borrow<&Manager>(from: Permitted.StoragePath)!.isPermitted(nft)
54    }
55
56    access(all) view fun getAll(): {Type: Bool} {
57        return self.account.storage.borrow<&Manager>(from: Permitted.StoragePath)!.getAll()
58    }
59    
60    access(all) view fun getReasonManagerPublicPath(): PublicPath {
61        return /public/permittedReason
62    }
63    
64    access(all) view fun getReasonManagerStoragePath(): StoragePath {
65        return /storage/permittedReason
66    }
67
68    access(all) resource PermitReasonManager {
69        access(all) let typeReasons: {Type: String}
70        access(all) let uuidReasons: {Type: String}
71
72        init() {
73            self.typeReasons = {}
74            self.uuidReasons = {}
75        }
76
77        access(Administrator) fun setReason(_ t: Type, _ s: String) {
78            self.typeReasons[t] = s
79        }
80
81        access(all) view fun getReason(_ t: Type): String? {
82            return self.typeReasons[t]
83        }
84    }
85
86    access(all) view fun getReason(_ t: Type): String? {
87        return self.account.storage.borrow<&PermitReasonManager>(from: Permitted.getReasonManagerStoragePath())!.getReason(t)
88    }
89
90    access(account) view fun getReasonManager(): auth(Administrator) &PermitReasonManager {
91        return self.account.storage.borrow<auth(Administrator) &PermitReasonManager>(from: Permitted.getReasonManagerStoragePath())!
92    }
93
94    access(all) fun createReasonManager(): @PermitReasonManager {
95        return <- create PermitReasonManager()
96    }
97
98    init() {
99        self.StoragePath = /storage/permittedManager
100        self.PublicPath = /public/permittedManager
101
102        self.account.storage.save(<- create Manager(), to: self.StoragePath)
103        self.account.storage.save(<- self.createReasonManager(), to: self.getReasonManagerStoragePath())
104    }
105}
106