@kipicore/dbcore 1.1.631 → 1.1.632

package/dist/models/psql/accountTaxEntryModel.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountTaxEntryModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountTaxTypeModel, AccountJournalLineModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountTaxEntryModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountTaxEntryModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountTaxTypeModel) {
+            AccountTaxEntryModel.belongsTo(AccountTaxTypeModel, { foreignKey: 'taxTypeId', as: 'taxType' });
+        }
+        if (AccountJournalLineModel) {
+            AccountTaxEntryModel.belongsTo(AccountJournalLineModel, { foreignKey: 'journalLineId', as: 'journalLine' });
+        }
+        if (UserModel) {
+            AccountTaxEntryModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountTaxEntryModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountTaxEntryModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountTaxEntryModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    taxTypeId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'tax_type_id',
+    },
+    journalLineId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_line_id',
+    },
+    taxAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'tax_amount',
+    },
+    baseAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        field: 'base_amount',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountTaxEntryModel',
+    tableName: 'account_tax_entries',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountTaxEntryModel;

package/dist/models/psql/accountTaxTypeModel.d.ts

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize';
+import { IAccountTaxTypeModelAttributes } from '../../interfaces/accountTaxTypeInterface';
+import { TAccountTaxTypeModelCreationAttributes } from '../../types/accountTaxTypeType';
+import { AccountTaxKind } from '../../constants/app';
+declare class AccountTaxTypeModel extends Model<IAccountTaxTypeModelAttributes, TAccountTaxTypeModelCreationAttributes> implements IAccountTaxTypeModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    code: string;
+    name: string;
+    taxKind: AccountTaxKind;
+    rate: number;
+    inputLedgerId?: string;
+    outputLedgerId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountTaxTypeModel;

package/dist/models/psql/accountTaxTypeModel.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountTaxTypeModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountLedgerModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountTaxTypeModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountTaxTypeModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountLedgerModel) {
+            AccountTaxTypeModel.belongsTo(AccountLedgerModel, { foreignKey: 'inputLedgerId', as: 'inputLedger' });
+            AccountTaxTypeModel.belongsTo(AccountLedgerModel, { foreignKey: 'outputLedgerId', as: 'outputLedger' });
+        }
+        if (UserModel) {
+            AccountTaxTypeModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountTaxTypeModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountTaxTypeModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountTaxTypeModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    code: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'code',
+    },
+    name: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'name',
+    },
+    taxKind: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'tax_kind',
+    },
+    rate: {
+        type: sequelize_1.DataTypes.DECIMAL(5, 2),
+        allowNull: true,
+        field: 'rate',
+    },
+    inputLedgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'input_ledger_id',
+    },
+    outputLedgerId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'output_ledger_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountTaxTypeModel',
+    tableName: 'account_tax_types',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountTaxTypeModel;

package/dist/models/psql/accountVendorInvoiceModel.d.ts

@@ -0,0 +1,28 @@
+import { Model } from 'sequelize';
+import { IAccountVendorInvoiceModelAttributes } from '../../interfaces/accountVendorInvoiceInterface';
+import { TAccountVendorInvoiceModelCreationAttributes } from '../../types/accountVendorInvoiceType';
+import { AccountApprovalStatus, AccountExpensePaymentStatus } from '../../constants/app';
+declare class AccountVendorInvoiceModel extends Model<IAccountVendorInvoiceModelAttributes, TAccountVendorInvoiceModelCreationAttributes> implements IAccountVendorInvoiceModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    vendorId?: string;
+    invoiceNumber: string;
+    invoiceDate: Date;
+    dueDate?: Date;
+    totalAmount: number;
+    taxAmount: number;
+    netAmount: number;
+    status: AccountApprovalStatus;
+    paymentStatus: AccountExpensePaymentStatus;
+    fileStorageId?: string;
+    journalEntryId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountVendorInvoiceModel;

package/dist/models/psql/accountVendorInvoiceModel.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+class AccountVendorInvoiceModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountJournalEntryModel, UserModel, FileStorageModel } = models;
+        if (InstituteModel) {
+            AccountVendorInvoiceModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountVendorInvoiceModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountVendorInvoiceModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (FileStorageModel) {
+            AccountVendorInvoiceModel.belongsTo(FileStorageModel, { foreignKey: 'fileStorageId', as: 'fileStorage' });
+        }
+        if (UserModel) {
+            AccountVendorInvoiceModel.belongsTo(UserModel, { foreignKey: { name: 'vendorId', allowNull: true, field: 'vendor_id' }, as: 'vendor' });
+            AccountVendorInvoiceModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountVendorInvoiceModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountVendorInvoiceModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountVendorInvoiceModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    vendorId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'vendor_id',
+    },
+    invoiceNumber: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'invoice_number',
+    },
+    invoiceDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'invoice_date',
+    },
+    dueDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'due_date',
+    },
+    totalAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'total_amount',
+    },
+    taxAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'tax_amount',
+    },
+    netAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'net_amount',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        defaultValue: app_1.AccountApprovalStatus.PENDING,
+    },
+    paymentStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'payment_status',
+        defaultValue: app_1.AccountExpensePaymentStatus.PENDING,
+    },
+    fileStorageId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'file_storage_id',
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountVendorInvoiceModel',
+    tableName: 'account_vendor_invoices',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountVendorInvoiceModel;

