@procxo/shared 1.0.2 → 1.0.4

package/src/database/entities/task-remainder.entity.ts

@@ -0,0 +1,29 @@
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Task } from './task.entity';
+import { SubTask } from './subtask.entity';
+
+@Entity({ name: 'task_reminders', schema: 'core' })
+export class TaskReminder extends BaseEntity {
+  @Column({ name: 'task_id', nullable: false })
+  taskId: number;
+
+  @Column({ name: 'sub_task_id', nullable: true })
+  subTaskId: number;
+
+  @ManyToOne(() => Task, (task) => task.reminders, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'task_id' })
+  task: Task;
+
+  @ManyToOne(() => SubTask, (subTask) => subTask.reminders, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'sub_task_id' })
+  subTask: SubTask;
+
+  @Column({ type: 'timestamp', name: 'reminder_at' })
+  reminderAt: Date;
+
+  @Column({ type: 'boolean', name: 'is_completed', default: false })
+  isCompleted: boolean;
+}

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

@@ -0,0 +1,22 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Task } from './task.entity';
+import { Tag } from './tag.entity';
+
+@Entity({ name: 'tasks_tags', schema: 'core' })
+export class TaskTag extends BaseEntity {
+  @Column({ name: 'task_id' })
+  taskId: number;
+
+  @Column({ name: 'tag_id' })
+  tagId: number;
+
+  // Relationship
+  @ManyToOne(() => Task, task => task.tasksLabel)
+  @JoinColumn({ name: 'task_id' })
+  task: Task;
+
+  @ManyToOne(() => Tag, tag => tag.tagsLabel)
+  @JoinColumn({ name: 'tag_id' })
+  tag: Tag;
+} 

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

@@ -0,0 +1,14 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'task_types', schema: 'core' })
+export class TaskType extends BaseEntity {
+  @Column({ name: 'name', length: 100, nullable: false })
+  name: string;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description: string;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+}

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

@@ -0,0 +1,21 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Task } from './task.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'task_users', schema: 'core' })
+export class TaskUser extends BaseEntity {
+  @Column({ name: 'task_id' })
+  taskId: number;
+
+  @Column({ name: 'user_id' })
+  userId: number;
+    
+  @ManyToOne(() => Task, task => task.taskUsers)
+  @JoinColumn({ name: 'task_id' })
+  task: Task;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+}

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

@@ -0,0 +1,176 @@
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Matter } from './matter.entity';
+import { TaskTag } from './task-tag.entity';
+import { CreditNoteEntity } from './credit-note.entity';
+import { User } from './user.entity';
+import { SubTask } from './subtask.entity';
+import { TaskComment } from './task-comment.entity';
+import { TaskReminder } from './task-remainder.entity';
+import { TaskUser } from './task-user.entity';
+import { TaskType } from './task-type.entity';
+import { TaskMilestone } from './task-milestone.entity';
+
+enum TaskStatus {
+  IN_PROGRESS = 'In Progress',
+  COMPLETED = 'Completed',
+  ON_HOLD = 'On Hold',
+  TO_DO = 'To-Do',
+}
+
+export enum TaskSourceType {
+  TEMPLATE = 'TEMPLATE',
+  INDIVIDUAL = 'INDIVIDUAL',
+}
+
+@Entity({ name: 'tasks', schema: 'core' })
+export class Task extends BaseEntity {
+  @Column({ name: 'matter_id', nullable: true })
+  matterId: number;
+
+  @Column({ name: 'title', length: 200, nullable: true })
+  title: string;
+
+  @Column({ name: 'task_type_id', nullable: true })
+  taskTypeId: number;
+
+  @Column({ name: 'description', type: 'text', nullable: true })
+  description: string;
+
+  @Column({ name: 'assigned_to', type: 'int', nullable: true })
+  assignedTo: number | null;
+
+  @Column({ name: 'priority', nullable: true })
+  priority: string;
+
+  @Column({ name: 'progress', nullable: true, default: 0 })
+  progress: number;
+
+  @Column({ name: 'invoice_id', nullable: true })
+  invoiceId: number;
+
+  @Column({
+    type: 'enum',
+    enum: TaskSourceType,
+    default: TaskSourceType.INDIVIDUAL,
+  })
+  sourceType: TaskSourceType;
+
+  @Column({
+    name: 'milestone_id',
+    nullable: true,
+  })
+  milestoneId: number;
+
+  @Column({
+    name: 'task_budget',
+    type: 'decimal',
+    nullable: true,
+  })
+  taskBudget: number;
+
+  @Column({
+    name: 'standard_fees',
+    type: 'decimal',
+    nullable: true,
+  })
+  standardFees: number;
+
+  @Column({
+    name: 'effort_hours',
+    type: 'decimal',
+    nullable: true,
+  })
+  effortHours: number;
+
+  @Column({
+    name: 'estimated_hours',
+    type: 'decimal',
+    nullable: true,
+  })
+  estimatedHours: number;
+
+  @Column({ name: 'file_id', nullable: true })
+  fileId: number;
+
+  @Column({ name: 'notes', type: 'text', nullable: true })
+  notes: string;
+
+  @Column({ name: 'status', length: 20, nullable: true })
+  status: string;
+
+  @Column({ name: 'start_date', type: 'date', nullable: true })
+  startDate: Date;
+
+  @Column({ name: 'due_date', type: 'date', nullable: true })
+  dueDate: Date;
+
+  // Relationships
+  @ManyToOne(() => Matter, (matter) => matter.tasks)
+  @JoinColumn({ name: 'matter_id' })
+  matter: Matter;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'assigned_to' })
+  assignedUser: User;
+
+  @ManyToOne(() => TaskType)
+  @JoinColumn({ name: 'task_type_id' })
+  taskType: TaskType;
+
+  @ManyToOne(() => TaskMilestone)
+  @JoinColumn({ name: 'milestone_id' })
+  milestone: TaskMilestone;
+
+
+  @OneToMany(() => TaskTag, (taskTag) => taskTag.task)
+  tasksLabel: TaskTag[];
+
+  @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;
+
+  @ManyToOne(() => CreditNoteEntity, (creditNote) => creditNote.tasks)
+  @JoinColumn({ name: 'credit_note_id' })
+  creditNote: CreditNoteEntity;
+
+  @OneToMany(() => SubTask, (subtask) => subtask.task)
+  subtasks: SubTask[];
+
+  @OneToMany(() => TaskComment, (taskComment) => taskComment.task)
+  comments: TaskComment[];
+
+  @OneToMany(() => TaskReminder, (taskReminder) => taskReminder.task)
+  reminders: TaskReminder[];
+
+  @OneToMany(() => TaskUser, (taskUser) => taskUser.task)
+  taskUsers: TaskUser[];
+
+  @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;
+
+}

