Feat[BE-222]: Completed SO and DO API

internal/modules/marketing/sales-orders/services/sales-orders.service.go

@@ -1,19 +1,19 @@
 package service
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"strings"
-	"time"
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	rInvMarketingDeliveryProduct "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/marketing-delivery-products/repositories"
 	productWarehouseRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/sales-orders/validations"
 	customerRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/customers/repositories"
-	kandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
 	userRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
@@ -25,8 +25,6 @@ import (
 )
 
 type SalesOrdersService interface {
-	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.Marketing, int64, error)
-	GetOne(ctx *fiber.Ctx, id uint) (*entity.Marketing, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.Marketing, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.Marketing, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
@@ -38,20 +36,18 @@ type salesOrdersService struct {
 	Validate             *validator.Validate
 	Repository           repository.SalesOrdersRepository
 	CustomerRepo         customerRepo.CustomerRepository
-	KandangRepo          kandangRepo.KandangRepository
 	ProductWarehouseRepo productWarehouseRepo.ProductWarehouseRepository
 	MarketingRepo        repository.MarketingRepository
 	UserRepo             userRepo.UserRepository
 	ApprovalSvc          commonSvc.ApprovalService
 }
 
-func NewSalesOrdersService(repo repository.SalesOrdersRepository, customerRepo customerRepo.CustomerRepository, kandangRepo kandangRepo.KandangRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, marketingRepo repository.MarketingRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, validate *validator.Validate) SalesOrdersService {
+func NewSalesOrdersService(repo repository.SalesOrdersRepository, customerRepo customerRepo.CustomerRepository, productWarehouseRepo productWarehouseRepo.ProductWarehouseRepository, marketingRepo repository.MarketingRepository, userRepo userRepo.UserRepository, approvalSvc commonSvc.ApprovalService, validate *validator.Validate) SalesOrdersService {
 	return &salesOrdersService{
 		Log:                  utils.Log,
 		Validate:             validate,
 		Repository:           repo,
 		CustomerRepo:         customerRepo,
-		KandangRepo:          kandangRepo,
 		ProductWarehouseRepo: productWarehouseRepo,
 		MarketingRepo:        marketingRepo,
 		UserRepo:             userRepo,
@@ -60,58 +56,15 @@ func NewSalesOrdersService(repo repository.SalesOrdersRepository, customerRepo c
 }
 
 func (s salesOrdersService) withRelations(db *gorm.DB) *gorm.DB {
-	return db.Preload("CreatedUser").
+	return db.
+		Preload("CreatedUser").
 		Preload("Customer").
 		Preload("SalesPerson").
 		Preload("Products.ProductWarehouse.Product").
 		Preload("Products.ProductWarehouse.Warehouse")
 }
 
-func (s salesOrdersService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.Marketing, int64, error) {
-	if err := s.Validate.Struct(params); err != nil {
-		return nil, 0, err
-	}
-
-	offset := (params.Page - 1) * params.Limit
-
-	marketings, total, err := s.MarketingRepo.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
-		db = s.withRelations(db)
-		if params.Search != "" {
-			return db.Where("so_number LIKE ?", "%"+params.Search+"%")
-		}
-		return db.Order("created_at DESC").Order("updated_at DESC")
-	})
-
-	if err != nil {
-		s.Log.Errorf("Failed to get marketings: %+v", err)
-		return nil, 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch sales orders")
-	}
-
-	if s.ApprovalSvc != nil && len(marketings) > 0 {
-		ids := make([]uint, len(marketings))
-		for i, item := range marketings {
-			ids[i] = item.Id
-		}
-
-		latestMap, err := s.ApprovalSvc.LatestByTargets(c.Context(), utils.ApprovalWorkflowMarketing, ids, func(db *gorm.DB) *gorm.DB {
-			return db.Preload("ActionUser")
-		})
-		if err != nil {
-			s.Log.Warnf("Unable to load latest approvals for marketings: %+v", err)
-		} else if len(latestMap) > 0 {
-			for i := range marketings {
-				if approval, ok := latestMap[marketings[i].Id]; ok {
-					marketings[i].LatestApproval = approval
-				}
-			}
-		}
-	}
-
-	return marketings, total, nil
-}
-
-func (s salesOrdersService) GetOne(c *fiber.Ctx, id uint) (*entity.Marketing, error) {
-
+func (s salesOrdersService) getOne(c *fiber.Ctx, id uint) (*entity.Marketing, error) {
 	marketing, err := s.MarketingRepo.GetByID(c.Context(), id, s.withRelations)
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, fiber.NewError(fiber.StatusNotFound, "SalesOrders not found")
@@ -125,15 +78,9 @@ func (s salesOrdersService) GetOne(c *fiber.Ctx, id uint) (*entity.Marketing, er
 		approvals, err := s.ApprovalSvc.ListByTarget(c.Context(), utils.ApprovalWorkflowMarketing, id, func(db *gorm.DB) *gorm.DB {
 			return db.Preload("ActionUser")
 		})
-		if err != nil {
-			s.Log.Warnf("Unable to load approvals for marketing %d: %+v", id, err)
-		} else if len(approvals) > 0 {
-			if marketing.LatestApproval == nil {
-				latest := approvals[len(approvals)-1]
-				marketing.LatestApproval = &latest
-			}
-		} else {
-			marketing.LatestApproval = nil
+		if err == nil && len(approvals) > 0 {
+			latest := approvals[len(approvals)-1]
+			marketing.LatestApproval = &latest
 		}
 	}
 
@@ -153,7 +100,6 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
 
 	for _, item := range req.MarketingProducts {
 		if err := commonSvc.EnsureRelations(c.Context(),
-			commonSvc.RelationCheck{Name: "Kandang", ID: &item.KandangId, Exists: s.KandangRepo.IdExists},
 			commonSvc.RelationCheck{Name: "ProductWarehouse", ID: &item.ProductWarehouseId, Exists: s.ProductWarehouseRepo.IdExists},
 		); err != nil {
 			return nil, err
@@ -165,14 +111,18 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid date format")
 	}
 
-	soNumber := "SO-" + time.Now().Format("20060102150405")
+	nextSeq, err := s.MarketingRepo.GetNextSequence(c.Context())
+	if err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to generate SO number")
+	}
+	soNumber := fmt.Sprintf("SO-%05d", nextSeq)
 
 	var marketing *entity.Marketing
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 
 		marketingRepoTx := repository.NewMarketingRepository(dbTransaction)
 		marketingProductRepoTx := repository.NewMarketingProductRepository(dbTransaction)
-		marketingDeliveryProductRepoTx := repository.NewMarketingDeliveryProductRepository(dbTransaction)
+		invDeliveryRepoTx := rInvMarketingDeliveryProduct.NewMarketingDeliveryProductRepository(dbTransaction)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
 
 		marketing = &entity.Marketing{
@@ -184,52 +134,18 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
 			CreatedBy:     1,
 		}
 		if err := marketingRepoTx.CreateOne(c.Context(), marketing, nil); err != nil {
-			s.Log.Errorf("Failed to create marketing: %+v", err)
-			return err
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create salesOrders")
 		}
 
 		if len(req.MarketingProducts) > 0 {
 			for _, product := range req.MarketingProducts {
-				marketingProduct := &entity.MarketingProduct{
-					MarketingId:        marketing.Id,
-					ProductWarehouseId: product.ProductWarehouseId,
-					Qty:                product.Qty,
-					UnitPrice:          product.UnitPrice,
-					AvgWeight:          product.AvgWeight,
-					TotalWeight:        product.TotalWeight,
-					TotalPrice:         product.TotalPrice,
-				}
-				if err := marketingProductRepoTx.CreateOne(c.Context(), marketingProduct, nil); err != nil {
-					s.Log.Errorf("Failed to create marketing product: %+v", err)
-					return err
-				}
-
-				marketingDeliveryProduct := &entity.MarketingDeliveryProduct{
-					MarketingProductId: marketingProduct.Id,
-					Qty:                0,
-					UnitPrice:          0,
-					TotalWeight:        0,
-					AvgWeight:          0,
-					TotalPrice:         0,
-					DeliveryDate:       nil,
-					VehicleNumber:      product.VehicleNumber,
-				}
-				if err := marketingDeliveryProductRepoTx.CreateOne(c.Context(), marketingDeliveryProduct, nil); err != nil {
-					s.Log.Errorf("Failed to create marketing delivery product: %+v", err)
-					return err
+				if err := s.createMarketingProductWithDelivery(c.Context(), marketing.Id, product, marketingProductRepoTx, invDeliveryRepoTx); err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to create marketing product")
 				}
 			}
 		}
 
 		actorID := uint(1) // TODO: ambil dari auth context
-		if err := approvalSvcTx.RegisterWorkflowSteps(
-			utils.ApprovalWorkflowMarketing,
-			utils.MarketingApprovalSteps,
-		); err != nil {
-			s.Log.Errorf("Failed to register workflow steps: %+v", err)
-			return err
-		}
-
 		approvalAction := entity.ApprovalActionCreated
 		if _, err := approvalSvcTx.CreateApproval(
 			c.Context(),
@@ -240,8 +156,7 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
 			actorID,
 			nil); err != nil {
 			if !errors.Is(err, gorm.ErrDuplicatedKey) {
-				s.Log.Errorf("Failed to create approval: %+v", err)
-				return err
+				fiber.NewError(fiber.StatusInternalServerError, "Failed to create approval")
 			}
 		}
 
@@ -256,7 +171,6 @@ func (s *salesOrdersService) CreateOne(c *fiber.Ctx, req *validation.Create) (*e
 
 	marketing, err = s.MarketingRepo.GetByID(c.Context(), marketing.Id, s.withRelations)
 	if err != nil {
-		s.Log.Errorf("Failed to fetch created marketing: %+v", err)
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch created sales order")
 	}
 
@@ -278,7 +192,6 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 
 	latestApproval, err := s.ApprovalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowMarketing, id, nil)
 	if err != nil {
-		s.Log.Errorf("Failed to check approval status: %+v", err)
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
 	}
 	if latestApproval != nil && latestApproval.StepNumber >= 3 {
@@ -299,8 +212,8 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 
 		marketingRepoTx := repository.NewMarketingRepository(dbTransaction)
 		marketingProductRepoTx := repository.NewMarketingProductRepository(dbTransaction)
-		marketingDeliveryProductRepoTx := repository.NewMarketingDeliveryProductRepository(dbTransaction)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
+		invDeliveryRepoTx := rInvMarketingDeliveryProduct.NewMarketingDeliveryProductRepository(dbTransaction)
 
 		updateBody := make(map[string]any)
 		if req.CustomerId != 0 {
@@ -330,53 +243,85 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 
 			oldProducts, err := marketingProductRepoTx.GetByMarketingID(c.Context(), id)
 			if err != nil && err != gorm.ErrRecordNotFound {
-				s.Log.Errorf("Failed to fetch old marketing products: %+v", err)
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to update products")
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch existing products")
 			}
 
-			for _, oldProduct := range oldProducts {
-				if err := marketingDeliveryProductRepoTx.DeleteMany(c.Context(), func(db *gorm.DB) *gorm.DB {
-					return db.Where("marketing_product_id = ?", oldProduct.Id)
-				}); err != nil && err != gorm.ErrRecordNotFound {
-					s.Log.Errorf("Failed to delete delivery products: %+v", err)
-					return fiber.NewError(fiber.StatusInternalServerError, "Failed to update products")
+			oldByPW := make(map[uint]*entity.MarketingProduct)
+			for i := range oldProducts {
+				p := oldProducts[i]
+				oldByPW[p.ProductWarehouseId] = &p
+			}
+
+			reqByPW := make(map[uint]validation.CreateMarketingProduct)
+			for _, rp := range req.MarketingProducts {
+				reqByPW[rp.ProductWarehouseId] = rp
+			}
+
+			for _, rp := range req.MarketingProducts {
+				if old, ok := oldByPW[rp.ProductWarehouseId]; ok {
+
+					updateBody := map[string]any{
+						"product_warehouse_id": rp.ProductWarehouseId,
+						"qty":                  rp.Qty,
+						"unit_price":           rp.UnitPrice,
+						"avg_weight":           rp.AvgWeight,
+						"total_weight":         rp.TotalWeight,
+						"total_price":          rp.TotalPrice,
+					}
+					if err := marketingProductRepoTx.PatchOne(c.Context(), old.Id, updateBody, nil); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, "Failed to update marketing product")
+					}
+
+					// Ensure delivery product exists; if not, create default
+					if _, err := invDeliveryRepoTx.GetByMarketingProductID(c.Context(), old.Id); err != nil {
+						if errors.Is(err, gorm.ErrRecordNotFound) {
+							mdp := &entity.MarketingDeliveryProduct{
+								MarketingProductId: old.Id,
+								Qty:                0,
+								UnitPrice:          0,
+								TotalWeight:        0,
+								AvgWeight:          0,
+								TotalPrice:         0,
+								DeliveryDate:       nil,
+								VehicleNumber:      rp.VehicleNumber,
+							}
+							if err := invDeliveryRepoTx.CreateOne(c.Context(), mdp, nil); err != nil {
+								return fiber.NewError(fiber.StatusInternalServerError, "Failed to create marketing delivery product")
+							}
+						} else {
+							return fiber.NewError(fiber.StatusInternalServerError, "Failed to check delivery product")
+						}
+					}
+				} else {
+					// Create new marketing product (use helper)
+					if err := s.createMarketingProductWithDelivery(c.Context(), id, rp, marketingProductRepoTx, invDeliveryRepoTx); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, "Failed to create marketing product")
+					}
 				}
 			}
 
-			if err := marketingProductRepoTx.DeleteMany(c.Context(), func(db *gorm.DB) *gorm.DB {
-				return db.Where("marketing_id = ?", id)
-			}); err != nil && err != gorm.ErrRecordNotFound {
-				s.Log.Errorf("Failed to delete marketing products: %+v", err)
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to update products")
-			}
-
-			for _, product := range req.MarketingProducts {
-				marketingProduct := &entity.MarketingProduct{
-					MarketingId:        id,
-					ProductWarehouseId: product.ProductWarehouseId,
-					Qty:                product.Qty,
-					UnitPrice:          product.UnitPrice,
-					AvgWeight:          product.AvgWeight,
-					TotalWeight:        product.TotalWeight,
-					TotalPrice:         product.TotalPrice,
-				}
-				if err := marketingProductRepoTx.CreateOne(c.Context(), marketingProduct, nil); err != nil {
-
-					return err
-				}
-
-				marketingDeliveryProduct := &entity.MarketingDeliveryProduct{
-					MarketingProductId: marketingProduct.Id,
-					Qty:                0,
-					UnitPrice:          0,
-					TotalWeight:        0,
-					AvgWeight:          0,
-					TotalPrice:         0,
-					DeliveryDate:       nil,
-					VehicleNumber:      product.VehicleNumber,
-				}
-				if err := marketingDeliveryProductRepoTx.CreateOne(c.Context(), marketingDeliveryProduct, nil); err != nil {
-					return err
+			// 2) Delete missing old products (prevent deletion if deliveries exist)
+			for _, old := range oldProducts {
+				if _, ok := reqByPW[old.ProductWarehouseId]; !ok {
+					// Check delivery product for this marketing product
+					deliveryProduct, err := invDeliveryRepoTx.GetByMarketingProductID(c.Context(), old.Id)
+					if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+						return fiber.NewError(fiber.StatusInternalServerError, "Failed to check existing delivery product")
+					}
+					if err == nil {
+						// If delivery exists (delivery_date not nil or qty > 0), prevent deletion
+						if deliveryProduct.DeliveryDate != nil || deliveryProduct.Qty > 0 {
+							return fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Cannot delete marketing product %d because it has delivery records", old.Id))
+						}
+						// safe to delete delivery product record
+						if err := invDeliveryRepoTx.DeleteOne(c.Context(), deliveryProduct.Id); err != nil {
+							return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete marketing delivery product")
+						}
+					}
+					// Delete marketing product
+					if err := marketingProductRepoTx.DeleteOne(c.Context(), old.Id); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete marketing product")
+					}
 				}
 			}
 		}
@@ -394,7 +339,6 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 				actorID,
 				&resetNote)
 			if err != nil {
-				s.Log.Errorf("Failed to create reset approval: %+v", err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Failed to reset approval status")
 			}
 		}
@@ -409,16 +353,16 @@ func (s salesOrdersService) UpdateOne(c *fiber.Ctx, req *validation.Update, id u
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update sales order")
 	}
 
-	return s.GetOne(c, id)
+	return s.getOne(c, id)
 }
 
 func (s salesOrdersService) DeleteOne(c *fiber.Ctx, id uint) error {
 	marketing, err := s.MarketingRepo.GetByID(c.Context(), id, s.withRelations)
+
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return fiber.NewError(fiber.StatusNotFound, "SalesOrders not found")
 	}
 	if err != nil {
-		s.Log.Errorf("Failed to fetch marketing %d before delete: %+v", id, err)
 		return fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch sales order")
 	}
 
@@ -494,7 +438,6 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 		if err != nil {
 			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to check approval status")
 		}
-
 		if latestApproval == nil {
 			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("No approval found for Marketing %d - sales orders must be created first", id))
 		}
@@ -511,13 +454,12 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 	}
 
 	err := s.MarketingRepo.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+
 		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
 
 		for _, approvableID := range approvableIDs {
-
 			latestApproval, err := approvalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowMarketing, approvableID, nil)
 			if err != nil {
-				s.Log.Errorf("Failed to get latest approval for %d: %+v", approvableID, err)
 				return fiber.NewError(fiber.StatusInternalServerError, "Failed to check current approval step")
 			}
 
