@platform-modules/foreign-ministry 1.3.297 → 1.3.309

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

@@ -1,181 +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 };
-}
+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 };
+}

package/src/helpers/evaluation-eligibility.utils.ts

@@ -1,36 +1,36 @@
-/**
- * Whether evaluations are still open for a setting's month range.
- * `evaluation_end_date` is the last calendar day (1–31) of each month in the range.
- */
-export function isEvaluationEligibilityWindowOpen(
-  fromMonth: number,
-  toMonth: number,
-  evaluationEndDay: number,
-  referenceDate: Date = new Date()
-): boolean {
-  const month = referenceDate.getUTCMonth() + 1;
-  const day = referenceDate.getUTCDate();
-  if (month < fromMonth || month > toMonth) return false;
-  if (!Number.isFinite(evaluationEndDay) || evaluationEndDay < 1 || evaluationEndDay > 31) return false;
-  return day <= evaluationEndDay;
-}
-
-export function parseEvaluationEndDay(input: unknown): number | null {
-  if (input == null || input === '') return null;
-  const n = typeof input === 'number' ? input : parseInt(String(input).trim(), 10);
-  if (!Number.isFinite(n) || n < 1 || n > 31) return null;
-  return Math.floor(n);
-}
-
-export function parseMonthRange(
-  fromInput: unknown,
-  toInput: unknown
-): { from_month: number; to_month: number } | null {
-  const from_month = typeof fromInput === 'number' ? fromInput : parseInt(String(fromInput).trim(), 10);
-  const to_month = typeof toInput === 'number' ? toInput : parseInt(String(toInput).trim(), 10);
-  if (!Number.isFinite(from_month) || !Number.isFinite(to_month)) return null;
-  if (!Number.isInteger(from_month) || !Number.isInteger(to_month)) return null;
-  if (from_month < 1 || from_month > 12 || to_month < 1 || to_month > 12) return null;
-  if (from_month > to_month) return null;
-  return { from_month, to_month };
-}
+/**
+ * Whether evaluations are still open for a setting's month range.
+ * `evaluation_end_date` is the last calendar day (1–31) of each month in the range.
+ */
+export function isEvaluationEligibilityWindowOpen(
+  fromMonth: number,
+  toMonth: number,
+  evaluationEndDay: number,
+  referenceDate: Date = new Date()
+): boolean {
+  const month = referenceDate.getUTCMonth() + 1;
+  const day = referenceDate.getUTCDate();
+  if (month < fromMonth || month > toMonth) return false;
+  if (!Number.isFinite(evaluationEndDay) || evaluationEndDay < 1 || evaluationEndDay > 31) return false;
+  return day <= evaluationEndDay;
+}
+
+export function parseEvaluationEndDay(input: unknown): number | null {
+  if (input == null || input === '') return null;
+  const n = typeof input === 'number' ? input : parseInt(String(input).trim(), 10);
+  if (!Number.isFinite(n) || n < 1 || n > 31) return null;
+  return Math.floor(n);
+}
+
+export function parseMonthRange(
+  fromInput: unknown,
+  toInput: unknown
+): { from_month: number; to_month: number } | null {
+  const from_month = typeof fromInput === 'number' ? fromInput : parseInt(String(fromInput).trim(), 10);
+  const to_month = typeof toInput === 'number' ? toInput : parseInt(String(toInput).trim(), 10);
+  if (!Number.isFinite(from_month) || !Number.isFinite(to_month)) return null;
+  if (!Number.isInteger(from_month) || !Number.isInteger(to_month)) return null;
+  if (from_month < 1 || from_month > 12 || to_month < 1 || to_month > 12) return null;
+  if (from_month > to_month) return null;
+  return { from_month, to_month };
+}

package/src/index.ts

@@ -562,6 +562,32 @@ export {
   EmployeeOfMonthSupportNominationMessageType,
 } from './models/EmployeeOfMonthSupportNominationChatModel';
 export { EmployeeOfMonthSupportNominationRequestAttachment } from './models/EmployeeOfMonthSupportNominationAttachmentModel';
