Feat[BE]: refactor expense API and expense table match with new ERD

2026-05-24 15:25:43 +00:00 · 2025-11-27 13:53:35 +07:00
parent 99688c8e11
commit 886446b55f
10 changed files with 278 additions and 169 deletions
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"mime/multipart"
-	"time"

 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
@@ -189,21 +188,13 @@ func (s *expenseService) CreateOne(c *fiber.Ctx, req *validation.Create) (*expen
 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to generate reference number")
 		}

-		var grandTotal float64
-		for _, costPerKandang := range req.CostPerKandangs {
-			for _, costItem := range costPerKandang.CostItems {
-				grandTotal += costItem.TotalCost
-			}
-		}
-
 		createdBy := uint64(1) //todo get from auth
 		expense = &entity.Expense{
 			ReferenceNumber: referenceNumber,
 			PoNumber:        req.PoNumber,
 			Category:        req.Category,
 			SupplierId:      req.SupplierID,
-			ExpenseDate:     expenseDate,
-			GrandTotal:      grandTotal,
+			TransactionDate: expenseDate,
 			CreatedBy:       createdBy,
 		}

@@ -249,8 +240,8 @@ func (s *expenseService) CreateOne(c *fiber.Ctx, req *validation.Create) (*expen
 						KandangId:             kandangId,
 						NonstockId:            &nonstockId,
 						Qty:                   costItem.Quantity,
-						TotalPrice:            costItem.TotalCost,
-						Note:                  costItem.Notes,
+						Price:                 costItem.Price,
+						Notes:                 costItem.Notes,
 					}

 					if err := expenseNonstockRepoTx.CreateOne(c.Context(), expenseNonstock, nil); err != nil {
@@ -326,7 +317,24 @@ func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		if err != nil {
 			return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid transaction_date format")
 		}
-		updateBody["expense_date"] = expenseDate
+		updateBody["transaction_date"] = expenseDate
+	}
+
+	if req.Category != nil {
+		updateBody["category"] = *req.Category
+	}
+
+	if req.SupplierID != nil {
+		supplierID := uint(*req.SupplierID)
+		supplierExistsFunc := func(ctx context.Context, id uint) (bool, error) {
+			return commonRepo.Exists[entity.Supplier](ctx, s.SupplierRepo.DB(), id)
+		}
+		if err := commonSvc.EnsureRelations(c.Context(),
+			commonSvc.RelationCheck{Name: "Supplier", ID: &supplierID, Exists: supplierExistsFunc},
+		); err != nil {
+			return nil, err
+		}
+		updateBody["supplier_id"] = *req.SupplierID
 	}

 	if len(updateBody) == 0 && req.CostPerKandang == nil && len(req.Documents) == 0 {
@@ -344,6 +352,21 @@ func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(tx))
 		expenseNonstockRepoTx := repository.NewExpenseNonstockRepository(tx)

+		currentExpense, err := expenseRepoTx.GetByID(c.Context(), id, nil)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "Expense not found")
+			}
+			return fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense")
+		}
+
+		categoryChanged := false
+		var newCategory string
+		if req.Category != nil && *req.Category != currentExpense.Category {
+			categoryChanged = true
+			newCategory = *req.Category
+		}
+
 		if len(updateBody) > 0 {
 			if err := expenseRepoTx.PatchOne(c.Context(), id, updateBody, nil); err != nil {
 				if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -353,39 +376,77 @@ func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 			}
 		}

