feat(employees): adiciona módulo employees com dados mocados e filtro OData

Implementa endpoint RESTful /v1/employees com CRUD completo e parser
de filtros OData () suportando contains, startswith, endswith,
operadores de comparação (eq, ne, gt, ge, lt, le) para strings,
números e datas, além de combinações com 'and'.

Dados mocados replicam os 20 employees da POC do po-angular para
testes de integração com o componente po-table.

Author: alinelariguet

src/app.module.ts

@@ -12,6 +12,7 @@ import { CitiesModule } from './cities/cities.module';
 import { HotelsModule } from './hotels/hotels.module';
 import { UploadModule } from './upload/upload.module';
 import { BatchDeleteModule } from './batch-delete/batch-delete.module';
+import { EmployeesModule } from './employees/employees.module';
 
 @Module({
   imports: [
@@ -26,7 +27,8 @@ import { BatchDeleteModule } from './batch-delete/batch-delete.module';
     PeopleModule,
     CitiesModule,
     UploadModule,
-    BatchDeleteModule
+    BatchDeleteModule,
+    EmployeesModule
   ]
 })
 export class AppModule {}

src/employees/db/employees.data.ts

@@ -0,0 +1,84 @@
+import { Employee } from '../interfaces/employee.interface';
+
+export const employees: Array<Employee> = [
+  {
+    id: 1, name: 'Ana Silva', age: 28, city: 'São Paulo',
+    department: 'TI', salary: 8500, status: 'Ativo', hireDate: '2023-03-15'
+  },
+  {
+    id: 2, name: 'Bruno Costa', age: 35, city: 'Rio de Janeiro',
+    department: 'RH', salary: 7200, status: 'Ativo', hireDate: '2022-01-10'
+  },
+  {
+    id: 3, name: 'Carla Mendes', age: 42, city: 'São Paulo',
+    department: 'Financeiro', salary: 12000, status: 'Ativo', hireDate: '2020-06-01'
+  },
+  {
+    id: 4, name: 'Diego Oliveira', age: 31, city: 'Belo Horizonte',
+    department: 'TI', salary: 9800, status: 'Inativo', hireDate: '2021-09-20'
+  },
+  {
+    id: 5, name: 'Elena Santos', age: 26, city: 'Curitiba',
+    department: 'Marketing', salary: 6500, status: 'Ativo', hireDate: '2024-02-01'
+  },
+  {
+    id: 6, name: 'Fernando Lima', age: 39, city: 'São Paulo',
+    department: 'TI', salary: 15000, status: 'Ativo', hireDate: '2019-04-15'
+  },
+  {
+    id: 7, name: 'Gabriela Rocha', age: 33, city: 'Porto Alegre',
+    department: 'RH', salary: 8000, status: 'Inativo', hireDate: '2022-07-01'
+  },
+  {
+    id: 8, name: 'Hugo Pereira', age: 45, city: 'Rio de Janeiro',
+    department: 'Financeiro', salary: 14000, status: 'Ativo', hireDate: '2018-11-10'
+  },
+  {
+    id: 9, name: 'Isabela Alves', age: 29, city: 'São Paulo',
+    department: 'Marketing', salary: 7800, status: 'Ativo', hireDate: '2023-08-20'
+  },
+  {
+    id: 10, name: 'João Ferreira', age: 37, city: 'Brasília',
+    department: 'TI', salary: 11000, status: 'Ativo', hireDate: '2021-01-05'
+  },
+  {
+    id: 11, name: 'Karen Souza', age: 24, city: 'Curitiba',
+    department: 'TI', salary: 6000, status: 'Ativo', hireDate: '2024-06-15'
+  },
+  {
+    id: 12, name: 'Lucas Barbosa', age: 41, city: 'São Paulo',
+    department: 'Financeiro', salary: 13500, status: 'Inativo', hireDate: '2019-02-28'
+  },
+  {
+    id: 13, name: 'Marina Castro', age: 30, city: 'Rio de Janeiro',
+    department: 'Marketing', salary: 8200, status: 'Ativo', hireDate: '2022-12-01'
+  },
+  {
+    id: 14, name: 'Nelson Dias', age: 48, city: 'Belo Horizonte',
+    department: 'RH', salary: 9500, status: 'Ativo', hireDate: '2017-05-10'
+  },
+  {
+    id: 15, name: 'Olivia Ribeiro', age: 27, city: 'Porto Alegre',
+    department: 'TI', salary: 7500, status: 'Ativo', hireDate: '2023-10-01'
+  },
+  {
+    id: 16, name: 'Paulo Cardoso', age: 36, city: 'São Paulo',
+    department: 'TI', salary: 10500, status: 'Inativo', hireDate: '2020-08-15'
+  },
+  {
+    id: 17, name: 'Raquel Martins', age: 32, city: 'Brasília',
+    department: 'Financeiro', salary: 9000, status: 'Ativo', hireDate: '2021-11-20'
+  },
+  {
+    id: 18, name: 'Samuel Teixeira', age: 44, city: 'Rio de Janeiro',
+    department: 'Marketing', salary: 11500, status: 'Ativo', hireDate: '2018-03-01'
+  },
+  {
+    id: 19, name: 'Tatiana Moreira', age: 25, city: 'Curitiba',
+    department: 'RH', salary: 5800, status: 'Ativo', hireDate: '2024-01-15'
+  },
+  {
+    id: 20, name: 'Victor Nascimento', age: 38, city: 'São Paulo',
+    department: 'TI', salary: 12500, status: 'Ativo', hireDate: '2020-04-01'
+  }
+];

