ti2 1.0.28 → 1.0.31

package/api.yml

@@ -1342,3 +1342,104 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/AnyValue'
+  /allotment/{appKey}/{userId}:
+    get:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - allotment
+      summary: Query the allotment
+      operationId: queryAllotment
+      parameters:
+        - name: appKey
+          in: path
+          description: app to create the booking for, defaults to first token
+          required: true
+          example: 'tourplan'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: the user/company that the appKey belongs to
+          required: true
+          schema:
+            type: string
+        - in: query
+          name: startDate
+          schema:
+            type: string
+          description: the start date of the requested allotment (dd/mm/yyyy)
+          default: "01/04/2023"
+        - in: query
+          name: endDate
+          schema:
+            type: string
+          description: the end date of the requested allotment (dd/mm/yyyy)
+          default: "03/04/2023"
+        - in: query
+          name: keyPath
+          schema:
+            type: string
+          description: a string with the product path separater by pipes ie. supplierId|locationId|productID
+          default: "MAGLUX|7CQLDACMAGLUXDELSUI"
+      responses:
+        '200':
+          description: Allotment Details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AnyValue'
+  /allotment/{appKey}/{hint}/{userId}:
+    get:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - allotment
+      summary: Query the allotment with an specific hit
+      operationId: queryAllotment
+      parameters:
+        - name: appKey
+          in: path
+          description: app to create the booking for, defaults to first token
+          required: true
+          example: 'tourplan'
+          schema:
+            type: string
+        - name: hint
+          in: path
+          description: a specific token hint to be used
+          required: true
+          example: 'tourplan-australia'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: the user/company that the appKey belongs to
+          required: true
+          schema:
+            type: string
+        - in: query
+          name: startDate
+          schema:
+            type: string
+          description: the start date of the requested allotment (dd/mm/yyyy)
+          default: "01/04/2023"
+        - in: query
+          name: endDate
+          schema:
+            type: string
+          description: the end date of the requested allotment (dd/mm/yyyy)
+          default: "03/04/2023"
+        - in: query
+          name: keyPath
+          schema:
+            type: string
+          description: a string with the product path separater by pipes ie. supplierId|locationId|productID
+          default: "MAGLUX|7CQLDACMAGLUXDELSUI"
+      responses:
+        '200':
+          description: Allotment Details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AnyValue'

package/auth/authHandler.js

@@ -1,6 +1,5 @@
 const jsonwebtoken = require('jsonwebtoken');
 const Promise = require('bluebird');
-const assert = require('assert');
 
 const sqldb = require('../models');
 
@@ -12,7 +11,8 @@ const {
   },
 } = process;
 
