@procxo/shared 1.0.1 → 1.0.4

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

@@ -0,0 +1,27 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { RolePermission } from './role-permission.entity';
+
+@Entity({ name: 'permissions', schema: 'user' })
+export class Permission extends BaseEntity {
+  @Column({ name: 'permission_name', unique: true })
+  permissionName: string;
+
+  @Column({ name: 'permission_slug', unique: true })
+  permissionSlug: string;
+
+  @Column({ name: 'permission_description', nullable: true, type: 'text' })
+  permissionDescription: string;
+
+  @Column({ name: 'module_name' })
+  moduleName: string;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+
+  @OneToMany(
+    () => RolePermission,
+    (rolePermission) => rolePermission.permission,
+  )
+  role_permissions: RolePermission[];
+}

package/src/database/entities/quickbooks-connection.entity.ts

@@ -0,0 +1,35 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'quickbooks_connections', schema: 'core' })
+export class QuickBooksConnection extends BaseEntity {
+  @Column({ type: 'int', name: 'organization_id', nullable: true })
+  organizationId: number;
+
+  @Column({ type: 'varchar', length: 255, name: 'realm_id', unique: true })
+  realmId: string;
+
+  @Column({ type: 'text', name: 'access_token' })
+  accessToken: string;
+
+  @Column({ type: 'text', name: 'refresh_token' })
+  refreshToken: string;
+
+  @Column({ type: 'timestamp', name: 'token_expires_at' })
+  tokenExpiresAt: Date;
+
+  @Column({ type: 'jsonb', name: 'scope', nullable: true })
+  scope: string[];
+
+  @Column({ type: 'boolean', name: 'is_active', default: true })
+  isActive: boolean;
+
+  @Column({ type: 'timestamp', name: 'last_sync_at', nullable: true })
+  lastSyncAt: Date;
+
+  @Column({ type: 'varchar', length: 255, name: 'company_name', nullable: true })
+  companyName: string;
+
+  @Column({ type: 'varchar', length: 50, name: 'environment', default: 'sandbox' })
+  environment: 'sandbox' | 'production';
+}

package/src/database/entities/quickbooks-sync-log.entity.ts

@@ -0,0 +1,79 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+export enum QBEntityType {
+  CLIENT = 'client',
+  INVOICE = 'invoice',
+  PAYMENT = 'payment',
+}
+
+export enum QBSyncAction {
+  CREATE = 'create',
+  UPDATE = 'update',
+  DELETE = 'delete',
+}
+
+export enum QBSyncDirection {
+  TO_QB = 'to_qb',
+  FROM_QB = 'from_qb',
+}
+
+export enum QBSyncStatus {
+  PENDING = 'pending',
+  SUCCESS = 'success',
+  FAILED = 'failed',
+}
+
+@Entity({ name: 'quickbooks_sync_logs', schema: 'core' })
+export class QuickBooksSyncLog extends BaseEntity {
+  @Column({
+    type: 'enum',
+    enum: QBEntityType,
+    name: 'entity_type',
+  })
+  entityType: QBEntityType;
+
+  @Column({ type: 'int', name: 'entity_id' })
+  entityId: number;
+
+  @Column({
+    type: 'enum',
+    enum: QBSyncAction,
+    name: 'action',
+  })
+  action: QBSyncAction;
+
+  @Column({
+    type: 'enum',
+    enum: QBSyncDirection,
+    name: 'direction',
+  })
+  direction: QBSyncDirection;
+
+  @Column({
+    type: 'enum',
+    enum: QBSyncStatus,
+    name: 'status',
+    default: QBSyncStatus.PENDING,
+  })
+  status: QBSyncStatus;
+
+  @Column({ type: 'text', name: 'error_message', nullable: true })
+  errorMessage: string;
+
+  @Column({ type: 'int', name: 'retry_count', default: 0 })
+  retryCount: number;
+
+  @Column({ type: 'varchar', length: 255, name: 'quickbooks_id', nullable: true })
+  quickbooksId: string;
+
+  @Column({ type: 'timestamp', name: 'synced_at', nullable: true })
+  syncedAt: Date;
+
+  @Column({ type: 'jsonb', name: 'request_payload', nullable: true })
+  requestPayload: any;
+
+  @Column({ type: 'jsonb', name: 'response_payload', nullable: true })
+  responsePayload: any;
+}
+

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

