feat(module): leave-requests module with shifts minor fixes

src/modules/leave_requests/controllers/leave-requests.controller.ts

@@ -0,0 +1,38 @@
+import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post } from "@nestjs/common";
+import { LeaveRequestsService } from "../services/leave-request.service";
+import { CreateLeaveRequestsDto } from "../dtos/create-leave-requests.dto";
+import { LeaveRequests } from "@prisma/client";
+import { UpdateLeaveRequestsDto } from "../dtos/update-leave-requests.dto";
+
+@Controller('leave-requests')
+export class LeaveRequestController {
+    constructor(private readonly leaveRequetsService: LeaveRequestsService){}
+
+    @Post()
+    create(@Body() dto: CreateLeaveRequestsDto): Promise<LeaveRequests> {
+        return this. leaveRequetsService.create(dto);
+    }
+
+    @Get()
+    findAll(): Promise<LeaveRequests[]> {
+        return this.leaveRequetsService.findAll();
+    }
+
+    @Get(':id')
+    findOne(@Param('id', ParseIntPipe) id: number): Promise<LeaveRequests> {
+        return this.leaveRequetsService.findOne(id);
+    }
+
+    @Patch(':id')
+    update(
+        @Param('id', ParseIntPipe) id: number,
+        @Body() dto: UpdateLeaveRequestsDto,
+    ): Promise<LeaveRequests> {
+        return this.leaveRequetsService.update(id, dto);
+    }
+
+    @Delete(':id')
+    remove(@Param('id', ParseIntPipe) id: number): Promise<LeaveRequests> {
+        return this.leaveRequetsService.remove(id);
+    }
+}

src/modules/leave_requests/dtos/create-leave-requests.dto.ts

@@ -1,3 +1,28 @@
+import { LeaveApprovalStatus, LeaveTypes } from "@prisma/client";
+import { Type } from "class-transformer";
+import { IsEnum, IsInt, IsNotEmpty, IsOptional, IsString } from "class-validator";
+
 export class CreateLeaveRequestsDto {
-    
-}
+    @Type(()=> Number)
+    @IsInt()
+    employee_id: number;
+
+    @IsEnum(LeaveTypes)
+    leave_type: LeaveTypes;
+
+    @Type(()=>Date)
+    @IsNotEmpty()
+    start_date_time:Date;
+
+    @Type(()=>Date)
+    @IsOptional()
+    end_date_time?: Date;
+
+    @IsString()
+    @IsNotEmpty()
+    comment: string;
+
+    @IsEnum(LeaveApprovalStatus)
+    @IsOptional()
+    approval_status?: LeaveApprovalStatus;
+}

src/modules/leave_requests/dtos/update-leave-requests.dto.ts

@@ -1,3 +1,4 @@
-export class UpdateLeaveRequestsDto {
-    
-}
+import { PartialType } from "@nestjs/swagger";
+import { CreateLeaveRequestsDto } from "./create-leave-requests.dto";
+
+export class UpdateLeaveRequestsDto extends PartialType(CreateLeaveRequestsDto){}

src/modules/leave_requests/leave-requests.module.ts

@@ -0,0 +1,11 @@
+import { PrismaService } from "src/prisma/prisma.service";
+import { LeaveRequestController } from "./controllers/leave-requests.controller";
+import { LeaveRequestsService } from "./services/leave-request.service";
+import { Module } from "@nestjs/common";
+
+@Module({
+    controllers: [LeaveRequestController],
+    providers: [ LeaveRequestsService, PrismaService],
+})
+
+export class LeaveRequestsModule {}

src/modules/leave_requests/services/leave-request.service.ts

@@ -0,0 +1,109 @@
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { PrismaService } from "src/prisma/prisma.service";
+import { CreateLeaveRequestsDto } from "../dtos/create-leave-requests.dto";
+import { LeaveRequests } from "@prisma/client";
+import { UpdateLeaveRequestsDto } from "../dtos/update-leave-requests.dto";
+
+@Injectable()
+export class LeaveRequestsService {
+    constructor(private readonly prisma: PrismaService) {}
+
+    async create(dto: CreateLeaveRequestsDto): Promise<LeaveRequests> {
+        const {
+            employee_id,
+            leave_type,
+            start_date_time,
+            end_date_time,
+            comment,
+            approval_status,
+        } = dto;
+
+        return this.prisma.leaveRequests.create({
+            data: {
+                employee_id,
+                leave_type,
+                start_date_time,
+                end_date_time,
+                comment,
+                approval_status: approval_status ?? undefined,
+            },
+            include: {
+                employee: {
+                    include: {
+                        user: true
+                    },
+                },
+            },
+        });
+    }
+
+    findAll(): Promise<LeaveRequests[]> {
+        return this.prisma.leaveRequests.findMany({
+            include: {
+                employee: {
+                    include: {
+                        user: true
+                    },
+                },
+            },
+        });
+    }
+
+    async findOne(id:number): Promise<LeaveRequests> {
+        const req = await this.prisma.leaveRequests.findUnique({
+        where: { id },
+            include: {
+                employee: {
+                    include: {
+                        user: true
+                    },
+                },
+            }, 
+        });
+        if(!req) {
+            throw new NotFoundException(`LeaveRequest #${id} not found`);
+        }
+        return req;
+    }
+
+
+    async update(
+        id: number,
+        dto: UpdateLeaveRequestsDto,
+    ): Promise<LeaveRequests> {
+        await this.findOne(id);
+        const {
+            employee_id,
+            leave_type,
+            start_date_time,
+            end_date_time,
+            comment,
+            approval_status,
+        } = dto;
+        return this.prisma.leaveRequests.update({
+            where: { id },
+            data: {
+                ...(employee_id !== undefined && { employee_id }),
+                ...(leave_type !== undefined && { leave_type } ),
+                ...(start_date_time !== undefined && { start_date_time }),
+                ...(end_date_time !== undefined && { end_date_time }),
+                ...(comment !== undefined && { comment }),
+                ...(approval_status == undefined && { approval_status }),
+            },
+            include: {
+                employee: {
+                    include: {
+                        user:true
+                    },
+                },
+            },
+        });
+    }
+
+    async remove(id:number): Promise<LeaveRequests> {
+        await this.findOne(id);
+        return this.prisma.leaveRequests.delete({
+            where: { id },
+        });
+    }
+}

