@procxo/shared 1.0.2 → 1.0.4

package/src/core/json/geographic-data/countries.json

@@ -0,0 +1,31 @@
+[
+  {
+    "id": 101,
+    "name": "India",
+    "iso3": "IND",
+    "iso2": "IN",
+    "numeric_code": "356",
+    "phonecode": "91",
+    "capital": "New Delhi",
+    "currency": "INR",
+    "currency_name": "Indian rupee",
+    "currency_symbol": "₹",
+    "tld": ".in",
+    "native": "भारत",
+    "region": "Asia",
+    "nationality": "Indian",
+    "timezones": [
+      {
+        "zoneName": "Asia/Kolkata",
+        "gmtOffset": 19800,
+        "gmtOffsetName": "UTC+05:30",
+        "abbreviation": "IST",
+        "tzName": "Indian Standard Time"
+      }
+    ],
+    "latitude": "20.00000000",
+    "longitude": "77.00000000",
+    "emoji": "🇮🇳",
+    "emojiU": "U+1F1EE U+1F1F3"
+  }
+]

package/src/database/entities/activity-logs.entity.ts

@@ -0,0 +1,31 @@
+import { BaseEntity } from './base.entity';
+import {
+    Entity,
+    Column,
+  } from 'typeorm';
+  
+  @Entity({ name: 'activity_logs', schema: 'core' })
+  export class ActivityLog extends BaseEntity {
+    @Column({ name: 'user_id' , nullable: true})
+    userId: number;
+  
+    @Column({ name: 'resource_type' , nullable: true})
+    resourceType: string;
+  
+    @Column({ name: 'resource_id' , nullable: true})
+    resourceId: number;
+  
+    @Column({ name: 'action' , nullable: true})
+    action: string;
+  
+    @Column({ name: 'description' , nullable: true})
+    description: string;
+  
+    @Column({ name: 'before_data' , type: 'json', nullable: true })
+    beforeData: Record<string, any>;
+  
+    @Column({ name: 'after_data' , type: 'json', nullable: true })
+    afterData: Record<string, any>;
+  
+  }
+  

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

@@ -0,0 +1,31 @@
+import { Entity, Column, OneToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Client } from './client.entity';
+
+@Entity({ name: 'addresses', schema: 'core' })
+export class Address extends BaseEntity {
+  @Column({ unique: true })
+  clientId: number;
+
+  @Column({ nullable: true })
+  address: string;
+
+  @Column({ length: 100, nullable: true })
+  billingContactPerson: string;
+
+  @Column({ nullable: true })
+  invoiceFrequency: string;
+
+  @Column({ type: 'int', nullable: true })
+  invoiceDayOfWeek: number;
+
+  @Column({ nullable: true })
+  attachment: string;
+
+  @Column({ type: 'text', nullable: true })
+  notes: string;
+
+  @OneToOne(() => Client, client => client.address)
+  @JoinColumn({ name: 'clientId' })
+  client: Client;
+} 

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