@@ -0,0 +1,30 @@
+import { Permission } from './permission.entity';
+import {
+  Entity,
+  Column,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { Role } from './role.entity';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'role_permissions', schema: 'user' })
+export class RolePermission extends BaseEntity {
+  @Column({ type: 'int' })
+  permission_id: number;
+
+  @Column({ type: 'int' })
+  role_id: number;
+
+  @ManyToOne(() => Permission, (permission) => permission.role_permissions, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'permission_id' })
+  permission: Permission;
+
+  @ManyToOne(() => Role, (role) => role.role_permissions, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'role_id' })
+  role: Role;
+}

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

@@ -0,0 +1,43 @@
+import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Shift } from './shift.entity';
+
+@Entity({ name: 'role_shifts', schema: 'timesheet' })
+export class RoleShift extends BaseEntity {
+  @Column({
+    name: 'role_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'Role id',
+  })
+  role_id: number;
+
+  @Column({
+    name: 'shift_id',
+    type: 'integer',
+    nullable: true,
+    comment: 'Shift id',
+  })
+  shift_id: number;
+
+  // @Column({
+  //   name: 'shift_start_date',
+  //   type: 'date',
+  //   nullable: true,
+  //   comment: 'Shift start date',
+  // })
+  // shift_start_date: Date;
+
+  // @Column({
+  //   name: 'shift_end_date',
+  //   type: 'date',
+  //   nullable: true,
+  //   comment: 'Shift end date',
+  // })
+  // shift_end_date: Date;
+  
+  @ManyToOne(() => Shift)
+  @JoinColumn({ name: 'shift_id' })
+  shift: Shift;
+  
+}

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

@@ -0,0 +1,30 @@
+import { Entity, Column,OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { RolePermission } from './role-permission.entity';
+import {UserRole} from './user-role.entity'
+@Entity({ name: 'roles', schema: 'user' })
+export class Role extends BaseEntity {
+  @Column({ name: 'role_name', unique: true })
+  roleName: string;
+
+  @Column({ name: 'role_slug', unique: false })
+  roleSlug: string;
+
+  @Column({ name: 'is_main_role_slug', default:false, type: 'boolean' })
+  isMainRoleSlug: boolean;
+
+  @Column({ name: 'role_description', nullable: true, type: 'text' })
+  roleDescription: string;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+
+  @OneToMany(() => RolePermission, (rolePermission) => rolePermission.role)
+  role_permissions: RolePermission[];
+
+  @OneToMany(() => UserRole, (userRole) => userRole.role)
+  user_roles: UserRole[];
+
+  // @OneToMany(() => ApprovalHierarchy, (approvalHierarchy) => approvalHierarchy.role)
+  // approval_hierarchy: ApprovalHierarchy[];
+} 

package/src/database/entities/sequence-generator.entity.ts

@@ -0,0 +1,40 @@
+import { Entity, Column, Unique } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'sequence_generator', schema: 'core'})
+@Unique(['module', 'prefix', 'year'])
+export class SequenceGenerator extends BaseEntity {
+  @Column({
+    name: 'module',
+    type: 'varchar',
+    length: 50,
+    nullable: false,
+    comment: 'Module name (e.g., PROFILE, USER, etc.)'
+  })
+  module: string;
+  
+  @Column({
+    name: 'prefix',
+    type: 'varchar',
+    length: 10,
+    nullable: false,
+    comment: 'Prefix for the sequence (e.g., PROF)'
+  })
+  prefix: string;
+  
+  @Column({
+    name: 'last_sequence',
+    type: 'int',
+    nullable: false,
+    comment: 'Last used sequence number'
+  })
+  lastSequence: number;
+  
+  @Column({
+    name: 'year',
+    type: 'int',
+    nullable: true,
+    comment: 'Year for which sequence is being generated (null for non-reset modules)'
+  })
+  year: number | null;
+} 

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

