@7365admin1/core 3.47.1-staging.129 → 3.47.1-staging.131

package/.changeset/terms-acceptance-list.md

@@ -0,0 +1,41 @@
+---
+"@7365admin1/core": minor
+---
+
+Read the Terms and Privacy Policy acceptance record as a list.
+
+Who accepted the platform Terms, and when, was already stored - `acceptedTerms`
+and `acceptedTermsAt` on the user - but the only way to read it was
+`GET /terms/:user/status`, one named user at a time. The staff console has no
+list of user ids to walk, so it could not show the acceptance record at all, and
+nobody could answer the question that matters the day new Terms are published:
+who has NOT accepted them yet.
+
+`usePlatformTermsController().getAcceptance` answers it as a paged list, filtered
+by version number and by accepted / not accepted, either or both, neither
+meaning everybody. With a version AND "not accepted", the answer includes the
+accounts still sitting on an older version, not only the ones that never
+accepted anything. A version number that was never published is a 404 rather
+than an empty page, so a mistyped filter cannot read as "nobody has accepted".
+
+`requirePlatformStaff` gates it, resolved from the session - the same gate the
+console audit list and the platform user list carry, and for the same reason: it
+is a cross-tenant read by definition. Staff-level, not owner-level; the owner
+tier stays reserved for the actions that change a client's service.
+
+Each row carries an id, a display name, the account type and status, the
+accepted version and the timestamp. No e-mail, no contact number, no birthday -
+a consent record does not need them, and this list spans every client at once.
+Soft-deleted accounts are excluded. The version number is joined at read time,
+so a row cannot hold a stale copy of it, and the join runs after the page is
+cut, on at most `limit` rows.
+
+Paging is `$skip` before `$limit`, the offset derived from the page - the defect
+fixed in the members list is not repeated here. Not cached: whether a person has
+accepted the current Terms is the one question where a stale answer is worse
+than a slow one.
+
+Additive only. `GET /terms/:user/status`, `POST /terms/:user/accept`,
+`GET /terms/latest`, `GET /terms/:id` and `POST /terms` are untouched, and no
+existing response shape or status code changed. The route that mounts this is a
+separate change in `iservice365-API-core`.

package/.changeset/users-v2-list-staff-guard.md

@@ -0,0 +1,13 @@
+---
+"@7365admin1/core": patch
+---
+
+Require Seven365 staff to read the platform-wide user list on /api/users/v2 too
+
+`/api/users` and `/api/users/v2` are separate mounts onto separate controllers,
+each with its own copy of the same unfiltered platform-wide list. Gating only
+v1 left the gate bypassable by adding `/v2` to the URL.
+
+`user-v2.controller.ts` `getUsers` now calls `requirePlatformStaff`, the same
+gate. The v2 per-user endpoints are unchanged, and the test that pins the v1
+profile endpoints as ungated now covers both controllers.

package/dist/index.d.ts

@@ -157,6 +157,16 @@ declare function useUserRepo(): {
         acceptedTerms?: ObjectId | null | undefined;
         acceptedTermsAt?: string | undefined;
     } | null>;
+    listTermsAcceptance: ({ terms, accepted, page, limit, }: {
+        terms?: ObjectId | null | undefined;
+        accepted?: boolean | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+    }) => Promise<{
+        items: any[];
+        pages: number;
+        pageRange: string;
+    }>;
     getUserByEmail: (email: string) => Promise<TUser | null>;
     getUserByReferralCode: (referralCode: string) => Promise<TUser | null>;
     getByEmailApp: (email: string, app: string) => Promise<TUser | null>;
@@ -10599,6 +10609,7 @@ declare function usePlatformTermsRepo(): {
         updatedAt?: string | undefined;
     }>;
     getById: (id: string | ObjectId) => Promise<TPlatformTerms>;
+    getByVersion: (version: number) => Promise<mongodb.WithId<TPlatformTerms> | null>;
     getLatest: () => Promise<TPlatformTerms>;
     getNextVersion: () => Promise<number>;
 };