package/src/database/entities/template-task.entity.ts

@@ -0,0 +1,25 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Template } from './template.entity';
+
+@Entity({ name: 'template_tasks', schema: 'core' })
+export class TemplateTask extends BaseEntity {
+  @Column({ length: 225 })
+  taskName: string;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  standardFees: number;
+
+  @Column({nullable: true})
+  estimatedHours: number;
+
+  @Column({ length: 255, nullable: true })
+  description: string;
+
+  @Column({ nullable: true, name: 'template_id' })
+  templateId: number;
+
+  @ManyToOne(() => Template, template => template.templateTasks)
+  @JoinColumn({ name: 'template_id' })
+  template: Template;
+} 

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

@@ -0,0 +1,28 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Matter } from './matter.entity';
+import { TemplateTask } from './template-task.entity';
+
+@Entity({ name: 'templates', schema: 'core' })
+export class Template extends BaseEntity {
+  @Column({ type: 'text' })
+  templateName: string;
+
+  @Column({ type: 'text', nullable: true })
+  description: string;
+
+  @Column({ nullable: true })
+  categoryId: number;
+
+  @Column({ nullable: true })
+  fileId: number;
+
+  @Column('jsonb', { nullable: true })
+  templateData: Record<string, any>;
+
+  @OneToMany(() => Matter, matter => matter.template)
+  matters: Matter[];
+
+  @OneToMany(() => TemplateTask, templateTask => templateTask.template)
+  templateTasks: TemplateTask[];
+} 

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

@@ -0,0 +1,45 @@
+import {
+  Entity,
+  Column,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { Timesheet } from './timesheet.entity';
+import { User } from './user.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'timesheet_comments', schema: 'timesheet' })
+export class TimesheetComment extends BaseEntity {
+
+  @Column({
+    name: 'timesheet_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the timesheet associated with the comment',
+  })
+  timesheet_id: number;
+
+  @ManyToOne(() => Timesheet)
+  @JoinColumn({ name: 'timesheet_id' })
+  timesheet: Timesheet;
+
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the user who made the comment',
+  })
+  user_id: number;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @Column({
+    name: 'comment',
+    type: 'text',
+    nullable: false,
+    comment: 'The comment text',
+  })
+  comment: string;
+}

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

