11 improve service #major (#14)

* improve service

* add service improvements

* improve the models

internal/api/api.go

@@ -15,9 +15,9 @@ import (
 )
 
 type Service interface {
-	ApplyCoupon(entity.Basket, string) (*entity.Basket, error)
-	CreateCoupon(int, string, int) (string, error)
-	GetCoupons([]string) ([]entity.Coupon, error)
+	ApplyCoupon(*entity.Basket, string) error
+	CreateCoupon(discount int, code string, minBasketValue int) (*entity.Coupon, error)
+	GetCoupons([]string) ([]*entity.Coupon, error)
 }
 
 // Config store main api settings
@@ -37,7 +37,7 @@ type API struct {
 	cfg Config
 }
 
-func New[T Service](cfg Config, svc T) (*API, error) {
+func New(cfg Config, svc Service) (*API, error) {
 	var logger *zap.Logger
 	var err error
 

internal/api/coupon.go

@@ -14,42 +14,44 @@ func (a *API) Apply(c *gin.Context) {
 	if err := c.ShouldBindJSON(&apiReq); err != nil {
 		return
 	}
-	basket, err := a.svc.ApplyCoupon(apiReq.Basket, apiReq.Code)
+	err := a.svc.ApplyCoupon(&apiReq.Basket, apiReq.Code)
 	if err != nil {
+		SendError(c, "error to apply the coupon", err.Error(), http.StatusBadRequest)
 		return
 	}
-
-	c.JSON(http.StatusOK, basket)
+	SendSuccess(c, "coupon applied successfully", apiReq.Basket)
 }
 
 func (a *API) Create(c *gin.Context) {
-	apiReq := Coupon{}
+	apiReq := CouponRequest{}
 	if err := c.ShouldBindJSON(&apiReq); err != nil {
+		SendError(c, "error to read the body", err.Error(), http.StatusBadRequest)
 		return
 	}
-	id, err := a.svc.CreateCoupon(apiReq.Discount, apiReq.Code, apiReq.MinBasketValue)
+	coupon, err := a.svc.CreateCoupon(apiReq.Discount, apiReq.Code, apiReq.MinBasketValue)
 	if err != nil {
 		SendError(c, "error to create coupon", err.Error(), http.StatusBadRequest)
+		return
 	}
-	SendSuccess(c, fmt.Sprintf("Coupon %s created successfully", id), nil)
+	SendSuccess(c, fmt.Sprintf("coupon %s created successfully", coupon.ID), coupon)
 }
 
 func (a *API) Get(c *gin.Context) {
 	codes := c.Query("codes")
 	if codes == "" {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "query parameter 'codes' is required"})
+		SendError(c, "query parameter 'codes' is required", "", http.StatusBadRequest)
 		return
 	}
 	codeList := strings.Split(codes, ",")
 	if len(codeList) == 0 {
-		c.JSON(http.StatusBadRequest, gin.H{"error": "query parameter 'codes' cannot be empty"})
+		SendError(c, "query parameter 'codes' cannot be empty", "", http.StatusBadRequest)
 		return
 	}
 
 	coupons, err := a.svc.GetCoupons(codeList)
 	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "failed not found coupons"})
+		SendError(c, "error to found all coupons", err.Error(), http.StatusNotFound)
 		return
 	}
-	c.JSON(http.StatusOK, coupons)
+	SendSuccess(c, "found all coupons", coupons)
 }

internal/api/entity/Coupons.go

@@ -1,7 +1,7 @@
 package entity
 