@@ -10645,6 +10656,16 @@ declare function usePlatformTermsService(): {
         acceptedTerms: ObjectId | undefined;
         version: number;
     }>;
+    listAcceptance: ({ version, accepted, page, limit, }: {
+        version?: number | null | undefined;
+        accepted?: boolean | undefined;
+        page?: number | undefined;
+        limit?: number | undefined;
+    }) => Promise<{
+        items: any[];
+        pages: number;
+        pageRange: string;
+    }>;
     add: ({ terms, policies, createdBy, }: {
         terms: string;
         policies: string;
@@ -10665,6 +10686,7 @@ declare function usePlatformTermsController(): {
     getLatest: (_req: Request, res: Response, next: NextFunction) => Promise<void>;
     getById: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     getStatus: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    getAcceptance: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     accept: (req: Request, res: Response, next: NextFunction) => Promise<void>;
     add: (req: Request, res: Response, next: NextFunction) => Promise<void>;
 };

package/dist/index.js

@@ -9491,6 +9491,68 @@ function useUserRepo() {
       throw new import_node_server_utils11.InternalServerError("Failed to read terms acceptance.");
     }
   }
+  async function listTermsAcceptance({
+    terms = null,
+    accepted,
+    page = 1,
+    limit = 20
+  }) {
+    page = Math.max(Number(page) || 1, 1) - 1;
+    limit = Math.min(Math.max(Number(limit) || 20, 1), 100);
+    const query2 = { status: { $ne: "deleted" /* DELETED */ } };
+    if (accepted === true) {
+      query2.acceptedTerms = terms ?? { $ne: null };
+    } else if (accepted === false) {
+      query2.acceptedTerms = terms ? { $ne: terms } : null;
+    } else if (terms) {
+      query2.acceptedTerms = terms;
+    }
+    const pipeline = [
+      { $match: query2 },
+      { $sort: { acceptedTermsAt: -1, _id: -1 } },
+      { $skip: page * limit },
+      { $limit: limit },
+      {
+        $lookup: {
+          from: "platform_terms",
+          localField: "acceptedTerms",
+          foreignField: "_id",
+          as: "acceptedVersion",
+          pipeline: [{ $project: { version: 1 } }]
+        }
+      },
+      {
+        $project: {
+          _id: 0,
+          id: { $toString: "$_id" },
+          name: { $ifNull: ["$name", ""] },
+          type: { $ifNull: ["$type", ""] },
+          status: 1,
+          acceptedTerms: {
+            $cond: [
+              { $ifNull: ["$acceptedTerms", false] },
+              {
+                id: { $toString: "$acceptedTerms" },
+                version: {
+                  $ifNull: [{ $first: "$acceptedVersion.version" }, null]
+                }
+              },
+              null
+            ]
+          },
+          acceptedTermsAt: { $ifNull: ["$acceptedTermsAt", null] }
+        }
+      }
+    ];
+    try {
+      const items = await collection.aggregate(pipeline).toArray();
+      const length = await collection.countDocuments(query2);
+      return (0, import_node_server_utils11.paginate)(items, page, limit, length);
+    } catch (error) {
+      import_node_server_utils11.logger.log({ level: "error", message: `${error}` });
+      throw new import_node_server_utils11.InternalServerError("Failed to read terms acceptance.");
+    }
+  }
   return {
     createIndex,
     createTextIndex,
@@ -9498,6 +9560,7 @@ function useUserRepo() {
     createUser,
     setAcceptedTerms,
     getAcceptedTerms,
+    listTermsAcceptance,
     getUserByEmail,
     getUserByReferralCode,
     getByEmailApp,
@@ -40883,6 +40946,13 @@ function usePlatformTermsRepo() {
     }
     return data;
   }
+  async function getByVersion(version) {
+    try {
+      return await collection.findOne({ version, ...notDeleted });
+    } catch (error) {
+      throw new import_node_server_utils126.InternalServerError("Failed to retrieve terms version.");
+    }
+  }
   async function getNextVersion() {
     try {
       const found = await collection.find({}).sort({ version: -1 }).limit(1).project({ version: 1, _id: 0 }).toArray();
@@ -40895,6 +40965,7 @@ function usePlatformTermsRepo() {
     createIndexes,
     add,
     getById,
+    getByVersion,
     getLatest,
     getNextVersion
   };
@@ -40918,11 +40989,13 @@ function usePlatformTermsService() {
     add: _add,
     getById: _getById,
     getLatest: _getLatest,
+    getByVersion: _getByVersion,
     getNextVersion: _getNextVersion
   } = usePlatformTermsRepo();
   const {
     getAcceptedTerms: _getAcceptedTerms,
-    setAcceptedTerms: _setAcceptedTerms
+    setAcceptedTerms: _setAcceptedTerms,
+    listTermsAcceptance: _listTermsAcceptance
   } = useUserRepo();
   const {
     getById: _getPersonById,
@@ -41006,6 +41079,22 @@ function usePlatformTermsService() {
     await _setPersonAcceptedTerms(personId, latest._id);
     return { acceptedTerms: latest._id, version: latest.version };
   }
+  async function listAcceptance({
+    version,
+    accepted,
+    page,
+    limit
+  }) {
+    let terms = null;
+    if (version) {
+      const found = await _getByVersion(version);
+      if (!found) {
+        throw new import_node_server_utils127.NotFoundError("Terms version not found.");
+      }
+      terms = found._id;
+    }
+    return await _listTermsAcceptance({ terms, accepted, page, limit });
+  }
   async function add({
     terms,
     policies,
@@ -41031,6 +41120,7 @@ function usePlatformTermsService() {
     acceptByUserId,
     getStatusByPersonId,
     acceptByPersonId,
+    listAcceptance,
     add
   };
 }
@@ -80406,6 +80496,7 @@ function useUserControllerV2() {
     if (error)
       return rejectValidation(error, next);
     try {
+      await requirePlatformStaff(req);
       const users = await _getUsers({
         search: value.search ?? "",
         page: value.page,
@@ -85193,6 +85284,7 @@ function usePlatformTermsController() {
     getLatest: _getLatest,
     getById: _getById,
     getStatusByUserId: _getStatusByUserId,
+    listAcceptance: _listAcceptance,
     acceptByUserId: _acceptByUserId,
     add: _add
   } = usePlatformTermsService();
@@ -85281,6 +85373,41 @@ function usePlatformTermsController() {
       return;
     }
   }
+  async function getAcceptance(req, res, next) {
+    const schema2 = import_joi160.default.object({
+      version: import_joi160.default.number().integer().min(1).optional().allow("", null),
+      accepted: import_joi160.default.boolean().optional().allow("", null),
+      page: import_joi160.default.number().integer().min(1).allow("", null).default(1),
+      limit: import_joi160.default.number().integer().min(1).max(100).allow("", null).default(20)
+    });
+    const { error, value } = schema2.validate(
+      { ...req.query },
+      { convert: true, stripUnknown: true }
+    );
+    if (error) {
+      import_node_server_utils287.logger.log({ level: "error", message: `${error.message}` });
+      next(new import_node_server_utils287.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await requirePlatformStaff(req);
+      res.json(
+        await _listAcceptance({
+          version: value.version || null,
+          // Left undefined when absent — `false` is a real filter here
+          // ("has NOT accepted"), so it must not be what "no filter" means.
+          accepted: typeof value.accepted === "boolean" ? value.accepted : void 0,
+          page: value.page,
+          limit: value.limit
+        })
+      );
+      return;
+    } catch (error2) {
+      import_node_server_utils287.logger.log({ level: "error", message: `${error2.message}` });
+      next(error2);
+      return;
+    }
+  }
   async function add(req, res, next) {
     const schema2 = import_joi160.default.object({
       user: schemaUserParam.optional(),
@@ -85320,6 +85447,7 @@ function usePlatformTermsController() {
     getLatest,
     getById,
     getStatus,
+    getAcceptance,
     accept,
     add
   };