@@ -0,0 +1,139 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+export enum AlertType {
+  MATTER = 'matter',
+  INVOICE = 'invoice',
+  OTHER = 'other',
+}
+
+export enum AlertStatus {
+  UNREAD = 'unread',
+  READ = 'read',
+  ARCHIVED = 'archived',
+  DELETED = 'deleted',
+}
+
+export enum AlertPriority {
+  CRITICAL = 'critical',
+  HIGH = 'high',
+  NORMAL = 'normal',
+  LOW = 'low',
+  BULK = 'bulk',
+}
+
+/**
+ * User Alert Entity    
+ * Represents the structure of the user alert table in the database.
+ */
+@Entity({ name: 'alerts', schema: 'notification' })
+export class Alert extends BaseEntity {
+  @Column({
+    type: 'varchar',
+    length: 255,
+    nullable: false,
+    comment: 'Title of the alert entry',
+  })
+  title: string;
+
+  @Column({
+    type: 'text',
+    nullable: false,
+    comment: 'Message of the alert entry',
+  })
+  message?: string;
+
+  @Column({
+    type: 'enum',
+    enum: AlertType,
+    default: AlertType.OTHER,
+    comment: 'Type of the alert entry',
+  })
+  type: AlertType;
+
+  @Column({
+    type: 'enum',
+    enum: AlertPriority,
+    default: AlertPriority.NORMAL,
+    comment: 'Priority of the alert entry',
+  })
+  priority: AlertPriority;
+
+  @Column({
+    type: 'enum',
+    enum: AlertStatus,
+    default: AlertStatus.UNREAD,
+    comment: 'Status of the alert entry',
+  })
+  status: AlertStatus;
+
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the user associated with the alert entry',
+  })
+  userId: number;
+
+  @Column({
+    name: 'read_at',
+    type: 'timestamp',
+    nullable: true,
+    comment: 'Read at of the alert entry',
+  })
+  readAt: Date | null;
+
+  @Column({
+    type: 'timestamp',
+    nullable: true,
+    comment: 'Expires at of the alert entry',
+  })
+  expiresAt?: Date;
+
+  @Column({
+    type: 'json',
+    nullable: true,
+    comment: 'Metadata of the alert entry',
+  })
+  metadata: Record<string, any> | null;
+
+  @Column({
+    type: 'json',
+    nullable: true,
+    comment: 'Action data of the alert entry',
+  })
+  actionData: Record<string, any> | null;
+
+  // Optional: Track related entity
+  @Column({
+    name: 'related_entity_id',
+    type: 'varchar',
+    length: 100,
+    nullable: true,
+    comment: 'ID of related business entity (matter, invoice, etc.)',
+  })
+  relatedEntityId: string | null;
+
+  @Column({
+    name: 'related_entity_type',
+    type: 'varchar',
+    length: 50,
+    nullable: true,
+    comment: 'Type of related business entity',
+  })
+  relatedEntityType: string | null;
+
+  markAsRead(): void {
+    this.status = AlertStatus.READ;
+    this.readAt = new Date();
+  }
+
+  markAsUnread(): void {
+    this.status = AlertStatus.UNREAD;
+    this.readAt = null;
+  }
+
+  archive(): void {
+    this.status = AlertStatus.ARCHIVED;
+  }
+}

package/src/database/entities/approval-condition.entity.ts

@@ -0,0 +1,48 @@
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+} from 'typeorm';
+import { ApprovalHierarchy } from './approval-hierarchy.entity';
+import { ApprovalLevel } from './approval-level.entity';
+import { BaseEntity } from './base.entity';
+
+export enum ConditionTypeEnum {
+  Price = 'Price',
+  Escalation = 'Escalation',
+}
+
+@Entity({ name: 'approval_conditions', schema: 'user' })
+export class ApprovalCondition extends BaseEntity {
+  @Column({ name: 'approval_hierarchy_id', nullable: true })
+  approval_hierarchy_id: number;
+
+  @ManyToOne(
+    () => ApprovalHierarchy,
+    (hierarchy) => hierarchy.approval_condition,
+    {
+      onDelete: 'CASCADE',
+    },
+  )
+  @JoinColumn({ name: 'approval_hierarchy_id' })
+  approval_hierarchy: ApprovalHierarchy;
+
+  @Column({
+    name: 'conditions',
+    nullable: true,
+    type: 'enum',
+    enum: ConditionTypeEnum,
+  })
+  conditions: ConditionTypeEnum;
+
+  @Column({ name: 'price_from', nullable: true, type: 'float' })
+  price_from: number;
+
+  @Column({ name: 'price_to', nullable: true, type: 'float' })
+  price_to: number;
+
+  @OneToMany(() => ApprovalLevel, (level) => level.approval_condition)
+  approval_level: ApprovalLevel[];
+}

package/src/database/entities/approval-hierarchy-role.entity.ts

@@ -0,0 +1,24 @@
+// entities/approval-hierarchy-role.entity.ts
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { ApprovalHierarchy } from './approval-hierarchy.entity';
+import { Role } from './role.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'approval_hierarchy_roles', schema: 'user' })
+export class ApprovalHierarchyRole extends BaseEntity {
+  @Column({ name: 'approval_hierarchy_id' })
+  approval_hierarchy_id: number;
+
+  @ManyToOne(() => ApprovalHierarchy, (hierarchy) => hierarchy.initiator_roles, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_hierarchy_id' })
+  approval_hierarchy: ApprovalHierarchy;
+
+  @Column({ name: 'role_id' })
+  role_id: number;
+
+  @ManyToOne(() => Role, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'role_id' })
+  role: Role;
+}

