feat/AB#74292 People picker

config/custom-environment-variables.js

@@ -63,6 +63,7 @@ module.exports = {
     clientId: 'COMMON_SERVICES_CLIENT_ID',
     clientSecret: 'COMMON_SERVICES_CLIENT_SECRET',
     scope: 'COMMON_SERVICES_SCOPE',
+    url: 'COMMON_SERVICES_URL',
   },
   microsoftGraph: {
     tokenEndpoint: 'MICROSOFT_GRAPH_TOKEN_ENDPOINT',

src/const/fieldTypes.ts

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

src/routes/download/index.ts

@@ -141,7 +141,8 @@ router.get('/form/records/:id', async (req, res) => {
         const records = await Record.find(filter);
         const rows = await getRows(
           columns,
-          getAccessibleFields(records, formAbility)
+          getAccessibleFields(records, formAbility),
+          req.headers.authorization
         );
         const type = (req.query ? req.query.type : 'xlsx').toString();
         const filename = formatFilename(form.name);
@@ -318,7 +319,7 @@ router.get('/resource/records/:id', async (req, res) => {
             archived: { $ne: true },
           });
         }
-        const rows = await getRows(columns, records);
+        const rows = await getRows(columns, records, req.headers.authorization);
         const type = (req.query ? req.query.type : 'xlsx').toString();
         const filename = formatFilename(resource.name);
         return await fileBuilder(res, filename, columns, rows, type);

src/routes/proxy/index.ts

@@ -18,6 +18,23 @@ const router = express.Router();
 /** Placeholder to hide settings in UI once saved */
 const SETTING_PLACEHOLDER = '●●●●●●●●●●●●●';
 
+/** common services configuration */
+export const commonServicesConfig = new ApiConfiguration({
+  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.tokenEndpoint'),
+      apiClientID: config.get<string>('commonServices.clientId'),
+      scope: config.get<string>('commonServices.scope'),
+      safeSecret: config.get<string>('commonServices.clientSecret'),
+    }),
+    config.get('encryption.key')
+  ).toString(),
+});
+
 /**
  * Proxy API request
  *
@@ -171,6 +188,16 @@ router.post('/ping/**', async (req: Request, res: Response) => {
   }
 });
 
+router.all('/common-services/**', async (req, res) => {
+  try {
+    const path = req.originalUrl.split('common-services').pop().substring(1);
+    await proxyAPIRequest(req, res, commonServicesConfig, 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

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

src/schema/query/people.query.ts

@@ -0,0 +1,67 @@
+import { GraphQLError, GraphQLInt, 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;
+  offset?: number;
+  limitItems?: number | null;
+};
+
+/**
+ * Return distant users from common services
+ */
+export default {
+  type: new GraphQLList(PersonType),
+  args: {
+    filter: { type: GraphQLJSON },
+    offset: { type: GraphQLInt },
+    limitItems: { type: GraphQLInt },
+  },
+  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,
+        args.offset,
+        args.limitItems
+      );
+      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/draftRecord.type.ts

