feat(#8877): Look up users from their facility_id or contact_id

api/src/controllers/users.js

@@ -112,7 +112,11 @@ const getAppUrl = (req) => `${req.protocol}://${req.hostname}`;
 
 const getUserList = async (req) => {
   await auth.check(req, 'can_view_users');
-  return await users.getList();
+  const filters = _.chain(req.query)
+    .pick(['facility_id', 'contact_id']) // keep only supported filtering properties
+    .mapKeys((value, key) => _.camelCase(key)) // rename them to keep consistent variable names
+    .value();
+  return await users.getList(filters);
 };
 
 const getType = user => {
@@ -233,7 +237,7 @@ module.exports = {
   v2: {
     get: async (req, res) => {
       try {
-        const body = await getUserList(req, res);
+        const body = await getUserList(req);
         res.json(body);
       } catch (err) {
         serverUtils.error(err, req, res);

api/src/migrations/add-contact-id-to-user-docs.js

@@ -0,0 +1,46 @@
+const db = require('../db');
+const logger = require('../logger');
+
+const BATCH_SIZE = 100;
+
+const processDocument = async ({ _id, contact_id }) => {
+  try {
+    const user = await db.users.get(_id);
+    user.contact_id = contact_id;
+    await db.users.put(user);
+  } catch (error) {
+    if (error.status !== 404) {
+      throw error;
+    }
+    logger.warn(`User with id "${_id}" does not exist anymore, skipping it.`);
+  }
+};
+
+const runBatch = async (skip = 0) => {
+  const options = {
+    include_docs: true,
+    limit: BATCH_SIZE,
+    key: ['user-settings'],
+    skip,
+  };
+  const { rows } = await db.medic.query('medic-client/doc_by_type', options);
+  if (!rows.length) {
+    return;
+  }
+
+  for (const row of rows) {
+    await processDocument(row.doc);
+  }
+
+  if (rows.length < BATCH_SIZE) {
+    return;
+  }
+
+  return runBatch(skip + BATCH_SIZE);
+};
+
+module.exports = {
+  name: 'add-contact-id-to-user-docs',
+  created: new Date(2024, 5, 2),
+  run: runBatch,
+};

api/tests/mocha/controllers/users.spec.js

@@ -31,15 +31,24 @@ describe('Users Controller', () => {
   afterEach(() => sinon.restore());
 
   describe('get users list', () => {
+    let userList;
 
     beforeEach(() => {
+      userList = [
+        { id: 'org.couchdb.user:admin', roles: ['_admin'] },
+        {
+          id: 'org.couchdb.user:chw',
+          roles: ['chw', 'district-admin'],
+          contact: {
+            _id: 'chw-contact',
+            parent: { _id: 'chw-facility' },
+          }
+        },
+        { id: 'org.couchdb.user:unknown' },
+      ];
       req = { };
       res = { json: sinon.stub() };
-      sinon.stub(users, 'getList').resolves([
-        { id: 'org.couchdb.user:admin', roles: [ '_admin' ] },
-        { id: 'org.couchdb.user:chw', roles: [ 'chw', 'district-admin' ] },
-        { id: 'org.couchdb.user:unknown' },
-      ]);
+      sinon.stub(users, 'getList').resolves(userList);
     });
 
     describe('v1', () => {
@@ -69,14 +78,13 @@ describe('Users Controller', () => {
     });
 
     describe('v2', () => {
-
       it('rejects if not permitted', async () => {
         sinon.stub(auth, 'check').rejects(new Error('nope'));
         await controller.v2.get(req, res);
         chai.expect(serverUtils.error.callCount).to.equal(1);
       });
 
-      it('gets the list of users', async () => {
+      it('gets the list of users without filters', async () => {
         sinon.stub(auth, 'check').resolves();
 
         await controller.v2.get(req, res);
@@ -92,6 +100,58 @@ describe('Users Controller', () => {
         chai.expect(result[2].roles).to.be.undefined;
       });
 
+      it('gets the list of users with facility_id filter', async () => {
+        sinon.stub(auth, 'check').resolves();
+        users.getList.resolves([userList[1]]);
+        req.query = {
+          facility_id: 'chw-facility',
+          unsupported: 'nope',
+          contactId: 'not supported either',
+          this_wont_work: 123,
+        };
+
+        await controller.v2.get(req, res);
+        chai.expect(users.getList.firstCall.args[0]).to.deep.equal({ facilityId: 'chw-facility' });
+        const result = res.json.args[0][0];
+        chai.expect(result.length).to.equal(1);
+        chai.expect(result[0].id).to.equal('org.couchdb.user:chw');
+        chai.expect(result[0].type).to.be.undefined;
+        chai.expect(result[0].roles).to.deep.equal(['chw', 'district-admin']);
+        chai.expect(result[0].contact._id).to.equal('chw-contact');
+        chai.expect(result[0].contact.parent._id).to.equal('chw-facility');
+      });
+
+      it('gets the list of users with facility_id and contact_id filters', async () => {
+        sinon.stub(auth, 'check').resolves();
+        users.getList.resolves([userList[1]]);
+        req.query = { facility_id: 'chw-facility', contact_id: 'chw-contact' };
+
+        await controller.v2.get(req, res);
+        chai.expect(users.getList.firstCall.args[0]).to.deep.equal({
+          contactId: 'chw-contact',
+          facilityId: 'chw-facility',
+        });
+        const result = res.json.args[0][0];
+        chai.expect(result.length).to.equal(1);
+        chai.expect(result[0].id).to.equal('org.couchdb.user:chw');
+        chai.expect(result[0].type).to.be.undefined;
+        chai.expect(result[0].roles).to.deep.equal(['chw', 'district-admin']);
+        chai.expect(result[0].contact._id).to.equal('chw-contact');
+        chai.expect(result[0].contact.parent._id).to.equal('chw-facility');
+      });
+
+      it('gets the list of users and ignores unexpected filters', async () => {
+        sinon.stub(auth, 'check').resolves();
+        req.query = { roles: ['chw'], name: 'admin' };
+
+        await controller.v2.get(req, res);
+        chai.expect(users.getList.firstCall.args[0]).to.deep.equal({});
+        const result = res.json.args[0][0];
+        chai.expect(result.length).to.equal(3);
+        chai.expect(result[0].id).to.equal('org.couchdb.user:admin');
+        chai.expect(result[1].id).to.equal('org.couchdb.user:chw');
+        chai.expect(result[2].id).to.equal('org.couchdb.user:unknown');
+      });
     });
 
   });

shared-libs/user-management/src/libs/facility.js

@@ -1,12 +1,10 @@
 const db = require('./db');
 
-const list = async (users, settings) => {
+const list = async (users) => {
   const ids = new Set();
   for (const user of users) {
-    ids.add(user?.doc?.facility_id);
-  }
-  for (const setting of settings) {
-    ids.add(setting?.contact_id);
+    ids.add(user?.facility_id);
+    ids.add(user?.contact_id);
   }
   ids.delete(undefined);
   if (!ids.size) {

shared-libs/user-management/src/users.js

@@ -45,6 +45,7 @@ const RESTRICTED_USER_EDITABLE_FIELDS = [
 
 const USER_EDITABLE_FIELDS = RESTRICTED_USER_EDITABLE_FIELDS.concat([
   'place',
+  'contact',
   'type',
   'roles',
 ]);
@@ -108,15 +109,33 @@ const getDocID = doc => {
 const getAllUserSettings = () => {
   const opts = {
     include_docs: true,
-    key: ['user-settings']
+    key: ['user-settings'],
   };
   return db.medic.query('medic-client/doc_by_type', opts)
     .then(result => result.rows.map(row => row.doc));
 };
 
-const getAllUsers = () => {
-  return db.users.allDocs({ include_docs: true })
-    .then(result => result.rows);
+const getSettingsByIds = async (ids) => {
+  const docs = ids.map(id => ({ id }));
+  const { results } = await db.medic.bulkGet({ docs });
+  return results
+    .map(result => result?.docs?.[0]?.ok)
+    .filter(doc => doc);
+};
+
+const getAllUsers = async (filters) => {
+  if (_.isEmpty(filters)) {
+    const { rows } = await db.users.allDocs({ include_docs: true });
+    return rows.map(({ doc }) => doc);
+  }
+
+  const { docs } = await db.users.find({
+    selector: {
+      facility_id: filters.facilityId,
+      contact_id: filters.contactId,
+    },
+  });
+  return docs;
 };
 
 const validateContact = (id, placeID) => {
@@ -335,21 +354,21 @@ const hasParent = (facility, id) => {
 const mapUsers = (users, settings, facilities) => {
   users = users || [];
   return users
-    .filter(user => user.id.indexOf(USER_PREFIX) === 0)
+    .filter(user => user._id.indexOf(USER_PREFIX) === 0)
     .map(user => {
-      const setting = getDoc(user.id, settings) || {};
+      const setting = getDoc(user._id, settings) || {};
       return {
-        id: user.id,
-        rev: user.doc._rev,
-        username: user.doc.name,
+        id: user._id,
+        rev: user._rev,
+        username: user.name,
         fullname: setting.fullname,
         email: setting.email,
         phone: setting.phone,
-        place: getDoc(user.doc.facility_id, facilities),
-        roles: user.doc.roles,
-        contact: getDoc(setting.contact_id, facilities),
+        place: getDoc(user.facility_id, facilities),
+        roles: user.roles,
+        contact: getDoc(user.contact_id, facilities),
         external_id: setting.external_id,
-        known: user.doc.known
+        known: user.known
       };
     });
 };
@@ -395,7 +414,7 @@ const getSettingsUpdates = (username, data) => {
 };
 
 const getUserUpdates = (username, data) => {
-  const ignore = ['type', 'place'];
+  const ignore = ['type', 'place', 'contact'];
 
   const user = {
     name: username,
@@ -418,6 +437,9 @@ const getUserUpdates = (username, data) => {
   if (data.place) {
     user.facility_id = getDocID(data.place);
   }
+  if (data.contact) {
+    user.contact_id = getDocID(data.contact);
+  }
 
   return user;
 };
@@ -544,7 +566,7 @@ const validateUserFacility = (data, user, userSettings) => {
 
 const validateUserContact = (data, user, userSettings) => {
   if (data.contact) {
-    return validateContact(userSettings.contact_id, user.facility_id);
+    return validateContact(user.contact_id, user.facility_id);
   }
 
   if (_.isNull(data.contact)) {
@@ -555,6 +577,7 @@ const validateUserContact = (data, user, userSettings) => {
         {'field': 'Contact'}
       ));
     }
+    user.contact_id = null;
     userSettings.contact_id = null;
   }
 };
@@ -770,9 +793,19 @@ const getUserSettings = async({ name }) => {
  */
 module.exports = {
   deleteUser: username => deleteUser(createID(username)),
-  getList: async () => {
-    const [ users, settings ] = await Promise.all([ getAllUsers(), getAllUserSettings() ]);
-    const facilities = await facility.list(users, settings);
+  getList: async (filters) => {
+    let users;
+    let settings;
+
+    if (_.isEmpty(filters)) {
+      [users, settings] = await Promise.all([getAllUsers(), getAllUserSettings()]);
+    } else {
+      users = await getAllUsers(filters);
+      const ids = users.map(({ _id }) => _id);
+      settings = await getSettingsByIds(ids);
+    }
+
+    const facilities = await facility.list(users);
     return mapUsers(users, settings, facilities);
   },
   getUserSettings,

shared-libs/user-management/test/unit/libs/facility.spec.js

@@ -6,11 +6,8 @@ const db = require('../../../src/libs/db');
 
 describe('facility', () => {
 
-  const userA = { doc: { facility_id: 'a' } };
-  const userB = { doc: { facility_id: 'b' } };
-
-  const settingA = { contact_id: 'a' };
-  const settingB = { contact_id: 'e' };
+  const userA = { facility_id: 'a', contact_id: 'a' };
+  const userB = { facility_id: 'b', contact_id: 'e' };
 
   const facilityA = { _id: 'a' };
   const facilityB = { _id: 'b' };
@@ -41,7 +38,7 @@ describe('facility', () => {
       { doc: facilityB },
       facilityNotFound,
     ] });
-    const result = await list([ userA, userB ], [ settingA, settingB ]);
+    const result = await list([userA, userB]);
     expect(result).to.deep.equal([ facilityA, facilityB ]);
     expect(allDocs.callCount).to.equal(1);
     expect(allDocs.args[0][0].keys).to.deep.equal([ 'a', 'b', 'e' ]);