feat(datatrakWeb): RN-1362: Datatrak Web User question type

packages/admin-panel/src/routes/surveys/surveys.js

@@ -541,7 +541,7 @@ const QUESTION_COLUMNS = [
                     fieldName: 'permissionGroup',
                     optionsEndpoint: 'permissionGroups',
                     optionLabelKey: 'name',
-                    optionValueKey: 'name',
+                    optionValueKey: 'id',
                     labelTooltip: 'Select the permission group the user list should be filtered by',
                   },
                 ],

packages/central-server/src/apiV2/import/importSurveys/ConfigImporter/ConfigImporter.js

@@ -12,6 +12,7 @@ import { processConditionConfig } from './processConditionConfig';
 import { processAutocompleteConfig } from './processAutocompleteConfig';
 import { processEntityConfig } from './processEntityConfig';
 import { processTaskConfig } from './processTaskConfig';
+import { processUserConfig } from './processUserConfig';
 
 const { CODE_GENERATOR, ARITHMETIC, CONDITION, AUTOCOMPLETE, ENTITY, PRIMARY_ENTITY, TASK, USER } =
   ANSWER_TYPES;
@@ -91,7 +92,8 @@ export class ConfigImporter {
         return { task: taskConfig };
       }
       case USER: {
-        return { user: config };
+        const userConfig = await processUserConfig(this.models, config);
+        return { user: userConfig };
       }
 
       default:

packages/central-server/src/apiV2/import/importSurveys/ConfigImporter/processUserConfig.js

@@ -0,0 +1,22 @@
+/**
+ * Tupaia
+ * Copyright (c) 2017 - 2024 Beyond Essential Systems Pty Ltd
+ */
+
+const translatePermissionGroup = async (config, models) => {
+  const { permissionGroup } = config;
+  const actualPermissionGroup = await models.permissionGroup.findOne({ name: permissionGroup });
+  if (!actualPermissionGroup) {
+    throw new Error(`Permission group ${permissionGroup} not found`);
+  }
+
+  return {
+    ...config,
+    permissionGroup: actualPermissionGroup.id,
+  };
+};
+
+export const processUserConfig = async (models, config) => {
+  const translatedConfig = await translatePermissionGroup(config, models);
+  return translatedConfig;
+};

packages/datatrak-web-server/src/app/createApp.ts

