@procxo/shared 1.0.2 → 1.0.4

package/src/database/entities/timesheet-summary.entity.ts

@@ -0,0 +1,101 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { CreditNoteEntity } from './credit-note.entity';
+
+@Entity({ name: 'timesheet_summaries', schema: 'core' })
+export class TimesheetSummary extends BaseEntity {
+  @Column({ type: 'varchar', name: 'matter_name', nullable: true })
+  matterName: string;
+
+  @Column({ type: 'varchar', name: 'group_name', nullable: true })
+  groupName: string;
+
+  @Column({ type: 'varchar', name: 'client_name', nullable: true })
+  clientName: string;
+
+  @Column({ type: 'varchar', name: 'title', nullable: true })
+  title: string;
+
+  @Column({ type: 'varchar', name: 'suffix', nullable: true })
+  suffix: string;
+
+  @Column({ type: 'varchar', name: 'file_path', nullable: true })
+  filePath: string;
+
+  @Column({ type: 'int', name: 'matter_id', nullable: true })
+  matterId: number;
+
+  @Column({ type: 'int', name: 'invoice_id', nullable: true })
+  invoiceId: number;
+
+  @Column({ type: 'varchar', name: 'status', nullable: true })
+  status: string;
+
+  @Column({ type: 'varchar', name: 'review_or_draft', nullable: true })
+  reviewOrDraft: string;
+
+  @Column('decimal', {
+    precision: 10,
+    scale: 2,
+    name: 'duration',
+    nullable: true,
+  })
+  duration: number;
+
+  @Column('decimal', {
+    precision: 10,
+    scale: 2,
+    name: 'total_price',
+    nullable: true,
+  })
+  totalPrice: number;
+
+  @Column('decimal', {
+    precision: 10,
+    scale: 2,
+    name: 'reviewer_amount',
+    nullable: true,
+  })
+  reviewerAmount: number;
+
+  @Column({ default: true, name: 'is_visible', nullable: true })
+  isVisible: boolean;
+
+  @Column({ type: 'date', name: 'date', nullable: true })
+  date: Date;
+
+  @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.summaries)
+  @JoinColumn({ name: 'credit_note_id' })
+  creditNote: CreditNoteEntity;
+}

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

@@ -0,0 +1,76 @@
+import { User } from './user.entity';
+import {
+  Entity,
+  Column,
+  OneToMany,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { TimesheetEvent } from './timesheet-event.entity';
+import { TimesheetComment } from './timesheet-comment.entity';
+
+export enum TimesheetStatus {
+  PENDING = 'PENDING',
+  APPROVED = 'APPROVED',
+  SEND_BACK = 'SEND-BACK',
+  MISSING = 'MISSING',
+  ACTIVE = 'ACTIVE',
+}
+
+enum ApprovalFlowType {
+  REPORTING_MANAGER_BASED = 'REPORTING_MANAGER_BASED',
+  HIERARCHY_BASED='HIERARCHY_BASED'
+}
+@Entity({ name: 'timesheets', schema: 'timesheet' })
+export class Timesheet extends BaseEntity {
+
+  @Column({ name: 'user_id', type: 'integer', nullable: false })
+  user_id: number;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({ name: 'week_start', type: 'date', nullable: false })
+  week_start: Date;
+
+  @Column({ name: 'week_end', type: 'date', nullable: false })
+  week_end: Date;
+
+  @Column({
+    name: 'status',
+    type: 'varchar',
+    default: 'PENDING',
+    comment: 'PENDING | APPROVED |SEND-BACK',
+  })
+  status: string;
+
+  @Column({ name: 'submitted_at', type: 'timestamp', nullable: true })
+  submitted_at: Date;
+
+  @Column({ name: 'approved_at', type: 'timestamp', nullable: true })
+  approved_at: Date;
+
+  @Column({ name: 'approved_by', type: 'integer', nullable: true })
+  approved_by: number;
+
+  @Column({name:'is_resubmitted',type:'boolean',default:false})
+  is_resubmitted: boolean;
+
+  @Column({name:'resubmitted_at',type:'timestamp',nullable:true})
+  resubmitted_at: Date;
+
+  @Column({
+    type: 'enum',
+    enum: ApprovalFlowType,
+    nullable: true,
+  })
+  approval_flow_type: ApprovalFlowType | null;
+
+  @OneToMany(() => TimesheetEvent, (timesheetEvent) => timesheetEvent.timesheet)
+  timesheet_events: TimesheetEvent[];
+
+  @OneToMany(() => TimesheetComment, (timesheetComment) => timesheetComment.timesheet)
+  timesheet_comments: TimesheetComment[];
+}

package/src/database/entities/transfer-ownership.entity.ts

@@ -0,0 +1,39 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'ownership_transfers', schema: 'user' })
+export class OwnershipTransfer extends BaseEntity {
+  @Column({ name: 'ownership_transfer_from_user_id' })
+  owenershipTransferFromUserId: number;
+
+  @Column({ name: 'ownership_transfer_to_user_id' })
+  ownershipTransferToUserId: number;
+
+  @Column({ name: 'ownership_transfer_reason', type: 'text' })
+  ownershipTransferReason: string;
+
+  @Column({ name: 'ownership_transfer_notes', type: 'text', nullable: true })
+  ownershipTransferNotes: string;
+
+  @Column({ name: 'transferred_at' })
+  transferredAt: Date;
+
+  @Column({name:'transferred_by_user_id'})
+  transferredByUserId: number;
+
+  @Column({name:"transfered_data",type:"jsonb",nullable:true})
+  transferedData: any;
+
+  @ManyToOne(() => User, { nullable: true })
+  @JoinColumn({ name: 'ownership_transfer_from_user_id' })
+  ownershipTransferFromUser: User;
+
+  @ManyToOne(() => User, { nullable: true })
+  @JoinColumn({ name: 'ownership_transfer_to_user_id' })
+  ownershipTransferToUser: User;
+
+  @ManyToOne(() => User, { nullable: true })
+  @JoinColumn({ name: 'transferred_by_user_id' })
+  transferredByUser: User;
+}

