@nutrien-br/liborgs 1.0.0

package/src/infra/models/schFinancial/CreditAnalysisResult.ts

@@ -0,0 +1,82 @@
+import {
+  CreationOptional,
+  DataTypes,
+  Model,
+  Sequelize,
+  NonAttribute
+} from "sequelize";
+import { CreditAnalysisResultEntity, CreateCreditAnalysisResultEntity } from "src/core/entity/schFinancial/CreditAnalysisResultSchema";
+import { Solicitation, CreditSource } from "../initModels";
+
+export class CreditAnalysisResult extends Model<
+  CreditAnalysisResultEntity,
+  CreateCreditAnalysisResultEntity
+> {
+  declare careId: CreationOptional<number>;
+  declare careExternalId: string;
+  declare careRequestedLimit: number | null;
+  declare careApprovedLimit: number | null;
+  declare careDateSolicitation: CreationOptional<Date>;
+  declare careResponseDate: Date | null;
+  declare careResponse: CreationOptional<boolean>;
+  declare careRequestId: string;
+  declare soliId: number;
+  declare csrcId: number;
+
+  declare solicitation?: NonAttribute<Solicitation>;
+  declare creditSource?: NonAttribute<CreditSource>;
+
+  init(sequelize: Sequelize): void {
+    CreditAnalysisResult.init({
+      careId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+      },
+      careExternalId: {
+        type: DataTypes.STRING(255),
+        allowNull: false,
+      },
+      careRequestedLimit: {
+        type: DataTypes.DECIMAL(15, 2),
+      },
+      careApprovedLimit: {
+        type: DataTypes.DECIMAL(15, 2),
+      },
+      careDateSolicitation: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+      },
+      careResponseDate: {
+        type: DataTypes.DATE,
+      },
+      careResponse: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+      },
+      careRequestId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+      },
+      soliId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+      },
+      csrcId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+      }
+    }, {
+      sequelize,
+      tableName: 'credit_analysis_result',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    CreditAnalysisResult.belongsTo(Solicitation, { foreignKey: 'soliId', as: 'solicitation' });
+    CreditAnalysisResult.belongsTo(CreditSource, { foreignKey: 'csrcId', as: 'creditSource' });
+  }
+}

package/src/infra/models/schFinancial/CreditSource.ts

@@ -0,0 +1,46 @@
+import { CreationOptional, DataTypes, Model, NonAttribute, Sequelize } from "sequelize";
+import { CreateCreditSourceEntity, CreditSourceEntity } from "src/core/entity/CreditSourceSchema";
+import { CreditSourceLimitHistory } from "./CreditSourceLimitHistory";
+import { CreditAnalysisResult } from "./CreditAnalysisResult";
+
+export class CreditSource extends Model<CreditSourceEntity, CreateCreditSourceEntity> {
+  declare csrcId: CreationOptional<number>;
+  declare csrcName: string;
+  declare csrcType: 'PARTNER' | 'IN_HOUSE';
+
+  declare limitHistories?: NonAttribute<CreditSourceLimitHistory[]>;
+  declare analysisResults?: NonAttribute<CreditAnalysisResult[]>;
+
+  init(sequelize: Sequelize): void {
+    CreditSource.init({
+      csrcId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      csrcName: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      csrcType: {
+        type: DataTypes.ENUM('PARTNER', 'IN_HOUSE'),
+        allowNull: false,
+      }
+    }, {
+      sequelize,
+      tableName: 'credit_start',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    })
+  }
+
+  associate(): void {
+    CreditSource.hasMany(CreditSourceLimitHistory, {
+      foreignKey: 'csrcId',
+      as: 'limitHistories'
+    });
+    CreditSource.hasMany(CreditAnalysisResult, { foreignKey: 'csrcId', as: 'analysisResults' });
+  }
+}

package/src/infra/models/schFinancial/CreditSourceLimitHistory.ts

