@procxo/shared 1.0.2 → 1.0.4

package/src/database/entities/invoice_item.entity.ts

@@ -0,0 +1,69 @@
+// ivm-api-core/src/modules/invoice/entities/invoice-item.entity.ts
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Invoice } from './invoice.entity';
+import { CreditNoteEntity } from './credit-note.entity';
+
+export enum InvoiceItemType {
+  TASK = 'task',
+  EXPENSE = 'expense',
+  SUMMARY = 'summary',
+  TIMESHEET_EVENT = 'timesheet_event',
+  FIXED_ITEM = 'fixed_item',
+}
+
+@Entity({ name: 'invoice_items', schema: 'core' })
+@Index('idx_invoice_items_invoice_id', ['invoiceId'])
+@Index('idx_invoice_items_item', ['itemType', 'itemId'])
+export class InvoiceItem extends BaseEntity {
+  @Column({ name: 'invoice_id' })
+  invoiceId: number;
+
+  @Column({ 
+    name: 'item_type', 
+    type: 'enum', 
+    enum: InvoiceItemType 
+  })
+  itemType: InvoiceItemType;
+
+  @Column({ name: 'item_id' })
+  itemId: number;
+
+  @Column({ 
+    type: 'decimal', 
+    precision: 10, 
+    scale: 2,
+    name: 'amount'
+  })
+  amount: number;
+
+  @Column({ type: 'decimal', name: 'credit_amount', nullable: true })
+  credit_amount: number | null;
+
+  @Column({ type: 'decimal', name: 'balance_amount', nullable: true })
+  balance_amount: number | null;
+
+  @Column({ type: 'int', name: 'credit_note_id', nullable: true })
+  credit_note_id: number | null;
+
+  @ManyToOne(() => CreditNoteEntity, (creditNote) => creditNote.invoiceItems)
+  @JoinColumn({ name: 'credit_note_id' })
+  creditNote: CreditNoteEntity;
+
+  // Relationships
+  @ManyToOne(() => Invoice, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'invoice_id' })
+  invoice: Invoice;
+
+//   @ManyToOne(() => Task, { nullable: true, onDelete: 'CASCADE' })
+//   @JoinColumn({ name: 'item_id' })
+//   task?: Task;
+
+//   @ManyToOne(() => Expense, { nullable: true, onDelete: 'CASCADE' })
+//   @JoinColumn({ name: 'item_id' })
+//   expense?: Expense;
+
+//   @ManyToOne(() => TimesheetSummary, { nullable: true, onDelete: 'CASCADE' })
+//   @JoinColumn({ name: 'item_id' })
+//   summary?: TimesheetSummary;
+}

package/src/database/entities/leave-balance.entity.ts