package/src/database/entities/upload-log.entity.ts

@@ -0,0 +1,78 @@
+import {
+    Entity,
+    Column,
+    ManyToOne,
+    JoinColumn,
+    CreateDateColumn,
+  } from 'typeorm';
+import {User} from './user.entity';
+import {BaseEntity} from './base.entity';
+  
+  // Enums
+  export enum UploadModuleEnum {
+    HOLIDAY = 'HOLIDAY',
+    USER = 'USER',
+    CLIENT = 'CLIENT',
+    EXPENSE = 'EXPENSE',
+  }
+  
+  export enum UploadStatus {
+    PENDING = 'PENDING',
+    IN_PROGRESS = 'IN_PROGRESS',
+    COMPLETED = 'COMPLETED',
+    FAILED = 'FAILED',
+    PROCESSING = 'PROCESSING',
+  }
+  
+  @Entity({ name: 'upload_logs', schema: 'user'})
+  export class UploadLog extends BaseEntity {
+  
+    @Column()
+    user_id: number;
+  
+    @ManyToOne(() => User, (user) => user.uploadLogs)
+    @JoinColumn({ name: 'user_id' })
+    user: User;
+  
+    @Column({
+      type: 'enum',
+      enum: UploadModuleEnum,
+      nullable: true,
+    })
+    module: UploadModuleEnum;
+  
+    @Column({ nullable: true })
+    file_name: string;
+  
+    @Column({ type: 'int', nullable: true })
+    file_size: number;
+  
+    @Column({
+      type: 'enum',
+      enum: UploadStatus,
+      default: UploadStatus.PENDING,
+    })
+    status: UploadStatus;
+  
+    @Column({ type: 'int', nullable: true })
+    total_records: number;
+  
+    @Column({ type: 'int', nullable: true })
+    success_count: number;
+  
+    @Column({ type: 'int', nullable: true })
+    failure_count: number;
+  
+    @Column({ nullable: true })
+    error_file_path: string;
+  
+    @CreateDateColumn({ name: 'started_at' })
+    started_at: Date;
+  
+    @Column({ type: 'timestamp', nullable: true })
+    completed_at: Date;
+  
+    @Column({ type: 'json', nullable: true })
+    errors: any;
+  }
+  

package/src/database/entities/user-notification-channel.entity.ts

@@ -0,0 +1,43 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+/**
+ * User Notification Channels Entity
+ * Controls global enable/disable for notification channels
+ */
+@Entity({ name: 'user_notification_channel', schema: 'notification' })
+@Index(['userId'], { unique: true })
+export class UserNotificationChannel extends BaseEntity {
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    unique: true,
+    comment: 'ID of the user',
+  })
+  userId: number;
+
+  @Column({
+    name: 'email_enabled',
+    type: 'boolean',
+    default: true,
+    comment: 'Global enable/disable for email notifications',
+  })
+  emailEnabled: boolean;
+
+  @Column({
+    name: 'push_enabled',
+    type: 'boolean',
+    default: true,
+    comment: 'Global enable/disable for push notifications',
+  })
+  pushEnabled: boolean;
+
+  @Column({
+    name: 'whatsapp_enabled',
+    type: 'boolean',
+    default: false,
+    comment: 'Global enable/disable for WhatsApp notifications',
+  })
+  whatsappEnabled: boolean;
+}

package/src/database/entities/user-notification-preference.entity.ts