+export {
+  EmbassyEvaluationCycle,
+  EmbassyEvaluationCycleStatus,
+} from './models/EmbassyEvaluationCycleModel';
+export {
+  EmbassyEvaluationAssignment,
+  EmbassyEvaluationAssignmentStatus,
+} from './models/EmbassyEvaluationAssignmentModel';
+export { EmbassyEvaluationResponse } from './models/EmbassyEvaluationResponseModel';
+export {
+  EmbassyEvaluationRequests,
+  EmbassyEvaluationRequestStatus,
+} from './models/EmbassyEvaluationRequestModel';
+export {
+  EmbassyEvaluationApprovalDetails,
+  EmbassyEvaluationApprovalStatus,
+} from './models/EmbassyEvaluationApprovalModel';
+export {
+  EmbassyEvaluationWorkFlow,
+  EmbassyEvaluationWorkFlowStatus,
+} from './models/EmbassyEvaluationWorkflowModel';
+export {
+  EmbassyEvaluationRequestChat,
+  EmbassyEvaluationMessageType,
+} from './models/EmbassyEvaluationChatModel';
+export { EmbassyEvaluationRequestAttachment } from './models/EmbassyEvaluationAttachmentModel';
 export {
   EvaluationForm,
   EvaluationFormType,

package/src/models/EmbassyEvaluationApprovalModel.ts

@@ -0,0 +1,57 @@
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from './BaseModel';
+
+export enum EmbassyEvaluationApprovalStatus {
+  PENDING = 'Pending',
+  IN_PROGRESS = 'In Progress',
+  APPROVED = 'Approved',
+  REJECTED = 'Rejected',
+}
+
+@Entity({ name: 'embassy_evaluation_approvals' })
+export class EmbassyEvaluationApprovalDetails extends BaseModel {
+  @Column({ type: 'integer', nullable: false })
+  request_id: number;
+
+  @Column({ type: 'integer', nullable: true })
+  service_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  sub_service_id: number | null;
+
+  @Column({ type: 'integer', nullable: false })
+  level: number;
+
+  @Column({ type: 'integer', nullable: true })
+  approver_role_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  department_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  section_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  approver_user_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  delegate_user_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  approved_by: number | null;
+
+  @Column({ type: 'varchar', length: 500, nullable: true, default: '' })
+  comment: string;
+
+  @Column({
+    type: 'enum',
+    enum: EmbassyEvaluationApprovalStatus,
+    enumName: 'embassy_evaluation_approval_status_enum',
+    default: EmbassyEvaluationApprovalStatus.PENDING,
+    nullable: false,
+  })
+  approval_status: EmbassyEvaluationApprovalStatus;
+
+  @Column({ type: 'boolean', default: true, nullable: false })
+  is_allowed: boolean;
+}

package/src/models/EmbassyEvaluationAssignmentModel.ts

@@ -0,0 +1,63 @@
+import { Column, Entity, Index } from 'typeorm';
+import { BaseModel } from './BaseModel';
+
+export enum EmbassyEvaluationAssignmentStatus {
+  PENDING = 'Pending',
+  IN_PROGRESS = 'In Progress',
+  SUBMITTED = 'Submitted',
+  LOCKED = 'Locked',
+}
+
+@Entity({ name: 'embassy_evaluation_assignments' })
+@Index('uq_embassy_eval_assignment', ['cycle_id', 'evaluation_year', 'mc_id', 'department_id', 'section_id'], {
+  unique: true,
+  where: '"is_deleted" = false',
+})
+export class EmbassyEvaluationAssignment extends BaseModel {
+  @Column({ type: 'int', nullable: false })
+  cycle_id: number;
+
+  /** Set at activation from cycle window + reference date; separates runs per year (not on cycle row). */
+  @Column({ type: 'int', nullable: false })
+  evaluation_year: number;
+
+  @Column({ type: 'int', nullable: false })
+  mc_id: number;
+
+  @Column({ type: 'int', nullable: false })
+  department_id: number;
+
+  @Column({ type: 'int', nullable: false })
+  section_id: number;
+
+  @Column({ type: 'int', nullable: false })
+  form_id: number;
+
+  @Column({ type: 'int', nullable: true })
+  assigned_to_user_id: number | null;
+
+  @Column({
+    type: 'enum',
+    enum: EmbassyEvaluationAssignmentStatus,
+    enumName: 'embassy_eval_assignment_status_enum',
+    default: EmbassyEvaluationAssignmentStatus.PENDING,
+    nullable: false,
+  })
+  status: EmbassyEvaluationAssignmentStatus;
+
+  @Column({ type: 'timestamp', nullable: true })
+  due_date: Date | null;
+
+  @Column({ type: 'timestamp', nullable: true })
+  submitted_at: Date | null;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2, nullable: true })
+  score: number | null;
+
+  @Column({ type: 'boolean', default: false, nullable: false })
+  workflow_triggered: boolean;
+
+  /** Set when cycle batch request is created after all mandatory evaluations complete. */
+  @Column({ type: 'int', nullable: true })
+  request_id: number | null;
+}

package/src/models/EmbassyEvaluationAttachmentModel.ts

@@ -0,0 +1,26 @@
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from './BaseModel';
+
+@Entity({ name: 'embassy_evaluation_attachments' })
+export class EmbassyEvaluationRequestAttachment extends BaseModel {
+  @Column({ type: 'integer', nullable: false })
+  request_id: number;
+
+  @Column({ type: 'integer', nullable: true })
+  service_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  sub_service_id: number | null;
+
+  @Column({ type: 'varchar', length: 500, nullable: false })
+  file_url: string;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  file_name: string | null;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  file_type: string | null;
+
+  @Column({ type: 'bigint', nullable: true })
+  file_size: number | null;
+}

package/src/models/EmbassyEvaluationChatModel.ts

@@ -0,0 +1,43 @@
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from './BaseModel';
+
+export enum EmbassyEvaluationMessageType {
+  TEXT = 'text',
+  IMAGE = 'image',
+  VIDEO = 'video',
+  FILE = 'file',
+  LINK = 'link',
+}
+
+@Entity({ name: 'embassy_evaluation_chats' })
+export class EmbassyEvaluationRequestChat extends BaseModel {
+  @Column({ type: 'integer', nullable: false })
+  request_id: number;
+
+  @Column({ type: 'integer', nullable: true })
+  service_id: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  sub_service_id: number | null;
+
+  @Column({ type: 'integer', nullable: false })
+  user_id: number;
+
+  @Column({ type: 'integer', nullable: true })
+  role_id: number | null;
+
+  @Column({ type: 'text', nullable: false })
+  message: string;
+
+  @Column({
+    type: 'enum',
+    enum: EmbassyEvaluationMessageType,
+    enumName: 'embassy_evaluation_message_type_enum',
+    default: EmbassyEvaluationMessageType.TEXT,
+    nullable: false,
+  })
+  message_type: EmbassyEvaluationMessageType;
+
+  @Column({ type: 'text', nullable: true })
+  status: string | null;
+}