wms-be/modules/quarantine/controller/quarantine_controller.go

package controller

import (
	"github.com/Caknoooo/go-gin-clean-starter/modules/quarantine/dto"
	"github.com/Caknoooo/go-gin-clean-starter/modules/quarantine/query"
	"github.com/Caknoooo/go-gin-clean-starter/modules/quarantine/service"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/constants"
	"github.com/Caknoooo/go-gin-clean-starter/pkg/utils"
	"github.com/gin-gonic/gin"
	"github.com/samber/do"
	"gorm.io/gorm"
)

type QuarantineController interface {
	Create(ctx *gin.Context)
	Update(ctx *gin.Context)
	Delete(ctx *gin.Context)
	GetById(ctx *gin.Context)
	GetAll(ctx *gin.Context)
	GetLinesByQuarantineId(ctx *gin.Context)
	CreateLine(ctx *gin.Context)
	UpdateLine(ctx *gin.Context)
	DeleteLine(ctx *gin.Context)
	OnComplete(ctx *gin.Context)
}

type quarantineController struct {
	quarantineService service.QuarantineService
	db                *gorm.DB
}

// GetLinesByQuarantineId implements QuarantineController.
func (c *quarantineController) GetLinesByQuarantineId(ctx *gin.Context) {
	id := ctx.Param("id")
	lines, err := c.quarantineService.GetLinesByQuarantineId(ctx, id)

	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_QUARANTINE_LINES, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_QUARANTINE_LINES, lines)
	ctx.JSON(200, res)
}

func NewQuarantineController(i *do.Injector, quarantineService service.QuarantineService) QuarantineController {
	return &quarantineController{
		quarantineService: quarantineService,
		db:                do.MustInvokeNamed[*gorm.DB](i, constants.DB),
	}
}

func (c *quarantineController) Create(ctx *gin.Context) {
	var req dto.QuarantineCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(400, res)
		return
	}
	created, err := c.quarantineService.Create(ctx, req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_CREATE_QUARANTINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_CREATE_QUARANTINE, created)
	ctx.JSON(200, res)
}

func (c *quarantineController) GetById(ctx *gin.Context) {
	id := ctx.Param("id")
	quarantine, err := c.quarantineService.GetById(ctx, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_QUARANTINE, err.Error(), nil)
		ctx.JSON(404, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_QUARANTINE, quarantine)
	ctx.JSON(200, res)
}

func (c *quarantineController) GetAll(ctx *gin.Context) {
	clientId := ctx.DefaultQuery("client_id", "")
	var filter query.QuarantineFilter
	filter.ClientID = clientId
	if err := ctx.ShouldBindQuery(&filter); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_QUARANTINE, err.Error(), nil)
		ctx.JSON(400, res)
		return
	}
	getAll := ctx.Query("get_all")
	if getAll != "" {
		quarantines, _, err := c.quarantineService.GetAll(ctx, filter)
		if err != nil {
			res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_QUARANTINE, err.Error(), nil)
			ctx.JSON(400, res)
			return
		}
		response := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_GET_QUARANTINE, quarantines)
		ctx.JSON(200, response)
		return
	}
	perPage := utils.ParseInt(ctx.DefaultQuery("per_page", "10"))
	page := utils.ParseInt(ctx.DefaultQuery("page", "1"))
	filter.PerPage = perPage
	filter.Page = (page - 1) * perPage
	quarantines, total, err := c.quarantineService.GetAll(ctx, filter)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_QUARANTINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	paginationResponse := utils.BuildPaginationResponse(perPage, page, total)
	res := utils.BuildResponseSuccessWithPagination(200, dto.MESSAGE_SUCCESS_GET_QUARANTINE, quarantines, paginationResponse)
	ctx.JSON(200, res)
}

func (c *quarantineController) Update(ctx *gin.Context) {
	id := ctx.Param("id")
	var req dto.QuarantineUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(400, res)
		return
	}
	updated, err := c.quarantineService.Update(ctx, req, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_UPDATE_QUARANTINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_UPDATE_QUARANTINE, updated)
	ctx.JSON(200, res)
}

func (c *quarantineController) Delete(ctx *gin.Context) {
	id := ctx.Param("id")
	if err := c.quarantineService.Delete(ctx, id); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_QUARANTINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_DELETE_QUARANTINE, nil)
	ctx.JSON(200, res)
}

func (c *quarantineController) CreateLine(ctx *gin.Context) {
	id := ctx.Param("id")
	var req dto.QuarantineLineCreateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(400, res)
		return
	}
	created, err := c.quarantineService.CreateLine(ctx, id, req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_CREATE_QUARANTINE_LINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_CREATE_QUARANTINE_LINE, created)
	ctx.JSON(200, res)
}

func (c *quarantineController) UpdateLine(ctx *gin.Context) {
	id := ctx.Param("id")
	var req dto.QuarantineLineUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_GET_DATA_FROM_BODY, err.Error(), nil)
		ctx.JSON(400, res)
		return
	}
	updated, err := c.quarantineService.UpdateLine(ctx, id, req)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_UPDATE_QUARANTINE_LINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_UPDATE_QUARANTINE_LINE, updated)
	ctx.JSON(200, res)
}

func (c *quarantineController) DeleteLine(ctx *gin.Context) {
	id := ctx.Param("id")
	if err := c.quarantineService.DeleteLine(ctx, id); err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_DELETE_QUARANTINE_LINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_DELETE_QUARANTINE_LINE, nil)
	ctx.JSON(200, res)
}

func (c *quarantineController) OnComplete(ctx *gin.Context) {
	id := ctx.Param("id")
	updated, err := c.quarantineService.OnComplete(ctx, id)
	if err != nil {
		res := utils.BuildResponseFailed(dto.MESSAGE_FAILED_COMPLETE_QUARANTINE, err.Error(), nil)
		ctx.JSON(500, res)
		return
	}
	res := utils.BuildResponseSuccess(dto.MESSAGE_SUCCESS_COMPLETE_QUARANTINE, updated)
	ctx.JSON(200, res)
}