@@ -0,0 +1,72 @@
+import { Column, Entity, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { User } from './user.entity';
+import { UserShift } from './user-shift.entity';
+import { RoleShift } from './role-shift.entity';
+
+@Entity({ name: 'shifts', schema: 'timesheet' })
+export class Shift extends BaseEntity {
+  @Column({
+    name: 'shift_name',
+    type: 'varchar',
+    nullable: false,
+    comment: 'Name of the shift',
+  })
+  shift_name: string;
+
+  @Column({
+    name: 'shift_start_time',
+    type: 'time',
+    nullable: false,
+    comment: 'Start time of the shift',
+  })
+  shift_start_time: string;
+
+  @Column({
+    name: 'shift_end_time',
+    type: 'time',
+    nullable: false,
+    comment: 'End time of the shift',
+  })
+  shift_end_time: string;
+
+  @Column({
+    name: 'break',
+    type: 'integer',
+    nullable: false,
+    comment: 'Break in minutes',
+  })
+  break: number;
+
+  @Column({
+    name: 'grace',
+    type: 'integer',
+    nullable: false,
+    comment: 'Grace in minutes',
+  })
+  grace: number;
+
+  @Column({
+    name: 'is_active',
+    type: 'boolean',
+    nullable: false,
+    comment: 'Is active',
+  })
+  is_active: boolean;
+
+  @ManyToOne(() => User, (user) => user.shifts)
+  @JoinColumn({ name: 'created_by' })
+  created_By: User;
+
+  @OneToMany(() => UserShift, (userShift) => userShift.current_shift)
+  user_current_shifts: UserShift[];
+
+  @OneToMany(() => UserShift, (userShift) => userShift.current_alternate_shift)
+  user_alternate_shifts: UserShift[];
+
+  @OneToMany(() => UserShift, (userShift) => userShift.planned_shift)
+  user_planned_shifts: UserShift[];
+
+  @OneToMany(() => RoleShift, (roleShift) => roleShift.shift)
+  role_shifts: RoleShift[];
+}

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

@@ -0,0 +1,22 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Tag } from './tag.entity';
+import { SubTask } from './subtask.entity';
+
+@Entity({ name: 'sub_tasks_tags', schema: 'core' })
+export class SubTaskTag extends BaseEntity {
+  @Column({ name: 'sub_task_id' })
+  subTaskId: number;
+
+  // Relationship
+  @ManyToOne(() => SubTask, (subTask) => subTask.subtaskLabel)
+  @JoinColumn({ name: 'sub_task_id' })
+  subTask: SubTask;
+
+  @Column({ name: 'tag_id' })
+  tagId: number;
+
+  @ManyToOne(() => Tag, (tag) => tag.tagsLabel)
+  @JoinColumn({ name: 'tag_id' })
+  tag: Tag;
+}

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

@@ -0,0 +1,21 @@
+import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { SubTask } from './subtask.entity';
+import { User } from './user.entity';
+
+@Entity({ name: 'subtask_users', schema: 'core' })
+export class SubTaskUser extends BaseEntity {
+  @Column({ name: 'subtask_id' })
+  subtaskId: number;
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @ManyToOne(() => SubTask, subtask => subtask.subtaskUsers)
+  @JoinColumn({ name: 'subtask_id' })
+  subtask: SubTask;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+}

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

@@ -0,0 +1,125 @@
+import { Entity, Column, ManyToOne, OneToMany, JoinColumn } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Matter } from './matter.entity';
+import { User } from './user.entity';
+import { Task } from './task.entity';
+import { TaskComment } from './task-comment.entity';
+import { SubTaskTag } from './sub-task-tag.entity';
+import { TaskReminder } from './task-remainder.entity';
+import { SubTaskUser } from './subtask-user.entity';
+
+import { TaskType } from './task-type.entity';
+import { TaskMilestone } from './task-milestone.entity';
+
+export enum SubTaskStatus {
+  IN_PROGRESS = 'In Progress',
+  COMPLETED = 'Completed',
+  ON_HOLD = 'On Hold',
+  TO_DO = 'To-Do',
+}
+
+@Entity({ name: 'sub_tasks', schema: 'core' })
+export class SubTask extends BaseEntity {
+
+  @Column({ name: 'sub_task_id', nullable: false })
+  subTaskId: string;
+
+  @Column({ name: 'task_id', nullable: true })
+  taskId: number;
+
+  @Column({ name: 'title', length: 200 })
+  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; // Store only userId, no relation to User entity
+
+  @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({
+  //   name: 'milestones',
+  //   nullable: true,
+  //   type: 'enum',
+  //   enum: ['1', '2', '3', '4']
+  // })
+  // milestones: string;
+
+  @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', nullable: true })
+  status: string;
+
+  @Column({ name: 'start_date', type: 'timestamp', nullable: true })
+  startDate: Date;
+
+  @Column({ name: 'due_date', type: 'timestamp', nullable: true })
+  dueDate: Date;
+
+  // Relationships
+  @ManyToOne(() => Matter, matter => matter.tasks)
+  @JoinColumn({ name: 'matter_id' })
+  matter: Matter;
+
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'assigned_to' })
+  assignedUser: User;
+
+  @OneToMany(() => SubTaskTag, subtaskTag => subtaskTag.subTask)
+  subtaskLabel: SubTaskTag[];
+
+  @ManyToOne(() => Task, task => task.subtasks)
+  @JoinColumn({ name: 'task_id' })
+  task: Task;
+
+  @OneToMany(() => TaskComment, taskComment => taskComment.subTask)
+  comments: TaskComment[];
+
+  @OneToMany(() => TaskReminder, taskReminder => taskReminder.subTask)
+  reminders: TaskReminder[];
+
+  @OneToMany(() => SubTaskUser, subtaskUser => subtaskUser.subtask)
+  subtaskUsers: SubTaskUser[];
+
+  @ManyToOne(() => TaskType)
+  @JoinColumn({ name: 'task_type_id' })
+  taskType: TaskType;
+
+  @ManyToOne(() => TaskMilestone)
+  @JoinColumn({ name: 'milestone_id' })
+  milestone: TaskMilestone;
+
+}

