OGD invite user flow

angular.json

@@ -37,7 +37,12 @@
               "src/styles.scss"
             ],
             "scripts": [],
-            "sourceMap": true
+            "sourceMap": true,
+            "vendorChunk": true,
+            "extractLicenses": false,
+            "buildOptimizer": false,
+            "optimization": false,
+            "namedChunks": true
           },
           "configurations": {
             "production": {
@@ -74,7 +79,8 @@
             "production": {
               "browserTarget": "rpx-xui-manage-organisations:build:production"
             }
-          }
+          },
+          "defaultConfiguration": ""
         },
         "serveTest": {
           "builder": "@angular-devkit/build-angular:dev-server",

api/allUserListWithoutRoles/index.ts

@@ -11,7 +11,7 @@ export async function handleAllUserListRoute(req: Request, res: Response) {
   try {
     const rdProfessionalApiPath = getConfigValue(SERVICES_RD_PROFESSIONAL_API_PATH);
     const response = await req.http.get(getRefdataAllUserListUrl(rdProfessionalApiPath));
-    logger.info('response::', response.data);
+    logger.info('response::', JSON.stringify(response.data));
     res.send(response.data);
   } catch (error) {
     logger.error('error', error);

api/application.ts

@@ -13,6 +13,7 @@ import {
   FEATURE_REDIS_ENABLED,
   FEATURE_TERMS_AND_CONDITIONS_ENABLED,
   HELMET, SERVICES_CCD_DATA_STORE_API_PATH,
+  SERVICES_CCD_DEFINITION_STORE_API_PATH,
   SERVICES_FEE_AND_PAY_API_PATH,
   SERVICES_MCA_PROXY_API_PATH,
   SERVICES_RD_PROFESSIONAL_API_PATH,
@@ -99,6 +100,8 @@ console.log('healthChecks', healthChecks);
 
 console.log('ccdData', getConfigValue(SERVICES_CCD_DATA_STORE_API_PATH));
 
+console.log('ccdDefinition', getConfigValue(SERVICES_CCD_DEFINITION_STORE_API_PATH));
+
 console.log('caseAssignmentApi', getConfigValue(SERVICES_MCA_PROXY_API_PATH));
 
 console.log('caseTypes', getConfigValue(CASE_TYPES));

api/configuration/references.ts

@@ -39,6 +39,7 @@ export const SERVICES_RD_PROFESSIONAL_API_PATH = 'services.rdProfessionalApi';
 export const SERVICES_FEE_AND_PAY_API_PATH = 'services.feeAndPayApi';
 export const SERVICES_TERMS_AND_CONDITIONS_API_PATH = 'services.termsAndConditions';
 
+export const SERVICES_CCD_DEFINITION_STORE_API_PATH = 'services.ccdDefinitionApi';
 export const SERVICES_CCD_DATA_STORE_API_PATH = 'services.ccdDataApi';
 export const SERVICES_MCA_PROXY_API_PATH = 'services.caseAssignmentApi';
 export const SERVICES_IDAM_ISS_URL = 'iss';

api/editUserPermissions/index.ts

@@ -30,6 +30,26 @@ async function inviteUserRoute(req: Request, res: Response) {
   }
 }
 
+export async function ogdEditUserRoute(req: Request) {
+  let ogdErrReport: ErrorReport;
+  if (!req.params.userId) {
+    ogdErrReport = getErrorReport('UserId is missing', '400', 'User Permissions route error');
+    throw (ogdErrReport);
+  }
+  const payload = req.body;
+  try {
+    const response = await req.http.put(getEditPermissionsUrl(getConfigValue(SERVICES_RD_PROFESSIONAL_API_PATH), req.params.userId), payload);
+    logger.info('response::', response.data);
+
+    return (response.data);
+  } catch (error) {
+    logger.info('error', error);
+    const ogdEditStatus = error.status ? error.status : 500;
+    ogdErrReport = getErrorReport(getErrorMessage(error), ogdEditStatus, getErrorMessage(error));
+    throw (ogdErrReport);
+  }
+}
+
 function getErrorMessage(error: any): string {
   return error && error.data ? error.data.message : '';
 }

api/inviteUser/index.ts

@@ -10,11 +10,12 @@ const logger = log4jui.getLogger('invite-user');
 
 router.post('/', inviteUserRoute);
 
+const rdProfessionalApiPath = getConfigValue(SERVICES_RD_PROFESSIONAL_API_PATH);
+const reqUrl = getRefdataUserCommonUrlUtil(rdProfessionalApiPath);
+
 export async function inviteUserRoute(req: Request, res: Response) {
   const payload = req.body;
   try {
-    const rdProfessionalApiPath = getConfigValue(SERVICES_RD_PROFESSIONAL_API_PATH);
-    const reqUrl = getRefdataUserCommonUrlUtil(rdProfessionalApiPath);
     logger.info('INVITE USER: request URL:: ', reqUrl);
     logger.info('INVITE USER: payload:: ', payload);
     const response = await req.http.post(reqUrl, payload);
@@ -31,4 +32,23 @@ export async function inviteUserRoute(req: Request, res: Response) {
     res.status(status).send(errReport);
   }
 }
+
+export async function inviteUserRouteOGD(req: Request) {
+  const payload = req.body.userPayload;
+  try {
+    logger.info('INVITE USER OGD: request URL:: ', reqUrl);
+    const response = await req.http.post(reqUrl, payload);
+    logger.info('response::', response.data);
+    return (response.data);
+  } catch (error) {
+    logger.error('error', error);
+    const ogdStatus = exists(error, 'status') ? error.status : 500;
+    const ogdErrReport = {
+      apiError: valueOrNull(error, 'data.errorMessage'),
+      apiStatusCode: ogdStatus,
+      message: valueOrNull(error, 'data.errorDescription')
+    };
+    throw (ogdErrReport);
+  }
+}
 export default router;

api/ogd/index.ts

@@ -0,0 +1,50 @@
+import { Request, Response, Router } from 'express';
+import { compareAccessTypes } from '../retrieveAccessTypes';
+import { inviteUserRouteOGD } from '../inviteUser';
+import { ogdEditUserRoute } from '../editUserPermissions';
+import { refreshUser } from '../refresh-user';
+import * as log4jui from '../lib/log4jui';
+
+export const router = Router({ mergeParams: true });
+const logger = log4jui.getLogger('OGD-FLOW');
+
+export async function ogdInvite(req: Request, res: Response) {
+  try {
+    logger.info('ogdInvite:: Invite Request received');
+    const userPayload = req.body.userPayload;
+    if (userPayload.roles.includes('pui-caa')) {
+      const compareResult = await compareAccessTypes(req);
+      req.body.userPayload = { ...userPayload, ...compareResult };
+    }
+    const operationResult = await inviteUserRouteOGD(req);
+    const userId = operationResult.userIdentifier;
+    req.body = { userId };
+    await refreshUser(req);
+    res.send(operationResult);
+  } catch (error) {
+    logger.error('ogdInvite:: Error ', error);
+    res.status(error.apiStatusCode || 500).json(error);
+  }
+}
+
+export async function ogdUpdate(req: Request, res: Response) {
+  try {
+    logger.info('ogdUpdate:: Edit User Request received');
+    const userPayload = req.body.userPayload;
+    const userId = req.params.userId;
+    const compareResult = await compareAccessTypes(req);
+    req.body = { ...userPayload, ...compareResult };
+    const operationResult = await ogdEditUserRoute(req);
+    req.body = { userId };
+    await refreshUser(req);
+    res.send(operationResult);
+  } catch (error) {
+    logger.error('ogdUpdate:: Error ', error);
+    res.status(error.apiStatusCode || 500).json(error);
+  }
+}
+
+router.post('/invite', ogdInvite);
+router.put('/update/:userId', ogdUpdate);
+
+export default router;

api/refresh-user/index.ts

@@ -0,0 +1,33 @@
+import { Request, Router } from 'express';
+import { getConfigValue } from '../configuration';
+import { SERVICES_ROLE_ASSIGNMENT_API_PATH } from '../configuration/references';
+import * as log4jui from '../lib/log4jui';
+import { exists, valueOrNull } from '../lib/util';
+
+const logger = log4jui.getLogger('refresh-user');
+
+export async function refreshUser(req: Request) {
+  const payload = req.body;
+  try {
+    const serviceApiBasePath = getConfigValue(SERVICES_ROLE_ASSIGNMENT_API_PATH);
+    const userId = payload.userId;
+    const reqUrl = `${serviceApiBasePath}/am/role-mapping/professional/refresh?userId=${userId}`;
+    logger.info('REFRESH USER: request URL:: ', reqUrl);
+    const response = await req.http.post(reqUrl);
+    logger.info('response::', response.data);
+    return response.data;
+  } catch (error) {
+    logger.error('error', error);
+    const status = exists(error, 'status') ? error.status : 500;
+    const errReport = {
+      apiError: valueOrNull(error, 'data.errorMessage'),
+      apiStatusCode: status,
+      message: valueOrNull(error, 'data.errorDescription')
+    };
+    throw (errReport);
+  }
+}
+
+export const router = Router({ mergeParams: true });
+router.post('/', refreshUser);
+export default router;

api/retrieveAccessTypes/accessTypesComparison.ts

@@ -0,0 +1,51 @@
+// Function to compare the users accessType selections with the most recently obtained ones
+export function processAccessTypes(currentOrganisationAccessTypes, userAccessTypeOptions) {
+  const processedAccessTypes = [];
+  const accessTypesMap = new Map();
+  currentOrganisationAccessTypes.forEach((jurisdiction) => {
+    jurisdiction.accessTypes.forEach((accessType) => {
+      const key = `${jurisdiction.jurisdictionId}-${accessType.organisationProfileId}-${accessType.accessTypeId}`;
+      accessTypesMap.set(key, accessType);
+    });
+  });
+
+  userAccessTypeOptions.userAccessTypes.forEach((userAccessType) => {
+    const key = `${userAccessType.jurisdictionId}-${userAccessType.organisationProfileId}-${userAccessType.accessTypeId}`;
+    const accessType = accessTypesMap.get(key);
+
+    if (accessType && accessType.display) {
+      if (accessType.accessMandatory && accessType.accessDefault) {
+        // If access type is mandatory and default is true, set it to true
+        processedAccessTypes.push({
+          jurisdictionId: userAccessType.jurisdictionId,
+          organisationProfileId: userAccessType.organisationProfileId,
+          accessTypeId: userAccessType.accessTypeId,
+          enabled: true
+        });
+      } else {
+        // For non-mandatory access types or mandatory with default false, use user's selection
+        processedAccessTypes.push(userAccessType);
+      }
+    }
+
+    // Remove the processed access type from the map
+    accessTypesMap.delete(key);
+  });
+
+  accessTypesMap.forEach((accessType, key) => {
+    if (accessType.display) {
+      const [jurisdictionId, organisationProfileId, accessTypeId] = key.split('-');
+      processedAccessTypes.push({
+        jurisdictionId,
+        organisationProfileId,
+        accessTypeId,
+        enabled: accessType.accessDefault
+      });
+    }
+  });
+
+  return {
+    ...userAccessTypeOptions,
+    userAccessTypes: processedAccessTypes
+  };
+}

api/retrieveAccessTypes/index.ts

@@ -0,0 +1,56 @@
+import { Request, Response, Router } from 'express';
+import { getConfigValue } from '../configuration';
+import { SERVICES_CCD_DEFINITION_STORE_API_PATH } from '../configuration/references';
+import * as log4jui from '../lib/log4jui';
+import { exists, valueOrNull } from '../lib/util';
+import { processAccessTypes } from './accessTypesComparison';
+
+const logger = log4jui.getLogger('retrive-access-types');
+
+async function fetchAccessTypes(req: Request, payload: any): Promise<any> {
+  try {
+    const ccdDefinitionStore = getConfigValue(SERVICES_CCD_DEFINITION_STORE_API_PATH);
+    const url = `${ccdDefinitionStore}/retrieve-access-types`;
+    logger.info('RETRIEVE ACCESS TYPES: request URL:: ', url);
+    const response = await req.http.post(url, payload);
+    return response.data;
+  } catch (error) {
+    logger.error(error);
+    throw error;
+  }
+}
+
+export async function handleRetrieveAccessTypes(req: Request, res: Response) {
+  const payload = req.body;
+  try {
+    const data = await fetchAccessTypes(req, payload);
+    res.send(data);
+  } catch (error) {
+    const status = exists(error, 'status') ? error.status : 500;
+    const errReport = {
+      apiError: valueOrNull(error, 'data.errorMessage'),
+      apiStatusCode: status,
+      message: valueOrNull(error, 'data.errorDescription')
+    };
+    res.status(status).send(errReport);
+  }
+}
+
+export async function compareAccessTypes(req: Request) {
+  try {
+    const orgIdPayload = { organisationProfileIds: req.body.orgIdsPayload };
+    const userAccessTypesPayload = req.body.userPayload;
+    const accessTypes = await fetchAccessTypes(req, orgIdPayload);
+    const comparedUserSelections = processAccessTypes(accessTypes.jurisdictions, userAccessTypesPayload);
+    return (comparedUserSelections);
+  } catch (error) {
+    logger.error('Error in compareAccessTypes:', error);
+    return ({ error: 'An error occurred while processing your request.' });
+  }
+}
+
+export const router = Router({ mergeParams: true });
+
+router.post('/', handleRetrieveAccessTypes);
+router.post('/compare', compareAccessTypes);
+export default router;

api/routes.ts

@@ -23,6 +23,9 @@ import getTermsAndConditions from './termsAndConditions';
 import userDetailsRouter from './user';
 import getUserDetails from './user-details';
 import getUserList from './userList';
+import refreshUser from './refresh-user';
+import retriveAccessTypes from './retrieveAccessTypes';
+import ogdInvite from './ogd';
 
 const router = Router({ mergeParams: true });
 
@@ -40,6 +43,7 @@ router.use('/accounts', accountsRouter);
 router.use('/user', userDetailsRouter);
 router.use('/healthCheck', healthCheck);
 router.use('/inviteUser', inviteUser);
+router.use('/refresh-user', refreshUser);
 router.use('/allUserList', getAllUserList);
 router.use('/allUserListWithoutRoles', getAllUserListWithoutRoles);
 router.use('/userList', getUserList);
@@ -57,4 +61,6 @@ router.use('/caseshare', caseShareRouter);
 router.use('/pba', pbaRouter);
 router.use('/register-org', registerRouter);
 router.use('/user-details', getUserDetails);
+router.use('/retrieve-access-types', retriveAccessTypes);
+router.use('/ogd-flow', ogdInvite);
 export default router;

charts/xui-mo-webapp/Chart.yaml

@@ -1,7 +1,7 @@
 apiVersion: v2
 name: xui-mo-webapp
 home: https://github.com/hmcts/rpx-xui-manage-organisations
-version: 1.1.16
+version: 1.1.17
 description: Expert UI
 maintainers:
   - name: HMCTS RPX XUI

charts/xui-mo-webapp/values.yaml

@@ -69,6 +69,7 @@ nodejs:
     MANAGE_CASE_LINK: https://manage-case.{{ .Values.global.environment }}.platform.hmcts.net/cases
     MANAGE_ORG_LINK: https://manage-org.{{ .Values.global.environment }}.platform.hmcts.net
     SERVICES_CCD_DATA_STORE_API: http://ccd-data-store-api-{{ .Values.global.environment }}.service.core-compute-{{ .Values.global.environment }}.internal
+    SERVICES_CCD_DEFINITION_STORE_API: http://ccd-definition-store-api-{{ .Values.global.environment }}.service.core-compute-{{ .Values.global.environment }}.internal
     SERVICES_MCA_PROXY_API: http://aac-manage-case-assignment-{{ .Values.global.environment }}.service.core-compute-{{ .Values.global.environment }}.internal
     SERVICES_IDAM_ISS_URL: https://forgerock-am.service.core-compute-idam-{{ .Values.global.environment }}2.internal:8443/openam/oauth2/realms/root/realms/hmcts
     SERVICES_ROLE_ASSIGNMENT_API: http://am-role-assignment-service-{{ .Values.global.environment }}.service.core-compute-{{ .Values.global.environment }}.internal

config/custom-environment-variables.json

@@ -33,6 +33,7 @@
         "feeAndPayApi": "FEE_AND_PAY_API",
         "termsAndConditions": "SERVICES_TERMS_AND_CONDITIONS_API_SERVICE",
         "ccdDataApi": "SERVICES_CCD_DATA_STORE_API",
+        "ccdDefinitionApi": "SERVICES_CCD_DEFINITION_STORE_API",
         "caseAssignmentApi": "SERVICES_MCA_PROXY_API",
         "role_assignment": {
           "roleApi": "SERVICES_ROLE_ASSIGNMENT_API"

config/default.json

@@ -36,6 +36,7 @@
     "feeAndPayApi": "https://payment-api-prod.service.core-compute-prod.internal",
     "termsAndConditions": "http://xui-terms-and-conditions-aat.service.core-compute-aat.internal",
     "ccdDataApi": "http://ccd-data-store-api-prod.service.core-compute-prod.internal",
+    "ccdDefinitionApi": "http://ccd-definition-store-api-prod.service.core-compute-prod.internal",
     "caseAssignmentApi": "http://aac-manage-case-assignment-prod.service.core-compute-prod.internal",
     "role_assignment": {
       "roleApi": "http://am-role-assignment-service-prod.service.core-compute-prod.internal"

src/app/app-initializer.ts

@@ -10,7 +10,8 @@ export function initApplication(store: Store<fromApp.State>): VoidFunction {
     store.dispatch(new fromApp.LoadFeatureToggleConfig([AppConstants.FEATURE_NAMES.feeAccount,
       AppConstants.FEATURE_NAMES.editUserPermissions,
       AppConstants.FEATURE_NAMES.caaMenuItems,
-      AppConstants.FEATURE_NAMES.newRegisterOrg]));
+      AppConstants.FEATURE_NAMES.newRegisterOrg,
+      AppConstants.FEATURE_NAMES.ogdInviteUserFlow]));
 
     store.pipe(
       select(fromSelectors.getAppState),