/
credential.go
101 lines (87 loc) · 3.89 KB
/
credential.go
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
package keeper
import (
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/store/prefix"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/query"
"github.com/elesto-dao/elesto/v2/x/credential"
)
// SetCredentialDefinition persist a credential definition to the store. The credential definition ID is used as key.
func (k Keeper) SetCredentialDefinition(ctx sdk.Context, def *credential.CredentialDefinition) {
k.Set(ctx, []byte(def.Id), credential.CredentialDefinitionKey, def, k.cdc.MustMarshal)
}
// GetCredentialDefinition retrieve a credential definition by its key.
// The boolean return will be false if the credential definition is not found
func (k Keeper) GetCredentialDefinition(ctx sdk.Context, key string) (credential.CredentialDefinition, bool) {
val, found := k.Get(ctx, []byte(key), credential.CredentialDefinitionKey, func(value []byte) (interface{}, bool) {
var data credential.CredentialDefinition
ok := k.Unmarshal(value, &data)
return data, ok
})
return val.(credential.CredentialDefinition), found
}
// GetCredentialDefinitions list credential definitions
func (k Keeper) GetCredentialDefinitions(ctx sdk.Context, req *credential.QueryCredentialDefinitionsRequest) (cds []*credential.CredentialDefinition, pageRes *query.PageResponse, err error) {
store := ctx.KVStore(k.storeKey)
cdStore := prefix.NewStore(store, credential.CredentialDefinitionKey)
pageRes, err = query.Paginate(cdStore, req.Pagination, func(key []byte, value []byte) error {
var cd credential.CredentialDefinition
k.cdc.MustUnmarshal(value, &cd)
cds = append(cds, &cd)
return nil
})
return
}
// SetPublicCredential persist a public verifiable credential to the store. The credential ID is used as key
func (k Keeper) SetPublicCredential(ctx sdk.Context, pc *credential.PublicVerifiableCredential) {
k.Set(ctx, []byte(pc.Id), credential.PublicCredentialKey, pc, k.cdc.MustMarshal)
}
// GetPublicCredential retrieve a public verifiable credential by its key.
// The boolean return will be false if the credential is not found
func (k Keeper) GetPublicCredential(ctx sdk.Context, key string) (credential.PublicVerifiableCredential, bool) {
val, found := k.Get(ctx, []byte(key), credential.PublicCredentialKey, func(value []byte) (interface{}, bool) {
var data credential.PublicVerifiableCredential
ok := k.Unmarshal(value, &data)
return data, ok
})
return val.(credential.PublicVerifiableCredential), found
}
// Unmarshal from byte slice to a struct, return false in case of errors
func (k Keeper) Unmarshal(data []byte, val codec.ProtoMarshaler) bool {
if len(data) == 0 {
return false
}
if err := k.cdc.Unmarshal(data, val); err != nil {
return false
}
return true
}
// GetCredentialDefinitionsWithFilter retrieve a list of credential definitions with filter
func (k Keeper) GetCredentialDefinitionsWithFilter(ctx sdk.Context, filter func(credentialDefinition *credential.CredentialDefinition) bool) []*credential.CredentialDefinition {
var cds []*credential.CredentialDefinition
iterator := k.GetAll(ctx, credential.CredentialDefinitionKey)
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var cd credential.CredentialDefinition
k.cdc.MustUnmarshal(iterator.Value(), &cd)
if filter(&cd) {
cds = append(cds, &cd)
}
}
return cds
}
// GetPublicCredentialWithFilter retrieve a list of verifiable credentials
// filtered by properties
func (k Keeper) GetPublicCredentialWithFilter(ctx sdk.Context, filter func(verifiableCredential *credential.PublicVerifiableCredential) bool) []*credential.PublicVerifiableCredential {
var pvcs []*credential.PublicVerifiableCredential
iterator := k.GetAll(ctx, credential.PublicCredentialKey)
defer iterator.Close()
for ; iterator.Valid(); iterator.Next() {
var pvc credential.PublicVerifiableCredential
k.cdc.MustUnmarshal(iterator.Value(), &pvc)
if filter(&pvc) {
pvcs = append(pvcs, &pvc)
}
}
return pvcs
}