138 lines
4.6 KiB
Go
138 lines
4.6 KiB
Go
package handler
|
|
|
|
import (
|
|
"eslogad-be/internal/constants"
|
|
"eslogad-be/internal/contract"
|
|
"eslogad-be/internal/logger"
|
|
"net/http"
|
|
"strconv"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type RepositoryAttachmentHandler struct {
|
|
attachmentService RepositoryAttachmentService
|
|
}
|
|
|
|
func NewRepositoryAttachmentHandler(attachmentService RepositoryAttachmentService) *RepositoryAttachmentHandler {
|
|
return &RepositoryAttachmentHandler{
|
|
attachmentService: attachmentService,
|
|
}
|
|
}
|
|
|
|
func (h *RepositoryAttachmentHandler) CreateAttachment(c *gin.Context) {
|
|
var req contract.CreateRepositoryAttachmentRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::CreateAttachment -> request binding failed")
|
|
h.sendValidationErrorResponse(c, "Invalid request body", constants.MissingFieldErrorCode)
|
|
return
|
|
}
|
|
|
|
userResponse, err := h.attachmentService.CreateAttachment(c.Request.Context(), &req)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::CreateAttachment -> Failed to create user from service")
|
|
h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
logger.FromContext(c).Infof("UserHandler::CreateUser -> Successfully created repository attachment = %+v", userResponse)
|
|
c.JSON(http.StatusOK, contract.BuildSuccessResponse(userResponse))
|
|
}
|
|
|
|
func (h *RepositoryAttachmentHandler) DeleteAttachment(c *gin.Context) {
|
|
attachmentIDStr := c.Param("id")
|
|
attachmentID, err := uuid.Parse(attachmentIDStr)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::DeleteAttachment -> Invalid attachment id")
|
|
h.sendValidationErrorResponse(c, "Invalid user ID", constants.MalformedFieldErrorCode)
|
|
return
|
|
}
|
|
|
|
err = h.attachmentService.DeleteAttachment(c.Request.Context(), attachmentID)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::DeleteAttachment -> Failed to delete attachment from service")
|
|
h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
logger.FromContext(c).Info("UserHandler::DeleteAttachment -> Successfully deleted attachment")
|
|
c.JSON(http.StatusOK, &contract.SuccessResponse{Message: "User deleted successfully"})
|
|
}
|
|
|
|
func (h *RepositoryAttachmentHandler) GetAttachment(c *gin.Context) {
|
|
attachmentIDStr := c.Param("id")
|
|
attachmentID, err := uuid.Parse(attachmentIDStr)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::GetAttachment -> Invalid attachment ID")
|
|
h.sendValidationErrorResponse(c, "Invalid user ID", constants.MalformedFieldErrorCode)
|
|
return
|
|
}
|
|
|
|
attachmentResponse, err := h.attachmentService.GetById(c.Request.Context(), attachmentID)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::GetAttachment -> Failed to get attachment from service")
|
|
h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
logger.FromContext(c).Infof("UserHandler::GetAttachment -> Successfully retrieved attachment = %+v", attachmentResponse)
|
|
c.JSON(http.StatusOK, attachmentResponse)
|
|
}
|
|
func (h *RepositoryAttachmentHandler) ListAttachment(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
req := &contract.ListRepositoryAttachmentsRequest{
|
|
Page: 1,
|
|
Limit: 10,
|
|
}
|
|
|
|
if page := c.Query("page"); page != "" {
|
|
if p, err := strconv.Atoi(page); err == nil {
|
|
req.Page = p
|
|
}
|
|
}
|
|
|
|
if limit := c.Query("limit"); limit != "" {
|
|
if l, err := strconv.Atoi(limit); err == nil {
|
|
req.Limit = l
|
|
}
|
|
}
|
|
|
|
attachmentsResponse, err := h.attachmentService.ListAttachment(ctx, req)
|
|
if err != nil {
|
|
logger.FromContext(c).WithError(err).Error("UserHandler::ListUsers -> Failed to list users from service")
|
|
h.sendErrorResponse(c, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
logger.FromContext(c).Infof("UserHandler::ListUsers -> Successfully listed users = %+v", attachmentsResponse)
|
|
c.JSON(http.StatusOK, contract.BuildSuccessResponse(attachmentsResponse))
|
|
}
|
|
|
|
func (h *RepositoryAttachmentHandler) sendValidationErrorResponse(c *gin.Context, message string, errorCode string) {
|
|
statusCode := constants.HttpErrorMap[errorCode]
|
|
if statusCode == 0 {
|
|
statusCode = http.StatusBadRequest
|
|
}
|
|
|
|
errorResponse := &contract.ErrorResponse{
|
|
Error: message,
|
|
Code: statusCode,
|
|
Details: map[string]interface{}{
|
|
"error_code": errorCode,
|
|
"entity": constants.UserValidatorEntity,
|
|
},
|
|
}
|
|
c.JSON(statusCode, errorResponse)
|
|
}
|
|
|
|
func (h *RepositoryAttachmentHandler) sendErrorResponse(c *gin.Context, message string, statusCode int) {
|
|
errorResponse := &contract.ErrorResponse{
|
|
Error: message,
|
|
Code: statusCode,
|
|
Details: map[string]interface{}{},
|
|
}
|
|
c.JSON(statusCode, errorResponse)
|
|
}
|