Add mark as read endpoint (#1863)

VERSION

@@ -1 +1 @@
-0.46.1
+0.47.0

protocol/messenger.go

@@ -1658,21 +1658,6 @@ func (m *Messenger) syncContact(ctx context.Context, contact *Contact) error {
 	return m.saveChat(chat)
 }
 
-// SendRaw takes encoded data, encrypts it and sends through the wire.
-// DEPRECATED
-func (m *Messenger) SendRaw(ctx context.Context, chat Chat, data []byte) ([]byte, error) {
-	publicKey, err := chat.PublicKey()
-	if err != nil {
-		return nil, err
-	}
-	if publicKey != nil {
-		return m.processor.SendPrivateRaw(ctx, publicKey, data, protobuf.ApplicationMetadataMessage_UNKNOWN)
-	} else if chat.Name != "" {
-		return m.processor.SendPublicRaw(ctx, chat.Name, data, protobuf.ApplicationMetadataMessage_UNKNOWN)
-	}
-	return nil, errors.New("chat is neither public nor private")
-}
-
 // RetrieveAll retrieves messages from all filters, processes them and returns a
 // MessengerResponse to the client
 func (m *Messenger) RetrieveAll() (*MessengerResponse, error) {
@@ -1980,17 +1965,14 @@ func (m *Messenger) RequestHistoricMessages(
 	return m.transport.SendMessagesRequest(ctx, peer, from, to, cursor)
 }
 
-// DEPRECATED
 func (m *Messenger) LoadFilters(filters []*transport.Filter) ([]*transport.Filter, error) {
 	return m.transport.LoadFilters(filters)
 }
 
-// DEPRECATED
 func (m *Messenger) RemoveFilters(filters []*transport.Filter) error {
 	return m.transport.RemoveFilters(filters)
 }
 
-// DEPRECATED
 func (m *Messenger) ConfirmMessagesProcessed(messageIDs [][]byte) error {
 	for _, id := range messageIDs {
 		if err := m.encryptor.ConfirmMessageProcessed(id); err != nil {
@@ -2000,37 +1982,30 @@ func (m *Messenger) ConfirmMessagesProcessed(messageIDs [][]byte) error {
 	return nil
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) MessageByID(id string) (*Message, error) {
 	return m.persistence.MessageByID(id)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) MessagesExist(ids []string) (map[string]bool, error) {
 	return m.persistence.MessagesExist(ids)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) MessageByChatID(chatID, cursor string, limit int) ([]*Message, string, error) {
 	return m.persistence.MessageByChatID(chatID, cursor, limit)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) SaveMessages(messages []*Message) error {
 	return m.persistence.SaveMessagesLegacy(messages)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) DeleteMessage(id string) error {
 	return m.persistence.DeleteMessage(id)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) DeleteMessagesByChatID(id string) error {
 	return m.persistence.DeleteMessagesByChatID(id)
 }
 
-// DEPRECATED: required by status-react.
 func (m *Messenger) MarkMessagesSeen(chatID string, ids []string) error {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
@@ -2047,7 +2022,24 @@ func (m *Messenger) MarkMessagesSeen(chatID string, ids []string) error {
 	return nil
 }
 
-// DEPRECATED: required by status-react.
+func (m *Messenger) MarkAllRead(chatID string) error {
+	m.mutex.Lock()
+	defer m.mutex.Unlock()
+	chat, ok := m.allChats[chatID]
+	if !ok {
+		return errors.New("chat not found")
+	}
+
+	err := m.persistence.MarkAllRead(chatID)
+	if err != nil {
+		return err
+	}
+
+	chat.UnviewedMessagesCount = 0
+	m.allChats[chat.ID] = chat
+	return nil
+}
+
 func (m *Messenger) UpdateMessageOutgoingStatus(id, newOutgoingStatus string) error {
 	return m.persistence.UpdateMessageOutgoingStatus(id, newOutgoingStatus)
 }

protocol/messenger_test.go

@@ -327,6 +327,29 @@ func (s *MessengerSuite) TestMarkMessagesSeen() {
 	s.Require().Equal(uint(1), chats[0].UnviewedMessagesCount)
 }
 
+func (s *MessengerSuite) TestMarkAllRead() {
+	chat := CreatePublicChat("test-chat", s.m.transport)
+	chat.UnviewedMessagesCount = 2
+	err := s.m.SaveChat(&chat)
+	s.Require().NoError(err)
+	inputMessage1 := buildTestMessage(chat)
+	inputMessage1.ID = "1"
+	inputMessage1.Seen = false
+	inputMessage2 := buildTestMessage(chat)
+	inputMessage2.ID = "2"
+	inputMessage2.Seen = false
+
+	err = s.m.SaveMessages([]*Message{inputMessage1, inputMessage2})
+	s.Require().NoError(err)
+
+	err = s.m.MarkAllRead(chat.ID)
+	s.Require().NoError(err)
+
+	chats := s.m.Chats()
+	s.Require().Len(chats, 1)
+	s.Require().Equal(uint(0), chats[0].UnviewedMessagesCount)
+}
+
 func (s *MessengerSuite) TestSendPublic() {
 	chat := CreatePublicChat("test-chat", s.m.transport)
 	chat.LastClockValue = uint64(100000000000000)

protocol/persistence_legacy.go

@@ -434,6 +434,28 @@ func (db sqlitePersistence) DeleteMessagesByChatID(id string) error {
 	return err
 }
 
+func (db sqlitePersistence) MarkAllRead(chatID string) error {
+	tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == nil {
+			err = tx.Commit()
+			return
+		}
+		// don't shadow original error
+		_ = tx.Rollback()
+	}()
+
+	_, err = tx.Exec(`UPDATE user_messages SET seen = 1 WHERE local_chat_id = ?`, chatID)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`UPDATE chats SET unviewed_message_count = 0 WHERE id = ?`, chatID)
+	return err
+}
+
 func (db sqlitePersistence) MarkMessagesSeen(chatID string, ids []string) error {
 	tx, err := db.db.BeginTx(context.Background(), &sql.TxOptions{})
 	if err != nil {

services/ext/api.go

@@ -194,30 +194,6 @@ func (api *PublicAPI) ConfirmMessagesProcessedByID(messageConfirmations []*Metad
 	return api.service.ConfirmMessagesProcessed(encryptionIDs)
 }
 
-// SendPublicMessage sends a public chat message to the underlying transport.
-// Message's payload is a transit encoded message.
-// It's important to call PublicAPI.afterSend() so that the client receives a signal
-// with confirmation that the message left the device.
-func (api *PublicAPI) SendPublicMessage(ctx context.Context, msg SendPublicMessageRPC) (types.HexBytes, error) {
-	chat := protocol.Chat{
-		Name: msg.Chat,
-	}
-	return api.service.messenger.SendRaw(ctx, chat, msg.Payload)
-}
-
-// SendDirectMessage sends a 1:1 chat message to the underlying transport
-// Message's payload is a transit encoded message.
-// It's important to call PublicAPI.afterSend() so that the client receives a signal
-// with confirmation that the message left the device.
-func (api *PublicAPI) SendDirectMessage(ctx context.Context, msg SendDirectMessageRPC) (types.HexBytes, error) {
-	chat := protocol.Chat{
-		ChatType: protocol.ChatTypeOneToOne,
-		ID:       types.EncodeHex(msg.PubKey),
-	}
-
-	return api.service.messenger.SendRaw(ctx, chat, msg.Payload)
-}
-
 func (api *PublicAPI) Join(chat protocol.Chat) error {
 	return api.service.messenger.Join(chat)
 }
@@ -337,6 +313,10 @@ func (api *PublicAPI) MarkMessagesSeen(chatID string, ids []string) error {
 	return api.service.messenger.MarkMessagesSeen(chatID, ids)
 }
 
+func (api *PublicAPI) MarkAllRead(chatID string) error {
+	return api.service.messenger.MarkAllRead(chatID)
+}
+
 func (api *PublicAPI) UpdateMessageOutgoingStatus(id, newOutgoingStatus string) error {
 	return api.service.messenger.UpdateMessageOutgoingStatus(id, newOutgoingStatus)
 }

services/shhext/api_nimbus.go

@@ -265,30 +265,6 @@ func (api *NimbusPublicAPI) Post(ctx context.Context, newMessage types.NewMessag
 	return api.publicAPI.Post(ctx, newMessage)
 }
 
-// SendPublicMessage sends a public chat message to the underlying transport.
-// Message's payload is a transit encoded message.
-// It's important to call NimbusPublicAPI.afterSend() so that the client receives a signal
-// with confirmation that the message left the device.
-func (api *NimbusPublicAPI) SendPublicMessage(ctx context.Context, msg SendPublicMessageRPC) (types.HexBytes, error) {
-	chat := protocol.Chat{
-		Name: msg.Chat,
-	}
-	return api.service.messenger.SendRaw(ctx, chat, msg.Payload)
-}
-
-// SendDirectMessage sends a 1:1 chat message to the underlying transport
-// Message's payload is a transit encoded message.
-// It's important to call NimbusPublicAPI.afterSend() so that the client receives a signal
-// with confirmation that the message left the device.
-func (api *NimbusPublicAPI) SendDirectMessage(ctx context.Context, msg SendDirectMessageRPC) (types.HexBytes, error) {
-	chat := protocol.Chat{
-		ChatType: protocol.ChatTypeOneToOne,
-		ID:       types.EncodeHex(msg.PubKey),
-	}
-
-	return api.service.messenger.SendRaw(ctx, chat, msg.Payload)
-}
-
 func (api *NimbusPublicAPI) Join(chat protocol.Chat) error {
 	return api.service.messenger.Join(chat)
 }