@hed-hog/operations 0.0.305 → 0.0.306

package/src/operations.service.ts

@@ -2065,22 +2065,19 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'code', 'clientName', 'startDate', 'endDate'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const filter = this.buildIdFilter(actor.visibleProjectIds, 'p.id', actor.isDirector);
+    const params: unknown[] = [...filter.params];
     const filters = [
       'p.deleted_at IS NULL',
       'pa.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
       `pa.status IN ('planned', 'active')`,
+      filter.clause,
     ];
 
     if (pagination.search) {
@@ -2174,23 +2171,30 @@ export class OperationsService {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
 
-    if (!actor.collaboratorId) {
-      throw new BadRequestException('Collaborator context is required.');
-    }
-
     const pagination = this.normalizePaginationParams(paginationParams, {
       defaultSortField: 'name',
       defaultSortOrder: 'asc',
       allowedSortFields: ['name', 'projectName', 'status', 'createdAt'],
     });
 
-    const params: unknown[] = [actor.collaboratorId];
+    const projectFilter = this.buildIdFilter(
+      actor.visibleProjectIds,
+      'COALESCE(t.project_id, pa.project_id)',
+      actor.isDirector
+    );
+    const params: unknown[] = [...projectFilter.params];
     const filters = [
       't.deleted_at IS NULL',
-      'pa.deleted_at IS NULL',
       'p.deleted_at IS NULL',
-      `pa.collaborator_id = $1`,
-      `pa.status IN ('planned', 'active')`,
+      projectFilter.clause,
+      `(
+        t.project_id IS NOT NULL
+        OR (
+          pa.id IS NOT NULL
+          AND pa.deleted_at IS NULL
+          AND pa.status IN ('planned', 'active')
+        )
+      )`,
     ];
 
     if (pagination.search) {
@@ -2208,7 +2212,12 @@ export class OperationsService {
     }
 
     if (paginationParams.projectId) {
-      filters.push(`pa.project_id = ${this.param(params, paginationParams.projectId)}`);
+      filters.push(
+        `COALESCE(t.project_id, pa.project_id) = ${this.param(
+          params,
+          paginationParams.projectId
+        )}`
+      );
     }
 
     if (paginationParams.status) {
@@ -2219,10 +2228,10 @@ export class OperationsService {
     const totalRow = await this.querySingle<{ total: string }>(
       `SELECT COUNT(*)::text AS total
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}`,
       params
     );
@@ -2254,16 +2263,16 @@ export class OperationsService {
               t.name,
               t.description,
               t.status,
-              pa.project_id AS "projectId",
+              COALESCE(t.project_id, pa.project_id) AS "projectId",
               pa.id AS "projectAssignmentId",
               p.name AS "projectName",
               p.code AS "projectCode",
               t.created_at AS "createdAt"
          FROM operations_task t
-         JOIN operations_project_assignment pa
+         LEFT JOIN operations_project_assignment pa
            ON pa.id = t.project_assignment_id
          JOIN operations_project p
-           ON p.id = pa.project_id
+           ON p.id = COALESCE(t.project_id, pa.project_id)
         WHERE ${whereClause}
         ORDER BY ${sortColumn} ${pagination.sortOrder.toUpperCase()}, t.id ASC
         LIMIT ${limitPlaceholder}
@@ -2699,9 +2708,9 @@ export class OperationsService {
         ? await this.getOwnedTaskRecord(tx as any, actor.collaboratorId as number, data.taskId)
         : null;
 
-      if (resolvedTask && resolvedTask.projectAssignmentId !== assignment.id) {
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -2760,6 +2769,116 @@ export class OperationsService {
     return this.getTimesheetEntryByIdForActor(actor, createdEntryId);
   }
 
+  async updateTimesheetEntry(
+    userId: number,
+    entryId: number,
+    data: QuickTimesheetEntryPayload
+  ) {
+    const actor = await this.getActorContext(userId);
+    this.ensureCollaborator(actor);
+    this.requireFields(data as Record<string, unknown>, ['workDate', 'duration']);
+
+    if (!actor.collaboratorId && !actor.isDirector) {
+      throw new BadRequestException('Collaborator context is required.');
+    }
+
+    const entry = await this.getTimesheetEntryByIdForActor(actor, entryId);
+
+    if (!actor.isDirector && entry.collaboratorId !== actor.collaboratorId) {
+      throw new ForbiddenException(
+        'Only the entry owner can update this timesheet entry.'
+      );
+    }
+
+    if (!['draft', 'rejected'].includes(entry.status)) {
+      throw new BadRequestException(
+        'Only draft or rejected timesheet entries can be edited.'
+      );
+    }
+
+    const collaboratorId = actor.isDirector
+      ? entry.collaboratorId
+      : (actor.collaboratorId as number);
+    const durationMinutes = this.normalizeDurationMinutes(data.duration, data.unit);
+    const taskLabel =
+      this.normalizeOptionalText(data.taskName) ??
+      this.normalizeOptionalText(data.activityLabel);
+    const targetWeek = this.getWorkWeekRange(data.workDate);
+    const isSameWeek =
+      entry.weekStartDate === targetWeek.weekStartDate &&
+      entry.weekEndDate === targetWeek.weekEndDate;
+
+    await this.prisma.$transaction(async (tx) => {
+      const assignment = await this.resolveOwnedProjectAssignment(
+        tx as any,
+        collaboratorId,
+        {
+          projectId: data.projectId ?? null,
+          projectAssignmentId: data.projectAssignmentId ?? null,
+        }
+      );
+
+      const resolvedTask = data.taskId
+        ? await this.getOwnedTaskRecord(tx as any, collaboratorId, data.taskId)
+        : null;
+
+      if (resolvedTask && resolvedTask.projectId !== assignment.projectId) {
+        throw new BadRequestException(
+          'The selected task does not belong to the chosen project.'
+        );
+      }
+
+      const activityLabel =
+        resolvedTask?.name ?? taskLabel ?? assignment.roleLabel ?? assignment.projectName;
+
+      if (!activityLabel) {
+        throw new BadRequestException('A task is required for the timesheet entry.');
+      }
+
+      const targetTimesheetId = isSameWeek
+        ? entry.timesheetId
+        : await this.getOrCreateTimesheetForWorkDate(
+            tx as any,
+            collaboratorId,
+            data.workDate
+          );
+
+      await (tx as any).$executeRawUnsafe(
+        `UPDATE operations_timesheet_entry
+            SET timesheet_id = $1,
+                project_assignment_id = $2,
+                task_id = $3,
+                activity_label = $4,
+                work_date = $5::date,
+                duration_minutes = $6,
+                hours = $7,
+                description = $8,
+                updated_at = NOW()
+          WHERE id = $9
+            AND deleted_at IS NULL`,
+        targetTimesheetId,
+        assignment.id,
+        resolvedTask?.id ?? data.taskId ?? null,
+        activityLabel,
+        data.workDate,
+        durationMinutes,
+        Number((durationMinutes / 60).toFixed(2)),
+        this.normalizeOptionalText(data.description),
+        entryId
+      );
+
+      await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+
+      if (targetTimesheetId !== entry.timesheetId) {
+        await this.refreshTimesheetTotal(tx as any, targetTimesheetId);
+      }
+
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
+    });
+
+    return this.getTimesheetEntryByIdForActor(actor, entryId);
+  }
+
   async removeTimesheetEntry(userId: number, entryId: number) {
     const actor = await this.getActorContext(userId);
     this.ensureCollaborator(actor);
@@ -2793,6 +2912,7 @@ export class OperationsService {
       );
 
       await this.refreshTimesheetTotal(tx as any, entry.timesheetId);
+      await this.cleanupEmptyEditableTimesheet(tx as any, entry.timesheetId);
     });
 
     return { success: true };
@@ -3129,7 +3249,11 @@ export class OperationsService {
           updated_at
         ) VALUES (
           $1, $2, $3, $4,
-          $5, $6, $7, $8, $9, $10, $11,
+          $5::text::operations_contract_template_contract_category_49bb07a713_enum,
+          $6::text::operations_contract_template_contract_type_3962dbda6a_enum,
+          $7::text::operations_contract_template_billing_model_384a7c60e2_enum,
+          $8::text::operations_contract_template_signature_status_56cb6d625b_enum,
+          $9, $10::text::operations_contract_template_status_c9d2e90231_enum, $11,
           NOW(), NOW()
         )
         RETURNING id`,
@@ -3218,12 +3342,12 @@ export class OperationsService {
                 code = $2,
                 name = $3,
                 description = $4,
-                contract_category = $5,
-                contract_type = $6,
-                billing_model = $7,
-                signature_status = $8,
+                contract_category = $5::text::operations_contract_template_contract_category_49bb07a713_enum,
+                contract_type = $6::text::operations_contract_template_contract_type_3962dbda6a_enum,
+                billing_model = $7::text::operations_contract_template_billing_model_384a7c60e2_enum,
+                signature_status = $8::text::operations_contract_template_signature_status_56cb6d625b_enum,
                 is_active = $9,
-                status = $10,
+                status = $10::text::operations_contract_template_status_c9d2e90231_enum,
                 content_html = $11,
                 updated_at = NOW()
           WHERE id = $12`,
@@ -5126,8 +5250,26 @@ export class OperationsService {
     }
 
     const collaborator = await this.getCollaboratorById(current.collaboratorId);
+
+    const projectManagerRow = await this.querySingle<{
+      managerCollaboratorId: number | null;
+    }>(
+      `SELECT p.manager_collaborator_id AS "managerCollaboratorId"
+         FROM operations_timesheet_entry e
+         LEFT JOIN operations_project_assignment pa ON pa.id = e.project_assignment_id
+         LEFT JOIN operations_project p ON p.id = pa.project_id
+        WHERE e.timesheet_id = $1
+          AND e.deleted_at IS NULL
+          AND p.manager_collaborator_id IS NOT NULL
+        LIMIT 1`,
+      [timesheetId]
+    );
+
     const approverId =
-      current.approverCollaboratorId ?? collaborator.supervisorId ?? null;
+      projectManagerRow?.managerCollaboratorId ??
+      current.approverCollaboratorId ??
+      collaborator.supervisorId ??
+      null;
 
     if (!approverId) {
       throw new BadRequestException(
@@ -5360,7 +5502,8 @@ export class OperationsService {
       endTime: string | null;
       breakMinutes: number | null;
     }>(
-      `SELECT collaborator_id AS "collaboratorId",
+      `SELECT DISTINCT ON (collaborator_id, weekday)
+              collaborator_id AS "collaboratorId",
               weekday,
               is_working_day AS "isWorkingDay",
               start_time AS "startTime",
@@ -5368,7 +5511,7 @@ export class OperationsService {
               break_minutes AS "breakMinutes"
          FROM operations_collaborator_schedule_day
         WHERE collaborator_id = ANY($1::int[])
-        ORDER BY id ASC`,
+        ORDER BY collaborator_id, weekday, id DESC`,
       [this.uniqueNumbers(requests.map((item) => item.collaboratorId))]
     );
 
@@ -5821,21 +5964,51 @@ export class OperationsService {
   private async getCollaboratorByUserId(userId: number) {
     return this.querySingle<{
       id: number;
+      userId: number | null;
+      personId: number | null;
       displayName: string;
       supervisorId: number | null;
       supervisorName: string | null;
+      activeAssignments: number;
     }>(
-      `SELECT c.id,
+      `WITH linked_collaborator AS (
+         SELECT person_id
+           FROM operations_collaborator
+          WHERE user_id = $1
+            AND deleted_at IS NULL
+          ORDER BY id DESC
+          LIMIT 1
+       )
+       SELECT c.id,
+              c.user_id AS "userId",
+              c.person_id AS "personId",
               COALESCE(NULLIF(c.display_name, ''), person_record.name) AS "displayName",
               s.id AS "supervisorId",
-              s.display_name AS "supervisorName"
+              s.display_name AS "supervisorName",
+              COUNT(pa.id) FILTER (
+                WHERE pa.deleted_at IS NULL
+                  AND pa.status IN ('planned', 'active')
+              )::int AS "activeAssignments"
          FROM operations_collaborator c
          LEFT JOIN person person_record
            ON person_record.id = c.person_id
          LEFT JOIN operations_collaborator s
            ON s.id = c.supervisor_collaborator_id
-        WHERE c.user_id = $1
-          AND c.deleted_at IS NULL`,
+         LEFT JOIN operations_project_assignment pa
+           ON pa.collaborator_id = c.id
+        WHERE c.deleted_at IS NULL
+          AND (
+            c.user_id = $1
+            OR (
+              c.person_id IS NOT NULL
+              AND c.person_id = (SELECT person_id FROM linked_collaborator)
+            )
+          )
+        GROUP BY c.id, person_record.id, s.id
+        ORDER BY "activeAssignments" DESC,
+                 CASE WHEN c.user_id = $1 THEN 0 ELSE 1 END,
+                 c.id ASC
+        LIMIT 1`,
       [userId]
     );
   }
@@ -7705,23 +7878,26 @@ export class OperationsService {
     const assignmentIds = entries
       .map((entry) => entry.projectAssignmentId)
       .filter((value): value is number => typeof value === 'number');
+    const assignmentMap = new Map<
+      number,
+      { id: number; collaboratorId: number; projectId: number }
+    >();
 
     if (assignmentIds.length) {
       const assignments = (await client.$queryRawUnsafe(
-        `SELECT id, collaborator_id AS "collaboratorId"
+        `SELECT id,
+                collaborator_id AS "collaboratorId",
+                project_id AS "projectId"
            FROM operations_project_assignment
           WHERE id = ANY($1::int[])
             AND deleted_at IS NULL`,
         assignmentIds
-      )) as { id: number; collaboratorId: number }[];
-      const assignmentMap = new Map(
-        assignments.map((assignment) => [
-          assignment.id,
-          assignment.collaboratorId,
-        ])
-      );
+      )) as { id: number; collaboratorId: number; projectId: number }[];
+      assignments.forEach((assignment) => {
+        assignmentMap.set(assignment.id, assignment);
+      });
       for (const assignmentId of assignmentIds) {
-        if (assignmentMap.get(assignmentId) !== collaboratorId) {
+        if (assignmentMap.get(assignmentId)?.collaboratorId !== collaboratorId) {
           throw new ForbiddenException(
             'Timesheet entries must use assignments owned by the target collaborator.'
           );
@@ -7735,14 +7911,17 @@ export class OperationsService {
       const resolvedTask = entry.taskId
         ? await this.getOwnedTaskRecord(client, collaboratorId, entry.taskId)
         : null;
+      const selectedAssignment = entry.projectAssignmentId
+        ? assignmentMap.get(entry.projectAssignmentId) ?? null
+        : null;
 
       if (
         resolvedTask &&
-        entry.projectAssignmentId &&
-        resolvedTask.projectAssignmentId !== entry.projectAssignmentId
+        selectedAssignment &&
+        resolvedTask.projectId !== selectedAssignment.projectId
       ) {
         throw new BadRequestException(
-          'The selected task does not belong to the chosen project assignment.'
+          'The selected task does not belong to the chosen project.'
         );
       }
 
@@ -7816,6 +7995,37 @@ export class OperationsService {
     );
   }
 
+  private async cleanupEmptyEditableTimesheet(client: any, timesheetId: number) {
+    const candidate = (await client.$queryRawUnsafe(
+      `SELECT t.id
+         FROM operations_timesheet t
+        WHERE t.id = $1
+          AND t.deleted_at IS NULL
+          AND t.status IN ('draft', 'rejected')
+          AND NOT EXISTS (
+            SELECT 1
+              FROM operations_timesheet_entry e
+             WHERE e.timesheet_id = t.id
+               AND e.deleted_at IS NULL
+          )
+        LIMIT 1`,
+      timesheetId
+    )) as Array<{ id: number }>;
+
+    if (!candidate[0]?.id) {
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `UPDATE operations_timesheet
+          SET deleted_at = NOW(),
+              updated_at = NOW()
+        WHERE id = $1
+          AND deleted_at IS NULL`,
+      timesheetId
+    );
+  }
+
   private async upsertApproval(
     client: any,
     input: {