@@ -0,0 +1,50 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { NotificationPreferenceType } from '../../core/constant';
+
+/**
+ * User Notification Preference Entity
+ * Each row represents one notification type preference for a user
+ */
+@Entity({ name: 'user_notification_preferences', schema: 'notification' })
+@Index(['userId', 'preferenceType'], { unique: true })
+export class UserNotificationPreference extends BaseEntity {
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the user',
+  })
+  userId: number;
+
+  @Column({
+    name: 'preference_type',
+    type: 'enum',
+    enum: NotificationPreferenceType,
+    nullable: false,
+    comment: 'Type of notification preference',
+  })
+  preferenceType: NotificationPreferenceType;
+
+  @Column({
+    name: 'is_enabled',
+    type: 'boolean',
+    default: true,
+    comment: 'Whether this notification type is enabled',
+  })
+  isEnabled: boolean;
+
+  @Column({
+    type: 'text',
+    nullable: true,
+    comment: 'Description of the notification preference',
+  })
+  description: string | null;
+
+  @Column({
+    type: 'json',
+    nullable: true,
+    comment: 'Additional settings for this notification type',
+  })
+  metadata: Record<string, any> | null;
+}

package/src/database/entities/user-role.entity.ts

@@ -0,0 +1,25 @@
+import {
+  Entity,
+  Column,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { User } from './user.entity';
+import { Role } from './role.entity';
+import { BaseEntity } from './base.entity';
+@Entity({ name: 'user_roles', schema: 'user' })
+export class UserRole extends BaseEntity {
+  @Column({ name: 'user_id' })
+  user_id: number;
+
+  @Column({ name: 'role_id' })
+  role_id: number;
+
+  @ManyToOne(() => User, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => Role, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'role_id' })
+  role: Role;
+}

package/src/database/entities/user-session-history.entity.ts

@@ -0,0 +1,45 @@
+import { BaseEntity } from './base.entity';
+import {
+  Entity,
+  Column,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { User } from './user.entity';
+
+@Entity({ name: 'user_session_history', schema: 'user' })
+export class UserSessionHistory extends BaseEntity {
+  @Column({ type: 'int', nullable: true })
+  user_id: number | null;
+
+  @ManyToOne(() => User, (user) => user.user_session_history)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({ type: 'varchar', nullable: true })
+  ip_address: string | null;
+
+  @Column({ type: 'text', nullable: true })
+  user_agent: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  browser: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  device: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  platform: string | null;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  login_timestamp: Date;
+
+  @Column({ type: 'timestamp', nullable: true })
+  logout_timestamp: Date | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  status: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  session_id: string | null;
+}

package/src/database/entities/user-shift.entity.ts

@@ -0,0 +1,109 @@
+import { User } from './user.entity';
+import { Entity, Column, JoinColumn, OneToOne, ManyToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Shift } from './shift.entity';
+
+export enum AllocationType {
+  ROLE = 'role',
+  USER = 'user',
+}
+
+@Entity({ name: 'user_shifts', schema: 'timesheet' })
+export class UserShift extends BaseEntity {
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the user associated with the shift',
+  })
+  user_id: number;
+
+  @Column({
+    name: 'current_shift_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'Current shift of the user',
+  })
+  current_shift_id: number;
+
+  @ManyToOne(() => Shift)
+  @JoinColumn({ name: 'current_shift_id' })
+  current_shift: Shift;
+
+  @Column({
+    name: 'is_alternate_shift',
+    type: 'boolean',
+    nullable: false,
+    comment: 'Check if the shift is alternate',
+  })
+  is_alternate_shift: boolean;
+
+  @Column({
+    name: 'current_alternate_shift_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'Current alternate shift of the user',
+  })
+  current_alternate_shift_id: number;
+
+  @ManyToOne(() => Shift)
+  @JoinColumn({ name: 'current_alternate_shift_id' })
+  current_alternate_shift: Shift;
+
+  @Column({
+    name: 'shift_start_date',
+    type: 'date',
+    nullable: false,
+    comment: 'Start date of the shift',
+  })
+  shift_start_date: Date;
+
+  @Column({
+    name: 'shift_end_date',
+    type: 'date',
+    nullable: false,
+    comment: 'End date of the shift',
+  })
+  shift_end_date: Date;
+
+  @Column({
+    name: 'planned_shift_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'The planned shift id to be assigned to the user',
+  })
+  planned_shift_id: number | null;
+
+  @ManyToOne(() => Shift)
+  @JoinColumn({ name: 'planned_shift_id' })
+  planned_shift: Shift;
+
+  @Column({
+    name: 'effective_date',
+    type: 'date',
+    nullable: true,
+    comment: 'The date when the planned shift becomes effective',
+  })
+  effective_date: Date | null;
+
+  @OneToOne(() => User) // Define a one-to-one relationship
+  @JoinColumn({ name: 'user_id' }) // Specify the column for the foreign key
+  user: User;
+
+  @Column({
+    name: 'shift_applied_by',
+    type: 'integer',
+    nullable: true,
+    comment: 'Shift applied by',
+  })
+  shift_applied_by: number;
+
+  @Column({
+    name: 'allocation_type',
+    type: 'enum',
+    enum: AllocationType,
+    nullable: true,
+    comment: 'Allocation type',
+  })
+  allocation_type: AllocationType;
+}