src/employees/dto/create-employee.dto.ts

@@ -0,0 +1,29 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class CreateEmployeeDto {
+
+  @ApiPropertyOptional()
+  id: number;
+
+  @ApiPropertyOptional()
+  name: string;
+
+  @ApiPropertyOptional()
+  age: number;
+
+  @ApiPropertyOptional()
+  city: string;
+
+  @ApiPropertyOptional()
+  department: string;
+
+  @ApiPropertyOptional()
+  salary: number;
+
+  @ApiPropertyOptional()
+  status: string;
+
+  @ApiPropertyOptional()
+  hireDate: string;
+
+}

src/employees/dto/get-employees.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+import { CreateEmployeeDto } from './create-employee.dto';
+
+export class GetEmployeesDto {
+
+  @ApiProperty({
+    type: () => [CreateEmployeeDto],
+  })
+  items: Array<CreateEmployeeDto>;
+
+  @ApiProperty()
+  hasNext: boolean;
+
+}

src/employees/employees.controller.ts

@@ -0,0 +1,58 @@
+import { Controller, Get, Param, Body, Post, Put, Query, Delete } from '@nestjs/common';
+import { ApiResponse, ApiParam, ApiTags, ApiBody, ApiQuery } from '@nestjs/swagger';
+
+import { EmployeesService } from './employees.service';
+import { CreateEmployeeDto } from './dto/create-employee.dto';
+import { GetEmployeesDto } from './dto/get-employees.dto';
+
+@ApiTags('employees')
+@Controller('employees')
+export class EmployeesController {
+
+  constructor(private employeesService: EmployeesService) {}
+
+  @ApiResponse({ status: 200, type: GetEmployeesDto })
+  @ApiQuery({ name: 'search', required: false })
+  @ApiQuery({ name: '$filter', required: false })
+  @ApiQuery({ name: 'page', required: false })
+  @ApiQuery({ name: 'pageSize', required: false })
+  @Get()
+  getEmployees(@Query() query) {
+    const search = query['search'];
+    const filter = query['$filter'];
+    const page = query['page'];
+    const pageSize = query['pageSize'];
+
+    return this.employeesService.getEmployees(search, filter, page, pageSize);
+  }
+
+  @ApiResponse({ status: 200, type: CreateEmployeeDto })
+  @ApiParam({ name: 'id' })
+  @Get(':id')
+  getEmployee(@Param('id') id: string) {
+    return this.employeesService.getEmployee(parseInt(id, 10));
+  }
+
+  @ApiResponse({ status: 201, type: CreateEmployeeDto })
+  @ApiBody({ type: CreateEmployeeDto })
+  @Post()
+  save(@Body() employee: CreateEmployeeDto) {
+    this.employeesService.save(employee);
+  }
+
+  @ApiResponse({ status: 200, type: CreateEmployeeDto })
+  @ApiParam({ name: 'id' })
+  @ApiBody({ type: CreateEmployeeDto })
+  @Put(':id')
+  update(@Body() employee: CreateEmployeeDto, @Param('id') id: string) {
+    this.employeesService.update(parseInt(id, 10), employee);
+  }
+
+  @ApiResponse({ status: 200 })
+  @ApiParam({ name: 'id' })
+  @Delete(':id')
+  deleteEmployee(@Param('id') id: string) {
+    return this.employeesService.delete(parseInt(id, 10));
+  }
+
+}

src/employees/employees.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+
+import { EmployeesController } from './employees.controller';
+import { EmployeesService } from './employees.service';
+
+@Module({
+  controllers: [EmployeesController],
+  providers: [EmployeesService]
+})
+export class EmployeesModule {}

src/employees/employees.service.ts

