@platform-modules/foreign-ministry 1.3.286 → 1.3.296

package/src/helpers/employee-evaluation-request.utils.ts

@@ -0,0 +1,181 @@
+import type { EntityManager } from 'typeorm';
+import { EmployeeEvaluationAnswers } from '../models/EmployeeEvaluationAnswerModel';
+import { EmployeeEvaluationPersonScore } from '../models/EmployeeEvaluationPersonScoreModel';
+import { EmployeeEvaluationRequests } from '../models/EmployeeEvaluationRequestModel';
+import { EvaluationEligibilitySetting } from '../models/EvaluationEligibilitySettingModel';
+import { EvaluationFormQuestion } from '../models/EvaluationFormQuestionModel';
+
+export const DEFAULT_MAX_EMPLOYEES_PER_REQUEST = 50;
+
+export type EmployeeEvaluationSubmitAnswer = {
+  section_id: number;
+  question_id: number;
+  score: number;
+  remarks?: string | null;
+};
+
+export type EmployeeEvaluationSubmitEmployee = {
+  user_id: number;
+  is_rca?: boolean;
+  answers: EmployeeEvaluationSubmitAnswer[];
+};
+
+export type NormalizedEmployeeSubmission = EmployeeEvaluationSubmitEmployee;
+
+export function normalizeEmployeeSubmissions(raw: unknown): {
+  employees: NormalizedEmployeeSubmission[];
+  error?: string;
+} {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return { employees: [], error: 'employees must be a non-empty array' };
+  }
+  const seen = new Set<number>();
+  const employees: NormalizedEmployeeSubmission[] = [];
+  for (const item of raw) {
+    if (item == null || typeof item !== 'object') {
+      return { employees: [], error: 'Each employee entry must be an object' };
+    }
+    const o = item as Record<string, unknown>;
+    const user_id = Number(o.user_id ?? o.employee_id);
+    if (!Number.isFinite(user_id) || user_id <= 0) {
+      return { employees: [], error: 'Each employee must have a valid user_id' };
+    }
+    if (seen.has(user_id)) {
+      return { employees: [], error: `Duplicate user_id ${user_id} in employees list` };
+    }
+    seen.add(user_id);
+    const answersRaw = o.answers;
+    if (!Array.isArray(answersRaw) || answersRaw.length === 0) {
+      return { employees: [], error: `Employee ${user_id} must include a non-empty answers array` };
+    }
+    const answers: EmployeeEvaluationSubmitAnswer[] = [];
+    const qSeen = new Set<number>();
+    for (const a of answersRaw) {
+      if (a == null || typeof a !== 'object') {
+        return { employees: [], error: `Invalid answer for employee ${user_id}` };
+      }
+      const ar = a as Record<string, unknown>;
+      const section_id = Number(ar.section_id);
+      const question_id = Number(ar.question_id);
+      const score = Number(ar.score);
+      if (!Number.isFinite(section_id) || !Number.isFinite(question_id)) {
+        return { employees: [], error: `section_id and question_id required for employee ${user_id}` };
+      }
+      if (!Number.isFinite(score) || score < 0) {
+        return { employees: [], error: `score must be a non-negative number for employee ${user_id}, question ${question_id}` };
+      }
+      if (qSeen.has(question_id)) {
+        return { employees: [], error: `Duplicate question_id ${question_id} for employee ${user_id}` };
+      }
+      qSeen.add(question_id);
+      answers.push({
+        section_id,
+        question_id,
+        score,
+        remarks: ar.remarks != null ? String(ar.remarks) : null,
+      });
+    }
+    employees.push({
+      user_id,
+      is_rca: o.is_rca !== undefined ? Boolean(o.is_rca) : false,
+      answers,
+    });
+  }
+  return { employees };
+}
+
+/** Resolve max employees from active eligibility setting for dept/section/month. */
+export async function resolveMaxEmployeesPerRequest(
+  manager: EntityManager,
+  department_id: number,
+  section_id: number,
+  month: number
+): Promise<number> {
+  const setting = await manager
+    .getRepository(EvaluationEligibilitySetting)
+    .createQueryBuilder('s')
+    .where('s.is_deleted = false')
+    .andWhere('s.is_active = true')
+    .andWhere('s.department_id = :department_id', { department_id })
+    .andWhere('s.section_id = :section_id', { section_id })
+    .andWhere('s.from_month <= :month', { month })
+    .andWhere('s.to_month >= :month', { month })
+    .orderBy('s.id', 'DESC')
+    .getOne();
+  const max = setting?.max_employees_per_request;
+  if (max != null && Number.isFinite(Number(max)) && Number(max) > 0) {
+    return Math.floor(Number(max));
+  }
+  return DEFAULT_MAX_EMPLOYEES_PER_REQUEST;
+}
+
+export async function persistEmployeeEvaluationScores(
+  manager: EntityManager,
+  opts: {
+    requestId: number;
+    formId: number;
+    createdBy: string;
+    employees: NormalizedEmployeeSubmission[];
+  }
+): Promise<{ totalScore: number; averageScore: number; employeeCount: number }> {
+  const { requestId, formId, createdBy, employees } = opts;
+  let requestTotal = 0;
+
+  for (const emp of employees) {
+    let personTotal = 0;
+    for (const ans of emp.answers) {
+      const qMeta = await manager.findOne(EvaluationFormQuestion, {
+        where: { id: ans.question_id, is_deleted: false },
+      });
+      const questionSectionId = qMeta?.form_section_id;
+      if (!qMeta || questionSectionId == null || questionSectionId !== ans.section_id) {
+        throw new Error(`Invalid question ${ans.question_id} for section ${ans.section_id}`);
+      }
+      if (qMeta.max_score != null && ans.score > qMeta.max_score) {
+        throw new Error(
+          `score ${ans.score} exceeds max_score ${qMeta.max_score} for question ${ans.question_id}`
+        );
+      }
+      personTotal += ans.score;
+      await manager.save(
+        EmployeeEvaluationAnswers,
+        manager.create(EmployeeEvaluationAnswers, {
+          request_id: requestId,
+          user_id: emp.user_id,
+          form_id: formId,
+          section_id: ans.section_id,
+          question_id: ans.question_id,
+          score: ans.score,
+          remarks: ans.remarks ?? null,
+          created_by: createdBy,
+          is_deleted: false,
+        })
+      );
+    }
+
+    await manager.save(
+      EmployeeEvaluationPersonScore,
+      manager.create(EmployeeEvaluationPersonScore, {
+        request_id: requestId,
+        user_id: emp.user_id,
+        is_rca: Boolean(emp.is_rca),
+        us_feedback: null,
+        total_score: personTotal,
+        created_by: createdBy,
+        is_deleted: false,
+      })
+    );
+    requestTotal += personTotal;
+  }
+
+  const employeeCount = employees.length;
+  const averageScore = employeeCount ? requestTotal / employeeCount : 0;
+  await manager.update(EmployeeEvaluationRequests, { id: requestId }, {
+    total_score: requestTotal,
+    average_score: averageScore,
+    employee_count: employeeCount,
+    updated_by: createdBy,
+  });
+
+  return { totalScore: requestTotal, averageScore, employeeCount };
+}