@dynamatix/gb-schemas 2.0.24 → 2.0.26

package/dist/properties/property.model.js

@@ -1,144 +0,0 @@
-import mongoose from 'mongoose';
-import { Pound } from '../value-objects/pound';
-const propertySchema = new mongoose.Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application",
-        description: "Unique identifier for the application",
-        required: true
-    },
-    pageValidFlag: {
-        type: Boolean,
-        default: true,
-        description: "Flag indicating if the page is valid",
-    },
-    propertyId: {
-        type: String,
-        required: true,
-        unique: true,
-        description: "Unique identifier for the property"
-    },
-    addressLine1: {
-        type: String,
-        required: true,
-        maxLength: 35,
-        description: "First line of the property address"
-    },
-    addressLine2: {
-        type: String,
-        required: false,
-        maxLength: 35,
-        description: "Second line of the property address"
-    },
-    addressLine3: {
-        type: String,
-        required: false,
-        maxLength: 35,
-        description: "Third line of the property address"
-    },
-    associatedLoanPartiesIds: {
-        type: [mongoose.Schema.Types.ObjectId],
-        required: false,
-        description: "List of associated loan parties (either applicant or company)"
-    },
-    city: {
-        type: String,
-        required: false,
-        maxLength: 30,
-        description: "City where the property is located"
-    },
-    countryLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Lookup',
-        required: true,
-        description: "Country where the property is located",
-    },
-    lender: {
-        type: String,
-        required: true,
-        maxLength: 35,
-        description: "Lender providing the loan for the property"
-    },
-    marketValue: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The market value of the property",
-    },
-    monthlyRent: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The monthly rent value of the property"
-    },
-    monthlyRepayment: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The monthly repayment value for the property"
-    },
-    originalLoanBalance: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The original loan balance for the property"
-    },
-    outstandingBalance: {
-        type: Pound,
-        required: true,
-        default: 0.00,
-        description: "The remaining outstanding balance of the property loan"
-    },
-    otherOwnershipParties: {
-        type: String,
-        required: false,
-        maxLength: 500,
-        description: "Other parties that own the property"
-    },
-    postCode: {
-        type: String,
-        required: true,
-        maxLength: 50,
-        description: "The postCode for the property"
-    },
-    remainingTerm: {
-        type: Number,
-        required: true,
-        max: 4,
-        description: "The remaining term of the loan in years"
-    },
-    portfolioFile: {
-        type: String,
-        required: false,
-        description: "File containing the portfolio details"
-    }
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-propertySchema.virtual('country').get(function () {
-    return this.countryLid instanceof mongoose.Types.ObjectId ? null : this.countryLid?.name || null;
-});
-propertySchema.virtual('stressedRCR').get(function () {
-    const monthlyRentValue = this.monthlyRent ? parseFloat(this.monthlyRent.toString()) : 0.00;
-    const monthlyRepaymentValue = this.monthlyRepayment ? parseFloat(this.monthlyRepayment.toString()) : 0.00;
-    // Avoid division by zero
-    if (monthlyRepaymentValue === 0) {
-        return '0.00'; // Return 0.00 if monthlyRepayment is zero
-    }
-    const stressedRCR = (monthlyRentValue / monthlyRepaymentValue) * 100;
-    return stressedRCR.toFixed(2);
-});
-// virtual property 'applicationType'
-propertySchema.virtual('applicationType').get(function () {
-    return this.applicationId?.applicationTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.applicationTypeLid?.name || null;
-});
-// virtual property 'lendingType'
-propertySchema.virtual('lendingType').get(function () {
-    return this.applicationId?.lendingTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationId?.lendingTypeLid?.name || null;
-});
-const PropertyModel = mongoose.model('Property', propertySchema);
-export default PropertyModel;

package/dist/shared/alert.model.js

@@ -1,24 +0,0 @@
-import mongoose from "mongoose";
-const alertSchema = new mongoose.Schema({
-    alertTypeLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup"
-    },
-    applicationId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Application",
-        required: true
-    },
-    alertMessage: { type: String },
-    documentId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Document",
-    },
-    statusLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup"
-    },
-    isActive: { type: String, default: true },
-}, { timestamps: true });
-const AlertModel = mongoose.model("Alert", alertSchema);
-export default AlertModel;

