@procxo/shared 1.0.1 → 1.0.4

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

@@ -0,0 +1,25 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Country } from './country.entity';
+
+@Entity({ name: 'cities', schema: 'core' })
+export class City extends BaseEntity {
+  @Column({ nullable: true })
+  name: string;
+
+  @Column({ type: 'decimal', precision: 10, scale: 8, nullable: true })
+  latitude: string;
+
+  @Column({ type: 'decimal', precision: 11, scale: 8, nullable: true })
+  longitude: string;
+
+  @Column({ default: false, nullable: true })
+  status: boolean;
+
+  @Column({ nullable: true, type: 'int' })
+  country_id: number;
+
+  @ManyToOne(() => Country, (country) => country.cities)
+  @JoinColumn({ name: 'country_id' })
+  country: Country;
+}

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

@@ -0,0 +1,91 @@
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn, OneToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Contact } from './contact.entity';
+import { Address } from './address.entity';
+import { Group } from './group.entity';
+import { Invoice } from './invoice.entity';
+import { Matter } from './matter.entity';
+
+export enum ClientType {
+ Prospect = 'Prospect',
+ Active = 'Active',
+ Inactive = 'Inactive', 
+}
+
+export enum engagementType {
+  Retainer = 'Retainer',
+  ProjectBased = 'Project-Based',
+  Hourly = 'Hourly', 
+  OneTime = 'One-Time',
+}
+
+@Entity({ name: 'clients', schema: 'core' })
+export class Client extends BaseEntity {
+  @Column({ length: 100 , nullable: true})
+  clientName: string;
+
+  @Column({ nullable: true, name: 'group_id' })
+  groupId: number;
+
+  @Column({
+    type: 'enum',
+    enum: ['Corporation', 'Partnership', 'Government Entity', 'Individual'],
+    default: 'Individual',
+    nullable: true ,
+    name: 'client_type'
+  })
+  clientType: string;
+
+  @Column({ length: 10, nullable: true, name: 'pan_no' })
+  panNo: string;
+
+  @Column({ length: 100, nullable: true, name: 'city' })
+  city: string;
+
+  @Column({ length: 100, nullable: true, name: 'country' })
+  country: string;
+
+  @Column({ length: 100, nullable: true, name: 'gst_no' })
+  gstNo: string;
+
+  @Column({ type: 'boolean', nullable: true, name: 'is_tds_applicable' })
+  isTdsApplicable: boolean;
+
+  @Column({ nullable: true, name: 'file_id' })
+  fileId: number;
+
+  @Column({ type: 'jsonb', nullable: true, name: 'flowace_data' })
+  flowaceData: any;
+
+  @Column({name:"status", type:"enum", enum:ClientType, nullable: true})
+  status: ClientType|null;
+
+  @Column({name:"engagement_type", type:"enum", enum:engagementType, nullable: true})
+  engagementType: engagementType|null;
+
+  // 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(() => Group, group => group.clientsData)
+  @JoinColumn({ name: 'group_id' })
+  group: Group;
+
+  @OneToMany(() => Invoice, (invoice) => invoice.client)
+  invoices: Invoice[];  
+
+  @OneToMany(() => Contact, contact => contact.client)
+  contacts: Contact[];
+
+  @OneToMany(() => Matter, matter => matter.client)
+  matters: Matter[];
+
+  @OneToOne(() => Address, address => address.client)
+  address: Address;
+} 

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

@@ -0,0 +1,27 @@
+import { Entity, Column, ManyToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Client } from './client.entity';
+
+@Entity({ name: 'contacts', schema: 'core' })
+export class Contact extends BaseEntity {
+  @Column()
+  clientId: number;
+
+  @Column({ length: 100 })
+  contactName: string;
+
+  @Column({ length: 10, default: 'Primary' })
+  contactType: string;
+
+  @Column({type: 'varchar', length: 150,nullable: true })
+  contactEmail: string|null;
+
+  @Column({ type: 'varchar', length: 10,nullable: true})
+  countryCode: string|null;
+
+  @Column({type: 'varchar', length: 15 ,nullable: true})
+  contactPhone: string|null;
+
+  @ManyToOne(() => Client, client => client.contacts)
+  client: Client;
+}

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

