1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using ArcaneLibs.Collections;
using LibMatrix.EventTypes.Spec.State;
using LibMatrix.Helpers;
using LibMatrix.Responses;
using MatrixUtils.Abstractions;
using Microsoft.Extensions.Logging;
using ModerationClient.Services;
namespace ModerationClient.ViewModels;
public partial class ClientViewModel : ViewModelBase {
public ClientViewModel(ILogger<ClientViewModel> logger, MatrixAuthenticationService authService, CommandLineConfiguration cfg) {
_logger = logger;
_authService = authService;
_cfg = cfg;
DisplayedSpaces.Add(_allRoomsNode = new AllRoomsSpaceNode(this));
_ = Task.Run(Run);
}
private readonly ILogger<ClientViewModel> _logger;
private readonly MatrixAuthenticationService _authService;
private readonly CommandLineConfiguration _cfg;
private SpaceNode? _currentSpace;
private readonly SpaceNode _allRoomsNode;
private string _status = "Loading...";
public ObservableCollection<SpaceNode> DisplayedSpaces { get; } = [];
public ObservableDictionary<string, RoomNode> AllRooms { get; } = new();
public SpaceNode CurrentSpace {
get => _currentSpace ?? _allRoomsNode;
set => SetProperty(ref _currentSpace, value);
}
public string Status {
get => _status + " " + DateTime.Now;
set => SetProperty(ref _status, value);
}
public async Task Run() {
Status = "Interrupted.";
return;
Status = "Doing initial sync...";
var sh = new SyncStateResolver(_authService.Homeserver, _logger, storageProvider: new FileStorageProvider(Path.Combine(_cfg.ProfileDirectory, "syncCache")));
// var res = await sh.SyncAsync();
//await sh.OptimiseStore();
while (true) {
// Status = "Syncing...";
var res = await sh.ContinueAsync();
Status = $"Processing sync... {res.next.NextBatch}";
await ApplySpaceChanges(res.next);
//OnPropertyChanged(nameof(CurrentSpace));
//OnPropertyChanged(nameof(CurrentSpace.ChildRooms));
// Console.WriteLine($"mow A={AllRooms.Count}|D={DisplayedSpaces.Count}");
// for (int i = 0; i < GC.MaxGeneration; i++) {
// GC.Collect(i, GCCollectionMode.Forced, blocking: true);
// GC.WaitForPendingFinalizers();
// }
Status = "Syncing...";
}
}
private async Task ApplySpaceChanges(SyncResponse newSync) {
List<Task> tasks = [];
foreach (var room in newSync.Rooms?.Join ?? []) {
if (!AllRooms.ContainsKey(room.Key)) {
AllRooms.Add(room.Key, new RoomNode { Name = "Loading..." });
}
if (room.Value.State?.Events is not null) {
var nameEvent = room.Value.State!.Events!.FirstOrDefault(x => x.Type == "m.room.name" && x.StateKey == "");
AllRooms[room.Key].Name = (nameEvent?.TypedContent as RoomNameEventContent)?.Name ?? "";
if (string.IsNullOrWhiteSpace(AllRooms[room.Key].Name)) {
AllRooms[room.Key].Name = "Loading...";
tasks.Add(_authService.Homeserver!.GetRoom(room.Key).GetNameOrFallbackAsync().ContinueWith(r => AllRooms[room.Key].Name = r.Result));
}
}
}
await Task.WhenAll(tasks);
return;
List<string> handledRoomIds = [];
var spaces = newSync.Rooms?.Join?
.Where(x => x.Value.State?.Events is not null)
.Where(x => x.Value.State!.Events!.Any(y => y.Type == "m.room.create" && (y.TypedContent as RoomCreateEventContent)!.Type == "m.space"))
.ToList();
Console.WriteLine("spaces: " + spaces.Count);
var nonRootSpaces = spaces
.Where(x => spaces.Any(x => x.Value.State!.Events!.Any(y => y.Type == "m.space.child" && y.StateKey == x.Key)))
.ToDictionary();
var rootSpaces = spaces
.Where(x => !nonRootSpaces.ContainsKey(x.Key))
.ToDictionary();
// var rootSpaces = spaces
// .Where(x=>!spaces.Any(x=>x.Value.State!.Events!.Any(y=>y.Type == "m.space.child" && y.StateKey == x.Key)))
// .ToList();
foreach (var (roomId, room) in rootSpaces) {
var space = new SpaceNode { Name = (room.State!.Events!.First(x => x.Type == "m.room.name")!.TypedContent as RoomNameEventContent).Name };
DisplayedSpaces.Add(space);
handledRoomIds.Add(roomId);
}
}
}
public class SpaceNode : RoomNode {
public ObservableCollection<SpaceNode> ChildSpaces { get; set; } = [];
public ObservableCollection<RoomNode> ChildRooms { get; set; } = [];
}
public class RoomNode {
public string Name { get; set; }
}
// implementation details
public class AllRoomsSpaceNode : SpaceNode {
public AllRoomsSpaceNode(ClientViewModel vm) {
Name = "All rooms";
vm.AllRooms.CollectionChanged += (_, args) => {
switch (args.Action) {
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Replace: {
foreach (var room in args.NewItems?.Cast<KeyValuePair<string, RoomNode>>() ?? []) ChildRooms.Add(room.Value);
foreach (var room in args.OldItems?.Cast<KeyValuePair<string, RoomNode>>() ?? []) ChildRooms.Remove(room.Value);
break;
}
case NotifyCollectionChangedAction.Reset: {
ChildSpaces.Clear();
ChildRooms.Clear();
break;
}
}
};
}
}
|