@@ -568,7 +510,7 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 
 	updated := make([]entity.Marketing, 0, len(approvableIDs))
 	for _, id := range approvableIDs {
-		marketing, err := s.GetOne(c, id)
+		marketing, err := s.getOne(c, id)
 		if err != nil {
 			return nil, err
 		}
@@ -577,3 +519,35 @@ func (s salesOrdersService) Approval(c *fiber.Ctx, req *validation.Approve) ([]e
 
 	return updated, nil
 }
+
+func (s *salesOrdersService) createMarketingProductWithDelivery(ctx context.Context, marketingId uint, rp validation.CreateMarketingProduct, marketingProductRepo repository.MarketingProductRepository, invDeliveryRepo rInvMarketingDeliveryProduct.MarketingDeliveryProductRepository) error {
+
+	marketingProduct := &entity.MarketingProduct{
+		MarketingId:        marketingId,
+		ProductWarehouseId: rp.ProductWarehouseId,
+		Qty:                rp.Qty,
+		UnitPrice:          rp.UnitPrice,
+		AvgWeight:          rp.AvgWeight,
+		TotalWeight:        rp.TotalWeight,
+		TotalPrice:         rp.TotalPrice,
+	}
+	if err := marketingProductRepo.CreateOne(ctx, marketingProduct, nil); err != nil {
+		return err
+	}
+
+	marketingDeliveryProduct := &entity.MarketingDeliveryProduct{
+		MarketingProductId: marketingProduct.Id,
+		Qty:                0,
+		UnitPrice:          0,
+		TotalWeight:        0,
+		AvgWeight:          0,
+		TotalPrice:         0,
+		DeliveryDate:       nil,
+		VehicleNumber:      rp.VehicleNumber,
+	}
+	if err := invDeliveryRepo.CreateOne(ctx, marketingDeliveryProduct, nil); err != nil {
+		return err
+	}
+
+	return nil
+}