@@ -0,0 +1,118 @@
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+import { LeaveType } from './leave-type.entity';
+import { Entitlement } from './entitlement.entity';
+
+export enum CreditFrequency {
+  MONTHLY = 'monthly',
+  QUARTERLY = 'quarterly',
+  HALF_YEARLY = 'half_yearly',
+  YEARLY = 'yearly',
+}
+
+@Entity({ name: 'leave_balances', schema: 'user' })
+@Index(['userId', 'leaveTypeId', 'entitlementId'], { unique: true })
+export class LeaveBalance extends BaseEntity {
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({ name: 'leave_type_id' })
+  leaveTypeId: number;
+
+  @Column({ name: 'entitlement_id' })
+  entitlementId: number;
+
+  @Column({ name: 'total_entitled', type: 'decimal', precision: 10, scale: 2, default: 0 })
+  totalEntitled: number;
+
+  @Column({ name: 'balance', type: 'decimal', precision: 10, scale: 2, default: 0 })
+  balance: number;
+
+  @Column({ name: 'used_balance', type: 'decimal', precision: 10, scale: 2, default: 0 })
+  usedBalance: number;
+
+  @Column({ name: 'pending_balance', type: 'decimal', precision: 10, scale: 2, default: 0 })
+  pendingBalance: number;
+
+  @Column({ name: 'carried_forward', type: 'decimal', precision: 10, scale: 2, default: 0 })
+  carriedForward: number;
+
+  @Column({ name: 'accrual_rate', type: 'decimal', precision: 10, scale: 4 })
+  accrualRate: number; // entitlements/12 for monthly accrual
+
+  @Column({ name: 'credit_frequency', type: 'enum', enum: CreditFrequency, default: CreditFrequency.MONTHLY })
+  creditFrequency: CreditFrequency;
+
+  @Column({ name: 'last_credited_date', type: 'date', nullable: true })
+  lastCreditedDate: Date;
+
+  @Column({ name: 'next_credit_date', type: 'date' })
+  nextCreditDate: Date;
+
+  @Column({ name: 'policy_start_date', type: 'date' })
+  policyStartDate: Date;
+
+  @Column({ name: 'policy_end_date', type: 'date' })
+  policyEndDate: Date;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+
+  @Column({ name: 'cron_enabled', default: true })
+  cronEnabled: boolean;
+
+  @Column({ name: 'last_cron_run', type: 'timestamp', nullable: true })
+  lastCronRun: Date;
+
+  // Relationships
+  @ManyToOne(() => User, user => user.id)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => LeaveType, leaveType => leaveType.id)
+  @JoinColumn({ name: 'leave_type_id' })
+  leaveType: LeaveType;
+
+  @ManyToOne(() => Entitlement, entitlement => entitlement.id)
+  @JoinColumn({ name: 'entitlement_id' })
+  entitlement: Entitlement;
+
+  // Helper methods
+  calculateAvailableBalance(): number {
+    return this.balance - this.usedBalance - this.pendingBalance;
+  }
+
+  canTakeLeave(requestedDays: number): boolean {
+    return this.calculateAvailableBalance() >= requestedDays;
+  }
+
+  creditLeave(amount: number): void {
+    this.balance = Number((Number(this.balance) + Number(amount)).toFixed(2));
+    this.lastCreditedDate = new Date();
+    this.calculateNextCreditDate();
+  }
+
+  debitLeave(amount: number): void {
+    this.usedBalance += amount;
+  }
+
+  private calculateNextCreditDate(): void {
+    const currentDate = new Date();
+    switch (this.creditFrequency) {
+      case CreditFrequency.MONTHLY:
+        this.nextCreditDate = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 1);
+        break;
+      case CreditFrequency.QUARTERLY:
+        this.nextCreditDate = new Date(currentDate.getFullYear(), currentDate.getMonth() + 3, 1);
+        break;
+      case CreditFrequency.HALF_YEARLY:
+        this.nextCreditDate = new Date(currentDate.getFullYear(), currentDate.getMonth() + 6, 1);
+        break;
+      case CreditFrequency.YEARLY:
+        this.nextCreditDate = new Date(currentDate.getFullYear() + 1, currentDate.getMonth(), 1);
+        break;
+    }
+  }
+} 

package/src/database/entities/leave-request.entity.ts

