quickblox-react-ui-kit 0.1.0

package/src/Data/source/local/ILocalDataSource.ts

@@ -0,0 +1,45 @@
+import { LocalDialogDTO } from '../../dto/dialog/LocalDialogDTO';
+import { LocalDialogsDTO } from '../../dto/dialog/LocalDialogsDTO';
+import { LocalUserDTO } from '../../dto/user/LocalUserDTO';
+import { LocalMessageDTO } from '../../dto/message/LocalMessageDTO';
+import { LocalMessagesDTO } from '../../dto/message/LocalMessagesDTO';
+import { FunctionTypeVoidToVoid } from '../../../Presentation/Views/Base/BaseViewModel';
+import { Pagination } from '../../../Domain/repository/Pagination';
+
+export interface ILocalDataSource {
+  subscribe(subscriber: FunctionTypeVoidToVoid): void;
+
+  release(): void;
+
+  isLocalSynced(): Promise<boolean>;
+
+  setLocalSynced(synced: boolean): void;
+
+  saveDialog(dtoDialog: LocalDialogDTO): Promise<boolean>;
+
+  deleteDialog(dtoDialog: LocalDialogDTO): Promise<boolean>;
+
+  getDialogs(pagination?: Pagination): Promise<LocalDialogsDTO>;
+
+  getDialog(dtoDialog: LocalDialogDTO): Promise<LocalDialogDTO>;
+
+  updateDialog(dtoDialog: LocalDialogDTO): Promise<boolean>;
+
+  getUser(dtoUser: LocalUserDTO): Promise<LocalUserDTO>;
+
+  saveUser(user: LocalUserDTO): Promise<boolean>;
+
+  // getUsers(usersIds: Array<number>): Promise<Array<UserEntity>>
+
+  // saveUsers(users: Array<UserEntity>): Promise<boolean>
+
+  getMessages(dtoMessages: LocalMessagesDTO): Promise<LocalMessagesDTO>;
+
+  saveMessage(dtoMessage: LocalMessageDTO): Promise<boolean>;
+
+  updateMessage(dtoMessage: LocalMessageDTO): Promise<boolean>;
+
+  deleteMessage(dtoMessage: LocalMessageDTO): Promise<boolean>;
+
+  clearAll(): Promise<void>;
+}

package/src/Data/source/local/ILocalFileDataSource.ts

@@ -0,0 +1,11 @@
+import { FileEntity } from '../../../Domain/entity/FileEntity';
+
+export interface ILocalFileDataSource {
+  clearAll(): Promise<void>;
+
+  getFile(id: string): Promise<FileEntity>;
+
+  createFile(file: FileEntity): Promise<void>;
+
+  deleteFile(id: string): Promise<void>;
+}

package/src/Data/source/local/LocalDataSource.ts

