525 lines
14 KiB
TypeScript
525 lines
14 KiB
TypeScript
// this file is responsible for managing chats.
|
|
|
|
import {
|
|
checkMatchesObjectStructure,
|
|
DATA_VERSION,
|
|
ValidObject,
|
|
} from "../Utility/typeSafety";
|
|
import FileModel, { FileContent } from "../Files/fileModel";
|
|
import {
|
|
HandlerManager,
|
|
createTimestamp,
|
|
localeCompare,
|
|
parse,
|
|
parseValidObject,
|
|
stringify,
|
|
} from "../Utility/utility";
|
|
import StorageModel, {
|
|
StorageModelSubPath,
|
|
filePaths,
|
|
} from "../Global/storageModel";
|
|
import { decryptString, encryptString } from "../Utility/crypto";
|
|
|
|
import ChatListModel from "./chatListModel";
|
|
import { Color } from "../../colors";
|
|
import ConnectionModel from "../Global/connectionModel";
|
|
import SettingsModel from "../Global/settingsModel";
|
|
import { v4 } from "uuid";
|
|
|
|
export default class ChatModel {
|
|
connectionModel: ConnectionModel;
|
|
storageModel: StorageModel;
|
|
settingsModel: SettingsModel;
|
|
chatListModel: ChatListModel;
|
|
|
|
fileModel: FileModel;
|
|
|
|
// data
|
|
id: string;
|
|
info: ChatInfo;
|
|
color: Color;
|
|
|
|
chatMessageHandlerManager: HandlerManager<ChatMessage> =
|
|
new HandlerManager();
|
|
reactionHandlerManager: HandlerManager<ChatMessageReaction> =
|
|
new HandlerManager();
|
|
|
|
get secondaryChannels(): string[] {
|
|
return this.info.secondaryChannels.sort(localeCompare);
|
|
}
|
|
|
|
// paths
|
|
getBasePath = (): string[] => {
|
|
return StorageModel.getPath(
|
|
StorageModelSubPath.Chat,
|
|
filePaths.chat.chatBase(this.id),
|
|
);
|
|
};
|
|
|
|
getInfoPath = (): string[] => {
|
|
return StorageModel.getPath(
|
|
StorageModelSubPath.Chat,
|
|
filePaths.chat.info(this.id),
|
|
);
|
|
};
|
|
|
|
getColorPath = (): string[] => {
|
|
return StorageModel.getPath(
|
|
StorageModelSubPath.Chat,
|
|
filePaths.chat.color(this.id),
|
|
);
|
|
};
|
|
|
|
getMessageDirPath = (): string[] => {
|
|
return StorageModel.getPath(
|
|
StorageModelSubPath.Chat,
|
|
filePaths.chat.messages(this.id),
|
|
);
|
|
};
|
|
|
|
getMessagePath = (id: string): string[] => {
|
|
return [...this.getMessageDirPath(), id];
|
|
};
|
|
|
|
getReactionDirPath = (): string[] => {
|
|
return StorageModel.getPath(
|
|
StorageModelSubPath.Chat,
|
|
filePaths.chat.reactions(this.id),
|
|
);
|
|
};
|
|
|
|
getReactionPath = (id: string): string[] => {
|
|
return [...this.getReactionDirPath(), id];
|
|
};
|
|
|
|
// handlers
|
|
handleMessage = (body: string): void => {
|
|
const chatMessage: ChatMessage | null = parseValidObject(
|
|
body,
|
|
ChatMessageReference,
|
|
);
|
|
if (chatMessage == null) return;
|
|
|
|
chatMessage.status = ChatMessageStatus.Received;
|
|
|
|
this.addMessage(chatMessage);
|
|
this.setReadStatus(true);
|
|
};
|
|
|
|
handleReaction = (reaction: ChatMessageReaction | any): void => {
|
|
if (
|
|
!checkMatchesObjectStructure(reaction, ChatMessageReactionReference)
|
|
)
|
|
return;
|
|
const reactionPath: string[] = this.getReactionPath(reaction.fileId);
|
|
|
|
if (reaction.isDeleting == true) {
|
|
this.storageModel.remove(reactionPath);
|
|
} else {
|
|
this.storageModel.writeStringifiable(reactionPath, reaction);
|
|
}
|
|
this.reactionHandlerManager.trigger(reaction);
|
|
|
|
};
|
|
|
|
handleMessageSent = (chatMessage: ChatMessage): void => {
|
|
chatMessage.status = ChatMessageStatus.Sent;
|
|
this.addMessage(chatMessage);
|
|
};
|
|
|
|
// settings
|
|
setPrimaryChannel = (primaryChannel: string): void => {
|
|
this.info.primaryChannel = primaryChannel;
|
|
this.storeInfo();
|
|
this.subscribe();
|
|
};
|
|
|
|
setSecondaryChannels = (secondaryChannels: string[]): void => {
|
|
this.info.secondaryChannels = secondaryChannels;
|
|
this.storeInfo();
|
|
};
|
|
|
|
setEncryptionKey = (key: string): void => {
|
|
this.info.encryptionKey = key;
|
|
this.storeInfo();
|
|
};
|
|
|
|
setColor = (color: Color): void => {
|
|
this.color = color;
|
|
this.storeColor();
|
|
};
|
|
|
|
// messaging
|
|
addMessage = async (chatMessage: ChatMessage): Promise<void> => {
|
|
await this.decryptMessage(chatMessage);
|
|
|
|
// message
|
|
if (chatMessage.body != "") {
|
|
const messagePath: string[] = this.getMessagePath(chatMessage.id);
|
|
this.storageModel.writeStringifiable(messagePath, chatMessage);
|
|
this.chatMessageHandlerManager.trigger(chatMessage);
|
|
}
|
|
|
|
// file
|
|
this.fileModel.handleStringifiedFileContent(
|
|
chatMessage.stringifiedFile,
|
|
);
|
|
};
|
|
|
|
getNameAndChannel = (): [string, string] | false => {
|
|
const senderName = this.settingsModel.username;
|
|
if (senderName == "") return false;
|
|
|
|
const allChannels = [this.info.primaryChannel];
|
|
for (const secondaryChannel of this.info.secondaryChannels) {
|
|
allChannels.push(secondaryChannel);
|
|
}
|
|
|
|
const combinedChannel: string = allChannels.join("/");
|
|
|
|
return [senderName, combinedChannel];
|
|
};
|
|
|
|
sendMessage = async (
|
|
body: string,
|
|
fileContent?: FileContent<string>,
|
|
): Promise<boolean> => {
|
|
const nameAndChannel = this.getNameAndChannel();
|
|
if (nameAndChannel == false) return;
|
|
const [senderName, combinedChannel] = nameAndChannel;
|
|
|
|
const chatMessage: ChatMessage = await ChatModel.createChatMessage(
|
|
combinedChannel,
|
|
senderName,
|
|
this.info.encryptionKey,
|
|
body,
|
|
fileContent,
|
|
);
|
|
|
|
this.addMessage(chatMessage);
|
|
this.connectionModel.sendMessageOrStore(chatMessage);
|
|
return true;
|
|
};
|
|
|
|
decryptMessage = async (chatMessage: ChatMessage): Promise<void> => {
|
|
const decryptedBody: string = await decryptString(
|
|
chatMessage.body,
|
|
this.info.encryptionKey,
|
|
);
|
|
const decryptedFile: string = await decryptString(
|
|
chatMessage.stringifiedFile ?? "",
|
|
this.info.encryptionKey,
|
|
);
|
|
chatMessage.body = decryptedBody;
|
|
chatMessage.stringifiedFile = decryptedFile;
|
|
};
|
|
|
|
sendReaction = async (
|
|
messageId: string,
|
|
content: ReactionSymbols,
|
|
isDeleting?: boolean,
|
|
): Promise<void> => {
|
|
const nameAndChannel = this.getNameAndChannel();
|
|
if (nameAndChannel == false) return;
|
|
const [senderName, combinedChannel] = nameAndChannel;
|
|
|
|
const reaction = ChatModel.createMessageReaction(
|
|
messageId,
|
|
senderName,
|
|
content,
|
|
isDeleting,
|
|
);
|
|
this.sendMessage("", reaction);
|
|
this.handleReaction(reaction);
|
|
};
|
|
|
|
subscribe = (): void => {
|
|
this.connectionModel.addChannel(this.info.primaryChannel);
|
|
};
|
|
|
|
setReadStatus = (hasUnreadMessages: boolean): void => {
|
|
this.info.hasUnreadMessages = hasUnreadMessages;
|
|
this.storeInfo();
|
|
};
|
|
|
|
// storage
|
|
storeInfo = (): void => {
|
|
this.storageModel.writeStringifiable(this.getInfoPath(), this.info);
|
|
};
|
|
|
|
storeColor = (): void => {
|
|
this.storageModel.write(this.getColorPath(), this.color);
|
|
};
|
|
|
|
delete = () => {
|
|
// untrack
|
|
this.chatListModel.untrackChat(this);
|
|
|
|
// delete
|
|
const dirPath: string[] = this.getBasePath();
|
|
this.storageModel.removeRecursively(dirPath);
|
|
};
|
|
|
|
// load
|
|
loadInfo = (): void => {
|
|
const info: ChatInfo | null = this.storageModel.readStringifiable(
|
|
this.getInfoPath(),
|
|
ChatInfoReference,
|
|
);
|
|
if (info != null) {
|
|
this.info = info;
|
|
} else {
|
|
this.info = ChatModel.generateChatInfo("0");
|
|
}
|
|
};
|
|
|
|
loadColor = (): void => {
|
|
const path: string[] = this.getColorPath();
|
|
const color: string | null = this.storageModel.read(path);
|
|
if (!color) {
|
|
this.color = Color.Standard;
|
|
} else {
|
|
this.color = color as any;
|
|
}
|
|
};
|
|
|
|
get messages(): ChatMessage[] {
|
|
const messageIds: string[] = this.storageModel.list(
|
|
this.getMessageDirPath(),
|
|
);
|
|
if (!Array.isArray(messageIds)) return [];
|
|
|
|
const chatMessages: ChatMessage[] = [];
|
|
for (const messageId of messageIds) {
|
|
const messagePath: string[] = this.getMessagePath(messageId);
|
|
const chatMessage: ChatMessage | null =
|
|
this.storageModel.readStringifiable(
|
|
messagePath,
|
|
ChatMessageReference,
|
|
);
|
|
if (chatMessage == null) continue;
|
|
chatMessages.push(chatMessage);
|
|
}
|
|
|
|
const sorted = chatMessages.sort((a, b) =>
|
|
a.dateSent.localeCompare(b.dateSent),
|
|
);
|
|
return sorted;
|
|
}
|
|
|
|
get reactions(): ChatMessageReaction[] {
|
|
const reactionIds: string[] = this.storageModel.list(
|
|
this.getReactionDirPath(),
|
|
);
|
|
if (!Array.isArray(reactionIds)) return [];
|
|
|
|
const reactions: ChatMessageReaction[] = [];
|
|
for (const reactionId of reactionIds) {
|
|
const reactionPath: string[] = this.getReactionPath(reactionId);
|
|
const reaction: ChatMessageReaction | null =
|
|
this.storageModel.readStringifiable(
|
|
reactionPath,
|
|
ChatMessageReactionReference,
|
|
);
|
|
if (reaction == null) continue;
|
|
reactions.push(reaction);
|
|
}
|
|
|
|
return reactions;
|
|
}
|
|
|
|
// init
|
|
constructor(
|
|
storageModel: StorageModel,
|
|
connectionModel: ConnectionModel,
|
|
settingsModel: SettingsModel,
|
|
chatListModel: ChatListModel,
|
|
chatId: string,
|
|
) {
|
|
this.id = chatId;
|
|
this.connectionModel = connectionModel;
|
|
this.settingsModel = settingsModel;
|
|
this.storageModel = storageModel;
|
|
this.chatListModel = chatListModel;
|
|
|
|
this.loadInfo();
|
|
this.loadColor();
|
|
this.subscribe();
|
|
|
|
this.fileModel = new FileModel(
|
|
this.storageModel,
|
|
this.settingsModel,
|
|
this,
|
|
);
|
|
}
|
|
|
|
// utility
|
|
static splitChannel(channelString: string): string[] {
|
|
return channelString.split("/");
|
|
}
|
|
|
|
static generateChatInfo = (primaryChannel: string): ChatInfo => {
|
|
return {
|
|
dataVersion: DATA_VERSION,
|
|
|
|
primaryChannel,
|
|
secondaryChannels: [],
|
|
encryptionKey: "",
|
|
hasUnreadMessages: false,
|
|
};
|
|
};
|
|
|
|
static createChatMessage = async (
|
|
channel: string,
|
|
sender: string,
|
|
encryptionKey: string,
|
|
body: string,
|
|
fileContent?: FileContent<string>,
|
|
): Promise<ChatMessage> => {
|
|
const chatMessage: ChatMessage = {
|
|
dataVersion: DATA_VERSION,
|
|
|
|
id: v4(),
|
|
|
|
channel,
|
|
sender,
|
|
body,
|
|
dateSent: createTimestamp(),
|
|
|
|
status: ChatMessageStatus.Outbox,
|
|
stringifiedFile: "",
|
|
};
|
|
if (fileContent != undefined) {
|
|
const stringifiedFile = stringify(fileContent);
|
|
chatMessage.stringifiedFile = stringifiedFile;
|
|
}
|
|
|
|
if (encryptionKey != "") {
|
|
chatMessage.body = await encryptString(
|
|
chatMessage.body,
|
|
encryptionKey,
|
|
);
|
|
chatMessage.stringifiedFile = await encryptString(
|
|
chatMessage.stringifiedFile,
|
|
encryptionKey,
|
|
);
|
|
}
|
|
|
|
return chatMessage;
|
|
};
|
|
|
|
static createMessageReaction = (
|
|
messageId: string,
|
|
sender: string,
|
|
content: ReactionSymbols,
|
|
isDeleting: boolean,
|
|
): ChatMessageReaction => {
|
|
const fileContent = FileModel.createFileContent(v4(), "reaction");
|
|
const reaction: ChatMessageReaction = {
|
|
...fileContent,
|
|
fileId: ChatModel.createMessageReactionId(messageId, content, sender),
|
|
|
|
messageId,
|
|
sender,
|
|
content,
|
|
isDeleting,
|
|
};
|
|
return reaction;
|
|
};
|
|
|
|
static createMessageReactionId = (messageId: string, content: ReactionSymbols, sender: string): string => {
|
|
return messageId + sender + reactionStringMap[content];
|
|
}
|
|
}
|
|
|
|
// types
|
|
export enum ReactionSymbols {
|
|
ThumbsUp = "👍",
|
|
Check = "✅",
|
|
Attention = "❗️",
|
|
DoubleAttention = "‼️",
|
|
Question = "❓",
|
|
}
|
|
|
|
const reactionStringMap: {[key: ReactionSymbols|string]: string} = {}
|
|
Object.entries(ReactionSymbols).forEach(value => {
|
|
reactionStringMap[value[1]] = value[0];
|
|
});
|
|
|
|
export interface ChatInfo extends ValidObject {
|
|
primaryChannel: string;
|
|
secondaryChannels: string[];
|
|
encryptionKey: string;
|
|
|
|
hasUnreadMessages: boolean;
|
|
}
|
|
|
|
export enum ChatMessageStatus {
|
|
Outbox = "outbox",
|
|
Sent = "sent",
|
|
Received = "received",
|
|
Other = "other",
|
|
}
|
|
|
|
export interface ChatMessage extends ValidObject {
|
|
id: string;
|
|
|
|
channel: string;
|
|
sender: string;
|
|
body: string;
|
|
dateSent: string;
|
|
|
|
status: ChatMessageStatus;
|
|
|
|
stringifiedFile: string;
|
|
}
|
|
|
|
export interface ChatMessageReaction
|
|
extends ValidObject, FileContent<"reaction"> {
|
|
messageId: string;
|
|
sender: string;
|
|
content: ReactionSymbols | string;
|
|
isDeleting: boolean;
|
|
}
|
|
|
|
// references
|
|
export const ChatInfoReference: ChatInfo = {
|
|
dataVersion: DATA_VERSION,
|
|
|
|
primaryChannel: "",
|
|
secondaryChannels: [""],
|
|
encryptionKey: "",
|
|
|
|
hasUnreadMessages: true,
|
|
};
|
|
|
|
export const ChatMessageReference: ChatMessage = {
|
|
dataVersion: DATA_VERSION,
|
|
|
|
id: "",
|
|
|
|
channel: "",
|
|
sender: "",
|
|
body: "",
|
|
dateSent: "",
|
|
|
|
status: "" as ChatMessageStatus,
|
|
|
|
stringifiedFile: "",
|
|
};
|
|
|
|
export const ChatMessageReactionReference: ChatMessageReaction = {
|
|
dataVersion: DATA_VERSION,
|
|
|
|
fileId: "",
|
|
fileContentId: "",
|
|
creationDate: "",
|
|
type: "reaction",
|
|
|
|
messageId: "",
|
|
sender: "",
|
|
content: "",
|
|
|
|
isDeleting: false,
|
|
};
|