quickblox-react-ui-kit 0.1.0

package/src/Domain/entity/Chat.ts

@@ -0,0 +1,4 @@
+export interface Chat {
+  id: number;
+  title: string;
+}

package/src/Domain/entity/ChatMessageAttachmentEntity.ts

@@ -0,0 +1,15 @@
+import { FileEntity } from './FileEntity';
+import { FileType } from './FileTypes';
+
+export default interface ChatMessageAttachmentEntity {
+  /** ID of the file on QuickBlox server (UID of file from QB.content.createAndUpload) */
+  id: string | number;
+  uid?: string;
+  file?: FileEntity;
+  type: FileType;
+  /** Link to a file in Internet */
+  url?: string;
+  name?: string;
+  size?: number;
+  [key: string]: unknown;
+}

package/src/Domain/entity/CustomDataEntity.ts

@@ -0,0 +1,3 @@
+export interface CustomDataEntity {
+  todo: unknown;
+}

package/src/Domain/entity/DialogEntity.ts

@@ -0,0 +1,15 @@
+import { DialogType } from './DialogTypes';
+import { LastMessageEntity } from './LastMessageEntity';
+import { CustomDataEntity } from './CustomDataEntity';
+
+export interface DialogEntity {
+  id: string;
+  name: string;
+  type: DialogType;
+  ownerId: string;
+  updatedAt: string;
+
+  lastMessage: LastMessageEntity;
+  unreadMessageCount: number;
+  customData: CustomDataEntity;
+}

package/src/Domain/entity/DialogEventInfo.ts

@@ -0,0 +1,15 @@
+import EventMessageType from './EventMessageType';
+import { NotificationTypes } from './NotificationTypes';
+import { MessageEntity } from './MessageEntity';
+
+export type MessageStatus = {
+  isTyping: boolean;
+  userId: number;
+  dialogId: string;
+};
+export type DialogEventInfo = {
+  eventMessageType: EventMessageType;
+  notificationTypes: NotificationTypes | undefined;
+  messageInfo: MessageEntity | undefined;
+  messageStatus: MessageStatus | undefined;
+};

package/src/Domain/entity/DialogTypes.ts

@@ -0,0 +1,7 @@
+export class DialogType {
+  public static readonly private: number = 3;
+
+  public static readonly public: number = 1;
+
+  public static readonly group: number = 2;
+}

package/src/Domain/entity/EventMessageType.ts

@@ -0,0 +1,7 @@
+export default class EventMessageType {
+  public static readonly SystemMessage = 'system_message';
+
+  public static readonly RegularMessage = 'qb_message';
+
+  public static readonly LocalMessage = 'local_event';
+}

package/src/Domain/entity/FileEntity.ts

@@ -0,0 +1,11 @@
+import { FileType } from './FileTypes';
+
+export interface FileEntity {
+  id?: string | number;
+  uid: string;
+  url?: string;
+  name?: string;
+  size?: number;
+  type?: FileType;
+  data?: string | File;
+}

package/src/Domain/entity/FileTypes.ts

@@ -0,0 +1,9 @@
+export class FileType {
+  public static readonly audio = 'audio';
+
+  public static readonly video = 'video';
+
+  public static readonly image = 'image';
+
+  public static readonly text = 'text';
+}

package/src/Domain/entity/GroupDialogEntity.ts

@@ -0,0 +1,54 @@
+import { DialogEntity } from './DialogEntity';
+import { CustomDataEntity } from './CustomDataEntity';
+import { LastMessageEntity } from './LastMessageEntity';
+import { DialogType } from './DialogTypes';
+
+export class GroupDialogEntity implements DialogEntity {
+  customData: CustomDataEntity;
+
+  id: string;
+
+  lastMessage: LastMessageEntity;
+
+  readonly ownerId: string;
+
+  type: DialogType;
+
+  unreadMessageCount: number;
+
+  updatedAt: string;
+
+  participantIds: Array<number>;
+
+  newParticipantIds?: Array<number>;
+
+  participantsToRemoveIds?: Array<number>;
+
+  name: string;
+
+  photo: string | null;
+
+  constructor(
+    customData: CustomDataEntity,
+    id: string,
+    lastMessage: LastMessageEntity,
+    ownerId: string,
+    type: DialogType,
+    unreadMessageCount: number,
+    updatedAt: string,
+    participantIds: Array<number>,
+    name: string,
+    photo: string,
+  ) {
+    this.customData = customData;
+    this.id = id;
+    this.lastMessage = lastMessage;
+    this.ownerId = ownerId;
+    this.type = type;
+    this.unreadMessageCount = unreadMessageCount;
+    this.updatedAt = updatedAt;
+    this.participantIds = participantIds;
+    this.name = name;
+    this.photo = photo;
+  }
+}

