analytics/webcontent/bi/js/admin/datasource/services/ConnectionUtils.js

"use strict";

/**
 * Licensed Materials - Property of IBM
 * IBM Cognos Products: admin
 * Copyright IBM Corp. 2017, 2018
 * US Government Users Restricted Rights - Use, duplication or disclosure
 * restricted by GSA ADP Schedule Contract with IBM Corp.
 */
define(['underscore', 'bi/commons/ui/core/Class', 'bi/admin/common/utils/AJAXUtils', 'text!bi/admin/datasource/services/datasources.json', 'bi/admin/datasource/utils/StringUtil', 'ba-react-admin/ba-react-admin.min'], function (_, Class, AJAXUtils, datasources, StringUtil, AdminReact) {
  'use strict'; //NOSONAR: meant to be strict

  var _singletonInstance = null;
  var ConnectionUtils = Class.extend({
    _DUAL_CNX_STR_SEPARATOR: 'IBM_JD_CNX_STR:',
    _connStringTemplateToken: '<caConnString>',
    _DEFAULTCONNECTIONSTRINGMODULE: 'bi/admin/datasource/slideout/JdbcConnectionStringPane',
    _getSignonsWithCredentials: function _getSignonsWithCredentials(ajaxService, dsId, dcId) {
      if (!dsId || !dcId) {
        return Promise.resolve([]);
      } else {
        var options = {
          method: 'GET',
          contentType: 'application/json; charset=utf-8',
          dataType: 'json'
        };
        options.url = AJAXUtils.getAJAXURL('datasources') + '/' + dsId + '/connections/' + dcId + '/signons';
        return new Promise(function (resolve, reject) {
          ajaxService.ajax(options).then(function (signons) {
            var retVal;

            if (signons.data) {
              retVal = signons;
            }

            resolve(retVal);
          }, reject);
        });
      }
    },
    getSignons: function getSignons(ajaxService, dsId, dcId) {
      return this._getSignonsWithCredentials(ajaxService, dsId, dcId).then(function (responseFromCreds) {
        var respCredentials = responseFromCreds && responseFromCreds.data && responseFromCreds.data.data ? responseFromCreds.data.data : [];
        return respCredentials;
      });
    },
    _connStringParseTMR: function _connStringParseTMR(paramsArray) {
      var parseResult = {
        tm1Params: {
          tm1AdminHost: '',
          tm1Port: '',
          tm1ServerName: '',
          tm1UseSSL: false,
          tm1Language: ''
        }
      };
      var items;

      _.each(paramsArray, function (entry) {
        if (entry.indexOf('TM1AdminHost') > -1) {
          items = entry.split('=');
          parseResult.tm1Params.tm1AdminHost = items[1];
        }

        if (entry.indexOf('TM1Protocol') > -1) {
          items = entry.split('=');
          parseResult.tm1Params.tm1UseSSL = items[1] === 'https';
        }

        if (entry.indexOf('TM1ServerPort') > -1) {
          items = entry.split('=');
          parseResult.tm1Params.tm1Port = items[1];
        }
      });

      return parseResult;
    },
    _connStringParseSAP: function _connStringParseSAP(paramsArray) {
      var parseResult = {
        sapbwParams: {
          logonType: '',
          server: '',
          sysNumber: '',
          clientNumber: '',
          logonGroup: '',
          codePage: '',
          routerString: ''
        }
      };
      var items;

      _.each(paramsArray, function (entry) {
        if (entry.indexOf('serverType') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.logonType = items[1];
        }

        if (entry.indexOf('server') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.server = items[1];
        }

        if (entry.indexOf('sysid') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.systemId = items[1];
        }

        if (entry.indexOf('sysnr') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.systemNumber = items[1];
        }

        if (entry.indexOf('client') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.clientNumber = items[1];
        }

        if (entry.indexOf('logonGroup') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.logonGroup = items[1];
        }

        if (entry.indexOf('codePage') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.codePage = parseInt(items[1]);
        }

        if (entry.indexOf('routerString') > -1) {
          items = entry.split('=');
          parseResult.sapbwParams.routerString = items[1];
        }
      });

      return parseResult;
    },
    _connStringParseOLAP: function _connStringParseOLAP(paramsArray) {
      var parseResult = {
        serverUrl: '',
        namedInstance: '',
        msasVersion: ''
      };
      var lang = false;
      var items;

      _.each(paramsArray, function (entry, i) {
        if (i === 2) {
          parseResult.msasVersion = entry;

          if (entry !== 'DO' || entry !== 'TMR') {
            lang = true;
          }
        }

        if (entry.indexOf('SERVER') > -1) {
          items = entry.split('=');
          var server = items[1].split('\\');
          parseResult.serverUrl = server[0];
          parseResult.namedInstance = server[1] || '';
        }

        if (lang && entry.indexOf('LCID') > -1) {
          items = entry.split('=');
          parseResult.languageVal = items[1];
        }
      });

      return parseResult;
    },
    parseConnectionString: function parseConnectionString(connection) {
      var conString = connection.connectionString;
      var connectionStringParseResult = {
        rawConnectionString: conString
      };

      this._resolveConnectionString(connectionStringParseResult);

      this._getMetaData(connectionStringParseResult);

      var parseResult;

      if (this.isTMRConnection(connection)) {
        parseResult = this._connStringParseTMR(conString.split(';'));
      } else if (conString.indexOf(ConnectionUtils.SAPBW) > -1) {
        parseResult = this._connStringParseSAP(conString.split(';'));
      } else if (this.isOLAPConnection(connection)) {
        parseResult = this._connStringParseOLAP(conString.split(';'));
      } else if (conString.indexOf(ConnectionUtils.EXTCAT) > -1) {
        parseResult = this._connStringParseExtCatalog(conString);
      } else {
        this._extractJDBCDriverInfo(connectionStringParseResult);

        if (connection.apiToken) {
          this._extractApiToken(connection.apiToken, connectionStringParseResult);
        }
      }

      _.extend(connectionStringParseResult, parseResult);

      return connectionStringParseResult;
    },
    _extractApiToken: function _extractApiToken(apiToken, parseResult) {
      parseResult.apiToken = {};

      if (apiToken.authKey) {
        parseResult.apiToken.authKey = apiToken.authKey;
      }

      if (apiToken.secretKey) {
        parseResult.apiToken.secretKey = apiToken.secretKey;
      }
    },
    _connStringParseExtCatalog: function _connStringParseExtCatalog(connectionStringParseResult) {
      var parseResult = {};

      if (connectionStringParseResult) {
        if (connectionStringParseResult.indexOf('URL=') > -1) {
          var conString = connectionStringParseResult.split('URL=');

          if (conString && conString.length > 0) {
            var urlString = conString[1].split(';');
            parseResult.serverUrl = urlString[0];
            parseResult.connectionProperties = '';

            for (var i = 1; i < urlString.length; i++) {
              if (!_.isEmpty(urlString[i])) {
                parseResult.connectionProperties += urlString[i] + ';';
              }
            }

            return parseResult;
          }
        }
      }
    },
    _extractJDBCDriverInfo: function _extractJDBCDriverInfo(connectionStringParseResult) {
      var items = connectionStringParseResult.connString.split(';DRIVER_NAME=');

      if (items && items.length > 1) {
        var stringVals = items[1].split(';');

        if (stringVals && stringVals.length > 0 && connectionStringParseResult.metadata.driverName !== stringVals[0]) {
          //driver has been updated with a different version
          connectionStringParseResult.metadata.driverName = stringVals[0];
        }
      }
    },
    resolveAuthMethod: function resolveAuthMethod(connectionStringParseResult, connection, signons) {
      var indexOfAuthSec = connection.connectionString.indexOf('^User ID:');

      if (connection.credentialNamespaces && connection.credentialNamespaces.length > 0) {
        connectionStringParseResult.authMethod = 'ucac';
      } else if (indexOfAuthSec !== -1 && signons.length > 0) {
        connectionStringParseResult.authMethod = 'usc';
      } else if (indexOfAuthSec !== -1) {
        connectionStringParseResult.authMethod = 'prompt';
      } else {
        connectionStringParseResult.authMethod = 'anon';
      }
    },
    _getConnectionCode: function _getConnectionCode(parseResult) {
      if (parseResult.msasVersion) {
        return parseResult.msasVersion;
      }

      return parseResult.metadata.code.split(':')[0];
    },
    _getAuthSection: function _getAuthSection(parseResult) {
      if (parseResult.authMethod === 'anon' || parseResult.authMethod === 'ucac') {
        return '';
      } else {
        return '^User ID:^?Password:';
      }
    },
    _buildConnectionTM1: function _buildConnectionTM1(connectionString, parseResult) {
      connectionString += ';LCID=' + 'en-us';
      connectionString += ';TM1AdminHost=' + parseResult.tm1Params.tm1AdminHost;
      connectionString += ';TM1Protocol=' + (parseResult.tm1Params.tm1UseSSL ? 'https' : 'http');
      connectionString += ';TM1ServerPort=' + parseResult.tm1Params.tm1Port;
      connectionString += ';TM1ServerName=TM1ServerName';
      connectionString += ';CATALOG=CATALOG;';
      connectionString += 'UID=%s;PWD=%s';
      return connectionString;
    },
    _buildConnectionJDBC: function _buildConnectionJDBC(connectionString, parseResult, objectInfo) {
      connectionString += ';URL=' + parseResult.jdbcURL;
      connectionString += ';DRIVER_NAME=' + parseResult.metadata.driverName + ';';

      if (parseResult.metadata.code.indexOf('JDBC:') === 0) {
        connectionString += 'ibmcognos.subcode=';
        connectionString += parseResult.metadata.code.substring(5) + ';';
      }

      if (parseResult.connectionProperties && parseResult.connectionProperties.length > 0) {
        connectionString += parseResult.connectionProperties + ';';
      }

      if (parseResult.gwConnStr != null && parseResult.gwConnStr.length <= 0 && parseResult.gwStringUpdated) {//do nothing - this prevents it from going in to the 2nd else if
      } else if (parseResult.gwConnStr && parseResult.gwStringUpdated && parseResult.gwConnStr.length > 0) {
        connectionString += parseResult.gwConnStr + ';';
      } else if (parseResult.connString && parseResult.connString.indexOf('IBMCOGNOS_SG_DEST') !== -1 && parseResult.connString.indexOf('IBMCOGNOS_SG_GWID') !== -1) {
        var tString = parseResult.connString.substring(parseResult.connString.indexOf('IBMCOGNOS_SG_GWID'));
        var indexOfSGWID = tString.indexOf(';', 1);

        if (indexOfSGWID >= 0) {
          connectionString += tString.substring(0, indexOfSGWID + 1);
        }

        tString = parseResult.connString.substring(parseResult.connString.indexOf('IBMCOGNOS_SG_DEST'));
        var indexOfSC = tString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          connectionString += tString.substring(0, indexOfSC + 1);
        }

        if (tString.indexOf('IBMCOGNOS_SG_JDBC_DEST') !== -1) {
          indexOfSC = tString.indexOf(';', 1);

          if (indexOfSC >= 0) {
            connectionString += tString.substring(indexOfSC + 1);
          }
        }
      }

      if (parseResult.apiToken) {
        if (parseResult.apiToken.authKey || parseResult.apiToken.secretKey) {
          if (!objectInfo.apiToken) {
            objectInfo.apiToken = {};
          }

          objectInfo.apiToken.authKey = parseResult.apiToken.authKey;
          objectInfo.apiToken.secretKey = parseResult.apiToken.secretKey;
        } else {
          objectInfo.apiToken.authKey = '';
          objectInfo.apiToken.secretKey = '';
        }
      }

      return connectionString;
    },
    _buildConnectionSAP: function _buildConnectionSAP(connectionString, parseResult) {
      connectionString += ';serverType=' + parseResult.sapbwParams.logonType;
      connectionString += ';server=' + parseResult.sapbwParams.server;

      if (parseResult.sapbwParams && parseResult.sapbwParams.logonType === 'applicationServer') {
        connectionString += ';sysnr=' + parseResult.sapbwParams.systemNumber;
      }

      if (parseResult.sapbwParams && parseResult.sapbwParams.logonType === 'messageServer') {
        connectionString += ';sysid=' + parseResult.sapbwParams.systemId;
      }

      connectionString += ';client=' + parseResult.sapbwParams.clientNumber;

      if (parseResult.sapbwParams && parseResult.sapbwParams.logonType === 'messageServer') {
        connectionString += ';logonGroup=' + parseResult.sapbwParams.logonGroup;
      }

      connectionString += ';codePage=' + parseResult.sapbwParams.codePage;
      connectionString += ';routerString=' + parseResult.sapbwParams.routerString;
      connectionString += ';UID=%s;PWD=%s';
      return connectionString;
    },
    _buildConnectionOLAP: function _buildConnectionOLAP(connectionString, parseResult, connCode) {
      connectionString += ';SERVER=' + parseResult.serverUrl;

      if (parseResult.namedInstance) {
        connectionString += '\\' + parseResult.namedInstance;
      }

      if (connCode !== 'DO') {
        if (parseResult.languageVal) {
          connectionString += ';LCID=' + parseResult.languageVal;
        } else {
          connectionString += ';LCID=' + 'en-us';
        }
      }

      connectionString += ';UID=%s;PWD=%s';
      return connectionString;
    },
    _buildConnectionEXTCAT: function _buildConnectionEXTCAT(connectionString, parseResult) {
      connectionString += ';URL=' + parseResult.serverUrl + ';';

      if (parseResult.connectionProperties && parseResult.connectionProperties.length > 0) {
        connectionString += parseResult.connectionProperties + ';';
      }

      return connectionString;
    },
    buildConnection: function buildConnection(parseResult, objectInfo) {
      var connCode = this._getConnectionCode(parseResult);

      var connectionString = this._getAuthSection(parseResult) + ';LOCAL;' + connCode;

      if (connCode === ConnectionUtils.EXTCAT) {
        connectionString = this._buildConnectionEXTCAT(connectionString, parseResult);
      } else if (!_.isUndefined(parseResult.jdbcURL)) {
        connectionString = this._buildConnectionJDBC(connectionString, parseResult, objectInfo);
      } else if (parseResult.tm1Params) {
        connectionString = this._buildConnectionTM1(connectionString, parseResult);
      } else if (parseResult.sapbwParams) {
        connectionString = this._buildConnectionSAP(connectionString, parseResult);
      } else {
        connectionString = this._buildConnectionOLAP(connectionString, parseResult, connCode);
      }

      return connectionString;
    },
    getUpdatedConnectionString: function getUpdatedConnectionString(parseResult, newConnString) {
      return parseResult.connStringTemplate.replace(this._connStringTemplateToken, newConnString);
    },
    _getMetaData: function _getMetaData(connectionStringParseResult) {
      if (!this.isOLAPConnection(connectionStringParseResult)) {
        connectionStringParseResult.jdbcURL = this._getJdbcUrl(connectionStringParseResult.connString);
      }

      connectionStringParseResult.metadata = this.getDSMeta(connectionStringParseResult);

      if (connectionStringParseResult.metadata && !connectionStringParseResult.metadata.module) {
        connectionStringParseResult.metadata.module = this._DEFAULTCONNECTIONSTRINGMODULE;
      }
    },
    _getSubCode: function _getSubCode(objInfo) {
      var connString = objInfo.connectionString ? objInfo.connectionString : objInfo.connString;
      var subCode = StringUtil.getField(connString, ';ibmcognos.subcode=');

      if (!subCode) {
        var subProtocol = this._getJdbcSubprotocol(objInfo);

        subCode = 'JDBC:' + subProtocol;
      } else {
        if (subCode.toUpperCase() === 'HIVE') {
          subCode = 'HIVE2';
        }

        subCode = 'JDBC:' + subCode;
      }

      return subCode;
    },
    _getJdbcUrl: function _getJdbcUrl(cs) {
      var jdbcUrl = '';
      var urlConstant = 'URL=';
      var urlStart = cs.indexOf(urlConstant);

      if (urlStart !== -1) {
        var urlEnd;
        var driverConstant = ';DRIVER_NAME=';
        urlEnd = cs.indexOf(driverConstant, urlStart + urlConstant.length);

        if (urlEnd !== -1) {
          jdbcUrl = cs.substring(urlStart + urlConstant.length, urlEnd);
        }
      }

      return jdbcUrl;
    },
    _getJdbcSubprotocol: function _getJdbcSubprotocol(connectionStringParseResult) {
      var connString = connectionStringParseResult.connectionString || connectionStringParseResult.connString || '';
      var jdbcUrl = connectionStringParseResult.jdbcURL || this._getJdbcUrl(connString) || '';
      var subprotocol = '';
      var protocolStart = 'jdbc:'.length; // Sybase and Greenplum have ':' in the protocol
      // name so searching for the first index doesn't
      // work
      // Have to put in a static check for now. If we get
      // too many exceptions we should look at
      // reading the connections metadata file for a list
      // subprotocols.

      var protocolEnd = jdbcUrl.indexOf(':', protocolStart);

      if (protocolEnd !== -1) {
        subprotocol = jdbcUrl.substring(protocolStart, protocolEnd);

        if (subprotocol.toLowerCase() === 'sybase' || subprotocol.toLowerCase() === 'pivotal') {
          protocolEnd = jdbcUrl.indexOf(':', protocolEnd + 1);
          subprotocol = jdbcUrl.substring(protocolStart, protocolEnd);
        }
      }

      return subprotocol;
    },
    _getMainCode: function _getMainCode(cs) {
      var local = ';LOCAL;';
      var start = cs.indexOf(local) + local.length;
      var end = cs.indexOf(';', start);
      return cs.substring(start, end);
    },
    _parseBasicConnectionString: function _parseBasicConnectionString(connectionStringParseResult) {
      var dualStackIndex = connectionStringParseResult.rawConnectionString.indexOf(this._DUAL_CNX_STR_SEPARATOR);

      if (dualStackIndex !== -1) {
        connectionStringParseResult.connString = connectionStringParseResult.rawConnectionString.substr(dualStackIndex + this._DUAL_CNX_STR_SEPARATOR.length);
        connectionStringParseResult.connStringTemplate = connectionStringParseResult.rawConnectionString.replace(connectionStringParseResult.connString, this._connStringTemplateToken);
      } else {
        connectionStringParseResult.connString = connectionStringParseResult.rawConnectionString;
        connectionStringParseResult.connStringTemplate = this._connStringTemplateToken;
      }
    },
    _resolveConnectionString: function _resolveConnectionString(connectionStringParseResult) {
      this._parseBasicConnectionString(connectionStringParseResult);

      this._resolveConnectionProperties(connectionStringParseResult);
    },
    _resolveConnectionProperties: function _resolveConnectionProperties(connectionStringParseResult) {
      var indexOfDriver = connectionStringParseResult.connString.indexOf(';DRIVER_NAME=');
      var indexOfProperties = connectionStringParseResult.connString.indexOf(';', indexOfDriver + 1);
      var indexOfLastProperties = connectionStringParseResult.connString.indexOf(';', indexOfProperties + 1);

      if (indexOfLastProperties !== -1 && indexOfProperties !== -1) {
        connectionStringParseResult.connectionProperties = this._removeIBMSubCode(connectionStringParseResult.connString.substring(indexOfProperties + 1, connectionStringParseResult.connString.length - 1));
        connectionStringParseResult.connectionProperties = this._removeSecureGWInfo(connectionStringParseResult.connectionProperties);
      } else {
        connectionStringParseResult.connectionProperties = '';
      }
    },
    _removeIBMSubCode: function _removeIBMSubCode(propertiesString) {
      if (propertiesString.indexOf('ibmcognos.subcode') !== -1) {
        var indexOfSC = propertiesString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          return propertiesString.substring(indexOfSC + 1);
        } else {
          return '';
        }
      } else {
        return propertiesString;
      }
    },
    _removeSecureGWInfo: function _removeSecureGWInfo(propertiesString) {
      if (propertiesString.indexOf('IBMCOGNOS_SG_GWID') !== -1) {
        var indexOfSC = propertiesString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          propertiesString = propertiesString.substring(indexOfSC + 1);
        } else {
          propertiesString = '';
        }
      }

      if (propertiesString.indexOf('IBMCOGNOS_SG_DEST') !== -1) {
        indexOfSC = propertiesString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          propertiesString = propertiesString.substring(indexOfSC + 1);
        } else {
          propertiesString = '';
        }
      }

      if (propertiesString.indexOf('IBMCOGNOS_SG_JDBC_DEST') !== -1) {
        indexOfSC = propertiesString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          propertiesString = propertiesString.substring(indexOfSC + 1);
        } else {
          propertiesString = '';
        }
      }

      if (propertiesString.indexOf('IBMCOGNOS_SG_JDBC_OVERRIDE') !== -1) {
        indexOfSC = propertiesString.indexOf(';', 1);

        if (indexOfSC >= 0) {
          propertiesString = propertiesString.substring(indexOfSC + 1);
        } else {
          propertiesString = '';
        }
      }

      return propertiesString;
    },
    getAuthenticationFromString: function getAuthenticationFromString(connection, signons) {
      var retVal = 'anon';

      if (connection.isNew) {//do nothing
      } else if (signons.length > 0) {
        retVal = 'usc';
      } else if (connection.credentialNamespaces && connection.credentialNamespaces.length > 0) {
        retVal = 'ucac';
      } else if (connection.connectionString.indexOf('^User ID:') !== -1) {
        retVal = 'prompt';
      }

      return retVal;
    },
    saveConnection: function saveConnection(ajaxService, objectInfo, connectionSignons, removedSignons) {
      delete objectInfo.tenantID;
      delete objectInfo.owner;
      objectInfo.type = 'dataSourceConnection';
      return this._updateConnection(ajaxService, objectInfo).then(function () {
        return this._removedDeletedSignons(ajaxService, removedSignons);
      }.bind(this)).then(function () {
        return this._updateEditedSignons(ajaxService, objectInfo, connectionSignons);
      }.bind(this)).then(function () {
        return this._addCreatedSignons(ajaxService, objectInfo, connectionSignons);
      }.bind(this));
    },
    _updateSignonPolicies: function _updateSignonPolicies(ajaxService, objectInfo, location) {
      var options = {
        method: 'PUT',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(objectInfo),
        url: location
      };
      return ajaxService.ajax(options);
    },
    _updateEditedSignons: function _updateEditedSignons(ajaxService, objectInfo, connectionSignons) {
      var editedSignons = _.filter(connectionSignons, function (signon) {
        return signon.isEdited;
      });

      var deletePromises = [];
      editedSignons.forEach(function (signon) {
        var delPromise = this._deleteSignon(ajaxService, signon.id);

        deletePromises.push(delPromise);
      }.bind(this));
      var createPromises = [];
      return Promise.all(deletePromises).then(function () {
        editedSignons.forEach(function (signon) {
          createPromises.push(this._createSignon(ajaxService, objectInfo, signon));
        }.bind(this));
        return Promise.all(createPromises);
      }.bind(this));
    },
    _addCreatedSignons: function _addCreatedSignons(ajaxService, objectInfo, connectionSignons) {
      var promises = [];

      var newSignons = _.filter(connectionSignons, function (signon) {
        return signon.isNew;
      });

      newSignons.forEach(function (signon) {
        promises.push(this._createSignon(ajaxService, objectInfo, signon));
      }.bind(this));
      return Promise.all(promises);
    },
    _removedDeletedSignons: function _removedDeletedSignons(ajaxService, removedSignons) {
      var promises = [];

      if (_.isUndefined(removedSignons) || removedSignons === null) {
        return Promise.resolve();
      }

      removedSignons.forEach(function (signon) {
        var remPromise = this._deleteSignon(ajaxService, signon.id);

        promises.push(remPromise);
      }.bind(this));
      return Promise.all(promises);
    },
    _deleteSignon: function _deleteSignon(ajaxService, signonId) {
      var options = {
        method: 'DELETE',
        url: 'v1/objects/' + signonId + '?force=true'
      };
      return ajaxService.ajax(options);
    },
    createNewConnection: function createNewConnection(ajaxService, objectInfo, connectionSignons) {
      return new Promise(function (resolve, reject) {
        return this._createConnection(ajaxService, objectInfo).then(function (response) {
          var respLocation = this._getLocation(response);

          objectInfo.connId = respLocation.split('/').pop();
          return this._createSignons(ajaxService, objectInfo, connectionSignons);
        }.bind(this)).then(resolve, function (err) {
          reject(err);
        });
      }.bind(this));
    },
    _createDataServer: function _createDataServer(ajaxService, objectInfo) {
      var dataSource = {
        defaultName: objectInfo.defaultName,
        type: 'dataSource'
      };
      var options = {
        method: 'POST',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(dataSource)
      };
      options.url = AJAXUtils.getAJAXURL('datasources');
      return ajaxService.ajax(options);
    },
    createNewDataSource: function createNewDataSource(ajaxService, objectInfo, connectionSignons) {
      return new Promise(function (resolve, reject) {
        return this._createDataServer(ajaxService, objectInfo, connectionSignons).then(function (response) {
          var location = this._getLocation(response);

          objectInfo.dataSourceId = location.split('/').pop();
          return this.createNewConnection(ajaxService, objectInfo, connectionSignons);
        }.bind(this)).then(resolve, function (err) {
          reject(err);
        });
      }.bind(this));
    },
    _createSignons: function _createSignons(ajaxService, objectInfo, connectionSignons) {
      var promises = [];
      objectInfo.id = objectInfo.connId;

      if (!_.isUndefined(connectionSignons) && connectionSignons !== null) {
        connectionSignons.forEach(function (item) {
          promises.push(this._createSignon(ajaxService, objectInfo, item));
        }.bind(this));
      }

      return Promise.all(promises);
    },
    _createConnection: function _createConnection(ajaxService, objectInfo) {
      var connURL = AJAXUtils.getAJAXURL('datasources') + '/' + objectInfo.dataSourceId + '/connections';
      var options = {
        method: 'POST',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(objectInfo),
        url: connURL
      };
      return ajaxService.ajax(options);
    },
    _updateConnection: function _updateConnection(ajaxService, objectInfo) {
      var connURL = AJAXUtils.getAJAXURL('datasources') + '/' + objectInfo.dataSourceId + '/connections/' + objectInfo.connId;
      var options = {
        method: 'PUT',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(objectInfo),
        url: connURL
      };
      return ajaxService.ajax(options);
    },
    _createSignon: function _createSignon(ajaxService, objectInfo, signon) {
      delete signon.searchPath;
      delete signon.owner;
      delete signon._meta;
      delete signon.ancestors;
      delete signon.version;

      if (signon.credentialsEx && signon.credentialsEx.updatedSignon) {
        if (signon.credentials) {
          delete signon.credentials;
        }

        delete signon.credentialsEx.updatedSignon;
      } //we need to add consumers to the signon.


      if (signon.membersListObject && signon.membersListObject.length > 0) {
        var consumers = [];

        _.each(signon.membersListObject, function (item) {
          var memberObject = {
            'id': item.id,
            'defaultName': item.label,
            'searchPath': item.searchPath,
            'type': item.type
          };
          consumers.push(memberObject);
        }.bind(this));

        signon.consumers = consumers;
        delete signon.membersListObject;
      }

      var url = AJAXUtils.getAJAXURL('datasources') + '/' + objectInfo.dataSourceId + '/connections/' + objectInfo.connId + '/signons';
      var options = {
        method: 'POST',
        contentType: 'application/json; charset=utf-8',
        data: JSON.stringify(signon),
        url: url
      };
      return ajaxService.ajax(options).then(function (response) {
        var location = this._getLocation(response);

        delete signon.credentials;
        return this._updateSignonPolicies(ajaxService, signon, location);
      }.bind(this));
    },
    _sendTest: function _sendTest(ajaxService, objectInfo, testType) {
      var options = {
        method: 'POST',
        contentType: 'application/json; charset=utf-8',
        dataType: 'json',
        data: JSON.stringify(objectInfo)
      };

      if (objectInfo.connectionString.indexOf('EXTCATALOG') > -1) {
        options.url = 'v1/metadata/sources/test_with_credential';
      } else {
        options.url = AJAXUtils.getAJAXURL(testType);
      }

      return ajaxService.ajax(options);
    },
    test: function test(ajaxService, connectionString, selectedSignon, apiToken) {
      var testObj = {
        connectionString: connectionString
      };

      if (apiToken && apiToken.apiTokenEncoded) {
        testObj.apiToken = apiToken.apiTokenEncoded;
      } else if (apiToken) {
        testObj.apiToken = apiToken;
      }

      var testType = 'test'; //Order matters

      if (selectedSignon && selectedSignon.namespace) {
        testObj.namespace = selectedSignon.namespace;
      } else if (selectedSignon && selectedSignon.credentialsEx && selectedSignon.credentialsEx.updatedSignon) {
        if (selectedSignon.credentialsEx.updatedSignon) {
          testObj.userName = selectedSignon.credentialsEx.username;
          testObj.password = selectedSignon.credentialsEx.password;
        }

        if (selectedSignon.credentialsEx.updatedSignon === 'testDialog') {
          delete selectedSignon.credentialsEx.updatedSignon;
        }
      } else if (selectedSignon && selectedSignon.credentials) {
        testObj.credentialString = selectedSignon.credentials;
        testType = 'testWithConn';
      }

      return this._sendTest(ajaxService, testObj, testType);
    },
    _getLocation: function _getLocation(response) {
      return response.jqXHR.getResponseHeader('location');
    },
    isOLAPConnection: function isOLAPConnection(objInfo) {
      var dsMeta;

      if (objInfo.vendor) {
        dsMeta = objInfo.vendor;
      } else {
        dsMeta = this.getDSMeta(objInfo);
      }

      return dsMeta ? dsMeta.isOLAP : false;
    },
    getConnectionClass: function getConnectionClass(objInfo) {
      if (this.isOLAPConnection(objInfo)) {
        return ConnectionUtils.OLAP;
      }

      return ConnectionUtils.JDBC;
    },
    getDSMeta: function getDSMeta(objInfo) {
      var dsCode = this._getDSCode(objInfo);

      var dsMeta = _.find(this.datasourceList.data, function (item) {
        if (item.versions) {
          var flag = false;

          for (var i = 0; i < item.versions.length; i++) {
            if (item.versions[i].code.toLowerCase() === dsCode.toLowerCase()) {
              flag = true;
            }
          }

          return flag;
        } else if (item.code.toLowerCase() === dsCode.toLowerCase()) {
          return true;
        } else if (item.categoryId && item.categoryId.toLowerCase() === ConnectionUtils.JDBC.toLowerCase() && dsCode.indexOf(ConnectionUtils.JDBC) === 0) {
          var subCode = 'JDBC:' + item.subProtocol;
          return subCode.toLowerCase() === dsCode.toLowerCase();
        }

        return false;
      }.bind(this));

      if (dsMeta && dsMeta.versions) {
        dsMeta.code = dsCode;
      }

      return dsMeta;
    },
    _getDSCode: function _getDSCode(objInfo) {
      var connString = objInfo.connectionString ? objInfo.connectionString : objInfo.connString;

      var dsCode = this._getMainCode(connString);

      if (dsCode === ConnectionUtils.JDBC) {
        dsCode = this._getSubCode(objInfo);
      }

      return dsCode;
    },
    isTMRConnection: function isTMRConnection(objInfo) {
      var code;

      if (objInfo.vendor) {
        code = objInfo.vendor.code;
      } else {
        var connString = objInfo.connectionString ? objInfo.connectionString : objInfo.connString;
        code = this._getMainCode(connString);
      }

      return code === ConnectionUtils.TMR;
    },
    checkForSecuredGatewayExtension: function checkForSecuredGatewayExtension(glassContext) {
      return glassContext.appController.findCollection('ibm.com.admin.AdminPanel');
    }
  });
  ConnectionUtils.EXTCAT = 'EXTCATALOG';
  ConnectionUtils.JDBC = 'JDBC';
  ConnectionUtils.OLAP = 'OLAP';
  ConnectionUtils.TMR = 'TMR';
  ConnectionUtils.SAPBW = 'BW';
  var _static = {
    getInstance: function getInstance() {
      if (!_singletonInstance) {
        _singletonInstance = new ConnectionUtils();

        try {
          _singletonInstance.datasourceList = JSON.parse(datasources);
        } catch (err) {//do nothing
        }
      }

      return _singletonInstance;
    }
  };
  return _static.getInstance();
});