feat/AB#74292 People picker

config/custom-environment-variables.js

@@ -62,5 +62,7 @@ module.exports = {
     clientId: 'COMMON_SERVICES_CLIENT_ID',
     clientSecret: 'COMMON_SERVICES_CLIENT_SECRET',
     scope: 'COMMON_SERVICES_SCOPE',
+    authUrl: 'COMMON_SERVICES_AUTH_URL',
+    url: 'COMMON_SERVICES_URL',
   },
 };

src/const/fieldTypes.ts

@@ -5,6 +5,7 @@ export const MULTISELECT_TYPES: string[] = [
   'tagbox',
   'owner',
   'users',
+  'people',
 ];
 
 /** List of date field types */

src/routes/proxy/index.ts

@@ -171,6 +171,33 @@ router.post('/ping/**', async (req: Request, res: Response) => {
   }
 });
 
+router.all('/common-services/**', async (req, res) => {
+  const commonServiceConfig = {
+    name: 'common-services',
+    status: 'active',
+    authType: 'service-to-service',
+    endpoint: config.get<string>('commonServices.url'),
+    settings: CryptoJS.AES.encrypt(
+      JSON.stringify({
+        authTargetUrl: config.get<string>('commonServices.authUrl'),
+        apiClientID: config.get<string>('commonServices.clientId'),
+        scope: config.get<string>('commonServices.scope'),
+        safeSecret: config.get<string>('commonServices.clientSecret'),
+      }),
+      config.get('encryption.key')
+    ).toString(),
+  };
+
+  try {
+    const api = new ApiConfiguration(commonServiceConfig);
+    const path = req.originalUrl.split('common-services').pop().substring(1);
+    await proxyAPIRequest(req, res, api, path);
+  } catch (err) {
+    logger.error(err.message, { stack: err.stack });
+    return res.status(500).send(req.t('common.errors.internalServerError'));
+  }
+});
+
 /**
  * Forward requests to actual API using the API Configuration
  */

src/schema/query/index.ts

@@ -39,6 +39,7 @@ import layer from './layer.query';
 import draftRecords from './draftRecords.query';
 import referenceDataAggregation from './referenceDataAggregation.query';
 import types from './types.query';
