ticket-booking-be/src/event/eventAdditionalDetail/eventAdditionalDetail.controller.ts

import { Body, Controller, Delete, Get, Param, Post, Put, Res, UsePipes, ValidationPipe } from '@nestjs/common';
import { EventAdditionalDetailService } from './eventAdditionalDetail.service';
import { Response } from 'express';
import { GenericResponse } from '../../common/GenericResponse.model';
import EventAdditionalDetail from './eventAdditionalDetail.entity';
import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiBody } from '@nestjs/swagger';
import { EventAdditionalDetailDTO, EventAdditionalDetailUpdateDTO } from './eventAdditionalDetail.dto';

@ApiTags('event/addl')
@Controller('event/addl/')
export class EventAdditionalDetailController {
    constructor(private eventAdditionalDetailService: EventAdditionalDetailService) {}

    @Get("/all")
    @ApiOperation({ summary: 'Get all eventAdditionalDetails' })
    @ApiResponse({
        status: 200,
        description: 'Successfully retrieved all eventAdditionalDetails',
    })
    @ApiResponse({
        status: 404,
        description: 'No eventAdditionalDetails found',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NOT_FOUND",
                "stackTrace": "No eventAdditionalDetails found"
            },
            "data": null
        }
    })
    async getAllEventAdditionalDetails(@Res() res: Response) {
        const response = await this.eventAdditionalDetailService.findAll() || [];
        if(!response) {
            const errorResponse = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NOT_FOUND',
                stackTrace: 'No eventAdditionalDetails found'
            }, null);
            return res.status(404).send(errorResponse);
        }
        const httpResponse = new GenericResponse(null, response);
        res.send(httpResponse);
    }

    @Get(':id')
    @ApiOperation({ summary: 'Get eventAdditionalDetail by ID' })
    @ApiParam({ name: 'id', type: Number, description: 'EventAdditionalDetail ID' })
    @ApiResponse({
        status: 400,
        description: 'ID is required',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NO_ID_REQ",
                "stackTrace": "Request"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 404,
        description: 'EventAdditionalDetail not found',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NOT_FOUND",
                "stackTrace": "EventAdditionalDetail not found"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 200,
        description: 'Successfully retrieved eventAdditionalDetail by ID',
    })
    async findById(@Param('id') id: number, @Res() res: Response) {
        if (!id) {
            const response = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NO_ID_REQ',
                stackTrace: 'Request'
            }, null);
            return res.status(400).send(response);
        }
        const response = await this.eventAdditionalDetailService.findByPk(id) || {};
        if (!response) {
            const errorResponse = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NOT_FOUND',
                stackTrace: `EventAdditionalDetail with ID ${id} not found`
            }, null);
            return res.status(404).send(errorResponse);
        }
        const httpResponse = new GenericResponse(null, response);
        res.status(200).send(httpResponse);
    }

    @Post('/filter')
    @ApiOperation({ summary: 'Filter eventAdditionalDetails based on criteria' })
    @ApiBody({ type: EventAdditionalDetail, description: 'Filter criteria for eventAdditionalDetails' })
    @ApiResponse({
        status: 400,
        description: 'Invalid filter criteria',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.INVALID_CRITERIA",
                "stackTrace": "Request"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 404,
        description: 'No eventAdditionalDetails found based on filter criteria',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NOT_FOUND",
                "stackTrace": "No eventAdditionalDetails found based on the filter criteria"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 200,
        description: 'Successfully filtered eventAdditionalDetails',
    })
    async filter(@Body() eventAdditionalDetail: EventAdditionalDetail, @Res() res: Response) {
        if (!eventAdditionalDetail) {
            const response = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.INVALID_CRITERIA',
                stackTrace: 'Request'
            }, null);
            return res.status(400).send(response);
        }
        const response = await this.eventAdditionalDetailService.filter(eventAdditionalDetail) || [];
        if (!response) {
            const errorResponse = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NOT_FOUND',
                stackTrace: 'No eventAdditionalDetails found based on the filter criteria'
            }, null);
            return res.status(404).send(errorResponse);
        }
        const httpResponse = new GenericResponse(null, response);
        res.status(200).send(httpResponse);
    }

    @Post()
    @ApiOperation({ summary: 'Insert a new eventAdditionalDetail' })
    @ApiBody({ type: EventAdditionalDetailDTO, description: 'EventAdditionalDetail data to insert' })
    @ApiResponse({
        status: 400,
        description: 'Invalid eventAdditionalDetail data',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.INVALID_DATA",
                "stackTrace": "Request"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 201,
        description: 'Successfully created a eventAdditionalDetail',
    })
    @UsePipes(new ValidationPipe({ whitelist: true}))
    async insert(@Body() eventAdditionalDetail: EventAdditionalDetailDTO, @Res() res: Response) {
        if (!eventAdditionalDetail) {
            const response = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.INVALID_DATA',
                stackTrace: 'Request'
            }, null);
            return res.status(400).send(response);
        }
        const response = await this.eventAdditionalDetailService.upsert(eventAdditionalDetail, true);
        const httpResponse = new GenericResponse(null, response);
        res.status(201).send(httpResponse);
    }

    @Put()
    @ApiOperation({ summary: 'Update an existing eventAdditionalDetail' })
    @ApiBody({ type: EventAdditionalDetailUpdateDTO, description: 'EventAdditionalDetail data to update' })
    @ApiResponse({
        status: 400,
        description: 'Invalid eventAdditionalDetail data or ID missing',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.INVALID_DATA",
                "stackTrace": "Request"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 404,
        description: 'EventAdditionalDetail not found',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NOT_FOUND",
                "stackTrace": "EventAdditionalDetail not found"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 200,
        description: 'Successfully updated eventAdditionalDetail',
    })
    @UsePipes(new ValidationPipe({ whitelist: true, skipMissingProperties: true }))
    async update(@Body() eventAdditionalDetail: EventAdditionalDetailUpdateDTO, @Res() res: Response) {
        if (!eventAdditionalDetail || !eventAdditionalDetail.id) {
            const response = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NO_ID_REQ',
                stackTrace: 'Request'
            }, null);
            return res.status(400).send(response);
        }
        const response = await this.eventAdditionalDetailService.upsert(eventAdditionalDetail, false);
        if (!response) {
            const errorResponse = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NOT_FOUND',
                stackTrace: `EventAdditionalDetail with ID ${eventAdditionalDetail.id} not found`
            }, null);
            return res.status(404).send(errorResponse);
        }
        const httpResponse = new GenericResponse(null, response);
        res.status(200).send(httpResponse);
    }

    @Delete(':id')
    @ApiOperation({ summary: 'Delete a eventAdditionalDetail by ID' })
    @ApiParam({ name: 'id', type: Number, description: 'EventAdditionalDetail ID to delete' })
    @ApiResponse({
        status: 400,
        description: 'ID parameter is required',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NO_ID_REQ",
                "stackTrace": "Request"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 404,
        description: 'EventAdditionalDetail not found',
        example: {
            "notification": {
                "exception": true,
                "exceptionSeverity": "HIGH",
                "exceptionMessage": "ERR.NOT_FOUND",
                "stackTrace": "EventAdditionalDetail not found"
            },
            "data": null
        }
    })
    @ApiResponse({
        status: 200,
        description: 'Successfully deleted eventAdditionalDetail',
    })
    async deleteById(@Param('id') id: number, @Res() res: Response) {
        if (!id) {
            const response = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NO_ID_REQ',
                stackTrace: 'Request'
            }, null);
            return res.status(400).send(response);
        }
        const response = await this.eventAdditionalDetailService.remove(id) || {};
        if (!response) {
            const errorResponse = new GenericResponse({
                exception: true,
                exceptionSeverity: 'HIGH',
                exceptionMessage: 'ERR.NOT_FOUND',
                stackTrace: `EventAdditionalDetail with ID ${id} not found`
            }, null);
            return res.status(404).send(errorResponse);
        }
        const httpResponse = new GenericResponse(null, response);
        res.status(200).send(httpResponse);
    }
}