@@ -0,0 +1,69 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { City } from './city.entity';
+
+@Entity({name: "countries", schema:"core"})
+export class Country extends BaseEntity {
+  @Column({ nullable: true })
+  name: string;
+
+  @Column({ type: 'char', length: 3, nullable: true, unique: true })
+  iso3: string;
+
+  @Column({ type: 'char', length: 2, nullable: true, unique: true })
+  iso2: string;
+
+  @Column({ type: 'char', length: 3, nullable: true })
+  numeric_code: string;
+
+  @Column({ nullable: true })
+  phonecode: string;
+
+  @Column({ nullable: true })
+  capital: string;
+
+  @Column({ nullable: true })
+  currency: string;
+
+  @Column({ nullable: true })
+  currency_name: string;
+
+  @Column({ nullable: true })
+  currency_symbol: string;
+
+  @Column({ nullable: true })
+  tld: string;
+
+  @Column({ nullable: true })
+  native: string;
+
+  @Column({ nullable: true })
+  region: string;
+
+  @Column({ nullable: true })
+  subregion: string;
+
+  @Column({ nullable: true })
+  nationality: string;
+
+  @Column({ type: 'decimal', precision: 10, scale: 8, nullable: true })
+  latitude: string;
+
+  @Column({ type: 'decimal', precision: 11, scale: 8, nullable: true })
+  longitude: string;
+
+  @Column({ nullable: true })
+  emoji: string;
+
+  @Column({ nullable: true })
+  emojiU: string;
+
+  @Column({ type: 'json', nullable: true })
+  timezones: any;
+
+  @Column({ default: false, nullable: true })
+  status: boolean;
+
+  @OneToMany(() => City, (city) => city.country)
+  cities: City[];
+}

package/src/database/entities/credit-note.entity.ts

@@ -0,0 +1,88 @@
+import { Entity, Column, OneToMany, OneToOne, JoinColumn, ManyToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { TimesheetSummary } from './timesheet-summary.entity';
+import { Expense } from './expense.entity';
+import { Task } from './task.entity';
+import { Invoice } from './invoice.entity';
+import { User } from './user.entity';
+import { InvoiceItem } from './invoice_item.entity';
+
+export enum CreditNoteStatus {
+  PENDING = 'Pending',
+  APPROVED = 'Approved',
+  REJECTED = 'Rejected',
+}
+
+@Entity({ name: 'credit_notes', schema: 'core' })
+export class CreditNoteEntity extends BaseEntity {
+  @Column({ type: 'varchar', name: 'invoice_number', nullable: false })
+  invoice_number: string;
+
+  @Column({ type: 'int', name: 'invoice_id', nullable: false })
+  invoice_id: number;
+
+  @Column({ type: 'varchar', name: 'credit_note_id', nullable: false })
+  credit_note_id: string;
+
+  @Column({ type: 'jsonb', name: 'bill_to', nullable: false })
+  bill_to: JSON;
+
+  @Column({ type: 'jsonb', name: 'bill_from', nullable: false })
+  bill_from: JSON;
+
+  @Column({ type: 'varchar', name: 'reason_for_credit_note', nullable: false })
+  reason_for_credit_note: string;
+
+  @Column({ type: 'decimal', name: 'sub_total', nullable: false })
+  sub_total: number;
+
+  @Column({ type: 'decimal', name: 'tds_rate', nullable: true })
+  tds_rate: number | null;
+
+  @Column({ type: 'decimal', name: 'tds_amount', nullable: false })
+  tds_amount: number;
+
+  @Column({ type: 'decimal', name: 'net_credit_after_tds', nullable: false })
+  net_credit_after_tds: number;
+
+  @Column({ type: 'varchar', name: 'download_url', nullable: true })
+  download_url: string;
+
+  @Column({ type: 'varchar', name: 'preview_url', nullable: true })
+  preview_url: string;
+
+  @Column({type:'int',name:'user_id',nullable:true})
+  userId: number;
+
+  @ManyToOne(() => User, (user) => user.creditNotes)
+  @JoinColumn({ name: 'user_id' })
+  raisedBy: User;
+
+  @Column({
+    name: 'status',
+    type: 'enum',
+    enum: CreditNoteStatus,
+    default: CreditNoteStatus.PENDING,
+    nullable: false,
+    comment: 'Status of the credit note',
+  })
+  status: CreditNoteStatus;
+
+  @OneToMany(() => TimesheetSummary, (timesheet) => timesheet.creditNote)
+  summaries: TimesheetSummary[];
+
+  @OneToMany(() => Expense, (expense) => expense.creditNote)
+  expenses: Expense[];
+
+  @OneToMany(() => Task, (task) => task.creditNote)
+  tasks: Task[];
+
+  @OneToOne(() => Invoice, (invoice) => invoice.creditNote, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'invoice_id' }) // This marks invoice_id as the foreign key
+  invoice: Invoice;
+
+  @OneToMany(() => InvoiceItem, (invoiceItem) => invoiceItem.creditNote)
+  invoiceItems: InvoiceItem[];
+}

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

@@ -0,0 +1,21 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Matter } from './matter.entity';
+
+@Entity({ name: 'currencies', schema: 'core' })
+export class Currency extends BaseEntity {
+  @Column({ name: 'name', nullable: false, unique: true })
+  name: string;
+
+  @Column({ name: 'code', nullable: false, unique: true })
+  code: string;
+
+  @Column({ name: 'symbol', nullable: false })
+  symbol: string;
+
+  @Column({ name: 'is_active', nullable: false, default: true })
+  isActive: boolean;
+
+  @OneToMany(() => Matter, (matter) => matter.currency)
+  matters: Matter[];
+}

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