package/src/Domain/entity/LastMessageEntity.ts

@@ -0,0 +1,5 @@
+export interface LastMessageEntity {
+  text: string;
+  dateSent: string;
+  userId: number;
+}

package/src/Domain/entity/MessageEntity.ts

@@ -0,0 +1,25 @@
+import ChatMessageAttachmentEntity from './ChatMessageAttachmentEntity';
+import { UserEntity } from './UserEntity';
+import { DialogType } from './DialogTypes';
+
+export interface MessageEntity {
+  id: number;
+  dialogId: string;
+  dialogType?: DialogType;
+  // TODO: check ChatMessageAttachmentEntity
+  attachments?: ChatMessageAttachmentEntity[];
+  // TODO: check notification_type
+  notification_type?: string;
+  // TODO: check markable
+  markable?: string;
+  created_at: string;
+  date_sent: number;
+  delivered_ids: Array<number>;
+  message: string;
+  read_ids: Array<number>;
+  read: number;
+  recipient_id: number;
+  sender_id: number;
+  sender?: UserEntity;
+  updated_at: string;
+}

package/src/Domain/entity/NotificationTypes.ts

@@ -0,0 +1,7 @@
+export class NotificationTypes {
+  public static readonly NEW_DIALOG = '1';
+
+  public static readonly UPDATE_DIALOG = '2';
+
+  public static readonly DELETE_LEAVE_DIALOG = '3';
+}

package/src/Domain/entity/PrivateDialogEntity.ts

@@ -0,0 +1,46 @@
+import { DialogEntity } from './DialogEntity';
+import { CustomDataEntity } from './CustomDataEntity';
+import { LastMessageEntity } from './LastMessageEntity';
+import { DialogType } from './DialogTypes';
+
+export class PrivateDialogEntity implements DialogEntity {
+  customData: CustomDataEntity;
+
+  id: string;
+
+  name: string;
+
+  lastMessage: LastMessageEntity;
+
+  readonly ownerId: string;
+
+  type: DialogType;
+
+  unreadMessageCount: number;
+
+  updatedAt: string;
+
+  participantId: number;
+
+  constructor(
+    customData: CustomDataEntity,
+    id: string,
+    name: string,
+    lastMessage: LastMessageEntity,
+    ownerId: string,
+    type: DialogType,
+    unreadMessageCount: number,
+    updatedAt: string,
+    participantId: number,
+  ) {
+    this.customData = customData;
+    this.id = id;
+    this.name = name;
+    this.lastMessage = lastMessage;
+    this.ownerId = ownerId;
+    this.type = type;
+    this.unreadMessageCount = unreadMessageCount;
+    this.updatedAt = updatedAt;
+    this.participantId = participantId;
+  }
+}

package/src/Domain/entity/PublicDialogEntity.ts

