message: Update editState on events.

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;
+    if (event.origContent != null) {
+      // The message is guaranteed to be edited.
+      // See also: https://zulip.com/api/get-events#update_message
+      message.editState = MessageEditState.edited;
+    }
     if (event.renderedContent != null) {
       assert(message.contentType == 'text/html',
         "Message contentType was ${message.contentType}; expected text/html.");
@@ -168,10 +173,26 @@ class MessageStoreImpl with MessageStore {
       return;
     }
 
-    // final newStreamId = event.newStreamId; // null if topic-only move
-    // final newTopic = event.newTopic!;
+    final newTopic = event.newTopic!;
+    final newChannelId = event.newStreamId; // null if topic-only move
+
+    if (newChannelId == null
+        && MessageEditState.topicMoveWasResolveOrUnresolve(event.origTopic!, newTopic)) {
+      // The topic was only resolved/unresolved.
+      // No change to the messages' editState.
+      return;
+    }
+
     // 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

@@ -437,6 +437,38 @@ UpdateMessageEvent updateMessageEditEvent(
   );
 }
 
+UpdateMessageEvent updateMessageMoveEvent(
+  List<Message> messages, {
+  int? newStreamId,
+  String? origTopic,
+  String? newTopic,
+  String? origContent,
+  String? newContent,
+}) {
+  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: origContent,
+    content: newContent,
+    renderedContent: newContent,
+    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,79 @@ 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)));
+      });
+
+      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)));
+      });
+
+      test('message topic both resolved and edited update', () async {
+        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 both unresolved and edited update', () async {
+        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',
+          newStreamId:  20,
+          origContent: 'old content',
+          newContent: 'new content'));
+        check(store).messages[message.id].editState.equals(MessageEditState.edited);
+        check(store).messages[otherMessage.id].editState.equals(MessageEditState.moved);
+      });
+    });
   });
 
   group('handleUpdateMessageFlagsEvent', () {