@platform-modules/foreign-ministry 1.3.324 → 1.3.327

package/scripts/check-column-types.js

@@ -1,38 +1,38 @@
-const dotenv = require('dotenv');
-const { Client } = require('pg');
-
-dotenv.config({ path: '../Reports_Service/.env' });
-dotenv.config({ path: '.env', override: true });
-
-async function main() {
-  const client = new Client({
-    host: process.env.DB_HOST.trim(),
-    port: 5432,
-    user: process.env.DB_USER.trim(),
-    password: process.env.DB_PASS,
-    database: process.env.DB_NAME.trim(),
-  });
-  await client.connect();
-
-  const tables = ['sla_requests', 'users', 'departments', 'sections', 'fm_services', 'fm_sub_services'];
-  for (const table of tables) {
-    const { rows } = await client.query(
-      `SELECT column_name, data_type
-       FROM information_schema.columns
-       WHERE table_schema = 'public' AND table_name = $1
-       ORDER BY ordinal_position`,
-      [table]
-    );
-    console.log(`\n${table}:`);
-    for (const row of rows) {
-      console.log(`  ${row.column_name}: ${row.data_type}`);
-    }
-  }
-
-  await client.end();
-}
-
-main().catch((err) => {
-  console.error(err.message);
-  process.exit(1);
-});
+const dotenv = require('dotenv');
+const { Client } = require('pg');
+
+dotenv.config({ path: '../Reports_Service/.env' });
+dotenv.config({ path: '.env', override: true });
+
+async function main() {
+  const client = new Client({
+    host: process.env.DB_HOST.trim(),
+    port: 5432,
+    user: process.env.DB_USER.trim(),
+    password: process.env.DB_PASS,
+    database: process.env.DB_NAME.trim(),
+  });
+  await client.connect();
+
+  const tables = ['sla_requests', 'users', 'departments', 'sections', 'fm_services', 'fm_sub_services'];
+  for (const table of tables) {
+    const { rows } = await client.query(
+      `SELECT column_name, data_type
+       FROM information_schema.columns
+       WHERE table_schema = 'public' AND table_name = $1
+       ORDER BY ordinal_position`,
+      [table]
+    );
+    console.log(`\n${table}:`);
+    for (const row of rows) {
+      console.log(`  ${row.column_name}: ${row.data_type}`);
+    }
+  }
+
+  await client.end();
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/scripts/check-service-tables.js

@@ -1,42 +1,42 @@
-const dotenv = require('dotenv');
-const path = require('path');
-const { Client } = require('pg');
-
-async function listTables(label, config) {
-  const client = new Client(config);
-  await client.connect();
-  const { rows } = await client.query(`
-    SELECT table_name
-    FROM information_schema.tables
-    WHERE table_schema = 'public'
-      AND (table_name LIKE '%service%' OR table_name LIKE 'sla%')
-    ORDER BY table_name
-  `);
-  console.log(`${label} (${config.database}):`, rows.map((r) => r.table_name).join(', ') || '(none)');
-  await client.end();
-}
-
-async function main() {
-  dotenv.config({ path: path.join(__dirname, '..', '.env') });
-  await listTables('FM shared_models/.env', {
-    host: process.env.DB_HOST.trim(),
-    port: 5432,
-    user: process.env.DB_USER.trim(),
-    password: process.env.DB_PASS,
-    database: process.env.DB_NAME.trim(),
-  });
-
-  dotenv.config({ path: path.join(__dirname, '..', '..', 'Reports_Service', '.env') });
-  await listTables('Reports_Service/.env', {
-    host: (process.env.TYPEORM_HOST || '').trim(),
-    port: 5432,
-    user: (process.env.TYPEORM_USERNAME || '').trim(),
-    password: process.env.TYPEORM_PASSWORD,
-    database: (process.env.TYPEORM_DATABASE || '').trim(),
-  });
-}
-
-main().catch((err) => {
-  console.error(err.message);
-  process.exit(1);
-});
+const dotenv = require('dotenv');
+const path = require('path');
+const { Client } = require('pg');
+
+async function listTables(label, config) {
+  const client = new Client(config);
+  await client.connect();
+  const { rows } = await client.query(`
+    SELECT table_name
+    FROM information_schema.tables
+    WHERE table_schema = 'public'
+      AND (table_name LIKE '%service%' OR table_name LIKE 'sla%')
+    ORDER BY table_name
+  `);
+  console.log(`${label} (${config.database}):`, rows.map((r) => r.table_name).join(', ') || '(none)');
+  await client.end();
+}
+
+async function main() {
+  dotenv.config({ path: path.join(__dirname, '..', '.env') });
+  await listTables('FM shared_models/.env', {
+    host: process.env.DB_HOST.trim(),
+    port: 5432,
+    user: process.env.DB_USER.trim(),
+    password: process.env.DB_PASS,
+    database: process.env.DB_NAME.trim(),
+  });
+
+  dotenv.config({ path: path.join(__dirname, '..', '..', 'Reports_Service', '.env') });
+  await listTables('Reports_Service/.env', {
+    host: (process.env.TYPEORM_HOST || '').trim(),
+    port: 5432,
+    user: (process.env.TYPEORM_USERNAME || '').trim(),
+    password: process.env.TYPEORM_PASSWORD,
+    database: (process.env.TYPEORM_DATABASE || '').trim(),
+  });
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/scripts/sync-sla-reports-sql.js

@@ -1,95 +1,95 @@
-/**
- * Applies SLA report views + stored procedures to PostgreSQL (idempotent CREATE OR REPLACE).
- *
- * Env (shared_models/.env or Reports_Service/.env):
- *   DB_HOST / TYPEORM_HOST
- *   DB_PORT / TYPEORM_PORT
- *   DB_USER / TYPEORM_USERNAME
- *   DB_PASS / TYPEORM_PASSWORD
- *   DB_NAME / TYPEORM_DATABASE
- *
- * Usage:
- *   node scripts/sync-sla-reports-sql.js
- *   npm run sync:sla-sql   (from shared_models)
- */
-
-const fs = require('fs');
-const path = require('path');
-const { Client } = require('pg');
-
-function loadEnvFiles() {
-  const dotenv = require('dotenv');
-  const sharedRoot = path.resolve(__dirname, '..');
-  const reportsEnv = path.resolve(sharedRoot, '..', 'Reports_Service', '.env');
-  const sharedEnv = path.join(sharedRoot, '.env');
-
-  // Reports_Service defaults first; shared_models/.env wins (FM DB for sync:sla-sql).
-  if (fs.existsSync(reportsEnv)) {
-    dotenv.config({ path: reportsEnv });
-  }
-  if (fs.existsSync(sharedEnv)) {
-    dotenv.config({ path: sharedEnv, override: true });
-  }
-}
-
-function getDbConfig() {
-  const host = (process.env.TYPEORM_HOST || process.env.DB_HOST || '').trim();
-  const port = parseInt(process.env.TYPEORM_PORT || process.env.DB_PORT || '5432', 10);
-  const user = (process.env.TYPEORM_USERNAME || process.env.DB_USER || '').trim();
-  const password = process.env.TYPEORM_PASSWORD || process.env.DB_PASS || '';
-  const database = (process.env.TYPEORM_DATABASE || process.env.DB_NAME || '').trim();
-
-  if (!host || !user || !database) {
-    throw new Error(
-      'Missing DB config. Set TYPEORM_* in Reports_Service/.env or DB_* in shared_models/.env'
-    );
-  }
-
-  return { host, port, user, password, database };
-}
-
-async function main() {
-  const skipSync = process.argv.includes('--skip');
-  if (skipSync || process.env.SKIP_SLA_SQL_SYNC === 'true') {
-    console.log('[sync-sla-reports-sql] skipped (SKIP_SLA_SQL_SYNC or --skip)');
-    return;
-  }
-
-  loadEnvFiles();
-  const config = getDbConfig();
-  const sqlDir = path.join(__dirname, '..', 'sql');
-  const manifestPath = path.join(sqlDir, 'sla-reports-sync.manifest.json');
-
-  if (!fs.existsSync(manifestPath)) {
-    throw new Error(`Manifest not found: ${manifestPath}`);
-  }
-
-  const files = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-  if (!Array.isArray(files) || files.length === 0) {
-    throw new Error('sla-reports-sync.manifest.json must be a non-empty array');
-  }
-
-  const client = new Client(config);
-  await client.connect();
-  console.log(`[sync-sla-reports-sql] connected to ${config.host}/${config.database}`);
-
-  try {
-    for (const file of files) {
-      const filePath = path.join(sqlDir, file);
-      if (!fs.existsSync(filePath)) {
-        throw new Error(`SQL file missing: ${filePath}`);
-      }
-      const sql = fs.readFileSync(filePath, 'utf8');
-      await client.query(sql);
-      console.log(`[sync-sla-reports-sql] applied ${file}`);
-    }
-    console.log('[sync-sla-reports-sql] done');
-  } finally {
-    await client.end();
-  }
-}
-
-main().catch((err) => {
-  console.error('[sync-sla-reports-sql] failed:', err.message);
-  process.exit(1);
-});
+/**
+ * Applies SLA report views + stored procedures to PostgreSQL (idempotent CREATE OR REPLACE).
+ *
+ * Env (shared_models/.env or Reports_Service/.env):
+ *   DB_HOST / TYPEORM_HOST
+ *   DB_PORT / TYPEORM_PORT
+ *   DB_USER / TYPEORM_USERNAME
+ *   DB_PASS / TYPEORM_PASSWORD
+ *   DB_NAME / TYPEORM_DATABASE
+ *
+ * Usage:
+ *   node scripts/sync-sla-reports-sql.js
+ *   npm run sync:sla-sql   (from shared_models)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Client } = require('pg');
+
+function loadEnvFiles() {
+  const dotenv = require('dotenv');
+  const sharedRoot = path.resolve(__dirname, '..');
+  const reportsEnv = path.resolve(sharedRoot, '..', 'Reports_Service', '.env');
+  const sharedEnv = path.join(sharedRoot, '.env');
+
+  // Reports_Service defaults first; shared_models/.env wins (FM DB for sync:sla-sql).
+  if (fs.existsSync(reportsEnv)) {
+    dotenv.config({ path: reportsEnv });
+  }
+  if (fs.existsSync(sharedEnv)) {
+    dotenv.config({ path: sharedEnv, override: true });
+  }
+}
+
+function getDbConfig() {
+  const host = (process.env.TYPEORM_HOST || process.env.DB_HOST || '').trim();
+  const port = parseInt(process.env.TYPEORM_PORT || process.env.DB_PORT || '5432', 10);
+  const user = (process.env.TYPEORM_USERNAME || process.env.DB_USER || '').trim();
+  const password = process.env.TYPEORM_PASSWORD || process.env.DB_PASS || '';
+  const database = (process.env.TYPEORM_DATABASE || process.env.DB_NAME || '').trim();
+
+  if (!host || !user || !database) {
+    throw new Error(
+      'Missing DB config. Set TYPEORM_* in Reports_Service/.env or DB_* in shared_models/.env'
+    );
+  }
+
+  return { host, port, user, password, database };
+}
+
+async function main() {
+  const skipSync = process.argv.includes('--skip');
+  if (skipSync || process.env.SKIP_SLA_SQL_SYNC === 'true') {
+    console.log('[sync-sla-reports-sql] skipped (SKIP_SLA_SQL_SYNC or --skip)');
+    return;
+  }
+
+  loadEnvFiles();
+  const config = getDbConfig();
+  const sqlDir = path.join(__dirname, '..', 'sql');
+  const manifestPath = path.join(sqlDir, 'sla-reports-sync.manifest.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Manifest not found: ${manifestPath}`);
+  }
+
+  const files = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new Error('sla-reports-sync.manifest.json must be a non-empty array');
+  }
+
+  const client = new Client(config);
+  await client.connect();
+  console.log(`[sync-sla-reports-sql] connected to ${config.host}/${config.database}`);
+
+  try {
+    for (const file of files) {
+      const filePath = path.join(sqlDir, file);
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`SQL file missing: ${filePath}`);
+      }
+      const sql = fs.readFileSync(filePath, 'utf8');
+      await client.query(sql);
+      console.log(`[sync-sla-reports-sql] applied ${file}`);
+    }
+    console.log('[sync-sla-reports-sql] done');
+  } finally {
+    await client.end();
+  }
+}
+
+main().catch((err) => {
+  console.error('[sync-sla-reports-sql] failed:', err.message);
+  process.exit(1);
+});

package/src/helpers/admin-auth.helper.ts

@@ -0,0 +1,46 @@
+import type { DataSource } from 'typeorm';
+import { Role } from '../models/role';
+import { UserRole } from '../models/userRolesModel';
+
+/** Parse authenticated user id from Fastify `request.meta`. */
+export function parsePortalUserIdFromRequest(request: {
+  meta?: { userId?: string | number };
+}): number | null {
+  const raw = request.meta?.userId;
+  if (raw == null || raw === '') return null;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+/**
+ * True when the user has an active Admin role in `user_role` (role.name = admin, case-insensitive).
+ * Same check as Reports_Service `isReportsAdmin`.
+ */
+export async function userHasPortalAdminRole(
+  dataSource: DataSource,
+  userId: number
+): Promise<boolean> {
+  if (!dataSource?.isInitialized || !Number.isFinite(userId) || userId <= 0) {
+    return false;
+  }
+
+  return dataSource
+    .getRepository(UserRole)
+    .createQueryBuilder('ur')
+    .innerJoin(Role, 'role', 'role.id = ur.role_id AND COALESCE(role.is_deleted, false) = false')
+    .where('ur.user_id = :userId', { userId })
+    .andWhere('ur.is_deleted = false')
+    .andWhere('ur.is_active = true')
+    .andWhere('LOWER(role.name) = :adminRole', { adminRole: 'admin' })
+    .getExists();
+}
+
+/** Convenience: resolve user id from request and check admin role. */
+export async function isPortalAdminFromRequest(
+  dataSource: DataSource,
+  request: { meta?: { userId?: string | number } }
+): Promise<boolean> {
+  const userId = parsePortalUserIdFromRequest(request);
+  if (!userId) return false;
+  return userHasPortalAdminRole(dataSource, userId);
+}

package/src/helpers/services-notification-config.helper.ts

@@ -0,0 +1,255 @@
+import type { EntityManager } from 'typeorm';
+import { Notification, NotificationType } from '../models/NotificationModel';
+import {
+  ServicesNotificationConfigs,
+  ServicesNotificationTriggerType,
+} from '../models/ServicesNotificationConfigsModel';
+import { UserRole } from '../models/userRolesModel';
+
+export type FmServicesNotificationConfigRecipient = {
+  user_id: number;
+  department_id: number | null;
+  section_id: number | null;
+  role_id: number | null;
+};
+
+export type CollectFmServicesNotificationConfigRecipientsParams = {
+  serviceId: number | null | undefined;
+  subServiceId: number | null | undefined;
+  /** When 0, FINAL_APPROVAL configs apply; EVERY_APPROVAL always applies on approval. */
+  pendingCount: number;
+  logPrefix?: string;
+};
+
+export type SendFmServicesNotificationConfigNotificationsParams = {
+  serviceId: number | null | undefined;
+  subServiceId: number | null | undefined;
+  pendingCount: number;
+  requestId: number;
+  status: string;
+  approvalLevel: number;
+  shortProductName: string;
+  requestTypeKey: string;
+  routePath: string;
+  createdBy: string | number;
+  logPrefix?: string;
+};
+
+/**
+ * Resolves users from active `services_notification_configs` for service/sub-service.
+ * FINAL_APPROVAL only when pendingCount === 0; EVERY_APPROVAL on each approval step.
+ */
+export async function collectFmServicesNotificationConfigRecipients(
+  manager: EntityManager,
+  params: CollectFmServicesNotificationConfigRecipientsParams
+): Promise<FmServicesNotificationConfigRecipient[]> {
+  const { serviceId, subServiceId, pendingCount, logPrefix = '[FM notification config]' } = params;
+  if (!serviceId || !subServiceId) return [];
+
+  const notificationConfigs = await manager
+    .getRepository(ServicesNotificationConfigs)
+    .createQueryBuilder('SNC')
+    .where('SNC.service_id = :service_id', { service_id: serviceId })
+    .andWhere('SNC.sub_service_id = :sub_service_id', { sub_service_id: subServiceId })
+    .andWhere('SNC.is_deleted = :is_deleted', { is_deleted: false })
+    .andWhere('SNC.is_active = :is_active', { is_active: true })
+    .getMany();
+
+  if (!notificationConfigs?.length) {
+    console.warn(
+      `${logPrefix} No notification configurations found for service ${serviceId} and sub_service ${subServiceId}`
+    );
+    return [];
+  }
+
+  const seen = new Map<number, FmServicesNotificationConfigRecipient>();
+
+  for (const notificationConfig of notificationConfigs) {
+    if (notificationConfig.trigger === ServicesNotificationTriggerType.FINAL_APPROVAL) {
+      if (pendingCount !== 0) continue;
+    } else if (notificationConfig.trigger === ServicesNotificationTriggerType.EVERY_APPROVAL) {
+      // include on every approval step
+    } else {
+      continue;
+    }
+
+    let usersQuery = manager
+      .getRepository(UserRole)
+      .createQueryBuilder('user_role')
+      .where('user_role.department_id = :department_id', {
+        department_id: notificationConfig.department_id,
+      })
+      .andWhere('user_role.section_id = :section_id', { section_id: notificationConfig.section_id })
+      .andWhere('user_role.is_deleted = :is_deleted', { is_deleted: false });
+
+    if (notificationConfig.role_id != null && notificationConfig.role_id !== undefined) {
+      usersQuery = usersQuery.andWhere('user_role.role_id = :role_id', {
+        role_id: notificationConfig.role_id,
+      });
+    }
+    const userRoles = await usersQuery.getMany();
+
+    if (!userRoles?.length) {
+      console.warn(
+        `${logPrefix} No users found for config (dept ${notificationConfig.department_id}${notificationConfig.section_id != null ? `, section ${notificationConfig.section_id}` : ''})`
+      );
+      continue;
+    }
+
+    for (const ur of userRoles) {
+      const uid = ur.user_id;
+      if (seen.has(uid)) continue;
+
+      const userRole = await manager
+        .getRepository(UserRole)
+        .createQueryBuilder('user_role')
+        .where('user_role.user_id = :userId', { userId: uid })
+        .andWhere('user_role.is_deleted = :is_deleted', { is_deleted: false })
+        .orderBy('user_role.created_at', 'ASC')
+        .getOne();
+
+      seen.set(uid, {
+        user_id: uid,
+        department_id: notificationConfig.department_id ?? null,
+        section_id: notificationConfig.section_id ?? null,
+        role_id: userRole?.role_id ?? null,
+      });
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+/**
+ * Inserts portal notifications for users resolved from `services_notification_configs`.
+ */
+export async function sendFmServicesNotificationConfigNotifications(
+  manager: EntityManager,
+  params: SendFmServicesNotificationConfigNotificationsParams
+): Promise<{ sentCount: number }> {
+  const {
+    serviceId,
+    subServiceId,
+    pendingCount,
+    requestId,
+    status,
+    approvalLevel,
+    shortProductName,
+    requestTypeKey,
+    routePath,
+    createdBy,
+    logPrefix = '[FM notification config]',
+  } = params;
+
+  if (!serviceId || !subServiceId) return { sentCount: 0 };
+
+  const notificationConfigs = await manager
+    .getRepository(ServicesNotificationConfigs)
+    .createQueryBuilder('SNC')
+    .where('SNC.service_id = :service_id', { service_id: serviceId })
+    .andWhere('SNC.sub_service_id = :sub_service_id', { sub_service_id: subServiceId })
+    .andWhere('SNC.is_deleted = :is_deleted', { is_deleted: false })
+    .andWhere('SNC.is_active = :is_active', { is_active: true })
+    .getMany();
+
+  if (!notificationConfigs?.length) {
+    console.warn(
+      `${logPrefix} No notification configurations found for service ${serviceId} and sub_service ${subServiceId}`
+    );
+    return { sentCount: 0 };
+  }
+
+  let sentCount = 0;
+  const createdByStr = String(createdBy ?? 'system');
+
+  for (const notificationConfig of notificationConfigs) {
+    if (notificationConfig.trigger === ServicesNotificationTriggerType.FINAL_APPROVAL) {
+      if (pendingCount !== 0) continue;
+    } else if (notificationConfig.trigger === ServicesNotificationTriggerType.EVERY_APPROVAL) {
+      // include on every approval step
+    } else {
+      continue;
+    }
+
+    let usersQuery = manager
+      .getRepository(UserRole)
+      .createQueryBuilder('user_role')
+      .where('user_role.department_id = :department_id', {
+        department_id: notificationConfig.department_id,
+      })
+      .andWhere('user_role.section_id = :section_id', { section_id: notificationConfig.section_id })
+      .andWhere('user_role.is_deleted = :is_deleted', { is_deleted: false });
+
+    if (notificationConfig.role_id != null && notificationConfig.role_id !== undefined) {
+      usersQuery = usersQuery.andWhere('user_role.role_id = :role_id', {
+        role_id: notificationConfig.role_id,
+      });
+    }
+    const userRoles = await usersQuery.getMany();
+
+    if (!userRoles?.length) {
+      console.warn(
+        `${logPrefix} No users found for ${notificationConfig.trigger} config (dept ${notificationConfig.department_id}${notificationConfig.section_id != null ? `, section ${notificationConfig.section_id}` : ''})`
+      );
+      continue;
+    }
+
+    const isEveryApproval = notificationConfig.trigger === ServicesNotificationTriggerType.EVERY_APPROVAL;
+    const notificationTitle = isEveryApproval
+      ? `${shortProductName} Request ${status} at Level ${approvalLevel}`
+      : `${shortProductName} Request ${status}`;
+    const notificationData = `${shortProductName} request #${requestId} has been ${status}.`;
+
+    for (const ur of userRoles) {
+      const targetUserId = ur.user_id;
+      try {
+        const primaryUserRole = await manager
+          .getRepository(UserRole)
+          .createQueryBuilder('user_role')
+          .where('user_role.user_id = :userId', { userId: targetUserId })
+          .andWhere('user_role.is_deleted = :is_deleted', { is_deleted: false })
+          .orderBy('user_role.created_at', 'ASC')
+          .getOne();
+
+        await manager
+          .createQueryBuilder()
+          .insert()
+          .into(Notification)
+          .values({
+            type: NotificationType.REQUEST_RAISED,
+            user_id: targetUserId,
+            role_id: primaryUserRole?.role_id ?? null,
+            department_id: notificationConfig.department_id ?? null,
+            section_id: notificationConfig.section_id ?? null,
+            request_id: requestId,
+            service_id: serviceId ?? null,
+            sub_service_id: subServiceId ?? null,
+            content: {
+              title: notificationTitle,
+              data: notificationData,
+              requestId,
+              requestType: requestTypeKey,
+              status,
+              level: approvalLevel,
+              timestamp: new Date().toISOString(),
+            },
+            is_read: false,
+            route_path: routePath,
+            created_by: createdByStr,
+          } as never)
+          .execute();
+        sentCount += 1;
+      } catch (userNotificationError: unknown) {
+        const message =
+          userNotificationError instanceof Error ? userNotificationError.message : String(userNotificationError);
+        console.warn(`${logPrefix} Failed to send config notification to user ${targetUserId}:`, message);
+      }
+    }
+
+    console.info(
+      `${logPrefix} Sent ${notificationConfig.trigger} config notifications to ${userRoles.length} user(s) in department ${notificationConfig.department_id}${notificationConfig.section_id != null ? `, section ${notificationConfig.section_id}` : ''}`
+    );
+  }
+
+  return { sentCount };
+}

package/src/index.ts

@@ -425,6 +425,20 @@ export * from './models/EmployeeMilestoneDetailsModel';
 export * from './models/MissionTravelPassportExpiryNotificationConfigModel';
 export * from './models/ServicesNotificationConfigsModel';
 export { ServicesNotificationTriggerType } from './models/ServicesNotificationConfigsModel';
+export {
+  collectFmServicesNotificationConfigRecipients,
+  sendFmServicesNotificationConfigNotifications,
+} from './helpers/services-notification-config.helper';
+export {
+  parsePortalUserIdFromRequest,
+  userHasPortalAdminRole,
+  isPortalAdminFromRequest,
+} from './helpers/admin-auth.helper';
+export type {
+  FmServicesNotificationConfigRecipient,
+  CollectFmServicesNotificationConfigRecipientsParams,
+  SendFmServicesNotificationConfigNotificationsParams,
+} from './helpers/services-notification-config.helper';
 // Moodle Users Model
 export * from './models/MoodleUsersModel';
 // Evaluation