@@ -29,6 +29,8 @@ import {
   GenerateLoginTokenRoute,
   LeaderboardRequest,
   LeaderboardRoute,
+  PermissionGroupUsersRequest,
+  PermissionGroupUsersRoute,
   ProjectRequest,
   ProjectRoute,
   ProjectsRequest,
@@ -88,6 +90,7 @@ export async function createApp() {
     .get<TaskRequest>('tasks/:taskId', handleWith(TaskRoute))
     .get<SingleSurveyResponseRequest>('surveyResponse/:id', handleWith(SingleSurveyResponseRoute))
     .get<SurveyUsersRequest>('users/:surveyCode/:countryCode', handleWith(SurveyUsersRoute))
+    .get<PermissionGroupUsersRequest>('users/:countryCode', handleWith(PermissionGroupUsersRoute))
     // Post Routes
     .post<CreateTaskRequest>('tasks', handleWith(CreateTaskRoute))
     .put<EditTaskRequest>('tasks/:taskId', handleWith(EditTaskRoute))

packages/datatrak-web-server/src/routes/PermissionGroupUsersRoute.ts

@@ -0,0 +1,43 @@
+/**
+ * Tupaia
+ * Copyright (c) 2017 - 2024 Beyond Essential Systems Pty Ltd
+ */
+
+/**
+ * Tupaia
+ * Copyright (c) 2017 - 2024 Beyond Essential Systems Pty Ltd
+ */
+
+import { Request } from 'express';
+import { Route } from '@tupaia/server-boilerplate';
+import { DatatrakWebUsersRequest } from '@tupaia/types';
+import { getFilteredUsers } from '../utils';
+
+export type PermissionGroupUsersRequest = Request<
+  DatatrakWebUsersRequest.Params,
+  DatatrakWebUsersRequest.ResBody,
+  DatatrakWebUsersRequest.ReqBody,
+  DatatrakWebUsersRequest.ReqQuery
+>;
+
+export class PermissionGroupUsersRoute extends Route<PermissionGroupUsersRequest> {
+  public async buildResponse() {
+    const { models, params, query } = this.req;
+    const { countryCode } = params;
+
+    const { searchTerm, permissionGroupId } = query;
+
+    if (!permissionGroupId) {
+      throw new Error('Permission group id is required');
+    }
+
+    // get the permission group
+    const permissionGroup = await models.permissionGroup.findById(permissionGroupId);
+
+    if (!permissionGroup) {
+      throw new Error(`Permission group with id '${permissionGroupId}' not found`);
+    }
+
+    return getFilteredUsers(models, countryCode, permissionGroup, searchTerm);
+  }
+}

packages/datatrak-web-server/src/routes/SurveyUsersRoute.ts

@@ -5,33 +5,16 @@
 
 import { Request } from 'express';
 import { Route } from '@tupaia/server-boilerplate';
-import { DatatrakWebSurveyUsersRequest, EntityType } from '@tupaia/types';
-import { QUERY_CONJUNCTIONS } from '@tupaia/database';
-
-const USERS_EXCLUDED_FROM_LIST = [
-  'edmofro@gmail.com', // Edwin
-  'kahlinda.mahoney@gmail.com', // Kahlinda
-  'lparish1980@gmail.com', // Lewis
-  'sus.lake@gmail.com', // Susie
-  'michaelnunan@hotmail.com', // Michael
-  'vanbeekandrew@gmail.com', // Andrew
-  'gerardckelly@gmail.com', // Gerry K
-  'geoffreyfisher@hotmail.com', // Geoff F
-  'josh@sussol.net', // mSupply API Client
-  'unicef.laos.edu@gmail.com', // Laos Schools Data Collector
-  'tamanu-server@tupaia.org', // Tamanu Server
-  'public@tupaia.org', // Public User
-];
+import { DatatrakWebUsersRequest } from '@tupaia/types';
+import { getFilteredUsers } from '../utils';
 
 export type SurveyUsersRequest = Request<
-  DatatrakWebSurveyUsersRequest.Params,
-  DatatrakWebSurveyUsersRequest.ResBody,
-  DatatrakWebSurveyUsersRequest.ReqBody,
-  DatatrakWebSurveyUsersRequest.ReqQuery
+  DatatrakWebUsersRequest.Params,
+  DatatrakWebUsersRequest.ResBody,
+  DatatrakWebUsersRequest.ReqBody,
+  DatatrakWebUsersRequest.ReqQuery
 >;
 
-const DEFAULT_PAGE_SIZE = 100;
-
 export class SurveyUsersRoute extends Route<SurveyUsersRequest> {
   public async buildResponse() {
     const { models, params, query } = this.req;
@@ -58,45 +41,6 @@ export class SurveyUsersRoute extends Route<SurveyUsersRequest> {
       throw new Error(`Permission group with id ${permissionGroupId} not found`);
     }
 
-    // get the ancestors of the permission group
-    const permissionGroupWithAncestors = await permissionGroup.getAncestors();
-
-    const entity = await models.entity.findOne({
-      country_code: countryCode,
-      type: EntityType.country,
-    });
-
-    // get the user entity permissions for the permission group and its ancestors
-    const userEntityPermissions = await models.userEntityPermission.find({
-      permission_group_id: permissionGroupWithAncestors.map(p => p.id),
-      entity_id: entity.id,
-    });
-
-    const userIds = userEntityPermissions.map(uep => uep.user_id);
-
-    const usersFilter = {
-      id: userIds,
-      email: { comparator: 'not in', comparisonValue: USERS_EXCLUDED_FROM_LIST },
-      [QUERY_CONJUNCTIONS.RAW]: {
-        // exclude E2E users and any internal users
-        sql: `(email NOT LIKE '%tupaia.org' AND email NOT LIKE '%beyondessential.com.au' AND email NOT LIKE '%@bes.au')`,
-      },
-    } as Record<string, any>;
-
-    if (searchTerm) {
-      usersFilter.full_name = { comparator: 'ilike', comparisonValue: `${searchTerm}%` };
-    }
-
-    const users = await models.user.find(usersFilter, {
-      sort: ['full_name ASC'],
-      limit: DEFAULT_PAGE_SIZE,
-    });
-    const userData = users.map(user => ({
-      id: user.id,
-      name: user.full_name,
-    }));
-
-    // only return the id and name of the users
-    return userData;
+    return getFilteredUsers(models, countryCode, permissionGroup, searchTerm);
   }
 }

packages/datatrak-web-server/src/routes/index.ts

@@ -26,3 +26,7 @@ export { TaskRequest, TaskRoute } from './TaskRoute';
 export { SurveyUsersRequest, SurveyUsersRoute } from './SurveyUsersRoute';
 export { CreateTaskRequest, CreateTaskRoute } from './CreateTaskRoute';
 export { EditTaskRequest, EditTaskRoute } from './EditTaskRoute';
+export {
+  PermissionGroupUsersRequest,
+  PermissionGroupUsersRoute,
+} from './PermissionGroupUsersRoute';

packages/datatrak-web-server/src/utils/getFilteredUsers.ts

@@ -0,0 +1,71 @@
+/**
+ * Tupaia
+ * Copyright (c) 2017 - 2024 Beyond Essential Systems Pty Ltd
+ */
+
+import { QUERY_CONJUNCTIONS } from '@tupaia/database';
+import { Country, EntityType } from '@tupaia/types';
+import { DatatrakWebServerModelRegistry } from '../types';
+import { PermissionGroupRecord } from '@tupaia/server-boilerplate';
+
+const USERS_EXCLUDED_FROM_LIST = [
+  'edmofro@gmail.com', // Edwin
+  'kahlinda.mahoney@gmail.com', // Kahlinda
+  'lparish1980@gmail.com', // Lewis
+  'sus.lake@gmail.com', // Susie
+  'michaelnunan@hotmail.com', // Michael
+  'vanbeekandrew@gmail.com', // Andrew
+  'gerardckelly@gmail.com', // Gerry K
+  'geoffreyfisher@hotmail.com', // Geoff F
+  'josh@sussol.net', // mSupply API Client
+  'unicef.laos.edu@gmail.com', // Laos Schools Data Collector
+  'tamanu-server@tupaia.org', // Tamanu Server
+  'public@tupaia.org', // Public User
+];
+
+const DEFAULT_PAGE_SIZE = 100;
+
+export const getFilteredUsers = async (
+  models: DatatrakWebServerModelRegistry,
+  countryCode: Country['code'],
+  permissionGroup: PermissionGroupRecord,
+  searchTerm?: string,
+) => {
+  // get the ancestors of the permission group
+  const permissionGroupWithAncestors = await permissionGroup.getAncestors();
+  const entity = await models.entity.findOne({
+    country_code: countryCode,
+    type: EntityType.country,
+  });
+
+  // get the user entity permissions for the permission group and its ancestors
+  const userEntityPermissions = await models.userEntityPermission.find({
+    permission_group_id: permissionGroupWithAncestors.map(p => p.id),
+    entity_id: entity.id,
+  });
+
+  const userIds = userEntityPermissions.map(uep => uep.user_id);
+
+  const usersFilter = {
+    id: userIds,
+    email: { comparator: 'not in', comparisonValue: USERS_EXCLUDED_FROM_LIST },
+    [QUERY_CONJUNCTIONS.RAW]: {
+      // exclude E2E users and any internal users
+      sql: `(email NOT LIKE '%tupaia.org' AND email NOT LIKE '%beyondessential.com.au' AND email NOT LIKE '%@bes.au')`,
+    },
+  } as Record<string, any>;
+
+  if (searchTerm) {
+    usersFilter.full_name = { comparator: 'ilike', comparisonValue: `${searchTerm}%` };
+  }
+
+  const users = await models.user.find(usersFilter, {
+    sort: ['full_name ASC'],
+    limit: DEFAULT_PAGE_SIZE,
+  });
+
+  return users.map(user => ({
+    id: user.id,
+    name: user.full_name,
+  }));
+};

packages/datatrak-web-server/src/utils/index.ts

@@ -7,3 +7,4 @@ export { sortSearchResults } from './sortSearchResults';
 export { addRecentEntities } from './addRecentEntities';
 export * from './formatTaskResponse';
 export * from './formatTaskChanges';
+export { getFilteredUsers } from './getFilteredUsers';

packages/datatrak-web/src/__tests__/features/Questions/UserQuestion.test.tsx

@@ -0,0 +1,106 @@
+/*
+ * Tupaia
+ *  Copyright (c) 2017 - 2024 Beyond Essential Systems Pty Ltd
+ */
+import React, { Ref } from 'react';
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { rest } from 'msw';
+import { setupServer } from 'msw/node';
+import { renderComponent } from '../../helpers/render';
+import { UserQuestion } from '../../../features/Questions';
+
+jest.mock('../../../features/Survey/SurveyContext/SurveyContext.tsx', () => ({
+  useSurveyForm: () => ({
+    countryCode: 'DL',
+  }),
+}));
+
+jest.mock('../../../api/queries/useUser', () => {
+  return {
+    useUser: jest.fn().mockReturnValue({}),
+  };
+});
+
+const users = [
+  {
+    name: 'Teddy Bear',
+    id: '1',
+  },
+  {
+    name: 'Grizzly Bear',
+    id: '2',
+  },
+  {
+    name: 'Panda Bear',
+    id: '3',
+  },
+  {
+    name: 'Koala Bear',
+    id: '4',
+  },
+  {
+    name: 'Polar Bear',
+    id: '5',
+  },
+];
+const server = setupServer(
+  rest.get('*/v1/users/DL', (_, res, ctx) => {
+    return res(ctx.status(200), ctx.json(users));
+  }),
+);
+
+beforeAll(() => server.listen());
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+
+describe('User Question', () => {
+  const onChange = jest.fn();
+  const props = {
+    id: 'theId',
+    label: 'Who should the task be assigned to?',
+    name: 'assignee',
+    config: {
+      user: {
+        permissionGroup: 'Public',
+      },
+    },
+    controllerProps: {
+      value: null,
+      onChange,
+      ref: {
+        current: {},
+      } as Ref<HTMLInputElement>,
+    },
+  };
+
+  it('renders the user question component without crashing', () => {
+    renderComponent(<UserQuestion {...props} />);
+  });
+
+  it('renders all the options', async () => {
+    renderComponent(<UserQuestion {...props} />);
+
+    const openButton = screen.getByTitle('Open');
+    openButton.click();
+
+    const displayOptions = await screen.findAllByRole('option');
+    expect(displayOptions.length).toBe(users.length);
+    displayOptions.forEach((option, index) => {
+      const text = users[index].name;
+      expect(option).toHaveTextContent(text);
+    });
+  });
+
+  it('Calls the onChange method with the option value', async () => {
+    renderComponent(<UserQuestion {...props} />);
+
+    const openButton = screen.getByTitle('Open');
+    openButton.click();
+
+    const displayOption = await screen.findByRole('option', { name: users[0].name });
+    userEvent.click(displayOption);
+
+    expect(onChange).toHaveBeenCalledWith(users[0].id);
+  });
+});

packages/datatrak-web/src/api/queries/index.ts

@@ -23,3 +23,4 @@ export { useEntities } from './useEntities';
 export { useTasks } from './useTasks';
 export { useTask } from './useTask';
 export { useSurveyUsers } from './useSurveyUsers';
+export { usePermissionGroupUsers } from './usePermissionGroupUsers';