@@ -0,0 +1,256 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+import { Timesheet } from './timesheet.entity';
+import { Matter } from './matter.entity';
+import { Task } from './task.entity';
+import { SubTask } from './subtask.entity';
+
+/**
+ * Timesheet Event Entity
+ * Represents the structure of the timesheet event table in the database.
+ */
+export enum EventTypes {
+  BILLABLE = 'Billable',
+  NON_BILLABLE = 'Non-billable',
+  BENCH = 'Bench',
+}
+
+export enum TaskTypes {
+  TASK = 'TASK',
+  SUBTASK = 'SUBTASK',
+}
+
+@Entity({ name: 'timesheet-events', schema: 'timesheet' })
+export class TimesheetEvent extends BaseEntity {
+  @Column({
+    name: 'user_id',
+    type: 'integer',
+    nullable: false,
+    comment: 'ID of the user associated with the timesheet event entry',
+  })
+  user_id: number;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id', referencedColumnName: 'id' })
+  user: User;
+
+  @Column({
+    name: 'title',
+    type: 'varchar',
+    length: 255,
+    nullable: false,
+    comment: 'Title of the task of related matter',
+  })
+  title: string;
+
+  @Column({
+    name: 'task_type',
+    type: 'enum',
+    enum: TaskTypes,
+    nullable: true,
+    comment: 'Type of the task of related matter',
+  })
+  task_type: TaskTypes | null;
+
+  @Column({
+    name: 'task_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'ID of the task of related matter',
+  })
+  task_id: number|null;
+
+  @Column({
+    name: 'subtask_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'ID of the subtask of related matter',
+  })
+  subtask_id: number|null;
+
+  @Column({
+    name: 'description',
+    type: 'text',
+    nullable: true,
+    comment: 'Description of the timesheet event entry',
+  })
+  description: string|null;
+
+  @Column({
+    name: 'event_type',
+    type: 'varchar',
+    nullable: false,
+    comment: 'Type of the timesheet event entry',
+    default: EventTypes.BILLABLE,
+  })
+  event_type: EventTypes;
+
+  @Column({
+    name: 'start_date',
+    type: 'date',
+    nullable: false,
+    comment: 'Start date of the timesheet event entry',
+  })
+  start_date: Date;
+
+  @Column({
+    name: 'start_time',
+    type: 'time',
+    nullable: false,
+    comment: 'Start time of the timesheet event entry',
+  })
+  start_time: string;
+
+  @Column({
+    name: 'end_date',
+    type: 'date',
+    nullable: false,
+    comment: 'End date of the timesheet event entry',
+  })
+  end_date: Date;
+
+  @Column({
+    name: 'end_time',
+    type: 'time',
+    nullable: false,
+    comment: 'End time of the timesheet event entry',
+  })
+  end_time: string;
+
+  @Column({
+    name: 'is_all_day',
+    type: 'boolean',
+    default: false,
+    comment: 'Indicates if the timesheet event entry spans the entire day',
+  })
+  is_all_day: boolean;
+
+  @Column({
+    name: 'matter_id',
+    type: 'bigint',
+    nullable: true,
+    comment: 'Associated matter or case ID (nullable)',
+  })
+  matter_id: number | null;
+
+  @ManyToOne(() => Matter)
+  @JoinColumn({ name: 'matter_id', referencedColumnName: 'id' })
+  matter: Matter;
+
+  @Column({
+    name: 'is_leave',
+    type: 'boolean',
+    default: false,
+    comment: 'Indicates if the timesheet event entry represents leave',
+  })
+  is_leave: boolean;
+
+  @Column({
+    name: 'work_category',
+    type: 'varchar',
+    nullable: true,
+    comment: 'Work category of the timesheet event',
+  })
+  work_category: string|null;
+
+  @Column({
+    name: 'status',
+    type: 'varchar',
+    default: 'PENDING',
+    nullable: true,
+    comment: 'Status of the timesheet event entry',
+  })
+  status: string;
+
+  @Column({
+    name: 'app_title',
+    type: 'varchar',
+    length: 255,
+    nullable: false,
+    comment: 'Title of the application managing the timesheet event entry',
+  })
+  app_title: string;
+
+  @Column({
+    name: 'app_name',
+    type: 'varchar',
+    length: 255,
+    nullable: false,
+    comment: 'Name of the application managing the timesheet event entry',
+  })
+  app_name: string;
+
+  @Column({
+    name: 'app_type',
+    type: 'varchar',
+    length: 255,
+    nullable: true,
+    comment: 'Type of the application managing the timesheet event entry',
+  })
+  app_type: string;
+
+  @Column({
+    name: 'hourly_price',
+    type: 'decimal',
+    precision: 10,
+    scale: 2,
+    nullable: true,
+    comment: 'Hourly price associated with the timesheet event entry',
+  })
+  hourly_price: number;
+
+  @Column({
+    name: 'total_price',
+    type: 'decimal',
+    precision: 10,
+    scale: 2,
+    nullable: true,
+    comment: 'Total price calculated for the timesheet event entry',
+  })
+  total_price: number;
+
+  @Column({
+    name: 'event_hours',
+    type: 'varchar',
+    nullable: true,
+    comment: 'Total hours calculated for the timesheet event entry',
+  })
+  event_hours: string;
+
+  @ManyToOne(() => Timesheet)
+  @JoinColumn({ name: 'timesheet_id', referencedColumnName: 'id' })
+  timesheet: Timesheet;
+
+  @ManyToOne(() => Task)
+  @JoinColumn({ name: 'task_id', referencedColumnName: 'id' })
+  task: Task;
+
+  @ManyToOne(() => SubTask)
+  @JoinColumn({ name: 'subtask_id', referencedColumnName: 'id' })
+  subtask: SubTask;
+
+  @Column({
+    name: 'timesheet_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'ID of the timesheet associated with the timesheet event entry',
+  })
+  timesheet_id: number | null;
+
+  @Column({
+    name: 'origin_date',
+    type: 'date',
+    nullable: true,
+    comment: 'Origin date of the timesheet event entry',
+  })
+  origin_date: Date;
+
+  @Column({
+    name: 'invoice_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'ID of the invoice associated with the timesheet event entry',
+  })
+  invoice_id: number | null;
+}