benjamyn/any-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change InviteId logic and add UserAdd to change builder

Browse Source
This commit is contained in:
mcrakhman 2022-07-12 20:25:13 +02:00 committed by Mikhail Iudin
parent df6f3659fd
commit dbfb8cbabc
No known key found for this signature in database
GPG Key ID: FAAAA8BAABDFF1C0
14 changed files with 258 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
aclchanges/pb/aclchanges.pb.go
View File

@ -652,6 +652,7 @@ type ACLChangeUserInvite struct {
EncryptPublicKey []byte `protobuf:"bytes,2,opt,name=encryptPublicKey,proto3" json:"encryptPublicKey,omitempty"`
EncryptedReadKeys [][]byte `protobuf:"bytes,3,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
Permissions ACLChangeUserPermissions `protobuf:"varint,4,opt,name=permissions,proto3,enum=anytype.ACLChangeUserPermissions" json:"permissions,omitempty"`
InviteId string `protobuf:"bytes,5,opt,name=InviteId,proto3" json:"InviteId,omitempty"`
}
func (m *ACLChangeUserInvite) Reset() { *m = ACLChangeUserInvite{} }
@ -715,12 +716,19 @@ func (m *ACLChangeUserInvite) GetPermissions() ACLChangeUserPermissions {
return ACLChange_Admin
}
func (m *ACLChangeUserInvite) GetInviteId() string {
if m != nil {
return m.InviteId
}
return ""
}
type ACLChangeUserJoin struct {
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
AcceptSignature []byte `protobuf:"bytes,3,opt,name=acceptSignature,proto3" json:"acceptSignature,omitempty"`
UserInviteChangeId string `protobuf:"bytes,4,opt,name=userInviteChangeId,proto3" json:"userInviteChangeId,omitempty"`
EncryptedReadKeys [][]byte `protobuf:"bytes,5,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
AcceptSignature []byte `protobuf:"bytes,3,opt,name=acceptSignature,proto3" json:"acceptSignature,omitempty"`
UserInviteId string `protobuf:"bytes,4,opt,name=userInviteId,proto3" json:"userInviteId,omitempty"`
EncryptedReadKeys [][]byte `protobuf:"bytes,5,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
}
func (m *ACLChangeUserJoin) Reset() { *m = ACLChangeUserJoin{} }
@ -777,9 +785,9 @@ func (m *ACLChangeUserJoin) GetAcceptSignature() []byte {
return nil
}
func (m *ACLChangeUserJoin) GetUserInviteChangeId() string {
func (m *ACLChangeUserJoin) GetUserInviteId() string {
if m != nil {
return m.UserInviteChangeId
return m.UserInviteId
}
return ""
}
@ -978,64 +986,64 @@ func init() {
}
var fileDescriptor_ffc88c8445fc0f24 = []byte{
// 897 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcb, 0x6e, 0xeb, 0x44,
0x18, 0xf6, 0x24, 0x6d, 0x1d, 0xff, 0x0e, 0x6d, 0x18, 0x75, 0x61, 0xf9, 0x14, 0x2b, 0x54, 0x5c,
0x22, 0x84, 0x52, 0x29, 0x07, 0x71, 0x13, 0x12, 0x34, 0x3d, 0x40, 0x42, 0x59, 0x1c, 0xcd, 0x11,
0x20, 0x90, 0x58, 0x4c, 0xed, 0xe1, 0xd4, 0x22, 0xb1, 0x2d, 0xcf, 0xa4, 0x22, 0x1b, 0xde, 0x00,
0xc1, 0x7b, 0xb0, 0xe3, 0x05, 0xd8, 0xb2, 0x3c, 0x0b, 0x84, 0x58, 0xa2, 0xf6, 0x45, 0xd0, 0x5c,
0x7c, 0x49, 0x6a, 0x17, 0x09, 0x55, 0x42, 0xec, 0x66, 0xbe, 0xf9, 0xfe, 0xf1, 0xf7, 0x5f, 0xc7,
0xf0, 0x32, 0x0d, 0x17, 0xe1, 0x25, 0x4d, 0x9e, 0x32, 0x7e, 0x92, 0x5d, 0x9c, 0x64, 0x79, 0x2a,
0x52, 0x7e, 0x52, 0x81, 0x63, 0x85, 0x60, 0x9b, 0x26, 0x6b, 0xb1, 0xce, 0xd8, 0xf1, 0xcf, 0x87,
0xe0, 0x9c, 0x9e, 0x7d, 0x7a, 0xa6, 0x4e, 0xf1, 0x10, 0x5c, 0x91, 0x33, 0x36, 0x63, 0x34, 0x9a,
0x47, 0xdc, 0x43, 0xc3, 0xee, 0xc8, 0x21, 0x75, 0x08, 0x07, 0x00, 0x34, 0x5c, 0x14, 0x84, 0x8e,
0x22, 0xd4, 0x10, 0xfc, 0x0a, 0xec, 0xf3, 0x84, 0x66, 0xfc, 0x32, 0x15, 0x53, 0xca, 0xd9, 0x3c,
0xf2, 0xba, 0x43, 0x34, 0x72, 0xc8, 0x16, 0x8a, 0xdf, 0x00, 0x9b, 0x86, 0x8b, 0x47, 0x54, 0x50,
0x6f, 0x67, 0x88, 0x46, 0xee, 0xc4, 0x1f, 0x1b, 0x49, 0xe3, 0x52, 0x8e, 0x5c, 0x49, 0x06, 0x29,
0xa8, 0x52, 0x9f, 0xf1, 0x43, 0x59, 0xee, 0x0e, 0xd1, 0xa8, 0x4f, 0xea, 0x10, 0x1e, 0x03, 0x0e,
0x57, 0x79, 0xce, 0x12, 0x41, 0x18, 0x8d, 0xce, 0xd9, 0x7a, 0x46, 0xf9, 0xa5, 0xb7, 0x37, 0x44,
0xa3, 0x1d, 0xd2, 0x70, 0x82, 0x8f, 0xc0, 0x11, 0xf1, 0x92, 0x71, 0x41, 0x97, 0x99, 0x67, 0x0f,
0xd1, 0xa8, 0x4b, 0x2a, 0x00, 0xfb, 0xd0, 0x8b, 0x23, 0x96, 0x88, 0x58, 0xac, 0xbd, 0x9e, 0xf2,
0xa3, 0xdc, 0xfb, 0xbf, 0x74, 0xe1, 0x40, 0x4a, 0x4d, 0x13, 0xc1, 0x12, 0xf1, 0x39, 0x5d, 0xac,
0x18, 0x7e, 0x13, 0xec, 0x15, 0x67, 0xf9, 0x69, 0x14, 0x79, 0xa8, 0xd5, 0xab, 0xcf, 0x34, 0x63,
0x66, 0x91, 0x82, 0x8c, 0xdf, 0x07, 0x90, 0x4b, 0xc2, 0x96, 0xe9, 0x15, 0xf3, 0x3a, 0xca, 0xf4,
0x85, 0x16, 0x53, 0x4d, 0x9a, 0x59, 0xa4, 0x66, 0x82, 0xbf, 0x86, 0x43, 0xb9, 0x7b, 0xcc, 0xf2,
0x65, 0xcc, 0x79, 0x9c, 0x26, 0xda, 0x40, 0x05, 0xdf, 0x9d, 0xbc, 0xda, 0x72, 0xd5, 0x36, 0x7d,
0x66, 0x91, 0xc6, 0x6b, 0x0a, 0x7d, 0xf3, 0xe4, 0x2a, 0x16, 0xcc, 0x24, 0xac, 0x4d, 0x9f, 0x26,
0x15, 0xfa, 0xf4, 0x0e, 0xbf, 0x03, 0x3d, 0xb9, 0xfb, 0x24, 0x8d, 0x13, 0x95, 0x35, 0x77, 0xf2,
0xa0, 0xc5, 0x5c, 0x52, 0x66, 0x16, 0x29, 0xe9, 0x78, 0x0a, 0xae, 0x5c, 0x9f, 0xa5, 0xc9, 0x37,
0x71, 0xbe, 0x54, 0xa9, 0x74, 0x27, 0x41, 0x8b, 0xb5, 0x61, 0xcd, 0x2c, 0x52, 0x37, 0x9a, 0xda,
0xb0, 0x7b, 0x25, 0x13, 0xe4, 0xff, 0x88, 0xc0, 0x36, 0x55, 0x85, 0x3f, 0x00, 0x97, 0x86, 0x8b,
0x27, 0xa6, 0x2e, 0x4d, 0xc2, 0x82, 0xe6, 0x32, 0x2c, 0x58, 0xa4, 0x6e, 0x82, 0xa7, 0xaa, 0x19,
0x4c, 0x05, 0xa8, 0x66, 0x70, 0x27, 0xc7, 0xcd, 0x17, 0xd4, 0xcb, 0x84, 0xd4, 0xac, 0xfc, 0x8f,
0xc0, 0xad, 0xdd, 0x8f, 0xdf, 0x82, 0x9e, 0xfc, 0x82, 0xa0, 0x82, 0x19, 0x45, 0x0f, 0x5a, 0x14,
0x49, 0x0a, 0x29, 0xc9, 0xfe, 0x0f, 0x1d, 0xe8, 0x15, 0x30, 0x7e, 0x09, 0x9e, 0xcb, 0xab, 0x22,
0x67, 0xba, 0x93, 0x77, 0xc8, 0x26, 0x88, 0xdf, 0xd3, 0x59, 0x55, 0x26, 0xdc, 0xc8, 0x3f, 0x6a,
0x09, 0xac, 0xfe, 0x5c, 0x8d, 0x8f, 0xa7, 0x60, 0xc7, 0x2a, 0xb9, 0xdc, 0xeb, 0x2a, 0xd3, 0xd1,
0x1d, 0x42, 0xc7, 0xba, 0x0e, 0xf8, 0x87, 0x89, 0xc8, 0xd7, 0xa4, 0x30, 0xf4, 0xbf, 0x84, 0x7e,
0xfd, 0x00, 0x0f, 0xa0, 0xfb, 0x2d, 0x5b, 0x2b, 0xc7, 0x1d, 0x22, 0x97, 0xf8, 0xa1, 0xc9, 0xdc,
0x3f, 0x34, 0x85, 0xbe, 0x85, 0x68, 0xee, 0xbb, 0x9d, 0xb7, 0x91, 0x7f, 0x83, 0xc0, 0x29, 0x85,
0x6f, 0x34, 0x32, 0xda, 0x6c, 0x64, 0x19, 0x2c, 0x96, 0x84, 0xf9, 0x3a, 0x13, 0x71, 0x9a, 0x9c,
0xb3, 0xb5, 0xfa, 0x54, 0x9f, 0x6c, 0x82, 0xf8, 0x75, 0x78, 0xde, 0x00, 0x2c, 0x32, 0x03, 0x44,
0x3b, 0xde, 0x27, 0xb7, 0x0f, 0xf0, 0x23, 0x70, 0xb3, 0xb2, 0x89, 0xb8, 0xea, 0x98, 0xfd, 0xc6,
0xd2, 0xd8, 0x6c, 0x43, 0x4e, 0xea, 0x66, 0x72, 0xdc, 0xcd, 0xb9, 0xa9, 0x61, 0x16, 0xa9, 0xc6,
0xe9, 0x91, 0x3a, 0xe4, 0xff, 0x8a, 0xc0, 0x36, 0xf3, 0xe4, 0xff, 0xe9, 0xa3, 0xff, 0x31, 0xb8,
0xb5, 0xc6, 0xbd, 0xd3, 0x89, 0x23, 0x70, 0xcc, 0xc0, 0x9c, 0x47, 0xca, 0x01, 0x87, 0x54, 0x80,
0xff, 0x07, 0x02, 0xa8, 0x4a, 0x01, 0x8f, 0xe0, 0x80, 0x86, 0x21, 0xcb, 0xc4, 0xe3, 0xd5, 0xc5,
0x22, 0x0e, 0xcf, 0x4d, 0x59, 0xf5, 0xc9, 0x36, 0x8c, 0x5f, 0x83, 0x81, 0x71, 0xae, 0xa2, 0xea,
0xf0, 0xdc, 0xc2, 0xff, 0x93, 0x08, 0xfd, 0x8e, 0xa0, 0x57, 0x4c, 0xc6, 0x7b, 0x48, 0x72, 0x19,
0x98, 0x27, 0xf1, 0xd3, 0x84, 0x8a, 0x55, 0xae, 0x5f, 0x89, 0x32, 0x30, 0x25, 0x2c, 0xdf, 0xd2,
0x6a, 0x84, 0x6b, 0xa5, 0xf3, 0x48, 0x79, 0xe1, 0x90, 0x86, 0x93, 0xe6, 0xe0, 0xec, 0xb6, 0x04,
0xc7, 0x5f, 0xe9, 0x74, 0x99, 0x07, 0xec, 0x2e, 0xbf, 0xce, 0xe1, 0xc0, 0x0c, 0x2e, 0xc2, 0xb2,
0x05, 0x0d, 0xcb, 0x89, 0xf3, 0x62, 0x43, 0x28, 0xc9, 0x06, 0x93, 0x6c, 0x5b, 0xfa, 0xdf, 0xc3,
0xfe, 0x26, 0xe5, 0x1e, 0x42, 0x5a, 0x55, 0x50, 0xe9, 0x9f, 0x89, 0xe9, 0x2d, 0xdc, 0xff, 0x0e,
0x0e, 0x9b, 0x9e, 0xde, 0x3b, 0x55, 0x6c, 0xd5, 0x51, 0xe7, 0x5f, 0xd5, 0xd1, 0xf1, 0x29, 0x1c,
0x6c, 0x9d, 0x63, 0x07, 0x76, 0x4f, 0xa3, 0x65, 0x9c, 0x0c, 0x2c, 0x0c, 0xb0, 0xf7, 0x45, 0x1e,
0x0b, 0x96, 0x0f, 0x90, 0x5c, 0x4b, 0xb9, 0x2c, 0x1f, 0x74, 0xb0, 0x0b, 0xb6, 0x4e, 0x51, 0x34,
0xe8, 0x4e, 0x8f, 0x7e, 0xbb, 0x0e, 0xd0, 0xb3, 0xeb, 0x00, 0xfd, 0x75, 0x1d, 0xa0, 0x9f, 0x6e,
0x02, 0xeb, 0xd9, 0x4d, 0x60, 0xfd, 0x79, 0x13, 0x58, 0x5f, 0x75, 0xb2, 0x8b, 0x8b, 0x3d, 0xf5,
0x6f, 0xf9, 0xf0, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x54, 0xc0, 0x2c, 0x4a, 0x84, 0x0a, 0x00,
0x00,
// 907 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x6f, 0xe3, 0x44,
0x18, 0xf6, 0x24, 0x6d, 0x1d, 0xbf, 0x0e, 0x6d, 0x18, 0xf5, 0x60, 0x79, 0x8b, 0x15, 0x2a, 0x3e,
0x22, 0x84, 0x52, 0x29, 0x8b, 0xf8, 0x12, 0x12, 0x34, 0x5d, 0x20, 0xa1, 0x1c, 0x56, 0xb3, 0x02,
0x04, 0x12, 0x87, 0xa9, 0x3d, 0x6c, 0x2d, 0x92, 0xb1, 0xe5, 0x99, 0x54, 0xe4, 0xc2, 0x3f, 0x40,
0xf0, 0x5b, 0xb8, 0x72, 0xe0, 0xba, 0xc7, 0x3d, 0x72, 0x44, 0xed, 0x3f, 0xe0, 0x17, 0xa0, 0xf9,
0xb0, 0xe3, 0xa4, 0x71, 0x91, 0x50, 0x25, 0xc4, 0x6d, 0xe6, 0x99, 0xe7, 0x99, 0xbc, 0x1f, 0xcf,
0x3b, 0x0e, 0xbc, 0x4a, 0xe3, 0x59, 0x7c, 0x49, 0xf9, 0x53, 0x26, 0x4e, 0xf2, 0x8b, 0x93, 0xbc,
0xc8, 0x64, 0x26, 0x4e, 0x56, 0xe0, 0x50, 0x23, 0xd8, 0xa5, 0x7c, 0x29, 0x97, 0x39, 0x3b, 0xfe,
0xed, 0x10, 0xbc, 0xd3, 0xb3, 0xcf, 0xcf, 0xf4, 0x29, 0xee, 0x83, 0x2f, 0x0b, 0xc6, 0x26, 0x8c,
0x26, 0xd3, 0x44, 0x04, 0xa8, 0xdf, 0x1e, 0x78, 0xa4, 0x0e, 0xe1, 0x08, 0x80, 0xc6, 0xb3, 0x92,
0xd0, 0xd2, 0x84, 0x1a, 0x82, 0x5f, 0x83, 0x7d, 0xc1, 0x69, 0x2e, 0x2e, 0x33, 0x39, 0xa6, 0x82,
0x4d, 0x93, 0xa0, 0xdd, 0x47, 0x03, 0x8f, 0x6c, 0xa0, 0xf8, 0x2d, 0x70, 0x69, 0x3c, 0x7b, 0x44,
0x25, 0x0d, 0x76, 0xfa, 0x68, 0xe0, 0x8f, 0xc2, 0xa1, 0x0d, 0x69, 0x58, 0x85, 0xa3, 0x56, 0x8a,
0x41, 0x4a, 0xaa, 0x8a, 0xcf, 0xe6, 0xa1, 0x95, 0xbb, 0x7d, 0x34, 0xe8, 0x92, 0x3a, 0x84, 0x87,
0x80, 0xe3, 0x45, 0x51, 0x30, 0x2e, 0x09, 0xa3, 0xc9, 0x39, 0x5b, 0x4e, 0xa8, 0xb8, 0x0c, 0xf6,
0xfa, 0x68, 0xb0, 0x43, 0xb6, 0x9c, 0xe0, 0x23, 0xf0, 0x64, 0x3a, 0x67, 0x42, 0xd2, 0x79, 0x1e,
0xb8, 0x7d, 0x34, 0x68, 0x93, 0x15, 0x80, 0x43, 0xe8, 0xa4, 0x09, 0xe3, 0x32, 0x95, 0xcb, 0xa0,
0xa3, 0xf3, 0xa8, 0xf6, 0xe1, 0xaf, 0x6d, 0x38, 0x50, 0xa1, 0x66, 0x5c, 0x32, 0x2e, 0xbf, 0xa4,
0xb3, 0x05, 0xc3, 0x6f, 0x83, 0xbb, 0x10, 0xac, 0x38, 0x4d, 0x92, 0x00, 0x35, 0x66, 0xf5, 0x85,
0x61, 0x4c, 0x1c, 0x52, 0x92, 0xf1, 0x87, 0x00, 0x6a, 0x49, 0xd8, 0x3c, 0xbb, 0x62, 0x41, 0x4b,
0x4b, 0x5f, 0x6a, 0x90, 0x1a, 0xd2, 0xc4, 0x21, 0x35, 0x09, 0xfe, 0x16, 0x0e, 0xd5, 0xee, 0x31,
0x2b, 0xe6, 0xa9, 0x10, 0x69, 0xc6, 0x8d, 0x40, 0x17, 0xdf, 0x1f, 0xbd, 0xde, 0x70, 0xd5, 0x26,
0x7d, 0xe2, 0x90, 0xad, 0xd7, 0x94, 0xf1, 0x4d, 0xf9, 0x55, 0x2a, 0x99, 0x6d, 0x58, 0x53, 0x7c,
0x86, 0x54, 0xc6, 0x67, 0x76, 0xf8, 0x3d, 0xe8, 0xa8, 0xdd, 0x67, 0x59, 0xca, 0x75, 0xd7, 0xfc,
0xd1, 0x83, 0x06, 0xb9, 0xa2, 0x4c, 0x1c, 0x52, 0xd1, 0xf1, 0x18, 0x7c, 0xb5, 0x3e, 0xcb, 0xf8,
0x77, 0x69, 0x31, 0xd7, 0xad, 0xf4, 0x47, 0x51, 0x83, 0xda, 0xb2, 0x26, 0x0e, 0xa9, 0x8b, 0xc6,
0x2e, 0xec, 0x5e, 0xa9, 0x06, 0x85, 0x3f, 0x23, 0x70, 0xad, 0xab, 0xf0, 0x47, 0xe0, 0xd3, 0x78,
0xf6, 0xc4, 0xfa, 0xd2, 0x36, 0x2c, 0xda, 0x6e, 0xc3, 0x92, 0x45, 0xea, 0x12, 0x3c, 0xd6, 0xc3,
0x60, 0x1d, 0xa0, 0x87, 0xc1, 0x1f, 0x1d, 0x6f, 0xbf, 0xa0, 0x6e, 0x13, 0x52, 0x53, 0x85, 0x9f,
0x80, 0x5f, 0xbb, 0x1f, 0xbf, 0x03, 0x1d, 0xf5, 0x0b, 0x92, 0x4a, 0x66, 0x23, 0x7a, 0xd0, 0x10,
0x91, 0xa2, 0x90, 0x8a, 0x1c, 0xfe, 0xd4, 0x82, 0x4e, 0x09, 0xe3, 0x57, 0xe0, 0x85, 0x62, 0x65,
0x72, 0x66, 0x26, 0x79, 0x87, 0xac, 0x83, 0xf8, 0x03, 0xd3, 0x55, 0x2d, 0x11, 0x36, 0xfc, 0xa3,
0x86, 0xc2, 0x9a, 0x9f, 0xab, 0xf1, 0xf1, 0x18, 0xdc, 0x54, 0x37, 0x57, 0x04, 0x6d, 0x2d, 0x1d,
0xdc, 0x11, 0xe8, 0xd0, 0xf8, 0x40, 0x7c, 0xcc, 0x65, 0xb1, 0x24, 0xa5, 0x30, 0xfc, 0x1a, 0xba,
0xf5, 0x03, 0xdc, 0x83, 0xf6, 0xf7, 0x6c, 0xa9, 0x13, 0xf7, 0x88, 0x5a, 0xe2, 0x87, 0xb6, 0x73,
0xff, 0x30, 0x14, 0xe6, 0x16, 0x62, 0xb8, 0xef, 0xb7, 0xde, 0x45, 0xe1, 0x0d, 0x02, 0xaf, 0x0a,
0x7c, 0x6d, 0x90, 0xd1, 0xfa, 0x20, 0xab, 0x62, 0x31, 0x1e, 0x17, 0xcb, 0x5c, 0xa6, 0x19, 0x3f,
0x67, 0x4b, 0xfd, 0x53, 0x5d, 0xb2, 0x0e, 0xe2, 0x37, 0xe1, 0x45, 0x0b, 0xb0, 0xc4, 0x3e, 0x20,
0x26, 0xf1, 0x2e, 0xb9, 0x7d, 0x80, 0x1f, 0x81, 0x9f, 0x57, 0x43, 0x24, 0xf4, 0xc4, 0xec, 0x6f,
0xb5, 0xc6, 0xfa, 0x18, 0x0a, 0x52, 0x97, 0xa9, 0xe7, 0x6e, 0x2a, 0xac, 0x87, 0x59, 0xa2, 0x07,
0xa7, 0x43, 0xea, 0x50, 0xf8, 0x3b, 0x02, 0xd7, 0xbe, 0x27, 0xff, 0xcf, 0x1c, 0xc3, 0x4f, 0xc1,
0xaf, 0x0d, 0xee, 0x9d, 0x49, 0x1c, 0x81, 0x67, 0x1f, 0xcc, 0x69, 0xa2, 0x13, 0xf0, 0xc8, 0x0a,
0x08, 0xff, 0x42, 0x00, 0x2b, 0x2b, 0xe0, 0x01, 0x1c, 0xd0, 0x38, 0x66, 0xb9, 0x7c, 0xbc, 0xb8,
0x98, 0xa5, 0xf1, 0xb9, 0xb5, 0x55, 0x97, 0x6c, 0xc2, 0xf8, 0x0d, 0xe8, 0xd9, 0xe4, 0x56, 0x54,
0x53, 0x9e, 0x5b, 0xf8, 0x7f, 0xe2, 0x82, 0x10, 0x3a, 0x26, 0xa7, 0xa9, 0xb1, 0x80, 0x47, 0xaa,
0x7d, 0xf8, 0x0c, 0x41, 0xa7, 0x7c, 0x35, 0xef, 0xc1, 0x00, 0x55, 0xd1, 0x9e, 0xa4, 0x4f, 0x39,
0x95, 0x8b, 0xc2, 0x7c, 0x41, 0xaa, 0xa2, 0x55, 0x30, 0x3e, 0x86, 0xee, 0xea, 0x79, 0x9f, 0x26,
0x3a, 0x37, 0x8f, 0xac, 0x61, 0xdb, 0x8b, 0xb5, 0xdb, 0x50, 0xac, 0x70, 0x61, 0xda, 0x67, 0x3f,
0x68, 0x77, 0xe5, 0x72, 0x0e, 0x07, 0xf6, 0x21, 0x23, 0x2c, 0x9f, 0xd1, 0xb8, 0x7a, 0x81, 0x5e,
0xde, 0x52, 0x5a, 0xb2, 0xc6, 0x24, 0x9b, 0xca, 0xf0, 0x47, 0xd8, 0x5f, 0xa7, 0xdc, 0x43, 0x19,
0x57, 0x8e, 0xaa, 0xf2, 0xb3, 0x75, 0xbc, 0x85, 0x87, 0x3f, 0xc0, 0xe1, 0xb6, 0x4f, 0xf1, 0x9d,
0x51, 0x6c, 0xf8, 0xaa, 0xf5, 0xaf, 0x7c, 0x75, 0x7c, 0x0a, 0x07, 0x1b, 0xe7, 0xd8, 0x83, 0xdd,
0xd3, 0x64, 0x9e, 0xf2, 0x9e, 0x83, 0x01, 0xf6, 0xbe, 0x2a, 0x52, 0xc9, 0x8a, 0x1e, 0x52, 0x6b,
0x15, 0x2e, 0x2b, 0x7a, 0x2d, 0xec, 0x83, 0x6b, 0x5a, 0x94, 0xf4, 0xda, 0xe3, 0xa3, 0x67, 0xd7,
0x11, 0x7a, 0x7e, 0x1d, 0xa1, 0x3f, 0xaf, 0x23, 0xf4, 0xcb, 0x4d, 0xe4, 0x3c, 0xbf, 0x89, 0x9c,
0x3f, 0x6e, 0x22, 0xe7, 0x9b, 0x56, 0x7e, 0x71, 0xb1, 0xa7, 0xff, 0x6b, 0x3e, 0xfc, 0x3b, 0x00,
0x00, 0xff, 0xff, 0xd3, 0xdf, 0xf9, 0x1b, 0x94, 0x0a, 0x00, 0x00,
}
func (m *ACLChange) Marshal() (dAtA []byte, err error) {
@ -1614,6 +1622,13 @@ func (m *ACLChangeUserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.InviteId) > 0 {
i -= len(m.InviteId)
copy(dAtA[i:], m.InviteId)
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.InviteId)))
i--
dAtA[i] = 0x2a
}
if m.Permissions != 0 {
i = encodeVarintAclchanges(dAtA, i, uint64(m.Permissions))
i--
@ -1674,10 +1689,10 @@ func (m *ACLChangeUserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
}
}
if len(m.UserInviteChangeId) > 0 {
i -= len(m.UserInviteChangeId)
copy(dAtA[i:], m.UserInviteChangeId)
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.UserInviteChangeId)))
if len(m.UserInviteId) > 0 {
i -= len(m.UserInviteId)
copy(dAtA[i:], m.UserInviteId)
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.UserInviteId)))
i--
dAtA[i] = 0x22
}
@ -2128,6 +2143,10 @@ func (m *ACLChangeUserInvite) Size() (n int) {
if m.Permissions != 0 {
n += 1 + sovAclchanges(uint64(m.Permissions))
}
l = len(m.InviteId)
if l > 0 {
n += 1 + l + sovAclchanges(uint64(l))
}
return n
}
@ -2149,7 +2168,7 @@ func (m *ACLChangeUserJoin) Size() (n int) {
if l > 0 {
n += 1 + l + sovAclchanges(uint64(l))
}
l = len(m.UserInviteChangeId)
l = len(m.UserInviteId)
if l > 0 {
n += 1 + l + sovAclchanges(uint64(l))
}
@ -3881,6 +3900,38 @@ func (m *ACLChangeUserInvite) Unmarshal(dAtA []byte) error {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field InviteId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclchanges
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthAclchanges
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthAclchanges
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.InviteId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipAclchanges(dAtA[iNdEx:])
@ -4033,7 +4084,7 @@ func (m *ACLChangeUserJoin) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field UserInviteChangeId", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field UserInviteId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@ -4061,7 +4112,7 @@ func (m *ACLChangeUserJoin) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.UserInviteChangeId = string(dAtA[iNdEx:postIndex])
m.UserInviteId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 5:
if wireType != 2 {

3
aclchanges/pb/protos/aclchanges.proto
View File

@ -69,13 +69,14 @@ message ACLChange {
bytes encryptPublicKey = 2;
repeated bytes encryptedReadKeys = 3; // all read keys that we know for the user
UserPermissions permissions = 4;
string InviteId = 5;
}
message UserJoin {
string identity = 1;
bytes encryptionKey = 2;
bytes acceptSignature = 3; // sign acceptPublicKey
string userInviteChangeId = 4;
string userInviteId = 4;
repeated bytes encryptedReadKeys = 5; // the idea is that user should itself reencrypt the keys with the pub key
}

58
acltree/aclstate.go
View File

@ -41,8 +41,8 @@ func newACLState(
}
}
func newACLStateFromSnapshot(
snapshot *pb.ACLChangeACLSnapshot,
func newACLStateFromSnapshotChange(
snapshotChange *pb.ACLChange,
identity string,
encryptionKey keys.EncryptionPrivKey,
signingPubKeyDecoder keys.SigningPubKeyDecoder) (*ACLState, error) {
@ -54,14 +54,18 @@ func newACLStateFromSnapshot(
userInvites: make(map[string]*pb.ACLChangeUserInvite),
signingPubKeyDecoder: signingPubKeyDecoder,
}
err := st.recreateFromSnapshot(snapshot)
err := st.recreateFromSnapshotChange(snapshotChange)
if err != nil {
return nil, err
}
return st, nil
}
func (st *ACLState) recreateFromSnapshot(snapshot *pb.ACLChangeACLSnapshot) error {
func (st *ACLState) recreateFromSnapshotChange(snapshotChange *pb.ACLChange) error {
snapshot := snapshotChange.GetAclData().GetAclSnapshot()
if snapshot == nil {
return fmt.Errorf("could not create state from snapshot, because it is nil")
}
state := snapshot.AclState
for _, userState := range state.UserStates {
st.userStates[userState.Identity] = userState
@ -71,7 +75,6 @@ func (st *ACLState) recreateFromSnapshot(snapshot *pb.ACLChangeACLSnapshot) erro
if !exists {
return ErrNoSuchUser
}
var lastKeyHash uint64
for _, key := range userState.EncryptedReadKeys {
key, hash, err := st.decryptReadKeyAndHash(key)
if err != nil {
@ -79,9 +82,8 @@ func (st *ACLState) recreateFromSnapshot(snapshot *pb.ACLChangeACLSnapshot) erro
}
st.userReadKeys[hash] = key
lastKeyHash = hash
}
st.currentReadKeyHash = lastKeyHash
st.currentReadKeyHash = snapshotChange.CurrentReadKeyHash
if snapshot.GetAclState().GetInvites() != nil {
st.userInvites = snapshot.GetAclState().GetInvites()
}
@ -101,21 +103,29 @@ func (st *ACLState) makeSnapshot() *pb.ACLChangeACLSnapshot {
}}
}
func (st *ACLState) applyChange(changeId string, change *pb.ACLChange) error {
func (st *ACLState) applyChange(change *pb.ACLChange) (err error) {
defer func() {
if err != nil {
return
}
st.currentReadKeyHash = change.CurrentReadKeyHash
}()
// we can't check this for the user which is joining, because it will not be in our list
if !st.isUserJoin(change) {
// we check signature when we add this to the Tree, so no need to do it here
if _, exists := st.userStates[change.Identity]; !exists {
return ErrNoSuchUser
err = ErrNoSuchUser
return
}
if !st.hasPermission(change.Identity, pb.ACLChange_Admin) {
return fmt.Errorf("user %s must have admin permissions", change.Identity)
err = fmt.Errorf("user %s must have admin permissions", change.Identity)
return
}
}
for _, ch := range change.GetAclData().GetAclContent() {
if err := st.applyChangeContent(changeId, ch); err != nil {
if err = st.applyChangeContent(ch); err != nil {
//log.Infof("error while applying changes: %v; ignore", err)
return err
}
@ -125,7 +135,7 @@ func (st *ACLState) applyChange(changeId string, change *pb.ACLChange) error {
}
// TODO: remove changeId, because it is not needed
func (st *ACLState) applyChangeContent(changeId string, ch *pb.ACLChangeACLContentValue) error {
func (st *ACLState) applyChangeContent(ch *pb.ACLChangeACLContentValue) error {
switch {
case ch.GetUserPermissionChange() != nil:
return st.applyUserPermissionChange(ch.GetUserPermissionChange())
@ -134,7 +144,7 @@ func (st *ACLState) applyChangeContent(changeId string, ch *pb.ACLChangeACLConte
case ch.GetUserRemove() != nil:
return st.applyUserRemove(ch.GetUserRemove())
case ch.GetUserInvite() != nil:
return st.applyUserInvite(changeId, ch.GetUserInvite())
return st.applyUserInvite(ch.GetUserInvite())
case ch.GetUserJoin() != nil:
return st.applyUserJoin(ch.GetUserJoin())
case ch.GetUserConfirm() != nil:
@ -153,15 +163,15 @@ func (st *ACLState) applyUserPermissionChange(ch *pb.ACLChangeUserPermissionChan
return nil
}
func (st *ACLState) applyUserInvite(changeId string, ch *pb.ACLChangeUserInvite) error {
st.userInvites[changeId] = ch
func (st *ACLState) applyUserInvite(ch *pb.ACLChangeUserInvite) error {
st.userInvites[ch.InviteId] = ch
return nil
}
func (st *ACLState) applyUserJoin(ch *pb.ACLChangeUserJoin) error {
invite, exists := st.userInvites[ch.UserInviteChangeId]
invite, exists := st.userInvites[ch.UserInviteId]
if !exists {
return fmt.Errorf("no such invite with id %s", ch.UserInviteChangeId)
return fmt.Errorf("no such invite with id %s", ch.UserInviteId)
}
if _, exists = st.userStates[ch.Identity]; exists {
@ -190,7 +200,6 @@ func (st *ACLState) applyUserJoin(ch *pb.ACLChangeUserJoin) error {
// if ourselves -> we need to decrypt the read keys
if st.identity == ch.Identity {
var lastKeyHash uint64
for _, key := range ch.EncryptedReadKeys {
key, hash, err := st.decryptReadKeyAndHash(key)
if err != nil {
@ -198,9 +207,7 @@ func (st *ACLState) applyUserJoin(ch *pb.ACLChangeUserJoin) error {
}
st.userReadKeys[hash] = key
lastKeyHash = hash
}
st.currentReadKeyHash = lastKeyHash
}
// adding user to the list
@ -227,6 +234,17 @@ func (st *ACLState) applyUserAdd(ch *pb.ACLChangeUserAdd) error {
EncryptedReadKeys: ch.EncryptedReadKeys,
}
if ch.Identity == st.identity {
for _, key := range ch.EncryptedReadKeys {
key, hash, err := st.decryptReadKeyAndHash(key)
if err != nil {
return ErrFailedToDecrypt
}
st.userReadKeys[hash] = key
}
}
return nil
}

7
acltree/aclstatebuilder.go
View File

@ -52,9 +52,8 @@ func (sb *aclStateBuilder) BuildBefore(beforeId string) (*ACLState, bool, error)
return nil, false, fmt.Errorf("root should always be a snapshot")
}
snapshot := root.Content.GetAclData().GetAclSnapshot()
state, err := newACLStateFromSnapshot(
snapshot,
state, err := newACLStateFromSnapshotChange(
root.Content,
sb.identity,
sb.key,
sb.decoder)
@ -99,7 +98,7 @@ func (sb *aclStateBuilder) BuildBefore(beforeId string) (*ACLState, bool, error)
idSeenMap[c.Content.Identity] = append(idSeenMap[c.Content.Identity], c)
if c.Content.GetAclData() != nil {
err = state.applyChange(c.Id, c.Content)
err = state.applyChange(c.Content)
if err != nil {
return false
}

16
acltree/acltree.go
View File

@ -30,7 +30,7 @@ type TreeUpdateListener interface {
type ACLTree interface {
ACLState() *ACLState
AddContent(f func(builder ChangeBuilder)) (*Change, error)
AddContent(f func(builder ChangeBuilder) error) (*Change, error)
AddChanges(changes ...*Change) (AddResult, error)
Heads() []string
Root() *Change
@ -186,23 +186,21 @@ func (a *aclTree) ACLState() *ACLState {
return a.aclState
}
func (a *aclTree) AddContent(build func(builder ChangeBuilder)) (*Change, error) {
func (a *aclTree) AddContent(build func(builder ChangeBuilder) error) (*Change, error) {
// TODO: add snapshot creation logic
a.Lock()
defer a.Unlock()
a.changeBuilder.Init(a.aclState, a.fullTree, a.accountData)
build(a.changeBuilder)
ch, marshalled, err := a.changeBuilder.Build()
if err != nil {
return nil, err
}
err = a.aclState.applyChange(ch.Id, ch.Content)
err := build(a.changeBuilder)
if err != nil {
return nil, err
}
ch, marshalled, err := a.changeBuilder.BuildAndApply()
if err != nil {
return nil, err
}
a.fullTree.AddFast(ch)
err = a.thread.AddRawChange(&thread.RawChange{

69
acltree/changebuilder.go
View File

@ -6,12 +6,14 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys"
"github.com/gogo/protobuf/proto"
"github.com/textileio/go-threads/crypto/symmetric"
"hash/fnv"
)
type MarshalledChange = []byte
type ACLChangeBuilder interface {
UserAdd(identity string, encryptionKey keys.EncryptionPubKey, permissions pb.ACLChangeUserPermissions)
UserAdd(identity string, encryptionKey keys.EncryptionPubKey, permissions pb.ACLChangeUserPermissions) error
AddId(id string) // TODO: this is only for testing
SetMakeSnapshot(bool) // TODO: who should decide this? probably ACLTree so we can delete it
}
@ -30,6 +32,8 @@ type changeBuilder struct {
changeContent proto.Marshaler
id string
makeSnapshot bool
readKey *symmetric.Key
readKeyHash uint64
}
func newChangeBuilder() *changeBuilder {
@ -42,6 +46,17 @@ func (c *changeBuilder) Init(state *ACLState, tree *Tree, acc *account.AccountDa
c.acc = acc
c.aclData = &pb.ACLChangeACLData{}
// setting read key for further encryption etc
if state.currentReadKeyHash == 0 {
c.readKey, _ = symmetric.NewRandom()
hasher := fnv.New64()
hasher.Write(c.readKey.Bytes())
c.readKeyHash = hasher.Sum64()
} else {
c.readKey = c.aclState.userReadKeys[c.aclState.currentReadKeyHash]
c.readKeyHash = c.aclState.currentReadKeyHash
}
}
func (c *changeBuilder) AddId(id string) {
@ -52,12 +67,44 @@ func (c *changeBuilder) SetMakeSnapshot(b bool) {
c.makeSnapshot = b
}
func (c *changeBuilder) UserAdd(identity string, encryptionKey keys.EncryptionPubKey, permissions pb.ACLChangeUserPermissions) {
//TODO implement me
panic("implement me")
func (c *changeBuilder) UserAdd(identity string, encryptionKey keys.EncryptionPubKey, permissions pb.ACLChangeUserPermissions) error {
var allKeys []*symmetric.Key
if c.aclState.currentReadKeyHash != 0 {
for _, key := range c.aclState.userReadKeys {
allKeys = append(allKeys, key)
}
} else {
allKeys = append(allKeys, c.readKey)
}
var encryptedKeys [][]byte
for _, k := range allKeys {
res, err := encryptionKey.Encrypt(k.Bytes())
if err != nil {
return err
}
encryptedKeys = append(encryptedKeys, res)
}
rawKey, err := encryptionKey.Raw()
if err != nil {
return err
}
ch := &pb.ACLChangeACLContentValue{
Value: &pb.ACLChangeACLContentValueValueOfUserAdd{
UserAdd: &pb.ACLChangeUserAdd{
Identity: identity,
EncryptionKey: rawKey,
EncryptedReadKeys: encryptedKeys,
Permissions: permissions,
},
},
}
c.aclData.AclContent = append(c.aclData.AclContent, ch)
return nil
}
func (c *changeBuilder) Build() (*Change, []byte, error) {
func (c *changeBuilder) BuildAndApply() (*Change, []byte, error) {
marshalled, err := c.changeContent.Marshal()
if err != nil {
return nil, nil, err
@ -69,10 +116,6 @@ func (c *changeBuilder) Build() (*Change, []byte, error) {
return nil, nil, err
}
if c.makeSnapshot {
c.aclData.AclSnapshot = c.aclState.makeSnapshot()
}
aclChange := &pb.ACLChange{
TreeHeadIds: c.tree.Heads(),
AclHeadIds: c.tree.ACLHeads(),
@ -83,6 +126,14 @@ func (c *changeBuilder) Build() (*Change, []byte, error) {
Timestamp: 0,
Identity: c.acc.Identity,
}
err = c.aclState.applyChange(aclChange)
if err != nil {
return nil, nil, err
}
if c.makeSnapshot {
c.aclData.AclSnapshot = c.aclState.makeSnapshot()
}
fullMarshalledChange, err := proto.Marshal(aclChange)
if err != nil {

2
acltree/snapshotvalidator.go
View File

@ -41,7 +41,7 @@ func (s *snapshotValidator) ValidateSnapshot(ch *Change) (bool, error) {
return false, fmt.Errorf("didn't find snapshot in ACL Tree")
}
otherSt, err := newACLStateFromSnapshot(ch.Content.GetAclData().GetAclSnapshot(), s.identity, s.key, s.decoder)
otherSt, err := newACLStateFromSnapshotChange(ch.Content, s.identity, s.key, s.decoder)
if err != nil {
return false, err
}

9
acltree/threadutility.go
View File

@ -8,17 +8,20 @@ import (
func BuildThreadWithACL(
acc *account.AccountData,
build func(builder ChangeBuilder),
build func(builder ChangeBuilder) error,
create func(change *thread.RawChange) (thread.Thread, error)) (thread.Thread, error) {
bld := newChangeBuilder()
bld.Init(
newACLState(acc.Identity, acc.EncKey, keys.NewEd25519Decoder()),
&Tree{},
acc)
build(bld)
err := build(bld)
if err != nil {
return nil, err
}
bld.SetMakeSnapshot(true)
change, payload, err := bld.Build()
change, payload, err := bld.BuildAndApply()
if err != nil {
return nil, err
}

11
plaintextdocument/document.go
View File

@ -27,13 +27,14 @@ func (p *plainTextDocument) Text() string {
}
func (p *plainTextDocument) AddText(text string) error {
_, err := p.aclTree.AddContent(func(builder acltree.ChangeBuilder) {
_, err := p.aclTree.AddContent(func(builder acltree.ChangeBuilder) error {
builder.AddChangeContent(
&pb.PlainTextChangeData{
Content: []*pb.PlainTextChangeContent{
createAppendTextChangeContent(text),
},
})
return nil
})
return err
}
@ -114,9 +115,13 @@ func NewPlainTextDocument(
acc *account.AccountData,
create func(change *thread.RawChange) (thread.Thread, error),
text string) (PlainTextDocument, error) {
changeBuilder := func(builder acltree.ChangeBuilder) {
builder.UserAdd(acc.Identity, acc.EncKey.GetPublic(), aclpb.ACLChange_Admin)
changeBuilder := func(builder acltree.ChangeBuilder) error {
err := builder.UserAdd(acc.Identity, acc.EncKey.GetPublic(), aclpb.ACLChange_Admin)
if err != nil {
return err
}
builder.AddChangeContent(createInitialChangeContent(text))
return nil
}
t, err := acltree.BuildThreadWithACL(
acc,

11
testutils/threadbuilder/threadbuilder.go
View File

@ -367,11 +367,11 @@ func (t *ThreadBuilder) parseACLChange(ch *ACLChange) (convCh *pb.ACLChangeACLCo
convCh = &pb.ACLChangeACLContentValue{
Value: &pb.ACLChangeACLContentValueValueOfUserJoin{
UserJoin: &pb.ACLChangeUserJoin{
Identity: t.keychain.GetIdentity(join.Identity),
EncryptionKey: rawKey,
AcceptSignature: signature,
UserInviteChangeId: join.InviteId,
EncryptedReadKeys: t.encryptReadKeys(join.EncryptedReadKeys, encKey),
Identity: t.keychain.GetIdentity(join.Identity),
EncryptionKey: rawKey,
AcceptSignature: signature,
UserInviteId: join.InviteId,
EncryptedReadKeys: t.encryptReadKeys(join.EncryptedReadKeys, encKey),
},
},
}
@ -389,6 +389,7 @@ func (t *ThreadBuilder) parseACLChange(ch *ACLChange) (convCh *pb.ACLChangeACLCo
EncryptPublicKey: rawEncKey,
EncryptedReadKeys: t.encryptReadKeys(invite.EncryptedReadKeys, encKey),
Permissions: t.convertPermission(invite.Permissions),
InviteId: invite.InviteId,
},
},
}

1
testutils/threadbuilder/ymlentities.go
View File

@ -45,6 +45,7 @@ type ACLChange struct {
EncryptionKey string `yaml:"encryptionKey"`
EncryptedReadKeys []string `yaml:"encryptedReadKeys"`
Permissions string `yaml:"permissions"`
InviteId string `yaml:"inviteId"`
} `yaml:"userInvite"`
UserConfirm *struct {

1
testutils/yamltests/userjoinexample.yml
View File

@ -29,6 +29,7 @@ changes:
encryptionKey: key.Enc.Onetime1
encryptedReadKeys: [key.Read.1]
permissions: writer
inviteId: A.1.2
- userAdd:
identity: C
permission: reader

1
testutils/yamltests/userjoinexampleupdate.yml
View File

@ -29,6 +29,7 @@ changes:
encryptionKey: key.Enc.Onetime1
encryptedReadKeys: [key.Read.1]
permissions: writer
inviteId: A.1.2
- userAdd:
identity: C
permission: reader

1
testutils/yamltests/userremoveexample.yml
View File

@ -29,6 +29,7 @@ changes:
encryptionKey: key.Enc.Onetime1
encryptedReadKeys: [key.Read.1]
permissions: writer
inviteId: A.1.2
readKey: key.Read.1
- id: A.1.3
identity: A