Line data    Source code

       1             : /* MIT License
       2             : *
       3             : * Copyright (C) 2019, 2020, 2021 Famedly GmbH
       4             : *
       5             : * Permission is hereby granted, free of charge, to any person obtaining a copy
       6             : * of this software and associated documentation files (the "Software"), to deal
       7             : * in the Software without restriction, including without limitation the rights
       8             : * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
       9             : * copies of the Software, and to permit persons to whom the Software is
      10             : * furnished to do so, subject to the following conditions:
      11             : *
      12             : * The above copyright notice and this permission notice shall be included in all
      13             : * copies or substantial portions of the Software.
      14             : *
      15             : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      16             : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      17             : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      18             : * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      19             : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      20             : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      21             : * SOFTWARE.
      22             : */
      23             : 
      24             : import 'package:matrix/matrix_api_lite.dart';
      25             : 
      26             : class SyncUpdate {
      27             :   String nextBatch;
      28             :   RoomsUpdate? rooms;
      29             :   List<Presence>? presence;
      30             :   List<BasicEvent>? accountData;
      31             :   List<BasicEventWithSender>? toDevice;
      32             :   DeviceListsUpdate? deviceLists;
      33             :   Map<String, int>? deviceOneTimeKeysCount;
      34             :   List<String>? deviceUnusedFallbackKeyTypes;
      35             : 
      36          17 :   SyncUpdate({
      37             :     required this.nextBatch,
      38             :     this.rooms,
      39             :     this.presence,
      40             :     this.accountData,
      41             :     this.toDevice,
      42             :     this.deviceLists,
      43             :     this.deviceOneTimeKeysCount,
      44             :     this.deviceUnusedFallbackKeyTypes,
      45             :   });
      46             : 
      47          35 :   SyncUpdate.fromJson(Map<String, Object?> json)
      48          35 :       : nextBatch = json.tryGet<String>('next_batch') ?? '',
      49          35 :         rooms = (() {
      50          35 :           final temp = json.tryGetMap<String, Object?>('rooms');
      51          35 :           return temp != null ? RoomsUpdate.fromJson(temp) : null;
      52          35 :         }()),
      53             :         presence = json
      54          70 :             .tryGetMap<String, List<Object?>>('presence')?['events']
      55         105 :             ?.map((i) => Presence.fromJson(i as Map<String, Object?>))
      56          35 :             .toList(),
      57             :         accountData = json
      58          70 :             .tryGetMap<String, List<Object?>>('account_data')?['events']
      59         105 :             ?.map((i) => BasicEvent.fromJson(i as Map<String, Object?>))
      60          35 :             .toList(),
      61             :         toDevice = json
      62          70 :             .tryGetMap<String, List<Object?>>('to_device')?['events']
      63          35 :             ?.map(
      64          70 :               (i) => BasicEventWithSender.fromJson(i as Map<String, Object?>),
      65             :             )
      66          35 :             .toList(),
      67          35 :         deviceLists = (() {
      68          35 :           final temp = json.tryGetMap<String, Object?>('device_lists');
      69          33 :           return temp != null ? DeviceListsUpdate.fromJson(temp) : null;
      70          35 :         }()),
      71             :         deviceOneTimeKeysCount =
      72          35 :             json.tryGetMap<String, int>('device_one_time_keys_count'),
      73             :         deviceUnusedFallbackKeyTypes =
      74          35 :             json.tryGetList<String>('device_unused_fallback_key_types') ??
      75          35 :                 json.tryGetList<String>(
      76             :                   'org.matrix.msc2732.device_unused_fallback_key_types',
      77             :                 );
      78             : 
      79           0 :   Map<String, Object?> toJson() {
      80           0 :     final data = <String, Object?>{};
      81           0 :     data['next_batch'] = nextBatch;
      82           0 :     if (rooms != null) {
      83           0 :       data['rooms'] = rooms!.toJson();
      84             :     }
      85           0 :     if (presence != null) {
      86           0 :       data['presence'] = {
      87           0 :         'events': presence!.map((i) => i.toJson()).toList(),
      88             :       };
      89             :     }
      90           0 :     if (accountData != null) {
      91           0 :       data['account_data'] = {
      92           0 :         'events': accountData!.map((i) => i.toJson()).toList(),
      93             :       };
      94             :     }
      95           0 :     if (toDevice != null) {
      96           0 :       data['to_device'] = {
      97           0 :         'events': toDevice!.map((i) => i.toJson()).toList(),
      98             :       };
      99             :     }
     100           0 :     if (deviceLists != null) {
     101           0 :       data['device_lists'] = deviceLists!.toJson();
     102             :     }
     103           0 :     if (deviceOneTimeKeysCount != null) {
     104           0 :       data['device_one_time_keys_count'] = deviceOneTimeKeysCount;
     105             :     }
     106           0 :     if (deviceUnusedFallbackKeyTypes != null) {
     107           0 :       data['device_unused_fallback_key_types'] = deviceUnusedFallbackKeyTypes;
     108           0 :       data['org.matrix.msc2732.device_unused_fallback_key_types'] =
     109           0 :           deviceUnusedFallbackKeyTypes;
     110             :     }
     111             :     return data;
     112             :   }
     113             : }
     114             : 
     115             : class RoomsUpdate {
     116             :   Map<String, JoinedRoomUpdate>? join;
     117             :   Map<String, InvitedRoomUpdate>? invite;
     118             :   Map<String, LeftRoomUpdate>? leave;
     119             :   Map<String, KnockRoomUpdate>? knock;
     120             : 
     121          15 :   RoomsUpdate({
     122             :     this.join,
     123             :     this.invite,
     124             :     this.leave,
     125             :     this.knock,
     126             :   });
     127             : 
     128          35 :   RoomsUpdate.fromJson(Map<String, Object?> json) {
     129         105 :     join = json.tryGetMap<String, Object?>('join')?.catchMap(
     130          35 :           (k, v) =>
     131          70 :               MapEntry(k, JoinedRoomUpdate.fromJson(v as Map<String, Object?>)),
     132             :         );
     133         105 :     invite = json.tryGetMap<String, Object?>('invite')?.catchMap(
     134          70 :           (k, v) => MapEntry(
     135             :             k,
     136          35 :             InvitedRoomUpdate.fromJson(v as Map<String, Object?>),
     137             :           ),
     138             :         );
     139         105 :     leave = json.tryGetMap<String, Object?>('leave')?.catchMap(
     140          35 :           (k, v) =>
     141          70 :               MapEntry(k, LeftRoomUpdate.fromJson(v as Map<String, Object?>)),
     142             :         );
     143          70 :     knock = json.tryGetMap<String, Object?>('knock')?.catchMap(
     144           0 :           (k, v) =>
     145           0 :               MapEntry(k, KnockRoomUpdate.fromJson(v as Map<String, Object?>)),
     146             :         );
     147             :   }
     148             : 
     149           0 :   Map<String, Object?> toJson() {
     150           0 :     final data = <String, Object?>{};
     151           0 :     if (join != null) {
     152           0 :       data['join'] = join!.map((k, v) => MapEntry(k, v.toJson()));
     153             :     }
     154           0 :     if (invite != null) {
     155           0 :       data['invite'] = invite!.map((k, v) => MapEntry(k, v.toJson()));
     156             :     }
     157           0 :     if (leave != null) {
     158           0 :       data['leave'] = leave!.map((k, v) => MapEntry(k, v.toJson()));
     159             :     }
     160           0 :     if (knock != null) {
     161           0 :       data['knock'] = knock!.map((k, v) => MapEntry(k, v.toJson()));
     162             :     }
     163             :     return data;
     164             :   }
     165             : }
     166             : 
     167             : abstract class SyncRoomUpdate {}
     168             : 
     169             : class JoinedRoomUpdate extends SyncRoomUpdate {
     170             :   RoomSummary? summary;
     171             :   List<MatrixEvent>? state;
     172             :   TimelineUpdate? timeline;
     173             :   List<BasicRoomEvent>? ephemeral;
     174             :   List<BasicRoomEvent>? accountData;
     175             :   UnreadNotificationCounts? unreadNotifications;
     176             : 
     177          14 :   JoinedRoomUpdate({
     178             :     this.summary,
     179             :     this.state,
     180             :     this.timeline,
     181             :     this.ephemeral,
     182             :     this.accountData,
     183             :     this.unreadNotifications,
     184             :   });
     185             : 
     186          36 :   JoinedRoomUpdate.fromJson(Map<String, Object?> json)
     187          36 :       : summary = json.tryGetFromJson('summary', RoomSummary.fromJson),
     188             :         state = json
     189          71 :             .tryGetMap<String, List<Object?>>('state')?['events']
     190         101 :             ?.map((i) => MatrixEvent.fromJson(i as Map<String, Object?>))
     191          35 :             .toList(),
     192          36 :         timeline = json.tryGetFromJson('timeline', TimelineUpdate.fromJson),
     193             :         ephemeral = json
     194          71 :             .tryGetMap<String, List<Object?>>('ephemeral')?['events']
     195         101 :             ?.map((i) => BasicRoomEvent.fromJson(i as Map<String, Object?>))
     196          35 :             .toList(),
     197             :         accountData = json
     198          71 :             .tryGetMap<String, List<Object?>>('account_data')?['events']
     199         101 :             ?.map((i) => BasicRoomEvent.fromJson(i as Map<String, Object?>))
     200          35 :             .toList(),
     201          36 :         unreadNotifications = json.tryGetFromJson(
     202             :           'unread_notifications',
     203             :           UnreadNotificationCounts.fromJson,
     204             :         );
     205             : 
     206           0 :   Map<String, Object?> toJson() {
     207           0 :     final data = <String, Object?>{};
     208           0 :     if (summary != null) {
     209           0 :       data['summary'] = summary!.toJson();
     210             :     }
     211           0 :     if (state != null) {
     212           0 :       data['state'] = {
     213           0 :         'events': state!.map((i) => i.toJson()).toList(),
     214             :       };
     215             :     }
     216           0 :     if (timeline != null) {
     217           0 :       data['timeline'] = timeline!.toJson();
     218             :     }
     219           0 :     if (ephemeral != null) {
     220           0 :       data['ephemeral'] = {
     221           0 :         'events': ephemeral!.map((i) => i.toJson()).toList(),
     222             :       };
     223             :     }
     224           0 :     if (accountData != null) {
     225           0 :       data['account_data'] = {
     226           0 :         'events': accountData!.map((i) => i.toJson()).toList(),
     227             :       };
     228             :     }
     229           0 :     if (unreadNotifications != null) {
     230           0 :       data['unread_notifications'] = unreadNotifications!.toJson();
     231             :     }
     232             :     return data;
     233             :   }
     234             : }
     235             : 
     236             : class InvitedRoomUpdate extends SyncRoomUpdate {
     237             :   List<StrippedStateEvent>? inviteState;
     238             : 
     239           3 :   InvitedRoomUpdate({this.inviteState});
     240             : 
     241          35 :   InvitedRoomUpdate.fromJson(Map<String, Object?> json)
     242             :       : inviteState = json
     243          70 :             .tryGetMap<String, List<Object?>>('invite_state')?['events']
     244         101 :             ?.map((i) => StrippedStateEvent.fromJson(i as Map<String, Object?>))
     245          35 :             .toList();
     246             : 
     247           0 :   Map<String, Object?> toJson() {
     248           0 :     final data = <String, Object?>{};
     249           0 :     if (inviteState != null) {
     250           0 :       data['invite_state'] = {
     251           0 :         'events': inviteState!.map((i) => i.toJson()).toList(),
     252             :       };
     253             :     }
     254             :     return data;
     255             :   }
     256             : }
     257             : 
     258             : class KnockRoomUpdate extends SyncRoomUpdate {
     259             :   List<StrippedStateEvent>? knockState;
     260             : 
     261           0 :   KnockRoomUpdate({this.knockState});
     262             : 
     263           0 :   KnockRoomUpdate.fromJson(Map<String, Object?> json)
     264             :       : knockState = json
     265           0 :             .tryGetMap<String, List<Object?>>('knock_state')?['events']
     266           0 :             ?.map((i) => StrippedStateEvent.fromJson(i as Map<String, Object?>))
     267           0 :             .toList();
     268             : 
     269           0 :   Map<String, Object?> toJson() {
     270           0 :     final data = <String, Object?>{};
     271           0 :     if (knockState != null) {
     272           0 :       data['knock_state'] = {
     273           0 :         'events': knockState!.map((i) => i.toJson()).toList(),
     274             :       };
     275             :     }
     276             :     return data;
     277             :   }
     278             : }
     279             : 
     280             : class LeftRoomUpdate extends SyncRoomUpdate {
     281             :   List<MatrixEvent>? state;
     282             :   TimelineUpdate? timeline;
     283             :   List<BasicRoomEvent>? accountData;
     284             : 
     285           3 :   LeftRoomUpdate({
     286             :     this.state,
     287             :     this.timeline,
     288             :     this.accountData,
     289             :   });
     290             : 
     291          35 :   LeftRoomUpdate.fromJson(Map<String, Object?> json)
     292             :       : state = json
     293          68 :             .tryGetMap<String, List<Object?>>('state')?['events']
     294          99 :             ?.map((i) => MatrixEvent.fromJson(i as Map<String, Object?>))
     295          33 :             .toList(),
     296          35 :         timeline = json.tryGetFromJson('timeline', TimelineUpdate.fromJson),
     297             :         accountData = json
     298          68 :             .tryGetMap<String, List<Object?>>('account_data')?['events']
     299          99 :             ?.map((i) => BasicRoomEvent.fromJson(i as Map<String, Object?>))
     300          33 :             .toList();
     301             : 
     302           0 :   Map<String, Object?> toJson() {
     303           0 :     final data = <String, Object?>{};
     304           0 :     if (state != null) {
     305           0 :       data['state'] = {
     306           0 :         'events': state!.map((i) => i.toJson()).toList(),
     307             :       };
     308             :     }
     309           0 :     if (timeline != null) {
     310           0 :       data['timeline'] = timeline!.toJson();
     311             :     }
     312           0 :     if (accountData != null) {
     313           0 :       data['account_data'] = {
     314           0 :         'events': accountData!.map((i) => i.toJson()).toList(),
     315             :       };
     316             :     }
     317             :     return data;
     318             :   }
     319             : }
     320             : 
     321             : class TimelineUpdate {
     322             :   List<MatrixEvent>? events;
     323             :   bool? limited;
     324             :   String? prevBatch;
     325             : 
     326          15 :   TimelineUpdate({
     327             :     this.events,
     328             :     this.limited,
     329             :     this.prevBatch,
     330             :   });
     331             : 
     332          35 :   TimelineUpdate.fromJson(Map<String, Object?> json)
     333             :       : events = json
     334          35 :             .tryGetList<Map<String, Object?>>('events')
     335         101 :             ?.map((v) => MatrixEvent.fromJson(v))
     336          35 :             .toList(),
     337          35 :         limited = json.tryGet<bool>('limited'),
     338          35 :         prevBatch = json.tryGet<String>('prev_batch');
     339             : 
     340           0 :   Map<String, Object?> toJson() {
     341           0 :     final data = <String, Object?>{};
     342           0 :     if (events != null) {
     343           0 :       data['events'] = events!.map((i) => i.toJson()).toList();
     344             :     }
     345           0 :     if (limited != null) {
     346           0 :       data['limited'] = limited;
     347             :     }
     348           0 :     if (prevBatch != null) {
     349           0 :       data['prev_batch'] = prevBatch;
     350             :     }
     351             :     return data;
     352             :   }
     353             : }
     354             : 
     355             : class UnreadNotificationCounts {
     356             :   int? highlightCount;
     357             :   int? notificationCount;
     358             : 
     359           2 :   UnreadNotificationCounts({
     360             :     this.notificationCount,
     361             :     this.highlightCount,
     362             :   });
     363             : 
     364          35 :   UnreadNotificationCounts.fromJson(Map<String, Object?> json)
     365          35 :       : highlightCount = json.tryGet<int>('highlight_count'),
     366          35 :         notificationCount = json.tryGet<int>('notification_count');
     367             : 
     368           0 :   Map<String, Object?> toJson() {
     369           0 :     final data = <String, Object?>{};
     370           0 :     if (highlightCount != null) {
     371           0 :       data['highlight_count'] = highlightCount;
     372             :     }
     373           0 :     if (notificationCount != null) {
     374           0 :       data['notification_count'] = notificationCount;
     375             :     }
     376             :     return data;
     377             :   }
     378             : }
     379             : 
     380             : class DeviceListsUpdate {
     381             :   List<String>? changed;
     382             :   List<String>? left;
     383             : 
     384           0 :   DeviceListsUpdate({
     385             :     this.changed,
     386             :     this.left,
     387             :   });
     388             : 
     389          33 :   DeviceListsUpdate.fromJson(Map<String, Object?> json)
     390          33 :       : changed = json.tryGetList<String>('changed') ?? [],
     391          33 :         left = json.tryGetList<String>('left') ?? [];
     392             : 
     393           0 :   Map<String, Object?> toJson() {
     394           0 :     final data = <String, Object?>{};
     395           0 :     if (changed != null) {
     396           0 :       data['changed'] = changed;
     397             :     }
     398           0 :     if (left != null) {
     399           0 :       data['left'] = left;
     400             :     }
     401             :     return data;
     402             :   }
     403             : }