438 lines
19 KiB
Go
438 lines
19 KiB
Go
package handler
|
|
|
|
import (
|
|
"strconv"
|
|
"time"
|
|
|
|
"apskel-pos-be/internal/appcontext"
|
|
"apskel-pos-be/internal/constants"
|
|
"apskel-pos-be/internal/contract"
|
|
"apskel-pos-be/internal/logger"
|
|
"apskel-pos-be/internal/models"
|
|
"apskel-pos-be/internal/service"
|
|
"apskel-pos-be/internal/util"
|
|
"apskel-pos-be/internal/validator"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type InventoryHandler struct {
|
|
inventoryService service.InventoryService
|
|
inventoryValidator validator.InventoryValidator
|
|
}
|
|
|
|
func NewInventoryHandler(
|
|
inventoryService service.InventoryService,
|
|
inventoryValidator validator.InventoryValidator,
|
|
) *InventoryHandler {
|
|
return &InventoryHandler{
|
|
inventoryService: inventoryService,
|
|
inventoryValidator: inventoryValidator,
|
|
}
|
|
}
|
|
|
|
func (h *InventoryHandler) CreateInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
contextInfo := appcontext.FromGinContext(ctx)
|
|
|
|
var req contract.CreateInventoryRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.FromContext(c.Request.Context()).WithError(err).Error("InventoryHandler::CreateInventory -> request binding failed")
|
|
validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::CreateInventory")
|
|
return
|
|
}
|
|
|
|
validationError, validationErrorCode := h.inventoryValidator.ValidateCreateInventoryRequest(&req)
|
|
if validationError != nil {
|
|
validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::CreateInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.CreateInventory(ctx, contextInfo, &req)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::CreateInventory -> Failed to create inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::CreateInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) UpdateInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
inventoryIDStr := c.Param("id")
|
|
inventoryID, err := uuid.Parse(inventoryIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::UpdateInventory -> Invalid inventory ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid inventory ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::UpdateInventory")
|
|
return
|
|
}
|
|
|
|
var req contract.UpdateInventoryRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::UpdateInventory -> request binding failed")
|
|
validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "Invalid request body")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::UpdateInventory")
|
|
return
|
|
}
|
|
|
|
validationError, validationErrorCode := h.inventoryValidator.ValidateUpdateInventoryRequest(&req)
|
|
if validationError != nil {
|
|
validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::UpdateInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.UpdateInventory(ctx, inventoryID, &req)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::UpdateInventory -> Failed to update inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::UpdateInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) DeleteInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
inventoryIDStr := c.Param("id")
|
|
inventoryID, err := uuid.Parse(inventoryIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::DeleteInventory -> Invalid inventory ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid inventory ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::DeleteInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.DeleteInventory(ctx, inventoryID)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::DeleteInventory -> Failed to delete inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::DeleteInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) GetInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
inventoryIDStr := c.Param("id")
|
|
inventoryID, err := uuid.Parse(inventoryIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventory -> Invalid inventory ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid inventory ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.GetInventoryByID(ctx, inventoryID)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::GetInventory -> Failed to get inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::GetInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) ListInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
contextInfo := appcontext.FromGinContext(ctx)
|
|
|
|
req := &contract.ListInventoryRequest{
|
|
Page: 1,
|
|
Limit: 10,
|
|
OutletID: &contextInfo.OutletID,
|
|
}
|
|
|
|
if pageStr := c.Query("page"); pageStr != "" {
|
|
if page, err := strconv.Atoi(pageStr); err == nil {
|
|
req.Page = page
|
|
}
|
|
}
|
|
|
|
if limitStr := c.Query("limit"); limitStr != "" {
|
|
if limit, err := strconv.Atoi(limitStr); err == nil {
|
|
req.Limit = limit
|
|
}
|
|
}
|
|
|
|
if search := c.Query("search"); search != "" {
|
|
req.Search = search
|
|
}
|
|
|
|
if outletIDStr := c.Query("outlet_id"); outletIDStr != "" {
|
|
if outletID, err := uuid.Parse(outletIDStr); err == nil {
|
|
req.OutletID = &outletID
|
|
}
|
|
}
|
|
|
|
if productIDStr := c.Query("product_id"); productIDStr != "" {
|
|
if productID, err := uuid.Parse(productIDStr); err == nil {
|
|
req.ProductID = &productID
|
|
}
|
|
}
|
|
|
|
if categoryIDStr := c.Query("category_id"); categoryIDStr != "" {
|
|
if categoryID, err := uuid.Parse(categoryIDStr); err == nil {
|
|
req.CategoryID = &categoryID
|
|
}
|
|
}
|
|
|
|
if lowStockStr := c.Query("low_stock_only"); lowStockStr != "" {
|
|
if lowStock, err := strconv.ParseBool(lowStockStr); err == nil {
|
|
req.LowStockOnly = &lowStock
|
|
}
|
|
}
|
|
|
|
if zeroStockStr := c.Query("zero_stock_only"); zeroStockStr != "" {
|
|
if zeroStock, err := strconv.ParseBool(zeroStockStr); err == nil {
|
|
req.ZeroStockOnly = &zeroStock
|
|
}
|
|
}
|
|
|
|
validationError, validationErrorCode := h.inventoryValidator.ValidateListInventoryRequest(req)
|
|
if validationError != nil {
|
|
logger.FromContext(ctx).WithError(validationError).Error("InventoryHandler::ListInventory -> request validation failed")
|
|
validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::ListInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.ListInventory(ctx, req)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::ListInventory -> Failed to list inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::ListInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) AdjustInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
var req contract.AdjustInventoryRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::AdjustInventory -> request binding failed")
|
|
validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::AdjustInventory")
|
|
return
|
|
}
|
|
|
|
validationError, validationErrorCode := h.inventoryValidator.ValidateAdjustInventoryRequest(&req)
|
|
if validationError != nil {
|
|
validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::AdjustInventory")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.AdjustInventory(ctx, &req)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::AdjustInventory -> Failed to adjust inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::AdjustInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) RestockInventory(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
var req contract.RestockInventoryRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
logger.FromContext(c.Request.Context()).WithError(err).Error("InventoryHandler::RestockInventory -> request binding failed")
|
|
validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::RestockInventory")
|
|
return
|
|
}
|
|
|
|
// TODO: Add validation for restock request
|
|
// validationError, validationErrorCode := h.inventoryValidator.ValidateRestockInventoryRequest(&req)
|
|
// if validationError != nil {
|
|
// validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
|
|
// util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::RestockInventory")
|
|
// return
|
|
// }
|
|
|
|
inventoryResponse := h.inventoryService.RestockInventory(ctx, &req)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::RestockInventory -> Failed to restock inventory from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::RestockInventory")
|
|
}
|
|
|
|
func (h *InventoryHandler) GetLowStockItems(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
outletIDStr := c.Param("outlet_id")
|
|
outletID, err := uuid.Parse(outletIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetLowStockItems -> Invalid outlet ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetLowStockItems")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.GetLowStockItems(ctx, outletID)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::GetLowStockItems -> Failed to get low stock items from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::GetLowStockItems")
|
|
}
|
|
|
|
func (h *InventoryHandler) GetZeroStockItems(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
|
|
outletIDStr := c.Param("outlet_id")
|
|
outletID, err := uuid.Parse(outletIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetZeroStockItems -> Invalid outlet ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetZeroStockItems")
|
|
return
|
|
}
|
|
|
|
inventoryResponse := h.inventoryService.GetZeroStockItems(ctx, outletID)
|
|
if inventoryResponse.HasErrors() {
|
|
errorResp := inventoryResponse.GetErrors()[0]
|
|
logger.FromContext(ctx).WithError(errorResp).Error("InventoryHandler::GetZeroStockItems -> Failed to get zero stock items from service")
|
|
}
|
|
|
|
util.HandleResponse(c.Writer, c.Request, inventoryResponse, "InventoryHandler::GetZeroStockItems")
|
|
}
|
|
|
|
func (h *InventoryHandler) GetInventoryReportSummary(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
contextInfo := appcontext.FromGinContext(ctx)
|
|
|
|
outletIDStr := c.Param("outlet_id")
|
|
outletID, err := uuid.Parse(outletIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventoryReportSummary -> Invalid outlet ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetInventoryReportSummary")
|
|
return
|
|
}
|
|
|
|
// Parse date range parameters for summary
|
|
var dateFrom, dateTo *time.Time
|
|
if dateFromStr := c.Query("date_from"); dateFromStr != "" {
|
|
if parsedDateFrom, err := time.Parse("2006-01-02", dateFromStr); err == nil {
|
|
dateFrom = &parsedDateFrom
|
|
}
|
|
}
|
|
if dateToStr := c.Query("date_to"); dateToStr != "" {
|
|
if parsedDateTo, err := time.Parse("2006-01-02", dateToStr); err == nil {
|
|
dateTo = &parsedDateTo
|
|
}
|
|
}
|
|
|
|
summary, err := h.inventoryService.GetInventoryReportSummary(ctx, outletID, contextInfo.OrganizationID, dateFrom, dateTo)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventoryReportSummary -> Failed to get inventory report summary from service")
|
|
responseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{responseError}), "InventoryHandler::GetInventoryReportSummary")
|
|
return
|
|
}
|
|
|
|
response := contract.BuildSuccessResponse(summary)
|
|
util.HandleResponse(c.Writer, c.Request, response, "InventoryHandler::GetInventoryReportSummary")
|
|
}
|
|
|
|
func (h *InventoryHandler) GetInventoryReportDetails(c *gin.Context) {
|
|
ctx := c.Request.Context()
|
|
contextInfo := appcontext.FromGinContext(ctx)
|
|
|
|
filter := &models.InventoryReportFilter{}
|
|
|
|
if outletIDStr := c.Param("outlet_id"); outletIDStr != "" {
|
|
outletID, err := uuid.Parse(outletIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventoryReportDetails -> Invalid outlet ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetInventoryReportDetails")
|
|
return
|
|
}
|
|
filter.OutletID = &outletID
|
|
} else {
|
|
logger.FromContext(ctx).Error("InventoryHandler::GetInventoryReportDetails -> Missing outlet_id parameter")
|
|
validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "outlet_id is required")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetInventoryReportDetails")
|
|
return
|
|
}
|
|
|
|
if categoryIDStr := c.Query("category_id"); categoryIDStr != "" {
|
|
categoryID, err := uuid.Parse(categoryIDStr)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventoryReportDetails -> Invalid category ID")
|
|
validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid category ID")
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "InventoryHandler::GetInventoryReportDetails")
|
|
return
|
|
}
|
|
filter.CategoryID = &categoryID
|
|
}
|
|
|
|
// Parse show_low_stock (optional)
|
|
if showLowStockStr := c.Query("show_low_stock"); showLowStockStr != "" {
|
|
if showLowStock, err := strconv.ParseBool(showLowStockStr); err == nil {
|
|
filter.ShowLowStock = &showLowStock
|
|
}
|
|
}
|
|
|
|
// Parse show_zero_stock (optional)
|
|
if showZeroStockStr := c.Query("show_zero_stock"); showZeroStockStr != "" {
|
|
if showZeroStock, err := strconv.ParseBool(showZeroStockStr); err == nil {
|
|
filter.ShowZeroStock = &showZeroStock
|
|
}
|
|
}
|
|
|
|
// Parse search (optional)
|
|
if search := c.Query("search"); search != "" {
|
|
filter.Search = &search
|
|
}
|
|
|
|
// Parse limit (optional)
|
|
if limitStr := c.Query("limit"); limitStr != "" {
|
|
if limit, err := strconv.Atoi(limitStr); err == nil && limit > 0 {
|
|
filter.Limit = &limit
|
|
}
|
|
}
|
|
|
|
// Parse offset (optional)
|
|
if offsetStr := c.Query("offset"); offsetStr != "" {
|
|
if offset, err := strconv.Atoi(offsetStr); err == nil && offset >= 0 {
|
|
filter.Offset = &offset
|
|
}
|
|
}
|
|
|
|
dateFromStr := c.Query("date_from")
|
|
dateToStr := c.Query("date_to")
|
|
|
|
if fromTime, toTime, err := util.ParseDateRangeToJakartaTime(dateFromStr, dateToStr); err == nil {
|
|
if fromTime != nil {
|
|
filter.DateFrom = fromTime
|
|
}
|
|
if toTime != nil {
|
|
filter.DateTo = toTime
|
|
}
|
|
}
|
|
|
|
report, err := h.inventoryService.GetInventoryReportDetails(ctx, filter, contextInfo.OrganizationID)
|
|
if err != nil {
|
|
logger.FromContext(ctx).WithError(err).Error("InventoryHandler::GetInventoryReportDetails -> Failed to get inventory report details from service")
|
|
responseError := contract.NewResponseError(constants.InternalServerErrorCode, constants.RequestEntity, err.Error())
|
|
util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{responseError}), "InventoryHandler::GetInventoryReportDetails")
|
|
return
|
|
}
|
|
|
|
response := contract.BuildSuccessResponse(report)
|
|
util.HandleResponse(c.Writer, c.Request, response, "InventoryHandler::GetInventoryReportDetails")
|
|
}
|