OpenContacts/lib/models/message.dart
2023-05-12 18:31:05 +02:00

197 lines
No EOL
5.6 KiB
Dart

import 'dart:async';
import 'dart:developer';
import 'package:contacts_plus_plus/clients/api_client.dart';
import 'package:contacts_plus_plus/apis/message_api.dart';
import 'package:contacts_plus_plus/auxiliary.dart';
import 'package:contacts_plus_plus/string_formatter.dart';
import 'package:uuid/uuid.dart';
enum MessageType {
unknown,
text,
sound,
sessionInvite,
object;
static const Map<MessageType, String> _mapper = {
MessageType.text: "Text",
MessageType.sound: "Sound",
MessageType.sessionInvite: "SessionInvite",
MessageType.object: "Object",
};
factory MessageType.fromName(String name) {
return MessageType.values.firstWhere((element) => element.name.toLowerCase() == name.toLowerCase(),
orElse: () => MessageType.unknown,
);
}
String? toName() {
return _mapper[this];
}
}
enum MessageState {
local,
sent,
read,
}
class Message implements Comparable {
final String id;
final String recipientId;
final String senderId;
final MessageType type;
final String content;
final FormatNode formattedContent;
final DateTime sendTime;
final MessageState state;
Message({required this.id, required this.recipientId, required this.senderId, required this.type,
required this.content, required this.sendTime, this.state=MessageState.local})
: formattedContent = FormatNode.fromText(content);
factory Message.fromMap(Map map, {MessageState? withState}) {
final typeString = (map["messageType"] as String?) ?? "";
final type = MessageType.fromName(typeString);
if (type == MessageType.unknown && typeString.isNotEmpty) {
log("Unknown MessageType '$typeString' in response");
}
return Message(
id: map["id"],
recipientId: map["recipientId"],
senderId: map["senderId"],
type: type,
content: map["content"],
sendTime: DateTime.parse(map["sendTime"]),
state: withState ?? (map["readTime"] != null ? MessageState.read : MessageState.local)
);
}
Message copy() => copyWith();
Message copyWith({
String? id,
String? recipientId,
String? senderId,
MessageType? type,
String? content,
DateTime? sendTime,
MessageState? state}) {
return Message(
id: id ?? this.id,
recipientId: recipientId ?? this.recipientId,
senderId: senderId ?? this.senderId,
type: type ?? this.type,
content: content ?? this.content,
sendTime: sendTime ?? this.sendTime,
state: state ?? this.state
);
}
Map toMap() => {
"id": id,
"recipientId": recipientId,
"senderId": senderId,
"ownerId": senderId,
"messageType": type.toName(),
"content": content,
"sendTime": sendTime.toIso8601String(),
};
static String generateId() {
return "MSG-${const Uuid().v4()}";
}
@override
int compareTo(other) {
return other.sendTime.compareTo(sendTime);
}
}
class MessageCache {
final List<Message> _messages = [];
final ApiClient _apiClient;
final String _userId;
Future? currentOperation;
List<Message> get messages => _messages;
MessageCache({required ApiClient apiClient, required String userId}) : _apiClient = apiClient, _userId = userId;
/// Adds a message to the cache, ensuring integrity of the message cache.
/// Returns true if the message was inserted into the cache and false if an existing message was overwritten.
bool addMessage(Message message) {
final existingIdx = _messages.indexWhere((element) => element.id == message.id);
if (existingIdx == -1) {
_messages.add(message);
_ensureIntegrity();
} else {
_messages[existingIdx] = message;
_messages.sort(); // Overwriting can't create duplicates, so we just need to sort.
}
return existingIdx == -1;
}
/// Sets the state of an existing message by id.
/// Returns true if a message with the specified id exists and was modified and false if the message doesn't exist.
bool setMessageState(String messageId, MessageState state) {
final messageIdx = _messages.indexWhere((element) => element.id == messageId);
if (messageIdx == -1) return false;
_messages[messageIdx] = _messages[messageIdx].copyWith(state: state);
return true;
}
Future<MessageCache> loadOlderMessages() async {
// final olderMessages = await MessageApi.getUserMessages(_apiClient, userId: _userId, fromTime: _messages.last.sendTime);
// Loading older messages is not conveniently supported by the Neos api from what I can tell.
// We could just extend the amount of messages loaded from today, but that gets extremely inefficient very quickly.
// For now, just pretend there are no more messages.
final olderMessages = <Message>[];
_messages.addAll(olderMessages);
_ensureIntegrity();
return this; //lmao
}
Future<void> loadMessages() async {
final messages = await MessageApi.getUserMessages(_apiClient, userId: _userId);
_messages.addAll(messages);
_ensureIntegrity();
}
void _ensureIntegrity() {
_messages.sort();
_messages.unique((element) => element.id);
}
}
class AudioClipContent {
final String id;
final String assetUri;
AudioClipContent({required this.id, required this.assetUri});
factory AudioClipContent.fromMap(Map map) {
return AudioClipContent(
id: map["id"],
assetUri: map["assetUri"],
);
}
}
class MarkReadBatch {
final String senderId;
final List<String> ids;
final DateTime readTime;
MarkReadBatch({required this.senderId, required this.ids, required this.readTime});
Map toMap() {
return {
"senderId": senderId,
"ids": ids,
"readTime": readTime.toUtc().toIso8601String(),
};
}
}