quickblox-react-ui-kit 0.1.0

package/src/Data/repository/UsersRepository.ts

@@ -0,0 +1,324 @@
+import { ILocalDataSource } from '../source/local/ILocalDataSource';
+import { IRemoteDataSource } from '../source/remote/IRemoteDataSource';
+import { UserEntity } from '../../Domain/entity/UserEntity';
+import RepositoryException, {
+  UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
+  UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
+  USER_ENTITY_REPOSITORY_EXCEPTION_CODE,
+  USER_ENTITY_REPOSITORY_EXCEPTION_MESSAGE,
+} from '../source/exception/RepositoryException';
+import {
+  LocalDataSourceException,
+  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+  UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
+} from '../source/exception/LocalDataSourceException';
+import { IMapper } from '../mapper/IMapper';
+import { LocalUserDTO } from '../dto/user/LocalUserDTO';
+import { RemoteUserDTO } from '../dto/user/RemoteUserDTO';
+import { UserLocalDTOMapper } from '../mapper/UserLocalDTOMapper';
+import { UserRemoteDTOMapper } from '../mapper/UserRemoteDTOMapper';
+import {
+  INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+  INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+  RemoteDataSourceException,
+  UNAUTHORISED_REMOTE_DATASOURCE_EXCEPTION_CODE,
+} from '../source/exception/RemoteDataSourceException';
+import {
+  PaginatedResult,
+  Pagination,
+} from '../../Domain/repository/Pagination';
+import {
+  PaginatedDTOResult,
+  RemoteDataSource,
+} from '../source/remote/RemoteDataSource';
+
+export default class UsersRepository {
+  private localDataSource: ILocalDataSource;
+
+  private remoteDataSource: IRemoteDataSource;
+
+  private userRemoteDTOMapper: IMapper;
+
+  private userLocalDTOMapper: IMapper;
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(
+    localDataSource: ILocalDataSource,
+    remoteDataSource: IRemoteDataSource,
+  ) {
+    this.localDataSource = localDataSource;
+    this.remoteDataSource = remoteDataSource;
+    this.userLocalDTOMapper = new UserLocalDTOMapper();
+    this.userRemoteDTOMapper = new UserRemoteDTOMapper();
+  }
+
+  async getUserFromLocal(userId: number): Promise<UserEntity> {
+    let checkResult = true;
+
+    if (userId === 0) {
+      checkResult = false;
+    }
+    let userEntity: UserEntity = UserLocalDTOMapper.createDefaultUserEntity();
+
+    if (checkResult) {
+      try {
+        // TODO: change
+        const dto: LocalUserDTO = new LocalUserDTO();
+
+        dto.id = userId.toString();
+
+        const userDTO: LocalUserDTO = await this.localDataSource.getUser(dto);
+
+        userEntity = await this.userLocalDTOMapper.toEntity(userDTO);
+      } catch (e) {
+        if (e instanceof LocalDataSourceException) {
+          if (e.code !== UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE) {
+            return Promise.reject(
+              new RepositoryException(
+                NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
+                NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
+              ),
+            );
+          }
+
+          return Promise.reject(
+            new RepositoryException(
+              UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
+              UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
+            ),
+          );
+        }
+        checkResult = false;
+      }
+    }
+
+    const prom = new Promise<UserEntity>((resolve, reject) => {
+      if (checkResult === true) {
+        resolve(userEntity);
+      } else {
+        reject(
+          new RepositoryException(
+            USER_ENTITY_REPOSITORY_EXCEPTION_MESSAGE,
+            USER_ENTITY_REPOSITORY_EXCEPTION_CODE,
+          ),
+        );
+      }
+    });
+
+    return prom;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getUserFromRemote(userId: number): Promise<UserEntity> {
+    let checkResult = true;
+
+    if (userId === 0) {
+      checkResult = false;
+    }
+    let userEntity: UserEntity = UserLocalDTOMapper.createDefaultUserEntity();
+
+    if (checkResult) {
+      try {
+        // TODO: change
+        const dto: RemoteUserDTO = new RemoteUserDTO();
+
+        dto.id = userId.toString();
+
+        const userDTO: LocalUserDTO = await this.remoteDataSource.getUser(dto);
+
+        userEntity = await this.userRemoteDTOMapper.toEntity(userDTO);
+      } catch (e) {
+        if (e instanceof RemoteDataSourceException) {
+          if (e.code !== UNAUTHORISED_REMOTE_DATASOURCE_EXCEPTION_CODE) {
+            return Promise.reject(
+              new RepositoryException(
+                INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+                INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+              ),
+            );
+          }
+
+          return Promise.reject(
+            new RepositoryException(
+              UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
+              UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
+            ),
+          );
+        }
+        checkResult = false;
+      }
+    }
+
+    const prom = new Promise<UserEntity>((resolve, reject) => {
+      if (checkResult === true) {
+        resolve(userEntity);
+      } else {
+        reject(
+          new RepositoryException(
+            USER_ENTITY_REPOSITORY_EXCEPTION_MESSAGE,
+            USER_ENTITY_REPOSITORY_EXCEPTION_CODE,
+          ),
+        );
+      }
+    });
+
+    return prom;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getUsersFromLocal(usersIds: Array<number>): Promise<Array<UserEntity>> {
+    const arrayUserDTO: Array<LocalUserDTO> = new Array<LocalUserDTO>();
+
+    try {
+      for (let i = 0; i < usersIds.length; i += 1) {
+        let dto: LocalUserDTO = new LocalUserDTO();
+
+        dto.id = usersIds[i].toString();
+        // TODO: check loop with await
+        // eslint-disable-next-line no-await-in-loop
+        dto = await this.localDataSource.getUser(dto);
+        arrayUserDTO.push(dto);
+      }
+      const users: Array<UserEntity> = new Array<UserEntity>();
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const item of arrayUserDTO) {
+        // eslint-disable-next-line no-await-in-loop
+        const entity: UserEntity = await this.userLocalDTOMapper.toEntity(item);
+
+        users.push(entity);
+      }
+
+      return Promise.resolve(users);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getUsersFromRemote(
+    usersIds: Array<number>,
+  ): Promise<Array<UserEntity>> {
+    const arrayUserDTO: Array<RemoteUserDTO> = new Array<RemoteUserDTO>();
+
+    try {
+      for (let i = 0; i < usersIds.length; i += 1) {
+        let dto: RemoteUserDTO = new RemoteUserDTO();
+
+        dto.id = usersIds[i].toString();
+        // TODO: check loop with await
+        // eslint-disable-next-line no-await-in-loop
+        dto = await this.remoteDataSource.getUser(dto);
+        arrayUserDTO.push(dto);
+      }
+      const users: Array<UserEntity> = new Array<UserEntity>();
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const item of arrayUserDTO) {
+        // eslint-disable-next-line no-await-in-loop
+        const entity: UserEntity = await this.userRemoteDTOMapper.toEntity(
+          item,
+        );
+
+        users.push(entity);
+      }
+
+      return Promise.resolve(users);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getALLUsersFromRemote(
+    pagination?: Pagination,
+    filter?: string,
+  ): Promise<PaginatedResult<UserEntity>> {
+    const currentPagination: Pagination = pagination || new Pagination(1, 5);
+
+    if (this.remoteDataSource instanceof RemoteDataSource) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const result: PaginatedDTOResult =
+        await this.remoteDataSource.getAllUsers(currentPagination, filter);
+      const ResultData: UserEntity[] = [];
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const remoteUser of result.ResultData) {
+        // eslint-disable-next-line no-await-in-loop
+        const userEntity: UserEntity = await this.userRemoteDTOMapper.toEntity<
+          RemoteUserDTO,
+          UserEntity
+        >(remoteUser);
+
+        ResultData.push(userEntity);
+      }
+      // const PaginatedList: Record<number, UserEntity[]> = {};
+      //
+      // //
+      // // eslint-disable-next-line no-restricted-syntax
+      // for (const [key, value] of Object.entries(result.PaginatedList)) {
+      //   const remoteUsers: RemoteUserDTO[] = value;
+      //   const pageusers: UserEntity[] = [];
+      //
+      //   // eslint-disable-next-line no-restricted-syntax
+      //   for (const remoteUser of remoteUsers) {
+      //     const userEntity: UserEntity =
+      //       // eslint-disable-next-line no-await-in-loop
+      //       await this.userRemoteDTOMapper.toEntity<RemoteUserDTO, UserEntity>(
+      //         remoteUser,
+      //       );
+      //
+      //     pageusers.push(userEntity);
+      //   }
+      //
+      //   PaginatedList[parseInt(key, 10)] = pageusers;
+      // }
+
+      return {
+        // PaginatedList,
+        ResultData,
+        CurrentPagination: result.PaginationResult,
+      };
+    }
+
+    // eslint-disable-next-line prefer-promise-reject-errors
+    return Promise.reject(false);
+  }
+
+  async saveUsersToLocal(entities: Array<UserEntity>): Promise<boolean> {
+    try {
+      // TODO: check this loop
+      // eslint-disable-next-line no-restricted-syntax
+      for (const item of entities) {
+        // eslint-disable-next-line no-await-in-loop
+        const dto: LocalUserDTO = await this.userLocalDTOMapper.fromEntity(
+          item,
+        );
+
+        // eslint-disable-next-line no-await-in-loop
+        await this.localDataSource.saveUser(dto);
+      }
+
+      return Promise.resolve(true);
+    } catch (e) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      return Promise.reject(false);
+    }
+  }
+
+  async saveUserToLocal(entity: UserEntity): Promise<boolean> {
+    try {
+      const dto: LocalUserDTO = await this.userLocalDTOMapper.fromEntity(
+        entity,
+      );
+
+      await this.localDataSource.saveUser(dto);
+
+      return Promise.resolve(true);
+    } catch (e) {
+      // eslint-disable-next-line prefer-promise-reject-errors
+      return Promise.reject(false);
+    }
+  }
+}

package/src/Data/source/exception/LocalDataSourceException.ts

@@ -0,0 +1,17 @@
+import RepositoryException from './RepositoryException';
+
+export const UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_MESSAGE = 'unexpected';
+export const UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE = 111;
+
+export const ALREADY_LOCAL_DATASOURCE_EXIST_EXCEPTION_MESSAGE = 'already exist';
+export const ALREADY_LOCAL_DATASOURCE_EXIST_EXCEPTION_CODE = 112;
+
+export const NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE = 'not found';
+export const NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE = 113;
+
+export class LocalDataSourceException extends RepositoryException {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(message: string, code: number) {
+    super(message, code);
+  }
+}

package/src/Data/source/exception/MapperDTOException.ts

@@ -0,0 +1,19 @@
+import RepositoryException from './RepositoryException';
+
+export const UNEXPECTED_MAPPER_DTO_EXCEPTION_MESSAGE =
+  'Error. Mapper DTO Unexpected exception .';
+export const UNEXPECTED_MAPPER_DTO_EXCEPTION_EXCEPTION_CODE = 131;
+
+export const INCORRECT_DATA_MAPPER_DTO_EXCEPTION_MESSAGE =
+  'Error. Mapper DTO Incorrect data exception .';
+export const INCORRECT_DATA_MAPPER_DTO_EXCEPTION_CODE = 132;
+
+export class MapperDTOException extends RepositoryException {
+  public _description: string;
+
+  // eslint-disable-next-line no-useless-constructor
+  constructor(message: string, code: number, description = '') {
+    super(message, code);
+    this._description = description;
+  }
+}

package/src/Data/source/exception/RemoteDataSourceException.ts

@@ -0,0 +1,28 @@
+import RepositoryException from './RepositoryException';
+
+export const UNAUTHORISED_REMOTE_DATASOURCE_EXCEPTION_MESSAGE = 'unauthorised';
+export const UNAUTHORISED_REMOTE_DATASOURCE_EXCEPTION_CODE = 121;
+
+export const INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE =
+  'incorrect data';
+export const INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE = 122;
+
+export const RESTRICTED_REMOTE_DATASOURCE_ACCESS_EXCEPTION_MESSAGE =
+  'restricted access';
+export const RESTRICTED_REMOTE_DATASOURCE_ACCESS_EXCEPTION_CODE = 123;
+
+export const CONNECTION_FAILD_REMOTE_DATASOURCE_EXCEPTION_MESSAGE =
+  'connection failed';
+export const CONNECTION_FAILD_REMOTE_DATASOURCE_EXCEPTION_CODE = 124;
+
+export const NOT_FOUND_REMOTE_DATASOURCE_EXCEPTION_MESSAGE = 'not found';
+export const NOT_FOUND_REMOTE_DATASOURCE_EXCEPTION_CODE = 125;
+
+export class RemoteDataSourceException extends RepositoryException {
+  public description: string;
+
+  constructor(message: string, code: number, description = '') {
+    super(message, code);
+    this.description = description;
+  }
+}

package/src/Data/source/exception/RepositoryException.ts

@@ -0,0 +1,27 @@
+export const UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE = 'error';
+export const UNEXPECTED_REPOSITORY_EXCEPTION_CODE = 101;
+
+export const USER_ENTITY_REPOSITORY_EXCEPTION_MESSAGE =
+  'Error. UserId raise User Entity exception.';
+export const USER_ENTITY_REPOSITORY_EXCEPTION_CODE = 102;
+
+export const DIALOG_ENTITY_REPOSITORY_EXCEPTION_MESSAGE =
+  'Error. DialogId raise Dialog Entity exception.';
+export const DIALOG_ENTITY_REPOSITORY_EXCEPTION_CODE = 103;
+
+export const MESSAGE_ENTITY_REPOSITORY_EXCEPTION_MESSAGE =
+  'Error. MessageId raise Message Entity exception.';
+export const MESSAGE_ENTITY_REPOSITORY_EXCEPTION_CODE = 103;
+
+export const FILE_ENTITY_REPOSITORY_EXCEPTION_MESSAGE =
+  'Error. Id raise File Entity exception.';
+export const FILE_ENTITY_REPOSITORY_EXCEPTION_CODE = 104;
+
+export default class RepositoryException extends Error {
+  public readonly code: number;
+
+  constructor(public message: string, code: number) {
+    super(message);
+    this.code = code;
+  }
+}

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

@@ -0,0 +1,262 @@
+import { FunctionResult } from '../../../CommonTypes/FunctionResult';
+import { PublicDialogEntity } from '../../../Domain/entity/PublicDialogEntity';
+
+// const COLLECTION = 'CHATS';
+// request to server with sDK
+const listChats: PublicDialogEntity[] = [
+  {
+    id: '1',
+    name: 'Chat 1',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '2',
+    name: 'Chat 2',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '3',
+    name: 'Chat 3',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '4',
+    name: 'Chat 4',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '5',
+    name: 'Chat 5',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+];
+// request to local cash
+const listCasheChats: PublicDialogEntity[] = [
+  {
+    id: '1',
+    name: 'Cash Chat 1',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '2',
+    name: 'Cash Chat 2',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '3',
+    name: 'Chat 3 from Cash',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '4',
+    name: 'Chat 4 from Cash',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '5',
+    name: 'Chat 5 from Cash',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '6',
+    name: 'Chat 6 from Cash',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+];
+// request preloaded
+const preloadedChats: PublicDialogEntity[] = [
+  {
+    id: '1',
+    name: 'Preload Chat 1',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '2',
+    name: 'Preload Chat 2',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+  {
+    id: '3',
+    name: 'Preload Chat 3',
+    customData: { todo: '' },
+    lastMessage: { dateSent: '', text: '', userId: 0 },
+    ownerId: '',
+    photo: '',
+    type: 0,
+    unreadMessageCount: 0,
+    updatedAt: '',
+  },
+];
+
+export function getOne(
+  id: number,
+): Promise<FunctionResult<PublicDialogEntity>> {
+  console.log('StorageDataSource. getOne');
+  try {
+    const filteredData = listChats.filter((item) => item.id === id.toString());
+
+    console.log(
+      `getOne id = ${id}, filtredData = ${JSON.stringify(filteredData)}`,
+    );
+
+    return Promise.resolve({
+      error: null,
+      result: filteredData.length > 0 ? filteredData[0] : [],
+    });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}
+export function getOneFromCash(
+  id: number,
+): Promise<FunctionResult<PublicDialogEntity>> {
+  console.log('StorageDataSource. getOneFromCash');
+  try {
+    const filteredData = listCasheChats.filter(
+      (item) => item.id === id.toString(),
+    );
+
+    console.log(
+      `getOneFromCash id = ${id}, filtredData = ${JSON.stringify(
+        filteredData,
+      )}`,
+    );
+
+    return Promise.resolve({
+      error: null,
+      result: filteredData.length > 0 ? filteredData[0] : [],
+    });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}
+//
+export function getOneFromPreload(
+  id: number,
+): Promise<FunctionResult<PublicDialogEntity>> {
+  console.log('StorageDataSource. getOneFromPreload');
+  try {
+    const filteredData = preloadedChats.filter(
+      (item) => item.id === id.toString(),
+    );
+
+    console.log(
+      `getOne id = ${id}, filtredData = ${JSON.stringify(filteredData)}`,
+    );
+
+    return Promise.resolve({
+      error: null,
+      result: filteredData.length > 0 ? filteredData[0] : [],
+    });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}
+//
+export function getAll(): Promise<FunctionResult<PublicDialogEntity[]>> {
+  console.log('StorageDataSource. getAll');
+  try {
+    return Promise.resolve({ error: null, result: listChats });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}
+export function getAllFromCash(): Promise<
+  FunctionResult<PublicDialogEntity[]>
+> {
+  console.log('StorageDataSource. getAllFromCash');
+  try {
+    return Promise.resolve({ error: null, result: listCasheChats });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}
+//
+export function getAllFromPreload(): Promise<
+  FunctionResult<PublicDialogEntity[]>
+> {
+  console.log('StorageDataSource. getAllFromPreload');
+  try {
+    return Promise.resolve({ error: null, result: preloadedChats });
+  } catch (err) {
+    return Promise.resolve({ error: err, result: [] });
+  }
+}