@@ -0,0 +1,21 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'departments', schema: 'user' })
+export class Department extends BaseEntity {
+  @Column({ name: 'department_name', unique: true })
+  departmentName: string;
+
+  @Column({ name: 'department_description', nullable: true, type: 'text' })
+  departmentDescription: string;
+
+  @Column({ name: 'department_slug', unique: true, nullable: false })
+  departmentSlug: string;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+
+  @OneToMany(() => User, (user) => user.department)
+  users: User[];
+}

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

@@ -0,0 +1,64 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { LeaveType } from './leave-type.entity';
+import { User } from './user.entity';
+
+export enum EntitlementType {
+  INDIVIDUAL = 'individual',
+  MULTIPLE = 'multiple',
+}
+
+@Entity({ name: 'entitlements', schema: 'user' })
+export class Entitlement extends BaseEntity {
+
+  @Column({ name: 'entitlement_type', type: 'enum', enum: EntitlementType, nullable: true })
+  entitlementType: EntitlementType;
+
+  @Column({ name: 'department_id' })
+  departmentId: number;
+
+  @Column({ name: 'leave_type_id' })
+  leaveTypeId: number;
+
+  @Column({ name: 'start_date', type: 'date' })
+  startDate: Date;
+
+  @Column({ name: 'end_date', type: 'date' })
+  endDate: Date;
+
+  @Column({ name: 'entitlements', type: 'decimal', precision: 10, scale: 2, nullable: true })
+  entitlements: number;
+
+  @Column({ name: 'original_entitlements', type: 'decimal', precision: 10, scale: 2, nullable: true })
+  originalEntitlements: number;
+
+  @Column({ name: 'user_id', nullable: true })
+  userId: number;
+
+  @Column({ default: true, name: 'is_active' })
+  isActive: boolean;
+
+  @Column({ name: 'last_calculated_date', type: 'date', nullable: true })
+  lastCalculatedDate: Date;
+
+   // Carry Forward Settings
+  @Column({ name: 'enable_carry_forward', default: true })
+  enableCarryForward: boolean;
+
+  @Column({ 
+    name: 'max_carry_forward_percentage', 
+    type: 'decimal', 
+    precision: 5, 
+    scale: 2, 
+    default: 100.00 
+  })
+  maxCarryForwardPercentage: number;
+
+  @ManyToOne(() => User, user => user.id)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => LeaveType, leaveType => leaveType.id)
+  @JoinColumn({ name: 'leave_type_id' })
+  leaveType: LeaveType;
+} 

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

