next-ucap-messenger/projects/ucap-webmessenger-protocol-room/src/lib/services/room-protocol.service.ts

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

import { Observable } from 'rxjs';
import { map, take, takeWhile } from 'rxjs/operators';

import { ProtocolService } from '@ucap-webmessenger/protocol';
import {
  SVC_TYPE_ROOM,
  SSVC_TYPE_ROOM_OPEN_REQ,
  SSVC_TYPE_ROOM_OPEN2_REQ,
  SSVC_TYPE_ROOM_OPEN3_REQ,
  SSVC_TYPE_ROOM_OPEN4_REQ,
  SSVC_TYPE_ROOM_INVITE_REQ,
  SSVC_TYPE_ROOM_INFO_ROOM,
  SSVC_TYPE_ROOM_INFO_RES,
  SSVC_TYPE_ROOM_INFO_REQ,
  SSVC_TYPE_ROOM_INFO_USER,
  SSVC_TYPE_ROOM_INFO_USER2
} from '../types/service';
import {
  RoomOpenRequest,
  encodeRoomOpen,
  decodeRoomOpen,
  RoomOpenResponse
} from '../models/room-open';
import {
  RoomOpen2Request,
  RoomOpen2Response,
  decodeRoomOpen2,
  encodeRoomOpen2
} from '../models/room-open2';
import {
  RoomOpen3Request,
  RoomOpen3Response,
  encodeRoomOpen3,
  decodeRoomOpen3
} from '../models/room-open3';
import {
  RoomOpen4Request,
  RoomOpen4Response,
  encodeRoomOpen4,
  decodeRoomOpen4
} from '../models/room-open4';
import {
  RoomInviteRequest,
  RoomInviteResponse,
  encodeRoomInvite,
  decodeRoomInvite
} from '../models/room-invite';
import {
  RoomInfoRequest,
  RoomInfoResponse,
  RoomInfoDataResponse,
  RoomUserShortDataResponse,
  RoomUserDataResponse,
  encodeRoomInfo,
  decodeRoomInfoData,
  decodeRoomInfo,
  decodeRoomUserShortData,
  decodeRoomUserData
} from '../models/room-info';

@Injectable({
  providedIn: 'root'
})
export class RoomProtocolService {
  constructor(private protocolService: ProtocolService) {}

  public roomOpen(req: RoomOpenRequest): Observable<RoomOpenResponse> {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_OPEN_REQ, ...encodeRoomOpen(req))
      .pipe(
        take(1),
        map(res => decodeRoomOpen(res))
      );
  }

  public roomOpen2(req: RoomOpen2Request): Observable<RoomOpen2Response> {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_OPEN2_REQ, ...encodeRoomOpen2(req))
      .pipe(
        take(1),
        map(res => decodeRoomOpen2(res))
      );
  }

  public roomOpen3(req: RoomOpen3Request): Observable<RoomOpen3Response> {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_OPEN3_REQ, ...encodeRoomOpen3(req))
      .pipe(
        take(1),
        map(res => decodeRoomOpen3(res))
      );
  }

  public roomOpen4(req: RoomOpen4Request): Observable<RoomOpen4Response> {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_OPEN4_REQ, ...encodeRoomOpen4(req))
      .pipe(
        take(1),
        map(res => decodeRoomOpen4(res))
      );
  }

  public roomInvite(req: RoomInviteRequest): Observable<RoomInviteResponse> {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_INVITE_REQ, ...encodeRoomInvite(req))
      .pipe(
        take(1),
        map(res => decodeRoomInvite(res))
      );
  }

  public roomInfo(
    req: RoomInfoRequest
  ): Observable<
    | RoomInfoResponse
    | RoomInfoDataResponse
    | RoomUserShortDataResponse
    | RoomUserDataResponse
  > {
    return this.protocolService
      .call(SVC_TYPE_ROOM, SSVC_TYPE_ROOM_INFO_REQ, ...encodeRoomInfo(req))
      .pipe(
        takeWhile(res => SSVC_TYPE_ROOM_INFO_RES !== res.subServiceType),
        map(res => {
          if (SSVC_TYPE_ROOM_INFO_ROOM === res.subServiceType) {
            return decodeRoomInfoData(res);
          } else if (SSVC_TYPE_ROOM_INFO_USER === res.subServiceType) {
            return decodeRoomUserShortData(res);
          } else if (SSVC_TYPE_ROOM_INFO_USER2 === res.subServiceType) {
            return decodeRoomUserData(res);
          }

          return decodeRoomInfo(res);
        })
      );
  }
}