src/modules/shifts/controllers/shifts.controller.ts

@@ -1,8 +1,8 @@
 import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post } from "@nestjs/common";
 import { ShiftsService } from "../services/shifts.service";
 import { Shifts } from "@prisma/client";
-import { UpdateEmployeeDto } from "src/modules/employees/dtos/update-employee.dto";
 import { CreateShiftDto } from "../dtos/create-shifts.dto";
+import { UpdateShiftsDto } from "../dtos/update-shifts.dto";
 
 @Controller('shifts')
 export class ShiftsController {
@@ -27,7 +27,7 @@ export class ShiftsController {
       @Patch(':id')
       update(
         @Param('id', ParseIntPipe) id: number,
-        @Body() dto: UpdateEmployeeDto,
+        @Body() dto: UpdateShiftsDto,
       ): Promise<Shifts> {
         return this.shiftsService.update(id, dto);
       }

src/modules/shifts/services/shifts.service.ts

@@ -8,73 +8,62 @@ import { UpdateShiftsDto } from "../dtos/update-shifts.dto";
 export class ShiftsService {
     constructor(private readonly prisma: PrismaService) {}
 
-    async create(dto: CreateShiftDto): Promise<Shifts> {
-        const {
-            timesheet_id,
-            shift_code_id,
-            date,
-            start_time,
-            end_time 
-        } = dto;
-
-        return this.prisma.shifts.create({
-            data: { 
-                timesheet_id,
-                shift_code_id,
-                date, start_time,
-                end_time
-            },
-            include: {
-                shift: {
-                    include: {
-                        employee: {
-                            include: { user: true }
-                        },
-                    },
-                shift_code: true,
-                },
-            },
-        });
-    }
+  async create(dto: CreateShiftDto): Promise<Shifts> {
+    const { timesheet_id, shift_code_id, date, start_time, end_time } = dto;
+    return this.prisma.shifts.create({
+      data: { timesheet_id, shift_code_id, date, start_time, end_time },
+      include: {
+        timesheet: {
+          include: {
+            employee: { include: { user: true } },
+          },
+        },
+        shift_code: true,
+      },
+    });
+  }
 
     findAll(): Promise<Shifts[]> {
         return this.prisma.shifts.findMany({
             include: {
                 timesheet: {
-                    include: {
-                        employee: { user:true }
+                  include: {
+                        employee: {
+                         include: { user:true }
                     },
                 },
             },
+          },
         });
     }
 
     async findOne(id: number): Promise<Shifts> {
         const shift = await this.prisma.shifts.findUnique({
             where: { id },
-                include: {
-                    timesheet: {
-                        include: {
-                            employee: { user: true }
+            include: {
+                timesheet: {
+                  include: {
+                      employee: {
+                       include: { user: true }
                         },
                     },
-                    shift_code: true,
                 },
-            });
-            if(!shift) {
-                throw new NotFoundException(`Shift #${id} not found`);
-            }
+            shift_code: true,
+            },
+        });
+        if(!shift) {
+            throw new NotFoundException(`Shift #${id} not found`);
+        }
         return shift;
     }
 
-    async update(
-        id: number,
-        dto: UpdateShiftsDto,
-    ): Promise<Shifts> {
-        await this.prisma.shifts.update({
+    async update(id: number, dto: UpdateShiftsDto): Promise<Shifts> {
+        await this.findOne(id);
+        const { timesheet_id, shift_code_id, date,start_time,end_time} = dto;
+        return this.prisma.shifts.update({
             where: { id },
             data: {
-                ...(timesheets_id !== undefined && { timesheet_id }),
+                ...(timesheet_id !== undefined && { timesheet_id }),
                 ...(shift_code_id !== undefined && { shift_code_id }),
                 ...(date !== undefined && { date }),
                 ...(start_time !== undefined && { start_time }),
@@ -87,8 +76,8 @@ export class ShiftsService {
                             include: { user: true }
                         },
                     },
-                    shift_code: true,
                 },
+            shift_code: true,
             },
         });
     }