@@ -0,0 +1,91 @@
+import {
+  CreationOptional,
+  DataTypes,
+  Model,
+  Sequelize,
+  InferAttributes,
+  InferCreationAttributes,
+  NonAttribute
+} from "sequelize";
+import { CreditSourceLimitHistoryEntity, CreateCreditSourceLimitHistoryEntity } from "src/core/entity/schFinancial/CreditSourceLimitHistorySchema";
+import { Person, Company, CreditSource } from "../initModels";
+
+export class CreditSourceLimitHistory extends Model<
+  CreditSourceLimitHistoryEntity,
+  CreateCreditSourceLimitHistoryEntity
+> {
+  declare cslhId: CreationOptional<number>;
+  declare csrcId: number;
+  declare persId: number | null;
+  declare compId: number | null;
+  declare cslhTotalLimit: number;
+  declare cslhUsedLimit: number;
+  declare cslhAvailableLimit: CreationOptional<number>;
+  declare cslhReferenceDate: Date;
+  declare cslhCreatedAt: CreationOptional<Date>;
+
+  declare person?: NonAttribute<Person>;
+  declare company?: NonAttribute<Company>;
+  declare creditSource?: NonAttribute<CreditSource>;
+
+  init(sequelize: Sequelize): void {
+    CreditSourceLimitHistory.init({
+      cslhId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+      },
+      csrcId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+      },
+      persId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: 'person', schema: 'sch_orgs' }, key: 'pers_id' }
+      },
+      compId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: { model: { tableName: 'company', schema: 'sch_orgs' }, key: 'comp_id' }
+      },
+      cslhTotalLimit: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      cslhUsedLimit: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      cslhAvailableLimit: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+        // set() { throw new Error('cslhAvailableLimit is a read-only generated column'); }
+      },
+      cslhReferenceDate: {
+        type: DataTypes.DATEONLY,
+        allowNull: false,
+      },
+      cslhCreatedAt: {
+        type: DataTypes.DATE,
+        defaultValue: DataTypes.NOW,
+      }
+    }, {
+      sequelize,
+      tableName: 'credit_source_limit_history',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    CreditSourceLimitHistory.belongsTo(Person, { foreignKey: 'persId', as: 'person' });
+    CreditSourceLimitHistory.belongsTo(Company, { foreignKey: 'compId', as: 'company' });
+    CreditSourceLimitHistory.belongsTo(CreditSource, {
+      foreignKey: 'csrcId',
+      as: 'creditSource',
+      onDelete: 'CASCADE'
+    });
+  }
+}

package/src/infra/models/schFinancial/RateRules.ts

