proflores-db-model 0.2.51 → 0.2.53

package/dist/types/QualityGrade.d.ts

@@ -0,0 +1,6 @@
+export declare enum QualityGrade {
+    PREMIUM = "PREMIUM",
+    STANDARD = "STANDARD",
+    ECONOMY = "ECONOMY",
+    REJECTED = "REJECTED"
+}

package/dist/types/QualityGrade.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QualityGrade = void 0;
+var QualityGrade;
+(function (QualityGrade) {
+    QualityGrade["PREMIUM"] = "PREMIUM";
+    QualityGrade["STANDARD"] = "STANDARD";
+    QualityGrade["ECONOMY"] = "ECONOMY";
+    QualityGrade["REJECTED"] = "REJECTED";
+})(QualityGrade || (exports.QualityGrade = QualityGrade = {}));

package/dist/types/index.d.ts

@@ -3,3 +3,9 @@ export { ExpenseDetailType } from "./ExpenseDetailType";
 export { ExpenseTypeType } from "./ExpenseTypeType";
 export { ProjectOrderType } from "./ProjectOrderType";
 export { MovementType } from "./MovementType";
+export { CropLotStatus } from "./CropLotStatus";
+export { GrowthStage } from "./GrowthStage";
+export { CropActivityType } from "./CropActivityType";
+export { QualityGrade } from "./QualityGrade";
+export { IncomeType } from "./IncomeType";
+export { IncomeStatus } from "./IncomeStatus";

package/dist/types/index.js

@@ -1,5 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MovementType = void 0;
+exports.IncomeStatus = exports.IncomeType = exports.QualityGrade = exports.CropActivityType = exports.GrowthStage = exports.CropLotStatus = exports.MovementType = void 0;
 var MovementType_1 = require("./MovementType");
 Object.defineProperty(exports, "MovementType", { enumerable: true, get: function () { return MovementType_1.MovementType; } });