package/src/database/entities/summary-task-status.entity.ts

@@ -0,0 +1,15 @@
+import { Entity, Column, Index } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'task_status', schema: 'core', synchronize: false })
+export class TaskStatus extends BaseEntity {
+  @Index({ unique: true })
+  @Column({ nullable: false, name: 'process_id' })
+  processId: string;
+
+  @Column({ nullable: false, name: 'status' })
+  status: string;
+
+  @Column({ type: 'float', nullable: true, name: 'time_taken' })
+  timeTaken: number;
+}

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

@@ -0,0 +1,38 @@
+import { BaseEntity } from './base.entity';
+import { Column, Entity, ManyToOne, JoinColumn } from 'typeorm';
+import { User } from './user.entity';
+
+@Entity({ name: 'superset', schema: 'core'})
+export class Superset extends BaseEntity {
+  @Column({ name: 'chart_id', nullable:true })
+  chartId: number;
+
+  @Column({ name: 'datasource_id' })
+  datasourceId: number;
+
+  @Column({ name: 'chart_embed_link', type: 'varchar', length: 255, nullable: true })
+  chartEmbedLink: string;
+
+  @Column({ name: 'datasource_name', type: 'varchar', nullable: true })
+  datasourceName: string;
+
+  @Column({ name: 'viz_type', type: 'varchar', nullable: true })
+  vizType: string;
+
+  @Column({ name: 'slice_name', type: 'varchar', length: 255, nullable: true })
+  sliceName: string;
+
+  @Column({ type: 'varchar', length: 2000, nullable: true })
+  params: string;
+
+  @Column({ default: false })
+  isfavourite: boolean;
+
+  @Column({ default: false })
+  ispermanent: boolean
+
+  @ManyToOne(() => User, (user) => user.supersetCharts, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'created_by' })
+  user: User;
+
+} 

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

@@ -0,0 +1,19 @@
+import { Entity, Column, OneToMany } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { MatterTag } from './matter-tag.entity';
+import { TaskTag } from './task-tag.entity';
+
+@Entity({ name: 'tags', schema: 'core' })
+export class Tag extends BaseEntity {
+  @Column()
+  tagName: string;
+
+  @Column({ nullable: true, default: 'MATTER' })
+  module: string;
+
+  @OneToMany(() => MatterTag, (matterTag) => matterTag.tag)
+  mattersLabel: MatterTag[];
+
+  @OneToMany(() => TaskTag, (taskTag) => taskTag.tag)
+  tagsLabel: TaskTag[];
+}

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

@@ -0,0 +1,41 @@
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+} from 'typeorm';
+import { SubTask } from "./subtask.entity";
+import { Task } from "./task.entity";
+import { User } from "./user.entity";
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'task_comments', schema: 'core' })
+export class TaskComment extends BaseEntity {
+  
+  @Column({ name: 'user_id', nullable: false })
+  userId: number;
+
+  @Column({ name: 'task_id', nullable: false })
+  taskId: number;
+
+  @Column({ name: 'sub_task_id', nullable: true })
+  subTaskId: number|null;
+
+  @Column({name:'is_parent',type:'boolean',default:false})
+  isParent: boolean;
+
+  @ManyToOne(() => SubTask, (subTask) => subTask.comments)
+  @JoinColumn({ name: 'sub_task_id' })
+  subTask: SubTask;
+
+  @ManyToOne(() => Task, (task) => task.comments)
+  @JoinColumn({ name: 'task_id' })
+  task: Task;
+
+  @Column({ name: 'comment', type: 'varchar', nullable: false })
+  comment: string;
+
+  @ManyToOne(() => User, (user) => user.taskComments)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+}

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

@@ -0,0 +1,14 @@
+import { Entity, Column } from 'typeorm';
+import { BaseEntity } from './base.entity';
+
+@Entity({ name: 'task_milestones', schema: 'core' })
+export class TaskMilestone 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;
+}