+		if categoryChanged {
+			if currentExpense.Category == "BOP" && newCategory == "NON-BOP" {
+
+				var existingExpenseNonstocks []entity.ExpenseNonstock
+				if err := tx.Where("expense_id = ?", id).Find(&existingExpenseNonstocks).Error; err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense nonstocks")
+				}
+
+				for _, ens := range existingExpenseNonstocks {
+					updateData := map[string]interface{}{
+						"project_flock_kandang_id": nil,
+					}
+					if err := expenseNonstockRepoTx.PatchOne(c.Context(), uint(ens.Id), updateData, nil); err != nil {
+						return fiber.NewError(fiber.StatusInternalServerError, "Failed to update project flock kandang id to null")
+					}
+				}
+			} else if currentExpense.Category == "NON-BOP" && newCategory == "BOP" {
+
+				var existingExpenseNonstocks []entity.ExpenseNonstock
+				if err := tx.Where("expense_id = ?", id).Find(&existingExpenseNonstocks).Error; err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense nonstocks")
+				}
+
+				projectFlockKandangRepoTx := projectFlockKandangRepo.NewProjectFlockKandangRepository(tx)
+				for _, ens := range existingExpenseNonstocks {
+					if ens.KandangId != nil {
+						projectFlockKandang, err := projectFlockKandangRepoTx.GetActiveByKandangID(c.Context(), uint(*ens.KandangId))
+						if err != nil {
+							if errors.Is(err, gorm.ErrRecordNotFound) {
+								return fiber.NewError(fiber.StatusNotFound, "No active project flock kandang found for this kandang")
+							}
+							return fiber.NewError(fiber.StatusInternalServerError, "Failed to find project flock kandang for this kandang")
+						}
+						projectFlockKandangId := uint64(projectFlockKandang.Id)
+
+						updateData := map[string]interface{}{
+							"project_flock_kandang_id": projectFlockKandangId,
+						}
+						if err := expenseNonstockRepoTx.PatchOne(c.Context(), uint(ens.Id), updateData, nil); err != nil {
+							return fiber.NewError(fiber.StatusInternalServerError, "Failed to update project flock kandang id")
+						}
+					}
+				}
+			}
+		}
+
 		if req.CostPerKandang != nil {

-			if err := tx.Where("expense_id = ?", id).Delete(&entity.ExpenseNonstock{}).Error; err != nil {
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to update expense items")
+			var existingExpenseNonstocks []entity.ExpenseNonstock
+			if err := tx.Where("expense_id = ?", id).Find(&existingExpenseNonstocks).Error; err != nil {
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense nonstocks for deletion")
 			}

-			var grandTotal float64
-			for _, cpk := range *req.CostPerKandang {
-				for _, costItem := range cpk.CostItems {
-					grandTotal += costItem.TotalCost
+			for _, ens := range existingExpenseNonstocks {
+				if err := expenseNonstockRepoTx.DeleteOne(c.Context(), uint(ens.Id)); err != nil {
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to delete expense nonstock")
 				}
 			}

-			if err := expenseRepoTx.PatchOne(c.Context(), id, map[string]interface{}{
-				"grand_total": grandTotal,
-			}, nil); err != nil {
-
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to update expense grand total")
+			updatedExpense, err := expenseRepoTx.GetByID(c.Context(), id, nil)
+			if err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return fiber.NewError(fiber.StatusNotFound, "Expense not found")
+				}
+				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get updated expense")
 			}

 			for _, cpk := range *req.CostPerKandang {
 				var projectFlockKandangId *uint64

-				expense, err := expenseRepoTx.GetByID(c.Context(), id, nil)
-				if err != nil {
-					if errors.Is(err, gorm.ErrRecordNotFound) {
-						return fiber.NewError(fiber.StatusNotFound, "Expense not found")
-					}
-					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get expense")
-				}
-
-				if expense.Category == "BOP" {
-
+				if updatedExpense.Category == "BOP" {
 					projectFlockKandangRepoTx := projectFlockKandangRepo.NewProjectFlockKandangRepository(tx)
 					projectFlockKandang, err := projectFlockKandangRepoTx.GetActiveByKandangID(c.Context(), uint(cpk.KandangID))
 					if err != nil {
@@ -408,11 +469,10 @@ func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 					}

 					var kandangId *uint64
-					if expense.Category == "NON-BOP" {
+					if updatedExpense.Category == "NON-BOP" {
 						id := uint64(cpk.KandangID)
 						kandangId = &id
-					} else if expense.Category == "BOP" {
-
+					} else if updatedExpense.Category == "BOP" {
 						if projectFlockKandangId != nil {
 							kandangId = &cpk.KandangID
 						}
@@ -425,8 +485,8 @@ func (s expenseService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 						KandangId:             kandangId,
 						NonstockId:            &costItem.NonstockID,
 						Qty:                   costItem.Quantity,
-						TotalPrice:            costItem.TotalCost,
-						Note:                  costItem.Notes,
+						Price:                 costItem.Price,
+						Notes:                 costItem.Notes,
 					}

 					if err := expenseNonstockRepoTx.CreateOne(c.Context(), expenseNonstock, nil); err != nil {
@@ -512,8 +572,6 @@ func (s *expenseService) CreateRealization(c *fiber.Ctx, expenseID uint, req *va
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid realization_date format")
 	}

-	createdBy := uint64(1) // TODO: replace with authenticated user id
-
 	if err := s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {

 		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(tx))
@@ -537,13 +595,14 @@ func (s *expenseService) CreateRealization(c *fiber.Ctx, expenseID uint, req *va
 			}

 			realization := &entity.ExpenseRealization{
-				ExpenseNonstockId:     &expenseNonstockID,
-				RealizationQty:        realizationItem.Qty,
-				RealizationUnitPrice:  realizationItem.UnitPrice,
-				RealizationTotalPrice: realizationItem.TotalPrice,
-				RealizationDate:       realizationDate,
-				Note:                  realizationItem.Notes,
-				CreatedBy:             &createdBy,
+				ExpenseNonstockId: &expenseNonstockID,
+				Qty:               realizationItem.Qty,
+				Price:             realizationItem.Price,
+				Notes:             "",
+			}
+
+			if realizationItem.Notes != nil {
+				realization.Notes = *realizationItem.Notes
 			}

 			if err := realizationRepoTx.CreateOne(c.Context(), realization, nil); err != nil {
@@ -570,7 +629,7 @@ func (s *expenseService) CreateRealization(c *fiber.Ctx, expenseID uint, req *va
 			expenseID,
 			utils.ExpenseStepRealisasi,
 			&approvalAction,
-			uint(createdBy),
+			uint(1), // TODO: replace with authenticated user id
 			nil); err != nil {

 			return fiber.NewError(fiber.StatusInternalServerError, "Failed to create realization approval")
@@ -665,15 +724,6 @@ func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *va
 			fmt.Sprintf("tidak bisa update realisasi pada step %s. Harus pada step Realisasi atau selesai", currentStepName))
 	}

-	var realizationDate *time.Time
-	if req.RealizationDate != "" {
-		parsedDate, err := utils.ParseDateString(req.RealizationDate)
-		if err != nil {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid realization_date format")
-		}
-		realizationDate = &parsedDate
-	}
-
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {

 		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(tx))
@@ -681,45 +731,43 @@ func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *va
 		expenseNonstockRepoTx := repository.NewExpenseNonstockRepository(tx)
 		expenseRepoTx := repository.NewExpenseRepository(tx)

-		for _, realizationItem := range req.Realizations {
+		// Check if only updating documents
+		updateDataOnly := len(req.Realizations) == 0 && len(req.Documents) > 0

-			expenseNonstockID := realizationItem.ExpenseNonstockID
+		if len(req.Realizations) > 0 {
+			for _, realizationItem := range req.Realizations {

-			if err := s.validateExpenseNonstockRelation(c, expenseNonstockRepoTx, expenseID, expenseNonstockID); err != nil {
-				return err
-			}
+				expenseNonstockID := realizationItem.ExpenseNonstockID

-			existingRealization, err := realizationRepoTx.GetByExpenseNonstockID(c.Context(), uint64(expenseNonstockID))
-			if err != nil {
-				if errors.Is(err, gorm.ErrRecordNotFound) {
-
-					return fiber.NewError(fiber.StatusNotFound, "Realization not found for this expense nonstock")
+				if err := s.validateExpenseNonstockRelation(c, expenseNonstockRepoTx, expenseID, expenseNonstockID); err != nil {
+					return err
 				}

-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to get existing realization")
+				existingRealization, err := realizationRepoTx.GetByExpenseNonstockID(c.Context(), uint64(expenseNonstockID))
+				if err != nil {
+					if errors.Is(err, gorm.ErrRecordNotFound) {
+
+						return fiber.NewError(fiber.StatusNotFound, "Realization not found for this expense nonstock")
+					}
+
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to get existing realization")
+				}
+
+				updateData := map[string]interface{}{
+					"qty":   realizationItem.Qty,
+					"price": realizationItem.Price,
+				}
+
+				if realizationItem.Notes != nil {
+					updateData["notes"] = *realizationItem.Notes
+				}
+
+				if err := realizationRepoTx.PatchOne(c.Context(), uint(existingRealization.Id), updateData, nil); err != nil {
+					s.Log.Errorf("Failed to update realization: %+v", err)
+					return fiber.NewError(fiber.StatusInternalServerError, "Failed to update realization")
+				}
 			}

-			updateData := map[string]interface{}{
-				"realization_qty":         realizationItem.Qty,
-				"realization_unit_price":  realizationItem.UnitPrice,
-				"realization_total_price": realizationItem.TotalPrice,
-				"realization_date":        *realizationDate,
-			}
-
-			if realizationItem.Notes != nil {
-				updateData["note"] = *realizationItem.Notes
-			}
-
-			if err := realizationRepoTx.PatchOne(c.Context(), uint(existingRealization.Id), updateData, nil); err != nil {
-				s.Log.Errorf("Failed to update realization: %+v", err)
-				return fiber.NewError(fiber.StatusInternalServerError, "Failed to update realization")
-			}
-		}
-
-		if err := expenseRepoTx.PatchOne(c.Context(), expenseID, map[string]interface{}{
-			"realization_date": *realizationDate,
-		}, nil); err != nil {
-			return fiber.NewError(fiber.StatusInternalServerError, "Failed to update realization date")
 		}

 		if len(req.Documents) > 0 {
@@ -728,7 +776,7 @@ func (s *expenseService) UpdateRealization(c *fiber.Ctx, expenseID uint, req *va
 			}
 		}

-		if *latestApproval.Action == entity.ApprovalActionUpdated {
+		if !updateDataOnly && *latestApproval.Action == entity.ApprovalActionUpdated {
 			actorID := uint(1) // TODO: replace with authenticated user id
 			approvalAction := entity.ApprovalActionUpdated
 			if _, err := approvalSvcTx.CreateApproval(