next-ucap-messenger/projects/ucap-webmessenger-app/src/app/store/messenger/sync/effects.ts

import { Injectable } from '@angular/core';

import { Actions, ofType, createEffect } from '@ngrx/effects';

import { of } from 'rxjs';
import {
  catchError,
  exhaustMap,
  map,
  withLatestFrom,
  switchMap,
  tap
} from 'rxjs/operators';

import { Store, select } from '@ngrx/store';

import { NGXLogger } from 'ngx-logger';

import {
  buddy2,
  buddy2Success,
  buddy2Failure,
  group2,
  group2Success,
  group2Failure,
  room,
  roomFailure,
  roomSuccess,
  updateRoomForNewEventMessage,
  refreshRoom,
  refreshRoomFailure,
  refreshRoomSuccess
} from './actions';
import { SessionStorageService } from '@ucap-webmessenger/web-storage';

import {
  SyncProtocolService,
  SSVC_TYPE_SYNC_BUDDY2_DATA,
  BuddyResponse,
  BuddyDetailData,
  SSVC_TYPE_SYNC_GROUP_DATA2,
  GroupDetailData,
  GroupResponse,
  UserInfo,
  SSVC_TYPE_SYNC_BUDDY2_RES,
  SSVC_TYPE_SYNC_GROUP_RES2,
  SSVC_TYPE_SYNC_ROOM_DATA,
  SSVC_TYPE_SYNC_ROOM_USER,
  SSVC_TYPE_SYNC_ROOM_USER2,
  SSVC_TYPE_SYNC_ROOM_RES,
  RoomData,
  RoomUserData,
  RoomUserDetailData,
  RoomResponse
} from '@ucap-webmessenger/protocol-sync';
import { regViewSuccess } from '@app/store/messenger/option';
import {
  RoomInfo,
  UserInfoShort,
  UserInfo as RoomUserInfo,
  RoomProtocolService,
  SSVC_TYPE_ROOM_INFO_ROOM,
  SSVC_TYPE_ROOM_INFO_USER,
  SSVC_TYPE_ROOM_INFO_USER2,
  InfoData,
  UserShortData,
  UserData,
  SSVC_TYPE_ROOM_INFO_RES
} from '@ucap-webmessenger/protocol-room';
import { LoginInfo, KEY_LOGIN_INFO } from '@app/types';

import * as ChatStore from '@app/store/messenger/chat';
import * as RoomStore from '@app/store/messenger/room';
import { Dictionary } from '@ngrx/entity';
import { LoginResponse } from '@ucap-webmessenger/protocol-authentication';

@Injectable()
export class Effects {
  buddy2$ = createEffect(
    () => {
      let buddyList: UserInfo[];

      return this.actions$.pipe(
        ofType(buddy2),
        tap(() => {
          buddyList = [];
        }),
        switchMap(req => {
          return this.syncProtocolService.buddy2(req).pipe(
            map(res => {
              switch (res.SSVC_TYPE) {
                case SSVC_TYPE_SYNC_BUDDY2_DATA:
                  buddyList.push(...(res as BuddyDetailData).buddyInfos);
                  break;
                case SSVC_TYPE_SYNC_BUDDY2_RES:
                  this.store.dispatch(
                    buddy2Success({
                      buddyList,
                      syncDate: (res as BuddyResponse).syncDate
                    })
                  );
                  break;
              }
            }),
            catchError(error => of(buddy2Failure({ error })))
          );
        })
      );
    },
    { dispatch: false }
  );

  group2$ = createEffect(
    () => {
      let groupList: GroupDetailData[];

      return this.actions$.pipe(
        ofType(group2),
        tap(() => {
          groupList = [];
        }),
        switchMap(req => {
          return this.syncProtocolService.group2(req).pipe(
            map(res => {
              switch (res.SSVC_TYPE) {
                case SSVC_TYPE_SYNC_GROUP_DATA2:
                  groupList.push(res as GroupDetailData);
                  break;
                case SSVC_TYPE_SYNC_GROUP_RES2:
                  this.store.dispatch(
                    group2Success({
                      groupList,
                      syncDate: (res as GroupResponse).syncDate
                    })
                  );
                  break;
              }
            }),
            catchError(error => of(group2Failure({ error })))
          );
        })
      );
    },
    { dispatch: false }
  );

  room$ = createEffect(
    () => {
      let roomList: RoomInfo[];
      let roomUserInfoMap: {
        [param: string]: {
          userInfoShortList: UserInfoShort[];
          userInfoList: RoomUserInfo[];
        };
      };

      return this.actions$.pipe(
        ofType(room),
        tap(() => {
          roomList = [];
          roomUserInfoMap = {};
        }),
        switchMap(req => {
          return this.syncProtocolService.room(req).pipe(
            map(res => {
              switch (res.SSVC_TYPE) {
                case SSVC_TYPE_SYNC_ROOM_DATA:
                  roomList.push(
                    ...(res as RoomData).roomInfos.filter(v => v.isJoinRoom)
                  );
                  break;
                case SSVC_TYPE_SYNC_ROOM_USER:
                  {
                    const roomUserData = res as RoomUserData;
                    if (!roomUserInfoMap[roomUserData.roomSeq]) {
                      roomUserInfoMap[roomUserData.roomSeq] = {
                        userInfoList: [],
                        userInfoShortList: []
                      };
                    }
                    roomUserInfoMap[
                      roomUserData.roomSeq
                    ].userInfoShortList.push(...roomUserData.userInfos);
                  }
                  break;
                case SSVC_TYPE_SYNC_ROOM_USER2:
                  {
                    const roomUserDetailData = res as RoomUserDetailData;
                    if (!roomUserInfoMap[roomUserDetailData.roomSeq]) {
                      roomUserInfoMap[roomUserDetailData.roomSeq] = {
                        userInfoList: [],
                        userInfoShortList: []
                      };
                    }
                    roomUserInfoMap[
                      roomUserDetailData.roomSeq
                    ].userInfoList.push(...roomUserDetailData.userInfos);
                  }
                  break;
                case SSVC_TYPE_SYNC_ROOM_RES:
                  {
                    this.store.dispatch(
                      roomSuccess({
                        roomList,
                        roomUserInfoMap,
                        syncDate: (res as RoomResponse).syncDate
                      })
                    );
                  }
                  break;
              }
            }),
            catchError(error => of(roomFailure({ error })))
          );
        })
      );
    },
    { dispatch: false }
  );

