@yousolution/node-red-contrib-you-sap-service-layer 0.0.3

package/nodes/support.js

@@ -0,0 +1,306 @@
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+const axiosLibrary = require('axios');
+const buildQuery = require('odata-query').default;
+
+const thickIdApi = [
+  'AccrualTypes',
+  'AssetClasses',
+  'AssetDepreciationGroups',
+  'AssetGroups',
+  'BankChargesAllocationCodes',
+  'BusinessPartners',
+  'CampaignResponseType',
+  'CashDiscounts',
+  'ChartOfAccounts',
+  'ChooseFromList',
+  'ContractTemplates',
+  'CostCenterTypes',
+  'CostElements',
+  'Countries',
+  'CreditCardPayments',
+  'Currencies',
+  'CustomsDeclaration',
+  'CycleCountDeterminations',
+  'DeductionTaxSubGroups',
+  'DepreciationAreas',
+  'DepreciationTypePools',
+  'DepreciationTypes',
+  'DistributionRules',
+  'DunningTerms',
+  'EmailGroups',
+  'EmployeeIDType',
+  'FAAccountDeterminations',
+  'FactoringIndicators',
+  'FiscalPrinter',
+  'ItemImages',
+  'Items',
+  'JournalEntryDocumentTypes',
+  'KPIs',
+  'LandedCostsCodes',
+  'LocalEra',
+  'MobileAddOnSetting',
+  'NFModels',
+  'ProductTrees',
+  'ProfitCenters',
+  'Projects',
+  'Queue',
+  'ReportTypes',
+  'Resources',
+  'SalesTaxCodes',
+  'TargetGroups',
+  'TaxInvoiceReport',
+  'TransactionCodes',
+  'UserDefaultGroups',
+  'UserObjectsMD',
+  'UserPermissionTree',
+  'UserTablesMD',
+  'VatGroups',
+  'Warehouses',
+  'WithholdingTaxCodes',
+  'WizardPaymentMethods',
+  'UDT',
+];
+
+async function login(node, idAuth) {
+  const flowContext = node.context().flow;
+
+  const host = flowContext.get(`_YOU_SapServiceLayer_${idAuth}.host`);
+  const port = flowContext.get(`_YOU_SapServiceLayer_${idAuth}.port`);
+  const version = flowContext.get(`_YOU_SapServiceLayer_${idAuth}.version`);
+
+  const url = `https://${host}:${port}/b1s/${version}/Login`;
+
+  const credentials = flowContext.get(`_YOU_SapServiceLayer_${idAuth}.credentials`);
+  const dataString = JSON.stringify(credentials);
+
+  const options = {
+    method: 'POST',
+    url: url,
+    rejectUnauthorized: false,
+    data: credentials,
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': dataString.length,
+    },
+  };
+
+  // try {
+  return await axiosLibrary(options);
+  // } catch (error) {
+  //   throw Error(`ERROR FUNCTION LOGIN: ${error}`);
+  // }
+}
+
+async function sendRequest({ node, msg, config, axios, login, options }) {
+  if (!node || !msg || !config || !axios || !login) {
+    const missingParams = [];
+    node ? null : missingParams.push('node');
+    msg ? null : missingParams.push('msg');
+    config ? null : missingParams.push('config');
+    axios ? null : missingParams.push('axios');
+    login ? null : missingParams.push('login');
+    throw new Error(`Missing mandatory params: ${missingParams.join(',')}.`);
+  }
+  let requestOptions = generateRequest(node, msg, config, options);
+  try {
+    return await axios(requestOptions.axiosOptions);
+  } catch (error) {
+    // Refresh headers re-login
+    if (error.response && (error.response.status == 401 || error.response.status == 301)) {
+      const flowContext = node.context().flow;
+      // try {
+      // update cookies for session timeout
+      const result = await login(node, requestOptions.idAuthNode);
+      flowContext.set(`_YOU_SapServiceLayer_${requestOptions.idAuthNode}.headers`, result.headers['set-cookie']);
+
+      try {
+        const headers = flowContext.get(`_YOU_SapServiceLayer_${requestOptions.idAuthNode}.headers`).join(';');
+
+        requestOptions.axiosOptions.headers.Cookie = headers;
+
+        return await axios(requestOptions.axiosOptions);
+      } catch (error) {
+        if (error.response && error.response.data) {
+          msg.statusCode = error.response.status;
+          msg.payload = error.response.data;
+          msg.requestUrl = requestOptions.axiosOptions.url;
+          node.send(msg);
+          throw new Error(JSON.stringify(error.response.data));
+        }
+        throw error;
+      }
+      // }
+    }
+    if (error.response && error.response.data) {
+      msg.statusCode = error.response.status;
+      msg.payload = error.response.data;
+      msg.requestUrl = requestOptions.axiosOptions.url;
+      node.send(msg);
+      throw new Error(JSON.stringify(error.response.data));
+    }
+    throw error;
+  }
+}
+
+function generateRequest(node, msg, config, options) {
+  options = options || {
+    hasRawQuery: false,
+    hasEntityId: false,
+    isClose: false,
+    isCrossJoin: false,
+    method: 'GET',
+    data: null,
+  };
+  // if (!options.typeOfNode) {
+  //   throw new Error('Missing type of node');
+  // }
+  options.hasRawQuery = options.hasRawQuery || false;
+  options.method = options.method || 'GET';
+  options.data = options.data || null;
+  options.hasEntityId = options.hasEntityId || false;
+  options.isClose = options.isClose || false;
+  options.isCrossJoin = options.isCrossJoin || false;
+
+  const { idAuthNode, host, port, version, cookies } = getSapParams(node, msg, config);
+
+  let rawQuery = null;
+  if (options.hasRawQuery) {
+    try {
+      rawQuery = eval(config.query);
+    } catch (error) {
+      throw new Error('Query editor error');
+    }
+  }
+
+  let entity = config.entity;
+  if (!entity) {
+    throw new Error('Missing entity');
+  }
+
+  if (entity == 'UDO') {
+    entity = config.udo;
+  }
+
+  if (entity == 'UDT') {
+    entity = config.udt;
+  }
+
+  if (entity == 'script') {
+    const partnerName = config.partnerName;
+    const scriptName = config.scriptName;
+    url = `https://${host}:${port}/b1s/${version}/${entity}/${partnerName}/${scriptName}`;
+  }
+
+  let url;
+
+  const odataNextLink = msg[config.nextLink];
+
+  if (!odataNextLink) {
+    url = `https://${host}:${port}/b1s/${version}/${entity}`;
+  }
+
+  if (options.isCrossJoin) {
+    url = `https://${host}:${port}/b1s/${version}/$crossjoin(${entity})`;
+  }
+
+  if (odataNextLink) {
+    url = `https://${host}:${port}/b1s/${version}/${odataNextLink}`;
+  }
+  if (options.isClose && !options.hasEntityId) {
+    throw new Error(`The options are not correct. If 'isClose' is true then 'hasEntityId' must be true.`);
+  }
+
+  if (options.hasEntityId) {
+    let entityId = msg[config.entityId];
+    if (!entityId && config.entity != 'UDO' && config.entity != 'UDT') {
+      throw new Error('Missing entityId');
+    }
+    const docEntry = msg[config.docEntry];
+    if (config.entity == 'UDO') {
+      if (!docEntry) {
+        throw new Error('Missing docEntry');
+      }
+      entityId = docEntry;
+    }
+
+    const code = msg[config.code];
+    if (config.entity == 'UDT') {
+      if (!code) {
+        throw new Error('Missing Code');
+      }
+      entityId = code;
+    }
+
+    if (thickIdApi.includes(entity) || config.entity === 'UDT') {
+      url = `https://${host}:${port}/b1s/${version}/${entity}('${entityId}')`;
+    } else {
+      url = `https://${host}:${port}/b1s/${version}/${entity}(${entityId})`;
+    }
+
+    if (options.isClose) {
+      url += `/Close`;
+    }
+  }
+
+  if (rawQuery && !odataNextLink) {
+    const urlOdata = buildQuery(rawQuery);
+    msg.odata = urlOdata;
+    url = `${url}${urlOdata}`;
+  }
+
+  // const cookies = flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.headers`).join(';');
+  const headers = { ...msg[config.headers], Cookie: cookies };
+
+  let axiosOptions = {
+    method: options.method,
+    url: url,
+    rejectUnauthorized: false,
+    withCredentials: true,
+    headers: headers,
+  };
+
+  if (options.data) {
+    axiosOptions = { ...axiosOptions, ...{ data: options.data } };
+  }
+
+  return {
+    axiosOptions: axiosOptions,
+    idAuthNode: idAuthNode,
+  };
+}
+
+function getSapParams(node, msg) {
+  try {
+    const flowContext = node.context().flow;
+
+    const idAuthNode = msg._YOU_SapServiceLayer.idAuth;
+    const host = flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.host`);
+    const port = flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.port`);
+    const version = flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.version`);
+
+    // if (!flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.headers`)) {
+    //   throw new Error('Authentication failed');
+    // }
+    const cookies = flowContext.get(`_YOU_SapServiceLayer_${idAuthNode}.headers`).join(';');
+
+    return { idAuthNode: idAuthNode, host: host, port: port, version: version, cookies: cookies };
+  } catch (error) {
+    throw new Error('Authentication failed');
+  }
+}
+
+module.exports = {
+  login: login,
+  generateRequest: generateRequest,
+  sendRequest: sendRequest,
+  thickIdApi: thickIdApi,
+};
+// if (process.env.NODE_ENV === 'test') {
+//   console.log('TEST');
+//   module.exports = {
+//     login: login,
+//     generateRequest: generateRequest,
+//     sendRequest: sendRequest,
+//     thickIdApi: thickIdApi,
+//   };
+// }

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@yousolution/node-red-contrib-you-sap-service-layer",
+  "version": "0.0.3",
+  "description": "Unofficial module SAP Service Layer for NODE-RED",
+  "license": "MIT",
+  "scripts": {
+    "update": "npm pack && mv yousolution-node-red-contrib-you-sap-service-layer-$npm_package_version.tgz ./data && cd data && npm i yousolution-node-red-contrib-you-sap-service-layer-$npm_package_version.tgz && docker-compose restart",
+    "test": "mocha 'test/**/*.spec.js'",
+    "coverage": "nyc npm run test"
+  },
+  "keywords": [
+    "node-red",
+    "SAP",
+    "service layer",
+    "API",
+    "ERP",
+    "integration",
+    "youSolution.Cloud"
+  ],
+  "author": "Andrea Trentin <andrea.trentin@yousolution.cloud>",
+  "node-red": {
+    "nodes": {
+      "authenticateSap": "/nodes/authenticateSap.js",
+      "listSap": "/nodes/listSap.js",
+      "createSap": "/nodes/createSap.js",
+      "deleteSap": "/nodes/deleteSap.js",
+      "getSap": "/nodes/getSap.js",
+      "patchSap": "/nodes/patchSap.js",
+      "closeSap": "/nodes/closeSap.js",
+      "crossJoinSap": "/nodes/crossJoinSap.js",
+      "nextLink": "/nodes/nextLink.js"
+    }
+  },
+  "dependencies": {
+    "axios": "^0.23.0",
+    "odata-query": "^6.7.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yousolution-cloud/node-red-contrib-you-sap-service-layer.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.0",
+    "@types/node-red-node-test-helper": "^0.2.2",
+    "@types/sinon": "^10.0.6",
+    "chai": "^4.3.4",
+    "mocha": "^9.1.3",
+    "node-red": "^2.1.4",
+    "node-red-node-test-helper": "^0.2.7",
+    "nyc": "^15.1.0",
+    "sinon": "^12.0.1"
+  }
+}

