@wenn/onb/redux/actions/run.actions.js

onb-core

import SockJS from 'sockjs-client';
import { Client } from '@stomp/stompjs';
import axios from 'axios';
import Fingerprint2 from 'fingerprintjs2';
import { change, stopSubmit } from 'redux-form';

import { globalNotification } from './notifications.actions';
import { loadingPage } from './loading.actions';
import { initializeParams } from './params.actions';
import { saveCamunda } from './camunda.actions';
import { saveCamundaData } from './camundaData.actions';
import { transformOffer } from './offer.actions';
import { currentStepper } from './stepper.actions';
import { validateEndSchema } from './../../utils/alerts';
import { saveHasError } from './hasError.actions';

import {
  FLOW_ERROR,
  SET_SETTINGS,
  SET_BPMSTEP,
  SET_WIDTH,
  SAVE_FAILED_CODE_ATTEMPTS,
  SET_USERNAME
} from '../constants';
let wsRetries = 0;
const MAX_WS_RETRIES = 5;
const { REACT_APP_ENV, REACT_APP_CAMUNDA_URL } = process.env;
const devEnviroment =
  REACT_APP_ENV === 'dev' || REACT_APP_ENV === 'stage' || window.log === 'true';

function setSettings(settings) {
  return {
    type: SET_SETTINGS,
    settings
  };
}

export function saveFlowError(flowerror) {
  return {
    type: FLOW_ERROR,
    flowerror
  };
}

export function initializeWidth(width) {
  return {
    type: SET_WIDTH,
    width
  };
}

export let stompClient = null;

export function disconnect() {
  stompClient && stompClient.deactivate();
}