@@ -0,0 +1,45 @@
+import { CreationOptional, DataTypes, Model, Sequelize, InferAttributes, InferCreationAttributes } from "sequelize";
+import { CreateRateRulesEntity, RateRulesEntity } from "src/core/entity/schFinancial/RateRulesSchema";
+
+export class RateRules extends Model<RateRulesEntity, CreateRateRulesEntity> {
+  declare raruId: CreationOptional<number>;
+  declare raruVersion: CreationOptional<number>;
+  declare raruRating: string;
+  declare raruInHousePercentage: number;
+  declare raruPartnerPercentage: number;
+
+  init(sequelize: Sequelize): void {
+    RateRules.init({
+      raruId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      raruVersion: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+      },
+      raruRating: {
+        type: DataTypes.STRING(2),
+        allowNull: false,
+      },
+      raruInHousePercentage: {
+        type: DataTypes.DECIMAL(5, 2),
+        allowNull: false,
+      },
+      raruPartnerPercentage: {
+        type: DataTypes.DECIMAL(5, 2),
+        allowNull: false,
+      }
+    }, {
+      sequelize,
+      tableName: 'rate_rules',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void { }
+}

package/src/infra/models/schFinancial/Solicitation.ts

@@ -0,0 +1,91 @@
+import { CreationOptional, DataTypes, Model, NonAttribute, Sequelize } from "sequelize";
+import { CreateSolicitationEntity, SolicitationEntity } from "src/core/entity/schFinancial/SolicitationSchema";
+import { Person, Company, SolicitationRevenue } from "../initModels";
+import { SolicitationRate } from "./SolicitationRate";
+import { SolicitationNf } from "./SolicitationNf";
+import { CreditAnalysisResult } from "./CreditAnalysisResult";
+
+export class Solicitation extends Model<SolicitationEntity, CreateSolicitationEntity> {
+  declare soliId: CreationOptional<number>;
+  declare soliRequestedLimit: number;
+  declare soliCompleted: boolean;
+  declare persId: CreationOptional<number>;
+  declare compId: CreationOptional<number>;
+
+  declare person?: NonAttribute<Person>
+  declare company?: NonAttribute<Company>
+  declare rates?: NonAttribute<SolicitationRate[]>
+  declare revenues?: NonAttribute<SolicitationRevenue[]>
+  declare nfs?: NonAttribute<SolicitationNf[]>
+  declare analysisResults?: NonAttribute<CreditAnalysisResult[]>;
+
+  init(sequelize: Sequelize): void {
+    Solicitation.init({
+      soliId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      soliRequestedLimit: {
+        type: DataTypes.NUMBER,
+        allowNull: false,
+      },
+      soliCompleted: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false,
+      },
+      persId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+          model: {
+            tableName: 'person',
+            schema: 'sch_orgs'
+          },
+          key: 'pers_id'
+        }
+      },
+      compId: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        references: {
+          model: {
+            tableName: 'company',
+            schema: 'sch_orgs'
+          },
+          key: 'comp_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'solicitation',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    })
+  }
+
+  associate(): void {
+    Solicitation.belongsTo(Person, {
+      foreignKey: 'persId',
+      as: 'person'
+    });
+
+    Solicitation.belongsTo(Company, {
+      foreignKey: 'compId',
+      as: 'company'
+    });
+    Solicitation.hasMany(SolicitationRate, {
+      foreignKey: 'soliId',
+      as: 'rates'
+    });
+    Solicitation.hasMany(SolicitationRevenue, {
+      foreignKey: 'soliId',
+      as: 'revenues'
+    });
+    Solicitation.hasMany(SolicitationNf, { foreignKey: 'soliId', as: 'nfs' });
+    Solicitation.hasMany(CreditAnalysisResult, { foreignKey: 'soliId', as: 'analysisResults' });
+  }
+}

package/src/infra/models/schFinancial/SolicitationNf.ts

@@ -0,0 +1,74 @@
+import {
+  CreationOptional,
+  DataTypes,
+  Model,
+  Sequelize,
+  InferAttributes,
+  InferCreationAttributes,
+  NonAttribute
+} from "sequelize";
+import { CreateSolicitationNfEntity, SolicitationNfEntity } from "src/core/entity/schFinancial/SolicitationNfSchema";
+import { Solicitation } from "./Solicitation";
+
+export class SolicitationNf extends Model<
+  SolicitationNfEntity,
+  CreateSolicitationNfEntity
+> {
+  declare sonfId: CreationOptional<number>;
+  declare sonfSumNf: number | null;
+  declare sonfCompleted: CreationOptional<boolean>;
+  declare sonfRequestId: string;
+  declare soliId: number;
+
+  declare solicitation?: NonAttribute<Solicitation>;
+
+  init(sequelize: Sequelize): void {
+    SolicitationNf.init({
+      sonfId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      sonfSumNf: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+      },
+      sonfCompleted: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false,
+      },
+      sonfRequestId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+      },
+      soliId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: 'solicitation',
+            schema: 'sch_financial'
+          },
+          key: 'soli_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'solicitation_nf',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    SolicitationNf.belongsTo(Solicitation, {
+      foreignKey: 'soliId',
+      as: 'solicitation',
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE'
+    });
+  }
+}

package/src/infra/models/schFinancial/SolicitationRate.ts

@@ -0,0 +1,72 @@
+import { CreationOptional, DataTypes, Model, NonAttribute, Sequelize } from "sequelize";
+import { CreateSolicitationRateEntity, SolicitationRateEntity } from "src/core/entity/schFinancial/SolicitationRateSchema";
+import { Solicitation } from "./Solicitation";
+
+export class SolicitationRate extends Model<SolicitationRateEntity, CreateSolicitationRateEntity> {
+  declare soraId: CreationOptional<number>;
+  declare soraRating: CreationOptional<string>;
+  declare soraInHousePercentage: number;
+  declare soraPartnerPercentage: number;
+  declare soraInHouseAllocation: number;
+  declare soraPartnerAllocation: number;
+  declare soliId: number;
+
+  declare solicitation?: NonAttribute<Solicitation>;
+
+  init(sequelize: Sequelize): void {
+    SolicitationRate.init({
+      soraId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      soraRating: {
+        type: DataTypes.STRING(2),
+        allowNull: true,
+      },
+      soraInHousePercentage: {
+        type: DataTypes.DECIMAL(5, 2),
+        allowNull: false,
+      },
+      soraPartnerPercentage: {
+        type: DataTypes.DECIMAL(5, 2),
+        allowNull: false,
+      },
+      soraInHouseAllocation: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      soraPartnerAllocation: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: false,
+      },
+      soliId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: 'solicitation',
+            schema: 'sch_financial'
+          },
+          key: 'soli_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'solicitation_rate',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    SolicitationRate.belongsTo(Solicitation, {
+      foreignKey: 'soliId',
+      as: 'solicitation',
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE'
+    });
+  }
+}

package/src/infra/models/schFinancial/SolicitationRevenue.ts