@@ -0,0 +1,155 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+import { LeaveType } from './leave-type.entity';
+import { LeaveBalance } from './leave-balance.entity';
+import { BaseEntity } from './base.entity';
+
+export enum LeaveRequestStatus {
+  PENDING = 'pending',
+  APPROVED = 'approved',
+  REJECTED = 'rejected',
+  CANCELLED = 'cancelled',
+  CANCELATION_REQUESTED = 'cancelation_requested',
+}
+
+export enum DaysType {
+  FULL_DAY = 'full_day',
+  FIRST_HALF = 'first_half',
+  SECOND_HALF = 'second_half',
+}
+
+export enum HalfDayPosition {
+  START_DATE = 'start_date',
+  END_DATE = 'end_date',
+  NONE = 'none',
+}
+
+export enum ApprovalFlowType {
+  REPORTING_MANAGER_BASED = 'REPORTING_MANAGER_BASED',
+  HIERARCHY_BASED='HIERARCHY_BASED'
+}
+
+@Entity({ name: 'leave_requests', schema: 'user' })
+export class LeaveRequest extends BaseEntity {
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({ name: 'leave_type_id' })
+  leaveTypeId: number;
+
+  @Column({ name: 'leave_balance_id', nullable: true })
+  leaveBalanceId: number;
+
+  @Column({ type: 'date', name: 'start_date' })
+  startDate: Date;
+
+  @Column({ type: 'date', name: 'end_date' })
+  endDate: Date;
+
+  @Column({ type: 'enum', enum: DaysType, name: 'start_date_type', default: DaysType.FULL_DAY })
+  startDateType: DaysType;
+
+  @Column({ type: 'enum', enum: DaysType, name: 'end_date_type', default: DaysType.FULL_DAY })
+  endDateType: DaysType;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2, name: 'total_days' })
+  totalDays: number;
+
+  @Column({ type: 'enum', enum: DaysType, name: 'days_type', default: DaysType.FULL_DAY })
+  daysType: DaysType;
+
+  @Column({ type: 'varchar', length: 500, name: 'reason', nullable: true })
+  reason: string;
+
+  @Column({ type: 'varchar', length: 500, name: 'cancel_reason', nullable: true })
+  cancelReason: string;
+
+  @Column({ type: 'enum', enum: LeaveRequestStatus, name: 'status', default: LeaveRequestStatus.PENDING })
+  status: LeaveRequestStatus;
+
+  @Column({ name: 'approver_id', nullable: true })
+  approverId: number;
+
+  @Column({ type: 'varchar', length: 500, name: 'remarks', nullable: true })
+  remarks: string;
+
+  @Column({ name: 'attachment_url', nullable: true })
+  attachmentUrl: string;
+
+  @Column({ name: 'attachment_preview_url', nullable: true })
+  attachmentPreviewUrl: string;
+
+  @Column({ type: 'varchar', length: 500, name: 'reject_reason', nullable: true })
+  rejectReason: string;
+
+  @Column({ type: 'timestamp', name: 'applied_at', default: () => 'CURRENT_TIMESTAMP' })
+  appliedAt: Date;
+
+  @Column({ type: 'timestamp', name: 'approved_at', nullable: true })
+  approvedAt: Date;
+
+  @Column({ type: 'timestamp', name: 'cancelled_at', nullable: true })
+  cancelledAt: Date;
+
+  @Column({ type: 'timestamp', name: 'cancelation_requested_at', nullable: true })
+  cancelationRequestedAt: Date;
+
+  @Column({ type: 'timestamp', name: 'rejected_at', nullable: true })
+  rejectedAt: Date;
+
+  @Column({ type: 'boolean', name: 'is_balance_debited', default: false })
+  isBalanceDebited: boolean;
+
+  @Column({ type: 'enum', enum: HalfDayPosition, name: 'half_day_position', default: HalfDayPosition.NONE })
+  halfDayPosition: HalfDayPosition;
+
+  @Column({ type: 'enum', enum: ApprovalFlowType, name: 'approval_flow_type', nullable: true })
+  approvalFlowType: ApprovalFlowType | null;
+
+  // Relationships
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => LeaveType, leaveType => leaveType.leaveRequests)
+  @JoinColumn({ name: 'leave_type_id' })
+  leaveType: LeaveType;
+
+  @ManyToOne(() => LeaveBalance)
+  @JoinColumn({ name: 'leave_balance_id' })
+  leaveBalance: LeaveBalance;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'approver_id' })
+  approver: User;
+
+  // Helper methods
+  isPending(): boolean {
+    return this.status === LeaveRequestStatus.PENDING;
+  }
+
+  isApproved(): boolean {
+    return this.status === LeaveRequestStatus.APPROVED;
+  }
+
+  isRejected(): boolean {
+    return this.status === LeaveRequestStatus.REJECTED;
+  }
+
+  isCancelled(): boolean {
+    return this.status === LeaveRequestStatus.CANCELLED;
+  }
+
+  canBeApproved(): boolean {
+    return this.status === LeaveRequestStatus.PENDING;
+  }
+
+  canBeRejected(): boolean {
+    return this.status === LeaveRequestStatus.PENDING;
+  }
+
+  canBeCancelled(): boolean {
+    return this.status === LeaveRequestStatus.PENDING || this.status === LeaveRequestStatus.APPROVED;
+  }
+} 

