next-ucap-messenger/projects/ucap-webmessenger-protocol-status/src/lib/services/status-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 {
  StatusRequest,
  encodeStatus,
  decodeStatus,
  StatusResponse
} from '../models/status';
import {
  SVC_TYPE_STATUS,
  SSVC_TYPE_STATUS_REQ,
  SSVC_TYPE_STATUS_BULK_INFO_REQ,
  SSVC_TYPE_STATUS_BULK_INFO_RES,
  SSVC_TYPE_STATUS_BULK_INFO_DATA,
  SSVC_TYPE_STATUS_BUDDY_REQ,
  SSVC_TYPE_STATUS_MSG_UPD_REQ,
  SSVC_TYPE_STATUS_SUBSCRIPT_REQ,
  SSVC_TYPE_STATUS_UNSUBSCRIPT_REQ
} from '../types/service';
import {
  BulkInfoRequest,
  BulkInfoResponse,
  BulkInfoData,
  encodeBulkInfo,
  decodeBulkInfo,
  decodeBulkInfoData
} from '../models/bulk';
import { BuddyResponse, decodeBuddy } from '../models/buddy';
import {
  MessageUpdateRequest,
  MessageUpdateResponse,
  encodeMessageUpdate,
  decodeMessageUpdate
} from '../models/message-update';
import {
  SubscribeRequest,
  SubscribeResponse,
  decodeSubscribe,
  encodeSubscribe
} from '../models/subscribe';
import { UnSubscribeRequest, encodeUnSubscribe } from '../models/unsubscribe';

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

  public status(req: StatusRequest): Observable<StatusResponse> {
    return this.protocolService
      .call(SVC_TYPE_STATUS, SSVC_TYPE_STATUS_REQ, ...encodeStatus(req))
      .pipe(
        take(1),
        map(res => {
          return decodeStatus(res);
        })
      );
  }

  public buddy(): Observable<BuddyResponse> {
    return this.protocolService
      .call(SVC_TYPE_STATUS, SSVC_TYPE_STATUS_BUDDY_REQ)
      .pipe(
        take(1),
        map(res => {
          return decodeBuddy(res);
        })
      );
  }

  public bulkInfo(
    req: BulkInfoRequest
  ): Observable<BulkInfoResponse | BulkInfoData> {
    return this.protocolService
      .call(
        SVC_TYPE_STATUS,
        SSVC_TYPE_STATUS_BULK_INFO_REQ,
        ...encodeBulkInfo(req)
      )
      .pipe(
        takeWhile(
          res => SSVC_TYPE_STATUS_BULK_INFO_RES !== res.subServiceType,
          true
        ),
        map(res => {
          if (SSVC_TYPE_STATUS_BULK_INFO_DATA === res.subServiceType) {
            return {
              ...decodeBulkInfoData(res),
              Type: SSVC_TYPE_STATUS_BULK_INFO_DATA
            };
          }
          return {
            ...decodeBulkInfo(res),
            Type: SSVC_TYPE_STATUS_BULK_INFO_RES
          };
        })
      );
  }

  public messageUpdate(
    req: MessageUpdateRequest
  ): Observable<MessageUpdateResponse> {
    return this.protocolService
      .call(
        SVC_TYPE_STATUS,
        SSVC_TYPE_STATUS_MSG_UPD_REQ,
        ...encodeMessageUpdate(req)
      )
      .pipe(
        take(1),
        map(res => {
          return decodeMessageUpdate(res);
        })
      );
  }

  /**
   * Only Use 1:1 Chat Room and must be using unsubscribe method.
   * @param req SubscribeRequest
   */
  public subscribe(req: SubscribeRequest): Observable<SubscribeResponse> {
    return this.protocolService
      .call(
        SVC_TYPE_STATUS,
        SSVC_TYPE_STATUS_SUBSCRIPT_REQ,
        ...encodeSubscribe(req)
      )
      .pipe(
        take(1),
        map(res => {
          return decodeSubscribe(res);
        })
      );
  }

  /**
   * Only Use 1:1 Chat Room and must be using subscribe method.
   * @param req UnSubscribeRequest
   */
  public unSubscribe(req: UnSubscribeRequest): void {
    return this.protocolService.send(
      SVC_TYPE_STATUS,
      SSVC_TYPE_STATUS_UNSUBSCRIPT_REQ,
      ...encodeUnSubscribe(req)
    );
  }
}