@@ -0,0 +1,72 @@
+import { DialogEntity } from './DialogEntity';
+import { CustomDataEntity } from './CustomDataEntity';
+import { LastMessageEntity } from './LastMessageEntity';
+import { DialogType } from './DialogTypes';
+import { GroupDialogEntity } from './GroupDialogEntity';
+
+export class PublicDialogEntity implements DialogEntity {
+  customData: CustomDataEntity;
+
+  id: string;
+
+  lastMessage: LastMessageEntity;
+
+  readonly ownerId: string;
+
+  type: DialogType;
+
+  unreadMessageCount: number;
+
+  updatedAt: string;
+
+  name: string;
+
+  photo: string;
+
+  constructor(
+    customData: CustomDataEntity,
+    id: string,
+    lastMessage: LastMessageEntity,
+    ownerId: string,
+    type: DialogType,
+    unreadMessageCount: number,
+    updatedAt: string,
+    name: string,
+    photo: string,
+  ) {
+    this.customData = customData;
+    this.id = id;
+    this.lastMessage = lastMessage;
+    this.ownerId = ownerId;
+    this.type = type;
+    this.unreadMessageCount = unreadMessageCount;
+    this.updatedAt = updatedAt;
+    this.name = name;
+    this.photo = photo;
+  }
+
+  public static getParticipants = (d: DialogEntity) => {
+    if (d.type === DialogType.group) {
+      return (d as GroupDialogEntity).participantIds;
+    }
+    if (
+      d.type === DialogType.private &&
+      (d as GroupDialogEntity).participantIds.length > 0
+    ) {
+      // return [(d as PrivateDialogEntity).participantId];
+      return [(d as GroupDialogEntity).participantIds[0]];
+    }
+
+    return [];
+  };
+
+  public static getNewParticipants = (d: DialogEntity) => {
+    if (d.type === DialogType.group) {
+      const newParticipants = (d as GroupDialogEntity).newParticipantIds;
+
+      return newParticipants || [];
+    }
+
+    return [];
+  };
+}

package/src/Domain/entity/UserEntity.ts

@@ -0,0 +1,22 @@
+export interface UserEntity {
+  id: number;
+  full_name: string;
+  email: string;
+  login: string;
+  // phone: string;
+  // website: string;
+  created_at: string;
+  updated_at: string;
+  last_request_at: string;
+  // external_user_id: null;
+  // facebook_id: string | null;
+  blob_id: string | null;
+  custom_data: string | null;
+  // age_over16: boolean;
+  // allow_statistics_analysis: boolean;
+  // allow_sales_activities: boolean;
+  // parents_contacts: string;
+  user_tags: string | null;
+  // password?: string;
+  // old_password?: string;
+}

package/src/Domain/exception/domain/DomainExecption.ts

@@ -0,0 +1,5 @@
+export default class DomainException extends Error {
+  constructor(public message: string) {
+    super(message);
+  }
+}

package/src/Domain/repository/IDialogsRepository.ts

@@ -0,0 +1,40 @@
+import { DialogEntity } from '../entity/DialogEntity';
+import { FunctionTypeVoidToVoid } from '../../Presentation/Views/Base/BaseViewModel';
+import { PaginatedResult, Pagination } from './Pagination';
+
+export interface IDialogsRepository {
+  saveDialogToLocal(dialog: DialogEntity): Promise<boolean>;
+
+  createDialogInRemote(dialog: DialogEntity): Promise<DialogEntity>;
+
+  updateDialogInLocal(dialog: DialogEntity): Promise<DialogEntity>;
+
+  updateDialogInRemote(dialog: DialogEntity): Promise<DialogEntity>;
+
+  getDialogFromLocal(dialogId: string): Promise<DialogEntity>;
+
+  getDialogFromRemote(dialogId: string): Promise<DialogEntity>;
+
+  getDialogsFromLocal(pagination?: Pagination): Promise<Array<DialogEntity>>;
+
+  getDialogsFromRemote(
+    pagination?: Pagination,
+  ): Promise<PaginatedResult<DialogEntity>>;
+
+  deleteDialogFromLocal(dialogId: string): Promise<boolean>;
+
+  deleteDialogFromRemote(dialogId: string): Promise<boolean>;
+
+  deleteUsersFromDialogFromRemote(
+    dialogId: string,
+    userIds: Array<number>,
+  ): Promise<boolean>;
+
+  subscribeLocalSync(subscriber: FunctionTypeVoidToVoid): void;
+
+  unsubscribeLocalSync(): void;
+
+  isLocalSynced(): Promise<boolean>;
+
+  setLocalSynced(synced: boolean): void;
+}

package/src/Domain/repository/IFileRepository.ts

