peter/doneit-web
1
0
Fork 0
mirror of https://code.equilibrium.co.ao/ITO/doneit-web.git synced 2026-04-18 20:47:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

code refactoring

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files
src/app/module/chat/chat.module.ts
+3 -3
View File
@@ -30,7 +30,7 @@ export class ChatModule {
}
syncMessage() {
async syncMessage() {
const connection = this.SignalRService.getConnectionState()
connection.pipe(
@@ -38,7 +38,7 @@ export class ChatModule {
).subscribe((value)=> {
if(value) {
// on reconnect
this.ChatServiceService.asyncAllRoomMessage();
this.ChatServiceService.start();
}
});
@@ -52,7 +52,7 @@ export class ChatModule {
// on page reload sync
if(!(!SessionStore.user.Inactivity || !SessionStore.exist)) {
this.ChatServiceService.asyncAllRoomMessage();
this.ChatServiceService.start();
}
}
}
src/app/module/chat/data/data-source/member-list/member-list-local-data-source.service.ts
-48
View File
@@ -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
// })
}
}
src/app/module/chat/data/data-source/room/room-live-data-source.service.ts
-44
View File
@@ -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
}
}
src/app/module/chat/data/data-source/room/room-memory-data-source.ts
-65
View File
@@ -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)
);
src/app/module/chat/data/data-source/room/rooom-local-data-source.service.ts → src/app/module/chat/data/repository/member-list-local-repository.service.ts
+17 -73
View File
@@ -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)
})
}
}
src/app/module/chat/data/data-source/member-list/member-list-remote-data-source.service.ts → src/app/module/chat/data/repository/member-list-remote-repository.service.ts
+3 -3
View File
@@ -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
src/app/module/chat/data/repository/message-respository.service.ts
+2 -79
View File
@@ -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)
src/app/module/chat/data/repository/room-local-repository.service.ts
+93
View File
@@ -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;
}
}
src/app/module/chat/data/data-source/room/room-remote-data-source.service.ts → src/app/module/chat/data/repository/room-remote-repository.service.ts
+32 -11
View File
@@ -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
}
}
src/app/module/chat/data/repository/room-repository.service.ts
-309
View File
@@ -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
}
}
src/app/module/chat/domain/chat-service.service.ts
+68 -9
View File
@@ -1,26 +1,38 @@
import { Injectable } from '@angular/core';
import { MessageDeleteLiveUseCaseService, MessageDeleteInputDTO } from 'src/app/module/chat/domain/use-case/message-delete-live-use-case.service'
import { MessageDeleteLiveUseCaseService } from 'src/app/module/chat/domain/use-case/message-delete-by-id-live-use-case.service'
import { SessionStore } from 'src/app/store/session.service';
import { MessageReactionInput, MessageReactionUseCaseService } from 'src/app/module/chat/domain/use-case/message-reaction-use-case.service';
import { MessageUpdateInput, MessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/message-update-use-case.service';
import { MessageReactionInput, MessageReactionUseCaseService } from 'src/app/module/chat/domain/use-case/message-reaction-by-id-use-case.service';
import { MessageUpdateInput, MessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/message-update-by-id-use-case.service';
import { MemberAdminUseCaseService, MemberSetAdminDTO } from 'src/app/module/chat/domain/use-case/member-admin-use-case.service';
import { MessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/message-create-use-case.service';
import { SignalRService } from '../infra/socket/signal-r.service';
import { SocketMessageDeleteUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-delete-use-case.service';
import { SocketMessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-update-use-case.service';
import { SocketMessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-create-use-case.service';
import { DownloadMessageAttachmentUserCaseService } from 'src/app/module/chat/domain/use-case/download-message-attachment-user-case.service';
import { DownloadMessageAttachmentUserCaseService } from 'src/app/module/chat/domain/use-case/message-download-attachment-user-case.service';
import { ListenMessageByRoomIdNewUseCase } from 'src/app/module/chat/domain/use-case/listen-message-by-roomId.service';
import { MemberListUpdateStatusUseCaseService } from 'src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service';
import { ListenMessageDeleteByRoomIdService } from './use-case/listene-message-delete-by-roomId.service';
import { ListenMessageUpdateByRoomIdUseCase } from './use-case/listen-message-update-by-roomId.service';
import { GetRoomByIdUseCaseService } from './use-case/room-get-by-id-use-case.service';
import { DeleteRoomUseCaseService } from './use-case/room-delete-by-id-use-case.service';
import { CreateRoomUseCaseService } from './use-case/room-create-use-case.service';
import { RoomLeaveUseCase } from './use-case/room-leave-by-id-use-case.service';
import { SyncAllRoomMessagesService } from './use-case/sync-all-room-messages.service';
import { ListenSendMessageUseCase } from './use-case/listen-send-message.service'
import { GetMessageAttachmentLocallyUseCaseService } from 'src/app/module/chat/domain/use-case/get-message-attachment-localy-use-case.service';
import { RemoveMemberUseCaseService } from './use-case/member/-use-case.service'
import { AddMemberUseCaseService } from './use-case/member-add-use-case.service'
import { UpdateRoomByIdUseCaseService } from './use-case/room-update-by-id-use-case.service'
import { GetMessageAttachmentLocallyUseCaseService } from 'src/app/module/chat/domain/use-case/message-get-attachment-localy-use-case.service';
import { GetRoomListUseCaseService } from 'src/app/module/chat/domain/use-case/room-get-list-use-case.service';
import { filter } from 'rxjs/operators';
import { v4 as uuidv4 } from 'uuid'
import { MessageEntity } from './entity/message';
import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/message-attachment-by-message-id.service';
import { RoomInputDTO } from '../data/dto/room/roomInputDTO';
import { UserRemoveListInputDTO } from '../data/dto/room/userRemoveListInputDTO';
import { AddMemberToRoomInputDTO } from '../data/dto/room/addMemberToRoomInputDto';
import { RoomUpdateInputDTO } from '../data/dto/room/roomUpdateInputDTO';
export const InstanceId = uuidv4();
@@ -48,7 +60,15 @@ export class ChatServiceService {
private MessageAttachmentByMessageIdService: MessageAttachmentByMessageIdUseCase,
private SyncAllRoomMessagesService: SyncAllRoomMessagesService,
private DownloadMessageAttachmentUserCaseService: DownloadMessageAttachmentUserCaseService,
private GetMessageAttachmentLocallyUseCaseService: GetMessageAttachmentLocallyUseCaseService
private GetMessageAttachmentLocallyUseCaseService: GetMessageAttachmentLocallyUseCaseService,
private GetRoomListUseCaseService: GetRoomListUseCaseService,
private GetRoomByIdUseCaseService: GetRoomByIdUseCaseService,
private DeleteRoomUseCaseService: DeleteRoomUseCaseService,
private CreateRoomUseCaseService: CreateRoomUseCaseService,
private RoomLeaveUseCase: RoomLeaveUseCase,
private AddMemberUseCaseService: AddMemberUseCaseService,
private UpdateRoomByIdUseCaseService: UpdateRoomByIdUseCaseService,
private RemoveMemberUseCaseService: RemoveMemberUseCaseService
) {
this.messageLiveSignalRDataSourceService.getMessageDelete()
.pipe()
@@ -76,13 +96,10 @@ export class ChatServiceService {
return !message?.requestId?.startsWith(InstanceId)
})
).subscribe(async (message) => {
if(message?.id) {
console.log('create message')
this.SocketMessageCreateUseCaseService.execute(message)
}
})
this.messageLiveSignalRDataSourceService.getData().pipe(
@@ -99,6 +116,15 @@ export class ChatServiceService {
}
async start() {
await this.getRoomList();
this.asyncAllRoomMessage();
}
removeMemberToRoom(data: UserRemoveListInputDTO) {
return this.RemoveMemberUseCaseService.execute(data)
}
messageDelete(data: {roomId, messageId}) {
const params = {
@@ -142,6 +168,39 @@ export class ChatServiceService {
}
getRoomList() {
return this.GetRoomListUseCaseService.execute()
}
getRoomById(id: string) {
return this.GetRoomByIdUseCaseService.execute(id)
}
deleteRoomById(id: string) {
return this.DeleteRoomUseCaseService.execute(id)
}
createRoom(data: RoomInputDTO) {
return this.CreateRoomUseCaseService.execute(data)
}
leaveRoom(data: UserRemoveListInputDTO) {
return this.RoomLeaveUseCase.execute(data)
}
addMemberToRoom(data: AddMemberToRoomInputDTO) {
return this.AddMemberUseCaseService.execute(data)
}
updateRoomById(data: RoomUpdateInputDTO) {
return this.UpdateRoomByIdUseCaseService.execute(data)
}
removeMember() {
}
listenToIncomingMessage(roomId:string) {
return this.ListenMessageByRoomIdNewUseCase.execute({roomId})
}
src/app/module/chat/domain/use-case/member-add-use-case.service.ts
+27
View File
@@ -0,0 +1,27 @@
import { Injectable } from '@angular/core';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { AddMemberToRoomInputDTO } from '../../data/dto/room/addMemberToRoomInputDto';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
@Injectable({
providedIn: 'root'
})
export class AddMemberUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
) { }
@captureAndReraiseAsync('RoomRepositoryService/addMemberToRoom')
async execute(data: AddMemberToRoomInputDTO) {
// return this.roomLiveSignalRDataSourceService.addMemberToRoom(data)
const result = await this.roomRemoteDataSourceService.addMemberToRoom(data)
return result
}
}
src/app/module/chat/domain/use-case/member-admin-use-case.service.ts
+3 -3
View File
@@ -1,7 +1,7 @@
import { Injectable } from '@angular/core';
import { z } from "zod";
import { RoomRepositoryService } from '../../data/repository/room-repository.service';
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
// Define the schema for the entire response
const MemberSetAdminDTOSchema = z.object({
@@ -18,12 +18,12 @@ export type MemberSetAdminDTO = z.infer<typeof MemberSetAdminDTOSchema>
export class MemberAdminUseCaseService {
constructor(
public repository: RoomRepositoryService
public repository: RoomRemoteDataSourceService
) { }
@ValidateSchema(MemberSetAdminDTOSchema)
execute(input: MemberSetAdminDTO) {
return this.repository.setAdmin(input)
return this.repository.setAmin(input)
}
}
src/app/module/chat/domain/use-case/member/-use-case.service.ts
+22
View File
@@ -0,0 +1,22 @@
import { Injectable } from '@angular/core';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { UserRemoveListInputDTO } from '../../../data/dto/room/userRemoveListInputDTO';
import { RoomRemoteDataSourceService } from '../../../data/repository/room-remote-repository.service';
@Injectable({
providedIn: 'root'
})
export class RemoveMemberUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
) { }
@captureAndReraiseAsync('RoomRepositoryService/removeMemberToRoom')
async execute(data: UserRemoveListInputDTO) {
const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
return result
}
}
src/app/module/chat/domain/use-case/message-create-use-case.service.ts
+39 -12
View File
@@ -8,7 +8,12 @@ import { InstanceId } from '../chat-service.service';
import { createDataURL } from 'src/app/utils/ToBase64';
import { zodSafeValidation } from 'src/app/utils/zodValidation';
import { Logger } from 'src/app/services/logger/main/service';
import { MessageAttachmentSource } from '../../data/dto/message/messageOutputDTO';
import { MessageAttachmentSource, MessageOutPutDataDTO } from '../../data/dto/message/messageOutputDTO';
import { MessageLocalDataSourceService } from '../../data/data-source/message/message-local-data-source.service';
import { err } from 'neverthrow';
import { MessageTable } from '../../infra/database/dexie/schema/message';
import { MessageMapper } from '../mapper/messageMapper';
import { SignalRService } from '../../infra/socket/signal-r.service';
const MessageInputUseCaseSchema = z.object({
memberId: z.number(),
@@ -26,6 +31,8 @@ export class MessageCreateUseCaseService {
constructor(
private MessageRepositoryService: MessageRepositoryService,
private AttachmentRepositoryService: AttachmentRepositoryService,
private messageLocalDataSourceService: MessageLocalDataSourceService,
private messageLiveSignalRDataSourceService: SignalRService,
) { }
@@ -38,9 +45,13 @@ export class MessageCreateUseCaseService {
message.requestId = InstanceId +'@'+ uuidv4();
const createMessageLocally = await this.MessageRepositoryService.createMessageLocally(message)
const createMessageLocally = await this.messageLocalDataSourceService.sendMessage(message)
if(createMessageLocally.isOk()) {
message.$id = createMessageLocally.value
if(message.hasAttachment) {
for (const attachment of message.attachments) {
@@ -48,7 +59,7 @@ export class MessageCreateUseCaseService {
if(attachment.source != MessageAttachmentSource.Webtrix) {
this.AttachmentRepositoryService.create({
$messageId: createMessageLocally.value.$id,
$messageId: createMessageLocally.value,
file: createDataURL(attachment.file, attachment.mimeType),
fileType: attachment.fileType,
source: attachment.source,
@@ -72,20 +83,36 @@ export class MessageCreateUseCaseService {
}
const sendToServer = await this.MessageRepositoryService.sendMessage(message)
//====================
message.sending = true
if(!sendToServer.isOk()) {
const DTO = MessageMapper.fromDomain(message, message.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 : message.$id
}
return this.messageLocalDataSourceService.update(message.$id, {...clone, sending: false, roomId: message.roomId})
} else {
Logger.error('failed to send message to the server', {
error: sendToServer.error
error: sendMessageResult.error
})
await this.messageLocalDataSourceService.update(message.$id, {sending: false, $id: message.$id})
return err('no connection')
}
return sendToServer
}
const result = await this.MessageRepositoryService.sendMessage(message)
return result
} else {
if(validation.error.formErrors.fieldErrors.attachments) {
src/app/module/chat/domain/use-case/message-delete-live-use-case.service.ts → src/app/module/chat/domain/use-case/message-delete-by-id-live-use-case.service.ts
View File
src/app/module/chat/domain/use-case/download-message-attachment-user-case.service.ts → src/app/module/chat/domain/use-case/message-download-attachment-user-case.service.ts
View File
src/app/module/chat/domain/use-case/get-message-attachment-localy-use-case.service.ts → src/app/module/chat/domain/use-case/message-get-attachment-localy-use-case.service.ts
View File
src/app/module/chat/domain/use-case/message-reaction-use-case.service.ts → src/app/module/chat/domain/use-case/message-reaction-by-id-use-case.service.ts
View File
src/app/module/chat/domain/use-case/message-update-use-case.service.ts → src/app/module/chat/domain/use-case/message-update-by-id-use-case.service.ts
View File
src/app/module/chat/domain/use-case/send-local-messages-use-case.service.ts → src/app/module/chat/domain/use-case/messages-send-offline-use-case.service.ts
View File
src/app/module/chat/domain/use-case/room-create-use-case.service.ts
+47
View File
@@ -0,0 +1,47 @@
import { Injectable } from '@angular/core';
import { create } from 'domain';
import { SessionStore } from 'src/app/store/session.service';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { RoomInputDTO } from '../../data/dto/room/roomInputDTO';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
@Injectable({
providedIn: 'root'
})
export class CreateRoomUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
@captureAndReraiseAsync('RoomRepositoryService/create')
async execute(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
}
const localResult = await this.roomLocalDataSourceService.createRoom(result.value.data)
return localResult.map(e => result.value)
}
return result
}
}
src/app/module/chat/domain/use-case/room-delete-by-id-use-case.service.ts
+42
View File
@@ -0,0 +1,42 @@
import { Injectable } from '@angular/core';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { isHttpResponse } from 'src/app/services/http.service';
import { RoomByIdInputDTO } from '../../data/dto/room/roomByIdInputDTO';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
@Injectable({
providedIn: 'root'
})
export class DeleteRoomUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
// private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
@captureAndReraiseAsync('RoomRepositoryService/deleteRoomById')
async execute(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
}
}
src/app/module/chat/domain/use-case/room-get-by-id-use-case.service.ts
+69
View File
@@ -0,0 +1,69 @@
import { Injectable } from '@angular/core';
import { id } from 'date-fns/locale';
import { isHttpResponse } from 'src/app/services/http.service';
import { roomListDetermineChanges } from '../../data/async/list/rooms/roomListChangeDetector';
import { roomMemberListDetermineChanges } from '../../data/async/list/rooms/roomMembersChangeDetector';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
import { MemberListLocalRepository } from '../../data/repository/member-list-local-repository.service';
import { MemberListMapper } from '../mapper/memberLIstMapper';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
@Injectable({
providedIn: 'root'
})
export class GetRoomByIdUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
// private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
private roomLocalDataSourceService: RoomLocalRepository,
private MemberListLocalRepository: MemberListLocalRepository
) { }
@captureAndReraiseAsync('RoomRepositoryService/getRoomById')
async execute(id: string) {
const result = await this.roomRemoteDataSourceService.getRoom(id)
if(result.isOk()) {
const localListRoom = await this.roomLocalDataSourceService.getRoomList()
if(localListRoom.isOk()) {
const object = {
chatRoom: result.value.data
}
const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom.value)
for( const roomData of roomsToUpdate) {
this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
}
// ============================
const localList = await this.MemberListLocalRepository.getRoomMemberById(id)
const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)
for (const user of membersToInsert) {
await this.MemberListLocalRepository.addMember(MemberListMapper(user, id))
}
for (const user of membersToUpdate) {
await this.MemberListLocalRepository.updateMemberRole(MemberListMapper(user, id))
}
for(const user of membersToDelete) {
await this.MemberListLocalRepository.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
}
}
src/app/module/chat/domain/use-case/room-get-list-use-case.service.ts
+47
View File
@@ -0,0 +1,47 @@
import { Injectable } from '@angular/core';
import { roomListDetermineChanges } from '../../data/async/list/rooms/roomListChangeDetector';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { isHttpResponse } from 'src/app/services/http.service';
@Injectable({
providedIn: 'root'
})
export class GetRoomListUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
// private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
@captureAndReraiseAsync('RoomRepositoryService/list')
async execute() {
const result = await this.roomRemoteDataSourceService.getRoomList()
const localList = await this.roomLocalDataSourceService.getRoomList()
if(localList.isOk()) {
if(result.isOk()) {
const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList.value)
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)
}
}
}
return result
}
}
src/app/module/chat/domain/use-case/room-leave-by-id-use-case.service.ts
+34
View File
@@ -0,0 +1,34 @@
import { Injectable } from '@angular/core';
import { UserRemoveListInputDTO } from '../../data/dto/room/userRemoveListInputDTO';
import { isHttpResponse } from 'src/app/services/http.service';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
@Injectable({
providedIn: 'root'
})
export class RoomLeaveUseCase {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
async execute(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
}
}
src/app/module/chat/domain/use-case/room-update-by-id-use-case.service.ts
+39
View File
@@ -0,0 +1,39 @@
import { Injectable } from '@angular/core';
import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
import { RoomUpdateInputDTO } from '../../data/dto/room/roomUpdateInputDTO';
import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
@Injectable({
providedIn: 'root'
})
export class UpdateRoomByIdUseCaseService {
constructor(
private roomRemoteDataSourceService: RoomRemoteDataSourceService,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
@captureAndReraiseAsync('RoomRepositoryService/updateRoomBy')
async execute(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
}
}
src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service.ts
+3 -4
View File
@@ -1,7 +1,7 @@
import { Injectable } from '@angular/core';
import { z } from 'zod';
import { RoomRepositoryService } from 'src/app/module/chat/data/repository/room-repository.service'
import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member-list-local-repository.service'
export const MemberListUPdateStatus = z.object({
key: z.string(),
@@ -19,13 +19,12 @@ export type MemberListUPdateStatusInputDTO = z.infer<typeof MemberListUPdateStat
export class MemberListUpdateStatusUseCaseService {
constructor(
private RoomRepositoryService: RoomRepositoryService
private MemberListLocalRepository: MemberListLocalRepository
) { }
@ValidateSchema(MemberListUPdateStatus)
execute(input: MemberListUPdateStatusInputDTO) {
console.log
return this.RoomRepositoryService.updateMemberStatus(input)
return this.MemberListLocalRepository.updateMembersStatus(input)
}
}
src/app/module/chat/domain/use-case/sync-all-room-messages.service.ts
+45 -12
View File
@@ -1,7 +1,10 @@
import { Injectable } from '@angular/core';
import { RoomRepositoryService } from 'src/app/module/chat/data/repository/room-repository.service'
import { MessageRepositoryService } from 'src/app/module/chat/data/repository/message-respository.service'
import { RoomTable } from '../../infra/database/dexie/schema/room';
import { MessageLocalDataSourceService } from '../../data/data-source/message/message-local-data-source.service';
import { messageListDetermineChanges } from '../../data/async/list/rooms/messageListChangedetector';
import { MessageTable } from '../../infra/database/dexie/schema/message';
import { MessageRemoteDataSourceService } from '../../data/data-source/message/message-remote-data-source.service';
import { ok } from 'neverthrow';
import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
@Injectable({
providedIn: 'root'
@@ -9,24 +12,54 @@ import { RoomTable } from '../../infra/database/dexie/schema/room';
export class SyncAllRoomMessagesService {
constructor(
private RoomRepositoryService: RoomRepositoryService,
private MessageRepositoryService: MessageRepositoryService
private messageLocalDataSourceService: MessageLocalDataSourceService,
private messageRemoteDataSourceService: MessageRemoteDataSourceService,
private roomLocalDataSourceService: RoomLocalRepository,
) { }
async execute() {
await this.RoomRepositoryService.list()
const allRooms: RoomTable[] = await this.RoomRepositoryService.getRoomList()
const allRooms = await this.roomLocalDataSourceService.findAll()
if(allRooms) {
if(allRooms.length == 0) {
if(allRooms.isOk()) {
if(allRooms.value.length == 0) {
console.log('no room to sync')
} else {
console.log('sync '+ allRooms.value.length)
}
for(const room of allRooms) {
this.MessageRepositoryService.listAllMessagesByRoomId(room.id)
for(const room of allRooms.value) {
const result = await this.messageRemoteDataSourceService.getMessagesFromRoom(room.id)
const localResult = await this.messageLocalDataSourceService.getItems(room.id)
if(result.isOk()) {
const { addedItems, changedItems, deletedItems } = messageListDetermineChanges(result.value.data, localResult)
for(const message of changedItems) {
let clone: MessageTable = message
clone.roomId = room.id
this.messageLocalDataSourceService.findOrUpdate(clone)
}
for(const message of addedItems) {
let clone: MessageTable = message
clone.roomId = room.id
}
this.messageLocalDataSourceService.createManyMessage(addedItems.reverse())
for(const message of deletedItems) {
this.messageLocalDataSourceService.deleteByMessageId(message.id)
}
}
}
return ok(true)
} else {
console.log('get all error', allRooms)
console.log('sync all error', allRooms)
}
}
src/app/module/chat/domain/use-case/typing-send-use-case.service.ts
+22
View File
@@ -0,0 +1,22 @@
import { Injectable } from '@angular/core';
import { SignalRService } from '../../infra/socket/signal-r.service';
import { SessionStore } from 'src/app/store/session.service';
@Injectable({
providedIn: 'root'
})
export class SendTypingUseCaseService {
constructor(
private messageLiveSignalRDataSourceService: SignalRService,
) { }
execute(roomId) {
return this.messageLiveSignalRDataSourceService.sendTyping({
roomId,
UserName:SessionStore.user.FullName,
userId: SessionStore.user.UserId
})
}
}
src/app/module/chat/infra/socket/signalR.ts
+1 -1
View File
@@ -7,7 +7,7 @@ import { v4 as uuidv4 } from 'uuid'
import { UserTypingDTO } from '../../data/dto/typing/typingInputDTO';
import { MessageOutPutDataDTO } from '../../data/dto/message/messageOutputDTO';
import { MessageDeleteInputDTO } from '../../data/dto/message/messageDeleteInputDTO';
import { MessageReactionInput } from '../../domain/use-case/message-reaction-use-case.service';
import { MessageReactionInput } from '../../domain/use-case/message-reaction-by-id-use-case.service';
import { ISignalRInput } from './signal-r.service';
export class SignalRConnection {