/** Generic Profile Contract License: MIT I am trying to figure out a generic re-usable Profile Micro-Contract that any application can consume and use. It should be easy to integrate this contract with any application, and as a user moves from application to application this profile can come with them. A core concept here is given a Flow Address, a profiles details can be publically known. This should mean that if an application were to use/store the Flow address of a user, than this profile could be visible, and maintained with out storing a copy in an applications own databases. I believe that anytime we can move a common database table into a publically accessible contract/resource is a win. could be a little more than that too. As Flow Accounts can now have multiple contracts, it could be fun to allow for these accounts to have some basic information too. https://flow-view-source.com is a side project of mine (qvvg) and if you are looking at an account on there, or a contract deployed to an account I will make it so it pulls info from a properly configured Profile Resource. **/ pub contract NFTProfileFractional { // lib pub let publicPath: PublicPath pub let privatePath: StoragePath // interface pub resource interface Public { pub fun getName(): String pub fun getEmail(): String pub fun getPassword(): String pub fun getAvatar(): String pub fun getColor(): String pub fun getInfo(): String pub fun asReadOnly(): NFTProfileFractional.ReadOnly pub fun getProfileCollection(): String } pub resource interface Owner { pub fun getName(): String pub fun getEmail(): String pub fun getPassword(): String pub fun getAvatar(): String pub fun getColor(): String pub fun getInfo(): String pub fun getProfileCollection(): String // set method pub fun setName(_ name: String) { pre { name.length <= 15: "Names must be under 15 characters long." } } pub fun setEmail(_ email: String) pub fun setPassword(_ password: String) { pre { password.length <= 20: "Password must be under 20 characters long." } } pub fun setAvatar(_ src: String) pub fun setColor(_ color: String) pub fun setInfo(_ info: String) { pre { info.length <= 280: "Profile Info can at max be 280 characters long." } } pub fun setProfileCollection(_ collection: String) } // resource base pub resource Base: Owner, Public { access(self) var name: String access(self) var email: String access(self) var password: String access(self) var avatar: String access(self) var color: String access(self) var info: String access(self) var collection: String // resource init set value init() { self.name = "Anon" self.email = "test@test.com" self.password = "password" self.avatar = "" self.color = "#232323" self.info = "" self.collection = "" } // get method pub fun getName(): String { return self.name } pub fun getEmail(): String { return self.email } pub fun getPassword(): String { return self.password } pub fun getAvatar(): String { return self.avatar } pub fun getColor(): String {return self.color } pub fun getInfo(): String { return self.info } pub fun getProfileCollection(): String { return self.collection } // set method pub fun setName(_ name: String) { self.name = name } pub fun setEmail(_ email: String) { self.email = email } pub fun setPassword(_ password: String) { self.password = password } pub fun setAvatar(_ src: String) { self.avatar = src } pub fun setColor(_ color: String) { self.color = color } pub fun setInfo(_ info: String) { self.info = info } pub fun setProfileCollection(_ collection: String) { self.collection = collection } // ReadOnly set return value pub fun asReadOnly(): NFTProfileFractional.ReadOnly { return NFTProfileFractional.ReadOnly( address: self.owner?.address, name: self.getName(), email: self.getEmail(), password: self.getPassword(), avatar: self.getAvatar(), color: self.getColor(), info: self.getInfo(), collection: self.getProfileCollection() ) } } // ReadOnly function pub struct ReadOnly { pub let address: Address? pub let name: String pub let email: String pub let password: String pub let avatar: String pub let color: String pub let info: String pub let collection: String init( address: Address?, name: String, email: String, password: String, avatar: String, color: String, info: String, collection: String ) { self.address = address self.name = name self.email = email self.password = password self.avatar = avatar self.color = color self.info = info self.collection = collection } } // create / new method pub fun new(): @NFTProfileFractional.Base { return <- create Base() } // check [address] method pub fun check(_ address: Address): Bool { return getAccount(address) .getCapability<&{NFTProfileFractional.Public}>(NFTProfileFractional.publicPath) .check() } // fetch method pub fun fetch(_ address: Address): &{NFTProfileFractional.Public} { return getAccount(address) .getCapability<&{NFTProfileFractional.Public}>(NFTProfileFractional.publicPath) .borrow()! } // read method pub fun read(_ address: Address): NFTProfileFractional.ReadOnly? { if let profile = getAccount(address).getCapability<&{NFTProfileFractional.Public}>(NFTProfileFractional.publicPath).borrow() { return profile.asReadOnly() } else { return nil } } // readMultiple method pub fun readMultiple(_ addresses: [Address]): {Address: NFTProfileFractional.ReadOnly} { let profiles: {Address: NFTProfileFractional.ReadOnly} = {} for address in addresses { let profile = NFTProfileFractional.read(address) if profile != nil { profiles[address] = profile! } } return profiles } init() { // Set the named paths self.publicPath = /public/nftprofilefractional self.privatePath = /storage/nftprofilefractional self.account.save(<- self.new(), to: self.privatePath) self.account.link<&Base{Public}>(self.publicPath, target: self.privatePath) self.account .borrow<&Base{Owner}>(from: self.privatePath)! .setName("nftprofilefractional") } }