package/test/authenticateSap.spec.js

@@ -0,0 +1,261 @@
+const should = require('should');
+const helper = require('node-red-node-test-helper');
+const authenticateSap = require('../nodes/authenticateSap');
+const Context = require('../node_modules/./@node-red/runtime/lib/nodes/context/index');
+const sinon = require('sinon');
+const Support = require('../nodes/support');
+
+helper.init(require.resolve('node-red'));
+
+describe('authenticateSap Node', () => {
+  beforeEach((done) => {
+    helper.startServer(done);
+  });
+
+  function initContext(done) {
+    Context.init({
+      contextStorage: {
+        memory0: {
+          module: 'memory',
+        },
+        memory1: {
+          module: 'memory',
+        },
+      },
+    });
+    Context.load().then(function () {
+      done();
+    });
+  }
+
+  afterEach((done) => {
+    helper
+      .unload()
+      .then(function () {
+        return Context.clean({ allNodes: {} });
+      })
+      .then(function () {
+        return Context.close();
+      })
+      .then(function () {
+        helper.stopServer(done);
+      });
+
+    // Restore the default sandbox here
+    sinon.restore();
+
+    // helper.unload();
+    // helper.stopServer(done);
+  });
+
+  it('should be loaded', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+
+    helper.load(authenticateSap, flow, () => {
+      initContext(function () {
+        const n1 = helper.getNode('n1');
+
+        // console.log(helper.log().args);
+
+        // n1.context().flow.set('A', 1, 'memory1', function (error) {
+        //   console.log(error);
+        // });
+
+        // console.log(n1.context().flow.get('A', 'memory1'));
+        // console.log('- - - B- - - -');
+
+        // n1.id
+        // flow.push({
+        //   [`_YOU_SapServiceLayer_${n1.id}.headers`]:
+        // })
+
+        try {
+          // n1.status.calledWith({ fill: 'gray', shape: 'ring', text: 'Set credentials1' });
+          // should.equal(n1.status.calledWith({ fill: 'gray', shape: 'ring', text: 'Missing credentials' }), true);
+          n1.should.have.property('name', 'authenticateSap');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should no have credentials', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+    helper.load(authenticateSap, flow, () => {
+      initContext(function () {
+        const n1 = helper.getNode('n1');
+
+        try {
+          should.equal(n1.status.calledWith({ fill: 'gray', shape: 'ring', text: 'Missing credentials' }), true);
+          n1.should.have.property('name', 'authenticateSap');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should no have credentials when send message', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+    helper.load(authenticateSap, flow, () => {
+      const n1 = helper.getNode('n1');
+
+      n1.receive({});
+
+      n1.on('call:error', (error) => {
+        try {
+          should.equal(n1.status.lastCall.calledWith({ fill: 'red', shape: 'dot', text: 'Missing credentials' }), true);
+          error.should.have.property('firstArg', new Error('Missing credentials'));
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have without headers connected', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(authenticateSap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+      n1.credentials.user = 'user';
+      n1.credentials.password = 'password';
+      n1.credentials.company = 'company';
+
+      sinon.stub(Support, 'login').resolves({
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': 100,
+        },
+      });
+
+      n1.receive({});
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have with headers connected', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+      { id: 'n2', type: 'helper' },
+    ];
+    helper.load(authenticateSap, flow, () => {
+      const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+      n1.credentials.user = 'user';
+      n1.credentials.password = 'password';
+      n1.credentials.company = 'company';
+
+      sinon.stub(Support, 'login').resolves({
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': 100,
+        },
+      });
+
+      n1.context().flow.set(`_YOU_SapServiceLayer_${n1.id}.headers`, true, 'memory1', function (error) {
+        // console.log(error);
+      });
+
+      n1.receive({});
+
+      n2.on('input', (msg) => {
+        try {
+          msg.should.have.property('_msgid');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  it('should have disconnected', (done) => {
+    const flow = [
+      {
+        id: 'n1',
+        type: 'authenticateSap',
+        name: 'authenticateSap',
+        wires: [['n2']],
+        z: 'flow',
+        rules: [{ t: 'set', p: 'payload', to: '#:(memory1)::flowValue', tot: 'flow' }],
+      },
+    ];
+    helper.load(authenticateSap, flow, () => {
+      // const n2 = helper.getNode('n2');
+      const n1 = helper.getNode('n1');
+      n1.credentials.user = 'user';
+      n1.credentials.password = 'password';
+      n1.credentials.company = 'company';
+
+      sinon.stub(Support, 'login').rejects();
+
+      n1.receive({});
+
+      n1.on('call:error', (error) => {
+        try {
+          error.should.have.property('firstArg', new Error('Error'));
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+});