@onereach/webform/src/api/services/message.service.js

Content Builder includes several views for: - Content builder view itself; - Web Form view; - Slack block-kit builder;

import store from '@/store';
import EventManager from '@/api/EventManager';
// import _isEmpty from 'lodash/isEmpty';
import _get from 'lodash/get';
import config from '@/config';

import * as events from '@/store/types/events';

const ERRORS = {
  wsDisconnected: 'Can\'t send message. WS is disconnected',
  sessionNoResult: 'Something went wrong. Couldn\'t fetch session id',
  noQueueResponse: 'Can\'t access messages queue'
};

/* const WS_EVENTS = {
  startSession: 'form/start-session',
  response: 'form/response'
}; */

const MessageService = {
  async sendMessage ({ name, params }, includeCallback = true, options = {}) {
    const message = {
      event: {
        name,
        params
      }
    };

    // console.log("sendMessage message -> ", message);

    try {
      return await EventManager.sendOutboundMessage({ message }, includeCallback, options);
    } catch (e) {
      return new Promise((resolve, reject) => resolve(null));
    }
  },

  /* async startSession ({
    browserFingerprint,
    beginningSessionId,
    previousSessionId,
    rwcUrl,
    queryParams,
    headers,
    userHeaders,
    deviceId,
    pageData,
    userTimezone,
    context,
    requireDelay = false
  }) {
    const { chatId } = store.state.config;

    if (requireDelay) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    try {
      const message = {
        event: {
          name: `${WS_EVENTS.startSession}/${chatId}`,
          params: {
            browserFingerprint,
            beginningSessionId,
            previousSessionId,
            rwcUrl,
            queryParams,
            headers,
            userHeaders,
            deviceId,
            pageData,
            userTimezone,
            context
          }
        }
      };
      const result = await EventManager.sendOutboundMessage({ message });

      if (_isEmpty(result)) throw Error(ERRORS.sessionNoResult);

      config.debug && console.debug('[EWPS::startSession] result:', result);

      return result;
    } catch (e) {
      throw new Error(e);
    }
  }, */

  async getMessagesFromQueue ({ sessionId, lastMessageId }) {
    config.debug && console.debug('[EWPS::getMessagesFromQueue] sessionId:', sessionId);

    const event = {
      name: `form/${events.UPDATE_CALLBACK}/${sessionId}`,
      params: { sessionId, lastMessageId }
    };
    // TODO: check async results ??? on restore session
    const result = await this.sendMessage(event, false);
    config.debug && console.debug('[EWPS::getMessagesFromQueue] result:', result);

    if (!result) {
      return null;
    }
    // the first condition added for backward compatibility with old step version
    return _get(result, 'result.messagesFromQueue.result.data', null) ||
          _get(result, 'messagesFromQueue.result.data', []);
  },

  async clearQueue ({ sessionId }) {
    const { chatId } = store.state.config;

    return this.sendMessage({
      name: `form/${events.ALL_MESSAGES_RECEIVED}/${chatId}`,
      params: {
        sessionId: sessionId
      }
    });
  },

  async updateCallback ({ sessionId }) {
    return this.sendMessage({
      name: `form/${events.UPDATE_CALLBACK}/${sessionId}`,
      params: {
        sessionId: sessionId
      }
    });
  },

  ensureConnection () {
    if (this.wsClient.connected) throw Error(ERRORS.wsDisconnected);
  },

  onMessage (event) {
    console.log('on message', event);
  },

  onConnect (event) {
    console.log('onConnect', event);
  },

  onError (event) {
    console.log('onError', event);
  },

  onClose (event) {
    console.log('onClose', event);
  }
};

export default MessageService;