ATS client push API: New POST API, New backend type for ATSClient, at…

…sController, route, services, validator updated

Backend unti test added
New ATSClientResource type, ATSUserResponse type, frontend components updated

app/src/controllers/ats.ts

@@ -1,7 +1,9 @@
 import { atsService } from '../services';
 
+import { getCurrentUsername } from '../utils/utils';
+
 import type { NextFunction, Request, Response } from 'express';
-import type { ATSUserSearchParameters } from '../types';
+import type { ATSClientResource, ATSUserSearchParameters } from '../types';
 
 const controller = {
   searchATSUsers: async (
@@ -12,6 +14,18 @@ const controller = {
     try {
       const response = await atsService.searchATSUsers(req.query);
 
+      res.status(response.status).json(response.data);
+    } catch (e: unknown) {
+      next(e);
+    }
+  },
+
+  createATSClient: async (req: Request<never, never, ATSClientResource, never>, res: Response, next: NextFunction) => {
+    try {
+      const identityProvider = req.currentContext?.tokenPayload?.identity_provider.toUpperCase();
+      const atsClient = req.body;
+      atsClient.createdBy = `${identityProvider}\\${getCurrentUsername(req.currentContext)}`;
+      const response = await atsService.createATSClient(atsClient);
       res.status(response.status).json(response.data);
     } catch (e: unknown) {
       next(e);

app/src/routes/v1/ats.ts

@@ -5,9 +5,10 @@ import { hasAuthorization } from '../../middleware/authorization';
 import { requireSomeAuth } from '../../middleware/requireSomeAuth';
 import { requireSomeGroup } from '../../middleware/requireSomeGroup';
 import { Action, Resource } from '../../utils/enums/application';
+import { atsValidator } from '../../validators';
 
 import type { NextFunction, Request, Response } from 'express';
-import type { ATSUserSearchParameters } from '../../types';
+import type { ATSClientResource, ATSUserSearchParameters } from '../../types';
 
 const router = express.Router();
 router.use(requireSomeAuth);
@@ -21,4 +22,14 @@ router.get(
   }
 );
 
+/** Creates a client in ATS */
+router.post(
+  '/client',
+  hasAuthorization(Resource.ATS, Action.CREATE),
+  atsValidator.createATSClient,
+  (req: Request<never, never, ATSClientResource, never>, res: Response, next: NextFunction): void => {
+    atsController.createATSClient(req, res, next);
+  }
+);
+
 export default router;

app/src/services/ats.ts

@@ -2,14 +2,13 @@ import axios from 'axios';
 import config from 'config';
 
 import type { AxiosInstance } from 'axios';
-import type { ATSUserSearchParameters } from '../types';
+import type { ATSClientResource, ATSUserSearchParameters } from '../types';
 
 /**
  * @function getToken
  * Gets Auth token using ATS client credentials
  * @returns
  */
-
 async function getToken() {
   const response = await axios({
     method: 'GET',
@@ -33,7 +32,6 @@ async function getToken() {
  * @param {AxiosRequestConfig} options Axios request config options
  * @returns {AxiosInstance} An axios instance
  */
-
 function atsAxios(): AxiosInstance {
   // Create axios instance
   const atsAxios = axios.create({
@@ -57,7 +55,6 @@ const service = {
    * @param {ATSUserSearchParameters} data The search parameters
    * @returns {Promise<data | null>} The result of calling the search api
    */
-
   searchATSUsers: async (params?: ATSUserSearchParameters) => {
     try {
       const { data, status } = await atsAxios().get('/clients', { params: params });
@@ -75,6 +72,31 @@ const service = {
         };
       }
     }
+  },
+
+  /**
+   * @function createATSClient
+   * Creates a client in ATS
+   * @param {ATSClientResource} data The client data
+   * @returns {Promise<data | null>} The result of calling the post api
+   */
+  createATSClient: async (atsClient: ATSClientResource) => {
+    try {
+      const { data, status } = await atsAxios().post('/clients', atsClient);
+      return { data: data, status };
+    } catch (e: unknown) {
+      if (axios.isAxiosError(e)) {
+        return {
+          data: e.response?.data.message,
+          status: e.response ? e.response.status : 500
+        };
+      } else {
+        return {
+          data: 'Error',
+          status: 500
+        };
+      }
+    }
   }
 };
 

app/src/types/ATSClientResource.ts

@@ -0,0 +1,23 @@
+import { BasicResponse } from '../utils/enums/application';
+
+type AddressResource = {
+  '@type': 'AddressResource';
+  addressLine1: string;
+  addressLine2: string | null;
+  city: string;
+  provinceCode: string;
+  countryCode: string;
+  postalCode: string | null;
+  primaryPhone: string;
+  email: string;
+};
+
+export type ATSClientResource = {
+  '@type': 'ClientResource';
+  address: AddressResource;
+  firstName: string;
+  surName: string;
+  regionName: string;
+  optOutOfBCStatSurveyInd: BasicResponse.YES | BasicResponse.NO;
+  createdBy: string;
+};

app/src/types/index.ts

@@ -1,5 +1,6 @@
 export type { Activity } from './Activity';
 export type { AccessRequest } from './AccessRequest';
+export type { ATSClientResource } from './ATSClientResource';
 export type { ATSUserSearchParameters } from './ATSUserSearchParameters';
 export type { BceidSearchParameters } from './BceidSearchParameters';
 export type { BringForward } from './BringForward';

app/src/validators/ats.ts

@@ -0,0 +1,33 @@
+import Joi from 'joi';
+
+import { validate } from '../middleware/validation';
+
+import { BasicResponse } from '../utils/enums/application';
+
+const addressBody = {
+  '@type': Joi.string().valid('AddressResource'),
+  addressLine1: Joi.string().max(255).allow(null),
+  city: Joi.string().max(255).allow(null),
+  provinceCode: Joi.string().max(255).allow(null),
+  primaryPhone: Joi.string().max(255).allow(null),
+  email: Joi.string().max(255).allow(null)
+};
+
+const clientBody = {
+  '@type': Joi.string().valid('ClientResource'),
+  firstName: Joi.string().max(255).required(),
+  surName: Joi.string().max(255).required(),
+  regionName: Joi.string().max(255).required(),
+  optOutOfBCStatSurveyInd: Joi.string().valid(BasicResponse.NO.toUpperCase()),
+  address: Joi.object(addressBody).allow(null)
+};
+
+const schema = {
+  createATSClient: {
+    body: Joi.object(clientBody)
+  }
+};
+
+export default {
+  createATSClient: validate(schema.createATSClient)
+};

app/src/validators/index.ts

@@ -1,4 +1,5 @@
 export { default as accessRequestValidator } from './accessRequest';
+export { default as atsValidator } from './ats';
 export { default as documentValidator } from './document';
 export { default as enquiryValidator } from './enquiry';
 export { default as noteValidator } from './note';