quickblox-react-ui-kit 0.4.2-beta.3 → 0.4.2-beta.5

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,19 @@
+import EventMessageType from './EventMessageType';
+import { NotificationTypes } from './NotificationTypes';
+import { MessageEntity } from './MessageEntity';
+import { DialogEntity } from './DialogEntity';
+
+export type MessageStatus = {
+  deliveryStatus: 'delivered' | 'read' | 'sent' | 'sending';
+  isTyping: boolean;
+  userId: number;
+  dialogId: string;
+  messageId: string;
+};
+export type DialogEventInfo = {
+  eventMessageType: EventMessageType;
+  notificationTypes: NotificationTypes | undefined;
+  dialogInfo?: DialogEntity | 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?: 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: number;
+  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: string;
+  dialogId: string;
+  dialogType?: DialogType;
+  attachments?: ChatMessageAttachmentEntity[];
+  notification_type?: string;
+  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;
+  qb_message_action?: 'forward' | 'reply';
+  origin_sender_name?: string;
+  qb_original_messages?: MessageEntity[];
+}

package/src/Domain/entity/NotificationTypes.ts

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

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,80 @@
+import { DialogEntity } from './DialogEntity';
+import { CustomDataEntity } from './CustomDataEntity';
+import { LastMessageEntity } from './LastMessageEntity';
+import { DialogType } from './DialogTypes';
+import { GroupDialogEntity } from './GroupDialogEntity';
+import { PrivateDialogEntity } from './PrivateDialogEntity';
+
+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 &&
+      (d as GroupDialogEntity).participantIds.length > 0
+    ) {
+      return [(d as GroupDialogEntity).participantIds[0]];
+    }
+    // artan 22.06.23
+    if (
+      d.type === DialogType.private &&
+      (d as PrivateDialogEntity).participantId
+    ) {
+      return [(d as PrivateDialogEntity).participantId];
+    }
+
+    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,13 @@
+export interface UserEntity {
+  id: number;
+  full_name: string;
+  email: string;
+  login: string;
+  created_at: string;
+  updated_at: string;
+  last_request_at: string;
+  blob_id: string | null;
+  photo: string | null;
+  custom_data: string | null;
+  user_tags: string | null;
+}

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,42 @@
+import { DialogEntity } from '../entity/DialogEntity';
+import { FunctionTypeVoidToVoid } from '../../CommonTypes/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;
+
+  release(): 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<MessageEntity>;
+
+  sendMessageToRemote(message: MessageEntity): Promise<MessageEntity>;
+
+  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,79 @@
+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;
+
+  private textInformationMessage: string;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    newDialog: GroupDialogEntity,
+    textInformationMessage: string,
+  ) {
+    console.log('CONSTRUCTOR CreateDialogUseCase');
+    this.dialogRepository = dialogRepository;
+    this.newDialog = newDialog;
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.textInformationMessage = textInformationMessage;
+  }
+
+  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 =
+      this.textInformationMessage && this.textInformationMessage.length > 0
+        ? this.textInformationMessage
+        : `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/ForwardMessagesUseCase.ts

@@ -0,0 +1,73 @@
+import { IUseCase } from './base/IUseCase';
+import { MessageEntity } from '../entity/MessageEntity';
+import MessagesRepository from '../../Data/repository/MessagesRepository';
+import { DialogEntity } from '../entity/DialogEntity';
+import { DialogType } from '../entity/DialogTypes';
+import { PrivateDialogEntity } from '../entity/PrivateDialogEntity';
+
+export class ForwardMessagesUseCase implements IUseCase<void, boolean> {
+  private messagesRepository: MessagesRepository;
+
+  private targetDialogs: DialogEntity[];
+
+  private messagesToForward: MessageEntity[];
+
+  private relatedMessage: MessageEntity;
+
+  private userName: string;
+
+  constructor(
+    messagesRepository: MessagesRepository,
+    targetDialogs: DialogEntity[],
+    messagesToForward: MessageEntity[],
+    relatedMessage: MessageEntity,
+    userName: string,
+  ) {
+    console.log('CONSTRUCTOR ForwardMessagesUseCase');
+    this.messagesRepository = messagesRepository;
+    this.relatedMessage = relatedMessage;
+    this.targetDialogs = targetDialogs;
+    this.messagesToForward = messagesToForward;
+    this.userName = userName;
+  }
+
+  async execute(): Promise<boolean> {
+    console.log('execute ForwardMessagesUseCase');
+
+    const promises = this.targetDialogs.map(async (targetDialog) => {
+      const dialogId = targetDialog.id;
+
+      const messageToSend: MessageEntity = {
+        ...this.relatedMessage,
+        dialogId,
+        dialogType: targetDialog.type, // added by artik 2024-01-18
+        qb_original_messages: this.messagesToForward,
+        qb_message_action: 'forward',
+        origin_sender_name:
+          this.relatedMessage.sender?.full_name || this.userName,
+      };
+
+      // added by artik 2024-01-18
+      if (targetDialog.type === DialogType.private) {
+        messageToSend.recipient_id = (
+          targetDialog as PrivateDialogEntity
+        ).participantId;
+      }
+      const sentMessage = await this.messagesRepository.sendMessageToRemote(
+        messageToSend,
+      );
+
+      return sentMessage;
+    });
+
+    const sentMessages: Awaited<MessageEntity | undefined>[] =
+      await Promise.all(promises); // all - нужно, чтобы все промисы выполнились, а
+    // Promise.allSettled(promises);// any - чтобы хотя бы один выполнился
+
+    const allMessagesSent = sentMessages?.every(
+      (message) => message && message.id && message.id.length > 0,
+    );
+
+    return Promise.resolve(allMessagesSent || false);
+  }
+}

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();
+  }
+}