-type Coupon struct {
-	Discount       int    `json:"discount"`
-	Code           string `json:"code"`
-	MinBasketValue int    `json:"min_basket_value"`
+type CouponRequest struct {
+	Discount       int    `json:"discount" binding:"required"`
+	Code           string `json:"code" binding:"required"`
+	MinBasketValue int    `json:"min_basket_value" binding:"required"`
 }

internal/api/entity/applicationRequest.go

@@ -3,6 +3,6 @@ package entity
 import "coupon_service/internal/service/entity"
 
 type ApplicationRequest struct {
-	Code   string
-	Basket entity.Basket
+	Code   string        `json:"code" binding:"required"`
+	Basket entity.Basket `json:"basket" binding:"required"`
 }

internal/repository/memdb/memdb.go

@@ -70,17 +70,3 @@ func (r *Repository) Save(coupon *entity.Coupon) error {
 	r.entries[coupon.Code] = &couponCopy
 	return nil
 }
-
-// Delete removes a Coupon from the repository by its code.
-// It returns an error if the coupon does not exist.
-func (r *Repository) Delete(code string) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	if _, exists := r.entries[code]; !exists {
-		return ErrCouponNotFound
-	}
-
-	delete(r.entries, code)
-	return nil
-}

internal/repository/memdb/memdb_test.go

@@ -96,20 +96,8 @@ func TestRepository_Delete(t *testing.T) {
 		err := repo.Save(coupon)
 		assert.NoError(t, err, "Expected no error when saving a valid coupon")
 
-		err = repo.Delete("WINTER30")
-		assert.NoError(t, err, "Expected no error when deleting an existing coupon")
-
-		// Verify that the coupon is deleted
-		_, err = repo.FindByCode("WINTER30")
-		assert.Error(t, err, "Expected an error when finding a deleted coupon")
-		assert.Equal(t, ErrCouponNotFound, err, "Error should be ErrCouponNotFound")
 	})
 
-	t.Run("Attempt to delete a non-existent coupon", func(t *testing.T) {
-		err := repo.Delete("NONEXISTENT")
-		assert.Error(t, err, "Expected an error when deleting a non-existent coupon")
-		assert.Equal(t, ErrCouponNotFound, err, "Error should be ErrCouponNotFound")
-	})
 }
 
 func TestRepository_Concurrency(t *testing.T) {

internal/service/entity/basket.go

@@ -5,7 +5,7 @@ import (
 )
 
 type Basket struct {
-	Value                 int
-	AppliedDiscount       int
-	ApplicationSuccessful bool
+	Value                 int  `json:"Value" binding:"required"`
+	AppliedDiscount       int  `json:"applied_discount,omitempty"`
+	ApplicationSuccessful bool `json:"application_successful,omitempty"`
 }

internal/service/entity/coupon.go

@@ -1,8 +1,8 @@
 package entity
 
 type Coupon struct {
-	ID             string
-	Code           string
-	Discount       int
-	MinBasketValue int
+	ID             string `json:"id"`
+	Code           string `json:"code"`
+	Discount       int    `json:"discount"`
+	MinBasketValue int    `json:"min_basket_value"`
 }

internal/service/errors.go

@@ -0,0 +1,29 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+)
+
+// Custom errors for better error handling.
+var (
+	ErrApplyDiscount          = errors.New("cannot apply discount to a basket of non-positive value")
+	ErrCouponDiscountValue    = errors.New("discount must be a positive integer")
+	ErrCouponMinBasketValue   = errors.New("minBasketValue cannot be negative")
+	ErrCouponDiscountTooBig   = errors.New("discount cannot be higher minBasketValue")
+	ErrCouponCodeAlreadyExist = errors.New("coupon code already used for another coupon")
+)
+
+// ErrApplyDiscountLessMin Custom error to apply function
+type ErrApplyDiscountLessMin struct {
+	MinValue int
+	Current  int
+}
+
+// Error return the message with the value
+func (e *ErrApplyDiscountLessMin) Error() string {
+	return fmt.Sprintf(
+		"cannot apply discount: value %d did not reach the minimum %d",
+		e.Current, e.MinValue,
+	)
+}

internal/service/service.go

@@ -7,65 +7,100 @@ import (
 	"github.com/google/uuid"
 )
 
