@dynamatix/gb-schemas 2.17.12 → 2.19.1

package/dist/applications/application.model.js

@@ -0,0 +1,254 @@
+import mongoose from "mongoose";
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+import creditProfileSchema from "./application-credit-profile.model";
+import { applyWorkflowPlugin } from "../shared/workflow.plugin";
+const applicationSchema = new mongoose.Schema({
+    queueId: [{
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "Queue",
+            default: null,
+        }],
+    underwriterReviewDate: { type: Date, default: null },
+    assignedToUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User", default: null },
+    assignedToUserDate: { type: Date, default: null },
+    firstAssignedToUserDate: { type: Date, default: null },
+    slaClockStart: { type: Date, default: null },
+    slaClockStop: { type: Date, default: null },
+    affordabilityCompletedAt: { type: Date, default: null },
+    applicationId: { type: String, required: true },
+    isApplicationFeePaid: { type: String, required: true },
+    applicationNumber: { type: String, required: true },
+    applicationTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    bankSolicitor: { type: String, default: "" },
+    brokerId: { type: mongoose.Schema.Types.ObjectId, ref: "Broker", default: null },
+    caseManager: { type: String, default: "" },
+    caseManagerAccepted: { type: String, default: false },
+    completedReason: { type: String, default: "" },
+    isIntendToOccupy: { type: String, required: true },
+    introducer: { type: String, default: "" },
+    isIntroducerSubmission: { type: String, required: true },
+    isBrokerAssigned: { type: String, default: false },
+    isFinanceRecommendedToApplicant: { type: String, required: true },
+    isWorkflowTaskCreated: { type: String, required: true },
+    lastUpdated: { type: String },
+    lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    networkClubName: { type: String, default: "" },
+    isNetworkClubSubmission: { type: String, required: true },
+    newReason: { type: String, default: "" },
+    purchaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    rejectedReason: { type: String, default: "" },
+    repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    selectedProduct: { type: String, required: false },
+    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    submitReason: { type: String, default: "" },
+    submittedDate: { type: String },
+    underwriter: { type: String, default: "" },
+    isValuationFeePaid: { type: String, required: true },
+    withdrawalReasonLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    declineReasonLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    isPortfolioConfirmed: { type: Boolean, default: false },
+    productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product", default: null },
+    product: { type: String },
+    securityId: { type: mongoose.Schema.Types.ObjectId, ref: "Security", default: null },
+    solicitorId: { type: mongoose.Schema.Types.ObjectId, ref: "Solicitor", default: null },
+    riskNarrativeId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationRiskNarrative", default: null },
+    riskNarrative: {
+        call1RequestedOn: { type: String, default: null },
+        call2RequestedOn: { type: String, default: null },
+        retryCount: { type: String, default: null },
+        riskRating: { type: String, default: null },
+        statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+        call2StatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
+    },
+    // Flag for a requested RiskNarrative Call 2. Owned by Catura and never mapped from Apprivo.
+    // Deliberately top-level, not inside `riskNarrative`: the background sync replaces that whole
+    // sub-document, which would wipe anything stored within it.
+    // null = never requested, false = awaiting a final Call2Status, true = final status received.
+    // The default MUST stay null: the fetch-risk-narrative job queries for an explicit false, and
+    // defaulting to false would mark every existing application as awaiting and sync them all.
+    isRiskNarrativeSynced: { type: Boolean, default: null },
+    applicants: [
+        { type: mongoose.Schema.Types.ObjectId, ref: "Applicant", default: null }
+    ],
+    isActive: { type: String, default: false },
+    riskRating: { type: String },
+    directDebitId: { type: mongoose.Schema.Types.ObjectId, ref: "Application_DirectDebit", default: null },
+    creditProfile: creditProfileSchema,
+    mortgageId: { type: mongoose.Schema.Types.ObjectId, ref: "Mortgage", default: null },
+    companyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationCompany", default: null },
+    offerId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationOffer", default: null },
+    newAuditRecordsCount: { type: Number, default: 0 }, // Ensure it is a Number
+    currentApprivoAuditId: Number,
+    propertyIds: [{ type: mongoose.Schema.Types.ObjectId, ref: "Property" }],
+    valuationId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationValuation" },
+    valuationReportId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationValuationReport" },
+    isMandateRequested: { type: Boolean, default: false },
+    isMandateApproved: { type: Boolean, default: null },
+    mandateReviewComments: { type: String, default: "" },
+    mandateRequestedByUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User", default: null },
+    mandateRequestedDate: { type: Date, default: null },
+    mandateReviewedByUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User", default: null },
+    mandateReviewedDate: { type: Date, default: null },
+    isReferred: { type: Boolean, default: false },
+    referredByUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User", default: null },
+    referredDate: { type: Date, default: null },
+    referralClearedByUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User", default: null },
+    referralClearedDate: { type: Date, default: null },
+    brokerTaskCount: {
+        type: Number,
+        default: 0
+    },
+    lenderTaskCount: {
+        type: Number,
+        default: 0
+    },
+    pendingTaskCountForUser: {
+        type: Number,
+        default: 0
+    },
+    applicationFormSignedDate: {
+        type: Date, // Stores as ISODate in MongoDB (e.g., "2023-11-15T12:30:45.123Z")
+        default: null
+    },
+    isUkResident: {
+        type: Boolean,
+        default: false
+    },
+    creditReportId: { type: String, default: null },
+    isAlgbraEligible: { type: Boolean, default: false },
+}, {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+applyAuditMiddleware(applicationSchema, "Application");
+// Apply workflow plugin to the schema
+applyWorkflowPlugin(applicationSchema, 'application');
+// Virtual property 'noOfApplicants'
+applicationSchema.virtual('noOfApplicants').get(function () {
+    return this.applicants ? this.applicants.length : 0;
+});
+// Virtual property 'applicationTypeName'
+applicationSchema.virtual('applicationTypeName').get(function () {
+    return this.applicationTypeLid instanceof mongoose.Types.ObjectId
+        ? null
+        : this.applicationTypeLid?.name ?? null;
+});
+// Virtual property 'lendingType'
+applicationSchema.virtual('lendingType').get(function () {
+    return this.lendingTypeLid instanceof mongoose.Types.ObjectId
+        ? null
+        : this.lendingTypeLid?.name ?? null;
+});
+// Virtual property 'purchaseType'
+applicationSchema.virtual('purchaseType').get(function () {
+    return this.purchaseTypeLid instanceof mongoose.Types.ObjectId
+        ? null
+        : this.purchaseTypeLid?.text ?? null;
+});
+// Virtual property 'status'
+applicationSchema.virtual('status').get(function () {
+    return this.statusLid instanceof mongoose.Types.ObjectId ? null : this.statusLid?.name ?? null;
+});
+// Ensure the fields are populated when querying
+applicationSchema.pre('find', function () {
+    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
+});
+applicationSchema.pre('findOne', function () {
+    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
+});
+// Virtual property 'LTV %'
+applicationSchema.virtual('ltv').get(function () {
+    const purchasePrice = this.mortgageId?.purchasePrice;
+    const loanRequired = this.mortgageId?.loanRequired;
+    if (purchasePrice && loanRequired) {
+        const parseCurrency = (value) => {
+            if (typeof value === 'string') {
+                return parseFloat(value.replace(/[^0-9.-]+/g, ""));
+            }
+            return value;
+        };
+        const parsedPurchasePrice = parseCurrency(purchasePrice);
+        const parsedLoanRequired = parseCurrency(loanRequired);
+        const ltv = (parsedLoanRequired / parsedPurchasePrice) * 100;
+        return ltv.toFixed(2) + "%";
+    }
+    return null;
+});
+applicationSchema.virtual('submittedDateFormatted').get(function () {
+    if (!this.submittedDate)
+        return null;
+    const date = new Date(this.submittedDate);
+    const day = String(date.getDate()).padStart(2, '0');
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const year = date.getFullYear();
+    return `${day}-${month}-${year}`;
+});
+// Virtual property for broker name
+applicationSchema.virtual('brokerName').get(function () {
+    if (this.brokerId && typeof this.brokerId === 'object' && this.brokerId.firstName && this.brokerId.lastName) {
+        return this.brokerId.firstName + " " + this.brokerId.lastName;
+    }
+    return null;
+});
+applicationSchema.virtual('brokerEmail').get(function () {
+    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.email : null;
+});
+applicationSchema.virtual('solicitorName').get(function () {
+    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.nameOfAccountHolder : null;
+});
+applicationSchema.virtual('solicitorEmail').get(function () {
+    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.email : null;
+});
+applicationSchema.virtual('brokerPhone').get(function () {
+    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.mobileTelephone : null;
+});
+applicationSchema.virtual('solicitorPhone').get(function () {
+    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.telephone : null;
+});
+// Virtual property 'pendingDays'
+applicationSchema.virtual('pendingDays').get(function () {
+    if (!this.applicationFormSignedDate)
+        return null;
+    // Get current date at midnight (ignoring time)
+    const now = new Date();
+    const todayMidnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    // Get signed date at midnight (ignoring time)
+    const signedDate = new Date(this.applicationFormSignedDate);
+    const signedMidnight = new Date(signedDate.getFullYear(), signedDate.getMonth(), signedDate.getDate());
+    // Calculate difference in just date
+    const diffTime = todayMidnight.getTime() - signedMidnight.getTime();
+    // Convert to days
+    const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
+    return diffDays;
+});
+// Virtual property 'taskCompletionPercent'
+applicationSchema.virtual('taskCompletionPercent').get(function () {
+    const broker = typeof this.brokerTaskCount === 'number' ? this.brokerTaskCount : 0;
+    const lender = typeof this.lenderTaskCount === 'number' ? this.lenderTaskCount : 0;
+    const total = broker + lender;
+    // If both broker and lender are 0, return 100.00
+    if (broker === 0 && lender === 0)
+        return 100.00;
+    // If broker is 0 and lender is not, return 100.00
+    if (broker === 0 && lender > 0)
+        return 100.00;
+    // If lender is 0 and broker is not, return 0.00
+    if (lender === 0 && broker > 0)
+        return 0.00;
+    // Calculate (lender/total)*100
+    return Number(((lender / total) * 100).toFixed(2));
+});
+// Database indexes for performance optimization
+// Single field indexes
+applicationSchema.index({ applicationId: 1 });
+applicationSchema.index({ assignedToUserId: 1 });
+applicationSchema.index({ brokerId: 1 });
+applicationSchema.index({ applicants: 1 }); // For array membership queries
+// Compound indexes for common query combinations
+applicationSchema.index({ applicants: 1, _id: 1 }); // For finding application by applicant
+applicationSchema.index({ assignedToUserId: 1, statusLid: 1 }); // For filtering by assignee and status
+// Text index for search functionality
+applicationSchema.index({ applicationNumber: "text" });
+const ApplicationModel = mongoose.model("Application", applicationSchema);
+export default ApplicationModel;

package/dist/applications/applications-task.model.d.ts

@@ -0,0 +1,313 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference path="../shared/encryption/encrypted-field-map.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const ApplicationsTaskModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    applicationId: mongoose.Types.ObjectId;
+    createdOn: string;
+    additionalData: {
+        concernTypeLid: mongoose.Types.ObjectId;
+        concernComments: string;
+        resolvedComments: string;
+        rejectionReason: string;
+        rejectionDate: string;
+        responderRemarks: string;
+        requesterAttachmentId: string;
+        responderAttachmentId: string;
+        requesterFileName: string;
+        responderFileName: string;
+        respondedDate: string;
+        description?: string | null | undefined;
+        statusLid?: mongoose.Types.ObjectId | null | undefined;
+        requesterId?: mongoose.Types.ObjectId | null | undefined;
+        responderId?: mongoose.Types.ObjectId | null | undefined;
+        taskType?: "internal" | "broker" | null | undefined;
+        acceptedDate?: string | null | undefined;
+        acceptedById?: mongoose.Types.ObjectId | null | undefined;
+        rejectedById?: mongoose.Types.ObjectId | null | undefined;
+    };
+    statusDate: string;
+    statusReason: string;
+    comments: mongoose.Types.DocumentArray<{
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }, mongoose.Types.Subdocument<mongoose.Types.ObjectId, any, {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }> & {
+        createdAt: NativeDate;
+        message: string;
+        createdBy: mongoose.Types.ObjectId;
+    }>;
+    status?: number | null | undefined;
+    checkflowId?: string | null | undefined;
+    instanceId?: string | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default ApplicationsTaskModel;
+//# sourceMappingURL=applications-task.model.d.ts.map

package/dist/applications/applications-task.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applications-task.model.d.ts","sourceRoot":"","sources":["../../applications/applications-task.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAiEhC,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6D,CAAC;AACzF,eAAe,qBAAqB,CAAC"}

package/dist/applications/applications-task.model.js

@@ -0,0 +1,58 @@
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+import { applyWorkflowPlugin } from "../shared/workflow.plugin";
+import mongoose from "mongoose";
+// Additional Data schema for the nested object
+const additionalDataSchema = new mongoose.Schema({
+    requesterId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    responderId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: false },
+    concernTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    description: { type: String },
+    concernComments: { type: String, required: true },
+    resolvedComments: { type: String, default: "" },
+    taskType: {
+        type: String,
+        enum: ["internal", "broker"], // allowed values
+        required: false
+    },
+    acceptedDate: { type: String },
+    acceptedById: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    rejectedById: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    rejectionReason: { type: String, default: null },
+    rejectionDate: { type: String, default: null },
+    responderRemarks: { type: String, default: "" },
+    requesterAttachmentId: { type: String, default: null },
+    responderAttachmentId: { type: String, default: null },
+    requesterFileName: { type: String, default: null },
+    responderFileName: { type: String, default: null },
+    respondedDate: { type: String, default: null }
+}, { _id: false });
+const applicationsTaskSchema = new mongoose.Schema({
+    checkflowId: { type: String, required: false },
+    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
+    instanceId: { type: String, required: false },
+    status: { type: Number, required: false, default: 2 }, // 2 = pending
+    statusReason: { type: String, default: "" },
+    statusDate: { type: String, default: null },
+    additionalData: { type: additionalDataSchema, required: true },
+    comments: [{
+            createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+            createdAt: { type: Date, default: Date.now },
+            message: { type: String, default: "", maxlength: 2000 }
+        }],
+    createdOn: { type: String, required: true, default: () => new Date().toISOString() }
+}, { timestamps: true });
+applyAuditMiddleware(applicationsTaskSchema, "ApplicationsTask");
+// Apply workflow plugin to the schema
+applyWorkflowPlugin(applicationsTaskSchema, 'applicationstask');
+// Indexes for query optimization
+applicationsTaskSchema.index({ applicationId: 1, instanceId: 1 }); // Compound index for findByApplicationIdAndInstanceId queries
+applicationsTaskSchema.index({ applicationId: 1, createdOn: -1 }); // Compound index for findAll with sort by createdOn descending
+// Unique index to prevent duplicate tasks created by concurrent syncs (background job + frontend-triggered sync).
+// partialFilterExpression excludes internal system tasks (instanceId = "") so they are not affected by this constraint.
+applicationsTaskSchema.index({ instanceId: 1, checkflowId: 1 }, {
+    unique: true,
+    partialFilterExpression: { instanceId: { $exists: true, $ne: "" } }
+});
+const ApplicationsTaskModel = mongoose.model("ApplicationsTask", applicationsTaskSchema);
+export default ApplicationsTaskModel;