package/src/database/entities/approval-hierarchy-user.entity.ts

@@ -0,0 +1,24 @@
+// entities/approval-hierarchy-user.entity.ts
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { ApprovalHierarchy } from './approval-hierarchy.entity';
+import { User } from './user.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'approval_hierarchy_users', schema: 'user' })
+export class ApprovalHierarchyUser extends BaseEntity {
+  @Column({ name: 'approval_hierarchy_id' })
+  approval_hierarchy_id: number;
+
+  @ManyToOne(() => ApprovalHierarchy, (hierarchy) => hierarchy.initiator_users, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_hierarchy_id' })
+  approval_hierarchy: ApprovalHierarchy;
+
+  @Column({ name: 'user_id' })
+  user_id: number;
+
+  @ManyToOne(() => User, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+}

package/src/database/entities/approval-hierarchy.entity.ts

@@ -0,0 +1,59 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { ApprovalCondition } from './approval-condition.entity';
+import { ApprovalLevel } from './approval-level.entity';
+import { ApprovalHierarchyUser } from './approval-hierarchy-user.entity';
+import { ApprovalHierarchyRole } from './approval-hierarchy-role.entity';
+
+
+export enum InitiatorTypeEnum {
+  Role = 'Role',
+  User = 'User',
+}
+
+@Entity({ name: 'approval_hierarchy', schema: 'user' })
+export class ApprovalHierarchy extends BaseEntity {
+  @Column({ name: 'name', nullable: true })
+  name: string;
+
+  @Column({ name: 'slug', unique: true, nullable: true })
+  slug: string;
+
+  @Column({ name: 'module', nullable: true })
+  module: string;
+
+  @Column({ name: 'task', nullable: true })
+  task: string;
+
+  @Column({ name: 'initiator_type', type: 'enum', enum: InitiatorTypeEnum })
+  initiator_type: InitiatorTypeEnum;
+
+  @Column({ name: 'is_active', default: true })
+  is_active: boolean;
+
+  @OneToMany(
+    () => ApprovalCondition,
+    (condition) => condition.approval_hierarchy,
+  )
+  approval_condition: ApprovalCondition[];
+
+  @OneToMany(() => ApprovalLevel, (level) => level.approval_hierarchy)
+  approval_level: ApprovalLevel[];
+
+  @OneToMany(
+    () => ApprovalHierarchyUser,
+    (hierarchyUser) => hierarchyUser.approval_hierarchy,
+    { cascade: true }
+  )
+  initiator_users: ApprovalHierarchyUser[];
+
+  @OneToMany(
+    () => ApprovalHierarchyRole,
+    (hierarchyRole) => hierarchyRole.approval_hierarchy,
+    { cascade: true }
+  )
+  initiator_roles: ApprovalHierarchyRole[];
+
+  // @OneToMany(() => ApprovalJourney, (journey) => journey.approvalHierarchy)
+  // approvalJourneys: ApprovalJourney[];
+}

package/src/database/entities/approval-journey.entity.ts

@@ -0,0 +1,75 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { ApprovalHierarchy } from './approval-hierarchy.entity';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+
+export enum ApprovalJourneyStatusEnum {
+  PENDING = 'Pending',
+  APPROVED = 'Approved',
+  REJECTED = 'Rejected',
+  AUTO_APPROVED = 'AutoApproved',
+  AUTO_REJECTED = 'AutoRejected',
+  ESCALATED = 'Escalated',
+  NA = 'NA',
+}
+
+@Entity({ name: 'approval_journey', schema: 'user' })
+export class ApprovalJourney extends BaseEntity {
+  @Column({ name: 'parent_id', type: 'varchar', nullable: true })
+  parent_id?: string;
+
+  @Column({ name: 'journy_type', type: 'varchar', nullable: true })
+  journy_type?: string;
+
+  @Column({ name: 'task_type', type: 'varchar', nullable: true })
+  task_type?: string;
+
+  @Column({ name: 'approval_hierarchy_id', type: 'int', nullable: true })
+  approval_hierarchy_id?: number;
+
+  @ManyToOne(() => ApprovalHierarchy, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'approval_hierarchy_id' })
+  approval_hierarchy?: ApprovalHierarchy;
+
+  @Column({ name: 'approvar_id', type: 'int', nullable: true })
+  approvar_id?: number;
+
+  @Column({ name: 'requester_id', type: 'int', nullable: true })
+  requester_id?: number;
+
+  @ManyToOne(() => User, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'requester_id' })
+  requester?: User;
+
+  @ManyToOne(() => User, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'approvar_id' })
+  user?: User;
+
+  @Column({ type: 'varchar', nullable: true })
+  level?: string;
+
+  @Column({
+    type: 'enum',
+    enum: ApprovalJourneyStatusEnum,
+    default: ApprovalJourneyStatusEnum.PENDING,
+  })
+  status: ApprovalJourneyStatusEnum;
+
+  @Column({ name: 'reject_reason', type: 'text', nullable: true })
+  reject_reason?: string;
+
+  @Column({ name: 'is_approver_turn', type: 'boolean', default: false })
+  is_approver_turn: boolean;
+
+  @Column({ name: 'valid_till', type: 'timestamp', nullable: true })
+  valid_till?: Date;
+
+  @Column({ name: 'duration', type: 'varchar', nullable: true })
+  duration?: string;
+
+  @Column({ name: 'valid_to', type: 'timestamp', nullable: true })
+  valid_to?: Date;
+
+  @Column({ name: 'journey_batch_id', type: 'uuid', nullable: true })
+  journey_batch_id?: string;
+}