@@ -0,0 +1,145 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+import { employees } from './db/employees.data';
+import { Employee } from './interfaces/employee.interface';
+import { Utils } from 'src/utils/utils';
+
+@Injectable()
+export class EmployeesService {
+
+  employees = [...employees];
+
+  getEmployees(search?: string, filter?: string, page?: string, pageSize?: string): { items: Array<Employee>, hasNext: boolean } {
+    let filteredEmployees = this.employees;
+
+    if (filter) {
+      filteredEmployees = this.applyODataFilter(filteredEmployees, filter);
+    } else if (search) {
+      filteredEmployees = Utils.filterByAll(search, filteredEmployees);
+    }
+
+    const total = filteredEmployees.length;
+    const parsedPage = page ? parseInt(page, 10) : undefined;
+    const parsedPageSize = pageSize ? parseInt(pageSize, 10) : undefined;
+    filteredEmployees = this.paginate(filteredEmployees, parsedPage, parsedPageSize);
+
+    return {
+      items: filteredEmployees,
+      hasNext: parsedPageSize ? total > (parsedPageSize * (parsedPage || 1)) : false
+    };
+  }
+
+  getEmployee(id: number): Employee {
+    const employee = this.employees.find(e => e.id === id);
+
+    if (!employee) {
+      throw new NotFoundException(`Funcionário ${id} não encontrado!`);
+    }
+
+    return employee;
+  }
+
+  save(employee: Employee) {
+    const id = this.employees.length > 0 ? Math.max(...this.employees.map(e => e.id)) + 1 : 1;
+    this.employees.push({ ...employee, id });
+  }
+
+  update(id: number, updatedEmployee: Employee) {
+    const employee = this.getEmployee(id);
+    Object.assign(employee, updatedEmployee);
+  }
+
+  delete(id: number) {
+    const index = this.employees.findIndex(e => e.id === id);
+
+    if (index === -1) {
+      throw new NotFoundException(`Funcionário ${id} não encontrado!`);
+    }
+
+    this.employees.splice(index, 1);
+    return { message: 'Funcionário removido com sucesso' };
+  }
+
+  private paginate(filteredEmployees: Array<Employee>, page?: number, pageSize?: number) {
+    if (pageSize || page) {
+      return Utils.paginate(filteredEmployees, page, pageSize);
+    }
+
+    return filteredEmployees;
+  }
+
+  private applyODataFilter(items: Array<Employee>, filter: string): Array<Employee> {
+    const conditions = filter.split(/\s+and\s+/i);
+
+    return items.filter(item => {
+      return conditions.every(condition => this.evaluateCondition(item, condition.trim()));
+    });
+  }
+
+  private evaluateCondition(item: any, condition: string): boolean {
+    // contains(property, 'value')
+    const containsMatch = condition.match(/contains\((\w+),\s*'([^']+)'\)/i);
+    if (containsMatch) {
+      const value = String(item[containsMatch[1]] || '').toLowerCase();
+      return value.includes(containsMatch[2].toLowerCase());
+    }
+
+    // startswith(property, 'value')
+    const startsWithMatch = condition.match(/startswith\((\w+),\s*'([^']+)'\)/i);
+    if (startsWithMatch) {
+      const value = String(item[startsWithMatch[1]] || '').toLowerCase();
+      return value.startsWith(startsWithMatch[2].toLowerCase());
+    }
+
+    // endswith(property, 'value')
+    const endsWithMatch = condition.match(/endswith\((\w+),\s*'([^']+)'\)/i);
+    if (endsWithMatch) {
+      const value = String(item[endsWithMatch[1]] || '').toLowerCase();
+      return value.endsWith(endsWithMatch[2].toLowerCase());
+    }
+
+    // property op 'string_value'
+    const stringMatch = condition.match(/(\w+)\s+(eq|ne)\s+'([^']+)'/);
+    if (stringMatch) {
+      const value = String(item[stringMatch[1]] || '');
+      const compareValue = stringMatch[3];
+      if (stringMatch[2] === 'eq') {
+        return value.toLowerCase() === compareValue.toLowerCase();
+      }
+      return value.toLowerCase() !== compareValue.toLowerCase();
+    }
+
+    // property op date_value (YYYY-MM-DD)
+    const dateMatch = condition.match(/(\w+)\s+(eq|ne|gt|ge|lt|le)\s+(\d{4}-\d{2}-\d{2})/);
+    if (dateMatch) {
+      const value = new Date(item[dateMatch[1]]).getTime();
+      const compareValue = new Date(dateMatch[3]).getTime();
+      switch (dateMatch[2]) {
+        case 'eq': return value === compareValue;
+        case 'ne': return value !== compareValue;
+        case 'gt': return value > compareValue;
+        case 'ge': return value >= compareValue;
+        case 'lt': return value < compareValue;
+        case 'le': return value <= compareValue;
+      }
+    }
+
+    // property op number_value
+    const numberMatch = condition.match(/(\w+)\s+(eq|ne|gt|ge|lt|le)\s+(\d+(?:\.\d+)?)/);
+    if (numberMatch) {
+      const value = Number(item[numberMatch[1]]);
+      const compareValue = Number(numberMatch[3]);
+      switch (numberMatch[2]) {
+        case 'eq': return value === compareValue;
+        case 'ne': return value !== compareValue;
+        case 'gt': return value > compareValue;
+        case 'ge': return value >= compareValue;
+        case 'lt': return value < compareValue;
+        case 'le': return value <= compareValue;
+      }
+    }
+
+    return true;
+  }
+
+}

src/employees/interfaces/employee.interface.ts

@@ -0,0 +1,19 @@
+export interface Employee {
+
+  id?: number;
+
+  name?: string;
+
+  age?: number;
+
+  city?: string;
+
+  department?: string;
+
+  salary?: number;
+
+  status?: string;
+
+  hireDate?: string;
+
+}