diff --git a/VERSION b/VERSION index cb6b534ab..7e750b4eb 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.59.0 +0.60.0 diff --git a/protocol/chat.go b/protocol/chat.go index bb85e2a12..c470f14be 100644 --- a/protocol/chat.go +++ b/protocol/chat.go @@ -67,6 +67,9 @@ type Chat struct { // Muted is used to check whether we want to receive // push notifications for this chat Muted bool `json:"muted,omitempty"` + + // Public key of administrator who created invitation link + InvitationAdmin string `json:"invitationAdmin,omitempty"` } func (c *Chat) PublicKey() (*ecdsa.PublicKey, error) { diff --git a/protocol/group_chat_invitation.go b/protocol/group_chat_invitation.go new file mode 100644 index 000000000..5380c9f3b --- /dev/null +++ b/protocol/group_chat_invitation.go @@ -0,0 +1,60 @@ +package protocol + +import ( + "crypto/ecdsa" + "encoding/json" + "fmt" + + "github.com/golang/protobuf/proto" + + "github.com/status-im/status-go/eth-node/crypto" + "github.com/status-im/status-go/eth-node/types" + "github.com/status-im/status-go/protocol/protobuf" +) + +// Invitation represents a group chat invitation request from a user in the application layer, used for persistence, querying and +// signaling +type GroupChatInvitation struct { + protobuf.GroupChatInvitation + + // From is a public key of the author of the invitation request. + From string `json:"from,omitempty"` + + // SigPubKey is the ecdsa encoded public key of the invitation author + SigPubKey *ecdsa.PublicKey `json:"-"` +} + +// ID is the Keccak256() contatenation of From-ChatId +func (g GroupChatInvitation) ID() string { + return types.EncodeHex(crypto.Keccak256([]byte(fmt.Sprintf("%s%s", g.From, g.ChatId)))) +} + +// GetSigPubKey returns an ecdsa encoded public key +// this function is required to implement the ChatEntity interface +func (g GroupChatInvitation) GetSigPubKey() *ecdsa.PublicKey { + return g.SigPubKey +} + +// GetProtoBuf returns the struct's embedded protobuf struct +// this function is required to implement the ChatEntity interface +func (g GroupChatInvitation) GetProtobuf() proto.Message { + return &g.GroupChatInvitation +} + +func (g GroupChatInvitation) MarshalJSON() ([]byte, error) { + item := struct { + ID string `json:"id"` + ChatID string `json:"chatId,omitempty"` + From string `json:"from"` + IntroductionMessage string `json:"introductionMessage,omitempty"` + State protobuf.GroupChatInvitation_State `json:"state,omitempty"` + }{ + ID: g.ID(), + ChatID: g.ChatId, + From: g.From, + IntroductionMessage: g.IntroductionMessage, + State: g.State, + } + + return json.Marshal(item) +} diff --git a/protocol/message_handler.go b/protocol/message_handler.go index 701c925dd..682798788 100644 --- a/protocol/message_handler.go +++ b/protocol/message_handler.go @@ -9,6 +9,7 @@ import ( "go.uber.org/zap" "github.com/status-im/status-go/eth-node/crypto" + "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/encryption/multidevice" "github.com/status-im/status-go/protocol/protobuf" @@ -54,10 +55,38 @@ func (m *MessageHandler) HandleMembershipUpdate(messageState *ReceivedMessageSta return err } - if chat == nil { + //if chat.InvitationAdmin exists means we are waiting for invitation request approvement, and in that case + //we need to create a new chat instance like we don't have a chat and just use a regular invitation flow + if chat == nil || len(chat.InvitationAdmin) > 0 { if len(message.Events) == 0 { return errors.New("can't create new group chat without events") } + + //approve invitations + if chat != nil && len(chat.InvitationAdmin) > 0 { + + groupChatInvitation := &GroupChatInvitation{ + GroupChatInvitation: protobuf.GroupChatInvitation{ + ChatId: message.ChatID, + }, + From: types.EncodeHex(crypto.FromECDSAPub(&m.identity.PublicKey)), + } + + groupChatInvitation, err = m.persistence.InvitationByID(groupChatInvitation.ID()) + if err != nil && err != errRecordNotFound { + return err + } + if groupChatInvitation != nil { + groupChatInvitation.State = protobuf.GroupChatInvitation_APPROVED + + err := m.persistence.SaveInvitation(groupChatInvitation) + if err != nil { + return err + } + messageState.GroupChatInvitations[groupChatInvitation.ID()] = groupChatInvitation + } + } + group, err = v1protocol.NewGroupWithEvents(message.ChatID, message.Events) if err != nil { return err @@ -69,7 +98,6 @@ func (m *MessageHandler) HandleMembershipUpdate(messageState *ReceivedMessageSta } newChat := CreateGroupChat(messageState.Timesource) chat = &newChat - } else { existingGroup, err := newProtocolGroupFromChat(chat) if err != nil { @@ -724,3 +752,45 @@ func (m *MessageHandler) HandleEmojiReaction(state *ReceivedMessageState, pbEmoj return nil } + +func (m *MessageHandler) HandleGroupChatInvitation(state *ReceivedMessageState, pbGHInvitations protobuf.GroupChatInvitation) error { + logger := m.logger.With(zap.String("site", "HandleGroupChatInvitation")) + if err := ValidateReceivedGroupChatInvitation(&pbGHInvitations); err != nil { + logger.Error("invalid group chat invitation", zap.Error(err)) + return err + } + + groupChatInvitation := &GroupChatInvitation{ + GroupChatInvitation: pbGHInvitations, + SigPubKey: state.CurrentMessageState.PublicKey, + } + + //From is the PK of author of invitation request + if groupChatInvitation.State == protobuf.GroupChatInvitation_REJECTED { + //rejected so From is the current user who received this rejection + groupChatInvitation.From = types.EncodeHex(crypto.FromECDSAPub(&m.identity.PublicKey)) + } else { + //invitation request, so From is the author of message + groupChatInvitation.From = state.CurrentMessageState.Contact.ID + } + + existingInvitation, err := m.persistence.InvitationByID(groupChatInvitation.ID()) + if err != errRecordNotFound && err != nil { + return err + } + + if existingInvitation != nil && existingInvitation.Clock >= pbGHInvitations.Clock { + // this is not a valid invitation, ignoring + return nil + } + + // save invitation + err = m.persistence.SaveInvitation(groupChatInvitation) + if err != nil { + return err + } + + state.GroupChatInvitations[groupChatInvitation.ID()] = groupChatInvitation + + return nil +} diff --git a/protocol/message_persistence.go b/protocol/message_persistence.go index 4eaf741f9..76c6d8916 100644 --- a/protocol/message_persistence.go +++ b/protocol/message_persistence.go @@ -835,3 +835,96 @@ func (db sqlitePersistence) EmojiReactionByID(id string) (*EmojiReaction, error) return nil, err } } + +func (db sqlitePersistence) SaveInvitation(invitation *GroupChatInvitation) (err error) { + query := "INSERT INTO group_chat_invitations(id,source,chat_id,message,state,clock) VALUES (?,?,?,?,?,?)" + stmt, err := db.db.Prepare(query) + if err != nil { + return + } + _, err = stmt.Exec( + invitation.ID(), + invitation.From, + invitation.ChatId, + invitation.IntroductionMessage, + invitation.State, + invitation.Clock, + ) + + return +} + +func (db sqlitePersistence) GetGroupChatInvitations() (rst []*GroupChatInvitation, err error) { + + tx, err := db.db.Begin() + if err != nil { + return + } + defer func() { + if err == nil { + err = tx.Commit() + return + } + _ = tx.Rollback() + }() + + bRows, err := tx.Query(`SELECT + source, + chat_id, + message, + state, + clock + FROM + group_chat_invitations`) + if err != nil { + return + } + defer bRows.Close() + for bRows.Next() { + invitation := GroupChatInvitation{} + err = bRows.Scan( + &invitation.From, + &invitation.ChatId, + &invitation.IntroductionMessage, + &invitation.State, + &invitation.Clock) + if err != nil { + return nil, err + } + rst = append(rst, &invitation) + } + + return rst, nil +} + +func (db sqlitePersistence) InvitationByID(id string) (*GroupChatInvitation, error) { + row := db.db.QueryRow( + `SELECT + source, + chat_id, + message, + state, + clock + FROM + group_chat_invitations + WHERE + group_chat_invitations.id = ? + `, id) + + chatInvitations := new(GroupChatInvitation) + err := row.Scan(&chatInvitations.From, + &chatInvitations.ChatId, + &chatInvitations.IntroductionMessage, + &chatInvitations.State, + &chatInvitations.Clock, + ) + + switch err { + case sql.ErrNoRows: + return nil, errRecordNotFound + case nil: + return chatInvitations, nil + default: + return nil, err + } +} diff --git a/protocol/message_validator.go b/protocol/message_validator.go index 9ec0bb253..e25e45b71 100644 --- a/protocol/message_validator.go +++ b/protocol/message_validator.go @@ -256,3 +256,12 @@ func ValidateReceivedEmojiReaction(emoji *protobuf.EmojiReaction, whisperTimesta return nil } + +func ValidateReceivedGroupChatInvitation(invitation *protobuf.GroupChatInvitation) error { + + if len(invitation.ChatId) == 0 { + return errors.New("chat-id can't be empty") + } + + return nil +} diff --git a/protocol/messenger.go b/protocol/messenger.go index ffa251a98..3732846bf 100644 --- a/protocol/messenger.go +++ b/protocol/messenger.go @@ -4,6 +4,7 @@ import ( "context" "crypto/ecdsa" "database/sql" + "encoding/hex" "io/ioutil" "math/rand" "os" @@ -94,10 +95,11 @@ type MessengerResponse struct { Contacts []*Contact `json:"contacts,omitempty"` Installations []*multidevice.Installation `json:"installations,omitempty"` EmojiReactions []*EmojiReaction `json:"emojiReactions,omitempty"` + Invitations []*GroupChatInvitation `json:"invitations,omitempty"` } func (m *MessengerResponse) IsEmpty() bool { - return len(m.Chats) == 0 && len(m.Messages) == 0 && len(m.Contacts) == 0 && len(m.Installations) == 0 + return len(m.Chats) == 0 && len(m.Messages) == 0 && len(m.Contacts) == 0 && len(m.Installations) == 0 && len(m.Invitations) == 0 } type dbConfig struct { @@ -768,6 +770,23 @@ func (m *Messenger) CreateGroupChatWithMembers(ctx context.Context, name string, return &response, m.saveChat(&chat) } +func (m *Messenger) CreateGroupChatFromInvitation(name string, chatID string, adminPK string) (*MessengerResponse, error) { + m.mutex.Lock() + defer m.mutex.Unlock() + + var response MessengerResponse + logger := m.logger.With(zap.String("site", "CreateGroupChatFromInvitation")) + logger.Info("Creating group chat from invitation", zap.String("name", name)) + chat := CreateGroupChat(m.getTimesource()) + chat.ID = chatID + chat.Name = name + chat.InvitationAdmin = adminPK + + response.Chats = []*Chat{&chat} + + return &response, m.saveChat(&chat) +} + func (m *Messenger) RemoveMemberFromGroupChat(ctx context.Context, chatID string, member string) (*MessengerResponse, error) { m.mutex.Lock() defer m.mutex.Unlock() @@ -859,6 +878,32 @@ func (m *Messenger) AddMembersToGroupChat(ctx context.Context, chatID string, me return nil, err } + //approve invitations + for _, member := range members { + logger.Info("ApproveInvitationByChatIdAndFrom", zap.String("chatID", chatID), zap.Any("member", member)) + + groupChatInvitation := &GroupChatInvitation{ + GroupChatInvitation: protobuf.GroupChatInvitation{ + ChatId: chat.ID, + }, + From: member, + } + + groupChatInvitation, err = m.persistence.InvitationByID(groupChatInvitation.ID()) + if err != nil && err != errRecordNotFound { + return nil, err + } + if groupChatInvitation != nil { + groupChatInvitation.State = protobuf.GroupChatInvitation_APPROVED + + err := m.persistence.SaveInvitation(groupChatInvitation) + if err != nil { + return nil, err + } + response.Invitations = append(response.Invitations, groupChatInvitation) + } + } + err = group.ProcessEvent(event) if err != nil { return nil, err @@ -963,6 +1008,151 @@ func (m *Messenger) ChangeGroupChatName(ctx context.Context, chatID string, name return &response, m.saveChat(chat) } +func (m *Messenger) SendGroupChatInvitationRequest(ctx context.Context, chatID string, adminPK string, + message string) (*MessengerResponse, error) { + logger := m.logger.With(zap.String("site", "SendGroupChatInvitationRequest")) + logger.Info("Sending group chat invitation request", zap.String("chatID", chatID), + zap.String("adminPK", adminPK), zap.String("message", message)) + + m.mutex.Lock() + defer m.mutex.Unlock() + + var response MessengerResponse + + // Get chat and clock + chat, ok := m.allChats[chatID] + if !ok { + return nil, ErrChatNotFound + } + clock, _ := chat.NextClockAndTimestamp(m.getTimesource()) + + invitationR := &GroupChatInvitation{ + GroupChatInvitation: protobuf.GroupChatInvitation{ + Clock: clock, + ChatId: chatID, + IntroductionMessage: message, + State: protobuf.GroupChatInvitation_REQUEST, + }, + From: types.EncodeHex(crypto.FromECDSAPub(&m.identity.PublicKey)), + } + + encodedMessage, err := proto.Marshal(invitationR.GetProtobuf()) + if err != nil { + return nil, err + } + + spec := common.RawMessage{ + LocalChatID: adminPK, + Payload: encodedMessage, + MessageType: protobuf.ApplicationMetadataMessage_GROUP_CHAT_INVITATION, + ResendAutomatically: true, + } + + pkey, err := hex.DecodeString(adminPK[2:]) + if err != nil { + return nil, err + } + // Safety check, make sure is well formed + adminpk, err := crypto.UnmarshalPubkey(pkey) + if err != nil { + return nil, err + } + + id, err := m.processor.SendPrivate(ctx, adminpk, spec) + if err != nil { + return nil, err + } + + spec.ID = types.EncodeHex(id) + spec.SendCount++ + err = m.persistence.SaveRawMessage(&spec) + if err != nil { + return nil, err + } + + response.Invitations = []*GroupChatInvitation{invitationR} + + err = m.persistence.SaveInvitation(invitationR) + if err != nil { + return nil, err + } + + return &response, nil +} + +func (m *Messenger) GetGroupChatInvitations() ([]*GroupChatInvitation, error) { + return m.persistence.GetGroupChatInvitations() +} + +func (m *Messenger) SendGroupChatInvitationRejection(ctx context.Context, invitationRequestID string) (*MessengerResponse, error) { + logger := m.logger.With(zap.String("site", "SendGroupChatInvitationRejection")) + logger.Info("Sending group chat invitation reject", zap.String("invitationRequestID", invitationRequestID)) + + m.mutex.Lock() + defer m.mutex.Unlock() + + invitationR, err := m.persistence.InvitationByID(invitationRequestID) + if err != nil { + return nil, err + } + + invitationR.State = protobuf.GroupChatInvitation_REJECTED + + // Get chat and clock + chat, ok := m.allChats[invitationR.ChatId] + if !ok { + return nil, ErrChatNotFound + } + clock, _ := chat.NextClockAndTimestamp(m.getTimesource()) + + invitationR.Clock = clock + + encodedMessage, err := proto.Marshal(invitationR.GetProtobuf()) + if err != nil { + return nil, err + } + + spec := common.RawMessage{ + LocalChatID: invitationR.From, + Payload: encodedMessage, + MessageType: protobuf.ApplicationMetadataMessage_GROUP_CHAT_INVITATION, + ResendAutomatically: true, + } + + pkey, err := hex.DecodeString(invitationR.From[2:]) + if err != nil { + return nil, err + } + // Safety check, make sure is well formed + userpk, err := crypto.UnmarshalPubkey(pkey) + if err != nil { + return nil, err + } + + id, err := m.processor.SendPrivate(ctx, userpk, spec) + if err != nil { + return nil, err + } + + spec.ID = types.EncodeHex(id) + spec.SendCount++ + err = m.persistence.SaveRawMessage(&spec) + if err != nil { + return nil, err + } + + var response MessengerResponse + + response.Invitations = []*GroupChatInvitation{invitationR} + + err = m.persistence.SaveInvitation(invitationR) + if err != nil { + return nil, err + } + + return &response, nil +} + func (m *Messenger) AddAdminsToGroupChat(ctx context.Context, chatID string, members []string) (*MessengerResponse, error) { m.mutex.Lock() defer m.mutex.Unlock() @@ -1920,6 +2110,8 @@ type ReceivedMessageState struct { // EmojiReactions is a list of emoji reactions for the current batch // indexed by from-message-id-emoji-type EmojiReactions map[string]*EmojiReaction + // GroupChatInvitations is a list of invitation requests or rejections + GroupChatInvitations map[string]*GroupChatInvitation // Response to the client Response *MessengerResponse // Timesource is a time source for clock values/timestamps. @@ -1938,6 +2130,7 @@ func (m *Messenger) handleRetrievedMessages(chatWithMessages map[transport.Filte ModifiedInstallations: m.modifiedInstallations, ExistingMessagesMap: make(map[string]bool), EmojiReactions: make(map[string]*EmojiReaction), + GroupChatInvitations: make(map[string]*GroupChatInvitation), Response: &MessengerResponse{}, Timesource: m.getTimesource(), } @@ -2202,6 +2395,13 @@ func (m *Messenger) handleRetrievedMessages(chatWithMessages map[transport.Filte logger.Warn("failed to handle EmojiReaction", zap.Error(err)) continue } + case protobuf.GroupChatInvitation: + logger.Debug("Handling GroupChatInvitation") + err = m.handler.HandleGroupChatInvitation(messageState, msg.ParsedMessage.Interface().(protobuf.GroupChatInvitation)) + if err != nil { + logger.Warn("failed to handle GroupChatInvitation", zap.Error(err)) + continue + } default: // Check if is an encrypted PushNotificationRegistration @@ -2284,6 +2484,10 @@ func (m *Messenger) handleRetrievedMessages(chatWithMessages map[transport.Filte messageState.Response.EmojiReactions = append(messageState.Response.EmojiReactions, emojiReaction) } + for _, groupChatInvitation := range messageState.GroupChatInvitations { + messageState.Response.Invitations = append(messageState.Response.Invitations, groupChatInvitation) + } + if len(contactsToSave) > 0 { err = m.persistence.SaveContacts(contactsToSave) if err != nil { diff --git a/protocol/migrations/migrations.go b/protocol/migrations/migrations.go index 2490fbf66..42d0ccd5f 100644 --- a/protocol/migrations/migrations.go +++ b/protocol/migrations/migrations.go @@ -18,6 +18,9 @@ // 1595862781_add_audio_data.up.sql (246B) // 1595865249_create_emoji_reactions_table.down.sql (27B) // 1595865249_create_emoji_reactions_table.up.sql (300B) +// 1596805115_create_group_chat_invitations_table.down.sql (34B) +// 1596805115_create_group_chat_invitations_table.up.sql (231B) +// 1597322655_add_invitation_admin_chat_field.up.sql (54B) // 1597757544_add_nickname.up.sql (52B) // doc.go (850B) @@ -448,6 +451,66 @@ func _1595865249_create_emoji_reactions_tableUpSql() (*asset, error) { return a, nil } +var __1596805115_create_group_chat_invitations_tableDownSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\x09\xf2\x0f\x50\x08\x71\x74\xf2\x71\x55\x48\x2f\xca\x2f\x2d\x88\x4f\xce\x48\x2c\x89\xcf\xcc\x2b\xcb\x2c\x49\x2c\xc9\xcc\xcf\x2b\xb6\x06\x04\x00\x00\xff\xff\x82\x66\x9d\x1a\x22\x00\x00\x00") + +func _1596805115_create_group_chat_invitations_tableDownSqlBytes() ([]byte, error) { + return bindataRead( + __1596805115_create_group_chat_invitations_tableDownSql, + "1596805115_create_group_chat_invitations_table.down.sql", + ) +} + +func _1596805115_create_group_chat_invitations_tableDownSql() (*asset, error) { + bytes, err := _1596805115_create_group_chat_invitations_tableDownSqlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "1596805115_create_group_chat_invitations_table.down.sql", size: 34, mode: os.FileMode(0644), modTime: time.Unix(1599471320, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6b, 0x5a, 0x17, 0xd8, 0x8d, 0xb3, 0xfe, 0xcb, 0xb6, 0xc0, 0xcb, 0x14, 0x68, 0x8c, 0x5b, 0x18, 0xf8, 0x7d, 0xc9, 0x2c, 0xa6, 0x41, 0xc9, 0x71, 0xeb, 0x3f, 0xc6, 0xa, 0x45, 0xee, 0x5d, 0x2a}} + return a, nil +} + +var __1596805115_create_group_chat_invitations_tableUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\x8d\xc1\x4a\xc4\x30\x14\x45\xf7\x85\xfe\xc3\x5d\x2a\xb8\x70\xef\x2a\xc6\x57\x0c\xc6\xb4\xa4\xaf\xd2\xae\x4a\xa8\xa1\x06\xb5\x91\x26\xf5\xfb\xc5\x96\x61\x18\x98\xed\x3d\x87\x73\xa5\x25\xc1\x04\x16\x8f\x9a\xa0\x2a\x98\x9a\x41\xbd\x6a\xb9\xc5\xbc\xc6\xed\x67\x9c\x3e\x5c\x1e\xc3\xf2\x1b\xb2\xcb\x21\x2e\x09\x37\x65\x01\x84\x77\xbc\x09\x2b\x9f\x85\x45\x63\xd5\xab\xb0\x03\x5e\x68\x40\x6d\x20\x6b\x53\x69\x25\x19\x96\x1a\x2d\x24\xdd\xfd\xeb\x29\x6e\xeb\xe4\xc1\xd4\xf3\xfe\x60\x3a\xad\x77\x70\xd4\xcf\xb1\x0b\xf8\xed\x53\x72\xb3\xbf\x0e\x53\x76\xd9\x43\x19\xc6\x13\x55\xa2\xd3\x8c\xfb\xa3\xf8\x15\xa7\xcf\x7d\x3f\xe9\x65\x71\xfb\xf0\x17\x00\x00\xff\xff\x34\x03\xb2\x2f\xe7\x00\x00\x00") + +func _1596805115_create_group_chat_invitations_tableUpSqlBytes() ([]byte, error) { + return bindataRead( + __1596805115_create_group_chat_invitations_tableUpSql, + "1596805115_create_group_chat_invitations_table.up.sql", + ) +} + +func _1596805115_create_group_chat_invitations_tableUpSql() (*asset, error) { + bytes, err := _1596805115_create_group_chat_invitations_tableUpSqlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "1596805115_create_group_chat_invitations_table.up.sql", size: 231, mode: os.FileMode(0644), modTime: time.Unix(1599471320, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6d, 0xb1, 0x14, 0x6d, 0x54, 0x28, 0x67, 0xc3, 0x23, 0x6a, 0xfc, 0x80, 0xdf, 0x9e, 0x4c, 0x35, 0x36, 0xf, 0xf8, 0xf3, 0x5f, 0xae, 0xad, 0xb, 0xc1, 0x51, 0x8e, 0x17, 0x7, 0xe5, 0x7f, 0x91}} + return a, nil +} + +var __1597322655_add_invitation_admin_chat_fieldUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\xf4\x09\x71\x0d\x52\x08\x71\x74\xf2\x71\x55\x48\xce\x48\x2c\x29\x56\x70\x74\x71\x51\x70\xf6\xf7\x09\xf5\xf5\x53\xc8\xcc\x2b\xcb\x2c\x49\x2c\xc9\xcc\xcf\x8b\x4f\x4c\xc9\xcd\xcc\x53\x08\x73\x0c\x72\xf6\x70\x0c\xb2\x06\x04\x00\x00\xff\xff\x51\xe6\x0d\x74\x36\x00\x00\x00") + +func _1597322655_add_invitation_admin_chat_fieldUpSqlBytes() ([]byte, error) { + return bindataRead( + __1597322655_add_invitation_admin_chat_fieldUpSql, + "1597322655_add_invitation_admin_chat_field.up.sql", + ) +} + +func _1597322655_add_invitation_admin_chat_fieldUpSql() (*asset, error) { + bytes, err := _1597322655_add_invitation_admin_chat_fieldUpSqlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "1597322655_add_invitation_admin_chat_field.up.sql", size: 54, mode: os.FileMode(0644), modTime: time.Unix(1599471320, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa9, 0x7a, 0xa0, 0xf2, 0xdb, 0x13, 0x91, 0x91, 0xa8, 0x34, 0x1a, 0xa1, 0x49, 0x68, 0xd5, 0xae, 0x2c, 0xd8, 0xd5, 0xea, 0x8f, 0x8c, 0xc7, 0x2, 0x4e, 0x58, 0x2c, 0x3a, 0x14, 0xd4, 0x4f, 0x2c}} + return a, nil +} + var __1597757544_add_nicknameUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\xf4\x09\x71\x0d\x52\x08\x71\x74\xf2\x71\x55\x48\xce\xcf\x2b\x49\x4c\x2e\x29\x56\x70\x74\x71\x51\x70\xf6\xf7\x09\xf5\xf5\x53\xc8\xc9\x4f\x4e\xcc\x89\xcf\xcb\x4c\xce\xce\x4b\xcc\x4d\x55\x08\x71\x8d\x08\xb1\x06\x04\x00\x00\xff\xff\x54\xf7\xdc\x23\x34\x00\x00\x00") func _1597757544_add_nicknameUpSqlBytes() ([]byte, error) { @@ -463,7 +526,7 @@ func _1597757544_add_nicknameUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1597757544_add_nickname.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1598445725, 0)} + info := bindataFileInfo{name: "1597757544_add_nickname.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1599471320, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf4, 0xa2, 0x64, 0x50, 0xc5, 0x4, 0xb9, 0x8b, 0xd1, 0x18, 0x9b, 0xc3, 0x91, 0x36, 0x2a, 0x1f, 0xc3, 0x6c, 0x2d, 0x92, 0xf8, 0x5e, 0xff, 0xb1, 0x59, 0x61, 0x2, 0x1c, 0xe1, 0x85, 0x90, 0xa4}} return a, nil } @@ -615,6 +678,12 @@ var _bindata = map[string]func() (*asset, error){ "1595865249_create_emoji_reactions_table.up.sql": _1595865249_create_emoji_reactions_tableUpSql, + "1596805115_create_group_chat_invitations_table.down.sql": _1596805115_create_group_chat_invitations_tableDownSql, + + "1596805115_create_group_chat_invitations_table.up.sql": _1596805115_create_group_chat_invitations_tableUpSql, + + "1597322655_add_invitation_admin_chat_field.up.sql": _1597322655_add_invitation_admin_chat_fieldUpSql, + "1597757544_add_nickname.up.sql": _1597757544_add_nicknameUpSql, "doc.go": docGo, @@ -679,6 +748,9 @@ var _bintree = &bintree{nil, map[string]*bintree{ "1595862781_add_audio_data.up.sql": &bintree{_1595862781_add_audio_dataUpSql, map[string]*bintree{}}, "1595865249_create_emoji_reactions_table.down.sql": &bintree{_1595865249_create_emoji_reactions_tableDownSql, map[string]*bintree{}}, "1595865249_create_emoji_reactions_table.up.sql": &bintree{_1595865249_create_emoji_reactions_tableUpSql, map[string]*bintree{}}, + "1596805115_create_group_chat_invitations_table.down.sql": &bintree{_1596805115_create_group_chat_invitations_tableDownSql, map[string]*bintree{}}, + "1596805115_create_group_chat_invitations_table.up.sql": &bintree{_1596805115_create_group_chat_invitations_tableUpSql, map[string]*bintree{}}, + "1597322655_add_invitation_admin_chat_field.up.sql": &bintree{_1597322655_add_invitation_admin_chat_fieldUpSql, map[string]*bintree{}}, "1597757544_add_nickname.up.sql": &bintree{_1597757544_add_nicknameUpSql, map[string]*bintree{}}, "doc.go": &bintree{docGo, map[string]*bintree{}}, }} diff --git a/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.down.sql b/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.down.sql new file mode 100644 index 000000000..2fe7a2b6d --- /dev/null +++ b/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.down.sql @@ -0,0 +1 @@ +DROP TABLE group_chat_invitations; \ No newline at end of file diff --git a/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.up.sql b/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.up.sql new file mode 100644 index 000000000..bc67353c6 --- /dev/null +++ b/protocol/migrations/sqlite/1596805115_create_group_chat_invitations_table.up.sql @@ -0,0 +1,8 @@ +CREATE TABLE IF NOT EXISTS group_chat_invitations ( + id VARCHAR PRIMARY KEY ON CONFLICT REPLACE, + source TEXT NOT NULL, + chat_id VARCHAR NOT NULL, + message VARCHAR NOT NULL, + state INT DEFAULT 0, + clock INT NOT NULL +); \ No newline at end of file diff --git a/protocol/migrations/sqlite/1597322655_add_invitation_admin_chat_field.up.sql b/protocol/migrations/sqlite/1597322655_add_invitation_admin_chat_field.up.sql new file mode 100644 index 000000000..3aac12322 --- /dev/null +++ b/protocol/migrations/sqlite/1597322655_add_invitation_admin_chat_field.up.sql @@ -0,0 +1 @@ +ALTER TABLE chats ADD COLUMN invitation_admin VARCHAR; \ No newline at end of file diff --git a/protocol/persistence.go b/protocol/persistence.go index c99d48cc7..788d0793d 100644 --- a/protocol/persistence.go +++ b/protocol/persistence.go @@ -122,8 +122,8 @@ func (db sqlitePersistence) saveChat(tx *sql.Tx, chat Chat) error { } // Insert record - stmt, err := tx.Prepare(`INSERT INTO chats(id, name, color, active, type, timestamp, deleted_at_clock_value, unviewed_message_count, last_clock_value, last_message, members, membership_updates, muted) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?)`) + stmt, err := tx.Prepare(`INSERT INTO chats(id, name, color, active, type, timestamp, deleted_at_clock_value, unviewed_message_count, last_clock_value, last_message, members, membership_updates, muted, invitation_admin) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?, ?)`) if err != nil { return err } @@ -143,6 +143,7 @@ func (db sqlitePersistence) saveChat(tx *sql.Tx, chat Chat) error { encodedMembers.Bytes(), encodedMembershipUpdates.Bytes(), chat.Muted, + chat.InvitationAdmin, ) if err != nil { return err @@ -201,6 +202,7 @@ func (db sqlitePersistence) chats(tx *sql.Tx) (chats []*Chat, err error) { chats.members, chats.membership_updates, chats.muted, + chats.invitation_admin, contacts.identicon, contacts.alias FROM chats LEFT JOIN contacts ON chats.id = contacts.id @@ -215,6 +217,7 @@ func (db sqlitePersistence) chats(tx *sql.Tx) (chats []*Chat, err error) { var ( alias sql.NullString identicon sql.NullString + invitationAdmin sql.NullString chat Chat encodedMembers []byte encodedMembershipUpdates []byte @@ -234,13 +237,19 @@ func (db sqlitePersistence) chats(tx *sql.Tx) (chats []*Chat, err error) { &encodedMembers, &encodedMembershipUpdates, &chat.Muted, + &invitationAdmin, &identicon, &alias, ) + if err != nil { return } + if invitationAdmin.Valid { + chat.InvitationAdmin = invitationAdmin.String + } + // Restore members membersDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembers)) err = membersDecoder.Decode(&chat.Members) @@ -278,6 +287,7 @@ func (db sqlitePersistence) Chat(chatID string) (*Chat, error) { encodedMembers []byte encodedMembershipUpdates []byte lastMessageBytes []byte + invitationAdmin sql.NullString ) err := db.db.QueryRow(` @@ -294,7 +304,8 @@ func (db sqlitePersistence) Chat(chatID string) (*Chat, error) { last_message, members, membership_updates, - muted + muted, + invitation_admin FROM chats WHERE id = ? `, chatID).Scan(&chat.ID, @@ -310,11 +321,15 @@ func (db sqlitePersistence) Chat(chatID string) (*Chat, error) { &encodedMembers, &encodedMembershipUpdates, &chat.Muted, + &invitationAdmin, ) switch err { case sql.ErrNoRows: return nil, nil case nil: + if invitationAdmin.Valid { + chat.InvitationAdmin = invitationAdmin.String + } // Restore members membersDecoder := gob.NewDecoder(bytes.NewBuffer(encodedMembers)) err = membersDecoder.Decode(&chat.Members) diff --git a/protocol/protobuf/application_metadata_message.pb.go b/protocol/protobuf/application_metadata_message.pb.go index afaaa4b3e..378b07e1d 100644 --- a/protocol/protobuf/application_metadata_message.pb.go +++ b/protocol/protobuf/application_metadata_message.pb.go @@ -46,7 +46,7 @@ const ( ApplicationMetadataMessage_PUSH_NOTIFICATION_REQUEST ApplicationMetadataMessage_Type = 20 ApplicationMetadataMessage_PUSH_NOTIFICATION_RESPONSE ApplicationMetadataMessage_Type = 21 ApplicationMetadataMessage_EMOJI_REACTION ApplicationMetadataMessage_Type = 22 - ApplicationMetadataMessage_EMOJI_REACTION_RETRACTION ApplicationMetadataMessage_Type = 23 + ApplicationMetadataMessage_GROUP_CHAT_INVITATION ApplicationMetadataMessage_Type = 23 ) var ApplicationMetadataMessage_Type_name = map[int32]string{ @@ -73,7 +73,7 @@ var ApplicationMetadataMessage_Type_name = map[int32]string{ 20: "PUSH_NOTIFICATION_REQUEST", 21: "PUSH_NOTIFICATION_RESPONSE", 22: "EMOJI_REACTION", - 23: "EMOJI_REACTION_RETRACTION", + 23: "GROUP_CHAT_INVITATION", } var ApplicationMetadataMessage_Type_value = map[string]int32{ @@ -100,7 +100,7 @@ var ApplicationMetadataMessage_Type_value = map[string]int32{ "PUSH_NOTIFICATION_REQUEST": 20, "PUSH_NOTIFICATION_RESPONSE": 21, "EMOJI_REACTION": 22, - "EMOJI_REACTION_RETRACTION": 23, + "GROUP_CHAT_INVITATION": 23, } func (x ApplicationMetadataMessage_Type) String() string { @@ -174,39 +174,41 @@ func init() { proto.RegisterType((*ApplicationMetadataMessage)(nil), "protobuf.ApplicationMetadataMessage") } -func init() { proto.RegisterFile("application_metadata_message.proto", fileDescriptor_ad09a6406fcf24c7) } +func init() { + proto.RegisterFile("application_metadata_message.proto", fileDescriptor_ad09a6406fcf24c7) +} var fileDescriptor_ad09a6406fcf24c7 = []byte{ - // 486 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0xd1, 0x52, 0xd3, 0x4e, - 0x14, 0xc6, 0xff, 0x85, 0xd2, 0xc2, 0xa1, 0xff, 0xba, 0x1c, 0xc0, 0x56, 0x10, 0xa8, 0xd5, 0x51, - 0xd4, 0x99, 0x5e, 0xe8, 0xb5, 0x17, 0xcb, 0xe6, 0x40, 0xa3, 0xcd, 0x26, 0xec, 0x6e, 0x74, 0xb8, - 0xda, 0x09, 0x12, 0x99, 0xce, 0x00, 0xcd, 0xd0, 0x70, 0xd1, 0x67, 0xf5, 0x29, 0x7c, 0x03, 0x27, - 0x69, 0x6a, 0xa9, 0x2d, 0x72, 0x95, 0xd9, 0xef, 0xfb, 0x9d, 0x73, 0xe6, 0x7c, 0x9b, 0x85, 0x76, - 0x94, 0x24, 0x57, 0xfd, 0xef, 0x51, 0xda, 0x1f, 0xdc, 0xd8, 0xeb, 0x38, 0x8d, 0x2e, 0xa2, 0x34, - 0xb2, 0xd7, 0xf1, 0x70, 0x18, 0x5d, 0xc6, 0x9d, 0xe4, 0x76, 0x90, 0x0e, 0x70, 0x35, 0xff, 0x9c, - 0xdf, 0xfd, 0x68, 0xff, 0xaa, 0xc0, 0x0e, 0x9f, 0x16, 0x78, 0x05, 0xef, 0x8d, 0x71, 0x7c, 0x0e, - 0x6b, 0xc3, 0xfe, 0xe5, 0x4d, 0x94, 0xde, 0xdd, 0xc6, 0xcd, 0x52, 0xab, 0x74, 0x58, 0x53, 0x53, - 0x01, 0x9b, 0x50, 0x4d, 0xa2, 0xd1, 0xd5, 0x20, 0xba, 0x68, 0x2e, 0xe5, 0xde, 0xe4, 0x88, 0x9f, - 0xa0, 0x9c, 0x8e, 0x92, 0xb8, 0xb9, 0xdc, 0x2a, 0x1d, 0xd6, 0x3f, 0xbc, 0xed, 0x4c, 0xe6, 0x75, - 0x1e, 0x9e, 0xd5, 0x31, 0xa3, 0x24, 0x56, 0x79, 0x59, 0xfb, 0xe7, 0x0a, 0x94, 0xb3, 0x23, 0xae, - 0x43, 0x35, 0x94, 0x5f, 0xa4, 0xff, 0x4d, 0xb2, 0xff, 0x90, 0x41, 0x4d, 0x74, 0xb9, 0xb1, 0x1e, - 0x69, 0xcd, 0x4f, 0x88, 0x95, 0x10, 0xa1, 0x2e, 0x7c, 0x69, 0xb8, 0x30, 0x36, 0x0c, 0x1c, 0x6e, - 0x88, 0x2d, 0xe1, 0x1e, 0x3c, 0xf3, 0xc8, 0x3b, 0x22, 0xa5, 0xbb, 0x6e, 0x50, 0xc8, 0x7f, 0x4a, - 0x96, 0x71, 0x1b, 0x36, 0x02, 0xee, 0x2a, 0xeb, 0x4a, 0x6d, 0x78, 0xaf, 0xc7, 0x8d, 0xeb, 0x4b, - 0x56, 0xce, 0x64, 0x7d, 0x26, 0xc5, 0xac, 0xbc, 0x82, 0x2f, 0xe1, 0x40, 0xd1, 0x69, 0x48, 0xda, - 0x58, 0xee, 0x38, 0x8a, 0xb4, 0xb6, 0xc7, 0xbe, 0xb2, 0x46, 0x71, 0xa9, 0xb9, 0xc8, 0xa1, 0x0a, - 0xbe, 0x83, 0xd7, 0x5c, 0x08, 0x0a, 0x8c, 0x7d, 0x8c, 0xad, 0xe2, 0x7b, 0x78, 0xe3, 0x90, 0xe8, - 0xb9, 0x92, 0x1e, 0x85, 0x57, 0xb1, 0x01, 0x9b, 0x13, 0xe8, 0xbe, 0xb1, 0x86, 0x5b, 0xc0, 0x34, - 0x49, 0x67, 0x46, 0x05, 0x3c, 0x80, 0xdd, 0xbf, 0x7b, 0xdf, 0x07, 0xd6, 0xb3, 0x68, 0xe6, 0x96, - 0xb4, 0x45, 0x80, 0xac, 0xb6, 0xd8, 0xe6, 0x42, 0xf8, 0xa1, 0x34, 0xec, 0x7f, 0x7c, 0x01, 0x7b, - 0xf3, 0x76, 0x10, 0x1e, 0xf5, 0x5c, 0x61, 0xb3, 0x7b, 0x61, 0x75, 0xdc, 0x87, 0x9d, 0xc9, 0x7d, - 0x08, 0xdf, 0x21, 0xcb, 0x9d, 0xaf, 0xa4, 0x8c, 0xab, 0xc9, 0x23, 0x69, 0xd8, 0x13, 0x6c, 0xc3, - 0x7e, 0x10, 0xea, 0xae, 0x95, 0xbe, 0x71, 0x8f, 0x5d, 0x31, 0x6e, 0xa1, 0xe8, 0xc4, 0xd5, 0x46, - 0x8d, 0x23, 0x67, 0x59, 0x42, 0xff, 0x66, 0xac, 0x22, 0x1d, 0xf8, 0x52, 0x13, 0xdb, 0xc0, 0x5d, - 0x68, 0xcc, 0xc3, 0xa7, 0x21, 0xa9, 0x33, 0x86, 0xf8, 0x0a, 0x5a, 0x0f, 0x98, 0xd3, 0x16, 0x9b, - 0xd9, 0xd6, 0x8b, 0xe6, 0xe5, 0xf9, 0xb1, 0xad, 0x6c, 0xa5, 0x45, 0x76, 0x51, 0xbe, 0x9d, 0xfd, - 0x82, 0xe4, 0xf9, 0x9f, 0x5d, 0xab, 0xa8, 0xc8, 0xf9, 0x69, 0xd6, 0x72, 0x56, 0xb3, 0x8a, 0x8c, - 0x2a, 0xec, 0xc6, 0x79, 0x25, 0x7f, 0x0d, 0x1f, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x79, 0x47, - 0x6f, 0x0d, 0xaa, 0x03, 0x00, 0x00, + // 493 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x93, 0x5f, 0x53, 0xd3, 0x4c, + 0x14, 0xc6, 0xdf, 0xf2, 0x9f, 0x03, 0x6f, 0x5d, 0x0e, 0xd4, 0x16, 0x10, 0xa8, 0xd5, 0x51, 0xd4, + 0x99, 0x5e, 0xe8, 0xb5, 0x17, 0xcb, 0xe6, 0xd0, 0xae, 0x36, 0x9b, 0xb0, 0xbb, 0xc1, 0xe1, 0x6a, + 0x27, 0x48, 0x64, 0x3a, 0x03, 0x34, 0x43, 0xc3, 0x45, 0x3f, 0xa9, 0x9f, 0xc2, 0xef, 0xe0, 0x24, + 0x6d, 0x2d, 0xd8, 0x22, 0x57, 0x99, 0x7d, 0x9e, 0xdf, 0x39, 0x67, 0xce, 0xb3, 0x59, 0x68, 0xc4, + 0x69, 0x7a, 0xd5, 0xfd, 0x1e, 0x67, 0xdd, 0xde, 0x8d, 0xbb, 0x4e, 0xb2, 0xf8, 0x22, 0xce, 0x62, + 0x77, 0x9d, 0xf4, 0xfb, 0xf1, 0x65, 0xd2, 0x4c, 0x6f, 0x7b, 0x59, 0x0f, 0x57, 0x8a, 0xcf, 0xf9, + 0xdd, 0x8f, 0xc6, 0xaf, 0x25, 0xd8, 0xe1, 0x93, 0x02, 0x7f, 0xc4, 0xfb, 0x43, 0x1c, 0x5f, 0xc0, + 0x6a, 0xbf, 0x7b, 0x79, 0x13, 0x67, 0x77, 0xb7, 0x49, 0xad, 0x54, 0x2f, 0x1d, 0xae, 0xeb, 0x89, + 0x80, 0x35, 0x58, 0x4e, 0xe3, 0xc1, 0x55, 0x2f, 0xbe, 0xa8, 0xcd, 0x15, 0xde, 0xf8, 0x88, 0x9f, + 0x61, 0x21, 0x1b, 0xa4, 0x49, 0x6d, 0xbe, 0x5e, 0x3a, 0x2c, 0x7f, 0x7c, 0xd7, 0x1c, 0xcf, 0x6b, + 0x3e, 0x3e, 0xab, 0x69, 0x07, 0x69, 0xa2, 0x8b, 0xb2, 0xc6, 0xcf, 0x45, 0x58, 0xc8, 0x8f, 0xb8, + 0x06, 0xcb, 0x91, 0xfa, 0xaa, 0x82, 0x6f, 0x8a, 0xfd, 0x87, 0x0c, 0xd6, 0x45, 0x9b, 0x5b, 0xe7, + 0x93, 0x31, 0xbc, 0x45, 0xac, 0x84, 0x08, 0x65, 0x11, 0x28, 0xcb, 0x85, 0x75, 0x51, 0xe8, 0x71, + 0x4b, 0x6c, 0x0e, 0xf7, 0x60, 0xdb, 0x27, 0xff, 0x88, 0xb4, 0x69, 0xcb, 0x70, 0x24, 0xff, 0x29, + 0x99, 0xc7, 0x0a, 0x6c, 0x84, 0x5c, 0x6a, 0x27, 0x95, 0xb1, 0xbc, 0xd3, 0xe1, 0x56, 0x06, 0x8a, + 0x2d, 0xe4, 0xb2, 0x39, 0x53, 0xe2, 0xa1, 0xbc, 0x88, 0xaf, 0xe0, 0x40, 0xd3, 0x49, 0x44, 0xc6, + 0x3a, 0xee, 0x79, 0x9a, 0x8c, 0x71, 0xc7, 0x81, 0x76, 0x56, 0x73, 0x65, 0xb8, 0x28, 0xa0, 0x25, + 0x7c, 0x0f, 0x6f, 0xb8, 0x10, 0x14, 0x5a, 0xf7, 0x14, 0xbb, 0x8c, 0x1f, 0xe0, 0xad, 0x47, 0xa2, + 0x23, 0x15, 0x3d, 0x09, 0xaf, 0x60, 0x15, 0x36, 0xc7, 0xd0, 0x7d, 0x63, 0x15, 0xb7, 0x80, 0x19, + 0x52, 0xde, 0x03, 0x15, 0xf0, 0x00, 0x76, 0xff, 0xee, 0x7d, 0x1f, 0x58, 0xcb, 0xa3, 0x99, 0x5a, + 0xd2, 0x8d, 0x02, 0x64, 0xeb, 0xb3, 0x6d, 0x2e, 0x44, 0x10, 0x29, 0xcb, 0xfe, 0xc7, 0x97, 0xb0, + 0x37, 0x6d, 0x87, 0xd1, 0x51, 0x47, 0x0a, 0x97, 0xdf, 0x0b, 0x2b, 0xe3, 0x3e, 0xec, 0x8c, 0xef, + 0x43, 0x04, 0x1e, 0x39, 0xee, 0x9d, 0x92, 0xb6, 0xd2, 0x90, 0x4f, 0xca, 0xb2, 0x67, 0xd8, 0x80, + 0xfd, 0x30, 0x32, 0x6d, 0xa7, 0x02, 0x2b, 0x8f, 0xa5, 0x18, 0xb6, 0xd0, 0xd4, 0x92, 0xc6, 0xea, + 0x61, 0xe4, 0x2c, 0x4f, 0xe8, 0xdf, 0x8c, 0xd3, 0x64, 0xc2, 0x40, 0x19, 0x62, 0x1b, 0xb8, 0x0b, + 0xd5, 0x69, 0xf8, 0x24, 0x22, 0x7d, 0xc6, 0x10, 0x5f, 0x43, 0xfd, 0x11, 0x73, 0xd2, 0x62, 0x33, + 0xdf, 0x7a, 0xd6, 0xbc, 0x22, 0x3f, 0xb6, 0x95, 0xaf, 0x34, 0xcb, 0x1e, 0x95, 0x57, 0xf2, 0x5f, + 0x90, 0xfc, 0xe0, 0x8b, 0x74, 0x9a, 0x46, 0x39, 0x3f, 0xc7, 0x6d, 0xa8, 0xb4, 0x74, 0x10, 0x85, + 0x45, 0x2c, 0x4e, 0xaa, 0x53, 0x69, 0x87, 0xdb, 0x55, 0xcf, 0x97, 0x8a, 0x97, 0xf0, 0xe9, 0x77, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xa0, 0x4d, 0x74, 0xca, 0xa6, 0x03, 0x00, 0x00, } diff --git a/protocol/protobuf/application_metadata_message.proto b/protocol/protobuf/application_metadata_message.proto index e88307071..39405c4ea 100644 --- a/protocol/protobuf/application_metadata_message.proto +++ b/protocol/protobuf/application_metadata_message.proto @@ -35,6 +35,6 @@ message ApplicationMetadataMessage { PUSH_NOTIFICATION_REQUEST = 20; PUSH_NOTIFICATION_RESPONSE = 21; EMOJI_REACTION = 22; - EMOJI_REACTION_RETRACTION = 23; + GROUP_CHAT_INVITATION = 23; } } diff --git a/protocol/protobuf/group_chat_invitation.pb.go b/protocol/protobuf/group_chat_invitation.pb.go new file mode 100644 index 000000000..b44a31b8e --- /dev/null +++ b/protocol/protobuf/group_chat_invitation.pb.go @@ -0,0 +1,147 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: group_chat_invitation.proto + +package protobuf + +import ( + fmt "fmt" + proto "github.com/golang/protobuf/proto" + math "math" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package + +type GroupChatInvitation_State int32 + +const ( + GroupChatInvitation_UNKNOWN GroupChatInvitation_State = 0 + GroupChatInvitation_REQUEST GroupChatInvitation_State = 1 + GroupChatInvitation_REJECTED GroupChatInvitation_State = 2 + GroupChatInvitation_APPROVED GroupChatInvitation_State = 3 +) + +var GroupChatInvitation_State_name = map[int32]string{ + 0: "UNKNOWN", + 1: "REQUEST", + 2: "REJECTED", + 3: "APPROVED", +} + +var GroupChatInvitation_State_value = map[string]int32{ + "UNKNOWN": 0, + "REQUEST": 1, + "REJECTED": 2, + "APPROVED": 3, +} + +func (x GroupChatInvitation_State) String() string { + return proto.EnumName(GroupChatInvitation_State_name, int32(x)) +} + +func (GroupChatInvitation_State) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_a6a73333de6a8ebe, []int{0, 0} +} + +type GroupChatInvitation struct { + // clock Lamport timestamp of the chat message + Clock uint64 `protobuf:"varint,1,opt,name=clock,proto3" json:"clock,omitempty"` + // chat_id the ID of the private group chat the message belongs to, for query efficiency the chat_id is stored in the db even though the + // target message also stores the chat_id + ChatId string `protobuf:"bytes,2,opt,name=chat_id,json=chatId,proto3" json:"chat_id,omitempty"` + IntroductionMessage string `protobuf:"bytes,3,opt,name=introduction_message,json=introductionMessage,proto3" json:"introduction_message,omitempty"` + // state of invitation + State GroupChatInvitation_State `protobuf:"varint,4,opt,name=state,proto3,enum=protobuf.GroupChatInvitation_State" json:"state,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GroupChatInvitation) Reset() { *m = GroupChatInvitation{} } +func (m *GroupChatInvitation) String() string { return proto.CompactTextString(m) } +func (*GroupChatInvitation) ProtoMessage() {} +func (*GroupChatInvitation) Descriptor() ([]byte, []int) { + return fileDescriptor_a6a73333de6a8ebe, []int{0} +} + +func (m *GroupChatInvitation) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_GroupChatInvitation.Unmarshal(m, b) +} +func (m *GroupChatInvitation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_GroupChatInvitation.Marshal(b, m, deterministic) +} +func (m *GroupChatInvitation) XXX_Merge(src proto.Message) { + xxx_messageInfo_GroupChatInvitation.Merge(m, src) +} +func (m *GroupChatInvitation) XXX_Size() int { + return xxx_messageInfo_GroupChatInvitation.Size(m) +} +func (m *GroupChatInvitation) XXX_DiscardUnknown() { + xxx_messageInfo_GroupChatInvitation.DiscardUnknown(m) +} + +var xxx_messageInfo_GroupChatInvitation proto.InternalMessageInfo + +func (m *GroupChatInvitation) GetClock() uint64 { + if m != nil { + return m.Clock + } + return 0 +} + +func (m *GroupChatInvitation) GetChatId() string { + if m != nil { + return m.ChatId + } + return "" +} + +func (m *GroupChatInvitation) GetIntroductionMessage() string { + if m != nil { + return m.IntroductionMessage + } + return "" +} + +func (m *GroupChatInvitation) GetState() GroupChatInvitation_State { + if m != nil { + return m.State + } + return GroupChatInvitation_UNKNOWN +} + +func init() { + proto.RegisterEnum("protobuf.GroupChatInvitation_State", GroupChatInvitation_State_name, GroupChatInvitation_State_value) + proto.RegisterType((*GroupChatInvitation)(nil), "protobuf.GroupChatInvitation") +} + +func init() { + proto.RegisterFile("group_chat_invitation.proto", fileDescriptor_a6a73333de6a8ebe) +} + +var fileDescriptor_a6a73333de6a8ebe = []byte{ + // 234 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x2f, 0xca, 0x2f, + 0x2d, 0x88, 0x4f, 0xce, 0x48, 0x2c, 0x89, 0xcf, 0xcc, 0x2b, 0xcb, 0x2c, 0x49, 0x2c, 0xc9, 0xcc, + 0xcf, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x00, 0x53, 0x49, 0xa5, 0x69, 0x4a, 0x1f, + 0x19, 0xb9, 0x84, 0xdd, 0x41, 0x2a, 0x9d, 0x33, 0x12, 0x4b, 0x3c, 0xe1, 0xea, 0x84, 0x44, 0xb8, + 0x58, 0x93, 0x73, 0xf2, 0x93, 0xb3, 0x25, 0x18, 0x15, 0x18, 0x35, 0x58, 0x82, 0x20, 0x1c, 0x21, + 0x71, 0x2e, 0x76, 0x88, 0x81, 0x29, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0x6c, 0x20, 0xae, + 0x67, 0x8a, 0x90, 0x21, 0x97, 0x48, 0x66, 0x5e, 0x49, 0x51, 0x7e, 0x4a, 0x69, 0x32, 0x48, 0x7b, + 0x7c, 0x6e, 0x6a, 0x71, 0x71, 0x62, 0x7a, 0xaa, 0x04, 0x33, 0x58, 0x95, 0x30, 0xb2, 0x9c, 0x2f, + 0x44, 0x4a, 0xc8, 0x92, 0x8b, 0xb5, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0x82, 0x45, 0x81, 0x51, 0x83, + 0xcf, 0x48, 0x59, 0x0f, 0xe6, 0x26, 0x3d, 0x2c, 0xee, 0xd1, 0x0b, 0x06, 0x29, 0x0d, 0x82, 0xe8, + 0x50, 0xb2, 0xe5, 0x62, 0x05, 0xf3, 0x85, 0xb8, 0xb9, 0xd8, 0x43, 0xfd, 0xbc, 0xfd, 0xfc, 0xc3, + 0xfd, 0x04, 0x18, 0x40, 0x9c, 0x20, 0xd7, 0xc0, 0x50, 0xd7, 0xe0, 0x10, 0x01, 0x46, 0x21, 0x1e, + 0x2e, 0x8e, 0x20, 0x57, 0x2f, 0x57, 0xe7, 0x10, 0x57, 0x17, 0x01, 0x26, 0x10, 0xcf, 0x31, 0x20, + 0x20, 0xc8, 0x3f, 0xcc, 0xd5, 0x45, 0x80, 0x39, 0x89, 0x0d, 0x6c, 0x93, 0x31, 0x20, 0x00, 0x00, + 0xff, 0xff, 0x9c, 0xc5, 0x9c, 0xd5, 0x23, 0x01, 0x00, 0x00, +} diff --git a/protocol/protobuf/group_chat_invitation.proto b/protocol/protobuf/group_chat_invitation.proto new file mode 100644 index 000000000..58bcefc73 --- /dev/null +++ b/protocol/protobuf/group_chat_invitation.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; + +package protobuf; + +message GroupChatInvitation { + + // clock Lamport timestamp of the chat message + uint64 clock = 1; + + // chat_id the ID of the private group chat the message belongs to, for query efficiency the chat_id is stored in the db even though the + // target message also stores the chat_id + string chat_id = 2; + + string introduction_message = 3; + + // state of invitation + State state = 4; + + enum State { + UNKNOWN = 0; + REQUEST = 1; + REJECTED = 2; + APPROVED = 3; + } +} \ No newline at end of file diff --git a/protocol/protobuf/service.go b/protocol/protobuf/service.go index 7879d05a1..78e02b43a 100644 --- a/protocol/protobuf/service.go +++ b/protocol/protobuf/service.go @@ -4,7 +4,7 @@ import ( "github.com/golang/protobuf/proto" ) -//go:generate protoc --go_out=. ./chat_message.proto ./application_metadata_message.proto ./membership_update_message.proto ./command.proto ./contact.proto ./pairing.proto ./push_notifications.proto ./emoji_reaction.proto ./enums.proto +//go:generate protoc --go_out=. ./chat_message.proto ./application_metadata_message.proto ./membership_update_message.proto ./command.proto ./contact.proto ./pairing.proto ./push_notifications.proto ./emoji_reaction.proto ./enums.proto ./group_chat_invitation.proto func Unmarshal(payload []byte) (*ApplicationMetadataMessage, error) { var message ApplicationMetadataMessage diff --git a/protocol/v1/status_message.go b/protocol/v1/status_message.go index 84ad468ae..a86d2c996 100644 --- a/protocol/v1/status_message.go +++ b/protocol/v1/status_message.go @@ -240,6 +240,8 @@ func (m *StatusMessage) HandleApplication() error { return m.unmarshalProtobufData(new(protobuf.PushNotificationResponse)) case protobuf.ApplicationMetadataMessage_EMOJI_REACTION: return m.unmarshalProtobufData(new(protobuf.EmojiReaction)) + case protobuf.ApplicationMetadataMessage_GROUP_CHAT_INVITATION: + return m.unmarshalProtobufData(new(protobuf.GroupChatInvitation)) case protobuf.ApplicationMetadataMessage_PUSH_NOTIFICATION_REGISTRATION: // This message is a bit different as it's encrypted, so we pass it straight through v := reflect.ValueOf(m.DecryptedPayload) diff --git a/services/ext/api.go b/services/ext/api.go index adc56ed09..9a5f302c4 100644 --- a/services/ext/api.go +++ b/services/ext/api.go @@ -213,6 +213,10 @@ func (api *PublicAPI) CreateGroupChatWithMembers(ctx Context, name string, membe return api.service.messenger.CreateGroupChatWithMembers(ctx, name, members) } +func (api *PublicAPI) CreateGroupChatFromInvitation(name string, chatID string, adminPK string) (*protocol.MessengerResponse, error) { + return api.service.messenger.CreateGroupChatFromInvitation(name, chatID, adminPK) +} + func (api *PublicAPI) AddMembersToGroupChat(ctx Context, chatID string, members []string) (*protocol.MessengerResponse, error) { return api.service.messenger.AddMembersToGroupChat(ctx, chatID, members) } @@ -233,6 +237,18 @@ func (api *PublicAPI) ChangeGroupChatName(ctx Context, chatID string, name strin return api.service.messenger.ChangeGroupChatName(ctx, chatID, name) } +func (api *PublicAPI) SendGroupChatInvitationRequest(ctx Context, chatID string, adminPK string, message string) (*protocol.MessengerResponse, error) { + return api.service.messenger.SendGroupChatInvitationRequest(ctx, chatID, adminPK, message) +} + +func (api *PublicAPI) GetGroupChatInvitations() ([]*protocol.GroupChatInvitation, error) { + return api.service.messenger.GetGroupChatInvitations() +} + +func (api *PublicAPI) SendGroupChatInvitationRejection(ctx Context, invitationRequestID string) (*protocol.MessengerResponse, error) { + return api.service.messenger.SendGroupChatInvitationRejection(ctx, invitationRequestID) +} + func (api *PublicAPI) LoadFilters(parent context.Context, chats []*transport.Filter) ([]*transport.Filter, error) { return api.service.messenger.LoadFilters(chats) }