package/src/database/entities/approval-level-escalation-user.entity.ts

@@ -0,0 +1,23 @@
+import { Entity, Column, ManyToOne, JoinColumn } from "typeorm";
+import { BaseEntity } from "./base.entity";
+import { ApprovalLevelEscalation } from "./approval-level-escalation.entity";
+import { User } from "./user.entity";
+
+@Entity({ name: 'approval_level_escalation_users', schema: 'user' })
+export class ApprovalLevelEscalationUser extends BaseEntity {
+  @Column({ name: 'approval_level_escalation_id', nullable: true })
+  approval_level_escalation_id: number;
+
+  @ManyToOne(() => ApprovalLevelEscalation, (approval_level_escalation) => approval_level_escalation.approval_level_escalation_user, {
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: 'approval_level_escalation_id' })
+  approval_level_escalation: ApprovalLevelEscalation;
+
+  @Column({ name: 'approver_id', nullable: true })
+  approver_id: number;
+
+  @ManyToOne(() => User, (user) => user.approval_level_escalation_user, { onDelete: "CASCADE" })
+  @JoinColumn({ name: 'approver_id' })
+  user: User;
+}

package/src/database/entities/approval-level-escalation.entity.ts

@@ -0,0 +1,45 @@
+import {
+  Entity,
+  Column,
+  ManyToOne,
+  OneToMany,
+  JoinColumn,
+} from 'typeorm';
+import { ApprovalLevel } from './approval-level.entity';
+import { User } from './user.entity';
+import { ApprovalLevelEscalationUser } from './approval-level-escalation-user.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'approval_level_escalations', schema: 'user' })
+export class ApprovalLevelEscalation extends BaseEntity {
+  @Column({ name: 'approval_level_id', nullable: true })
+  approval_level_id: number;
+
+  @ManyToOne(() => ApprovalLevel, (level) => level.approval_level_escalation, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_level_id', referencedColumnName: 'id' })
+  approval_level: ApprovalLevel;
+
+  @Column({ name: 'escalation_approver_id', nullable: true })
+  escalation_approver_id: number;
+
+  @ManyToOne(() => User, (user) => user.approval_level_escalation, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'escalation_approver_id' })
+  user: User;
+
+  @Column({ name: 'valid_till_hours', nullable: true })
+  valid_till_hours: number;
+
+  @Column({ name: 'valid_till_minutes', nullable: true })
+  valid_till_minutes: number;
+
+  @OneToMany(
+    () => ApprovalLevelEscalationUser,
+    (approval_level_escalation_user) =>
+      approval_level_escalation_user.approval_level_escalation,
+  )
+  approval_level_escalation_user: ApprovalLevelEscalationUser[];
+}

package/src/database/entities/approval-level-user.entity.ts

