Ajeng

prisma/migrations/20240610092131_add_meeting_model/migration.sql

+-- CreateTable
+CREATE TABLE "Meeting" (
+    "id_meeting" SERIAL NOT NULL,
+    "id_employee" INTEGER NOT NULL,
+    "date" TIMESTAMP(3) NOT NULL,
+    "start_time" TIMESTAMP(3) NOT NULL,
+    "end_time" TIMESTAMP(3) NOT NULL,
+    "link_meeting" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+
+    CONSTRAINT "Meeting_pkey" PRIMARY KEY ("id_meeting")
+);
+
+-- AddForeignKey
+ALTER TABLE "Meeting" ADD CONSTRAINT "Meeting_id_employee_fkey" FOREIGN KEY ("id_employee") REFERENCES "Employee"("id_employee") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/schema.prisma

   Presensi      Presensi[]
   overtimes     Overtimes[]
   time_off      TimeOff[]
+  meeting       Meeting[]
 }
 
 enum Pendidikan {
   menikah
   melahirkan
 }
+
+
+model Meeting {
+  id_meeting    Int     @id @default(autoincrement())
+  id_employee   Int
+  employee      Employee? @relation(fields: [id_employee], references: [id_employee])
+  date          DateTime
+  start_time    DateTime
+  end_time      DateTime
+  link_meeting  String
+  description   String
+}
+

src/key_result/key_result.controller.ts

   Get,
   Post,
   Body,
-  Patch,
   Param,
   Delete,
+  Put,
   // UseGuards,
 } from '@nestjs/common';
 import { KeyResultService } from './key_result.service';
     return this.keyResultService.findOne({ id_key_result: +id });
   }
 