@@ -0,0 +1,72 @@
+import {
+  CreationOptional,
+  DataTypes,
+  Model,
+  Sequelize,
+  NonAttribute
+} from "sequelize";
+import { Solicitation } from "./Solicitation";
+import { CreateSolicitationRevenueEntity, SolicitationRevenueEntity } from "src/core/entity/schFinancial/SolicitationRevenueSchema";
+
+export class SolicitationRevenue extends Model<
+  SolicitationRevenueEntity,
+  CreateSolicitationRevenueEntity
+> {
+  declare soreId: CreationOptional<number>;
+  declare soreRevenue: number | null;
+  declare soreCompleted: CreationOptional<boolean>;
+  declare soreRequestId: string;
+  declare soliId: number;
+
+  declare solicitation?: NonAttribute<Solicitation>;
+
+  init(sequelize: Sequelize): void {
+    SolicitationRevenue.init({
+      soreId: {
+        type: DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+        allowNull: false,
+      },
+      soreRevenue: {
+        type: DataTypes.DECIMAL(15, 2),
+        allowNull: true,
+      },
+      soreCompleted: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        allowNull: false,
+      },
+      soreRequestId: {
+        type: DataTypes.UUID,
+        allowNull: false,
+      },
+      soliId: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        references: {
+          model: {
+            tableName: 'solicitation',
+            schema: 'sch_financial'
+          },
+          key: 'soli_id'
+        }
+      }
+    }, {
+      sequelize,
+      tableName: 'solicitation_revenue',
+      schema: process.env.NODE_ENV === 'test' ? undefined : 'sch_financial',
+      underscored: true,
+      timestamps: false
+    });
+  }
+
+  associate(): void {
+    SolicitationRevenue.belongsTo(Solicitation, {
+      foreignKey: 'soliId',
+      as: 'solicitation',
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE'
+    });
+  }
+}

package/src/infra/models/schFinancial/__tests__/creditSource.spec.ts

@@ -0,0 +1,20 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { CreditSource } from '../CreditSource'
+
+describe('CreditSource Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of CreditSource', async () => {
+      const creditSources = await CreditSource.findAll()
+      expect(creditSources[0].csrcName).toBe('FARM')
+    })
+  })
+})

package/src/infra/models/schFinancial/__tests__/creditSourceLimitHistory.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { Solicitation } from '../Solicitation'
+import { SolicitationRate } from "../SolicitationRate";
+import { CreditSource, CreditSourceLimitHistory, Person, RateRules } from "../../initModels";
+
+describe('CreditSourceLimitHistory Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of CreditSourceLimitHistory', async () => {
+      const creditSourceLimitHistories = await CreditSourceLimitHistory.findAll()
+      expect(creditSourceLimitHistories[0].cslhId).toBe(1)
+    })
+  })
+
+  describe('When findOne is called', () => {
+    it('should return one with relationship', async () => {
+      const creditSourceLimitHistory = await CreditSourceLimitHistory.findOne({
+        where: { cslhId: 1 },
+        include: [
+          { model: CreditSource, as: 'creditSource' },
+          { model: Person, as: 'person' }
+        ]
+      })
+
+      expect(creditSourceLimitHistory?.cslhTotalLimit).toBe(4000)
+      expect(creditSourceLimitHistory?.person?.persId).toBe(1)
+    })
+  })
+})

package/src/infra/models/schFinancial/__tests__/rateRules.spec.ts

@@ -0,0 +1,37 @@
+import { describe, it, afterEach, beforeEach, expect } from "vitest";
+import { initMock, closeMock } from '../../../../utils/initMock'
+import { Solicitation } from '../Solicitation'
+import { SolicitationRate } from "../SolicitationRate";
+import { Person, RateRules } from "../../initModels";
+
+describe('RateRules Model', () => {
+  beforeEach(async () => {
+    await initMock()
+  })
+
+  afterEach(async () => {
+    await closeMock()
+  })
+
+  describe('When findAll is called', () => {
+    it('should return a list of Rules', async () => {
+      const solicitations = await RateRules.findAll()
+      expect(solicitations[0].raruRating).toBe('A')
+    })
+  })
+
+  describe('When findOne is called', () => {
+    it('should return one with relationship', async () => {
+      const solicitation = await Solicitation.findOne({
+        where: { soliId: 1 },
+        include: [
+          { model: SolicitationRate, as: 'rates' },
+          { model: Person, as: 'person' }
+        ]
+      })
+      expect(solicitation?.soliId).toBe(1)
+      expect(solicitation?.rates?.[0]?.soraRating).toBe('A');
+      expect(solicitation?.person?.persId).toBe(1)
+    })
+  })
+})