@@ -0,0 +1,25 @@
+import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { ApprovalLevel } from './approval-level.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'approval_level_users', schema: 'user' })
+export class ApprovalLevelUser extends BaseEntity {
+  @Column({ name: 'approval_level_id', nullable: true })
+  approval_level_id: number;
+
+  @ManyToOne(() => ApprovalLevel, (level) => level.approval_level_users, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_level_id' })
+  approval_level: ApprovalLevel;
+
+  @Column({ name: 'approver_id', nullable: true })
+  approver_id: number;
+
+  @ManyToOne(() => User, (user) => user.approval_level_user, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approver_id' })
+  user: User;
+}

package/src/database/entities/approval-level.entity.ts

@@ -0,0 +1,51 @@
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+} from 'typeorm';
+import { ApprovalHierarchy } from './approval-hierarchy.entity';
+import { ApprovalCondition } from './approval-condition.entity';
+import { ApprovalLevelUser } from './approval-level-user.entity';
+import { ApprovalLevelEscalation } from './approval-level-escalation.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'approval_levels', schema: 'user' })
+export class ApprovalLevel extends BaseEntity {
+  @Column({ nullable: true })
+  approval_hierarchy_id: number;
+
+  @ManyToOne(() => ApprovalHierarchy, (hierarchy) => hierarchy.approval_level, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_hierarchy_id' })
+  approval_hierarchy: ApprovalHierarchy;
+
+  @Column({ name: 'approval_condition_id', nullable: true })
+  approval_condition_id: number;
+
+  @ManyToOne(() => ApprovalCondition, (condition) => condition.approval_level, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'approval_condition_id' })
+  approval_condition: ApprovalCondition;
+
+  @Column({ name: 'level', nullable: true })
+  level: string;
+
+  @Column({ name: 'valid_till_hours', nullable: true })
+  valid_till_hours: number;
+
+  @Column({ name: 'valid_till_minutes', nullable: true })
+  valid_till_minutes: number;
+
+  @OneToMany(
+    () => ApprovalLevelEscalation,
+    (escalation) => escalation.approval_level,
+  )
+  approval_level_escalation: ApprovalLevelEscalation[];
+
+  @OneToMany(() => ApprovalLevelUser, (user) => user.approval_level)
+  approval_level_users: ApprovalLevelUser[];
+}

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

@@ -0,0 +1,31 @@
+import { CreateDateColumn, PrimaryGeneratedColumn, UpdateDateColumn, Column, DeleteDateColumn, Generated } from 'typeorm';
+
+export abstract class BaseEntity {
+  @PrimaryGeneratedColumn('increment')
+  id: number;
+
+  @Column()
+  @Generated('uuid')
+  uuid: string;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date | null;
+
+  @Column({ name: 'created_by', type: 'int', nullable: true })
+  createdBy: number | null;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date | null;
+
+  @Column({ name: 'updated_by', type: 'int', nullable: true })
+  updatedBy: number | null;
+
+  @Column({ name: 'is_deleted', default: false })
+  isDeleted: boolean;
+
+  @Column({ name: 'deleted_by', type: 'int', nullable: true })
+  deletedBy: number | null;
+
+  @DeleteDateColumn({ name: 'deleted_at', nullable: true })
+  deletedAt: Date | null;
+} 

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

@@ -0,0 +1,36 @@
+import { Entity, Column, ManyToOne, JoinColumn, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'chats', schema: 'user' })
+@Index(['senderId', 'receiverId'])
+@Index(['createdAt'])
+@Index(['isRead'])
+export class Chat extends BaseEntity {
+  @Column({ name: 'chat_id', type: 'bigint', primary: true, generated: 'increment' })
+  chatId: string;
+
+  @Column({ name: 'sender_id', nullable: false })
+  senderId: number;
+
+  @Column({ name: 'receiver_id', nullable: false })
+  receiverId: number;
+
+  @Column({ name: 'message', type: 'text', nullable: true })
+  message: string;
+
+  @Column({ name: 'file_id', nullable: true })
+  fileId: number;
+
+  @Column({ name: 'is_read', default: false })
+  isRead: boolean;
+
+  // Relationships
+  @ManyToOne(() => User, (user) => user.sent_chats, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'sender_id' })
+  sender: User;
+
+  @ManyToOne(() => User, (user) => user.received_chats, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'receiver_id' })
+  receiver: User;
+}