@@ -0,0 +1,141 @@
+import { Entity, Column, ManyToOne, JoinColumn, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Matter } from './matter.entity';
+import { User } from './user.entity';
+import { CreditNoteEntity } from './credit-note.entity';
+
+enum ApprovalStatus {
+  PENDING_APPROVAL = 'pending_approval',
+  APPROVED = 'approved',
+  REJECTED = 'rejected',
+  AUTO_REJECTED = 'auto_rejected',
+}
+@Entity({ name: 'expenses', schema: 'core' })
+export class Expense extends BaseEntity {
+  @Column({ name: 'matter_id' })
+  matterId: number;
+
+  @Column({ name: 'invoice_id', nullable: true })
+  invoiceId: number;
+
+  @Column({ type: 'text', nullable: true })
+  description: string;
+
+  @Column({ length: 50 })
+  expenseType: string;
+
+  @Column({ name: 'requester_id', nullable: true })
+  requesterId: number;
+
+  @ManyToOne(() => User, { nullable: true })
+  @JoinColumn({ name: 'requester_id' })
+  requester: User;
+
+  @Column({ name: 'councillor_name', length: 255, nullable: true })
+  councillorName: string;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  amount: number;
+
+  @Column({
+    name: 'proposed_date_of_hearing',
+    type: 'timestamp',
+    nullable: true,
+  })
+  proposedDateOfHearing: Date;
+
+  @Column({ name: 'date_of_hearing', type: 'timestamp', nullable: true })
+  dateOfHearing: Date;
+
+  @Column({ name: 'file_id', nullable: true })
+  fileId: number;
+
+  @Column({ name: 'attachments', type: 'json', nullable: true })
+  attachments: any[] | null;
+
+  @Column({ name: 'paid_by', nullable: true })
+  paidBy: number;
+
+  @Column({ length: 50, default: 'Pending' })
+  status: string;
+
+  @Column({
+    name: 'approval_status',
+    length: 50,
+    nullable: true,
+    enum: ApprovalStatus,
+  })
+  approvalStatus: ApprovalStatus;
+
+  @Column({ name: 'reject_reason', nullable: true })
+  rejectReason: string;
+
+  @Column({ name: 'payment_method', length: 50, nullable: true })
+  paymentMethod: string;
+
+  @Column({ name: 'cost_to_client', nullable: true })
+  costToClient: boolean;
+
+  @Column({ name: 'cost_to_company', nullable: true })
+  costToCompany: boolean;
+
+  @Column({ name: 'bill_to_client', nullable: true })
+  billToClient: boolean;
+
+  @Column({ name: 'types_of_billed', length: 50, nullable: true })
+  typesOfBilled: string;
+
+  @Column({ name: 'date_of_expense', type: 'timestamp', nullable: true })
+  dateOfExpense: Date;
+
+  @Column({ name: 'reimbursement_category', length: 50, nullable: true })
+  reimbursementCategory: string;
+
+  @Column({ name: 'expense_category', length: 50, nullable: true })
+  expenseCategory: string;
+
+  @Column({ name: 'client_id', nullable: true })
+  clientId: number;
+
+  @ManyToOne(() => Matter, (matter) => matter.expenses)
+  @JoinColumn({ name: 'matter_id' })
+  matter: Matter;
+
+  @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;
+
+  @Column({ type: 'decimal', name: 'original_amount', nullable: true })
+  original_amount: number | null;
+
+  @Column({
+    type: 'decimal',
+    name: 'invoiced_amount',
+    precision: 10,
+    scale: 2,
+    nullable: true,
+    default: 0,
+  })
+  invoicedAmount: number;
+
+  @Column({
+    type: 'decimal',
+    name: 'remaining_amount',
+    precision: 10,
+    scale: 2,
+    nullable: true,
+  })
+  remainingAmount: number;
+
+  @ManyToOne(() => CreditNoteEntity, (creditNote) => creditNote.expenses)
+  @JoinColumn({ name: 'credit_note_id' })
+  creditNote: CreditNoteEntity;
+
+  // @OneToMany(() => InvoiceItem, (invoiceItem) => invoiceItem.expense)
+  // invoiceItems: InvoiceItem[];
+}

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

@@ -0,0 +1,22 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'file_data' , schema: 'user' })
+export class FileData extends BaseEntity {
+  @Column()
+  fileName: string;
+
+  @Column()
+  urlLocation: string;
+
+  @Column({ nullable: true })
+  fileDescription: string;
+
+  @Column()
+  fileType: string;
+
+  @Column({ nullable: true })
+  previewUrl: string ;
+
+}
+

package/src/database/entities/fixed-invoice-item.entity.ts

@@ -0,0 +1,29 @@
+// ivm-api-core/src/modules/invoice/entities/fixed-invoice-item.entity.ts
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Invoice } from './invoice.entity';
+
+@Entity({ name: 'fixed_invoice_items', schema: 'core' })
+@Index('idx_fixed_invoice_items_invoice_id', ['invoiceId'])
+export class FixedInvoiceItem extends BaseEntity {
+  @Column({ name: 'invoice_id' })
+  invoiceId: number;
+
+  @Column({ 
+    type: 'text',
+    name: 'description'
+  })
+  description: string;
+
+  @Column({ 
+    type: 'decimal', 
+    precision: 10, 
+    scale: 2,
+    name: 'amount'
+  })
+  amount: number;
+
+  @ManyToOne(() => Invoice, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'invoice_id' })
+  invoice: Invoice;
+}

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

@@ -0,0 +1,21 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { Client } from './client.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'groups', schema: 'core' })
+export class Group extends BaseEntity {
+  @Column({ length: 255, unique: true, name: 'group_name' })
+  groupName: string;
+
+  @Column({ name: 'is_active', default: true , type: 'boolean',nullable: true})
+  isActive: boolean;
+
+  @Column('jsonb', { nullable: true, name: 'prefix_group' })
+  prefixGroup: Record<string, any>;
+
+  @OneToMany(() => Client, client => client.group, {
+    cascade: true,
+    onDelete: 'CASCADE',
+  })
+  clientsData: Client[];
+} 

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

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  Column,
+  Index,
+} from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+/**
+ * Gst Entity
+ * Represents the structure of the GST table in the database.
+ */
+@Entity({ name: 'gst', schema: 'user' })
+export class Gst extends BaseEntity {
+  @Index('idx_gst_number')
+  @Column({
+    name: 'gst_number',
+    type: 'varchar',
+    length: 15,
+    nullable: false,
+    unique: true,
+    comment: 'GST number associated with the entity',
+  })
+  gst_number: string;
+
+  @Column({
+    name: 'gst_info',
+    type: 'json',
+    nullable: true,
+    comment: 'Additional information about the GST in JSON format',
+  })
+  gst_info: Record<string, any>;
+}