+// Production enums
+var CropLotStatus_1 = require("./CropLotStatus");
+Object.defineProperty(exports, "CropLotStatus", { enumerable: true, get: function () { return CropLotStatus_1.CropLotStatus; } });
+var GrowthStage_1 = require("./GrowthStage");
+Object.defineProperty(exports, "GrowthStage", { enumerable: true, get: function () { return GrowthStage_1.GrowthStage; } });
+var CropActivityType_1 = require("./CropActivityType");
+Object.defineProperty(exports, "CropActivityType", { enumerable: true, get: function () { return CropActivityType_1.CropActivityType; } });
+var QualityGrade_1 = require("./QualityGrade");
+Object.defineProperty(exports, "QualityGrade", { enumerable: true, get: function () { return QualityGrade_1.QualityGrade; } });
+// Income enums
+var IncomeType_1 = require("./IncomeType");
+Object.defineProperty(exports, "IncomeType", { enumerable: true, get: function () { return IncomeType_1.IncomeType; } });
+var IncomeStatus_1 = require("./IncomeStatus");
+Object.defineProperty(exports, "IncomeStatus", { enumerable: true, get: function () { return IncomeStatus_1.IncomeStatus; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proflores-db-model",
-  "version": "0.2.51",
+  "version": "0.2.53",
   "description": "Data model for managing expenses and transactions for Proflores nursery business",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/entities/ExpenseDetail.ts

@@ -9,6 +9,9 @@ import {
 import { ExpenseTransaction } from "./ExpenseTransaction";
 import { Inventory } from "./Inventory";
 import { ProjectOrder } from "./ProjectOrder";
+import { Budget } from "../models/apu/Budget";
+import { CropLot } from "../models/production/CropLot";
+import { CropActivity } from "../models/production/CropActivity";
 
 @Entity()
 export class ExpenseDetail implements ObjectLiteral {
@@ -44,7 +47,19 @@ export class ExpenseDetail implements ObjectLiteral {
   @Column("boolean", { default: true })
   isActive!: boolean;
 
-  @ManyToOne(() => ProjectOrder, { nullable: false })
+  @ManyToOne(() => ProjectOrder, { nullable: true })
   @JoinColumn({ name: "projectId" })
   projectOrder?: ProjectOrder;
+
+  @ManyToOne(() => Budget, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idBudget" })
+  budget?: Budget | null;
+
+  @ManyToOne(() => CropLot, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idCropLot" })
+  cropLot?: CropLot | null;
+
+  @ManyToOne(() => CropActivity, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idCropActivity" })
+  cropActivity?: CropActivity | null;
 }

package/src/entities/ExpenseTransaction.ts

@@ -7,13 +7,16 @@ import {
   JoinColumn,
   OneToMany,
   ObjectLiteral,
-  OneToOne 
+  OneToOne,
+  Index,
 } from "typeorm";
 import { ExpenseType } from "./ExpenseType";
 import { ExpenseDetail } from "./ExpenseDetail";
 import { TransactionBank } from "./Bank/TransactionBank";
+import { Budget } from "../models/apu/Budget";
 
 @Entity()
+@Index(["budget"])
 export class ExpenseTransaction implements ObjectLiteral {
   @PrimaryGeneratedColumn("increment")
   expenseTransactionId!: number;
@@ -46,7 +49,14 @@ export class ExpenseTransaction implements ObjectLiteral {
   expenseDetails?: ExpenseDetail[];
 
   @OneToOne(() => TransactionBank, (transactionBank) => transactionBank.expenseTransaction, {
-    nullable: true, 
+    nullable: true,
   })
   transactionBank?: TransactionBank;
+
+  @ManyToOne(() => Budget, (budget) => budget.expenses, {
+    nullable: true,
+    onDelete: "SET NULL",
+  })
+  @JoinColumn({ name: "idBudget" })
+  budget?: Budget | null;
 }

package/src/entities/Income.ts

@@ -0,0 +1,99 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToOne,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from "typeorm";
+import { Budget } from "../models/apu/Budget";
+import { Payment } from "./Payment";
+import { CropLot } from "../models/production/CropLot";
+import { Client } from "../models/apu/Client";
+import { Inventory } from "./Inventory";
+import { TransactionBank } from "./Bank/TransactionBank";
+import { IncomeType } from "../types/IncomeType";
+import { IncomeStatus } from "../types/IncomeStatus";
+
+@Entity("incomes")
+@Index(["incomeDate"])
+@Index(["incomeType"])
+@Index(["status"])
+@Index(["budget"])
+@Index(["cropLot"])
+export class Income implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idIncome!: number;
+
+  @Column({
+    type: "enum",
+    enum: IncomeType,
+    default: IncomeType.OTHER,
+  })
+  incomeType!: IncomeType;
+
+  @Column("decimal", { precision: 14, scale: 2, nullable: false })
+  amount!: number;
+
+  @Column("date", { nullable: false })
+  incomeDate!: Date;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @Column({
+    type: "enum",
+    enum: IncomeStatus,
+    default: IncomeStatus.PENDING,
+  })
+  status!: IncomeStatus;
+
+  @ManyToOne(() => Budget, (budget) => budget.incomes, {
+    nullable: true,
+    onDelete: "SET NULL",
+  })
+  @JoinColumn({ name: "idBudget" })
+  budget?: Budget | null;
+
+  @ManyToOne(() => Payment, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idPayment" })
+  payment?: Payment | null;
+
+  @ManyToOne(() => CropLot, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idCropLot" })
+  cropLot?: CropLot | null;
+
+  @ManyToOne(() => Client, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idClient" })
+  client?: Client | null;
+
+  @ManyToOne(() => Inventory, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idInventory" })
+  inventory?: Inventory | null;
+
+  @Column("decimal", { precision: 12, scale: 4, nullable: true })
+  quantity?: number | null;
+
+  @Column("decimal", { precision: 14, scale: 4, nullable: true })
+  unitPrice?: number | null;
+
+  @Column("varchar", { length: 255, nullable: true })
+  invoiceUuid?: string | null;
+
+  @OneToOne(() => TransactionBank, { nullable: true, cascade: true })
+  @JoinColumn({ name: "idTransactionBank" })
+  transactionBank?: TransactionBank | null;
+
+  @Column("text", { nullable: true })
+  notes?: string | null;
+
+  @CreateDateColumn({ type: "timestamp" })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: "timestamp" })
+  updatedAt!: Date;
+}

package/src/entities/InventoryMovement.ts

@@ -3,6 +3,7 @@ import {
     PrimaryGeneratedColumn,
     Column,
     ManyToOne,
+    OneToOne,
     JoinColumn,
     CreateDateColumn,
     UpdateDateColumn,
@@ -10,6 +11,7 @@ import {
   } from "typeorm";
   import { Inventory } from "./Inventory";
   import { MovementType } from "../types/MovementType";
+  import { Harvest } from "../models/production/Harvest";
   @Entity("inventory_movement")
   export class InventoryMovement implements ObjectLiteral {
     @PrimaryGeneratedColumn("increment")
@@ -47,6 +49,10 @@ import {
   
     @Column("varchar", { length: 50, nullable: true })
     referenceModule?: string;
-  
+
+    @OneToOne(() => Harvest, (harvest) => harvest.inventoryMovement, {
+      nullable: true,
+    })
+    harvest?: Harvest | null;
   }
   

package/src/index.ts

@@ -21,7 +21,9 @@ export { SupplierImage } from "./entities/SupplierImage";
 export { InventoryImage } from "./entities/InventoryImage";
 export { Payment } from "./entities/Payment";
 export { PaymentCfdi } from "./entities/PaymentCfdi";
+export { Income } from "./entities/Income";
 
 export * from "./types";
 export * from "./models/technical-sheet";
 export * from "./models/apu";
+export * from "./models/production";

package/src/models/apu/Budget.ts

@@ -6,6 +6,8 @@ import { Project } from "./Project";
 import { BudgetItem } from "./BudgetItem";
 import { BudgetCancellationFolio } from "./BudgetCancellationFolio";
 import { Payment } from "../../entities/Payment";
+import { ExpenseTransaction } from "../../entities/ExpenseTransaction";
+import { Income } from "../../entities/Income";
 
 @Entity("budgets")
 @Index(["project"])
@@ -55,4 +57,10 @@ export class Budget implements ObjectLiteral {
 
   @OneToMany(() => Payment, (payment) => payment.budget)
   payments?: Payment[];
+
+  @OneToMany(() => ExpenseTransaction, (expense) => expense.budget)
+  expenses?: ExpenseTransaction[];
+
+  @OneToMany(() => Income, (income) => income.budget)
+  incomes?: Income[];
 }

package/src/models/apu/budget-snapshot.entity.ts

@@ -9,6 +9,7 @@ import { Budget } from "../apu";
 @Index(["budget"])                       // como @Index(["apu"]) en tu ApuItem
 @Index(["createdAt"])
 @Index(["pdfHash"])
+@Index(["budget", "createdAt"])
 @Check(`"total" >= 0`)
 export class BudgetSnapshot {
   @PrimaryGeneratedColumn("increment")

package/src/models/production/CropActivity.ts

@@ -0,0 +1,68 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from "typeorm";
+import { CropLot } from "./CropLot";
+import { CropActivityType } from "../../types/CropActivityType";
+import { UnitOfMeasure } from "../../entities/UnitOfMesure";
+import { CropExpense } from "./CropExpense";
+
+@Entity("crop_activities")
+@Index(["cropLot", "activityDate"])
+@Index(["activityType"])
+export class CropActivity implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idCropActivity!: number;
+
+  @ManyToOne(() => CropLot, (cropLot) => cropLot.activities, {
+    nullable: false,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "idCropLot" })
+  cropLot!: CropLot;
+
+  @Column({
+    type: "enum",
+    enum: CropActivityType,
+  })
+  activityType!: CropActivityType;
+
+  @Column("text", { nullable: false })
+  description!: string;
+
+  @Column("date", { nullable: false })
+  activityDate!: Date;
+
+  @Column("decimal", { precision: 12, scale: 4, nullable: true })
+  quantity?: number | null;
+
+  @ManyToOne(() => UnitOfMeasure, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idUnitOfMeasure" })
+  unitOfMeasure?: UnitOfMeasure | null;
+
+  @Column("decimal", { precision: 8, scale: 2, nullable: true })
+  laborHours?: number | null;
+
+  @Column("text", { nullable: true })
+  notes?: string | null;
+
+  @Column("varchar", { length: 255, nullable: true })
+  performedBy?: string | null;
+
+  @CreateDateColumn({ type: "timestamp" })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: "timestamp" })
+  updatedAt!: Date;
+
+  @OneToMany(() => CropExpense, (expense) => expense.cropActivity, { cascade: true })
+  expenses?: CropExpense[];
+}

package/src/models/production/CropExpense.ts

@@ -0,0 +1,74 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from "typeorm";
+import { CropLot } from "./CropLot";
+import { CropActivity } from "./CropActivity";
+import { ExpenseType } from "../../entities/ExpenseType";
+import { Resource } from "../apu/Resource";
+import { Inventory } from "../../entities/Inventory";
+
+@Entity("crop_expenses")
+@Index(["cropLot", "expenseDate"])
+@Index(["cropActivity"])
+export class CropExpense implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idCropExpense!: number;
+
+  @ManyToOne(() => CropLot, (cropLot) => cropLot.expenses, {
+    nullable: false,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "idCropLot" })
+  cropLot!: CropLot;
+
+  @ManyToOne(() => CropActivity, (activity) => activity.expenses, {
+    nullable: true,
+    onDelete: "SET NULL",
+  })
+  @JoinColumn({ name: "idCropActivity" })
+  cropActivity?: CropActivity | null;
+
+  @ManyToOne(() => ExpenseType, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idExpenseType" })
+  expenseType?: ExpenseType | null;
+
+  @Column("varchar", { length: 255, nullable: false })
+  concept!: string;
+
+  @Column("decimal", { precision: 14, scale: 2, nullable: false })
+  amount!: number;
+
+  @Column("decimal", { precision: 12, scale: 4, nullable: false, default: 1 })
+  quantity!: number;
+
+  @Column("decimal", { precision: 14, scale: 4, nullable: false })
+  unitPrice!: number;
+
+  @Column("date", { nullable: false })
+  expenseDate!: Date;
+
+  @ManyToOne(() => Resource, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idResource" })
+  resource?: Resource | null;
+
+  @ManyToOne(() => Inventory, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idInventory" })
+  inventory?: Inventory | null;
+
+  @Column("text", { nullable: true })
+  notes?: string | null;
+
+  @CreateDateColumn({ type: "timestamp" })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: "timestamp" })
+  updatedAt!: Date;
+}

package/src/models/production/CropLot.ts

@@ -0,0 +1,106 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from "typeorm";
+import { GrowthArea } from "./GrowthArea";
+import { ProductionSeason } from "./ProductionSeason";
+import { PlantTechnicalSheet } from "../technical-sheet/PlantTechnicalSheet";
+import { CropLotStatus } from "../../types/CropLotStatus";
+import { CropStage } from "./CropStage";
+import { CropActivity } from "./CropActivity";
+import { CropExpense } from "./CropExpense";
+import { Harvest } from "./Harvest";
+
+@Entity("crop_lots")
+@Index(["code"], { unique: true })
+@Index(["growthArea"])
+@Index(["season"])
+@Index(["status"])
+export class CropLot implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idCropLot!: number;
+
+  @Column("varchar", { length: 64, nullable: false, unique: true })
+  code!: string;
+
+  @Column("varchar", { length: 255, nullable: false })
+  name!: string;
+
+  @ManyToOne(() => GrowthArea, (area) => area.cropLots, {
+    nullable: false,
+    onDelete: "RESTRICT",
+  })
+  @JoinColumn({ name: "idGrowthArea" })
+  growthArea!: GrowthArea;
+
+  @ManyToOne(() => ProductionSeason, (season) => season.cropLots, {
+    nullable: false,
+    onDelete: "RESTRICT",
+  })
+  @JoinColumn({ name: "idSeason" })
+  season!: ProductionSeason;
+
+  @ManyToOne(() => PlantTechnicalSheet, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idPlantTechnicalSheet" })
+  plantTechnicalSheet?: PlantTechnicalSheet | null;
+
+  @Column("decimal", { precision: 12, scale: 2, nullable: false, default: 0 })
+  quantity!: number;
+
+  @Column("decimal", { precision: 12, scale: 2, nullable: true })
+  expectedYield?: number | null;
+
+  @Column("decimal", { precision: 12, scale: 2, nullable: true })
+  actualYield?: number | null;
+
+  @Column("decimal", { precision: 14, scale: 4, nullable: true })
+  unitCost?: number | null;
+
+  @Column("decimal", { precision: 14, scale: 2, nullable: true })
+  totalCost?: number | null;
+
+  @Column({
+    type: "enum",
+    enum: CropLotStatus,
+    default: CropLotStatus.PLANNED,
+  })
+  status!: CropLotStatus;
+
+  @Column("date", { nullable: false })
+  sowingDate!: Date;
+
+  @Column("date", { nullable: true })
+  expectedHarvestDate?: Date | null;
+
+  @Column("date", { nullable: true })
+  actualHarvestDate?: Date | null;
+
+  @Column("text", { nullable: true })
+  notes?: string | null;
+
+  @CreateDateColumn({ type: "timestamp" })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: "timestamp" })
+  updatedAt!: Date;
+
+  @OneToMany(() => CropStage, (stage) => stage.cropLot, { cascade: true })
+  stages?: CropStage[];
+
+  @OneToMany(() => CropActivity, (activity) => activity.cropLot, { cascade: true })
+  activities?: CropActivity[];
+
+  @OneToMany(() => CropExpense, (expense) => expense.cropLot, { cascade: true })
+  expenses?: CropExpense[];
+
+  @OneToMany(() => Harvest, (harvest) => harvest.cropLot, { cascade: true })
+  harvests?: Harvest[];
+}

package/src/models/production/CropStage.ts

@@ -0,0 +1,45 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+} from "typeorm";
+import { CropLot } from "./CropLot";
+import { GrowthStage } from "../../types/GrowthStage";
+import { CropStageImage } from "./CropStageImage";
+
+@Entity("crop_stages")
+@Index(["cropLot", "stage"])
+export class CropStage implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idCropStage!: number;
+
+  @ManyToOne(() => CropLot, (cropLot) => cropLot.stages, {
+    nullable: false,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "idCropLot" })
+  cropLot!: CropLot;
+
+  @Column({
+    type: "enum",
+    enum: GrowthStage,
+  })
+  stage!: GrowthStage;
+
+  @Column("date", { nullable: false })
+  startDate!: Date;
+
+  @Column("date", { nullable: true })
+  endDate?: Date | null;
+
+  @Column("text", { nullable: true })
+  notes?: string | null;
+
+  @OneToMany(() => CropStageImage, (image) => image.cropStage, { cascade: true })
+  images?: CropStageImage[];
+}

package/src/models/production/CropStageImage.ts

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  JoinColumn,
+  ObjectLiteral,
+  CreateDateColumn,
+} from "typeorm";
+import { CropStage } from "./CropStage";
+
+@Entity("crop_stage_images")
+export class CropStageImage implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idCropStageImage!: number;
+
+  @ManyToOne(() => CropStage, (stage) => stage.images, {
+    nullable: false,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "idCropStage" })
+  cropStage!: CropStage;
+
+  @Column("varchar", { length: 512, nullable: false })
+  imageUrl!: string;
+
+  @Column("varchar", { length: 255, nullable: true })
+  caption?: string | null;
+
+  @CreateDateColumn({ type: "timestamp" })
+  createdAt!: Date;
+}

package/src/models/production/GrowthArea.ts

@@ -0,0 +1,41 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+  ObjectLiteral,
+  Index,
+} from "typeorm";
+import { Branch } from "../../entities/Branches";
+import { CropLot } from "./CropLot";
+
+@Entity("growth_areas")
+@Index(["code"], { unique: true })
+export class GrowthArea implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idGrowthArea!: number;
+
+  @Column("varchar", { length: 255, nullable: false })
+  name!: string;
+
+  @Column("varchar", { length: 64, nullable: false, unique: true })
+  code!: string;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @Column("decimal", { precision: 10, scale: 2, nullable: true })
+  capacity?: number | null;
+
+  @ManyToOne(() => Branch, { nullable: true, onDelete: "SET NULL" })
+  @JoinColumn({ name: "idBranch" })
+  branch?: Branch | null;
+
+  @Column("boolean", { default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => CropLot, (cropLot) => cropLot.growthArea)
+  cropLots?: CropLot[];
+}