Profile

1pub contract Profile {
2  pub let publicPath: PublicPath
3  pub let privatePath: StoragePath
4
5  pub resource interface Public {
6    pub fun getName(): String
7    pub fun getAvatar(): String
8    pub fun getColor(): String
9    pub fun getInfo(): String
10    pub fun asReadOnly(): Profile.ReadOnly
11  }
12  
13  pub resource interface Owner {
14    pub fun getName(): String
15    pub fun getAvatar(): String
16    pub fun getColor(): String
17    pub fun getInfo(): String
18    
19    pub fun setName(_ name: String) {
20      pre {
21        name.length <= 15: "Names must be under 15 characters long."
22      }
23    }
24    pub fun setAvatar(_ src: String)
25    pub fun setColor(_ color: String)
26    pub fun setInfo(_ info: String) {
27      pre {
28        info.length <= 280: "Profile Info can at max be 280 characters long."
29      }
30    }
31  }
32  
33  pub resource Base: Owner, Public {
34    access(self) var name: String
35    access(self) var avatar: String
36    access(self) var color: String
37    access(self) var info: String
38    
39    init() {
40      self.name = "Anon"
41      self.avatar = ""
42      self.color = "#232323"
43      self.info = ""
44    }
45    
46    pub fun getName(): String { return self.name }
47    pub fun getAvatar(): String { return self.avatar }
48    pub fun getColor(): String {return self.color }
49    pub fun getInfo(): String { return self.info }
50    
51    pub fun setName(_ name: String) { self.name = name }
52    pub fun setAvatar(_ src: String) { self.avatar = src }
53    pub fun setColor(_ color: String) { self.color = color }
54    pub fun setInfo(_ info: String) { self.info = info }
55    
56    pub fun asReadOnly(): Profile.ReadOnly {
57      return Profile.ReadOnly(
58        address: self.owner?.address,
59        name: self.getName(),
60        avatar: self.getAvatar(),
61        color: self.getColor(),
62        info: self.getInfo()
63      )
64    }
65  }
66
67  pub struct ReadOnly {
68    pub let address: Address?
69    pub let name: String
70    pub let avatar: String
71    pub let color: String
72    pub let info: String
73    
74    init(address: Address?, name: String, avatar: String, color: String, info: String) {
75      self.address = address
76      self.name = name
77      self.avatar = avatar
78      self.color = color
79      self.info = info
80    }
81  }
82  
83  pub fun new(): @Profile.Base {
84    return <- create Base()
85  }
86  
87  pub fun check(_ address: Address): Bool {
88    return getAccount(address)
89      .getCapability<&{Profile.Public}>(Profile.publicPath)
90      .check()
91  }
92  
93  pub fun fetch(_ address: Address): &{Profile.Public} {
94    return getAccount(address)
95      .getCapability<&{Profile.Public}>(Profile.publicPath)
96      .borrow()!
97  }
98  
99  pub fun read(_ address: Address): Profile.ReadOnly? {
100    if let profile = getAccount(address).getCapability<&{Profile.Public}>(Profile.publicPath).borrow() {
101      return profile.asReadOnly()
102    } else {
103      return nil
104    }
105  }
106  
107  pub fun readMultiple(_ addresses: [Address]): {Address: Profile.ReadOnly} {
108    let profiles: {Address: Profile.ReadOnly} = {}
109    for address in addresses {
110      let profile = Profile.read(address)
111      if profile != nil {
112        profiles[address] = profile!
113      }
114    }
115    return profiles
116  }
117
118    
119  init() {
120    self.publicPath = /public/profile
121    self.privatePath = /storage/profile
122    
123    self.account.save(<- self.new(), to: self.privatePath)
124    self.account.link<&Base{Public}>(self.publicPath, target: self.privatePath)
125    
126    self.account
127      .borrow<&Base{Owner}>(from: self.privatePath)!
128      .setName("qvvg")
129  }
130}