api: Add route setTypingStatus.

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

Author: PIG208

lib/api/model/events.dart

@@ -936,7 +936,9 @@ class TypingEvent extends Event {
 @JsonEnum(fieldRename: FieldRename.snake)
 enum TypingOp {
   start,
-  stop
+  stop;
+
+  String toJson() => _$TypingOpEnumMap[this]!;
 }
 
 /// A Zulip event of type `reaction`, with op `add` or `remove`.

lib/api/route/messages.dart

@@ -1,5 +1,6 @@
 import 'package:json_annotation/json_annotation.dart';
 
+import '../../model/narrow.dart';
 import '../core.dart';
 import '../exception.dart';
 import '../model/model.dart';
@@ -221,6 +222,15 @@ Future<SendMessageResult> sendMessage(
 /// This is either a [StreamDestination] or a [DmDestination].
 sealed class MessageDestination {
   const MessageDestination();
+
+  factory MessageDestination.fromSendableNarrow(SendableNarrow narrow) {
+    switch (narrow) {
+      case TopicNarrow():
+        return StreamDestination(narrow.streamId, narrow.topic);
+      case DmNarrow():
+        return DmDestination(userIds: narrow.allRecipientIds);
+    }
+  }
 }
 
 /// A conversation in a stream, for specifying to [sendMessage].

lib/api/route/typing.dart

@@ -0,0 +1,26 @@
+import '../core.dart';
+import '../model/events.dart';
+import 'messages.dart';
+
+
+/// https://zulip.com/api/set-typing-status
+Future<void> setTypingStatus(ApiConnection connection, {
+  required TypingOp op,
+  required MessageDestination destination,
+}) {
+  final supportsTypeChannel = connection.zulipFeatureLevel! >= 248; // TODO(server-9)
+  switch (destination) {
+    case StreamDestination():
+      return connection.post('setTypingStatus', (_) {}, 'typing', {
+        'type': RawParameter((supportsTypeChannel) ? 'channel' : 'stream'),
+        'op': RawParameter(op.toJson()),
+        'stream_id': destination.streamId,
+        'topic': RawParameter(destination.topic),
+      });
+    case DmDestination():
+      return connection.post('setTypingStatus', (_) {}, 'typing', {
+        'op': RawParameter(op.toJson()),
+        'to': destination.userIds,
+      });
+  }
+}

test/api/route/typing_test.dart

@@ -0,0 +1,81 @@
+import 'dart:convert';
+
+import 'package:http/http.dart' as http;
+import 'package:checks/checks.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:zulip/api/model/events.dart';
+import 'package:zulip/api/route/messages.dart';
+import 'package:zulip/api/route/typing.dart';
+
+import '../../stdlib_checks.dart';
+import '../fake_api.dart';
+
+void main() {
+  const streamId = 123;
+  const topic = 'topic';
+  const userIds = [101, 102, 103];
+
+  Future<void> checkSetTypingStatus(FakeApiConnection connection, {
+    required TypingOp op,
+    required MessageDestination destination,
+    required Map<String, String> expectedBodyFields,
+  }) async {
+    connection.prepare(json: {});
+    await setTypingStatus(connection,
+      op: op,
+      destination: destination,
+    );
+    check(connection.lastRequest).isA<http.Request>()
+      ..method.equals('POST')
+      ..url.path.equals('/api/v1/typing')
+      ..bodyFields.deepEquals(expectedBodyFields);
+  }
+
+  final testCases = [
+    (TypingOp.start, 'start'),
+    (TypingOp.stop,  'stop' ),
+  ];
+
+  for (final (op, expectedOp) in testCases) {
+    test('send typing status $expectedOp to topic', () {
+      return FakeApiConnection.with_((connection) async {
+        checkSetTypingStatus(connection,
+          op: op,
+          destination: const StreamDestination(streamId, topic),
+          expectedBodyFields: {
+            'type': 'channel',
+            'op': expectedOp,
+            'stream_id': streamId.toString(),
+            'topic': topic,
+          });
+      });
+    });
+
+    test('send typing status $expectedOp to dm', () {
+      return FakeApiConnection.with_((connection) async {
+        checkSetTypingStatus(connection,
+          op: op,
+          destination: const DmDestination(userIds: userIds),
+          expectedBodyFields: {
+            'op': expectedOp,
+            'to': jsonEncode(userIds),
+          });
+      });
+    });
+  }
+
+  test('use stream on legacy server', () {
+    return FakeApiConnection.with_(zulipFeatureLevel: 247, (connection) async {
+      checkSetTypingStatus(connection,
+        op: TypingOp.start,
+        destination: const StreamDestination(streamId, topic),
+        expectedBodyFields: {
+          'type': 'stream',
+          'op': 'start',
+          'stream_id': streamId.toString(),
+          'topic': topic,
+        },
+      );
+    });
+  });
+}