package/src/database/entities/leave-type.entity.ts

@@ -0,0 +1,37 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { LeaveRequest } from './leave-request.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'leave_types', schema: 'user' })
+export class LeaveType extends BaseEntity{
+
+  @Column({ unique: true, name: 'name', nullable: true })
+  name: string;
+
+  @Column({ name: 'leave_type_slug', nullable: true })
+  leaveTypeSlug: string;
+  
+  @Column({ unique: true, name: 'code', nullable: true })
+  code: string;
+
+  @Column({ name: 'description', nullable: true })
+  description: string;
+
+  @Column({ default: true, name: 'is_active', nullable: true })
+  isActive: boolean;
+
+  @Column({ type: 'boolean', name: 'is_entitlement_situational', default: false, nullable: true })
+  isEntitlementSituational: boolean;
+
+  @Column({ type: 'varchar', length: 20, name: 'entitlement_frequency', nullable:true })
+  entitlementFrequency: string|null;
+
+  @Column({ type: 'int', name: 'no_of_leaves', nullable: true })
+  noOfLeaves: number;
+
+  @Column({ type: 'boolean', name: 'allow_carry_forward', default: false, nullable: true })
+  allowCarryForward: boolean;
+
+  @OneToMany(() => LeaveRequest, leaveRequest => leaveRequest.leaveType)
+  leaveRequests: LeaveRequest[];
+} 

package/src/database/entities/matter-tag.entity.ts

@@ -0,0 +1,21 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { Matter } from './matter.entity';
+import { BaseEntity } from './base.entity';
+import { Tag } from './tag.entity';
+
+@Entity({ name: 'matters_tags', schema: 'core' })
+export class MatterTag extends BaseEntity {
+  @Column({ name: 'matterId' })
+  matterId: number;
+
+  @Column({ name: 'tagId' })
+  tagId: number;
+
+  @ManyToOne(() => Matter, matter => matter.mattersLabel)
+  @JoinColumn({ name: 'matterId' })
+  matter: Matter;
+
+  @ManyToOne(() => Tag, tag => tag.mattersLabel)
+  @JoinColumn({ name: 'tagId' })
+  tag: Tag;
+} 

package/src/database/entities/matter-task-view-filter.entity.ts

@@ -0,0 +1,21 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+export enum VIEW_TYPE{
+  KANBAN_VIEW = 'kanban_view',
+  LIST_VIEW = 'list_view',
+}
+
+@Entity({ name: 'matter_task_view_filters', schema: 'core' })
+@Index(['userId'], { unique: true })
+export class MatterTaskViewFilter extends BaseEntity {
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({ name: 'view_type', length: 100, nullable: false })
+  viewType: VIEW_TYPE;
+
+  @Column({ name: 'filters', type: 'jsonb', nullable: true })
+  filters: any;
+}
+

package/src/database/entities/matter-team-member.entity.ts

@@ -0,0 +1,30 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { Matter } from './matter.entity';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'matter_team_members', schema: 'core' })
+export class MatterTeamMember extends BaseEntity{
+  @Column({ name: 'matter_id' })
+  matterId: number;
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({
+    name: 'hourly_rate',
+    type: 'numeric',    
+    precision: 10,     
+    scale: 2,          
+    nullable: true,
+  })
+  hourlyRate: number | null;
+
+  @ManyToOne(() => Matter, matter => matter.teamMembers)
+  @JoinColumn({ name: 'matter_id' })
+  matter: Matter;
+
+  @ManyToOne(() => User, user => user.teamMembers)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+} 

package/src/database/entities/matter.entity.ts

