message: Handle UpdateMessageEvent for moving/editing.

When a channel (a.k.a stream) or a topic gets updated on a message, we
get a UpdateMessageEvent from the server. The same happens when the
message's content is updated.

This updates the edit state to show the "edited" or "moved" marker
properly on the messages affected, and leave other move related states
(like streamId) untouched until we get to #150.

Signed-off-by: Zixuan James Li <[email protected]>

Author: PIG208

lib/model/message.dart

@@ -125,6 +125,11 @@ class MessageStoreImpl with MessageStore {
     if (message == null) return;
 
     message.flags = event.flags;
+    // According to the API, the content of the message is edited if origContent
+    // is not null.
+    if (event.origContent != null) {
+      message.editState = MessageEditState.edited;
+    }
     if (event.renderedContent != null) {
       assert(message.contentType == 'text/html',
         "Message contentType was ${message.contentType}; expected text/html.");
@@ -143,7 +148,10 @@ class MessageStoreImpl with MessageStore {
     // The interaction between the fields of these events are a bit tricky.
     // For reference, see: https://zulip.com/api/get-events#update_message
 
-    if (event.origTopic == null) {
+    final bool isChannelMoved = event.newStreamId != null;
+    bool isTopicMoved = event.origTopic != null;
+
+    if (!isTopicMoved && !isChannelMoved) {
       // There was no move.
       assert(() {
         if (event.newStreamId != null && event.origStreamId != null
@@ -168,10 +176,27 @@ class MessageStoreImpl with MessageStore {
       return;
     }
 
+    if (isTopicMoved) {
+      // Eliminate the case when the topic is updated but resolved/unresolved.
+      isTopicMoved = MessageEditState.areSameTopic(event.origTopic!, event.newTopic!);
+    }
+
+    // When nothing has been moved,
+    // return early as the messages' editStates need no update.
+    if (!isTopicMoved && !isChannelMoved) return;
+
     // final newStreamId = event.newStreamId; // null if topic-only move
     // final newTopic = event.newTopic!;
     // TODO(#150): Handle message moves.  The views' recipient headers
     //   may need updating, and consequently showSender too.
+    //   Currently only editState gets updated.
+    for (final messageId in event.messageIds) {
+      final message = messages[messageId];
+      if (message == null) continue;
+      // Do not override the edited marker if the message has also been moved.
+      if (message.editState == MessageEditState.edited) continue;
+      message.editState = MessageEditState.moved;
+    }
   }
 
   void handleDeleteMessageEvent(DeleteMessageEvent event) {

test/example_data.dart

@@ -420,6 +420,38 @@ UpdateMessageEvent updateMessageEditEvent(
   );
 }
 
+UpdateMessageEvent updateMessageMoveEvent(
+  List<Message> messages, {
+  int? newStreamId,
+  String? origTopic,
+  String? newTopic,
+  String? origContent,
+  String? origRenderedContent,
+}) {
+  assert(messages.isNotEmpty);
+  final origMessage = messages[0];
+  final messageId = origMessage.id;
+  return UpdateMessageEvent(
+    id: 0,
+    userId: selfUser.userId,
+    renderingOnly: false,
+    messageId: messageId,
+    messageIds: messages.map((message) => message.id).toList(),
+    flags: origMessage.flags,
+    editTimestamp: 1234567890, // TODO generate timestamp
+    origStreamId: origMessage is StreamMessage ? origMessage.streamId : null,
+    newStreamId: newStreamId,
+    propagateMode: null,
+    origTopic: origTopic,
+    newTopic: newTopic,
+    origContent: origContent,
+    origRenderedContent: origRenderedContent,
+    content: 'some probably-mismatched new Markdown',
+    renderedContent: origMessage.content,
+    isMeMessage: false,
+  );
+}
+
 UpdateMessageFlagsRemoveEvent updateMessageFlagsRemoveEvent(
   MessageFlag flag,
   Iterable<Message> messages, {

test/model/message_test.dart

@@ -207,7 +207,8 @@ void main() {
         ..content.not((it) => it.equals(updateEvent.renderedContent!))
         ..lastEditTimestamp.isNull()
         ..flags.not((it) => it.deepEquals(updateEvent.flags))
-        ..isMeMessage.not((it) => it.equals(updateEvent.isMeMessage!));
+        ..isMeMessage.not((it) => it.equals(updateEvent.isMeMessage!))
+        ..editState.equals(MessageEditState.none);
 
       await store.handleEvent(updateEvent);
       checkNotifiedOnce();
@@ -216,7 +217,8 @@ void main() {
         ..content.equals(updateEvent.renderedContent!)
         ..lastEditTimestamp.equals(updateEvent.editTimestamp)
         ..flags.equals(updateEvent.flags)
-        ..isMeMessage.equals(updateEvent.isMeMessage!);
+        ..isMeMessage.equals(updateEvent.isMeMessage!)
+        ..editState.equals(MessageEditState.edited);
     });
 
     test('ignore when message unknown', () async {
@@ -269,6 +271,80 @@ void main() {
     test('rendering-only update does not change timestamp (for old server versions)', () async {
       await checkRenderingOnly(legacy: true);
     });
+
+    group('Handle message edit state update', () {
+      final message = eg.streamMessage();
+      final otherMessage = eg.streamMessage();
+
+      Future<void> sendEvent(Message message, UpdateMessageEvent event) async {
+        await prepare();
+        await prepareMessages([message, otherMessage]);
+
+        await store.handleEvent(event);
+        checkNotifiedOnce();
+      }
+
+      test('message not moved update', () async {
+        await sendEvent(message, eg.updateMessageEditEvent(message));
+        check(store).messages[message.id].editState.equals(MessageEditState.edited);
+        check(store).messages[otherMessage.id].editState.equals(MessageEditState.none);
+      });
+
+      test('message topic moved update', () async {
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: 'old topic',
+          newTopic:  'new topic',
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.moved)));
+      });
+
+      test('message topic resolved update', () async {
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: 'new topic',
+          newTopic:  '✔ new topic',
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.none)));
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: '✔ new topic',
+          newTopic:  'new topic 2',
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.moved)));
+      });
+
+      test('message topic unresolved update', () async {
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: '✔ new topic',
+          newTopic:  'new topic',
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.none)));
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: 'new topic',
+          newTopic:  '✔ new topic 2',
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.moved)));
+      });
+
+      test('message stream moved update', () async {
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: 'topic',
+          newTopic: 'topic',
+          newStreamId:  20,
+        ));
+        check(store).messages.values.every(((message) => message.editState.equals(MessageEditState.moved)));
+      });
+
+      test('message is both moved and updated', () async {
+        await sendEvent(message, eg.updateMessageMoveEvent([message, otherMessage],
+          origTopic: 'topic',
+          newTopic: 'topic',
+          origContent: 'old content',
+          origRenderedContent: 'old content',
+          newStreamId:  20,
+        ));
+        check(store).messages[message.id].editState.equals(MessageEditState.edited);
+        check(store).messages[otherMessage.id].editState.equals(MessageEditState.moved);
+      });
+    });
   });
 
   group('handleUpdateMessageFlagsEvent', () {