@platform-modules/civil-aviation-authority 2.3.291 → 2.3.293

package/src/i18n/workflow-chat-message.builder.ts

@@ -344,6 +344,81 @@ export function buildSynchronizedChatMessage(ctx: ChatMessageContext): Bilingual
 
 // ─── Backward-compatible aliases used by Cancellation pilot ───────────────────
 
+export type RequestApprovedAssignedWorkflowParams = {
+  assignedUserName: string;
+  roleName: string;
+  roleArabicName?: string | null;
+  actorUserName: string;
+  employeeId: string | number;
+  assigneeLabel?: 'user' | 'technician';
+};
+
+/** Parse legacy English-only assignment comments used as workflow log suffixes. */
+export function tryParseRequestAssignedComment(
+  comment?: string | null,
+): Omit<RequestApprovedAssignedWorkflowParams, 'roleArabicName'> | null {
+  const text = comment?.trim();
+  if (!text) return null;
+
+  const technicianMatch = text.match(
+    /^Request assigned to technician (.+?) by (.+?) \((.+?) - (.+?)\)$/,
+  );
+  if (technicianMatch) {
+    return {
+      assignedUserName: technicianMatch[1].trim(),
+      roleName: technicianMatch[2].trim(),
+      actorUserName: technicianMatch[3].trim(),
+      employeeId: technicianMatch[4].trim(),
+      assigneeLabel: 'technician',
+    };
+  }
+
+  const userMatch = text.match(/^Request assigned to (.+?) by (.+?) \((.+?) - (.+?)\)$/);
+  if (userMatch) {
+    return {
+      assignedUserName: userMatch[1].trim(),
+      roleName: userMatch[2].trim(),
+      actorUserName: userMatch[3].trim(),
+      employeeId: userMatch[4].trim(),
+      assigneeLabel: 'user',
+    };
+  }
+
+  return null;
+}
+
+/** Bilingual workflow content for approved assignment steps (HR, IT, Tender, etc.). */
+export function buildRequestApprovedAssignedWorkflowFields(
+  params: RequestApprovedAssignedWorkflowParams,
+): BilingualText {
+  const assignedUserEn = params.assignedUserName?.trim() || 'User';
+  const roleEn = params.roleName?.trim() || 'Approver';
+  const roleAr = resolveBilingualName(roleEn, params.roleArabicName);
+  const actorEn = params.actorUserName?.trim() || 'User';
+  const employeeId = String(params.employeeId ?? 'N/A');
+
+  const templateKey =
+    params.assigneeLabel === 'technician'
+      ? 'request_approved_assigned_to_technician'
+      : 'request_approved_assigned_to_user';
+
+  return renderSynchronizedWorkflowMessage(
+    templateKey,
+    {
+      assignedUserName: assignedUserEn,
+      roleName: roleEn,
+      actorUserName: actorEn,
+      employeeId,
+    },
+    {
+      assignedUserName: assignedUserEn,
+      roleName: roleAr,
+      actorUserName: actorEn,
+      employeeId,
+    },
+  );
+}
+
 /** Standard workflow log UPDATE fields for all CAA module repositories. */
 export function buildWorkflowLogUpdateFields(params: {
   approvalStatus: string;
@@ -352,6 +427,23 @@ export function buildWorkflowLogUpdateFields(params: {
   roleArabicName?: string | null;
   comment?: string | null;
 }): { content: string; content_ar: string; status: string; status_ar: string | null } {
+  if (params.approvalStatus === 'Approved') {
+    const assignment = tryParseRequestAssignedComment(params.comment);
+    if (assignment) {
+      const bilingual = buildRequestApprovedAssignedWorkflowFields({
+        ...assignment,
+        roleName: params.roleName?.trim() || assignment.roleName,
+        roleArabicName: params.roleArabicName,
+      });
+      return {
+        content: bilingual.en,
+        content_ar: bilingual.ar,
+        status: params.workflowStatus,
+        status_ar: resolveWorkflowStatusAr(params.workflowStatus),
+      };
+    }
+  }
+
   let action: WorkflowMessageAction;
   if (params.approvalStatus === 'Approved') action = 'approved';
   else if (params.approvalStatus === 'Rejected') action = 'rejected';
@@ -399,6 +491,19 @@ export function toChatPersistFields(
   };
 }
 
+/** User-typed chat — never auto-translate; message_ar stays null. */
+export function buildUserEnteredChatPersistFields(
+  message: string,
+  status: string,
+): { message: string; message_ar: null; status: string; status_ar: string | null } {
+  return {
+    message,
+    message_ar: null,
+    status,
+    status_ar: resolveChatStatusAr(status),
+  };
+}
+
 export function buildApprovalWorkflowContent(params: {
   status: 'Approved' | 'Rejected' | 'Returned for Modification' | 'Pending' | string;
   roleName?: string | null;
@@ -832,6 +937,23 @@ export type ItHelpdeskMuscatWorkflowParams =
     }
   | { variant: 'routing_resolved' };
 
+function resolveItHelpdeskGenericStatusAr(status: string): string {
+  switch (status.trim()) {
+    case 'Approved':
+      return 'تمت الموافقة على';
+    case 'Rejected':
+      return 'تم رفض';
+    case 'Closed':
+      return 'تم إغلاق';
+    case 'Assigned':
+      return 'تم تعيين';
+    case 'Reassigned':
+      return 'تمت إعادة تعيين';
+    default:
+      return resolveChatStatusAr(status) ?? status.toLowerCase();
+  }
+}
+
 export function buildItHelpdeskMuscatWorkflowLog(params: ItHelpdeskMuscatWorkflowParams): BilingualText {
   const comment = formatColonCommentSuffix(
     'comment' in params ? params.comment : undefined,
@@ -954,7 +1076,7 @@ export function buildItHelpdeskMuscatWorkflowLog(params: ItHelpdeskMuscatWorkflo
       const approverEn = params.approverRoleName.trim();
       const approverAr = resolveBilingualName(approverEn, params.approverRoleArabicName);
       const statusEn = params.status.toLowerCase();
-      const statusAr = resolveChatStatusAr(params.status) ?? statusEn;
+      const statusAr = resolveItHelpdeskGenericStatusAr(params.status);
       return renderSynchronizedWorkflowMessage(
         'it_helpdesk_wf_status_by_role',
         { status: statusEn, statusAr, approverRoleName: approverEn, comment },
@@ -1113,13 +1235,130 @@ function resolveArabicChatRoleName(
   actors: BilingualActorNames | undefined,
   parsedEnglishRole?: string,
 ): string {
+  const parsed = parsedEnglishRole?.trim();
   if (actors?.roleName?.trim()) {
-    return resolveBilingualName(actors.roleName, actors.roleArabicName);
+    const actorRole = actors.roleName.trim();
+    if (!parsed || parsed.toLowerCase() === actorRole.toLowerCase()) {
+      return resolveBilingualName(actorRole, actors.roleArabicName);
+    }
+  }
+  if (actors?.roleArabicName?.trim() && parsed) {
+    return resolveBilingualName(parsed, actors.roleArabicName);
   }
   if (actors?.userName?.trim()) {
     return resolveBilingualName(actors.userName, actors.userArabicName);
   }
-  return resolveBilingualName(parsedEnglishRole, actors?.roleArabicName);
+  return resolveBilingualName(parsed, actors?.roleArabicName);
+}
+
+function escapeRegexLiteral(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Match a templated EN message and extract placeholder values (full-structure match). */
+function matchTemplateMessage(
+  templateEn: string,
+  message: string,
+): Record<string, string> | null {
+  if (!/\{\{\w+\}\}/.test(templateEn)) return null;
+
+  const captures: Array<{ key: string; groupIndex: number }> = [];
+  let regexBody = '';
+  let cursor = 0;
+  let groupIndex = 0;
+  const tokenRe = /\{\{(\w+)\}\}/g;
+  let tokenMatch: RegExpExecArray | null;
+
+  while ((tokenMatch = tokenRe.exec(templateEn)) !== null) {
+    regexBody += escapeRegexLiteral(templateEn.slice(cursor, tokenMatch.index));
+    const key = tokenMatch[1];
+    const afterToken = templateEn.slice(tokenMatch.index + tokenMatch[0].length);
+
+    if (key === 'comment') {
+      groupIndex += 1;
+      captures.push({ key, groupIndex });
+      regexBody += '(.*)';
+      cursor = tokenMatch.index + tokenMatch[0].length;
+      continue;
+    }
+
+    if (afterToken.startsWith('{{comment}}')) {
+      groupIndex += 1;
+      captures.push({ key, groupIndex });
+      groupIndex += 1;
+      captures.push({ key: 'comment', groupIndex });
+      regexBody += '([^:]+?)(: .*)?';
+      tokenRe.lastIndex = tokenMatch.index + tokenMatch[0].length + '{{comment}}'.length;
+      cursor = tokenRe.lastIndex;
+      continue;
+    }
+
+    groupIndex += 1;
+    captures.push({ key, groupIndex });
+    regexBody += '(.+?)';
+    cursor = tokenMatch.index + tokenMatch[0].length;
+  }
+  regexBody += escapeRegexLiteral(templateEn.slice(cursor));
+
+  const match = message.match(new RegExp(`^${regexBody}$`, 's'));
+  if (!match) return null;
+
+  const params: Record<string, string> = {};
+  captures.forEach(({ key, groupIndex: idx }) => {
+    params[key] = match[idx] ?? '';
+  });
+  return params;
+}
+
+function buildArabicChatTemplateParams(
+  params: Record<string, string>,
+  actors?: BilingualActorNames,
+): Record<string, string> {
+  const arParams: Record<string, string> = { ...params };
+  if (params.roleName !== undefined) {
+    arParams.roleName = resolveArabicChatRoleName(actors, params.roleName.trim());
+  }
+  if (params.userName !== undefined) {
+    arParams.userName = actors?.userName?.trim()
+      ? resolveBilingualName(actors.userName, actors.userArabicName)
+      : resolveBilingualName(params.userName.trim(), actors?.userArabicName);
+  }
+  return arParams;
+}
+
+function buildArabicWorkflowTemplateParams(
+  params: Record<string, string>,
+  actors?: BilingualActorNames,
+): Record<string, string> {
+  const arParams: Record<string, string> = { ...params };
+  if (params.roleName !== undefined) {
+    arParams.roleName = resolveArabicChatRoleName(actors, params.roleName.trim());
+  }
+  if (params.approverRoleName !== undefined) {
+    arParams.approverRoleName = resolveArabicChatRoleName(actors, params.approverRoleName.trim());
+  }
+  if (params.assignedRoleName !== undefined) {
+    arParams.assignedRoleName = resolveArabicChatRoleName(actors, params.assignedRoleName.trim());
+  }
+  if (params.name !== undefined) {
+    arParams.name = resolveArabicWorkflowActorName(actors, params.name.trim());
+  }
+  if (params.status !== undefined && params.statusAr === undefined) {
+    const normalizedStatus =
+      params.status.charAt(0).toUpperCase() + params.status.slice(1).toLowerCase();
+    arParams.statusAr = resolveItHelpdeskGenericStatusAr(normalizedStatus);
+  }
+  return arParams;
+}
+
+function countTemplatePlaceholders(templateEn: string): number {
+  return (templateEn.match(/\{\{\w+\}\}/g) || []).length;
+}
+
+function listWorkflowTemplatesBySpecificity(): Array<[string, BilingualText]> {
+  return Object.entries(WORKFLOW_TEMPLATES).sort(
+    ([, a], [, b]) => countTemplatePlaceholders(b.en) - countTemplatePlaceholders(a.en),
+  );
 }
 
 export function resolveWorkflowContentAr(
@@ -1130,7 +1369,14 @@ export function resolveWorkflowContentAr(
   const normalized = content.trim();
 
   for (const tpl of Object.values(WORKFLOW_TEMPLATES)) {
-    if (tpl.en === normalized) return tpl.ar;
+    if (tpl.en === normalized || tpl.en.toLowerCase() === normalized.toLowerCase()) return tpl.ar;
+  }
+
+  for (const [, tpl] of listWorkflowTemplatesBySpecificity()) {
+    if (!/\{\{\w+\}\}/.test(tpl.en)) continue;
+    const params = matchTemplateMessage(tpl.en, normalized);
+    if (!params) continue;
+    return interpolate(tpl.ar, buildArabicWorkflowTemplateParams(params, actors));
   }
 
   const commentIdx = normalized.indexOf(': ');
@@ -1168,6 +1414,31 @@ export function resolveWorkflowContentAr(
     return interpolate(WORKFLOW_TEMPLATES.request_approval_pending_from.ar, { name: nameAr });
   }
 
+  // Legacy HR worker strings (pre-i18n catalog)
+  if (normalized === 'Send Notification') {
+    return WORKFLOW_TEMPLATES.notification_sent_pending?.ar ?? null;
+  }
+  const notificationSuccessVariants = [
+    'notification sent successfully',
+    'notification sent sucessfully',
+    'notification sent',
+  ];
+  if (notificationSuccessVariants.includes(normalized.toLowerCase())) {
+    return WORKFLOW_TEMPLATES.notification_sent_successfully?.ar ?? null;
+  }
+  const legacyPendingPrefix = 'Approval pending from ';
+  if (normalized.startsWith(legacyPendingPrefix)) {
+    const namePartEn = normalized.slice(legacyPendingPrefix.length).trim();
+    const nameAr = resolveArabicWorkflowActorName(actors, namePartEn);
+    return interpolate(WORKFLOW_TEMPLATES.request_approval_pending_from.ar, { name: nameAr });
+  }
+  if (
+    normalized === 'Approval Pending from HR Section' ||
+    normalized === 'Approval Pending from Records Department'
+  ) {
+    return WORKFLOW_TEMPLATES.request_approval_pending?.ar ?? null;
+  }
+
   return null;
 }
 
@@ -1182,46 +1453,77 @@ export function resolveChatMessageAr(
     if (tpl.en === normalized) return tpl.ar;
   }
 
-  for (const tplKey of ['request_submitted_by', 'cancellation_submitted_by'] as const) {
-    const submittedTpl = CHAT_TEMPLATES[tplKey];
-    if (!submittedTpl) continue;
-    const prefix = submittedTpl.en.split('{{userName}}')[0];
-    if (!normalized.startsWith(prefix)) continue;
-    const afterPrefix = normalized.slice(prefix.length);
-    const parenMatch = afterPrefix.match(/^(.+?) \((.+)\)$/);
-    if (parenMatch) {
-      const userEn = parenMatch[1].trim();
-      const employeeId = parenMatch[2].trim();
-      const userAr = actors?.userName?.trim()
-        ? resolveBilingualName(actors.userName, actors.userArabicName)
-        : resolveBilingualName(userEn, actors?.userArabicName);
-      return interpolate(submittedTpl.ar, { userName: userAr, employeeId });
-    }
-  }
-
   for (const tpl of Object.values(CHAT_TEMPLATES)) {
-    if (!tpl.en.includes('{{roleName}}')) continue;
-    const prefix = tpl.en.split('{{roleName}}')[0];
-    if (!normalized.startsWith(prefix)) continue;
-    const rest = normalized.slice(prefix.length);
-    const commentIdx = rest.lastIndexOf(' - ');
-    const roleNameEn = commentIdx >= 0 ? rest.slice(0, commentIdx) : rest;
-    const commentSuffix = commentIdx >= 0 ? rest.slice(commentIdx) : '';
-    const roleNameAr = resolveArabicChatRoleName(actors, roleNameEn.trim());
-    return interpolate(tpl.ar, { roleName: roleNameAr, comment: commentSuffix });
+    if (!/\{\{\w+\}\}/.test(tpl.en)) continue;
+    const params = matchTemplateMessage(tpl.en, normalized);
+    if (!params) continue;
+    return interpolate(tpl.ar, buildArabicChatTemplateParams(params, actors));
   }
 
   return null;
 }
 
+/** True when message matches a known system chat template (safe to resolve message_ar). */
+export function isSystemGeneratedChatMessage(
+  message: string | null | undefined,
+  actors?: BilingualActorNames,
+): boolean {
+  return resolveChatMessageAr(message, actors) != null;
+}
+
 /** Generic workflow log enricher — use in all module repositories. */
 export function enrichWorkflowLog(log: Record<string, unknown>): Record<string, unknown> {
   const status = log.status != null ? String(log.status) : null;
   const content = log.content != null ? String(log.content) : null;
   const actors = extractBilingualActorsFromRecord(log);
+  const resolvedAr = resolveWorkflowContentAr(content, actors);
+  const existingAr =
+    log.content_ar != null && String(log.content_ar).trim() !== ''
+      ? String(log.content_ar)
+      : null;
+  // Re-resolve when stored AR still embeds the English actor parsed from `content`.
+  const pendingPrefix = WORKFLOW_TEMPLATES.request_approval_pending_from?.en.split('{{name}}')[0].trim();
+  let content_ar = existingAr ?? resolvedAr;
+  if (
+    content &&
+    pendingPrefix &&
+    content.startsWith(pendingPrefix) &&
+    existingAr &&
+    resolvedAr &&
+    existingAr !== resolvedAr
+  ) {
+    const namePartEn = content.slice(pendingPrefix.length).trim();
+    if (namePartEn && existingAr.includes(namePartEn)) {
+      content_ar = resolvedAr;
+    }
+  }
+  if (
+    content &&
+    existingAr &&
+    resolvedAr &&
+    existingAr !== resolvedAr &&
+    /Request assigned to/i.test(existingAr)
+  ) {
+    content_ar = resolvedAr;
+  }
+  if (
+    content &&
+    existingAr &&
+    resolvedAr &&
+    existingAr !== resolvedAr &&
+    actors?.roleName?.trim() &&
+    actors?.roleArabicName?.trim() &&
+    existingAr.includes(actors.roleName.trim())
+  ) {
+    content_ar = resolvedAr;
+  }
+  if ((content_ar == null || content_ar === '') && content) {
+    const notificationAr = resolveWorkflowContentAr(content, actors);
+    if (notificationAr) content_ar = notificationAr;
+  }
   return {
     ...log,
-    content_ar: log.content_ar ?? resolveWorkflowContentAr(content, actors),
+    content_ar,
     status_ar: log.status_ar ?? resolveWorkflowStatusAr(status),
   };
 }

package/src/index.ts

@@ -425,6 +425,7 @@ export * from './models/MaintenanceAttachmentModel';
 export * from './models/MaintenanceChatModel';
 export * from './models/MaintenanceWorkflowModel';
 export * from './models/FollowUpReportRequestModel';
+export * from './models/FollowUpReportItemModel';
 export * from './models/FollowUpReportApprovalModel';
 export * from './models/FollowUpReportAttachmentModel';
 export * from './models/FollowUpReportChatModel';
@@ -497,7 +498,9 @@ export * from './models/RespondToEnquiriesAttachmentModel';
 export {RespondToEnquiriesRequestAttachment} from './models/RespondToEnquiriesAttachmentModel';
 export * from './models/RequestATenderRequestModel';
 export * from './models/RequestTenderAnalysisRequestModel';
-export * from './models/ContractServiceRequestModel';export * from './models/SlaConfigModel';
+export * from './models/ContractServiceRequestModel';
+export * from './models/ContractServiceRequestDocumentModel';
+export * from './models/SlaConfigModel';
 export * from './models/SlaRequestModel';
 export * from './models/SlaMyRequestsViewModel';
 export * from './models/SlaApprovalsViewModel';

package/src/models/ContractServiceRequestDocumentModel.ts

@@ -0,0 +1,35 @@
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from './BaseModel';
+
+@Entity({ name: 'contract_service_request_documents' })
+export class ContractServiceRequestDocument 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 })
+  document_name: string;
+
+  @Column({ type: 'text', nullable: true })
+  description: string | 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;
+
+  @Column({ type: 'integer', nullable: false })
+  uploaded_by: number;
+}

package/src/models/ContractServiceRequestModel.ts

@@ -43,6 +43,12 @@ export class ContractServiceRequest extends BaseModel {
     @Column({ type: "varchar", length: 255, nullable: false })
     company_name: string;
 
+    @Column({ type: "varchar", length: 30, nullable: true })
+    company_phone_number: string | null;
+
+    @Column({ type: "text", nullable: true })
+    notes: string | null;
+
     @Column({
         type: "enum",
         enum: RespondToEnquiriesRequestStatus,

package/src/models/FollowUpReportItemModel.ts

@@ -0,0 +1,59 @@
+import { Column, Entity } from 'typeorm';
+import { BaseModel } from './BaseModel';
+import { FollowUpReportSubjectClassification } from './FollowUpReportRequestModel';
+
+@Entity({ name: 'followup_report_items' })
+export class FollowUpReportItem 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: 100, nullable: true })
+  reference_type: string | null;
+
+  @Column({ type: 'date', nullable: true })
+  letter_date: Date | null;
+
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  subject: string | null;
+
+  @Column({
+    type: 'enum',
+    enum: FollowUpReportSubjectClassification,
+    enumName: 'maintenance_subject_classification_en',
+    nullable: true,
+  })
+  subject_classification: FollowUpReportSubjectClassification | null;
+
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  general_manager_comment: string | null;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  response_date_target: string | null;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  action_status: string | null;
+
+  @Column({ type: 'text', nullable: true })
+  action_taken: string | null;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  delay_period: string | null;
+
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  file_url: string | null;
+
+  @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/FollowUpReportRequestModel.ts

@@ -8,8 +8,17 @@ export enum FollowUpReportSubjectClassification {
   CONFIDENTIAL = 'Confidential',
   INFORMATIONAL = 'Informational',
   NORMAL = 'Normal',
+  IMPORTANT = 'Important',
+  HIGHLY_CONFIDENTIAL = 'Highly Confidential',
+  RESTRICTED = 'Restricted',
+  LIMITED = 'Limited',
 }
 
+/** Allowed API/DB values for follow-up report subject classification. */
+export const FOLLOW_UP_REPORT_SUBJECT_CLASSIFICATION_VALUES = Object.values(
+  FollowUpReportSubjectClassification,
+) as FollowUpReportSubjectClassification[];
+
 /** Concerned department under General Manager of Support Services */
 export enum FollowUpReportConcernedDepartment {
   IT = 'IT',
@@ -78,6 +87,21 @@ export class FollowUpReportRequests extends BaseModel {
   @Column({ type: 'date', nullable: false })
   date_to: Date;
 
+  @Column({ type: 'varchar', length: 500, nullable: true })
+  general_manager_comment: string | null;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  response_date_target: string | null;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  action_status: string | null;
+
+  @Column({ type: 'text', nullable: true })
+  action_taken: string | null;
+
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  delay_period: string | null;
+
   @Column({ type: 'date', nullable: false, default: () => 'CURRENT_DATE' })
   request_submission_date: Date;
 

package/src/models/RespondToEnquiriesAttachmentModel.ts

@@ -30,6 +30,9 @@ export class RespondToEnquiriesRequestAttachment extends BaseModel {
     @Column({ type: "text", nullable: true })
     description: string;
 
+    @Column({ type: "varchar", length: 500, nullable: true })
+    document_name: string | null;
+
     constructor(
         request_id: number,
         uploaded_by: number,
@@ -39,7 +42,8 @@ export class RespondToEnquiriesRequestAttachment extends BaseModel {
         file_name?: string,
         file_type?: string,
         file_size?: number,
-        description?: string
+        description?: string,
+        document_name?: string
     ) {
         super();
         this.request_id = request_id;
@@ -51,5 +55,6 @@ export class RespondToEnquiriesRequestAttachment extends BaseModel {
         this.file_type = file_type || "";
         this.file_size = file_size || null;
         this.description = description || "";
+        this.document_name = document_name || null;
     }
 }