CT/src/Upgrader/v1.ts

// this file is responsible for migrating data from v1 to v2.

import {
  BoardInfoFileContent,
  TaskFileContent,
} from "../Model/Files/boardsAndTasksModel";
import ChatModel, {
  ChatMessage,
  ChatMessageStatus,
} from "../Model/Chat/chatModel";
import { getLocalStorageItemAndClear, parseArray, parseOrFallback } from "../Model/Utility/utility";

import ChatListModel from "../Model/Chat/chatListModel";
import ConnectionModel from "../Model/Global/connectionModel";
import FileModel from "../Model/Files/fileModel";
import SettingsModel from "../Model/Global/settingsModel";
import { checkMatchesObjectStructure } from "../Model/Utility/typeSafety";
import { translations } from "../View/translations";
import { v4 } from "uuid";

export default class v1Upgrader {
  // general
  migrateSettings = (): void => {
    const name: string | null = getLocalStorageItemAndClear("sender-name");
    if (name != null) {
      const parsedName: string = parseOrFallback(name);
      this.settingsModel.setName(parsedName);
    }

    const firstDayOfWeek: string | null =
      getLocalStorageItemAndClear("first-day-of-week");
    if (firstDayOfWeek != null) {
      const parsedFirstDayOfWeek: string = parseOrFallback(firstDayOfWeek);
      this.settingsModel.setFirstDayOfWeek(parsedFirstDayOfWeek);
    }
  };

  migrateConnections = (): void => {
    const previousAddressString: string | null =
      getLocalStorageItemAndClear("previous-addresses");
    if (previousAddressString == null) return;

    const previousAddresses: any[] = parseArray(previousAddressString);
    for (const address of previousAddresses) {
      if (typeof address != "string") continue;
      this.connectionModel.storeAddress(address);
    }
  };

  // chats
  migrateChats = (): void => {
    const chatIdString: string | null = getLocalStorageItemAndClear("chat-ids");
    if (chatIdString == null) return;

    const chatIds: any[] = parseArray(chatIdString);
    for (const chatId of chatIds) {
      if (typeof chatId != "string") continue;
      this.migrateChatById(chatId);
    }
  };

