ih-black-lion/lib/connectors/Connector.js

State handler for Arus projects

import xml2js, {
  parseString
} from 'xml2js';
import {
  Fault
} from '../models';
import Request from '../Request';
import serialize from '../serialize';
import {
  toCamelCase,
  interceptFault
} from './utils';

const urls = {
  tryURL: undefined,
  catchURL: undefined
};

export default class Connector {
  constructor(requestMethod, requestParams, Model, URLS = urls,
    extraParam = undefined) {
    this.requestMethod = requestMethod;
    this.requestParams = requestParams;
    this.Model = Model;
    this.extraParam = extraParam;

    try {
      this.defaults = {
        url: URLS.tryURL,
        auth: [__USERNAME__, __PASSWORD__],
        send: undefined,
        headers: undefined,
      };
    } catch (err) {
      this.defaults = {
        url: URLS.catchURL,
        auth: [process.env.USERNAME, process.env.PASSWORD],
        send: undefined,
        headers: undefined,
      };
    }
    this.params = {
      ...this.defaults,
      ...this.requestParams
    };
  }

  checkTypes() {
    if (typeof this.params !== 'object') {
      return Promise.reject(new TypeError(`Type of params is ${typeof this.params}. Expected an object\n\tparams = ${this.params}`));
    } else if (this.Model !== undefined && typeof this.Model !== 'function') {
      return Promise.reject(new TypeError(`Type of Model is ${typeof this.Model}. Expected a function\n\tModel = ${this.Model}`));
    }
    return true;
  }

  /* eslint no-unused-expressions: ["error", { "allowTernary": true }] */
  get Promise() {
    this.checkTypes(); // Checking the types here to simplify the usage of the Connectors.
    switch (this.requestMethod) {
      case 'GET':
        return new Promise((resolve, reject) => {
          Request.get(this.params)
            .then((res) => {
              let jRes;
              parseString(res.data, (err, parsedRes) => {
                if (!err) {
                  jRes = parsedRes;
                } else {
                  reject(err);
                }
              });

              if (interceptFault(jRes)) {
                reject(new Fault(serialize(jRes)));
              } else {
                this.extraParam ?
                  resolve(new this.Model(serialize(jRes), this.extraParam)) :
                  resolve(new this.Model(serialize(jRes)));
              }
            }).catch(reject);
        });
      case 'GETJSON':
        return new Promise((resolve, reject) => {
          Request.get(this.params)
            .then((res) => {
              resolve(res.data);
              // let jRes;
              // parseString(res.data, (err, parsedRes) => {
              //   if (!err) {
              //     jRes = parsedRes;
              //   } else {
              //     reject(err);
              //   }
              // });

              // if (interceptFault(jRes)) {
              //   reject(new Fault(serialize(jRes)));
              // } else {
              //   this.extraParam ?
              //     resolve(new this.Model(serialize(jRes), this.extraParam)) :
              //     resolve(res.data);
              // }
            }).catch(reject);
        });
      case 'POST':
        return new Promise((resolve, reject) => {
          Request.post(this.params)
            .then((res) => {
              let jRes;
              parseString(res.data, (err, parsedRes) => {
                if (!err) {
                  jRes = parsedRes;
                } else {
                  reject(err);
                }
              });
              if (interceptFault(jRes)) {
                reject(new Fault(serialize(jRes)));
              } else {
                this.extraParam ?
                  resolve(new this.Model(serialize(jRes), this.extraParam)) :
                  resolve(new this.Model(serialize(jRes)));
              }
            }).catch(reject);
        });
      default:
        return new TypeError(`requestMethod is ${this.requestMethod}. Expected either 'GET' or 'POST'`);
    }
  }
}