package/dist/shared/apprivo-sync-journey.model.js

@@ -1,17 +0,0 @@
-import mongoose from "mongoose";
-const ApprivoSyncJourneySchema = new mongoose.Schema({
-    applicationId: { type: String, required: true },
-    milestoneLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    mileStoneStatus: {
-        type: String,
-        enum: ['Completed', 'Errored', 'Not Applicable'],
-        required: true
-    },
-    error: { type: String, default: null },
-    isFirstPull: { type: String, required: true },
-    jobRunId: { type: mongoose.Schema.Types.ObjectId, ref: "Job_Run" },
-    startTime: { type: Date, default: null },
-    endTime: { type: Date, default: null },
-}, { timestamps: true });
-const ApprivoSyncJourneyModel = mongoose.model('ApprivoSyncJourney', ApprivoSyncJourneySchema);
-export default ApprivoSyncJourneyModel;

package/dist/shared/checklist.model.js

@@ -1,30 +0,0 @@
-import mongoose from "mongoose";
-const checklistSchema = new mongoose.Schema({
-    checkTypeLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        required: true
-    },
-    source: {
-        type: String,
-        required: true
-    },
-    sourceId: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: false
-    },
-    applicationId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Application",
-        required: true
-    },
-    checkDescription: { type: String },
-    checkStatusLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        required: true
-    }
-}, { timestamps: true });
-checklistSchema.index({ checkDescription: 'text', source: 'text' });
-const CheckListModel = mongoose.model("CheckList", checklistSchema);
-export default CheckListModel;

package/dist/shared/document-type-model.js

@@ -1,10 +0,0 @@
-import mongoose from "mongoose";
-const DocumentTypeSchema = new mongoose.Schema({
-    name: { type: String, required: true },
-    label: { type: String },
-    source: { type: String, default: null },
-    parentDocumentTypeId: { type: mongoose.Schema.Types.ObjectId, ref: 'DocumentType', default: null },
-    matchRules: { type: mongoose.Schema.Types.Mixed }
-});
-const DocumentTypeModel = mongoose.model('DocumentType', DocumentTypeSchema);
-export default DocumentTypeModel;

package/dist/shared/index.js

@@ -1,12 +0,0 @@
-export { default as LookupGroupModel } from './lookup-group.model';
-export { default as LookupModel } from './lookup.model';
-export { default as SystemParameterModel } from './system-parameter.model';
-export { default as AlertModel } from './alert.model';
-export { default as CheckListModel } from './checklist.model';
-export { default as JobSettingModel } from './job-setting.model';
-export { default as TaskModel } from './task.model';
-export { default as ApprivoSyncJourneyModel } from './apprivo-sync-journey.model';
-export { default as JobRunModel } from './job-run.model';
-export { default as TaskDocumentTypeModel } from './task-document.model';
-export { default as DocumentTypeModel } from './document-type-model';
-export { default as SchemaDocModel } from './schema-doc.model';

package/dist/shared/job-run.model.js

@@ -1,14 +0,0 @@
-import mongoose, { Schema } from "mongoose";
-const jobRunSchema = new Schema({
-    jobName: { type: String, required: true },
-    status: {
-        type: String,
-        enum: ['Running', 'Completed', 'Errored'],
-        required: true
-    },
-    error: { type: String, default: null },
-    startTime: { type: Date, default: null },
-    endTime: { type: Date, default: null }
-});
-const JobRunModel = mongoose.model('Job_Run', jobRunSchema);
-export default JobRunModel;

package/dist/shared/job-setting.model.js

@@ -1,11 +0,0 @@
-import mongoose from "mongoose";
-const jobSettingSchema = new mongoose.Schema({
-    name: { type: String, required: true },
-    isActive: { type: String, default: true },
-    frequency: {
-        type: String, default: '2 hours'
-    },
-    jobParams: { type: [mongoose.Schema.Types.Mixed] }
-});
-const JobSettingModel = mongoose.model("Job_Setting", jobSettingSchema);
-export default JobSettingModel;

package/dist/shared/lookup-group.model.js