package/dist/models/psql/accountVendorPaymentModel.d.ts

@@ -0,0 +1,25 @@
+import { Model } from 'sequelize';
+import { IAccountVendorPaymentModelAttributes } from '../../interfaces/accountVendorPaymentInterface';
+import { TAccountVendorPaymentModelCreationAttributes } from '../../types/accountVendorPaymentType';
+import { AccountPaymentMode } from '../../constants/app';
+declare class AccountVendorPaymentModel extends Model<IAccountVendorPaymentModelAttributes, TAccountVendorPaymentModelCreationAttributes> implements IAccountVendorPaymentModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    vendorId?: string;
+    invoiceId: string;
+    bankAccountId?: string;
+    paymentMode: AccountPaymentMode;
+    paidAmount: number;
+    paidDate: Date;
+    voucherId?: string;
+    journalEntryId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountVendorPaymentModel;

package/dist/models/psql/accountVendorPaymentModel.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountVendorPaymentModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountVendorInvoiceModel, AccountVoucherModel, AccountJournalEntryModel, UserModel } = models;
+        if (InstituteModel) {
+            AccountVendorPaymentModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountVendorPaymentModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountVendorInvoiceModel) {
+            AccountVendorPaymentModel.belongsTo(AccountVendorInvoiceModel, { foreignKey: 'invoiceId', as: 'invoice' });
+        }
+        if (AccountVoucherModel) {
+            AccountVendorPaymentModel.belongsTo(AccountVoucherModel, { foreignKey: 'voucherId', as: 'voucher' });
+        }
+        if (AccountJournalEntryModel) {
+            AccountVendorPaymentModel.belongsTo(AccountJournalEntryModel, { foreignKey: 'journalEntryId', as: 'journalEntry' });
+        }
+        if (UserModel) {
+            AccountVendorPaymentModel.belongsTo(UserModel, { foreignKey: { name: 'vendorId', allowNull: true, field: 'vendor_id' }, as: 'vendor' });
+            AccountVendorPaymentModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountVendorPaymentModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountVendorPaymentModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountVendorPaymentModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    vendorId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'vendor_id',
+    },
+    invoiceId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'invoice_id',
+    },
+    bankAccountId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'bank_account_id',
+    },
+    paymentMode: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'payment_mode',
+    },
+    paidAmount: {
+        type: sequelize_1.DataTypes.DECIMAL(10, 2),
+        allowNull: true,
+        field: 'paid_amount',
+    },
+    paidDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'paid_date',
+    },
+    voucherId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'voucher_id',
+    },
+    journalEntryId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'journal_entry_id',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountVendorPaymentModel',
+    tableName: 'account_vendor_payments',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountVendorPaymentModel;

package/dist/models/psql/accountVoucherModel.d.ts

@@ -0,0 +1,28 @@
+import { Model } from 'sequelize';
+import { IAccountVoucherModelAttributes } from '../../interfaces/accountVoucherInterface';
+import { TAccountVoucherModelCreationAttributes } from '../../types/accountVoucherType';
+import { AccountSourceModule, AccountApprovalStatus, AccountVoucherStatus } from '../../constants/app';
+declare class AccountVoucherModel extends Model<IAccountVoucherModelAttributes, TAccountVoucherModelCreationAttributes> {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    voucherTypeId: string;
+    voucherNumber: string;
+    voucherDate: Date;
+    financialYearId: string;
+    sourceModule?: AccountSourceModule;
+    sourceId?: string;
+    referenceNumber?: string;
+    narration?: string;
+    approvalStatus: AccountApprovalStatus;
+    status: AccountVoucherStatus;
+    reversedVoucherId?: string;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountVoucherModel;

package/dist/models/psql/accountVoucherModel.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+const app_1 = require("../../constants/app");
+class AccountVoucherModel extends sequelize_1.Model {
+    static associate(models) {
+        const { AccountVoucherTypeModel, AccountFinancialYearModel, InstituteModel, AcademicCalendarModel } = models;
+        if (AccountVoucherTypeModel) {
+            AccountVoucherModel.belongsTo(AccountVoucherTypeModel, { foreignKey: 'voucherTypeId', as: 'voucherType' });
+        }
+        if (AccountFinancialYearModel) {
+            AccountVoucherModel.belongsTo(AccountFinancialYearModel, { foreignKey: 'financialYearId', as: 'financialYear' });
+        }
+        if (InstituteModel) {
+            AccountVoucherModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountVoucherModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        // Self-referential for reversed voucher
+        AccountVoucherModel.belongsTo(AccountVoucherModel, { foreignKey: 'reversedVoucherId', as: 'reversedVoucher' });
+        // Journal entries (hasMany) will be added when JournalEntryModel is created.
+        const { UserModel } = models;
+        if (UserModel) {
+            AccountVoucherModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountVoucherModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountVoucherModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountVoucherModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    voucherTypeId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'voucher_type_id',
+    },
+    voucherNumber: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'voucher_number',
+    },
+    voucherDate: {
+        type: sequelize_1.DataTypes.DATEONLY,
+        allowNull: true,
+        field: 'voucher_date',
+    },
+    financialYearId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'financial_year_id',
+    },
+    sourceModule: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_module',
+    },
+    sourceId: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'source_id',
+    },
+    referenceNumber: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'reference_number',
+    },
+    narration: {
+        type: sequelize_1.DataTypes.TEXT,
+        allowNull: true,
+    },
+    approvalStatus: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        defaultValue: app_1.AccountApprovalStatus.PENDING,
+        field: 'approval_status',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        defaultValue: app_1.AccountVoucherStatus.DRAFT,
+    },
+    reversedVoucherId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'reversed_voucher_id',
+    },
+}, {
+    modelName: 'AccountVoucherModel',
+    tableName: 'account_vouchers',
+    timestamps: true,
+    paranoid: true,
+    sequelize: index_1.sequelize,
+});
+exports.default = AccountVoucherModel;

