api-antrian-operasi/internal/domain/antrian_operasi/handler.go

package antrianoperasi

import (
	"log"

	diagnosa "antrian-operasi/internal/domain/reference/diagnosa"
	dokter "antrian-operasi/internal/domain/reference/dokter"
	kategori "antrian-operasi/internal/domain/reference/kategori"
	"antrian-operasi/internal/domain/reference/pasien"
	spesialis "antrian-operasi/internal/domain/reference/spesialis"
	tindakan "antrian-operasi/internal/domain/reference/tindakan"
	"antrian-operasi/internal/shared"

	"github.com/gin-gonic/gin"
)

type AntrianOperasiHandler struct {
	repo          IAntrianOperasiRepository
	repoKategori  kategori.IKategoriRepository
	repoSpesialis spesialis.ISpesialisRepository
	repoDokter    dokter.IDokterRepository
	repoDiagnosa  diagnosa.IDiagnosaRepository
	repoTindakan  tindakan.ITindakanRepository
	repoPasien    pasien.IPasienRepository
}

func NewAntrianOperasiHandler(
	repo IAntrianOperasiRepository,
	repoKategori kategori.IKategoriRepository,
	repoSpesialis spesialis.ISpesialisRepository,
	repoDokter dokter.IDokterRepository,
	repoDiagnosa diagnosa.IDiagnosaRepository,
	repoTindakan tindakan.ITindakanRepository,
	repoPasien pasien.IPasienRepository) AntrianOperasiHandler {
	return AntrianOperasiHandler{
		repo, repoKategori, repoSpesialis, repoDokter, repoDiagnosa, repoTindakan, repoPasien,
	}
}

// CreateAntrianOperasi godoc
// @Summary Create Antrian Operasi
// @Tags Antrian Operasi
// @Param body body CreatePasienOperasiRequest true "Create Pasien Operasi"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/ [post]
func (h AntrianOperasiHandler) CreateAntrianOperasi(c *gin.Context) {
	var req CreatePasienOperasiRequest
	// Binding format JSON
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "error bind json",
			Errors:  shared.ValidationError(err),
		})
		return
	}

	// Request data master validation
	isValid, errValidation := req.DataValidation(c, h)
	if isValid == false {
		log.Printf("validation error : %s", errValidation)
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "validation error",
			Errors:  errValidation,
		})
		return
	}

	// Start insert database
	res, err := h.repo.CreateAntrianOperasi(c, req)
	if err != nil {
		log.Printf("insert error : %s", err)
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "insert error",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(201, shared.ToBaseResponse(res, true, 201, "success insert antrian operasi"))
}

// ListAntrianOperasi godoc
// @Summary Get List Antrian Operasi
// @Tags Antrian Operasi
// @Param search query string false "Search Keyword"
// @Param type query string false "Type antrian : all, kategori, spesialis, sub-spesialis"
// @Param type_id query string false "Type id :id kategori, id spesialis, id sub-spesialis"
// @Param status query string false "Status : 1, 2, 3, 4"
// @Param limit query string false "Limit" default(10)
// @Param offset query string false "Offset" default(0)
// @Param sort_by query string false "Type sort : tanggal_daftar no_urut_kategori no_urut_spesialis"
// @Param sort_order query string false "Type sort order : ASC DESC"
// @Success 200 {object} []PasienOperasi
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/ [get]
func (h AntrianOperasiHandler) GetListAntrianOperasi(c *gin.Context) {
	var query AntrianQuery
	if err := c.ShouldBindQuery(&query); err != nil {
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "error bind json",
			Errors:  shared.ValidationError(err),
		})
		return
	}

	res, err := h.repo.SearchableListAntrianOperasi(c.Request.Context(), query)
	if err != nil {
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: err.Error(),
		})
		return
	}

	c.JSON(200,
		shared.ToBaseResponsePaginate(
			res.Data, res.Paging, true, 200, "success get list antrian operasi",
		))
}

