code refactoring

This commit is contained in:
Peter Maquiran
2024-08-18 13:27:57 +01:00
parent 650c772084
commit ef12ff439d
50 changed files with 729 additions and 735 deletions
@@ -1,48 +0,0 @@
import { Injectable } from '@angular/core';
import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
import { z } from 'zod';
import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
const MemberTableSchema = z.object({
$roomIdUserId: z.string().optional(),
id: z.string(),
roomId: z.string(),
user: z.object({
wxUserId: z.number(),
wxFullName: z.string(),
wxeMail: z.string(),
userPhoto: z.string().nullable(),
}),
joinAt: z.string(),
status: z.string()
})
export type IMemberTable = z.infer<typeof MemberTableSchema>
type IMemberTableSchema = EntityTable<IMemberTable, '$roomIdUserId'>
// Database declaration (move this to its own module also)
export const roomMemberList = new Dexie('roomMemberList') as Dexie & {
memberList: EntityTable<IMemberTable, '$roomIdUserId'>;
};
roomMemberList.version(1).stores({
memberList: '$roomIdUserId, id, user, joinAt, roomId, status',
});
@Injectable({
providedIn: 'root'
})
export class MemberListLocalDataSourceService extends DexieRepository<IMemberTable> {
constructor() {
super(roomMemberList.memberList, MemberTableSchema);
// messageDataSource.message.hook('creating', (primKey, obj, trans) => {
// // const newMessage = await trans.table('message').get(primKey);
// this.messageSubject.next(obj);
// // return newMessage
// })
}
}
@@ -1,44 +0,0 @@
import { Injectable } from '@angular/core';
import { SignalRService } from '../../../infra/socket/signal-r.service';
import { AddMemberToRoomInputDTO } from '../../dto/room/addMemberToRoomInputDto';
import { v4 as uuidv4 } from 'uuid'
@Injectable({
providedIn: 'root'
})
export class RoomLiveDataSourceService {
constructor(
private socket: SignalRService,
) {}
// async getRoomById(data: WebSocketMessage) {
// try {
// const result = await this.socket.sendMessage(data).toPromise()
// console.log({result})
// return ok(result)
// } catch (e) {
// return err(e)
// }
// }
async addMemberToRoom(data: AddMemberToRoomInputDTO) {
const result = await this.socket.sendData({
method: 'AddRoomMember',
data: {
requestId: uuidv4(),
roomId: data.id,
members: data.members
}
})
console.log({result})
return result
}
}
@@ -1,65 +0,0 @@
import { createAction, createFeatureSelector, createReducer, createSelector, on, props } from "@ngrx/store";
import { RoomOutPutDTO } from "../../dto/room/roomOutputDTO";
import { RoomTable } from "../../../infra/database/dexie/schema/room";
export interface ChatRoom {
[roomId: string]: RoomTable[];
}
export interface RoomRemoteDataSourceState {
chatRooms: ChatRoom;
}
export const initialState: RoomRemoteDataSourceState = {
chatRooms: {
// add more rooms as needed
}
};
export const addMessage = createAction(
'[Chat] Add Message',
props<{ roomId: string; message: any }>()
);
export const addRoom = createAction(
'[Chat] Add Room',
props<RoomOutPutDTO>()
);
const _chatReducer = createReducer(
initialState,
on(addMessage, (state, { roomId, message }) => ({
...state,
chatRooms: {
...state.chatRooms,
[roomId]: [...(state.chatRooms[roomId] || []), message]
}
})),
on(addRoom, (state, roomData: RoomOutPutDTO) => ({
...state,
chatRooms: {
...state.chatRooms,
[roomData.data.roomName]: roomData.data
}
}))
);
export function chatReducer(state, action) {
return _chatReducer(state, action);
}
// Create a feature selector
export const selectChatState = createFeatureSelector<RoomRemoteDataSourceState>('chat');
// Create a selector for a specific room's messages
export const selectMessagesByRoom = (roomId: string) => createSelector(
selectChatState,
(state: RoomRemoteDataSourceState) => state.chatRooms[roomId] || []
);
// Create a selector for the list of rooms
export const selectAllRooms = createSelector(
selectChatState,
(state: RoomRemoteDataSourceState) => Object.keys(state.chatRooms)
);
@@ -1,72 +1,31 @@
import { Injectable } from '@angular/core';
import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
import { liveQuery, Observable } from 'Dexie';
import { err, ok, Result } from 'neverthrow';
import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../dto/room/roomListOutputDTO';
import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
import { z } from 'zod';
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { MemberListUPdateStatusInputDTO } from '../../../domain/use-case/socket/member-list-update-status-use-case.service';
import { MemberTable } from '../../../infra/database/dexie/schema/members';
import { chatDatabase } from '../../../infra/database/dexie/service';
import { RoomTable, RoomTableSchema } from '../../../infra/database/dexie/schema/room';
import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
import { RoomTable, RoomTableSchema } from '../../infra/database/dexie/schema/room';
import { chatDatabase } from '../../infra/database/dexie/service';
import { ok } from 'neverthrow';
import { err, Result } from 'neverthrow';
import { MemberListUPdateStatusInputDTO } from '../../domain/use-case/socket/member-list-update-status-use-case.service';
import { MemberTable } from '../../infra/database/dexie/schema/members';
@Injectable({
providedIn: 'root'
})
export class RoomLocalDataSourceService extends DexieRepository<RoomTable> {
export class MemberListLocalRepository extends DexieRepository<RoomTable> {
constructor() {
super(chatDatabase.room, RoomTableSchema)
// messageDataSource.message.hook('creating', (primKey, obj, trans) => {
// // const newMessage = await trans.table('message').get(primKey);
// this.messageSubject.next(obj);
// // return newMessage
// })
}
async removeUserTyping() {}
@ValidateSchema(RoomTableSchema)
async createRoom(data: RoomTable) {
try {
const result = await chatDatabase.room.add(data)
return ok(result)
} catch (e) {
return err(false)
}
}
async deleteRoomById(id: string) {
try {
const result = await chatDatabase.room.delete(id)
return ok(result)
} catch (e) {
return err(false)
}
}
async leaveRoom(id: string) {
return this.deleteRoomById(id)
}
async updateRoom(data: RoomTable) {
try {
const result = await chatDatabase.room.update(data.id, data);
return ok(result)
} catch (e) {
return err(false)
}
}
async createOrUpdateRoom(data: RoomTable) {
const createResult = await this.createRoom(data)
if(createResult.isOk()) {
return createResult
} else {
return this.updateRoom(data)
}
}
async addMember(data: MemberTable) {
try {
data.$roomIdUserId = data.roomId + data.wxUserId
@@ -122,7 +81,7 @@ export class RoomLocalDataSourceService extends DexieRepository<RoomTable> {
const member = await chatDatabase.members.where({ $roomIdUserId: $roomIdUserId }).first();
if (member) {
const result = await ok(chatDatabase.members.delete($roomIdUserId));
const result = ok(await chatDatabase.members.delete($roomIdUserId));
console.log(`Member with $roomIdUserId ${$roomIdUserId} removed from room ${member.roomId}.`);
return result
} else {
@@ -135,19 +94,6 @@ export class RoomLocalDataSourceService extends DexieRepository<RoomTable> {
}
}
async getRoomById(id: any) {
try {
const result = await chatDatabase.room.get(id)
return ok(result)
} catch (e) {
return err(false)
}
}
async getRoomList() {
return await chatDatabase.room.toArray()
}
getMemberLive(data: {roomId, wxUserId}) {
const $roomIdUserId = data.roomId + data.wxUserId
@@ -175,6 +121,4 @@ export class RoomLocalDataSourceService extends DexieRepository<RoomTable> {
return members.filter(e => e.isAdmin != true)
})
}
}
@@ -3,13 +3,13 @@ import { Result } from 'neverthrow';
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { HttpService } from 'src/app/services/http.service';
import { DataSourceReturn } from 'src/app/services/Repositorys/type';
import { AddMemberToRoomInputDTOSchema, AddMemberToRoomInputDTO } from '../../dto/room/addMemberToRoomInputDto';
import { UserRemoveListInputDTOSchema, UserRemoveListInputDTO } from '../../dto/room/userRemoveListInputDTO';
import { AddMemberToRoomInputDTOSchema, AddMemberToRoomInputDTO } from '../dto/room/addMemberToRoomInputDto';
import { UserRemoveListInputDTOSchema, UserRemoveListInputDTO } from '../dto/room/userRemoveListInputDTO';
@Injectable({
providedIn: 'root'
})
export class MemberListRemoteDataSourceService {
export class MemberListRemoteRepository {
private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
@@ -4,14 +4,9 @@ import { SessionStore } from 'src/app/store/session.service';
import { SignalRService } from '../../infra/socket/signal-r.service';
import { v4 as uuidv4 } from 'uuid'
import { err, ok } from 'neverthrow';
import { MessageDeleteInputDTO } from '../../domain/use-case/message-delete-live-use-case.service';
import { MessageUpdateInput } from '../../domain/use-case/message-update-use-case.service';
import { messageListDetermineChanges } from '../async/list/rooms/messageListChangedetector';
import { MessageEntity } from '../../domain/entity/message';
import { MessageDeleteInputDTO } from '../../domain/use-case/message-delete-by-id-live-use-case.service';
import { MessageUpdateInput } from '../../domain/use-case/message-update-by-id-use-case.service';
import { InstanceId } from '../../domain/chat-service.service';
import { MessageMapper } from '../../domain/mapper/messageMapper';
import { MessageOutPutDataDTO } from '../dto/message/messageOutputDTO';
import { MessageTable } from 'src/app/module/chat/infra/database/dexie/schema/message';
import { MessageLocalDataSourceService } from '../data-source/message/message-local-data-source.service';
import { MessageLiveDataSourceService } from '../data-source/message/message-live-signalr-data-source.service';
import { AttachmentLocalDataSource } from 'src/app/module/chat/data/data-source/attachment/attachment-local-data-source.service'
@@ -29,48 +24,6 @@ export class MessageRepositoryService {
private AttachmentLocalDataSourceService: AttachmentLocalDataSource
) {}
async createMessageLocally(entity: MessageEntity) {
//const requestId = InstanceId +'@'+ uuidv4();
const localActionResult = await this.messageLocalDataSourceService.sendMessage(entity)
return localActionResult.map(e => {
entity.$id = e
return entity
})
}
async sendMessage(entity: MessageEntity) {
entity.sending = true
const DTO = MessageMapper.fromDomain(entity, entity.requestId)
const sendMessageResult = await this.messageLiveSignalRDataSourceService.sendMessage<MessageOutPutDataDTO>(DTO)
// return this sendMessageResult
if(sendMessageResult.isOk()) {
if(sendMessageResult.value.sender == undefined || sendMessageResult.value.sender == null) {
delete sendMessageResult.value.sender
}
let clone: MessageTable = {
...sendMessageResult.value,
id: sendMessageResult.value.id,
$id : entity.$id
}
return this.messageLocalDataSourceService.update(entity.$id, {...clone, sending: false, roomId: entity.roomId})
} else {
await this.messageLocalDataSourceService.update(entity.$id, {sending: false, $id: entity.$id})
return err('no connection')
}
}
sendMessageDelete(data: MessageDeleteInputDTO) {
data['requestId'] = InstanceId +'@'+ uuidv4();
@@ -104,36 +57,6 @@ export class MessageRepositoryService {
})
}
async listAllMessagesByRoomId(id: string) {
const result = await this.messageRemoteDataSourceService.getMessagesFromRoom(id)
const localResult = await this.messageLocalDataSourceService.getItems(id)
if(result.isOk()) {
const { addedItems, changedItems, deletedItems } = messageListDetermineChanges(result.value.data, localResult)
for(const message of changedItems) {
let clone: MessageTable = message
clone.roomId = id
this.messageLocalDataSourceService.findOrUpdate(clone)
}
for(const message of addedItems) {
let clone: MessageTable = message
clone.roomId = id
}
this.messageLocalDataSourceService.createManyMessage(addedItems.reverse())
for(const message of deletedItems) {
this.messageLocalDataSourceService.deleteByMessageId(message.id)
}
return ok(addedItems)
}
return result
}
getItemsLive (roomId: string) {
return this.messageLocalDataSourceService.getItemsLive(roomId)
@@ -0,0 +1,93 @@
import { Injectable } from '@angular/core';
import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../dto/room/roomListOutputDTO';
import { liveQuery, Observable } from 'Dexie';
import { err, ok, Result } from 'neverthrow';
import { z } from 'zod';
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { chatDatabase } from '../../infra/database/dexie/service';
import { RoomTable, RoomTableSchema } from '../../infra/database/dexie/schema/room';
import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
@Injectable({
providedIn: 'root'
})
export class RoomLocalRepository extends DexieRepository<RoomTable> {
constructor() {
super(chatDatabase.room, RoomTableSchema)
}
async removeUserTyping() {}
@ValidateSchema(RoomTableSchema)
async createRoom(data: RoomTable) {
try {
const result = await chatDatabase.room.add(data)
return ok(result)
} catch (e) {
return err(false)
}
}
async deleteRoomById(id: string) {
try {
const result = await chatDatabase.room.delete(id)
return ok(result)
} catch (e) {
return err(false)
}
}
async leaveRoom(id: string) {
return this.deleteRoomById(id)
}
async updateRoom(data: RoomTable) {
try {
const result = await chatDatabase.room.update(data.id, data);
return ok(result)
} catch (e) {
return err(false)
}
}
async createOrUpdateRoom(data: RoomTable) {
const createResult = await this.createRoom(data)
if(createResult.isOk()) {
return createResult
} else {
return this.updateRoom(data)
}
}
async getRoomById(id: any) {
try {
const result = await chatDatabase.room.get(id)
return ok(result)
} catch (e) {
return err(false)
}
}
async getRoomList() {
return await this.findAll()
}
getItemsLive(): Observable<RoomListOutPutDTO[]> {
return liveQuery(() => chatDatabase.room.toArray()) as any;
}
getRoomByIdLive(id: any): Observable<RoomListItemOutPutDTO | undefined> {
return liveQuery(() => chatDatabase.room.get(id)) as any;
}
}
@@ -1,20 +1,22 @@
import { Injectable } from '@angular/core';
import { Result } from 'neverthrow';
import { HttpService } from 'src/app/services/http.service';
import { RoomListOutPutDTO, RoomListOutPutDTOSchema } from '../../dto/room/roomListOutputDTO';
import { RoomInputDTO, RoomInputDTOSchema } from '../../dto/room/roomInputDTO';
import { RoomOutPutDTO, RoomOutPutDTOSchema } from '../../dto/room/roomOutputDTO';
import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../../dto/room/addMemberToRoomInputDto';
import { RoomListOutPutDTO, RoomListOutPutDTOSchema } from '../dto/room/roomListOutputDTO';
import { RoomInputDTO, RoomInputDTOSchema } from '../dto/room/roomInputDTO';
import { RoomOutPutDTO, RoomOutPutDTOSchema } from '../dto/room/roomOutputDTO';
import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../dto/room/addMemberToRoomInputDto';
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { RoomByIdInputDTO, RoomByIdInputDTOSchema } from '../../dto/room/roomByIdInputDTO';
import { RoomByIdOutputDTO, RoomByIdOutputDTOSchema } from '../../dto/room/roomByIdOutputDTO';
import { RoomByIdInputDTO, RoomByIdInputDTOSchema } from '../dto/room/roomByIdInputDTO';
import { RoomByIdOutputDTO, RoomByIdOutputDTOSchema } from '../dto/room/roomByIdOutputDTO';
import { APIReturn } from 'src/app/services/decorators/api-validate-schema.decorator';
import { UserRemoveListInputDTO, UserRemoveListInputDTOSchema } from '../../dto/room/userRemoveListInputDTO';
import { RoomUpdateInputDTO, RoomUpdateInputDTOSchema } from '../../dto/room/roomUpdateInputDTO';
import { RoomUpdateOutputDTO } from '../../dto/room/roomUpdateOutputDTO';
import { UserRemoveListInputDTO, UserRemoveListInputDTOSchema } from '../dto/room/userRemoveListInputDTO';
import { RoomUpdateInputDTO, RoomUpdateInputDTOSchema } from '../dto/room/roomUpdateInputDTO';
import { RoomUpdateOutputDTO } from '../dto/room/roomUpdateOutputDTO';
import { DataSourceReturn } from 'src/app/services/Repositorys/type';
import { SessionStore } from 'src/app/store/session.service';
import { MemberSetAdminDTO } from '../../../domain/use-case/member-admin-use-case.service';
import { MemberSetAdminDTO } from '../../domain/use-case/member-admin-use-case.service';
import { SignalRService } from '../../infra/socket/signal-r.service';
import { v4 as uuidv4 } from 'uuid'
@Injectable({
providedIn: 'root'
@@ -23,7 +25,10 @@ export class RoomRemoteDataSourceService {
private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
constructor(private httpService: HttpService) {}
constructor(
private httpService: HttpService,
private socket: SignalRService,
) {}
@ValidateSchema(RoomInputDTOSchema)
@@ -71,4 +76,20 @@ export class RoomRemoteDataSourceService {
return await this.httpService.patch<any>(`${this.baseUrl}/Room/${data.roomId}/Member/${data.memberId}/admin`);
}
async addMemberToRoomSocket(data: AddMemberToRoomInputDTO) {
const result = await this.socket.sendData({
method: 'AddRoomMember',
data: {
requestId: uuidv4(),
roomId: data.id,
members: data.members
}
})
console.log({result})
return result
}
}
@@ -1,309 +0,0 @@
import { Injectable } from '@angular/core';
import { RoomRemoteDataSourceService } from '../data-source/room/room-remote-data-source.service'
import { RoomInputDTO } from '../dto/room/roomInputDTO';
import { AddMemberToRoomInputDTO } from '../dto/room/addMemberToRoomInputDto';
import { RoomLocalDataSourceService } from '../data-source/room/rooom-local-data-source.service';
import { RoomByIdInputDTO } from '../dto/room/roomByIdInputDTO';
import { roomListDetermineChanges } from '../async/list/rooms/roomListChangeDetector';
import { UserRemoveListInputDTO } from '../dto/room/userRemoveListInputDTO';
import { roomMemberListDetermineChanges } from '../async/list/rooms/roomMembersChangeDetector';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { RoomUpdateInputDTO } from '../dto/room/roomUpdateInputDTO';
import { SessionStore } from 'src/app/store/session.service';
import { RoomLiveDataSourceService } from '../data-source/room/room-live-data-source.service';
import { isHttpResponse } from 'src/app/services/http.service';
import { MemberListUPdateStatusInputDTO } from '../../domain/use-case/socket/member-list-update-status-use-case.service';
import { MemberSetAdminDTO } from '../../domain/use-case/member-admin-use-case.service';
import { MemberListMapper } from '../../domain/mapper/memberLIstMapper';
function date(isoDateString) {
let date = new Date(isoDateString);
const tzOffset = -date.getTimezoneOffset(); // in minutes
const diff = tzOffset >= 0 ? '+' : '-';
const pad = (n: number) => (n < 10 ? '0' : '') + n;
return date.getFullYear() +
'-' + pad(date.getMonth() + 1) +
'-' + pad(date.getDate()) +
'T' + pad(date.getHours()) +
':' + pad(date.getMinutes()) +
':' + pad(date.getSeconds()) +
diff + pad(Math.floor(Math.abs(tzOffset) / 60)) +
':' + pad(Math.abs(tzOffset) % 60);
}
@Injectable({
providedIn: 'root'
})
export class RoomRepositoryService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
// private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
private roomLocalDataSourceService: RoomLocalDataSourceService,
private roomLiveSignalRDataSourceService: RoomLiveDataSourceService,
) {}
@captureAndReraiseAsync('RoomRepositoryService/list')
async list() {
const result = await this.roomRemoteDataSourceService.getRoomList()
const localList = await this.roomLocalDataSourceService.getRoomList()
if(result.isOk()) {
const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList)
for( const roomData of roomsToInsert) {
this.roomLocalDataSourceService.createRoom(roomData.chatRoom)
}
for( const roomData of roomsToUpdate) {
this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
}
for( const roomData of roomsToDelete) {
this.roomLocalDataSourceService.deleteRoomById(roomData.id)
}
try {
const rooms = roomsToInsert.concat(roomsToUpdate)
for(const room of rooms) {
const expirationDate = new Date(room.chatRoom.expirationDate);
const now = new Date();
if (room.chatRoom.expirationDate != null && expirationDate.getTime() >= now.getTime()) {
const timeRemaining = expirationDate.getTime() - now.getTime();
setTimeout(() => {
this.list()
}, timeRemaining)
}
}
} catch (error) {
console.log(error)
}
}
return result
}
async getRoomList() {
return await this.roomLocalDataSourceService.getRoomList()
}
@captureAndReraiseAsync('RoomRepositoryService/updateRoomBy')
async updateRoomBy(data: RoomUpdateInputDTO) {
const result = await this.roomRemoteDataSourceService.updateRoom(data)
if(result.isOk()) {
const localList = await this.roomLocalDataSourceService.getRoomList()
// const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([result.value.data], localList)
// for( const roomData of roomsToUpdate) {
// if(!roomData.chatRoom.createdBy?.wxUserId) {
// delete roomData.chatRoom.createdBy;
// }
// this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
// }
}
return result
}
@captureAndReraiseAsync('RoomRepositoryService/getRoomById')
async getRoomById(id: RoomByIdInputDTO) {
const result = await this.roomRemoteDataSourceService.getRoom(id)
if(result.isOk()) {
const localListRoom = await this.roomLocalDataSourceService.getRoomList()
const object = {
chatRoom: result.value.data
}
const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom)
for( const roomData of roomsToUpdate) {
this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
}
// ============================
const localList = await this.roomLocalDataSourceService.getRoomMemberById(id)
const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)
for (const user of membersToInsert) {
await this.roomLocalDataSourceService.addMember(MemberListMapper(user, id))
}
for (const user of membersToUpdate) {
await this.roomLocalDataSourceService.updateMemberRole(MemberListMapper(user, id))
}
for(const user of membersToDelete) {
await this.roomLocalDataSourceService.removeMemberFromRoom(user.$roomIdUserId)
}
} else if (isHttpResponse(result.error) ) {
if(result.error.status == 404) {
await this.roomLocalDataSourceService.deleteRoomById(id)
}
// this.httpErrorHandle.httpStatusHandle(result.error)
}
return result
}
@captureAndReraiseAsync('RoomRepositoryService/deleteRoomById')
async deleteRoomById(id: RoomByIdInputDTO) {
const result = await this.roomRemoteDataSourceService.deleteRoom(id)
if(result.isOk()) {
const result = await this.roomLocalDataSourceService.deleteRoomById(id)
// this.messageLiveDataSourceService.sendMessage({
// type: 'createRoom',
// payload: {a: '5'}
// })
return result
} else if (isHttpResponse(result.error)) {
if(result.error.status == 404) {
await this.roomLocalDataSourceService.deleteRoomById(id)
}
// this.httpErrorHandle.httpStatusHandle(result.error)
}
return result
}
@captureAndReraiseAsync('RoomRepositoryService/create')
async create(data: RoomInputDTO) {
const result = await this.roomRemoteDataSourceService.createRoom(data)
if(result.isOk()) {
if(!result.value.data.createdBy) {
let dataObject;
result.value.data.createdBy = {
wxeMail: SessionStore.user.Email,
wxFullName: SessionStore.user.FullName,
wxUserId: SessionStore.user.UserId,
}
dataObject = result.value.data
dataObject.lastMessage = {
sentAt: date(new Date()),
message: "",
sender: {
wxUserId: "",
wxFullName: "",
},
}
}
// this.roomMemoryDataSourceService.dispatch(addRoom(result.value))
const localResult = await this.roomLocalDataSourceService.createRoom(result.value.data)
// this.messageLiveDataSourceService.sendMessage({
// type: 'createRoom',
// payload: {a: '5'}
// })
return localResult.map(e => result.value)
}
return result
}
@captureAndReraiseAsync('RoomRepositoryService/addMemberToRoom')
async addMemberToRoom(data: AddMemberToRoomInputDTO) {
// return this.roomLiveSignalRDataSourceService.addMemberToRoom(data)
const result = await this.roomRemoteDataSourceService.addMemberToRoom(data)
return result
}
async updateMemberStatus(data: MemberListUPdateStatusInputDTO) {
const result = await this.roomLocalDataSourceService.updateMembersStatus(data)
return result
}
@captureAndReraiseAsync('RoomRepositoryService/removeMemberToRoom')
async removeMemberToRoom(data: UserRemoveListInputDTO) {
const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
return result
}
setAdmin(input: MemberSetAdminDTO) {
return this.roomRemoteDataSourceService.setAmin(input);
}
async leaveRoom(data: UserRemoveListInputDTO) {
const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
if(result.isOk()) {
this.roomLocalDataSourceService.leaveRoom(data.id)
} else if (isHttpResponse(result.error)) {
if(result.error.status == 404) {
await this.roomLocalDataSourceService.deleteRoomById(data.id)
}
// this.httpErrorHandle.httpStatusHandle(result.error)
}
return result
}
getItemsLive() {
return this.roomLocalDataSourceService.getItemsLive()
}
getItemByIdLive(id: any) {
return this.roomLocalDataSourceService.getRoomByIdLive(id)
}
getRoomMemberByIdLive(roomId: any) {
return this.roomLocalDataSourceService.getRoomMemberByIdLive(roomId)
}
getRoomMemberById(roomId: any) {
return this.roomLocalDataSourceService.getRoomMemberById(roomId)
}
getRoomStatus(roomId:string) {
return this.roomLocalDataSourceService.allMemberOnline(roomId);
}
getRoomMemberNoneAdminByIdLive(roomId) {
return this.roomLocalDataSourceService.getRoomMemberNoneAdminByIdLive(roomId)
}
get find() {
return this.roomLocalDataSourceService.find
}
get findAll() {
return this.roomLocalDataSourceService.findAll
}
}