-  @Patch(':id')
+  @Put(':id')
   update(
     @Param('id') id: string,
     @Body() updateKeyResultDto: UpdateKeyResultDto,

src/meeting/dto/create-meeting.dto.ts

-export class CreateMeetingDto {}
+import { IsDateString, IsInt, IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateMeetingDto {
+  @IsNotEmpty()
+  @IsInt()
+  id_employee: number;
+
+  @IsNotEmpty()
+  @IsDateString()
+  date: string;
+
+  @IsNotEmpty()
+  @IsDateString()
+  start_time: string;
+
+  @IsNotEmpty()
+  @IsDateString()
+  end_time: string;
+
+  @IsNotEmpty()
+  @IsString()
+  link_meeting: string;
+
+  @IsNotEmpty()
+  @IsString()
+  description: string;
+}

src/meeting/meeting.controller.ts

-import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Param,
+  Delete,
+  Put,
+} from '@nestjs/common';
 import { MeetingService } from './meeting.service';
 import { CreateMeetingDto } from './dto/create-meeting.dto';
 import { UpdateMeetingDto } from './dto/update-meeting.dto';
+import { AuthService } from 'src/auth/auth.service';
 
 @Controller('meeting')
 export class MeetingController {
-  constructor(private readonly meetingService: MeetingService) {}
+  constructor(
+    private readonly meetingService: MeetingService,
+    private readonly authService: AuthService,
+  ) {}
 
   @Post()
   create(@Body() createMeetingDto: CreateMeetingDto) {
 
   @Get(':id')
   findOne(@Param('id') id: string) {
-    return this.meetingService.findOne(+id);
+    return this.meetingService.findOne({ id_meeting: +id });
   }
 
-  @Patch(':id')
+  @Put(':id')
   update(@Param('id') id: string, @Body() updateMeetingDto: UpdateMeetingDto) {
-    return this.meetingService.update(+id, updateMeetingDto);
+    return this.meetingService.update({ id_meeting: +id }, updateMeetingDto);
   }
 
   @Delete(':id')

src/meeting/meeting.module.ts

 import { Module } from '@nestjs/common';
 import { MeetingService } from './meeting.service';
 import { MeetingController } from './meeting.controller';
+import { PrismaService } from 'src/prisma.service';
+import { AuthService } from 'src/auth/auth.service';
+import { EmployeeService } from 'src/employee/employee.service';
 
 @Module({
   controllers: [MeetingController],
-  providers: [MeetingService]
+  providers: [MeetingService, PrismaService, AuthService, EmployeeService],
 })
 export class MeetingModule {}

src/meeting/meeting.service.ts

-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable } from '@nestjs/common';
 import { CreateMeetingDto } from './dto/create-meeting.dto';
 import { UpdateMeetingDto } from './dto/update-meeting.dto';
+import { PrismaService } from 'src/prisma.service';
+import { Prisma } from '@prisma/client';
 
 @Injectable()
 export class MeetingService {
-  create(createMeetingDto: CreateMeetingDto) {
-    return 'This action adds a new meeting';
+  constructor(private prisma: PrismaService) {}
+
+  async create(createMeetingDto: CreateMeetingDto) {
+    try {
+      const createMeeting = await this.prisma.meeting.create({
+        data: {
+          id_employee: createMeetingDto.id_employee,
+          date: new Date(createMeetingDto.date),
+          start_time: new Date(createMeetingDto.start_time),
+          end_time: new Date(createMeetingDto.end_time),
+          link_meeting: createMeetingDto.link_meeting,
+          description: createMeetingDto.description,
+        },
+      });
+      return createMeeting;
+    } catch (error) {
+      console.error('Error creating meeting:', error);
+      throw new BadRequestException('Gagal menambahkan meeting');
+    }
   }
 
   findAll() {
-    return `This action returns all meeting`;
+    return this.prisma.meeting.findMany();
   }
 
-  findOne(id: number) {
-    return `This action returns a #${id} meeting`;
+  async findOne(getMeetingbyId: Prisma.MeetingWhereUniqueInput) {
+    const getMeeting = await this.prisma.meeting.findUnique({
+      where: getMeetingbyId,
+    });
+    if (!getMeeting) {
+      throw new BadRequestException('data tidak ditemukan');
+    }
+
+    return getMeeting;
   }
 
-  update(id: number, updateMeetingDto: UpdateMeetingDto) {
-    return `This action updates a #${id} meeting`;
+  async update(
+    where: Prisma.MeetingWhereUniqueInput,
+    updateMeetingDto: UpdateMeetingDto,
+  ) {
+    try {
+      const updateMeeting = await this.prisma.meeting.update({
+        where,
+        data: {
+          id_employee: updateMeetingDto.id_employee,
+          date: updateMeetingDto.date
+            ? new Date(updateMeetingDto.date)
+            : undefined,
+          start_time: updateMeetingDto.start_time
+            ? new Date(updateMeetingDto.start_time)
+            : undefined,
+          end_time: updateMeetingDto.end_time
+            ? new Date(updateMeetingDto.end_time)
+            : undefined,
+          link_meeting: updateMeetingDto.link_meeting,
+          description: updateMeetingDto.description,
+        },
+      });
+      return {
+        message: 'Data meeting berhasil di update',
+        meeting: updateMeeting,
+      };
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2025'
+      ) {
+        throw new BadRequestException('Data meeting tidak dapat ditemukan');
+      }
+      throw error;
+    }
   }
 
-  remove(id: number) {
-    return `This action removes a #${id} meeting`;
+  async remove(id: number) {
+    try {
+      const deleteMeeting = await this.prisma.meeting.delete({
+        where: { id_meeting: id },
+      });
+      if (!deleteMeeting) {
+        throw new BadRequestException('Data meeting tidak dapat ditemukan');
+      }
+      return { message: 'Data meeting berhasil dihapus' };
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2025'
+      ) {
+        throw new BadRequestException('Data meeting tidak dapat ditemukan');
+      }
+      throw error;
+    }
   }
 }

src/main.ts

 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+
+  // Konfigurasi CORS
+  app.enableCors({
+    origin: 'http://localhost:5173', // Ganti dengan URL Vue.js Anda
+    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+    credentials: true, // Izinkan pengiriman cookie dan otorisasi header
+  });
+
   await app.listen(3000);
 }
 bootstrap();