Update backend

internal/entity/order.go

@@ -109,6 +109,7 @@ type OrderExecuteRequest struct {
 func (o *Order) SetExecutePaymentStatus() {
 	if o.PaymentType == "CASH" {
 		o.Status = "PAID"
+		o.TicketStatus = "USED"
 		return
 	}
 	o.Status = "PENDING"
@@ -184,7 +185,9 @@ func (e *HistoryOrderDB) ToHistoryOrder() *HistoryOrder {
 func (b *HistoryOrderList) ToHistoryOrderList() []*HistoryOrder {
 	var HistoryOrders []*HistoryOrder
 	for _, historyOrder := range *b {
-		HistoryOrders = append(HistoryOrders, historyOrder.ToHistoryOrder())
+		if historyOrder.Status != "NEW" && historyOrder.Tickets != nil {
+			HistoryOrders = append(HistoryOrders, historyOrder.ToHistoryOrder())
+		}
 	}
 	return HistoryOrders
 }

internal/handlers/http/customerorder/order.go

@@ -42,9 +42,8 @@ func (h *Handler) Inquiry(c *gin.Context) {
 		return
 	}
 
-	validate := validator.New()
+	if err := request.ValidateAndHandleError(req); err != nil {
-	if err := validate.Struct(req); err != nil {
+		response.ErrorWrapper(c, errors.NewErrorMessage(errors.ErrorBadRequest, err.Error()))
-		response.ErrorWrapper(c, err)
 		return
 	}
 

internal/handlers/request/order.go

@@ -15,9 +15,9 @@ type Order struct {
 
 type CustomerOrder struct {
 	PartnerID     int64                     `json:"partner_id" validate:"required"`
-	PaymentMethod transaction.PaymentMethod `json:"payment_method" validate:"required"`
+	PaymentMethod transaction.PaymentMethod `json:"payment_method" validate:"required,oneof=ONLINE"`
-	OrderItems    []OrderItem               `json:"order_items" validate:"required"`
+	OrderItems    []OrderItem               `json:"order_items" validate:"required,min=1"`
-	VisitDate     string                    `json:"visit_date"`
+	VisitDate     string                    `json:"visit_date" validate:"required"`
 }
 
 func (o *CustomerOrder) ToEntity(createdBy int64) *entity.OrderRequest {

internal/handlers/request/user.go

@@ -10,7 +10,7 @@ import (
 
 type User struct {
 	Name        string    `json:"name" validate:"required"`
-	Email       string    `json:"email" validate:"required"`
+	Email       string    `json:"email" validate:"required,email"`
 	Password    string    `json:"password" validate:"required"`
 	PartnerID   *int64    `json:"partner_id"`
 	SiteID      *int64    `json:"site_id"`
@@ -72,6 +72,7 @@ func (p *UserParam) ToEntity(ctx mycontext.Context) entity.UserSearch {
 		Offset:    p.Offset,
 	}
 }
+
 type CustomerParam struct {
 	Search    string `form:"search" json:"search" example:"admin,branch1"`
 	Name      string `form:"name" json:"name" example:"Admin 1"`

internal/handlers/request/validator.go

@@ -0,0 +1,50 @@
+package request
+
+import (
+	errors2 "errors"
+	"github.com/go-playground/validator/v10"
+	"reflect"
+)
+
+var validate *validator.Validate
+
+func ValidateAndHandleError(req interface{}) error {
+	validate = validator.New()
+
+	if err := validate.Struct(req); err != nil {
+		formattedError := formatValidationError(err)
+		return errors2.New(formattedError)
+	}
+	return nil
+}
+
+func formatValidationError(err error) string {
+	if _, ok := err.(*validator.InvalidValidationError); ok {
+		return err.Error()
+	}
+
+	var errorMessage string
+	for _, err := range err.(validator.ValidationErrors) {
+		switch err.Tag() {
+		case "required":
+			errorMessage += "The field '" + err.Field() + "' is required."
+		case "min":
+			if err.Kind() == reflect.Slice {
+				errorMessage += "The field '" + err.Field() + "' must contain at least " + err.Param() + " items."
+			} else {
+				errorMessage += "The field '" + err.Field() + "' must be at least " + err.Param() + "."
+			}
+		case "oneof":
+			errorMessage += "The field '" + err.Field() + "' must be one of [" + err.Param() + "]."
+		case "email":
+			errorMessage += "The field '" + err.Field() + "' must be a valid email address."
+		case "len":
+			errorMessage += "The field '" + err.Field() + "' must be exactly " + err.Param() + " characters long."
+		default:
+			errorMessage += "The field '" + err.Field() + "' is invalid."
+		}
+		errorMessage += " "
+	}
+
+	return errorMessage
+}

internal/services/order/order.go

@@ -64,9 +64,11 @@ func (s *OrderService) CreateOrder(ctx mycontext.Context, req *entity.OrderReque
 		return nil, err
 	}
 
+	var siteID int64
 	productMap := make(map[int64]*entity.ProductDB)
 	for _, product := range products {
 		productMap[product.ID] = product
+		siteID = product.SiteID
 	}
 
 	totalAmount := 0.0
@@ -86,18 +88,19 @@ func (s *OrderService) CreateOrder(ctx mycontext.Context, req *entity.OrderReque
 	}
 
 	order := &entity.Order{
-		PartnerID:   req.PartnerID,
+		PartnerID:    req.PartnerID,
-		RefID:       generator.GenerateUUID(),
+		RefID:        generator.GenerateUUID(),
-		Status:      order2.New.String(),
+		Status:       order2.New.String(),
-		Amount:      totalAmount,
+		Amount:       totalAmount,
-		Total:       totalAmount + s.cfg.GetOrderFee(),
+		Total:        totalAmount + s.cfg.GetOrderFee(),
-		Fee:         s.cfg.GetOrderFee(),
+		Fee:          s.cfg.GetOrderFee(),
-		PaymentType: req.PaymentMethod,
+		PaymentType:  req.PaymentMethod,
-		SiteID:      ctx.GetSiteID(),
+		SiteID:       &siteID,
-		CreatedBy:   req.CreatedBy,
+		CreatedBy:    req.CreatedBy,
-		OrderItems:  []entity.OrderItem{},
+		OrderItems:   []entity.OrderItem{},
-		Source:      req.Source,
+		Source:       req.Source,
-		VisitDate:   parsedTime,
+		VisitDate:    parsedTime,
+		TicketStatus: "UNUSED",
 	}
 
 	for _, item := range req.OrderItems {

internal/utils/format_validator_error.go

@@ -0,0 +1,38 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/go-playground/validator/v10"
+	"reflect"
+)
+
+func formatValidationError(err error) string {
+	if _, ok := err.(*validator.InvalidValidationError); ok {
+		return err.Error()
+	}
+
+	var errorMessage string
+	for _, err := range err.(validator.ValidationErrors) {
+		switch err.Tag() {
+		case "required":
+			errorMessage += fmt.Sprintf("The field '%s' is required.", err.Field())
+		case "min":
+			if err.Kind() == reflect.Slice {
+				errorMessage += fmt.Sprintf("The field '%s' must contain at least %s items.", err.Field(), err.Param())
+			} else {
+				errorMessage += fmt.Sprintf("The field '%s' must be at least %s.", err.Field(), err.Param())
+			}
+		case "oneof":
+			errorMessage += fmt.Sprintf("The field '%s' must be one of [%s].", err.Field(), err.Param())
+		case "email":
+			errorMessage += fmt.Sprintf("The field '%s' must be a valid email address.", err.Field())
+		case "len":
+			errorMessage += fmt.Sprintf("The field '%s' must be exactly %s characters long.", err.Field(), err.Param())
+		default:
+			errorMessage += fmt.Sprintf("The field '%s' is invalid.", err.Field())
+		}
+		errorMessage += " "
+	}
+
+	return errorMessage
+}