-const invalid = next => next({ status: 401, message: 'Unauthorized' });
+const invalid = (res, msg) => res.status(401).json({ error: msg || 'Unauthorized' });
+
 const getToken = ({ req }) => {
   if (
     !req.header('Authorization')
@@ -20,61 +20,101 @@ const getToken = ({ req }) => {
   ) return null;
   return req.header('Authorization').split(' ')[1];
 };
+
 // the authentication middleware
-const app = async (req, res, next) => {
-  if (!req.pathParams || !req.pathParams.app) return invalid(next);
+const appCheck = async req => {
+  if (!req.pathParams || !req.pathParams.app) {
+    return 'App parameters not found';
+  }
   const token = getToken({ req });
-  if (!token) return invalid(next);
-  // try {
+  if (!token) return 'Api key not found';
   const appRecord = await sqldb.Integration.findOne({
     where: {
       name: req.pathParams.app,
     },
   });
-  if (!appRecord) return invalid(next);
+  if (!appRecord) return 'App not found';
   if (appRecord.apiKey !== token) {
-    return invalid(next);
+    return 'Invalid api key';
   }
   req.appRecord = appRecord.dataValues;
+  return undefined;
+};
+
+const app = async (req, res, next) => {
+  const error = await appCheck(req);
+  if (error) {
+    return invalid(res, error);
+  }
   return next();
 };
 
 // The requester is an admin; createApps and other admin tasks
-const admin = async (req, res, next) => {
+const adminCheck = async req => {
   const token = getToken({ req });
-  if (token !== adminKey) return invalid(next);
+  if (token !== adminKey) return 'Invalid admin key';
+  return undefined;
+};
+
+const admin = async (req, res, next) => {
+  const error = await adminCheck(req);
+  if (error) {
+    return invalid(res, error);
+  }
   return next();
 };
 
 // the request is from a user, checke the userId agains the url param
-const user = async (req, res, next) => {
+const userCheck = async req => {
   const token = getToken({ req });
-  if (!token) return invalid(next);
+  if (!token) return 'Token not found';
+  let userId;
   try {
-    const { userId } = jsonwebtoken.verify(token, jwtSecret);
-    assert(userId);
-    if (req.params.userId && userId !== req.params.userId) return invalid(next);
+    ({ userId } = jsonwebtoken.verify(token, jwtSecret));
   } catch (err) {
-    return invalid(next);
+    return 'Invalid token';
+  }
+  if (!userId) return 'UserId not found';
+  if (req.params.userId && userId !== req.params.userId) {
+    return 'Non matching user id';
+  }
+  return undefined;
+};
+
+const user = async (req, res, next) => {
+  const error = await userCheck(req);
+  if (error) {
+    return invalid(res, error);
   }
   return next();
 };
 
 // The requester comes from frontend; frontend driven tasks
-const frontend = async (req, res, next) => {
+const frontendCheck = async req => {
   const token = getToken({ req });
-  if (token !== frontendKey) return invalid(next);
+  if (token !== frontendKey) {
+    return 'Invalid frontend token';
+  }
+  return undefined;
+};
+
+const frontend = async (req, res, next) => {
+  const error = await frontendCheck(req);
+  if (error) {
+    return invalid(res, error);
+  }
   return next();
 };
 
-const adminOrUser = levels => async (req, res, next) => {
-  const result = await Promise.all(levels.map(
-    level => level(req, res, err => err),
+const multipleAuthEval = levels => async (req, res, next) => {
+  // res.send = true;
+  const results = await Promise.all(levels.map(
+    levelCheck => levelCheck(req),
   ));
-  if (result.some(val => (!val))) {
+  if (results.some(val => !val)) {
     return next();
   }
-  return next(result[0]);
+  return invalid(res, results.join(' or '));
 };
 
 module.exports = {
@@ -82,6 +122,6 @@ module.exports = {
   frontend,
   admin,
   user,
-  'admin,user': adminOrUser([admin, user]),
-  'admin,app,user': adminOrUser([admin, app, user]),
+  'admin,user': multipleAuthEval([adminCheck, userCheck]),
+  'admin,app,user': multipleAuthEval([adminCheck, appCheck, userCheck]),
 };

package/controllers/__tests__/allotments.js

@@ -0,0 +1,106 @@
+/* globals beforeAll describe it expect */
+
+const chance = require('chance').Chance();
+const testUtils = require('../../test/utils');
+
+const { env: { adminKey } } = process;
+
+describe('allotment', () => {
+  const newApp = {
+    name: 'tourplantest',
+    packageName: 'ti2-tourplanTest',
+    adminEmail: 'engineering+tourplantest@tourconnect.com',
+  };
+  const appKey = newApp.name;
+  const userId = '551394be5ac58e5c76000019';
+  const token = {
+    endpoint: 'https://someendpoint.com',
+    username: chance.guid(),
+    password: chance.string(),
+  };
+  const newIntegration = {
+    tokenHint: 'testingToken',
+    token,
+  };
+  let doApiDelete;
+  let doApiGet;
+  let doApiPost;
+  let plugins;
+  beforeAll(async () => {
+    ({
+      doApiDelete,
+      doApiGet,
+      doApiPost,
+      plugins,
+    } = await testUtils({
+      plugins: [appKey],
+    }));
+  });
+
+  let userToken;
+  it('drop any existing user integration', async () => {
+    try {
+      await doApiDelete({
+        url: `/${appKey}/${userId}`,
+        token: adminKey,
+        payload: { tokenHint: newIntegration.tokenHint },
+      });
+    } catch (err) {
+      // console.debug(err);
+    }
+  });
+  it('create the user', async () => {
+    ({ value: userToken } = await doApiPost({
+      url: '/user',
+      token: adminKey,
+      payload: { userId },
+    }));
+    expect(userToken).toBeTruthy();
+  });
+  it('create the App+User setup', async () => {
+    const { userAppKeys } = await doApiGet({
+      url: `/user/${userId}/apps`,
+      token: userToken,
+    });
+    if (!userAppKeys.map(e => e.integrationId).includes(appKey)) {
+      // relation does not exits
+      const { value } = await doApiPost({
+        url: `/${appKey}/${userId}`,
+        token: userToken,
+        payload: newIntegration,
+      });
+      expect(value).toBeTruthy();
+    }
+  });
+  const payload = {
+    dateFormat: 'DD-MM-YYYY',
+    startDate: '01-12-2022',
+    endDate: '15-12-2022',
+    keyPath: `${chance.guid()}|${chance.guid()}`,
+  };
+  const urlParams = new URLSearchParams(payload).toString();
+  it('should be able to get some allotments', async () => {
+    const { allotments } = await doApiGet({
+      url: `/allotment/${appKey}/${userId}?${urlParams}`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].queryAllotment).toHaveBeenCalled();
+    expect(Array.isArray(allotments)).toBeTruthy();
+    const call = plugins[0].queryAllotment.mock.calls[0][0];
+    expect(call.payload).toEqual(payload);
+    expect(call.token).toEqual(token);
+  });
+  it('should be able to get some allotments with a hint', async () => {
+    const { allotments } = await doApiGet({
+      url: `/allotment/${appKey}/${newIntegration.tokenHint}/${userId}?${urlParams}`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].queryAllotment).toHaveBeenCalled();
+    expect(Array.isArray(allotments)).toBeTruthy();
+    const call = plugins[0].queryAllotment.mock.calls[0][0];
+    expect(call.payload).toEqual(payload);
+    expect(call.token).toEqual(token);
+  });
+});

package/controllers/allotment.js

@@ -0,0 +1,40 @@
+const assert = require('assert');
+
+const { UserAppKey } = require('../models/index');
+
+const queryAllotment = plugins => async (req, res, next) => {
+  const {
+    params: {
+      appKey,
+      hint,
+      userId,
+    },
+    query,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    assert(app, `could not find the app ${appKey}`);
+    const userAppKeys = await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    });
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    assert(app.queryAllotment, 'could not find the allotment method');
+    const search = app.queryAllotment;
+    const results = await search({
+      token,
+      payload: query,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
+module.exports = plugins => ({
+  queryAllotment: queryAllotment(plugins),
+});

package/index.js

@@ -17,6 +17,7 @@ const adminController = require('./controllers/admin');
 const appController = require('./controllers/app');
 const userController = require('./controllers/user');
 const bookingsController = require('./controllers/bookings');
+const allotmentController = require('./controllers/allotment');
 const { Integration } = require('./models');
 const cache = require('./cache');
 
@@ -24,6 +25,8 @@ const cache = require('./cache');
 const rebuild = fn => obj =>
   Object.fromEntries(Object.entries(obj).flatMap(([k, v]) => fn(k, v)));
 
+const isNumber = value => !Number.isNaN(Number(value));
+
 module.exports = async ({
   apiDocs = true,
   elasticLogIndex = 'apilog_ti2',
@@ -64,7 +67,8 @@ module.exports = async ({
     },
     raw: true,
   });
-  const missingIntegrations = R.difference(pluginNames, matchedIntegrations.map(R.prop('name')));
+  const matchedIntegrationsNames = matchedIntegrations.map(R.prop('name'));
+  const missingIntegrations = R.difference(pluginNames, matchedIntegrationsNames);
   if (missingIntegrations.length > 0) {
     // need to crete the missing integrations
     await Integration.bulkCreate(missingIntegrations.map(name => ({
@@ -81,6 +85,7 @@ module.exports = async ({
     ...appController,
     ...userController(plugins),
     ...bookingsController(plugins),
+    ...allotmentController(plugins),
     cache: R.omit(['cache'], cache),
   }; // mehthods that should map to the yaml api spec
   app.plugins = plugins;
@@ -121,6 +126,8 @@ module.exports = async ({
     );
     const connect = connector(api, allSchema, {
       security: auth,
+      notFound: (req, res) => res.sendStatus(404),
+      notImplemented: (req, res) => res.sendStatus(501),
     });
     if (elasticLogsClient) { // API request logs are saved on elastic
       // setup the index
@@ -200,20 +207,18 @@ module.exports = async ({
       });
     }
     connect(app);
-    if (process.env.mock) {
-      app.use(middleware.mock());
-    }
-    app.use((req, res, next) => {
-      return res.sendStatus(404);
-    })
+    app.use(middleware.mock());
     // global error Handling
-    app.use((err, req, res) => {
+    app.use((err, req, res, next) => {
+      if (res.headersSent) {
+        return next(err);
+      }
       if (process.env.CONSOLE_ERRORS || process.env.JEST_WORKER_ID) {
         console.error(err);
       }
       return res.status((() => {
-        if (isNan(err.status)) return 500;
-        return parseInt(err.status, 10);
+        if (!isNumber(err.status)) return 500;
+        return Number(err.status);
       })()).json({
         message: err.message || 'Internal Error',
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2",
-  "version": "1.0.28",
+  "version": "1.0.31",
   "description": "Tourist Industry Exchange (TI2)",
   "main": "index.js",
   "scripts": {

package/test/plugin.js

@@ -53,6 +53,7 @@ class Plugin {
     });
     this.searchQuote = jestPlugin.fn(() => ({ quote: [{ id: chance.guid() }] }));
     this.createBooking = jestPlugin.fn(() => {});
+    this.queryAllotment = jestPlugin.fn(() => ({ allotments: [] }));
 
     /**
      * Background and schedule Jos
@@ -437,6 +438,25 @@ class Plugin {
    * @returns {Booking} retVal.booking - A Booking object.
    */
   createBooking() {}
+
+  /**
+   * Query Allotment
+   * @async
+   * @param {Object} args - Allotment query arguments.
+   * @param {Object} args.token - A token definition, it's content varies between integrations.
+   * @param {Object} args.payload - Search spect object.
+   *      dateFormat = 'DD/MM/YYYY',
+      startDate,
+      endDate,
+      keyPath,
+   * @param {string} args.payload.dateFormat - Date format to use for params and return value (i.e. DD/MM/YYYY
+   * @param {string} args.payload.startDate - Start date for the query of allotment objects
+   * @param {string} args.payload.endDate - End date for the query of allotment objects
+   * @param {string} args.payload.keyPath - End date for the query of allotment objects
+   * @returns {object} retVal - the return object.
+   * @returns {Booking} retVal.booking - A Booking object.
+   */
+  queryAllotment() {}
 }
 
 module.exports = Plugin;