  migrateChatById = (id: string): void => {
    // get primary channel
    const primaryChannel: string | null = getLocalStorageItemAndClear(
      storageKeys.primaryChannel(id)
    );
    if (primaryChannel == null) return;
    const parsedPriamryChannel: string = parseOrFallback(primaryChannel);

    // create chat
    const chatModel: ChatModel =
      this.chatListModel.createChat(parsedPriamryChannel);

    // secondary channels
    const secondaryChannelString: string | null = getLocalStorageItemAndClear(
      storageKeys.secondaryChannels(id)
    );
    if (secondaryChannelString != null) {
      const potentialSecondaryChannels: any[] = parseArray(
        secondaryChannelString
      );

      const confirmedSecondaryChannels: string[] = [];
      for (const secondaryChannel of potentialSecondaryChannels) {
        if (typeof secondaryChannel != "string") continue;
        confirmedSecondaryChannels.push(secondaryChannel);
      }

      chatModel.setSecondaryChannels(confirmedSecondaryChannels);
    }

    // encryption key
    const encryptionKey: string | null = getLocalStorageItemAndClear(
      storageKeys.encyptionKey(id)
    );
    if (encryptionKey != null) {
      const parsedEncryptionKey: string = parseOrFallback(encryptionKey);
      chatModel.setEncryptionKey(parsedEncryptionKey);
    }

    // messages
    const messagesString: string =
      getLocalStorageItemAndClear(storageKeys.messages(id)) ?? "";
    const messageOutboxString: string =
      getLocalStorageItemAndClear(storageKeys.outbox(id)) ?? "";
    const potentialMessages: any[] = parseArray(messagesString);
    const potentialMessagesInOutbox: any[] = parseArray(messageOutboxString);

    const addMessages = (
      potentialMessages: any[],
      status: ChatMessageStatus
    ) => {
      for (const potentialMessage of potentialMessages) {
        const isV1ChatMessage: boolean = checkMatchesObjectStructure(
          potentialMessage,
          V1ChatMessageReference
        );
        if (isV1ChatMessage == false) continue;
        const v1ChatMessage: typeof V1ChatMessageReference = potentialMessage;

        const convertedChatMessage: ChatMessage = {
          dataVersion: "v2",

          id: v4(),

          channel: v1ChatMessage.channel,
          sender: v1ChatMessage.sender,
          body: v1ChatMessage.body,
          dateSent: v1ChatMessage.isoDate,

          status,
          stringifiedFile: "",
        };
        chatModel.addMessage(convertedChatMessage);
        if (status == ChatMessageStatus.Outbox) {
          this.connectionModel.sendMessageOrStore(convertedChatMessage);
        }
      }
    };

    addMessages(potentialMessages, ChatMessageStatus.Received);
    addMessages(potentialMessagesInOutbox, ChatMessageStatus.Outbox);

    // objects
    const objectsString: string =
      getLocalStorageItemAndClear(storageKeys.objects(id)) ?? "";
    const objectOutboxString: string =
      getLocalStorageItemAndClear(storageKeys.itemOutbox(id)) ?? "";
    const potentialObjects: any[] = parseArray(objectsString);
    const potentialObjectsInOutbox: any[] = parseArray(objectOutboxString);

    const addObjects = (potentialObjects: any[]): void => {
      const board: BoardInfoFileContent =
        chatModel.fileModel.boardsAndTasksModel.createBoard(
          translations.updater.migrated
        );
      chatModel.fileModel.boardsAndTasksModel.updateBoard(board);

      for (const potentialObjectEntry of potentialObjects) {
        const potentialObject = potentialObjectEntry[1];
        const isV1MessageObject: boolean =
          checkIsV1MessageObject(potentialObject);
        if (isV1MessageObject == false) continue;

        const objectId: string = potentialObject.id;
        const objectName: string = potentialObject.title;

        const contentVersions: any[] = Object.values(
          potentialObject.contentVersions
        );
        for (const potentialVersion of contentVersions) {
          const isV1MessageObjectContent: boolean =
            checkIsV1MessageObjectContent(potentialVersion);
          if (isV1MessageObjectContent == false) continue;

          const convertedTaskFileContent: TaskFileContent = {
            dataVersion: "v2",

            fileId: objectId,
            fileContentId: FileModel.generateFileContentId(
              potentialVersion.isoDateVersionCreated
            ),
            creationDate: potentialVersion.isoDateVersionCreated,
            type: "task",

            name: objectName ?? "",
            boardId: board.fileId ?? "",

            description: potentialVersion.noteContent ?? "",

            category: potentialVersion.categoryName ?? "",
            status: potentialVersion.status ?? "",
            priority: potentialVersion.priority ?? "",

            date: potentialVersion.date ?? "",
            time: potentialVersion.time ?? "",
          };
          console.log(convertedTaskFileContent);
          chatModel.fileModel.handleFileContent(convertedTaskFileContent);
        }
      }
    };

    addObjects([...potentialObjects, ...potentialObjectsInOutbox]);
  };

  // init
  constructor(
    public settingsModel: SettingsModel,
    public connectionModel: ConnectionModel,
    public chatListModel: ChatListModel
  ) {
    this.migrateSettings();
    this.migrateConnections();
    this.migrateChats();
  }
}

const storageKeys = {
  viewType(id: string): string {
    return id + "view-type";
  },

  hasUnread(id: string): string {
    return id + "has-unread-messages";
  },

  primaryChannel(id: string): string {
    return id + "primary-channel";
  },

  secondaryChannels(id: string): string {
    return id + "secondary-channels";
  },

  encyptionKey(id: string): string {
    return id + "encryption-key";
  },

  messages(id: string): string {
    return id + "messages";
  },

  objects(id: string): string {
    return id + "items";
  },

  outbox(id: string): string {
    return id + "outbox";
  },

  itemOutbox(id: string): string {
    return id + "item-outbox";
  },

  composingMessage(id: string): string {
    return id + "composing-message";
  },
};

const V1ChatMessageReference = {
  channel: "",
  sender: "",
  body: "",
  isoDate: "",
};

function checkIsV1MessageObject(object: any): boolean {
  if (object.id == undefined) return false;
  if (object.title == undefined) return false;
  if (object.contentVersions == undefined) return false;

  return true;
}

function checkIsV1MessageObjectContent(object: any): boolean {
  if (object.id == undefined) return false;
  if (object.isoDateVersionCreated == undefined) return false;

  return true;
}