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

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

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

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

import { NGXLogger } from 'ngx-logger';

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

import * as ChatStore from '@app/store/messenger/chat';
import * as RoomStore from '@app/store/messenger/room';
import * as SyncStore from '@app/store/messenger/sync';

import { SessionStorageService } from '@ucap-webmessenger/web-storage';
import { KEY_ENVIRONMENTS_INFO } from './../../../types/environment.type';
import { LoginInfo, KEY_LOGIN_INFO, EnvironmentsInfo } from '@app/types';
import { Dictionary } from '@ngrx/entity';
import { openSuccess, openFailure } from '../room';
import { LoginResponse } from '@ucap-webmessenger/protocol-authentication';
import { KEY_LOGIN_RES_INFO } from '@app/types/login-res-info.type';
import { StatusCode, MessageStatusCode } from '@ucap-webmessenger/api';
import { environment } from '../../../../environments/environment';
import {
  AlertDialogComponent,
  AlertDialogResult,
  AlertDialogData,
  DialogService
} from '@ucap-webmessenger/ui';
import {
  retrieveMessage,
  retrieveMessageFailure,
  retrieveMessageSuccess,
  searchMessage,
  searchMessageSuccess,
  searchMessageFailure
} from './actions';
import {
  MessageApiService,
  RetrieveRequest,
  MessageType,
  RetrieveSearchRequest,
  MessageSearchType
} from '@ucap-webmessenger/api-message';

@Injectable()
export class Effects {
  retrieveMessage$ = createEffect(
    () => {
      // const loginResInfo: LoginResponse = this.sessionStorageService.get<
      //   LoginResponse
      // >(KEY_LOGIN_RES_INFO);
      const environmentsInfo = this.sessionStorageService.get<EnvironmentsInfo>(
        KEY_ENVIRONMENTS_INFO
      );

      return this.actions$.pipe(
        ofType(retrieveMessage),
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) =>
                state.account.authentication.loginRes as LoginResponse
            )
          )
        ),
        switchMap(([req, loginResInfo]) => {
          const request: RetrieveRequest = {
            userSeq: loginResInfo.userSeq,
            deviceType: environmentsInfo.deviceType,
            tokenKey: loginResInfo.tokenString,
            type: req.messageType,
            pageSize: !!req.pageSize ? req.pageSize : 1000,
            pageCount: !!req.pageCount ? req.pageCount : 0
          };

          switch (req.messageType) {
            case MessageType.Receive: {
              return this.messageApiService
                .retrieveReceiveMessage(request)
                .pipe(
                  map(res => {
                    if (res.responseCode === MessageStatusCode.Success) {
                      this.store.dispatch(
                        retrieveMessageSuccess({
                          res,
                          messageType: req.messageType
                        })
                      );
                    }
                  }),
                  catchError(error => of(retrieveMessageFailure({ error })))
                );
            }
            case MessageType.Send: {
              return this.messageApiService.retrieveSendMessage(request).pipe(
                map(res => {
                  if (res.responseCode === MessageStatusCode.Success) {
                    this.store.dispatch(
                      retrieveMessageSuccess({
                        res,
                        messageType: req.messageType
                      })
                    );
                  }
                }),
                catchError(error => of(retrieveMessageFailure({ error })))
              );
            }
            case MessageType.Reservation: {
              return this.messageApiService
                .retrieveReservationMessage(request)
                .pipe(
                  map(res => {
                    if (res.responseCode === MessageStatusCode.Success) {
                      this.store.dispatch(
                        retrieveMessageSuccess({
                          res,
                          messageType: req.messageType
                        })
                      );
                    }
                  }),
                  catchError(error => of(retrieveMessageFailure({ error })))
                );
            }
          }
        })
      );
    },
    { dispatch: false }
  );

  searchMessage$ = createEffect(
    () => {
      const environmentsInfo = this.sessionStorageService.get<EnvironmentsInfo>(
        KEY_ENVIRONMENTS_INFO
      );

      return this.actions$.pipe(
        ofType(searchMessage),
        withLatestFrom(
          this.store.pipe(
            select(
              (state: any) =>
                state.account.authentication.loginRes as LoginResponse
            )
          )
        ),
        switchMap(([req, loginResInfo]) => {
          const request: RetrieveRequest = {
            userSeq: loginResInfo.userSeq,
            deviceType: environmentsInfo.deviceType,
            tokenKey: loginResInfo.tokenString,
            type: req.messageType,
            pageSize: !!req.pageSize ? req.pageSize : 1000,
            pageCount: !!req.pageCount ? req.pageCount : 0
          };

          return this.messageApiService
            .retrieveSearchMessage({
              ...request,
              searchTitle:
                req.searchType === MessageSearchType.Title ? req.searchStr : '',
              searchName:
                req.searchType === MessageSearchType.Name ? req.searchStr : '',
              searchContent:
                req.searchType === MessageSearchType.Contents
                  ? req.searchStr
                  : ''
            } as RetrieveSearchRequest)
            .pipe(
              map(res => {
                if (res.responseCode === MessageStatusCode.Success) {
                  this.store.dispatch(
                    searchMessageSuccess({
                      res,
                      messageType: req.messageType
                    })
                  );
                }
              }),
              catchError(error => of(searchMessageFailure({ error })))
            );
        })
      );
    },
    { dispatch: false }
  );

  constructor(
    private actions$: Actions,
    private store: Store<any>,
    private messageApiService: MessageApiService,
    private sessionStorageService: SessionStorageService,
    private dialogService: DialogService,
    private logger: NGXLogger
  ) {}
}