@procxo/shared 1.0.4 → 1.0.5

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

@@ -1,31 +0,0 @@
-[
-  {
-    "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

@@ -1,31 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,24 +0,0 @@
-// 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

@@ -1,24 +0,0 @@
-// 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

@@ -1,59 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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;
-}