@hed-hog/operations 0.0.302 → 0.0.304

package/src/operations.service.spec.ts

@@ -2,6 +2,7 @@
 
 import { BadRequestException } from '@nestjs/common';
 import { OperationsService } from './operations.service';
+import { OperationsAccessService } from './services/shared/operations-access.service';
 
 describe('OperationsService proposal integration', () => {
   let service: OperationsService;
@@ -23,6 +24,7 @@ describe('OperationsService proposal integration', () => {
       integrationApi as any,
       {} as any,
       {} as any,
+      new OperationsAccessService(),
     );
 
     jest.spyOn(service as any, 'generateContractCode').mockResolvedValue('CTR-001');
@@ -208,3 +210,451 @@ describe('OperationsService proposal integration', () => {
     );
   });
 });
+
+describe('OperationsService quick-entry timesheets', () => {
+  let service: OperationsService;
+
+  beforeEach(() => {
+    service = new OperationsService(
+      {
+        $transaction: jest.fn(),
+      } as any,
+      {} as any,
+      {
+        publishEvent: jest.fn().mockResolvedValue(undefined),
+      } as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest.spyOn(service as any, 'getActorContext').mockResolvedValue({
+      userId: 15,
+      roleSlugs: ['admin-operations-collaborator'],
+      collaboratorId: 7,
+      collaboratorName: 'Taylor Tester',
+      isDirector: false,
+      isSupervisor: false,
+      isCollaborator: true,
+      teamCollaboratorIds: [],
+      visibleCollaboratorIds: [7],
+      visibleProjectIds: [11],
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('rejects quick entries with non-positive duration', async () => {
+    await expect(
+      service.createTimesheetEntry(15, {
+        projectId: 11,
+        workDate: '2026-04-09',
+        duration: 0,
+        unit: 'minutes',
+      } as any),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('rejects quick entries without a work date', async () => {
+    await expect(
+      service.createTimesheetEntry(15, {
+        projectId: 11,
+        duration: 30,
+        unit: 'minutes',
+      } as any),
+    ).rejects.toThrow(BadRequestException);
+  });
+
+  it('stores quick-entry duration in minutes and keeps hours compatible', async () => {
+    const tx = {
+      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 91 }]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'resolveOwnedProjectAssignment').mockResolvedValue({
+      id: 33,
+      projectId: 11,
+      projectName: 'Project Atlas',
+      projectCode: 'OPS-11',
+      roleLabel: 'Engineer',
+    });
+    jest.spyOn(service as any, 'getOwnedTaskRecord').mockResolvedValue({
+      id: 44,
+      name: 'Implement API',
+      projectAssignmentId: 33,
+      projectId: 11,
+      projectName: 'Project Atlas',
+      projectCode: 'OPS-11',
+    });
+    jest.spyOn(service as any, 'getOrCreateTimesheetForWorkDate').mockResolvedValue(55);
+    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+      id: 91,
+      durationMinutes: 90,
+      hours: 1.5,
+    });
+
+    const result = await service.createTimesheetEntry(15, {
+      projectId: 11,
+      taskId: 44,
+      workDate: '2026-04-09',
+      duration: 1.5,
+      unit: 'hours',
+      description: 'Worked on the API layer',
+    } as any);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        id: 91,
+        durationMinutes: 90,
+        hours: 1.5,
+      }),
+    );
+    expect(tx.$queryRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('INSERT INTO operations_timesheet_entry'),
+      55,
+      33,
+      44,
+      'Implement API',
+      '2026-04-09',
+      90,
+      1.5,
+      'Worked on the API layer',
+    );
+  });
+
+  it('uses the task assignment when full timesheet entries omit projectAssignmentId', async () => {
+    const tx = {
+      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 55 }]),
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
+      id: 7,
+      supervisorId: 18,
+    });
+    jest.spyOn(service as any, 'getOwnedTaskRecord').mockResolvedValue({
+      id: 44,
+      name: 'Implement API',
+      projectAssignmentId: 33,
+      projectId: 11,
+      projectName: 'Project Atlas',
+      projectCode: 'OPS-11',
+    });
+    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
+      id: 55,
+      status: 'draft',
+    });
+
+    await service.createTimesheet(15, {
+      weekStartDate: '2026-04-06',
+      weekEndDate: '2026-04-12',
+      entries: [
+        {
+          taskId: 44,
+          workDate: '2026-04-09',
+          duration: 2,
+          unit: 'hours',
+          description: 'Worked on the API layer',
+        },
+      ],
+    } as any);
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('INSERT INTO operations_timesheet_entry'),
+      55,
+      33,
+      44,
+      'Implement API',
+      '2026-04-09',
+      120,
+      2,
+      'Worked on the API layer',
+    );
+  });
+
+  it('rejects submitting a timesheet without a resolved approver', async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValue([{ id: 1 }]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'getTimesheetById').mockResolvedValue({
+      id: 55,
+      collaboratorId: 7,
+      approverCollaboratorId: null,
+      status: 'draft',
+    });
+    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
+      id: 7,
+      supervisorId: null,
+    });
+    jest.spyOn(service as any, 'upsertApproval').mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
+      id: 55,
+      status: 'submitted',
+    });
+
+    await expect(service.submitTimesheet(15, 55)).rejects.toThrow(BadRequestException);
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
+  });
+
+  it('rejects submitting a timesheet without active entries', async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValue([]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'getTimesheetById').mockResolvedValue({
+      id: 56,
+      collaboratorId: 7,
+      approverCollaboratorId: 18,
+      status: 'draft',
+    });
+    jest.spyOn(service as any, 'getCollaboratorById').mockResolvedValue({
+      id: 7,
+      supervisorId: 18,
+    });
+    jest.spyOn(service as any, 'querySingle').mockResolvedValue({ exists: false });
+    jest.spyOn(service as any, 'upsertApproval').mockResolvedValue(undefined);
+    jest.spyOn(service as any, 'listSingleTimesheet').mockResolvedValue({
+      id: 56,
+      status: 'submitted',
+    });
+
+    await expect(service.submitTimesheet(15, 56)).rejects.toThrow(BadRequestException);
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalled();
+  });
+
+  it('deletes only draft quick entries and refreshes the weekly total', async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+      id: 91,
+      timesheetId: 55,
+      collaboratorId: 7,
+      status: 'draft',
+    });
+    jest.spyOn(service as any, 'refreshTimesheetTotal').mockResolvedValue(undefined);
+
+    await expect(service.removeTimesheetEntry(15, 91)).resolves.toEqual({
+      success: true,
+    });
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('UPDATE operations_timesheet_entry'),
+      91,
+    );
+    expect((service as any).refreshTimesheetTotal).toHaveBeenCalledWith(tx, 55);
+  });
+
+  it('rejects deleting entries from submitted timesheets', async () => {
+    jest.spyOn(service as any, 'getTimesheetEntryByIdForActor').mockResolvedValue({
+      id: 92,
+      timesheetId: 56,
+      collaboratorId: 7,
+      status: 'submitted',
+    });
+
+    await expect(service.removeTimesheetEntry(15, 92)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+});
+
+describe('OperationsService approval side effects', () => {
+  let service: OperationsService;
+
+  beforeEach(() => {
+    service = new OperationsService(
+      {
+        $transaction: jest.fn(),
+      } as any,
+      {} as any,
+      {
+        publishEvent: jest.fn().mockResolvedValue(undefined),
+      } as any,
+      {} as any,
+      {} as any,
+      new OperationsAccessService(),
+    );
+
+    jest.spyOn(service as any, 'getActorContext').mockResolvedValue({
+      userId: 22,
+      roleSlugs: ['admin-operations-supervisor'],
+      collaboratorId: 18,
+      collaboratorName: 'Sam Supervisor',
+      isDirector: false,
+      isSupervisor: true,
+      isCollaborator: false,
+      teamCollaboratorIds: [7],
+      visibleCollaboratorIds: [7, 18],
+      visibleProjectIds: [11],
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('applies approved permanent schedule adjustments to the active collaborator weekly schedule', async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest
+        .fn()
+        .mockResolvedValueOnce([
+          {
+            collaboratorId: 7,
+            requestScope: 'permanent',
+          },
+        ])
+        .mockResolvedValueOnce([
+          {
+            weekday: 'monday',
+            isWorkingDay: true,
+            startTime: '08:00',
+            endTime: '17:00',
+            breakMinutes: 45,
+          },
+          {
+            weekday: 'friday',
+            isWorkingDay: false,
+            startTime: null,
+            endTime: null,
+            breakMinutes: 0,
+          },
+        ]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'querySingle')
+      .mockResolvedValueOnce({
+        id: 81,
+        targetType: 'schedule_adjustment_request',
+        targetId: 400,
+        requesterCollaboratorId: 7,
+        approverCollaboratorId: 18,
+        status: 'pending',
+      })
+      .mockResolvedValueOnce({
+        id: 81,
+        targetType: 'schedule_adjustment_request',
+        targetId: 400,
+        status: 'approved',
+        decidedAt: '2026-04-11T12:00:00.000Z',
+        decisionNote: 'Approved for the new weekly schedule.',
+      });
+    jest.spyOn(service as any, 'insertApprovalHistory').mockResolvedValue(undefined);
+
+    await expect(
+      service.approve(22, 81, {
+        note: 'Approved for the new weekly schedule.',
+      }),
+    ).resolves.toEqual(
+      expect.objectContaining({
+        id: 81,
+        status: 'approved',
+      }),
+    );
+
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('UPDATE operations_schedule_adjustment_request'),
+      'approved',
+      18,
+      400,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('UPDATE operations_collaborator_schedule_day'),
+      7,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'),
+      7,
+      'monday',
+      true,
+      '08:00',
+      '17:00',
+      45,
+    );
+    expect(tx.$executeRawUnsafe).toHaveBeenCalledWith(
+      expect.stringContaining('INSERT INTO operations_collaborator_schedule_day'),
+      7,
+      'friday',
+      false,
+      null,
+      null,
+      0,
+    );
+  });
+
+  it('keeps the collaborator weekly schedule unchanged for approved temporary adjustments', async () => {
+    const tx = {
+      $executeRawUnsafe: jest.fn().mockResolvedValue(undefined),
+      $queryRawUnsafe: jest.fn().mockResolvedValueOnce([
+        {
+          collaboratorId: 7,
+          requestScope: 'temporary',
+        },
+      ]),
+    };
+
+    (service as any).prisma.$transaction.mockImplementation(
+      async (callback: (client: unknown) => unknown) => callback(tx),
+    );
+
+    jest.spyOn(service as any, 'querySingle')
+      .mockResolvedValueOnce({
+        id: 82,
+        targetType: 'schedule_adjustment_request',
+        targetId: 401,
+        requesterCollaboratorId: 7,
+        approverCollaboratorId: 18,
+        status: 'pending',
+      })
+      .mockResolvedValueOnce({
+        id: 82,
+        targetType: 'schedule_adjustment_request',
+        targetId: 401,
+        status: 'approved',
+        decidedAt: '2026-04-11T12:05:00.000Z',
+        decisionNote: 'Approved as a temporary exception.',
+      });
+    jest.spyOn(service as any, 'insertApprovalHistory').mockResolvedValue(undefined);
+
+    await service.approve(22, 82, {
+      note: 'Approved as a temporary exception.',
+    });
+
+    expect(tx.$executeRawUnsafe).not.toHaveBeenCalledWith(
+      expect.stringContaining('UPDATE operations_collaborator_schedule_day'),
+      7,
+    );
+  });
+});