// DetailAntrianOperasi godoc
// @Summary Detail List Antrian Operasi
// @Tags Antrian Operasi
// @Param id path string true "id antrian"
// @Success 200 {object} DetailPasienOperasiResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/{id} [get]
func (h AntrianOperasiHandler) GetDetailAntrianOperasi(c *gin.Context) {
	id := c.Param("id")
	res, err := h.repo.GetAntrianOperasiById(c, id)
	if err != nil {
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: err.Error(),
		})
		return
	}

	c.JSON(200,
		shared.ToBaseResponse(
			res.MapToResponse(), true, 200, "success get antrian operasi",
		))
}

// UpdateAntrianOperasi godoc
// @Summary Update Antrian Operasi
// @Tags Antrian Operasi
// @Param id path string true "id antrian"
// @Param body body CreatePasienOperasiRequest true "Update Pasien Operasi"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/{id} [put]
func (h AntrianOperasiHandler) UpdateAntrianOperasi(c *gin.Context) {
	id := c.Param("id")
	var req CreatePasienOperasiRequest
	// Binding format JSON
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "error bind json",
			Errors:  shared.ValidationError(err),
		})
		return
	}

	// Request data master validation
	isValid, errValidation := req.DataValidation(c, h)
	if isValid == false {
		log.Printf("validation error : %s", errValidation)
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "validation error",
			Errors:  errValidation,
		})
		return
	}

	// Start insert database
	res, err := h.repo.UpdateAntrianOperasi(c, id, req)
	if err != nil {
		log.Printf("insert error : %s", err)
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "update error",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(200, shared.ToBaseResponse(res, true, 200, "success update antrian operasi"))
}

// UpdateStatusAntrianOperasi godoc
// @Summary Update Status Antrian Operasi
// @Tags Antrian Operasi
// @Param id path string true "id antrian"
// @Param body body StatusPasienRequest true "Update Status Pasien Operasi"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/{id}/update-status [put]
func (h AntrianOperasiHandler) UpdateStatusAntrianOperasi(c *gin.Context) {
	id := c.Param("id")
	var req StatusPasienRequest
	// Binding format JSON
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "error bind json",
			Errors:  shared.ValidationError(err),
		})
		return
	}

	// Request data master validation
	isValid, errValidation := req.UpdateStatusValidation()
	if isValid == false {
		log.Printf("validation error : %s", errValidation)
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "validation error",
			Errors:  errValidation,
		})
		return
	}

	// Start update database
	res, err := h.repo.UpdateStatusAntrianOperasi(c, id, req)
	if err != nil {
		log.Printf("update antrian error : %s", err)
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "update error",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(200, shared.ToBaseResponse(res, true, 200, "success update antrian operasi"))
}

// DeleteAntrianOperasi godoc
// @Summary Delete Antrian Operasi
// @Tags Antrian Operasi
// @Param id path string true "id antrian"
// @Success 200 {object} shared.BaseResponse
// @Failure 500 {object} shared.BaseErrorResponse
// @Router /antrian-operasi/{id} [delete]
func (h AntrianOperasiHandler) DeleteAntrianOperasi(c *gin.Context) {
	id := c.Param("id")
	// check antrian is exist
	_, err := h.repo.GetAntrianOperasiById(c, id)
	if err != nil {
		log.Printf("validation error : %s", err)
		c.JSON(400, shared.BaseErrorResponse{
			Success: false,
			Code:    400,
			Message: "antrian not found",
		})
		return
	}

	// Start delete
	err = h.repo.DeleteStatusAntrianOperasi(c, id)
	if err != nil {
		log.Printf("delete antrian error : %s", err)
		errMessage := []string{err.Error()}
		c.JSON(500, shared.BaseErrorResponse{
			Success: false,
			Code:    500,
			Message: "delete error",
			Errors:  errMessage,
		})
		return
	}

	c.JSON(200, shared.ToBaseResponse("", true, 200, "success delete antrian operasi"))
}