@@ -50,7 +50,8 @@ export const DraftRecordType = new GraphQLObjectType({
                 if (
                   field.choices ||
                   field.choicesByUrl ||
-                  field.choicesByGraphQL
+                  field.choicesByGraphQL ||
+                  ['people', 'singlepeople'].includes(field.type)
                 ) {
                   res[name] = await getDisplayText(
                     field,

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/schema/types/record.type.ts

@@ -75,7 +75,8 @@ export const RecordType = new GraphQLObjectType({
                 if (
                   field.choices ||
                   field.choicesByUrl ||
-                  field.choicesByGraphQL
+                  field.choicesByGraphQL ||
+                  ['people', 'singlepeople'].includes(field.type)
                 ) {
                   res[name] = await getDisplayText(
                     field,

src/schema/types/resource.type.ts

@@ -224,6 +224,7 @@ export const ResourceType = new GraphQLObjectType({
             { id: r._id }
           ),
         }));
+
         return {
           pageInfo: {
             hasNextPage,

src/utils/aggregation/setDisplayText.ts

@@ -38,7 +38,10 @@ const setDisplayText = async (
     const formField = lookAt.find((field: any) => {
       return (
         lookFor === field.name &&
-        (field.choices || field.choicesByUrl || field.choicesByGraphQL)
+        (field.choices ||
+          field.choicesByUrl ||
+          field.choicesByGraphQL ||
+          ['people', 'singlepeople'].includes(field.type))
       );
     });
     if (formField) {
@@ -47,10 +50,14 @@ const setDisplayText = async (
       return { ...(await acc) };
     }
   };
-  const fieldWithChoices = await mappedFields.reduce(reducer, {});
-  for (const [key, field] of Object.entries(fieldWithChoices)) {
+  const fieldWithChoices: any = await mappedFields.reduce(reducer, {});
+  for (const [key, field] of Object.entries<any>(fieldWithChoices)) {
     // Fetch choices from source ( static / rest / graphql )
-    const choices = await getFullChoices(field, context);
+    let peopleIds = [];
+    if (['people', 'singlepeople'].includes(field.type)) {
+      peopleIds = items.map((item) => item[key]);
+    }
+    const choices = await getFullChoices(field, context, peopleIds);
     for (const item of items) {
       const fieldValue = get(item, key, null);
       if (fieldValue) {

src/utils/files/getRows.ts

@@ -1,17 +1,20 @@
 import get from 'lodash/get';
 import set from 'lodash/set';
 import { getText } from '../form/getDisplayText';
+import { getPeople, getPeopleFilter } from '@utils/proxy';
 
 /**
  * Transforms records into export rows, using fields definition.
  *
  * @param columns definition of export columns.
  * @param records list of records.
+ * @param token used to make graphql queries
  * @returns list of export rows.
  */
 export const getRows = async (
   columns: any[],
-  records: any[]
+  records: any[],
+  token?: string
 ): Promise<any[]> => {
   const rows = [];
   for (const record of records) {
@@ -113,6 +116,29 @@ export const getRows = async (
           }
           break;
         }
+        case 'people':
+        case 'singlepeople': {
+          const value = get(data, column.field);
+          const filter = getPeopleFilter(value);
+          const people = await getPeople(token, filter);
+          if (!people) {
+            return;
+          }
+          set(
+            row,
+            column.name,
+            people
+              .map((x) => {
+                const fullname =
+                  x.firstname && x.lastname
+                    ? `${x.firstname}, ${x.lastname}`
+                    : x.firstname || x.lastname;
+                return `${fullname} (${x.emailaddress})`;
+              })
+              .join(', ')
+          );
+          break;
+        }
         default: {
           const value = column.default
             ? get(record, column.field)

src/utils/files/getRowsFromMeta.ts

@@ -58,6 +58,8 @@ export const getRowsFromMeta = (columns: any[], records: any[]): any[] => {
           set(row, column.name, Array.isArray(value) ? value.join(',') : value);
           break;
         }
+        case 'people':
+        case 'singlepeople':
         case 'users': {
           let value: any = get(record, column.field);
           const choices = column.meta.field.choices || [];
@@ -92,16 +94,8 @@ export const getRowsFromMeta = (columns: any[], records: any[]): any[] => {
           set(row, column.name, Array.isArray(value) ? value.join(',') : value);
           break;
         }
-        case 'multipletext': {
-          const value = get(record, column.name);
-          set(row, column.name, value);
-          break;
-        }
-        case 'matrix': {
-          const value = get(record, column.name);
-          set(row, column.name, value);
-          break;
-        }
+        case 'multipletext':
+        case 'matrix':
         case 'matrixdropdown': {
           const value = get(record, column.name);
           set(row, column.name, value);

src/utils/form/getDisplayText.ts

@@ -5,6 +5,7 @@ import { logger } from '@services/logger.service';
 import axios from 'axios';
 import get from 'lodash/get';
 import jsonpath from 'jsonpath';
+import { getPeople, getPeopleFilter } from '@utils/proxy';
 
 /**
  * Gets display text from choice value.
@@ -38,11 +39,13 @@ export const getText = (choices: any[], value: any): string => {
  *
  * @param field field to get value of.
  * @param context provides the data sources context.
+ * @param peopleIds ids of people to fetch
  * @returns Choice list of the field.
  */
 export const getFullChoices = async (
   field: any,
-  context: Context
+  context: Context,
+  peopleIds?: string[] | string
 ): Promise<{ value: string; text: string }[] | string[]> => {
   try {
     if (field.choicesByUrl) {
@@ -110,6 +113,23 @@ export const getFullChoices = async (
         choices.push({ [valueField]: 'other', [textField]: 'Other' });
       }
       return choices;
+    } else if (['people', 'singlepeople'].includes(field.type)) {
+      // Generate a filter to only fetch users we need
+      const filter = getPeopleFilter(peopleIds);
+      const people = await getPeople(context.token, filter);
+      if (!people) {
+        return [];
+      }
+      return 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,
+        };
+      });
     } else {
       return field.choices;
     }
@@ -133,7 +153,7 @@ const getDisplayText = async (
   context: Context
 ): Promise<string | string[]> => {
   const choices: { value: string; text: string }[] | string[] =
-    await getFullChoices(field, context);
+    await getFullChoices(field, context, [value]);
   if (choices && choices.length) {
     if (Array.isArray(value)) {
       return value.map((x) => getText(choices, x));

src/utils/form/getFieldType.ts

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