+// Repository interface to memdb repository
 type Repository interface {
 	FindByCode(string) (*Coupon, error)
 	Save(*Coupon) error
 }
 
+// Service manage application features
 type Service struct {
 	repo Repository
 }
 
-func New(repo Repository) Service {
-	return Service{
+// New create a new Service
+func New(repo Repository) *Service {
+	return &Service{
 		repo: repo,
 	}
 }
 
-func (s Service) ApplyCoupon(basket Basket, code string) (b *Basket, e error) {
-	b = &basket
+// ApplyCoupon in the basket provided
+// It returns an error if code coupon not exist and basket value must be positive value
+func (s *Service) ApplyCoupon(basket *Basket, code string) error {
 	coupon, err := s.repo.FindByCode(code)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	if b.Value > 0 {
-		b.AppliedDiscount = coupon.Discount
-		b.ApplicationSuccessful = true
+	if basket.Value <= 0 {
+		return ErrApplyDiscount
 	}
-	if b.Value == 0 {
-		return
+
+	if basket.Value < coupon.MinBasketValue {
+		return &ErrApplyDiscountLessMin{
+			MinValue: coupon.MinBasketValue,
+			Current:  basket.Value,
+		}
 	}
 
-	return nil, fmt.Errorf("Tried to apply discount to negative value")
+	basket.AppliedDiscount = coupon.Discount
+	basket.ApplicationSuccessful = true
+
+	return nil
 }
 
-func (s Service) CreateCoupon(discount int, code string, minBasketValue int) (string, error) {
-	coupon := Coupon{
-		Discount:       discount,
+// CreateCoupon a new coupon
+// It returns an error if discount not be a positive number and minBasketValue cant not be negative
+// It returns an error if discount be higher that min basket
+func (s *Service) CreateCoupon(discount int, code string, minBasketValue int) (*Coupon, error) {
+	if discount <= 0 {
+		return nil, ErrCouponDiscountValue
+	}
+
+	if minBasketValue < 0 {
+		return nil, ErrCouponMinBasketValue
+	}
+
+	if discount > minBasketValue {
+		return nil, ErrCouponDiscountTooBig
+	}
+
+	if _, err := s.repo.FindByCode(code); err == nil {
+		return nil, ErrCouponCodeAlreadyExist
+	}
+
+	coupon := &Coupon{
+		ID:             uuid.NewString(),
 		Code:           code,
+		Discount:       discount,
 		MinBasketValue: minBasketValue,
-		ID:             uuid.NewString(),
 	}
 
-	if err := s.repo.Save(&coupon); err != nil {
-		return "", err
+	if err := s.repo.Save(coupon); err != nil {
+		return nil, fmt.Errorf("failed to save coupon: %w", err)
 	}
-	return coupon.ID, nil
+	return coupon, nil
 }
 
-func (s Service) GetCoupons(codes []string) ([]Coupon, error) {
-	coupons := make([]Coupon, 0, len(codes))
-	var e error
+// GetCoupons return a list of coupons based on the codes provided
+// It returns an error if case one of the code does not exist will
+func (s *Service) GetCoupons(codes []string) ([]*Coupon, error) {
+	coupons := make([]*Coupon, 0, len(codes))
+	var errs []error
 
-	for idx, code := range codes {
+	for _, code := range codes {
 		coupon, err := s.repo.FindByCode(code)
 		if err != nil {
-			e = fmt.Errorf("code: %s, index: %d", code, idx)
+			errs = append(errs, fmt.Errorf("coupon code: %s, err: %s", code, err.Error()))
 			continue
 		}
-		coupons = append(coupons, *coupon)
+		coupons = append(coupons, coupon)
+	}
+
+	if len(errs) > 0 {
+		return coupons, fmt.Errorf("one or more errors occurred: %v", errs)
 	}
 
-	return coupons, e
+	return coupons, nil
 }