diff --git a/src/__tests__/integration/bmPaidLaborCostRoutes.integration.test.js b/src/__tests__/integration/bmPaidLaborCostRoutes.integration.test.js
new file mode 100644
index 000000000..51720758d
--- /dev/null
+++ b/src/__tests__/integration/bmPaidLaborCostRoutes.integration.test.js
@@ -0,0 +1,113 @@
+/**
+ * Integration Tests for Paid Labor Cost Routes
+ *
+ * This test suite covers:
+ * 1. Authorization tests (401 responses without auth token)
+ * 2. Route functionality tests (method validation, route existence)
+ *
+ * Note: These tests require the full app to be loaded, which may require
+ * additional dependencies (e.g., @aws-sdk/client-s3) to be installed.
+ */
+
+const request = require('supertest');
+const { app } = require('../../app');
+
+const agent = request.agent(app);
+
+describe('bmPaidLaborCostRoutes tests', () => {
+  // Global timeout for the entire test suite
+  jest.setTimeout(60000); // 1 minute
+
+  beforeAll(async () => {
+    console.log('=== Starting Paid Labor Cost Integration Test Setup ===');
+    console.log('✓ Test setup completed');
+    console.log('=== Paid Labor Cost Integration Test Setup Complete ===');
+  }, 60000); // 1 minute timeout for beforeAll
+
+  /**
+   * Authorization Tests
+   * Verifies that routes require authentication (return 401 without auth header)
+   */
+  describe('Authorization Tests', () => {
+    it('should return 401 if authorization header is not present for GET /api/labor-cost', async () => {
+      console.log('Testing 401 unauthorized access for GET /api/labor-cost...');
+
+      try {
+        await agent.get('/api/labor-cost').expect(401);
+        console.log('✓ GET /api/labor-cost 401 test passed');
+      } catch (error) {
+        console.error('❌ GET /api/labor-cost 401 test failed:', error.message);
+        throw error;
+      }
+    }, 30000);
+
+    it('should return 401 if authorization header is not present for GET with query params', async () => {
+      console.log('Testing 401 unauthorized access for GET /api/labor-cost with query params...');
+
+      try {
+        await agent.get('/api/labor-cost?projects=["A"]').expect(401);
+        console.log('✓ GET /api/labor-cost with query params 401 test passed');
+      } catch (error) {
+        console.error('❌ GET /api/labor-cost with query params 401 test failed:', error.message);
+        throw error;
+      }
+    }, 30000);
+  });
+
+  /**
+   * Route Functionality Tests
+   * Verifies route configuration and method handling
+   * Note: Full functionality tests require database connection.
+   * If database is not available, these become smoke tests.
+   */
+  describe('Route Functionality Tests', () => {
+    it('should return 404 or method not allowed for POST method', async () => {
+      console.log('Testing POST method (should not be allowed)...');
+
+      try {
+        const response = await agent.post('/api/labor-cost').send({});
+        // POST should return 404 (route doesn't exist), 405 (method not allowed), or 401 (auth required)
+        const { status } = response;
+        expect([404, 405, 401]).toContain(status);
+        console.log(`✓ POST /api/labor-cost returned ${status} as expected`);
+      } catch (error) {
+        // If it throws, check the status code
+        const status = error.status || error.response?.status;
+        if ([404, 405, 401].includes(status)) {
+          console.log(`✓ POST /api/labor-cost returned ${status} as expected`);
+        } else {
+          console.error(
+            `❌ POST /api/labor-cost test failed with status ${status}:`,
+            error.message,
+          );
+          throw error;
+        }
+      }
+    }, 30000);
+
+    // Note: The following test requires authentication token
+    // It will fail with 401 if no token is provided, which is expected
+    // To fully test route existence, a valid token would be needed
+    it('should have route configured (returns 401 without auth, not 404)', async () => {
+      console.log('Testing route existence...');
+
+      try {
+        const response = await agent.get('/api/labor-cost');
+        // Route exists if we get 401 (unauthorized) rather than 404 (not found)
+        expect(response.status).toBe(401);
+        console.log('✓ Route exists (returned 401, not 404)');
+      } catch (error) {
+        // If error status is 401, that's good - route exists
+        if (error.status === 401 || error.response?.status === 401) {
+          console.log('✓ Route exists (returned 401, not 404)');
+        } else if (error.status === 404 || error.response?.status === 404) {
+          console.error('❌ Route does not exist (returned 404)');
+          throw new Error('Route /api/labor-cost not found');
+        } else {
+          console.error('❌ Route test failed:', error.message);
+          throw error;
+        }
+      }
+    }, 30000);
+  });
+});
diff --git a/src/controllers/bmdashboard/__tests__/bmPaidLaborCostController.test.js b/src/controllers/bmdashboard/__tests__/bmPaidLaborCostController.test.js
new file mode 100644
index 000000000..ec4f58417
--- /dev/null
+++ b/src/controllers/bmdashboard/__tests__/bmPaidLaborCostController.test.js
@@ -0,0 +1,679 @@
+/**
+ * Unit Tests for Paid Labor Cost Controller
+ *
+ * This test suite covers:
+ * 1. Helper function unit tests (looksLikeJson, parseArrayParam, parseDateRangeParam,
+ *    isValidDateValue, sanitizeStringArrayForQuery)
+ * 2. Controller logic tests (parameter validation, query building, response formatting,
+ *    error handling, edge cases)
+ *
+ * Coverage Target: >90% (currently ~97%)
+ */
+
+jest.mock('../../../models/laborCost');
+jest.mock('../../../startup/logger');
+
+const LaborCost = require('../../../models/laborCost');
+const logger = require('../../../startup/logger');
+const bmPaidLaborCostController = require('../bmPaidLaborCostController');
+
+/**
+ * Helper Functions Test Suite
+ * Tests private helper functions exported via testExports for direct unit testing
+ */
+describe('bmPaidLaborCostController - Helper Functions', () => {
+  const {
+    looksLikeJson,
+    parseArrayParam,
+    parseDateRangeParam,
+    isValidDateValue,
+    sanitizeStringArrayForQuery,
+  } = bmPaidLaborCostController.testExports;
+
+  describe('looksLikeJson()', () => {
+    it.each([
+      ['valid JSON object string', '{"key":"value"}', true],
+      ['nested JSON object', '{"nested":{"key":"val"}}', true],
+      ['JSON array string', '["item1","item2"]', true],
+      ['JSON with leading whitespace', '  {"key":"value"}', true],
+      ['plain string', 'plain text', false],
+      ['comma-separated string', 'Project A, Project B', false],
+      ['null input', null, false],
+      ['undefined input', undefined, false],
+      ['number input', 123, false],
+      ['object (not string)', {}, false],
+      ['array (not string)', [], false],
+      ['empty string', '', false],
+    ])('should return %s for %s', (_label, input, expected) => {
+      expect(looksLikeJson(input)).toBe(expected);
+    });
+  });
+
+  describe('parseArrayParam()', () => {
+    it('should return empty array for null input', () => {
+      expect(parseArrayParam(null)).toEqual([]);
+    });
+
+    it('should return empty array for undefined input', () => {
+      expect(parseArrayParam(undefined)).toEqual([]);
+    });
+
+    it('should return array as-is when already an array', () => {
+      const input = ['Project A', 'Project B'];
+      expect(parseArrayParam(input)).toEqual(input);
+    });
+
+    it('should parse valid JSON array string', () => {
+      expect(parseArrayParam('["Project A","Project B"]')).toEqual(['Project A', 'Project B']);
+    });
+
+    it('should parse single item JSON array', () => {
+      expect(parseArrayParam('["Single"]')).toEqual(['Single']);
+    });
+
+    it('should wrap JSON string in array', () => {
+      expect(parseArrayParam('"Project A"')).toEqual(['Project A']);
+    });
+
+    it('should return error object for JSON object (invalid)', () => {
+      const result = parseArrayParam('{"key":"value"}');
+      expect(result).toHaveProperty('__invalidFormat', true);
+      expect(result).toHaveProperty('__error');
+      expect(result.__error).toContain('JSON object provided instead of array');
+    });
+
+    it('should parse comma-separated string', () => {
+      expect(parseArrayParam('Project A,Project B')).toEqual(['Project A', 'Project B']);
+    });
+
+    it('should parse comma-separated string with spaces', () => {
+      expect(parseArrayParam('Project A, Project B')).toEqual(['Project A', 'Project B']);
+    });
+
+    it('should return single value array for string without comma', () => {
+      expect(parseArrayParam('Single Project')).toEqual(['Single Project']);
+    });
+
+    it('should return error object for mixed JSON and plain string', () => {
+      const result = parseArrayParam('{"json":true},Plain');
+      expect(result).toHaveProperty('__invalidFormat', true);
+      expect(result).toHaveProperty('__error');
+      expect(result.__error).toContain('Cannot mix JSON');
+    });
+
+    it('should return error object for invalid JSON that looks like JSON', () => {
+      // '[incomplete' starts with '[' so looksLikeJson returns true, triggering error
+      const result = parseArrayParam('[incomplete');
+      expect(result).toHaveProperty('__invalidFormat', true);
+      expect(result).toHaveProperty('__error');
+      expect(result.__error).toContain('Cannot mix JSON');
+    });
+
+    it('should return empty array for empty string', () => {
+      expect(parseArrayParam('')).toEqual([]);
+    });
+
+    it('should return empty array for string with only commas and spaces', () => {
+      expect(parseArrayParam('  ,  ,  ')).toEqual([]);
+    });
+
+    it('should return empty array for number input', () => {
+      expect(parseArrayParam(123)).toEqual([]);
+    });
+  });
+
+  describe('parseDateRangeParam()', () => {
+    it('should return null for null input', () => {
+      expect(parseDateRangeParam(null)).toBeNull();
+    });
+
+    it('should return null for undefined input', () => {
+      expect(parseDateRangeParam(undefined)).toBeNull();
+    });
+
+    it('should return object as-is when already an object', () => {
+      const input = { start_date: '2025-04-01', end_date: '2025-04-30' };
+      expect(parseDateRangeParam(input)).toEqual(input);
+    });
+
+    it('should parse valid JSON string', () => {
+      const result = parseDateRangeParam('{"start_date":"2025-04-01","end_date":"2025-04-30"}');
+      expect(result).toEqual({ start_date: '2025-04-01', end_date: '2025-04-30' });
+    });
+
+    it('should parse partial object JSON string', () => {
+      const result = parseDateRangeParam('{"start_date":"2025-04-01"}');
+      expect(result).toEqual({ start_date: '2025-04-01' });
+    });
+
+    it('should parse empty object JSON string', () => {
+      expect(parseDateRangeParam('{}')).toEqual({});
+    });
+
+    it('should return null for invalid JSON string', () => {
+      expect(parseDateRangeParam('invalid json')).toBeNull();
+    });
+
+    it('should return null for malformed JSON string', () => {
+      expect(parseDateRangeParam('{malformed')).toBeNull();
+    });
+
+    it('should return null for number input', () => {
+      expect(parseDateRangeParam(123)).toBeNull();
+    });
+
+    it('should parse string "null" to null', () => {
+      expect(parseDateRangeParam('null')).toBeNull();
+    });
+  });
+
+  describe('isValidDateValue()', () => {
+    it.each([
+      ['null (optional)', null, true],
+      ['undefined (optional)', undefined, true],
+      ['empty string (falsy)', '', true],
+      ['valid date-only format', '2025-04-01', true],
+      ['another valid date-only format', '2025-04-30', true],
+      ['end of year date', '2025-12-31', true],
+      ['start of year date', '2025-01-01', true],
+      ['valid datetime with Z', '2025-04-01T00:00:00Z', true],
+      ['valid datetime with milliseconds', '2025-04-01T12:30:45.123Z', true],
+      ['valid datetime with timezone offset', '2025-04-01T00:00:00+05:30', true],
+      ['Feb 29 in leap year (2024)', '2024-02-29', true],
+      ['invalid month (13)', '2025-13-01', false],
+      ['invalid month (0)', '2025-00-01', false],
+      ['invalid day (32)', '2025-04-32', false],
+      ['invalid day (0)', '2025-04-00', false],
+      ['invalid day for February', '2025-02-30', false],
+      ['Feb 29 in non-leap year', '2025-02-29', false],
+      ['unparseable string', 'not-a-date', false],
+      ['number input', 123, false],
+      ['object input', {}, false],
+    ])('should return correct result for %s', (_label, input, expected) => {
+      expect(isValidDateValue(input)).toBe(expected);
+    });
+
+    it('should return true for date with slashes (JavaScript Date can parse it)', () => {
+      expect(isValidDateValue('2025/04/01')).toBe(true);
+    });
+
+    it('should handle single digit month/day format', () => {
+      const result = isValidDateValue('2025-4-1');
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('sanitizeStringArrayForQuery()', () => {
+    it('should return empty array for empty input', () => {
+      expect(sanitizeStringArrayForQuery([])).toEqual([]);
+    });
+
+    it('should pass through normal strings unchanged', () => {
+      expect(sanitizeStringArrayForQuery(['Project A', 'Project B'])).toEqual([
+        'Project A',
+        'Project B',
+      ]);
+    });
+
+    it('should filter out strings starting with $', () => {
+      expect(sanitizeStringArrayForQuery(['$gt', 'Project A'])).toEqual(['Project A']);
+    });
+
+    it('should filter all elements when all start with $', () => {
+      expect(sanitizeStringArrayForQuery(['$inject', '$where'])).toEqual([]);
+    });
+
+    it('should convert non-string values to strings via String()', () => {
+      expect(sanitizeStringArrayForQuery([123, true])).toEqual(['123', 'true']);
+    });
+
+    it('should preserve strings with $ not at the start', () => {
+      expect(sanitizeStringArrayForQuery(['Project$A', 'cost$10'])).toEqual([
+        'Project$A',
+        'cost$10',
+      ]);
+    });
+  });
+});
+
+/**
+ * Controller Logic Test Suite
+ * Tests the main getLaborCost() function with mocked dependencies
+ */
+describe('bmPaidLaborCostController - getLaborCost()', () => {
+  let controller;
+  let mockReq;
+  let mockRes;
+  let mockSort;
+  let mockLean;
+  let mockExec;
+
+  /** Calls getLaborCost with given query and optional mock DB records. Reduces duplication. */
+  async function callGetLaborCost(query, records = []) {
+    mockReq.query = query;
+    mockExec.mockResolvedValue(records);
+    await controller.getLaborCost(mockReq, mockRes);
+  }
+
+  /** Asserts 200 and LaborCost.find called with expectedFilter. */
+  function expectSuccessWithFind(expectedFilter) {
+    expect(mockRes.status).toHaveBeenCalledWith(200);
+    expect(LaborCost.find).toHaveBeenCalledWith(expectedFilter);
+  }
+
+  /** Asserts 200 and empty find. */
+  function expectSuccessEmptyFind() {
+    expectSuccessWithFind({});
+  }
+
+  /** Asserts 400 INVALID_PARAMETER with the given error substring. */
+  function expectInvalidParamError(errorSubstring) {
+    expect(mockRes.status).toHaveBeenCalledWith(400);
+    expect(mockRes.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        Code: 'INVALID_PARAMETER',
+        error: expect.stringContaining(errorSubstring),
+      }),
+    );
+  }
+
+  // Shared date filter shapes used across multiple describe blocks
+  const DATE_RANGE_BOTH = { date: { $gte: expect.any(Date), $lte: expect.any(Date) } };
+  const DATE_RANGE_START_ONLY = { date: { $gte: expect.any(Date) } };
+  const DATE_RANGE_END_ONLY = { date: { $lte: expect.any(Date) } };
+
+  /**
+   * Setup mocks before each test
+   * Creates chainable mock for LaborCost.find().sort().lean().exec()
+   */
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Set up mock chain for LaborCost.find().sort().lean().exec()
+    mockExec = jest.fn().mockResolvedValue([]);
+    mockLean = jest.fn().mockReturnValue({ exec: mockExec });
+    mockSort = jest.fn().mockReturnValue({ lean: mockLean });
+    LaborCost.find = jest.fn().mockReturnValue({ sort: mockSort });
+    logger.logException = jest.fn();
+
+    mockReq = {
+      query: {},
+      method: 'GET',
+      originalUrl: '/api/labor-cost',
+      url: '/api/labor-cost',
+    };
+    mockRes = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    };
+    controller = bmPaidLaborCostController();
+  });
+
+  /**
+   * Parameter Validation Tests - Projects
+   */
+  describe('Parameter Validation - Projects', () => {
+    it('should call sort, lean, exec and succeed when projects param is undefined', async () => {
+      await callGetLaborCost({});
+      expectSuccessEmptyFind();
+      expect(mockSort).toHaveBeenCalledWith({ date: 1 });
+      expect(mockLean).toHaveBeenCalled();
+      expect(mockExec).toHaveBeenCalled();
+    });
+
+    it.each([
+      ['empty array', { projects: '[]' }, {}],
+      ['valid JSON array', { projects: '["Project A"]' }, { project_name: { $in: ['Project A'] } }],
+      [
+        'multiple projects',
+        { projects: '["Project A","Project B"]' },
+        { project_name: { $in: ['Project A', 'Project B'] } },
+      ],
+      [
+        'comma-separated',
+        { projects: 'Project A,Project B' },
+        { project_name: { $in: ['Project A', 'Project B'] } },
+      ],
+    ])('should succeed with %s projects', async (_label, query, expectedFind) => {
+      await callGetLaborCost(query);
+      expectSuccessWithFind(expectedFind);
+    });
+
+    it.each([
+      ['JSON object', '{"name":"Project A"}', 'JSON object provided instead of array'],
+      ['non-string elements', '[1, 2, 3]', 'All project names must be strings'],
+      ['mixed valid/invalid', '["valid", 123]', 'All project names must be strings'],
+      ['mixed format', '{"json":true},Plain', 'Cannot mix JSON'],
+    ])('should return 400 for %s', async (_label, projectsValue, errorSubstring) => {
+      await callGetLaborCost({ projects: projectsValue });
+      expectInvalidParamError(errorSubstring);
+    });
+  });
+
+  /**
+   * Parameter Validation Tests - Tasks
+   */
+  describe('Parameter Validation - Tasks', () => {
+    it.each([
+      ['undefined', {}],
+      ['empty array', { tasks: '[]' }],
+    ])('should succeed when tasks param is %s', async (_label, query) => {
+      await callGetLaborCost(query);
+      expectSuccessEmptyFind();
+    });
+
+    it.each([
+      ['valid JSON array', { tasks: '["Task 1"]' }, { task: { $in: ['Task 1'] } }],
+      ['multiple tasks', { tasks: '["Task 1","Task 2"]' }, { task: { $in: ['Task 1', 'Task 2'] } }],
+      ['comma-separated', { tasks: 'Task 1,Task 2' }, { task: { $in: ['Task 1', 'Task 2'] } }],
+    ])('should succeed with %s tasks', async (_label, query, expectedFind) => {
+      await callGetLaborCost(query);
+      expectSuccessWithFind(expectedFind);
+    });
+
+    it.each([
+      ['JSON object', '{"name":"Task 1"}', 'JSON object provided instead of array'],
+      ['non-string elements', '[1, 2, 3]', 'All task names must be strings'],
+    ])('should return 400 for %s in tasks', async (_label, tasksValue, errorSubstring) => {
+      await callGetLaborCost({ tasks: tasksValue });
+      expectInvalidParamError(errorSubstring);
+    });
+  });
+
+  /**
+   * Parameter Validation Tests - Date Range
+   */
+  describe('Parameter Validation - Date Range', () => {
+    it.each([
+      ['undefined', {}],
+      ['null string', { date_range: 'null' }],
+      ['empty object', { date_range: '{}' }],
+    ])('should succeed when date_range is %s', async (_label, query) => {
+      await callGetLaborCost(query);
+      expectSuccessEmptyFind();
+    });
+
+    it.each([
+      ['both dates', '{"start_date":"2025-04-01","end_date":"2025-04-30"}', DATE_RANGE_BOTH],
+      ['only start_date', '{"start_date":"2025-04-01","end_date":null}', DATE_RANGE_START_ONLY],
+      ['only end_date', '{"start_date":null,"end_date":"2025-04-30"}', DATE_RANGE_END_ONLY],
+    ])('should succeed with %s', async (_label, dateRangeValue, expectedFind) => {
+      await callGetLaborCost({ date_range: dateRangeValue });
+      expectSuccessWithFind(expectedFind);
+    });
+
+    it('should return 400 for invalid JSON date_range', async () => {
+      await callGetLaborCost({ date_range: '{malformed' });
+      expectInvalidParamError('date_range must be a valid JSON object');
+    });
+
+    it.each([
+      [
+        'invalid start month',
+        '{"start_date":"2025-13-01","end_date":"2025-04-30"}',
+        'start_date must be a valid ISO 8601',
+      ],
+      [
+        'invalid end day',
+        '{"start_date":"2025-04-01","end_date":"2025-04-32"}',
+        'end_date must be a valid ISO 8601',
+      ],
+      [
+        'non-string start_date',
+        '{"start_date":12345,"end_date":"2025-04-30"}',
+        'start_date must be a string',
+      ],
+      [
+        'non-string end_date',
+        '{"start_date":"2025-04-01","end_date":12345}',
+        'end_date must be a string',
+      ],
+    ])('should return 422 for %s', async (_label, dateRangeValue, errorSubstring) => {
+      await callGetLaborCost({ date_range: dateRangeValue });
+      expect(mockRes.status).toHaveBeenCalledWith(422);
+      expect(mockRes.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          Code: 'INVALID_DATE_FORMAT',
+          error: expect.stringContaining(errorSubstring),
+        }),
+      );
+    });
+
+    it('should return 400 when start_date > end_date', async () => {
+      await callGetLaborCost({
+        date_range: '{"start_date":"2025-04-30","end_date":"2025-04-01"}',
+      });
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        Code: 'INVALID_DATE_RANGE',
+        error: 'start_date must be before or equal to end_date',
+      });
+    });
+  });
+
+  /**
+   * Query Building and Database Call
+   */
+  describe('Query Building and Database Call', () => {
+    it('should build empty query and call sort, lean, exec when no filters', async () => {
+      await callGetLaborCost({});
+      expect(LaborCost.find).toHaveBeenCalledWith({});
+      expect(mockSort).toHaveBeenCalledWith({ date: 1 });
+      expect(mockLean).toHaveBeenCalled();
+      expect(mockExec).toHaveBeenCalled();
+    });
+
+    it.each([
+      [
+        'date range only',
+        { date_range: '{"start_date":"2025-04-01","end_date":"2025-04-30"}' },
+        DATE_RANGE_BOTH,
+      ],
+      [
+        'start date only',
+        { date_range: '{"start_date":"2025-04-01","end_date":null}' },
+        DATE_RANGE_START_ONLY,
+      ],
+      [
+        'end date only',
+        { date_range: '{"start_date":null,"end_date":"2025-04-30"}' },
+        DATE_RANGE_END_ONLY,
+      ],
+    ])('should build query filter with %s', async (_label, query, expectedFind) => {
+      await callGetLaborCost(query);
+      expect(LaborCost.find).toHaveBeenCalledWith(expectedFind);
+    });
+
+    it('should build combined query filter with all filters', async () => {
+      await callGetLaborCost({
+        projects: '["A"]',
+        tasks: '["T1"]',
+        date_range: '{"start_date":"2025-04-01","end_date":"2025-04-30"}',
+      });
+      expect(LaborCost.find).toHaveBeenCalledWith({
+        project_name: { $in: ['A'] },
+        task: { $in: ['T1'] },
+        date: { $gte: expect.any(Date), $lte: expect.any(Date) },
+      });
+    });
+  });
+
+  /**
+   * Response Formatting
+   */
+  describe('Response Formatting', () => {
+    it('should return empty results with totalCost 0', async () => {
+      await callGetLaborCost({});
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith({ totalCost: 0, data: [] });
+    });
+
+    it('should format single record correctly', async () => {
+      const testDate = new Date('2025-04-01');
+      await callGetLaborCost({}, [{ project_name: 'A', task: 'T1', date: testDate, cost: 100 }]);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        totalCost: 100,
+        data: [{ project: 'A', task: 'T1', date: testDate.toISOString(), cost: 100 }],
+      });
+    });
+
+    it('should format multiple records and calculate totalCost', async () => {
+      const testDate1 = new Date('2025-04-01');
+      const testDate2 = new Date('2025-04-02');
+      await callGetLaborCost({}, [
+        { project_name: 'A', task: 'T1', date: testDate1, cost: 100 },
+        { project_name: 'B', task: 'T2', date: testDate2, cost: 200 },
+      ]);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        totalCost: 300,
+        data: [
+          { project: 'A', task: 'T1', date: testDate1.toISOString(), cost: 100 },
+          { project: 'B', task: 'T2', date: testDate2.toISOString(), cost: 200 },
+        ],
+      });
+    });
+
+    it('should convert string cost to number', async () => {
+      const testDate = new Date('2025-04-01');
+      await callGetLaborCost({}, [{ project_name: 'A', task: 'T1', date: testDate, cost: '100' }]);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        totalCost: 100,
+        data: [{ project: 'A', task: 'T1', date: testDate.toISOString(), cost: 100 }],
+      });
+    });
+
+    it('should handle null date in response', async () => {
+      await callGetLaborCost({}, [{ project_name: 'A', task: 'T1', date: null, cost: 100 }]);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        totalCost: 100,
+        data: [{ project: 'A', task: 'T1', date: null, cost: 100 }],
+      });
+    });
+  });
+
+  /**
+   * Error Handling
+   */
+  const dbErrorResponse = {
+    Code: 'DATABASE_ERROR',
+    error: 'A database error occurred while fetching labor cost data. Please try again later.',
+  };
+
+  describe('Error Handling', () => {
+    it('should handle MongoError and return 500 with log context', async () => {
+      const error = new Error('Database connection failed');
+      error.name = 'MongoError';
+      mockReq.query = {};
+      mockExec.mockRejectedValue(error);
+
+      await controller.getLaborCost(mockReq, mockRes);
+
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'getLaborCost - Database Error - Paid Labor Cost Controller',
+        { query: {}, method: 'GET', url: '/api/labor-cost' },
+      );
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.json).toHaveBeenCalledWith(dbErrorResponse);
+    });
+
+    it.each([
+      ['MongooseError', 'MongooseError'],
+      ['CastError', 'CastError'],
+      ['ValidationError', 'ValidationError'],
+      ['Mongo connection message', null, 'Mongo connection failed'],
+    ])('should handle %s and return 500', async (_label, errorName, errorMessage = 'DB error') => {
+      const error = new Error(errorMessage);
+      if (errorName) error.name = errorName;
+      mockReq.query = {};
+      mockExec.mockRejectedValue(error);
+
+      await controller.getLaborCost(mockReq, mockRes);
+
+      expect(logger.logException).toHaveBeenCalled();
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.json).toHaveBeenCalledWith(dbErrorResponse);
+    });
+
+    it('should handle generic error and return 500 with INTERNAL_SERVER_ERROR', async () => {
+      const error = new Error('Unknown error');
+      mockReq.query = {};
+      mockExec.mockRejectedValue(error);
+
+      await controller.getLaborCost(mockReq, mockRes);
+
+      expect(logger.logException).toHaveBeenCalledWith(
+        error,
+        'getLaborCost - Unexpected Error - Paid Labor Cost Controller',
+        { query: {}, method: 'GET', url: '/api/labor-cost' },
+      );
+      expect(mockRes.status).toHaveBeenCalledWith(500);
+      expect(mockRes.json).toHaveBeenCalledWith({
+        Code: 'INTERNAL_SERVER_ERROR',
+        error:
+          'An unexpected error occurred while fetching labor cost data. Please try again later.',
+      });
+    });
+  });
+
+  /**
+   * Edge Cases - Boundary Conditions
+   */
+  describe('Edge Cases - Boundary Conditions', () => {
+    it('should handle empty string projects parameter', async () => {
+      await callGetLaborCost({ projects: '' });
+      expectSuccessEmptyFind();
+    });
+
+    it.each([
+      ['very long project name', 'A'.repeat(1000)],
+      ['Unicode', '日本語'],
+      ['special characters', 'Project <script>'],
+    ])('should handle %s in projects', async (_label, projectValue) => {
+      await callGetLaborCost({ projects: JSON.stringify([projectValue]) });
+      expectSuccessWithFind({ project_name: { $in: [projectValue] } });
+    });
+
+    it('should silently exclude $-prefixed project names (NoSQL injection prevention)', async () => {
+      await callGetLaborCost({ projects: JSON.stringify(['$inject', 'Project A']) });
+      expectSuccessWithFind({ project_name: { $in: ['Project A'] } });
+    });
+
+    it('should handle large array of projects', async () => {
+      const projects = Array.from({ length: 100 }, (_, i) => `Project ${i + 1}`);
+      await callGetLaborCost({ projects: JSON.stringify(projects) });
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(LaborCost.find).toHaveBeenCalledWith({ project_name: { $in: projects } });
+    });
+
+    it.each([
+      ['dates far in the past', '{"start_date":"1900-01-01","end_date":"1900-12-31"}'],
+      ['dates far in the future', '{"start_date":"2100-01-01","end_date":"2100-12-31"}'],
+    ])('should handle %s', async (_label, dateRangeValue) => {
+      await callGetLaborCost({ date_range: dateRangeValue });
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(LaborCost.find).toHaveBeenCalledWith(DATE_RANGE_BOTH);
+      expect(mockRes.json).toHaveBeenCalledWith({ totalCost: 0, data: [] });
+    });
+  });
+
+  /**
+   * Edge Cases - Request Object
+   * Tests handling of malformed or missing request query objects
+   * All three cases test the same code path: `const query = req.query || {};`
+   */
+  describe('Edge Cases - Request Object', () => {
+    it.each([
+      ['missing query property', undefined],
+      ['null query property', null],
+      ['empty query object', {}],
+    ])('should handle %s', async (_label, queryValue) => {
+      mockReq.query = queryValue;
+      mockExec.mockResolvedValue([]);
+      await controller.getLaborCost(mockReq, mockRes);
+      expectSuccessEmptyFind();
+    });
+  });
+});
diff --git a/src/controllers/bmdashboard/bmPaidLaborCostController.js b/src/controllers/bmdashboard/bmPaidLaborCostController.js
index c9d3dba0f..73d32954e 100644
--- a/src/controllers/bmdashboard/bmPaidLaborCostController.js
+++ b/src/controllers/bmdashboard/bmPaidLaborCostController.js
@@ -1,6 +1,578 @@
+const LaborCost = require('../../models/laborCost');
+const logger = require('../../startup/logger');
+
+/**
+ * Helper function to check if a string looks like a JSON object or array
+ * Used to detect invalid mixed formats (e.g., {"key":"val"},Project 1)
+ */
+const looksLikeJson = (str) => {
+  if (typeof str !== 'string') return false;
+  const trimmed = str.trim();
+  return trimmed.startsWith('{') || trimmed.startsWith('[');
+};
+
+/**
+ * Helper function to parse array from query parameter
+ * Handles JSON strings, comma-separated strings, or already parsed arrays
+ */
+const parseArrayParam = (param) => {
+  if (!param) return [];
+  if (Array.isArray(param)) return param;
+  if (typeof param === 'string') {
+    try {
+      const parsed = JSON.parse(param);
+      // If parsed successfully, check if it's an object (not array) and not null
+      if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+        // Single JSON object when expecting array - this is invalid
+        return {
+          __invalidFormat: true,
+          __error:
+            'Invalid format: JSON object provided instead of array. Use JSON array format (e.g., ["Project 1"]) or comma-separated strings.',
+        };
+      }
+      return Array.isArray(parsed) ? parsed : [parsed];
+    } catch {
+      // If not JSON, treat as comma-separated string
+      const commaSeparated = param
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+
+      // Check if any item looks like JSON (invalid mixed format)
+      const hasJsonLike = commaSeparated.some((item) => looksLikeJson(item));
+      if (hasJsonLike) {
+        return {
+          __invalidFormat: true,
+          __error:
+            'Invalid format: Cannot mix JSON objects/arrays with plain strings. Use JSON array (e.g., ["Project 1"]) or comma-separated strings (e.g., Project 1,Project 2).',
+        };
+      }
+
+      return commaSeparated;
+    }
+  }
+  return [];
+};
+
+/**
+ * Helper function to parse date_range object from query parameter
+ * Handles JSON strings or already parsed objects
+ */
+const parseDateRangeParam = (param) => {
+  if (!param) return null;
+  if (typeof param === 'object' && param !== null) return param;
+  if (typeof param === 'string') {
+    try {
+      return JSON.parse(param);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+};
+
+/**
+ * Validate ISO 8601 date format and value (not NaN when parsed)
+ * Handles edge cases like invalid months (e.g., "2025-13-01"), invalid days, dates far in past/future
+ */
+const isValidDateValue = (dateString) => {
+  if (!dateString) return true; // null/undefined is valid (optional)
+  if (typeof dateString !== 'string') return false;
+
+  // Parse the date
+  const date = new Date(dateString);
+
+  // Check if date is valid (not NaN)
+  if (Number.isNaN(date.getTime())) {
+    return false;
+  }
+
+  // For date-only format (YYYY-MM-DD), verify components match to catch invalid months/days
+  // This catches edge cases like "2025-13-01" (invalid month) which JavaScript adjusts
+  // Note: Date-only strings are parsed as UTC midnight, so use UTC methods for comparison
+  const DATE_PARTS_COUNT = 3;
+  if (!dateString.includes('T') && !dateString.includes('Z')) {
+    const parts = dateString.split('-');
+    if (parts.length === DATE_PARTS_COUNT) {
+      const year = parseInt(parts[0], 10);
+      const month = parseInt(parts[1], 10);
+      const day = parseInt(parts[2], 10);
+
+      // Check if parsed values match input (catches invalid months/days that get adjusted)
+      // Use UTC methods since date-only strings are parsed as UTC midnight
+      if (
+        !Number.isNaN(year) &&
+        !Number.isNaN(month) &&
+        !Number.isNaN(day) &&
+        (date.getUTCFullYear() !== year ||
+          date.getUTCMonth() + 1 !== month ||
+          date.getUTCDate() !== day)
+      ) {
+        return false; // Date was adjusted (e.g., invalid month/day like "2025-13-01")
+      }
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Validates and parses projects parameter
+ * Returns { error: { status, response } } if validation fails, or { projectsArray } on success
+ */
+const validateAndParseProjects = (projects) => {
+  if (projects === undefined) {
+    return { projectsArray: [] };
+  }
+
+  const projectsArray = parseArrayParam(projects);
+
+  // Check if parsing returned an invalid format marker
+  if (projectsArray && typeof projectsArray === 'object' && projectsArray.__invalidFormat) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: projectsArray.__error || 'projects parameter contains invalid format',
+        },
+      },
+    };
+  }
+
+  if (!Array.isArray(projectsArray)) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: 'projects must be an array',
+        },
+      },
+    };
+  }
+
+  // Validate that all project names are strings
+  if (projectsArray.length > 0 && !projectsArray.every((p) => typeof p === 'string')) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: 'All project names must be strings',
+        },
+      },
+    };
+  }
+
+  return { projectsArray };
+};
+
+/**
+ * Validates and parses tasks parameter
+ * Returns { error: { status, response } } if validation fails, or { tasksArray } on success
+ */
+const validateAndParseTasks = (tasks) => {
+  if (tasks === undefined) {
+    return { tasksArray: [] };
+  }
+
+  const tasksArray = parseArrayParam(tasks);
+
+  // Check if parsing returned an invalid format marker
+  if (tasksArray && typeof tasksArray === 'object' && tasksArray.__invalidFormat) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: tasksArray.__error || 'tasks parameter contains invalid format',
+        },
+      },
+    };
+  }
+
+  if (!Array.isArray(tasksArray)) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: 'tasks must be an array',
+        },
+      },
+    };
+  }
+
+  // Validate that all task names are strings
+  if (tasksArray.length > 0 && !tasksArray.every((t) => typeof t === 'string')) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: 'All task names must be strings',
+        },
+      },
+    };
+  }
+
+  return { tasksArray };
+};
+
+/**
+ * Validates date string format
+ * Returns { error: { status, response } } if validation fails, or null on success
+ */
+const validateDateString = (dateValue, fieldName) => {
+  if (dateValue === null) {
+    return null;
+  }
+
+  if (typeof dateValue !== 'string') {
+    return {
+      error: {
+        status: 422,
+        response: {
+          Code: 'INVALID_DATE_FORMAT',
+          error: `${fieldName} must be a string in ISO 8601 format (e.g., "2025-04-01" or "2025-04-01T00:00:00Z")`,
+        },
+      },
+    };
+  }
+
+  if (!isValidDateValue(dateValue)) {
+    return {
+      error: {
+        status: 422,
+        response: {
+          Code: 'INVALID_DATE_FORMAT',
+          error: `${fieldName} must be a valid ISO 8601 date string (e.g., "2025-04-01" or "2025-04-01T00:00:00Z")`,
+        },
+      },
+    };
+  }
+
+  return null;
+};
+
+/**
+ * Validates date range logic (start_date must be before or equal to end_date)
+ * Returns { error: { status, response } } if validation fails, or null on success
+ */
+const validateDateRangeLogic = (startDate, endDate) => {
+  if (startDate !== null && endDate !== null) {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    if (start > end) {
+      return {
+        error: {
+          status: 400,
+          response: {
+            Code: 'INVALID_DATE_RANGE',
+            error: 'start_date must be before or equal to end_date',
+          },
+        },
+      };
+    }
+  }
+  return null;
+};
+
+/**
+ * Parses date_range parameter structure
+ * Returns { error: { status, response } } if parsing fails, or { dateRange, startDate, endDate } on success
+ */
+const parseDateRangeStructure = (dateRangeParam) => {
+  if (dateRangeParam === undefined || dateRangeParam === null) {
+    return { dateRange: null, startDate: null, endDate: null };
+  }
+
+  // Track if the param was a string before parsing (to detect parsing failures)
+  const wasString = typeof dateRangeParam === 'string';
+  const dateRange = parseDateRangeParam(dateRangeParam);
+
+  // If dateRangeParam was a non-empty string but parsing returned null,
+  // that means JSON parsing failed (invalid JSON format)
+  if (
+    wasString &&
+    dateRangeParam !== 'null' &&
+    dateRangeParam.trim() !== '' &&
+    dateRange === null
+  ) {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error:
+            'date_range must be a valid JSON object (e.g., {"start_date":"2025-04-01","end_date":"2025-04-30"}) or null',
+        },
+      },
+    };
+  }
+
+  if (dateRange !== null && typeof dateRange !== 'object') {
+    return {
+      error: {
+        status: 400,
+        response: {
+          Code: 'INVALID_PARAMETER',
+          error: 'date_range must be an object or null',
+        },
+      },
+    };
+  }
+
+  // Extract start_date and end_date from date_range
+  let startDate = null;
+  let endDate = null;
+  if (dateRange !== null && typeof dateRange === 'object') {
+    startDate = dateRange.start_date !== undefined ? dateRange.start_date : null;
+    endDate = dateRange.end_date !== undefined ? dateRange.end_date : null;
+  }
+
+  return { dateRange, startDate, endDate };
+};
+
+/**
+ * Validates and parses date_range parameter
+ * Returns { error: { status, response } } if validation fails, or { dateRange, startDate, endDate } on success
+ */
+const validateAndParseDateRange = (dateRangeParam) => {
+  // Parse date range structure
+  const parseResult = parseDateRangeStructure(dateRangeParam);
+  if (parseResult.error) {
+    return parseResult;
+  }
+
+  const { dateRange, startDate, endDate } = parseResult;
+
+  // Validate start_date format
+  const startDateError = validateDateString(startDate, 'start_date');
+  if (startDateError) {
+    return startDateError;
+  }
+
+  // Validate end_date format
+  const endDateError = validateDateString(endDate, 'end_date');
+  if (endDateError) {
+    return endDateError;
+  }
+
+  // Validate date range logic
+  const rangeLogicError = validateDateRangeLogic(startDate, endDate);
+  if (rangeLogicError) {
+    return rangeLogicError;
+  }
+
+  return { dateRange, startDate, endDate };
+};
+
+// Constants for date manipulation
+const START_OF_DAY_HOUR = 0;
+const START_OF_DAY_MINUTE = 0;
+const START_OF_DAY_SECOND = 0;
+const START_OF_DAY_MS = 0;
+const END_OF_DAY_HOUR = 23;
+const END_OF_DAY_MINUTE = 59;
+const END_OF_DAY_SECOND = 59;
+const END_OF_DAY_MS = 999;
+
+/**
+ * Sanitizes an array of user-provided strings for safe use in MongoDB query filters.
+ * Converts each element to a plain string primitive and removes any values beginning
+ * with '$', which is the MongoDB operator prefix, to prevent NoSQL injection.
+ * @param {string[]} arr - Validated array of string values from user input
+ * @returns {string[]} Array of sanitized string primitives safe for use in queries
+ */
+const sanitizeStringArrayForQuery = (arr) =>
+  arr.map(String).filter((item) => !item.startsWith('$'));
+
+/**
+ * Builds MongoDB query filter from parsed and sanitized parameters
+ */
+const buildQueryFilter = ({ projectsArray, tasksArray, dateRange, startDate, endDate }) => {
+  const queryFilter = {};
+
+  // Build date filter
+  if (dateRange !== null) {
+    if (startDate !== null || endDate !== null) {
+      queryFilter.date = {};
+      if (startDate !== null) {
+        const start = new Date(startDate);
+        start.setUTCHours(
+          START_OF_DAY_HOUR,
+          START_OF_DAY_MINUTE,
+          START_OF_DAY_SECOND,
+          START_OF_DAY_MS,
+        );
+        queryFilter.date.$gte = start;
+      }
+      if (endDate !== null) {
+        const end = new Date(endDate);
+        end.setUTCHours(END_OF_DAY_HOUR, END_OF_DAY_MINUTE, END_OF_DAY_SECOND, END_OF_DAY_MS);
+        queryFilter.date.$lte = end;
+      }
+    }
+  }
+
+  // Build project filter — sanitize to prevent NoSQL injection via MongoDB operator strings
+  const sanitizedProjects = sanitizeStringArrayForQuery(projectsArray);
+  if (sanitizedProjects.length > 0) {
+    queryFilter.project_name = { $in: sanitizedProjects };
+  }
+
+  // Build task filter — sanitize to prevent NoSQL injection via MongoDB operator strings
+  const sanitizedTasks = sanitizeStringArrayForQuery(tasksArray);
+  if (sanitizedTasks.length > 0) {
+    queryFilter.task = { $in: sanitizedTasks };
+  }
+
+  return queryFilter;
+};
+
+/**
+ * Fetches labor cost records from the database using a validated filter.
+ * This function must only be called with validated/sanitized parameters (from
+ * validateAndParseProjects, validateAndParseTasks, validateAndParseDateRange)
+ * so that the query is not constructed from raw user-controlled data.
+ *
+ * @param {Object} validatedFilter - Validated filter parameters
+ * @param {string[]} validatedFilter.projectsArray - Validated project names
+ * @param {string[]} validatedFilter.tasksArray - Validated task names
+ * @param {Object|null} validatedFilter.dateRange - Validated date range object
+ * @param {string|null} validatedFilter.startDate - Validated start date string
+ * @param {string|null} validatedFilter.endDate - Validated end date string
+ * @returns {Promise<Object[]>} Labor cost records
+ */
+const findLaborCostByValidatedFilter = async ({
+  projectsArray,
+  tasksArray,
+  dateRange,
+  startDate,
+  endDate,
+}) => {
+  const queryFilter = buildQueryFilter({
+    projectsArray,
+    tasksArray,
+    dateRange,
+    startDate,
+    endDate,
+  });
+  return LaborCost.find(queryFilter).sort({ date: 1 }).lean().exec();
+};
+
+/**
+ * Formats response data and calculates total cost
+ */
+const formatResponseData = (laborCostRecords) => {
+  const formattedData = laborCostRecords.map((record) => ({
+    project: record.project_name,
+    task: record.task,
+    date: record.date ? new Date(record.date).toISOString() : null,
+    cost: typeof record.cost === 'number' ? record.cost : Number(record.cost),
+  }));
+
+  const totalCost =
+    formattedData.length > 0
+      ? formattedData.reduce((sum, record) => sum + (record.cost || 0), 0)
+      : 0;
+
+  return {
+    totalCost,
+    data: formattedData,
+  };
+};
+
+/**
+ * Handles errors and returns appropriate response
+ */
+const handleError = (error, req, res) => {
+  const errorContext = {
+    query: req.query,
+    method: req.method,
+    url: req.originalUrl || req.url,
+  };
+
+  const isDatabaseError =
+    error.name === 'MongoError' ||
+    error.name === 'MongooseError' ||
+    error.name === 'CastError' ||
+    error.name === 'ValidationError' ||
+    (error.message && error.message.includes('Mongo')) ||
+    (error.message && error.message.includes('connection'));
+
+  if (isDatabaseError) {
+    logger.logException(
+      error,
+      'getLaborCost - Database Error - Paid Labor Cost Controller',
+      errorContext,
+    );
+    return res.status(500).json({
+      Code: 'DATABASE_ERROR',
+      error: 'A database error occurred while fetching labor cost data. Please try again later.',
+    });
+  }
+
+  logger.logException(
+    error,
+    'getLaborCost - Unexpected Error - Paid Labor Cost Controller',
+    errorContext,
+  );
+  return res.status(500).json({
+    Code: 'INTERNAL_SERVER_ERROR',
+    error: 'An unexpected error occurred while fetching labor cost data. Please try again later.',
+  });
+};
+
 const laborCostController = () => {
   const getLaborCost = async (req, res) => {
-    res.status(200).json([]); // Return empty array for now
+    try {
+      // Handle edge case: request query is missing or null
+      const query = req.query || {};
+
+      // Extract parameters from req.query
+      const { projects, tasks, date_range: dateRangeParam } = query;
+
+      // Validate and parse projects
+      const projectsResult = validateAndParseProjects(projects);
+      if (projectsResult.error) {
+        return res.status(projectsResult.error.status).json(projectsResult.error.response);
+      }
+      const { projectsArray } = projectsResult;
+
+      // Validate and parse tasks
+      const tasksResult = validateAndParseTasks(tasks);
+      if (tasksResult.error) {
+        return res.status(tasksResult.error.status).json(tasksResult.error.response);
+      }
+      const { tasksArray } = tasksResult;
+
+      // Validate and parse date_range
+      const dateRangeResult = validateAndParseDateRange(dateRangeParam);
+      if (dateRangeResult.error) {
+        return res.status(dateRangeResult.error.status).json(dateRangeResult.error.response);
+      }
+      const { dateRange, startDate, endDate } = dateRangeResult;
+
+      // Query database using validated parameters only (not raw req.query)
+      const laborCostRecords = await findLaborCostByValidatedFilter({
+        projectsArray,
+        tasksArray,
+        dateRange,
+        startDate,
+        endDate,
+      });
+
+      // Format response data
+      const response = formatResponseData(laborCostRecords);
+
+      // Return response with 200 OK status code
+      return res.status(200).json(response);
+    } catch (error) {
+      return handleError(error, req, res);
+    }
   };
 
   return {
@@ -9,3 +581,10 @@ const laborCostController = () => {
 };
 
 module.exports = laborCostController;
+module.exports.testExports = {
+  looksLikeJson,
+  parseArrayParam,
+  parseDateRangeParam,
+  isValidDateValue,
+  sanitizeStringArrayForQuery,
+};
diff --git a/src/routes/bmdashboard/bmPaidLaborCostRouter.js b/src/routes/bmdashboard/bmPaidLaborCostRouter.js
index 788f9d672..cadfdd10b 100644
--- a/src/routes/bmdashboard/bmPaidLaborCostRouter.js
+++ b/src/routes/bmdashboard/bmPaidLaborCostRouter.js
@@ -3,6 +3,6 @@ const express = require('express');
 const router = express.Router();
 const controller = require('../../controllers/bmdashboard/bmPaidLaborCostController')();
 
-router.post('/', controller.getLaborCost);
+router.get('/', controller.getLaborCost);
 
 module.exports = router;