cargo-platform/internal/handlers/router/postal_code/postal_code.go

package postal_code

import (
	"cargo-erp-backend/internal/handlers/dto"
	postal_codeimporter "cargo-erp-backend/internal/importers/postal_code"
	"cargo-erp-backend/internal/usecases"
	"cargo-erp-backend/pkg/helpers"
	"cargo-erp-backend/pkg/importer"
	"cargo-erp-backend/pkg/response"
	"net/http"

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

type PostalCodeHandlerInterface interface {
	Router()
}

type PostalCodeHandler struct {
	Helper helpers.HelperInterface
	Group  *gin.RouterGroup
}

func NewPostalCodeHandler(helper helpers.HelperInterface, g *gin.RouterGroup) PostalCodeHandlerInterface {
	return &PostalCodeHandler{Helper: helper, Group: g}
}

func (h *PostalCodeHandler) Router() {
	r := h.Group.Group("postal-codes")
	{
		r.GET("/", h.GetAll)
		r.POST("/list", h.GetList)
		r.GET("/:id", h.GetByID)
		r.POST("/", h.Create)
		r.PUT("/:id", h.Update)
		r.DELETE("/:id", h.Delete)
		r.GET("/template", h.Template)
		r.POST("/import", h.Import)
		r.POST("/import/stop", h.ImportStop)
		r.GET("/import/status/:jobId", h.ImportStatus)
	}
}

func (h *PostalCodeHandler) GetAll(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	var req dto.PostalCodeFilterAllRequest
	if err := c.ShouldBindQuery(&req); err != nil {
		response.Error(c, http.StatusBadRequest, err.Error())
		return
	}
	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	postalCodes, _, err := u.GetAll(req)
	if err != nil {
		response.Error(c, http.StatusInternalServerError, err.Error())
		return
	}
	var responseDTO = make([]dto.CreatePostalCodeResponse, 0)
	for _, v := range postalCodes {
		var DTO dto.CreatePostalCodeResponse
		h.Helper.MapStructToStruct(v, "json", &DTO, "json")
		responseDTO = append(responseDTO, DTO)
	}
	response.Success(c, responseDTO)
}

func (h *PostalCodeHandler) GetList(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}

	var req dto.DataTableRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "Request Format request invalid")
		return
	}
	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	res, err := u.GetList(req)
	if err != nil {
		response.Error(c, http.StatusInternalServerError, err.Error())
		return
	}
	response.Success(c, res)
	return
}

func (h *PostalCodeHandler) GetByID(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	id := c.Param("id")

	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	postalCode, err := u.GetByID(id)
	if err != nil {
		response.Error(c, http.StatusNotFound, "postal code not found")
		return
	}

	response.Success(c, postalCode)
}

func (h *PostalCodeHandler) Create(c *gin.Context) {
	var req dto.CreatePostalCodeRequest
	if err := c.BindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, err.Error())
		return
	}
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	var merchantid *string = nil
	if userid.UsersRole_Relation == nil || userid.UsersRole_Relation.RoleKey != "SPM" {
		merchantid = userid.MerchantID
	}
	createdBy := userid.ID

	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	postalCode, err := u.Create(req.PostalCode, req.ProvinceID, req.CityID, req.DistrictID, req.SubdistrictID, createdBy, merchantid)
	if err != nil {
		response.Error(c, http.StatusInternalServerError, err.Error())
		return
	}
	var responseDTO dto.CreatePostalCodeResponse
	h.Helper.MapStructToStruct(postalCode, "json", &responseDTO, "json")
	response.Created(c, responseDTO)
}

func (h *PostalCodeHandler) Update(c *gin.Context) {
	id := c.Param("id")

	var req dto.UpdatePostalCodeRequest
	if err := c.BindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, err.Error())
		return
	}
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	updatedBy := userid.ID

	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	postalCode, err := u.Update(id, req.PostalCode, req.ProvinceID, req.CityID, req.DistrictID, req.SubdistrictID, updatedBy)
	if err != nil {
		response.Error(c, http.StatusInternalServerError, err.Error())
		return
	}
	var responseDTO dto.CreatePostalCodeResponse
	h.Helper.MapStructToStruct(postalCode, "json", &responseDTO, "json")
	response.Success(c, responseDTO)
}

func (h *PostalCodeHandler) Delete(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	id := c.Param("id")
	u := usecases.NewPostalCodeUsecase(h.Helper, *userid)
	if err := u.Delete(id); err != nil {
		response.Error(c, http.StatusInternalServerError, err.Error())
		return
	}

	response.Success(c, map[string]interface{}{"message": "postal code deleted"})
}

func (h *PostalCodeHandler) Template(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	handler := postal_codeimporter.NewPostalCodeImportHandler(*userid, h.Helper)
	imp := importer.NewImporter(h.Helper, handler)
	imp.ServeTemplate(c.Writer)
}

func (h *PostalCodeHandler) Import(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}

	file, header, err := c.Request.FormFile("file")
	if err != nil {
		response.Error(c, http.StatusBadRequest, "File is required")
		return
	}
	defer file.Close()

	handler := postal_codeimporter.NewPostalCodeImportHandler(*userid, h.Helper)
	imp := importer.NewImporter(h.Helper, handler)

	result, err := imp.Process(file, userid.ID, header.Filename)
	if err != nil {
		response.Error(c, http.StatusBadRequest, err.Error())
		return
	}

	var importLogs []dto.ImportLog
	for _, l := range result.Logs {
		importLogs = append(importLogs, dto.ImportLog{
			Row:     l.Row,
			Status:  l.Status,
			Data:    l.Data,
			Message: l.Message,
		})
	}

	response.Success(c, dto.ImportPostalCodeResponse{
		JobID:     result.JobID,
		TotalRows: result.TotalRows,
		Imported:  result.Imported,
		Skipped:   result.Skipped,
		Logs:      importLogs,
		Errors:    result.Errors,
		IsAsync:   result.IsAsync,
		Message:   result.Message,
	})
}

func (h *PostalCodeHandler) ImportStatus(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}
	jobId := c.Param("jobId")

	handler := postal_codeimporter.NewPostalCodeImportHandler(*userid, h.Helper)
	imp := importer.NewImporter(h.Helper, handler)

	job, logs, err := imp.GetJobStatus(jobId)
	if err != nil {
		response.Error(c, http.StatusNotFound, "Job not found")
		return
	}

	response.Success(c, map[string]interface{}{
		"job":  job,
		"logs": logs,
	})
}

func (h *PostalCodeHandler) ImportStop(c *gin.Context) {
	userid, err := h.Helper.GetAuthInfo(c.GetString("auth"))
	if err != nil {
		response.Error(c, http.StatusUnauthorized, err.Error())
		return
	}

	var req dto.StopImportRequest
	if err := c.BindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "job_id is required")
		return
	}

	handler := postal_codeimporter.NewPostalCodeImportHandler(*userid, h.Helper)
	imp := importer.NewImporter(h.Helper, handler)

	if err := imp.StopJob(req.JobID); err != nil {
		response.Error(c, http.StatusBadRequest, err.Error())
		return
	}

	response.Success(c, map[string]interface{}{"message": "Job stopped"})
}