export function initializeCamunda(settings) {
  return (dispatch, getState) => {
    dispatch(saveCamunda({ brand: settings.config.CAMUNDA_BRAND }));
    dispatch(saveCamunda({ country: settings.config.COUNTRY.toUpperCase() }));
    dispatch(
      saveCamunda({ ui_version: process.env.REACT_APP_TAG_VERSION || 'v1.0.0' })
    );
    dispatch(initializeFingerPrint(settings.utils.urls));
    dispatch(initializeParams());
    const handler = {
      get: function(target, name) {
        if (name === 'pages' || name === 'CAMUNDA') {
          const { leadOrigin } = getState().settings;
          return target[name][leadOrigin] || target[name].onb;
        }
        return target[name];
      }
    };

    settings.config = new Proxy(settings.config, handler);

    dispatch(initializeSettings(settings));
    const wording = getState().settings.wording;

    const URL =
      REACT_APP_CAMUNDA_URL ||
      settings.utils.urls.camunda[(REACT_APP_ENV || 'dev').toUpperCase()];
    stompClient = new Client({
      debug: str => {
        var res = str.split(' ');
        if (res[0] === 'Whoops!') {
          const notification = {
            bpmStep: {
              code: 'lost_connection',
              step: 'end'
            },
            status: {
              statusCode: '200',
              message: 'se perdio la conexión del socket'
            }
          };
          dispatch(globalNotification(notification));
        } else {
          console.log(str); // eslint-disable-line
        }
      },
      reconnectDelay: 1000,
      heartbeatIncoming: 4000,
      heartbeatOutgoing: 4000
    });

    stompClient.webSocketFactory = () => {
      return new SockJS(URL);
    };

    stompClient.onConnect = conect => {
      if (conect.command === 'CONNECTED') {
        dispatch(saveCamunda({ userName: conect.headers['user-name'] }));
        dispatch({
          type: SET_USERNAME,
          id: conect.headers['user-name']
        });
        dispatch(loadingPage(false));
      }
      /* eslint-disable complexity */
      stompClient.subscribe(settings.utils.urls.camunda.SUBSCRIBE, response => {
        const data = JSON.parse(response.body);
        dispatch({ type: SET_BPMSTEP, bpmStep: data.currentTaskName });
        // CONSOLE CAMUNDA
        if (devEnviroment) console.log('CAMUNDA-DATA:::', data);
        if (data.bpmStep.step === 'end') {
          let flowData;
          try {
            flowData = JSON.parse(data.data);
            const {
              settings: {
                config: { alerts }
              }
            } = getState();

            if (data.bpmStep.code && alerts && alerts.get) {
              validateEndSchema(data.bpmStep.code, flowData, alerts.get);
            }
          } catch (e) {
            console.log(e);
            sendlog('error', {
              error_type: 'critical',
              error_name: e.name,
              error_desc: e.message,
              error_stack: e.stack
            });
          }
          switch (data.bpmStep.code) {
            case 'scoring':
              dispatch(saveCamunda({ offerid: flowData.id }));
              dispatch(
                saveCamundaData({
                  [data.bpmStep.code]: flowData
                })
              );
              break;
            case 'identity_validation':
            case 'validation_questions_retrieval':
            case 'get_lead':
              dispatch(
                saveCamundaData({
                  [data.bpmStep.code]: flowData
                })
              );
              break;
            case 'sms_send':
              dispatch(
                saveCamunda({
                  validationID: flowData.validationID
                })
              );
              break;
            case 'offer_retrieval':
              // no sale
              const {
                settings: {
                  config: { NO_SALE = false }
                }
              } = getState();
              if (NO_SALE) {
                const data = {
                  bpmStep: {
                    code: 'no_sale',
                    step: 'end'
                  },
                  status: {
                    statusCode: '200'
                  }
                };
                dispatch(globalNotification(data));
                dispatch(saveFlowError(true));
              }
              // "productid","offerid",
              if (flowData && flowData[0]) {
                dispatch(change('Product', 'amount', flowData[0].max_amount));
                dispatch(transformOffer(data.bpmStep.code, flowData[0]));
              }
              break;
            case 'validation_questions_process':
              const isRejected = flowData.evaluationStatus === 'RECHAZADO';
              if (isRejected) {
                const error = {
                  bpmStep: {
                    code: 'validation_questions_process',
                    step: 'end'
                  },
                  status: {
                    statusCode: '200',
                    message: 'error validando preguntas'
                  }
                };
                dispatch(globalNotification(error));
              }
              break;
            case 'basic_data_retrieval_salesforce':
              dispatch(saveCamundaData({ [data.bpmStep.code]: data }));
              break;
            case 'taskid':
              dispatch(
                saveCamunda({
                  [data.bpmStep.code]: flowData.taskid
                })
              );
              dispatch(saveCamunda({ goto: flowData.taskid }));

              if (flowData.flowerror === 'true') {
                switch (flowData.flowerrorcomponent) {
                  case 'IdentityValidationDelegate':
                    dispatch(
                      stopSubmit('InitialInfo', {
                        national_id: wording.notifications.nationalIdError
                      })
                    );
                    break;
                  case 'ProcessAnswersDelegate':
                    data.bpmStep.code = 'invalid_data';
                    dispatch(globalNotification(data));
                    break;
                  case 'IsClientArgentinaDelegate':
                    data.bpmStep.code = 'is_client';
                    dispatch(globalNotification(data));
                    break;
                  case 'IsBlacklistedArgentinaDelegate':
                    data.bpmStep.code = 'is_in_blacklist';
                    dispatch(globalNotifiscation(data));
                    break;
                  case 'ScoringArgentinaDelegate':
                    data.bpmStep.code = 'no_product';
                    dispatch(globalNotification(data));
                    break;
                  case 'SMSConfirmValidationArgentinaDelegate':
                    dispatch(
                      stopSubmit('BasicInfo', {
                        validationcode:
                          wording.notifications.validationCodeError
                      })
                    );
                    dispatch({ type: SAVE_FAILED_CODE_ATTEMPTS });
                    dispatch(
                      stopSubmit('LeadConfirmInfo', {
                        validationcode:
                          wording.notifications.validationCodeError
                      })
                    );
                    break;
                  case 'SendToSalesForceDelegate':
                    dispatch(globalNotification(data));
                    break;
                  case 'ValidateCBUArgentinaDelegate':
                    dispatch(
                      stopSubmit('PersonalInfo', {
                        cbu_code: wording.notifications.cbuCodeError
                      })
                    );
                    break;
                  default:
                    dispatch(globalNotification(data));
                    break;
                }
                dispatch(saveFlowError(true));
                dispatch(loadingPage(false));
              } else {
                const {
                  currentPage,
                  settings: {
                    config: { pages }
                  }
                } = getState();
                const currentStep = pages.find(
                  page => page.url === currentPage
                );
                currentStep &&
                  currentStep.currentStep &&
                  dispatch(currentStepper(Number(currentStep.currentStep)));
                dispatch(saveFlowError(false));
              }
              break;
            default:
              break;
          }
        }
      });
    };
    stompClient.onWebSocketClose = frame => {
      if (wsRetries > MAX_WS_RETRIES) {
        sendlog('error', {
          error_type: 'socketTimeout',
          error_desc: `Socket timeout after ${MAX_WS_RETRIES} retries.`
        });
        stompClient.deactivate();
        dispatch(saveHasError(true));
        dispatch(saveFlowError(true));
      }
      wsRetries++;
    };
    stompClient.activate();
    return stompClient;
  };
}

async function getIP(ip) {
  const response = await axios.get(ip);
  return response;
}

function getFingerprint() {
  const options = { excludeCanvas: true, excludeWebGL: true };
  return new Fingerprint2(options);
}

function initializeFingerPrint(urls) {
  return dispatch => {
    getFingerprint().get((res, com) => {
      getIP(urls.IP.USER)
        .then(response => {
          const ip = {
            key: 'ip',
            value: response.data
          };
          com.push(ip);
          dispatch(saveCamunda({ fingerprint: JSON.stringify(com) }));
        })
        .catch(e => {
          dispatch(saveCamunda({ fingerprint: JSON.stringify(com) }));
        });
    });
  };
}

function initializeSettings(settings) {
  return dispatch => {
    dispatch(setSettings(settings));
  };
}