@@ -0,0 +1,156 @@
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Client } from './client.entity';
+import { Task } from './task.entity';
+import { MatterTeamMember } from './matter-team-member.entity';
+import { MatterTag } from './matter-tag.entity';
+import { Template } from './template.entity';
+import { Invoice } from './invoice.entity';
+import { User } from './user.entity';
+import { TimesheetEvent } from './timesheet-event.entity';
+import { Expense } from './expense.entity';
+import { Currency } from './currency.entity';
+
+export enum ApprovalStatus {
+  PENDING_APPROVAL = 'pending_approval',
+  APPROVED = 'approved',
+  REJECTED = 'rejected',
+  AUTO_REJECTED = 'auto_rejected',
+}
+
+export enum OvertimeFeeType {
+  HOURLY_RATE = 'hourly_rate',
+  FIXED_RATE = 'fixed_rate',
+}
+@Entity({ name: 'matters', schema: 'core' })
+export class Matter extends BaseEntity {
+  @Column({ name: 'client_id' })
+  clientId: number;
+
+  @Column({ length: 200 })
+  title: string;
+
+  @Column('text', { array: true, name: 'billing_mode' })
+  billingMode: string[];
+
+  @Column({ type: 'decimal', precision: 10, scale: 2, name: 'standard_fee' })
+  standardFee: number;
+
+  @Column({ name: 'overtime_fee_type', nullable: true })
+  overtimeFeeType: OvertimeFeeType;
+
+  @Column({
+    type: 'decimal',
+    precision: 10,
+    scale: 2,
+    name: 'overtime_fixed_rate',
+    nullable: true,
+  })
+  overtimeFixedRate: number;
+
+  @Column({
+    type: 'decimal',
+    precision: 10,
+    scale: 2,
+    name: 'overtime_hourly_rate',
+    nullable: true,
+  })
+  overtimeHourlyRate: number;
+
+  @Column({ type: 'timestamp', name: 'startDate', nullable: true })
+  startDate: Date;
+
+  @Column({ type: 'timestamp', name: 'dueDate', nullable: true })
+  dueDate: Date;
+
+  @Column({ name: 'departmentId', nullable: true })
+  departmentId: number;
+
+  @Column({ name: 'userId', nullable: true })
+  userId: number;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'userId' })
+  user: User;
+
+  @Column({ type: 'text', nullable: true })
+  notes: string;
+
+  @Column({ name: 'created_for', nullable: true })
+  createdFor: number;
+
+  @Column({ name: 'templateId', nullable: true })
+  templateId: number | null;
+
+  @Column({ name: 'fileId', nullable: true })
+  fileId: number;
+
+  @Column({ length: 20, nullable: true })
+  status: string;
+
+  @Column({ length: 20, nullable: true })
+  reason_for_matter: string;
+
+  @Column({ name: 'approval_status', nullable: true, enum: ApprovalStatus })
+  approvalStatus: ApprovalStatus;
+
+  @Column({ name: 'reject_reason', nullable: true })
+  rejectReason: string;
+
+  @Column({ length: 10, nullable: true })
+  priority: string;
+
+  @Column({ length: 10, nullable: true })
+  riskLevel: string;
+
+  @Column({ name: 'elId', nullable: true })
+  elId: number;
+
+  @Column({ name: 'signatureId', nullable: true })
+  signatureId: number;
+
+  @Column({ nullable: true })
+  progress: number;
+
+  @Column({ type: 'jsonb', nullable: true })
+  flowaceData: any;
+
+  @Column({ name: 'currency_id', nullable: true })
+  currencyId: number | null;
+
+  @Column({ name: 'is_archived', default: false })
+  isArchived: boolean;
+
+  @ManyToOne(() => Client)
+  @JoinColumn({ name: 'client_id' })
+  client: Client;
+
+  @Column({ name: 'partnerId', nullable: true })
+  partnerId: number;
+
+  @ManyToOne(() => Template)
+  @JoinColumn({ name: 'templateId' })
+  template: Template;
+
+  @OneToMany(() => MatterTeamMember, (teamMember) => teamMember.matter)
+  teamMembers: MatterTeamMember[];
+
+  @OneToMany(() => Task, (task) => task.matter)
+  tasks: Task[];
+
+  @OneToMany(() => MatterTag, (matterTag) => matterTag.matter)
+  mattersLabel: MatterTag[];
+
+  @OneToMany(() => Expense, (expense) => expense.matter)
+  expenses: Expense[];
+
+  @OneToMany(() => Invoice, (invoice) => invoice.matter)
+  invoices: Invoice[];
+
+  @ManyToOne(() => Currency, (currency) => currency.matters)
+  @JoinColumn({ name: 'currency_id' })
+  currency: Currency;
+
+  @OneToMany(() => TimesheetEvent, (timesheetEvent) => timesheetEvent.matter)
+  timesheetEvents: TimesheetEvent[];
+}