@@ -0,0 +1,9 @@
+import { FileEntity } from '../entity/FileEntity';
+
+export interface IFileRepository {
+  saveFileInRemote(fileEntity: FileEntity): Promise<FileEntity>;
+
+  downloadFile(fileEntity: FileEntity): Promise<FileEntity>;
+
+  deleteFile(fileEntity: FileEntity): Promise<boolean>;
+}

package/src/Domain/repository/IMessagesRepository.ts

@@ -0,0 +1,28 @@
+import { MessageEntity } from '../entity/MessageEntity';
+import { PaginatedResult, Pagination } from './Pagination';
+import { DialogEntity } from '../entity/DialogEntity'
+
+export interface IMessagesRepository {
+  saveMessageToLocal(message: MessageEntity): Promise<boolean>;
+
+  sendMessageToRemote(message: MessageEntity): Promise<boolean>;
+
+  getMessagesFromLocal(dialogId: string): Promise<Array<MessageEntity>>;
+
+  getMessagesFromRemote(
+    dialogId: string,
+    pagination: Pagination,
+  ): Promise<PaginatedResult<MessageEntity>>;
+
+  updateMessageInLocal(message: MessageEntity): Promise<boolean>;
+
+  updateMessageInRemote(message: MessageEntity): Promise<boolean>;
+
+  deleteMessageInLocal(message: MessageEntity): Promise<boolean>;
+
+  deleteMessageInRemote(message: MessageEntity): Promise<boolean>;
+
+  typingMessageStart(dialog: DialogEntity, senderId: number): Promise<void>;
+
+  typingMessageStop(dialog: DialogEntity, senderId: number): Promise<void>;
+}

package/src/Domain/repository/IUsersRepository.ts

@@ -0,0 +1,13 @@
+import { UserEntity } from '../entity/UserEntity'
+
+export interface IUsersRepository {
+  getUserFromLocal(userId: number): Promise<UserEntity>;
+
+  getUserFromRemote(userId: number): Promise<UserEntity>;
+
+  getUsersFromLocal(usersIds: Array<number>): Promise<Array<UserEntity>>;
+
+  getUsersFromRemote(usersIds: Array<number>): Promise<Array<UserEntity>>;
+
+  saveUsersToLocal(users: Array<UserEntity>): void
+}

package/src/Domain/repository/Pagination.ts

@@ -0,0 +1,48 @@
+export class Pagination {
+  public getCurrentPage(): number {
+    return this._currentPage;
+  }
+
+  public setCurrentPage(value: number) {
+    this._currentPage = value;
+  }
+
+  get totalPages(): number {
+    return this._totalPages;
+  }
+
+  set totalPages(value: number) {
+    this._totalPages = value;
+  }
+
+  private _currentPage: number;
+
+  private _totalPages: number;
+
+  public perPage: number;
+
+  public hasNextPage(): boolean {
+    return this._currentPage < this._totalPages;
+  }
+
+  public nextPage(): boolean {
+    if (this.hasNextPage()) {
+      this._currentPage += 1;
+
+      return true;
+    }
+
+    return false;
+  }
+
+  constructor(currentPage = 0, perPage = 0) {
+    this._currentPage = currentPage;
+    this._totalPages = 0;
+    this.perPage = perPage;
+  }
+}
+export type PaginatedResult<TResult> = {
+  // PaginatedList: Record<number, TArg[]>;
+  ResultData: TResult[];
+  CurrentPagination: Pagination;
+};

package/src/Domain/use_cases/CreateDialogUseCase.ts