@@ -1,16 +0,0 @@
-import mongoose from "mongoose";
-const lookupGroupSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required: true,
-        unique: true,
-    },
-    lookups: [
-        {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: "Lookup", // References the Lookup collection
-        },
-    ],
-});
-const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
-export default LookupGroupModel;

package/dist/shared/lookup.model.js

@@ -1,20 +0,0 @@
-import mongoose from "mongoose";
-const lookupSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required: true
-    },
-    text: {
-        type: String,
-        required: true
-    },
-    lookupGroupId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "LookupGroup", // References the LookupGroup collection
-    },
-    value: {
-        type: String
-    }
-});
-const LookupModel = mongoose.model('Lookup', lookupSchema);
-export default LookupModel;

package/dist/shared/system-parameter.model.js

@@ -1,32 +0,0 @@
-import mongoose from "mongoose";
-const systemParameterSchema = new mongoose.Schema({
-    parameterName: {
-        type: String,
-        required: true,
-    },
-    parameterValue: {
-        type: mongoose.Schema.Types.Mixed,
-        required: true,
-    },
-    notes: {
-        type: String,
-    },
-    createdByUserId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User',
-        required: true,
-    },
-    createdOn: {
-        type: Date,
-        default: Date.now,
-    },
-    updatedByUserId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User',
-    },
-    updatedOn: {
-        type: Date,
-    },
-});
-const SystemParameterModel = mongoose.model('SystemParameter', systemParameterSchema);
-export default SystemParameterModel;

package/dist/shared/task-document.model.js

@@ -1,23 +0,0 @@
-import mongoose from 'mongoose';
-// Define the schema for TaskDocumentType
-const taskDocumentTypeSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required: true,
-    },
-    value: {
-        type: String,
-        required: true,
-    },
-    parentDocumentTypeId: {
-        type: mongoose.Schema.Types.ObjectId,
-        default: null, // Null for parent categories
-    },
-    source: {
-        type: String,
-        required: true,
-        enum: ['applicant', 'application'], // Only allow these two values
-    },
-});
-const TaskDocumentTypeModel = mongoose.model('TaskDocumentType', taskDocumentTypeSchema);
-export default TaskDocumentTypeModel;

package/dist/shared/task.model.js

@@ -1,15 +0,0 @@
-import mongoose from "mongoose";
-const { Schema } = mongoose;
-const actionSchema = new Schema({
-    type: { type: String, required: true }, // Type of the action
-    message: { type: String, required: false },
-    target: { type: String, required: false },
-});
-const taskSchema = new Schema({
-    name: { type: String, required: true },
-    description: { type: String, required: true },
-    actionsOnFailure: { type: [actionSchema], default: [] },
-    actionsOnSuccess: { type: [actionSchema], default: [] },
-}, { timestamps: true });
-const TaskModel = mongoose.model("Task", taskSchema);
-export default TaskModel;

package/dist/underwriter/index.js

@@ -1 +0,0 @@
-export { default as UnderwriterModel } from './underwriter.model';

package/dist/underwriter/underwriter.model.js

@@ -1,17 +0,0 @@
-import mongoose from "mongoose";
-const underwriterSchema = new mongoose.Schema({
-    fullName: { type: String, required: true },
-    mandateLevel: { type: Number, required: true },
-    underwriterId: { type: Number, required: true },
-    totalBTLCaseCount: { type: Number, required: true },
-    btlPreOfferCaseCount: { type: Number, required: true },
-    btlPostOfferCaseCount: { type: Number, required: true },
-    totalBridgingCaseCount: { type: Number, required: true },
-    bridgingPreOfferCaseCount: { type: Number, required: true },
-    bridgingPostOfferCaseCount: { type: Number, required: true },
-    bridgingMandateLevel: { type: Number, required: true }
-}, {
-    timestamps: true
-});
-const UnderwriterModel = mongoose.model('Underwriter', underwriterSchema);
-export default UnderwriterModel;

package/dist/users/auth-log.model.js