package/dist/models/psql/accountWebhookDeliveryModel.d.ts

@@ -0,0 +1,24 @@
+import { Model } from 'sequelize';
+import { IAccountWebhookDeliveryModelAttributes } from '../../interfaces/accountWebhookDeliveryInterface';
+import { TAccountWebhookDeliveryModelCreationAttributes } from '../../types/accountWebhookDeliveryType';
+import { AccountWebhookDeliveryStatus } from '../../constants/app';
+declare class AccountWebhookDeliveryModel extends Model<IAccountWebhookDeliveryModelAttributes, TAccountWebhookDeliveryModelCreationAttributes> implements IAccountWebhookDeliveryModelAttributes {
+    id: string;
+    instituteId: string;
+    academicCalendarId: string;
+    subscriptionId: string;
+    eventId: string;
+    status: AccountWebhookDeliveryStatus;
+    attempts: number;
+    lastError?: string;
+    requestRef?: any;
+    responseRef?: any;
+    createdBy?: string;
+    updatedBy?: string;
+    deletedBy?: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly deletedAt?: Date;
+    static associate(models: any): void;
+}
+export default AccountWebhookDeliveryModel;

package/dist/models/psql/accountWebhookDeliveryModel.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_1 = require("./index");
+class AccountWebhookDeliveryModel extends sequelize_1.Model {
+    static associate(models) {
+        const { InstituteModel, AcademicCalendarModel, AccountWebhookSubscriptionModel, UserModel, } = models;
+        if (InstituteModel) {
+            AccountWebhookDeliveryModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'institute' });
+        }
+        if (AcademicCalendarModel) {
+            AccountWebhookDeliveryModel.belongsTo(AcademicCalendarModel, { foreignKey: 'academicCalendarId', as: 'academicCalendar' });
+        }
+        if (AccountWebhookSubscriptionModel) {
+            AccountWebhookDeliveryModel.belongsTo(AccountWebhookSubscriptionModel, { foreignKey: 'subscriptionId', as: 'subscription' });
+        }
+        if (UserModel) {
+            AccountWebhookDeliveryModel.belongsTo(UserModel, { foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' }, as: 'createdByUser' });
+            AccountWebhookDeliveryModel.belongsTo(UserModel, { foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' }, as: 'updatedByUser' });
+            AccountWebhookDeliveryModel.belongsTo(UserModel, { foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' }, as: 'deletedByUser' });
+        }
+    }
+}
+AccountWebhookDeliveryModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        primaryKey: true,
+        allowNull: false,
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'institute_id',
+    },
+    academicCalendarId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'academic_calendar_id',
+    },
+    subscriptionId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'subscription_id',
+    },
+    eventId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: true,
+        field: 'event_id',
+    },
+    status: {
+        type: sequelize_1.DataTypes.STRING,
+        allowNull: true,
+        field: 'status',
+    },
+    attempts: {
+        type: sequelize_1.DataTypes.INTEGER,
+        allowNull: true,
+        field: 'attempts',
+        defaultValue: 0,
+    },
+    lastError: {
+        type: sequelize_1.DataTypes.TEXT,
+        allowNull: true,
+        field: 'last_error',
+    },
+    requestRef: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'request_ref',
+    },
+    responseRef: {
+        type: sequelize_1.DataTypes.JSONB,
+        allowNull: true,
+        field: 'response_ref',
+    },
+}, {
+    sequelize: index_1.sequelize,
+    modelName: 'AccountWebhookDeliveryModel',
+    tableName: 'account_webhook_deliveries',
+    timestamps: true,
+    paranoid: true,
+});
+exports.default = AccountWebhookDeliveryModel;