@@ -0,0 +1,73 @@
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { IUseCase } from './base/IUseCase';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+import { stringifyError } from '../../utils/parse';
+import { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import EventMessageType from '../entity/EventMessageType';
+
+export class CreateDialogUseCase implements IUseCase<void, DialogEntity> {
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private newDialog: GroupDialogEntity;
+
+  // todo: delete synUseCase: BaseUseCase<boolean>, use only dialogRepository
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    newDialog: GroupDialogEntity,
+  ) {
+    console.log('CONSTRUCTOR CreateDialogUseCase');
+    this.dialogRepository = dialogRepository;
+    this.newDialog = newDialog;
+    this.eventMessagesRepository = eventMessagesRepository;
+  }
+
+  async execute(): Promise<DialogEntity> {
+    console.log('execute CreateDialogUseCase', JSON.stringify(this.newDialog));
+    const result: DialogEntity = await this.dialogRepository
+      .createDialogInRemote(this.newDialog)
+      .catch((e) => {
+        const message = stringifyError(e);
+
+        console.log('EXCEPTION IN CREATE DIALOG USE CASE', message);
+        throw Error(message);
+      });
+
+    // добавляю локально
+    await this.dialogRepository.saveDialogToLocal(result);
+    // уведомляю
+    this.eventMessagesRepository.dispatchEvent<DialogEntity>(
+      EventMessageType.LocalMessage,
+      result,
+      [],
+    );
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.NEW_DIALOG;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.SystemMessage,
+      remoteMessageDTO,
+      [...this.newDialog.participantIds],
+    );
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.NEW_DIALOG;
+    remoteMessageDTO.date_sent = Date.now() / 1000;
+    remoteMessageDTO.message = `User ${this.newDialog.ownerId} create new dialog ${this.newDialog.name}`;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.RegularMessage,
+      remoteMessageDTO,
+      [...this.newDialog.participantIds],
+    );
+
+    return Promise.resolve(result);
+  }
+}

package/src/Domain/use_cases/GetAllDialogsUseCase.ts

@@ -0,0 +1,20 @@
+import { IUseCase } from './base/IUseCase';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { DialogEntity } from '../entity/DialogEntity';
+
+export class GetAllDialogsUseCase
+  implements IUseCase<void, Array<DialogEntity>>
+{
+  private dialogRepository: DialogsRepository;
+
+  constructor(dialogRepository: DialogsRepository) {
+    console.log('CONSTRUCTOR GetAllDialogsUseCase');
+    this.dialogRepository = dialogRepository;
+  }
+
+  execute(): Promise<Array<DialogEntity>> {
+    console.log('execute GetAllDialogsUseCase');
+
+    return this.dialogRepository.getDialogsFromLocal();
+  }
+}

package/src/Domain/use_cases/GetAllDialogsUseCaseWithMock.ts

@@ -0,0 +1,45 @@
+import { IUseCase } from './base/IUseCase';
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { PaginatedResult, Pagination } from '../repository/Pagination';
+
+export class GetAllDialogsUseCaseWithMock
+  implements IUseCase<void, PaginatedResult<DialogEntity>>
+{
+  private readonly dialogRepository: DialogsRepository;
+
+  private readonly pagination: Pagination;
+
+  constructor(dialogRepository: DialogsRepository, pagination?: Pagination) {
+    console.log('CONSTRUCTOR GetAllDialogsUseCaseWithMock');
+    this.dialogRepository = dialogRepository;
+    this.pagination = pagination || new Pagination();
+  }
+
+  async execute(): Promise<PaginatedResult<DialogEntity>> {
+    console.log('execute GetAllDialogsUseCaseWithMock');
+    const fromRemote: PaginatedResult<DialogEntity> =
+      await this.dialogRepository.getDialogsFromRemote(this.pagination);
+
+    await Promise.all(
+      fromRemote.ResultData.map(async (entity) => {
+        // eslint-disable-next-line no-return-await
+        return await this.dialogRepository.saveDialogToLocal(entity);
+      }),
+    );
+    // fromRemote.forEach((entity) => {
+    //   this.dialogRepository.saveDialogToLocal(entity);
+    //   console.log('store item to local: ', JSON.stringify(entity));
+    // });
+
+    const dialogs: Array<DialogEntity> =
+      await this.dialogRepository.getDialogsFromLocal(this.pagination);
+
+    return {
+      // PaginatedList: fromRemote.PaginatedList,
+      ResultData: dialogs,
+      CurrentPagination: fromRemote.CurrentPagination,
+    };
+    //  return this.dialogRepository.getDialogsFromLocal(this.pagination);
+  }
+}