@@ -1,21 +0,0 @@
-import mongoose from "mongoose";
-const AuthLogSchema = new mongoose.Schema({
-    userEmail: {
-        type: String,
-        required: true
-    },
-    loggedInTimestamp: {
-        type: Date,
-        default: Date.now
-    },
-    isSuccess: {
-        type: Boolean,
-        required: true
-    },
-    activity: {
-        type: String,
-        enum: ["LOGIN", "LOGOUT", "PASSWORD_RESET"]
-    }
-});
-const AuthLogModel = mongoose.model("AuthLog", AuthLogSchema);
-export default AuthLogModel;

package/dist/users/index.js

@@ -1,6 +0,0 @@
-export { default as UserModel } from './user.model';
-export { default as RoleModel } from './role.model';
-export { default as RoleGroupModel } from './role-group.model';
-export { default as PermissionModel } from './permission.model';
-export { default as TasksModel } from './tasks.model';
-export { default as AuthLogModel } from './auth-log.model';

package/dist/users/permission.model.js

@@ -1,10 +0,0 @@
-import mongoose from "mongoose";
-const permissionSchema = new mongoose.Schema({
-    name: { type: String, required: true },
-    controllerName: { type: String, required: true },
-    methodName: { type: String, required: true }
-}, {
-    timestamps: true
-});
-const PermissionModel = mongoose.model('Permission', permissionSchema);
-export default PermissionModel;

package/dist/users/role-group.model.js

@@ -1,14 +0,0 @@
-import mongoose from "mongoose";
-const RoleGroupSchema = new mongoose.Schema({
-    groupId: { type: String, required: true },
-    name: { type: String, required: true },
-    description: { type: String },
-    roles: [{
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Role'
-        }]
-}, {
-    timestamps: true
-});
-const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
-export default RoleGroupModel;

package/dist/users/role.model.js

@@ -1,13 +0,0 @@
-import mongoose from "mongoose";
-const RoleSchema = new mongoose.Schema({
-    roleId: { type: String, required: true },
-    name: { type: String, required: true },
-    description: { type: String },
-    permissions: [{
-            type: mongoose.Schema.Types.ObjectId, ref: 'Permission'
-        }]
-}, {
-    timestamps: true
-});
-const RoleModel = mongoose.model('Role', RoleSchema);
-export default RoleModel;

package/dist/users/tasks.model.js

@@ -1,15 +0,0 @@
-import mongoose from "mongoose";
-const TasksSchema = new mongoose.Schema({
-    taskTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskType ["Document", "Information"]
-    actionTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // Example: "Request Document Delete"
-    entityId: { type: mongoose.Schema.Types.ObjectId, required: true }, // Could be documentId, applicationId, applicantId
-    createdByUserId: { ref: "User", type: mongoose.Schema.Types.ObjectId, required: true },
-    assignedToUserId: { ref: "User", type: mongoose.Schema.Types.ObjectId, required: true },
-    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskStatus ["Requested", "Completed", "Cancelled"]
-    priorityLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null }, // LookupGroup: TaskPriority ["High", "Medium", "Low"]
-    expiryDate: { type: Date, required: true },
-}, {
-    timestamps: true
-});
-const TasksModel = mongoose.model("Tasks", TasksSchema);
-export default TasksModel;

package/dist/users/user.model.js

@@ -1,30 +0,0 @@
-import mongoose from "mongoose";
-const ClaimSchema = new mongoose.Schema({
-    key: { type: String, required: true },
-    value: { type: String, required: true }
-});
-const userSchema = new mongoose.Schema({
-    accountId: { type: String, required: true },
-    email: { type: String, required: true },
-    fullName: { type: String, required: true },
-    password: { type: String, required: true },
-    organisationId: { type: mongoose.Schema.Types.Mixed },
-    status: { type: String, required: true },
-    groups: [{
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'RoleGroup'
-        }],
-    claims: [ClaimSchema],
-    externalData: { type: mongoose.Schema.Types.Mixed },
-    modifiedOn: { type: String },
-    modifiedById: { type: String },
-    createdOnInApprivo: { type: String },
-    createdById: { type: String },
-    deletedOn: { type: String },
-    deletedById: { type: String },
-    token: { type: String }
-}, {
-    timestamps: true
-});
-const UserModel = mongoose.model('User', userSchema);
-export default UserModel;