+import people from './people.query';
 
 /** GraphQL query type definition */
 const Query = new GraphQLObjectType({
@@ -84,6 +85,7 @@ const Query = new GraphQLObjectType({
     layers,
     layer,
     draftRecords,
+    people,
   },
 });
 

src/schema/query/people.query.ts

@@ -0,0 +1,58 @@
+import { GraphQLError, GraphQLList } from 'graphql';
+import { logger } from '@services/logger.service';
+import { Context } from '@server/apollo/context';
+import GraphQLJSON from 'graphql-type-json';
+import { PersonType } from '@schema/types/person.type';
+import { getPeople } from '@utils/proxy';
+
+/** Arguments for the people query */
+type PeopleArgs = {
+  filter?: any;
+};
+
+/**
+ * Return distant users from common services
+ */
+export default {
+  type: new GraphQLList(PersonType),
+  args: {
+    filter: { type: GraphQLJSON },
+  },
+  async resolve(parent, args: PeopleArgs, context: Context) {
+    if (!args.filter) return [];
+    try {
+      // Formatted filter used by the API
+      const getFormattedFilter = (filter: any) => {
+        const formattedFilter = `{${filter.logic.toUpperCase()}:[
+            ${filter.filters.map((el: any) => {
+              if (el.operator === 'like') {
+                el.value = `"%${el.value}%"`;
+              } else if (el.operator === 'in') {
+                el.value = el.value.map((e) => `"${e}"`);
+                el.value = `[${el.value}]`;
+              }
+              return `{ ${el.field}_${el.operator}: ${el.value} }`;
+            })}
+          ]
+        }`;
+        return formattedFilter.replace(/\s/g, '');
+      };
+      const filter = getFormattedFilter(args.filter);
+      const people = await getPeople(context.token, filter);
+      if (people) {
+        return people.map((person) => {
+          const updatedPerson = { ...person };
+          updatedPerson.id = updatedPerson.userid;
+          delete updatedPerson.userid;
+          return updatedPerson;
+        });
+      }
+      return [];
+    } catch (err) {
+      logger.error(err.message, { stack: err.stack });
+      throw new GraphQLError(
+        context.i18next.t('common.errors.internalServerError')
+      );
+    }
+  },
+};

src/schema/types/person.type.ts

@@ -0,0 +1,14 @@
+import { GraphQLObjectType, GraphQLString } from 'graphql';
+
+/**
+ * GraphQL Person type.
+ */
+export const PersonType = new GraphQLObjectType({
+  name: 'Person',
+  fields: () => ({
+    id: { type: GraphQLString },
+    firstname: { type: GraphQLString },
+    lastname: { type: GraphQLString },
+    emailaddress: { type: GraphQLString },
+  }),
+});

src/utils/form/getFieldType.ts

@@ -81,6 +81,8 @@ export const getFieldType = async (question: {
       return 'users';
     case 'owner':
       return 'owner';
+    case 'people':
+      return 'people';
     case 'geospatial':
       return 'geospatial';
     default:

src/utils/proxy/getPeople.ts

@@ -0,0 +1,41 @@
+import axios from 'axios';
+
+/**
+ * Fetches the people
+ *
+ * @param token The authorization token
+ * @param filter The filter used for fetching the distant users
+ * @returns the choices
+ */
+export const getPeople = async (token: string, filter: any): Promise<any[]> => {
+  const url = 'http://localhost:3000/proxy/common-services/graphql';
+  const query = `query {
+    users(
+      filter: ${filter}
+    ) {
+      userid
+      firstname
+      lastname
+      emailaddress
+    }
+  }`;
+  try {
+    let people: any[] = [];
+    await axios({
+      url,
+      method: 'post',
+      headers: {
+        Authorization: token,
+        'Content-Type': 'application/json',
+      },
+      data: {
+        query: query,
+      },
+    }).then(({ data }) => {
+      people = data?.data?.users;
+    });
+    return people;
+  } catch {
+    return [];
+  }
+};

src/utils/proxy/index.ts

@@ -1,2 +1,3 @@
 export * from './authManagement';
 export * from './getChoices';
+export * from './getPeople';

src/utils/schema/introspection/getFieldType.ts

@@ -122,6 +122,9 @@ const getFieldType = (
     case 'owner': {
       return GraphQLJSON;
     }
+    case 'people': {
+      return GraphQLJSON;
+    }
     case 'geospatial': {
       return GraphQLJSON;
     }

src/utils/schema/resolvers/Meta/getMetaFieldResolver.ts

@@ -4,14 +4,17 @@ import getMetaOwnerResolver from './getMetaOwnerResolver';
 import getMetaUsersResolver from './getMetaUsersResolver';
 import getMetaRadioResolver from './getMetaRadiogroupResolver';
 import getMetaTagboxResolver from './getMetaTagboxResolver';
+import getMetaPeopleResolver from './getMetaPeopleResolver';
+import { Context } from '@server/apollo/context';
 
 /**
  * Return GraphQL resolver of the field, based on its type.
  *
  * @param field field definition.
+ * @param context graphQL context.
  * @returns resolver of the field.
  */
-const getMetaFieldResolver = (field: any) => {
+const getMetaFieldResolver = (field: any, context: Context) => {
   switch (field.type) {
     case 'dropdown': {
       return getMetaDropdownResolver(field);
@@ -28,6 +31,9 @@ const getMetaFieldResolver = (field: any) => {
     case 'users': {
       return getMetaUsersResolver(field);
     }
+    case 'people': {
+      return getMetaPeopleResolver(field, context);
+    }
     case 'owner': {
       return getMetaOwnerResolver(field);
     }

src/utils/schema/resolvers/Meta/getMetaPeopleResolver.ts

@@ -0,0 +1,55 @@
+import { Record } from '@models';
+import { Context } from '@server/apollo/context';
+import { getPeople } from '@utils/proxy';
+
+/**
+ * Return people meta resolver.
+ *
+ * @param field field definition.
+ * @param context graphQL context.
+ * @returns People resolver.
+ */
+const getMetaPeopleResolver = async (field: any, context: Context) => {
+  const records = await Record.find({
+    resource: field.resource,
+    archived: false,
+  });
+  const peopleIds = [];
+  records.forEach((record) => {
+    const propertyValue = record.data[field.name];
+    propertyValue?.flat().forEach((id: string) => {
+      if (!peopleIds.includes(id)) {
+        peopleIds.push(id);
+      }
+    });
+  });
+  const getFilter = (people: any) => {
+    const formattedFilter = `{
+          userid_in:
+          [${people.map((el: any) => `"${el}"`)}]
+    }`;
+    return formattedFilter.replace(/\s/g, '');
+  };
+  const filter = getFilter(peopleIds);
+  const people = await getPeople(context.token, filter);
+  if (!people) {
+    return [];
+  }
+
+  delete field.resource;
+
+  return Object.assign(field, {
+    choices: people.map((x: any) => {
+      const fullname =
+        x.firstname && x.lastname
+          ? `${x.firstname}, ${x.lastname}`
+          : x.firstname || x.lastname;
+      return {
+        text: `${fullname} (${x.emailaddress})`,
+        value: x.userid,
+      };
+    }),
+  });
+};
+
+export default getMetaPeopleResolver;

src/utils/schema/resolvers/Meta/index.ts

@@ -161,7 +161,7 @@ export const getMetaResolver = (
     .reduce(
       (resolvers, fieldName) =>
         Object.assign({}, resolvers, {
-          [fieldName]: (parent) => {
+          [fieldName]: (parent, args, context) => {
             const field = relationshipFields.includes(fieldName)
               ? parent[
                   fieldName.slice(
@@ -170,7 +170,10 @@ export const getMetaResolver = (
                   )
                 ]
               : parent[fieldName];
-            return getMetaFieldResolver(field);
+            if (field.type === 'people') {
+              field.resource = id;
+            }
+            return getMetaFieldResolver(field, context);
           },
         }),
       {}