package/src/database/entities/payment.entity.ts

@@ -0,0 +1,72 @@
+import { Entity, Column, ManyToOne, JoinColumn, Check } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Invoice } from './invoice.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'payments', schema: 'core'})
+@Check(`payment_mode IN ('Bank Transfer', 'Card', 'Cash', 'Cheque')`)
+@Check(`payment_status IN ('Partially Paid', 'Full Payment', 'Overdue', 'Cancelled', 'Refunded')`)
+export class Payment extends BaseEntity {
+    @Column({ name: 'invoice_id', type: 'integer' })
+    invoiceId: number;
+
+    @Column({ name: 'amount', type: 'decimal', precision: 10, scale: 2, nullable: true })
+    amount: number;
+
+    @Column({ name: 'payment_date', type: 'timestamp' })
+    paymentDate: Date;
+
+    @Column({ name: 'confirmed_by', type: 'integer', nullable: true })
+    confirmedBy: number;
+
+    @Column({ name: 'transaction_reference_number', type: 'varchar', length: 255, nullable: true })
+    transactionReferenceNumber: string;
+
+    @Column({ name: 'account_holder_name', type: 'varchar', length: 255, nullable: true })
+    accountHolderName: string;
+
+    @Column({ name: 'account_number', type: 'varchar', length: 255, nullable: true })
+    accountNumber: string;
+
+    @Column({ name: 'received_amount', type: 'decimal', precision: 10, scale: 2, nullable: true })
+    receivedAmount: number;
+
+    @Column({ name: 'is_tds_applicable', type: 'boolean', default: false })
+    isTdsApplicable: boolean;
+
+    @Column({ name: 'tds_amount', type: 'decimal', precision: 10, scale: 2, nullable: true })
+    tdsAmount: number;
+
+    @Column({ name: 'tds_percentage', type: 'decimal', precision: 10, scale: 2, nullable: true })
+    tdsPercentage: number;
+
+    @Column({ name: 'total_payment_recorded', type: 'decimal', precision: 10, scale: 2, nullable: true })
+    totalPaymentRecorded: number;
+
+    @Column({ name: 'payment_mode', type: 'varchar', length: 50 })
+    paymentMode: 'Bank Transfer' | 'Card' | 'Cash' | 'Cheque';
+
+    @Column({ name: 'payment_status', type: 'varchar', length: 50 })
+    paymentStatus: 'Partially Paid' | 'Full Payment' | 'Overdue' | 'Cancelled' | 'Refunded';
+
+    @Column({ name: 'invoice_no', type: 'varchar', nullable: true })
+    invoiceNo: string;
+
+    // QuickBooks Integration Fields
+    @Column({ type: 'varchar', length: 255, nullable: true, name: 'quickbooks_id' })
+    quickbooksId: string;
+
+    @Column({ type: 'varchar', length: 50, nullable: true, name: 'quickbooks_sync_token' })
+    quickbooksSyncToken: string;
+
+    @Column({ type: 'timestamp', nullable: true, name: 'last_synced_at' })
+    lastSyncedAt: Date;
+
+    @ManyToOne(() => User, { onDelete: 'SET NULL', onUpdate: 'CASCADE' })
+    @JoinColumn({ name: 'confirmed_by' })
+    user: User;
+
+    @ManyToOne(() => Invoice, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })
+    @JoinColumn({ name: 'invoice_id' })
+    invoice: Invoice;
+}