  newEventMessageForRoomInfoList$ = createEffect(
    () =>
      this.actions$.pipe(
        ofType(ChatStore.newEventMessage),
        withLatestFrom(
          this.store.pipe(
            select((state: any) => state.messenger.sync.room.ids as string[])
          ),
          this.store.pipe(
            select((state: any) => state.messenger.sync.room.syncDate as string)
          )
        ),
        tap(([action, roomSeqList, roomSyncDate]) => {
          const index = roomSeqList.findIndex(
            (roomSeq, i) => roomSeq === action.roomSeq
          );

          if (-1 === index) {
            const loginInfo = this.sessionStorageService.get<LoginInfo>(
              KEY_LOGIN_INFO
            );

            this.store.dispatch(
              room({
                syncDate: roomSyncDate,
                localeCode: loginInfo.localeCode
              })
            );
            return;
          }

          this.store.dispatch(updateRoomForNewEventMessage(action));
        })
      ),
    { dispatch: false }
  );

  openRoom$ = createEffect(
    () =>
      this.actions$.pipe(
        ofType(ChatStore.openRoom),
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) =>
                state.account.authentication.loginRes as LoginResponse
            )
          ),
          this.store.pipe(
            select(
              (state: any) =>
                state.messenger.sync.roomUser.entities as Dictionary<
                  RoomUserDetailData
                >
            )
          ),
          this.store.pipe(
            select(
              (state: any) =>
                state.messenger.sync.roomUserShort.entities as Dictionary<
                  RoomUserData
                >
            )
          )
        ),
        tap(([action, loginRes, roomUsers, roomUserShorts]) => {
          const userSeqList = [...action.userSeqList, loginRes.userSeq];
          let roomSeq = null;

          for (const key in roomUsers) {
            if (roomUsers.hasOwnProperty(key)) {
              const element = roomUsers[key];
              if (userSeqList.length === element.userInfos.length) {
                roomSeq = key;
                for (const roomUserInfo of element.userInfos) {
                  if (-1 === userSeqList.indexOf(roomUserInfo.seq)) {
                    roomSeq = null;
                    break;
                  }
                }
              }
            }
          }

          for (const key in roomUserShorts) {
            if (roomUserShorts.hasOwnProperty(key)) {
              const element = roomUserShorts[key];
              if (userSeqList.length === element.userInfos.length) {
                roomSeq = key;
                for (const roomUserDetailData of element.userInfos) {
                  if (-1 === userSeqList.indexOf(roomUserDetailData.seq)) {
                    roomSeq = null;
                    break;
                  }
                }
              }
            }
          }

          this.logger.debug(
            'openRoom',
            'userSeqList',
            userSeqList,
            'roomSeq',
            roomSeq
          );
          if (!!roomSeq) {
            this.store.dispatch(ChatStore.selectedRoom({ roomSeq }));
            return;
          }

          this.store.dispatch(
            RoomStore.open({
              req: { divCd: 'DivCode', userSeqs: userSeqList }
            })
          );
        })
      ),
    { dispatch: false }
  );

  refreshRoom$ = createEffect(
    () => {
      let roomInfo: RoomInfo;
      let userInfoShortList: UserInfoShort[];
      let userInfoList: RoomUserInfo[];

      return this.actions$.pipe(
        ofType(refreshRoom),
        tap(() => {
          roomInfo = null;
          userInfoShortList = [];
          userInfoList = [];
        }),
        switchMap(req => {
          return this.roomProtocolService.info(req).pipe(
            map(res => {
              switch (res.SSVC_TYPE) {
                case SSVC_TYPE_ROOM_INFO_ROOM:
                  roomInfo = (res as InfoData).roomInfo;
                  break;
                case SSVC_TYPE_ROOM_INFO_USER:
                  userInfoShortList.push(...(res as UserShortData).userInfos);
                  break;
                case SSVC_TYPE_ROOM_INFO_USER2:
                  userInfoList.push(...(res as UserData).userInfos);
                  break;
                case SSVC_TYPE_ROOM_INFO_RES:
                  this.store.dispatch(
                    refreshRoomSuccess({
                      roomInfo,
                      userInfoShortList,
                      userInfoList
                    })
                  );
                  break;
              }
            }),
            catchError(error => of(refreshRoomFailure({ error })))
          );
        })
      );
    },
    { dispatch: false }
  );

  constructor(
    private actions$: Actions,
    private store: Store<any>,
    private syncProtocolService: SyncProtocolService,
    private roomProtocolService: RoomProtocolService,
    private sessionStorageService: SessionStorageService,
    private logger: NGXLogger
  ) {}
}