@@ -0,0 +1,377 @@
+import { ILocalDataSource } from './ILocalDataSource';
+import {
+  LocalDataSourceException,
+  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+  UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
+  UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+} from '../exception/LocalDataSourceException';
+import { LocalDialogDTO } from '../../dto/dialog/LocalDialogDTO';
+import { LocalMessageDTO } from '../../dto/message/LocalMessageDTO';
+import { LocalDialogsDTO } from '../../dto/dialog/LocalDialogsDTO';
+import { LocalMessagesDTO } from '../../dto/message/LocalMessagesDTO';
+import { LocalUserDTO } from '../../dto/user/LocalUserDTO';
+import { Pagination } from '../../../Domain/repository/Pagination';
+import { SubscriptionPerformer } from '../../../Domain/use_cases/base/Subscribable/SubscriptionPerformer';
+
+export class LocalDataSource
+  extends SubscriptionPerformer<boolean>
+  implements ILocalDataSource
+{
+  private localSynced = false;
+
+  public isLocalSynced(): Promise<boolean> {
+    return Promise.resolve(this.localSynced);
+  }
+
+  // public release(): void {
+  //   this.onEventByTypeSubscribers.slice();
+  // }
+
+  // public subscribe(subscriber: FunctionTypeVoidToVoid): void {
+  //   this.onEventByTypeSubscribers.push(subscriber);
+  // }
+
+  public setLocalSynced(synced: boolean): void {
+    this.localSynced = synced;
+    if (synced) {
+      this.informSubscribers(synced);
+    }
+  }
+
+  // protected informSubscribers(): void {
+  //   this.onEventByTypeSubscribers.forEach((subscriber) => {
+  //     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  //     subscriber();
+  //   });
+  // }
+
+  // constructor() {
+  //   super();
+  //   // this.onEventByTypeSubscribers = [];
+  // }
+
+  // private readonly onEventByTypeSubscribers: Array<FunctionTypeVoidToVoid>;
+
+  private dialogs: Record<string, LocalDialogDTO> = {};
+
+  private users: Record<string, LocalUserDTO> = {};
+
+  private messages: Record<string, LocalMessageDTO> = {};
+
+  clearAll(): Promise<void> {
+    this.messages = {};
+    sessionStorage.setItem('messages', JSON.stringify(this.messages));
+
+    this.dialogs = {};
+    sessionStorage.setItem('dialogs', JSON.stringify(this.dialogs));
+
+    this.users = {};
+    sessionStorage.setItem('users', JSON.stringify(this.users));
+
+    return Promise.resolve();
+  }
+
+  deleteDialog(dtoDialog: LocalDialogDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('dialogs');
+    const result: string = storageValue ?? '';
+
+    this.dialogs = result === '' ? {} : JSON.parse(result);
+    const filteredDialogsList: Record<string, LocalDialogDTO> = {};
+
+    if (
+      this.dialogs[dtoDialog.id] === undefined ||
+      this.dialogs[dtoDialog.id] === null
+    ) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    Object.keys(this.dialogs).forEach((key) => {
+      if (key !== dtoDialog.id) {
+        filteredDialogsList[key] = this.dialogs[key];
+      }
+    });
+    this.dialogs = filteredDialogsList;
+    sessionStorage.setItem('dialogs', JSON.stringify(this.dialogs));
+
+    return Promise.resolve(true);
+  }
+
+  deleteMessage(dtoMessage: LocalMessageDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('messages');
+    const result: string = storageValue ?? '';
+
+    this.messages = result === '' ? {} : JSON.parse(result);
+    const filteredMessagesList: Record<string, LocalMessageDTO> = {};
+
+    if (
+      this.messages[dtoMessage.id] === undefined ||
+      this.messages[dtoMessage.id] === null
+    ) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    Object.keys(this.messages).forEach((key) => {
+      if (key !== dtoMessage.id.toString()) {
+        filteredMessagesList[key] = this.messages[key];
+      }
+    });
+    this.messages = filteredMessagesList;
+    sessionStorage.setItem('messages', JSON.stringify(this.messages));
+
+    return Promise.resolve(true);
+  }
+
+  getDialog(dtoDialog: LocalDialogDTO): Promise<LocalDialogDTO> {
+    const storageValue = sessionStorage.getItem('dialogs');
+    const result: string = storageValue ?? '';
+
+    this.dialogs = result === '' ? {} : JSON.parse(result);
+    try {
+      const entity: LocalDialogDTO = this.dialogs[dtoDialog.id];
+
+      if (entity === undefined || entity === null) {
+        return Promise.reject(
+          new LocalDataSourceException(
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+          ),
+        );
+      }
+
+      return Promise.resolve(entity);
+    } catch (e) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+  }
+
+  getDialogs(pagination?: Pagination): Promise<LocalDialogsDTO> {
+    const storageValue = sessionStorage.getItem('dialogs');
+    const result: string = storageValue ?? '';
+
+    this.dialogs = result === '' ? {} : JSON.parse(result);
+    try {
+      const arrayDialogDTO: Array<LocalDialogDTO> = Object.keys(
+        this.dialogs,
+      ).map((id) => this.dialogs[id]);
+
+      if (arrayDialogDTO === undefined || arrayDialogDTO === null) {
+        return Promise.reject(
+          new LocalDataSourceException(
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+          ),
+        );
+      }
+      const currentPagination: Pagination = pagination || new Pagination();
+      const dtoResult: LocalDialogsDTO = new LocalDialogsDTO(
+        arrayDialogDTO,
+        currentPagination,
+      );
+
+      return Promise.resolve(dtoResult);
+    } catch (e) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+  }
+
+  getMessages(dtoMessages: LocalMessagesDTO): Promise<LocalMessagesDTO> {
+    const storageValue = sessionStorage.getItem('messages');
+    const result: string = storageValue ?? '';
+
+    this.messages = result === '' ? {} : JSON.parse(result);
+    // let resultMessages : Array<LocalMessagesDTO>;
+    const arrayMessageDTO: Array<LocalMessageDTO> = [];
+
+    try {
+      // eslint-disable-next-line no-restricted-syntax
+      for (const item of dtoMessages.messages) {
+        // eslint-disable-next-line array-callback-return
+        Object.keys(this.messages).map((id) => {
+          if (this.messages[id].dialogId === item.dialogId) {
+            const dto: LocalMessageDTO = this.messages[id];
+
+            arrayMessageDTO.push(dto);
+          }
+        });
+      }
+
+      if (arrayMessageDTO.length === 0) {
+        return Promise.reject(
+          new LocalDataSourceException(
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+          ),
+        );
+      }
+
+      return Promise.resolve(
+        new LocalMessagesDTO(arrayMessageDTO, new Pagination()),
+      );
+    } catch (e) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+  }
+
+  getUser(dtoUser: LocalUserDTO): Promise<LocalUserDTO> {
+    const storageValue = sessionStorage.getItem('users');
+    const result: string = storageValue ?? '';
+
+    this.users = result === '' ? {} : JSON.parse(result);
+    try {
+      const dto: LocalUserDTO = this.users[dtoUser.id];
+
+      if (dto === undefined || dto === null) {
+        return Promise.reject(
+          new LocalDataSourceException(
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+            NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+          ),
+        );
+      }
+
+      return Promise.resolve(dto);
+    } catch (e) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+  }
+
+  saveDialog(dtoDialog: LocalDialogDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('dialogs');
+    const result: string = storageValue ?? '';
+
+    this.dialogs = result === '' ? {} : JSON.parse(result);
+    if (dtoDialog === null || dtoDialog === undefined) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+    this.dialogs[dtoDialog.id] = dtoDialog;
+    sessionStorage.setItem('dialogs', JSON.stringify(this.dialogs));
+
+    return Promise.resolve(true);
+  }
+
+  saveMessage(dtoMessage: LocalMessageDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('messages');
+    const result: string = storageValue ?? '';
+
+    this.messages = result === '' ? {} : JSON.parse(result);
+    if (dtoMessage === null || dtoMessage === undefined) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+    this.messages[dtoMessage.id] = dtoMessage;
+    sessionStorage.setItem('messages', JSON.stringify(this.messages));
+
+    return Promise.resolve(true);
+  }
+
+  saveUser(dtoUser: LocalUserDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('users');
+    const result: string = storageValue ?? '';
+
+    this.users = result === '' ? {} : JSON.parse(result);
+    if (dtoUser === null || dtoUser === undefined) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+    this.users[dtoUser.id] = dtoUser;
+    sessionStorage.setItem('users', JSON.stringify(this.users));
+
+    return Promise.resolve(true);
+  }
+
+  updateDialog(dtoDialog: LocalDialogDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('dialogs');
+    const result: string = storageValue ?? '';
+
+    this.dialogs = result === '' ? {} : JSON.parse(result);
+    // todo: const filteredDialogsList: Record<string, DialogEntity> = {};
+
+    if (
+      this.dialogs[dtoDialog.id] === undefined ||
+      this.dialogs[dtoDialog.id] === null
+    ) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    this.dialogs[dtoDialog.id] = dtoDialog;
+
+    sessionStorage.setItem('dialogs', JSON.stringify(this.dialogs));
+
+    return Promise.resolve(true);
+  }
+
+  updateMessage(dtoMessage: LocalMessageDTO): Promise<boolean> {
+    const storageValue = sessionStorage.getItem('messages');
+    const result: string = storageValue ?? '';
+
+    this.messages = result === '' ? {} : JSON.parse(result);
+    // todo: const filteredMessagesList: Record<string, MessageEntity> = {};
+
+    if (
+      this.messages[dtoMessage.id] === undefined ||
+      this.messages[dtoMessage.id] === null
+    ) {
+      return Promise.reject(
+        new LocalDataSourceException(
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+          NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    this.messages[dtoMessage.id] = dtoMessage;
+
+    sessionStorage.setItem('messages', JSON.stringify(this.messages));
+
+    return Promise.resolve(true);
+  }
+}

package/src/Data/source/local/LocalFileDataSource.ts

@@ -0,0 +1,22 @@
+import { ILocalFileDataSource } from './ILocalFileDataSource';
+import { FileEntity } from '../../../Domain/entity/FileEntity';
+
+
+export class LocalFileDataSource implements ILocalFileDataSource {
+  clearAll(): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
+
+  createFile(file: FileEntity): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
+
+  deleteFile(id: string): Promise<void> {
+    throw new Error('Method not implemented.')
+  }
+
+  getFile(id: string): Promise<FileEntity> {
+    throw new Error('Method not implemented.')
+  }
+
+}

package/src/Data/source/remote/IRemoteDataSource.ts

@@ -0,0 +1,112 @@
+import { RemoteDialogDTO } from '../../dto/dialog/RemoteDialogDTO';
+import { RemoteDialogsDTO } from '../../dto/dialog/RemoteDialogsDTO';
+import { RemoteUserDTO } from '../../dto/user/RemoteUserDTO';
+import { RemoteUsersDTO } from '../../dto/user/RemoteUsersDTO';
+import { RemoteMessagesDTO } from '../../dto/message/RemoteMessagesDTO';
+import { RemoteMessageDTO } from '../../dto/message/RemoteMessageDTO';
+import { RemoteFileDTO } from '../../dto/file/RemoteFileDTO';
+import { Pagination } from '../../../Domain/repository/Pagination';
+import { CallBackFunction } from '../../../Domain/use_cases/base/IUseCase';
+import { NotificationTypes } from '../../../Domain/entity/NotificationTypes';
+// todo list of all actions
+/*
+ 0!!! не реализованы эксепшены для createDialog RemouteDataSource и
+ и нет обрадотки эксепшенов для DTO и Mapper
+ + 1. UML диаграмы сравнить и синхронизировать
+ + 2. Синхронизировать сигнатуры методов в интерфейсах и реализациях
+ + 3. Изменить все методы Promise<boolean> на Promise<void>
+ 4. Прверить, что Not Found exception переименован в Not Found Item exception
+ 4.1 и эксепшен Not Found Item exception генерируют только методы для одной энтити -одного элемента
+ списки возвращают пустую коллекцию
+ 5. Доделіваем Dialogs = полцчение одного диалога, получение диалогов из Ремутедатасоурсе
+ 6. Передалать Dialogs = полцчение одного диалога, получение диалогов из Локаладатасоурсе
+ Вернуть радотоспособность тестам других репозиториев, что уже есть
+ ======================
+ Refactoring DTO for RemoteDS using RemoteDialogDTO as example
+ create DTO for localDS - in separate branche for LocalDS
+ изменить типы в мапперах в DTO (QB=>DTO)
+ создать новый маппер внутри соурса под именем IDTOMapper c двумя методами
+ Переделать
+     тесты
+     RemoteDS
+     DialogRepository
+  Нужны тесты для мапперов
+ */
+export interface IRemoteMessaging<TArg> {
+  subscribeOnSystemMessaging(
+    notificationType: NotificationTypes,
+    callback: CallBackFunction<TArg>,
+  ): void;
+
+  subscribeOnMessaging(callback: CallBackFunction<TArg>): void;
+
+  releaseSubscriptions(): void;
+}
+export interface IRemoteDataSource extends IRemoteMessaging<RemoteMessageDTO> {
+  /*
+  позитивный тест на результат - нет эксепшена и тот диалог, который вернули, можем найти
+  по id и среди списка всех
+  тест на эксепшн = негативный тест на результат - это эксепшен некорректные данные
+  эксепшны с диаграмы: коннекш фейлд, нет авторизации, запрещен доступ, некоректные данные
+   */
+  createDialog(dto: RemoteDialogDTO): Promise<RemoteDialogDTO>;
+  /*
+  негативный тест - нет такого диалога
+  */
+  updateDialog(dto: RemoteDialogDTO): Promise<RemoteDialogDTO>;
+  /*
+  негативный тест экспшн
+  Как сигнализуирем, что нет такого диалога по id - эксепшеном или пустым объектом?
+  проверить, что договаривались, на эксепшн НотФаунд
+  Позитивный тест - нет эксепшена и вернули значение
+   */
+  getDialog(dto: RemoteDialogDTO): Promise<RemoteDialogDTO>;
+  /*
+   негативный тест - пытаемся удалить того, которого нет - эксепшн некоректные данные
+   позитивный тест - удалили без экспепшена тот. что был и после удаления такого нет
+   ни по id ни при получении списком
+    */
+
+  getDialogs(pagination?: Pagination): Promise<RemoteDialogsDTO>;
+
+  deleteDialog(dto: RemoteDialogDTO): Promise<void>;
+
+  deleteUsersFromDialog(
+    dialogDto: RemoteDialogDTO,
+    usersDTO: Array<RemoteUserDTO>,
+  ): Promise<void>;
+
+  getUser(dto: RemoteUserDTO): Promise<RemoteUserDTO>;
+
+  getUsers(dto: RemoteUsersDTO): Promise<RemoteUsersDTO>;
+
+  getMessages(
+    dialogId: string,
+    pagination: Pagination,
+  ): Promise<RemoteMessagesDTO>;
+
+  typingMessageStart(
+    dialogDTO: RemoteDialogDTO,
+    senderId: number,
+  ): Promise<void>;
+  typingMessageStop(
+    dialogDTO: RemoteDialogDTO,
+    senderId: number,
+  ): Promise<void>;
+
+  sendMessage(dto: RemoteMessageDTO): Promise<RemoteMessageDTO>;
+
+  sendSystemMessage(dto: RemoteMessageDTO): Promise<boolean>;
+
+  updateMessage(dto: RemoteMessageDTO): Promise<RemoteMessageDTO>;
+
+  deleteMessage(dto: RemoteMessageDTO): Promise<void>;
+
+  createFile(dto: RemoteFileDTO): Promise<RemoteFileDTO>;
+
+  getFile(dto: RemoteFileDTO): Promise<RemoteFileDTO>;
+
+  deleteFile(dto: RemoteFileDTO): Promise<void>;
+
+  subscribeToChatConnectionEvents(fileId: string): Promise<void>;
+}