Merge branch 'development' of https://gitlab.com/mbugroup/lti-api into feat/BE/sso-adjustment

internal/modules/closings/services/closing.service.go

@@ -185,7 +185,12 @@ func (s closingService) GetPenjualan(c *fiber.Ctx, projectFlockID uint, projectF
 		return nil, err
 	}
 
-	realisasi, err := s.MarketingDeliveryProductRepo.GetClosingPenjualan(c.Context(), projectFlockID, projectFlockKandangID)
+	projectFlock, err := s.ProjectFlockRepo.GetByID(c.Context(), projectFlockID, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	realisasi, err := s.MarketingDeliveryProductRepo.GetClosingPenjualan(c.Context(), projectFlockID, projectFlockKandangID, projectFlock.Category)
 	if err != nil {
 		return nil, err
 	}

internal/modules/closings/services/closingKeuangan.service.go

@@ -2,20 +2,19 @@ package service
 
 import (
 	"errors"
-	"strings"
 
+	"github.com/gofiber/fiber/v2"
+	"github.com/sirupsen/logrus"
+	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"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/closings/dto"
-	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/closings/repositories"
 	expenseRealizationRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/expenses/repositories"
 	marketingDeliveryProductRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/marketing/repositories"
 	chickinRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/chickins/repositories"
 	projectflockRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	recordingRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
-	"github.com/gofiber/fiber/v2"
-	"github.com/sirupsen/logrus"
 	"gorm.io/gorm"
 )
 
@@ -25,9 +24,28 @@ type ClosingKeuanganService interface {
 	GetClosingKeuanganByKandang(ctx *fiber.Ctx, projectFlockID uint, projectFlockKandangID uint) (*dto.ClosingKeuanganData, error)
 }
 
+// CostData holds all cost-related information
+type CostData struct {
+	FeedCost               float64
+	OvkCost                float64
+	ChickenCost            float64
+	ExpeditionCost         float64
+	BudgetOperational      float64
+	RealizationOperational float64
+}
+
+// ProductionData holds all production and sales related information
+type ProductionData struct {
+	TotalPopulationIn   float64
+	TotalDepletion      float64
+	TotalWeightProduced float64
+	TotalEggWeightKg    float64
+	TotalWeightSold     float64
+	TotalSalesAmount    float64
+}
+
 type closingKeuanganService struct {
 	Log                          *logrus.Logger
-	ClosingKeuanganRepo          repository.ClosingKeuanganRepository
 	ProjectFlockRepo             projectflockRepository.ProjectflockRepository
 	ProjectFlockKandangRepo      projectflockRepository.ProjectFlockKandangRepository
 	MarketingDeliveryProductRepo marketingDeliveryProductRepository.MarketingDeliveryProductRepository
@@ -35,10 +53,11 @@ type closingKeuanganService struct {
 	ProjectBudgetRepo            projectflockRepository.ProjectBudgetRepository
 	ChickinRepo                  chickinRepository.ProjectChickinRepository
 	RecordingRepo                recordingRepository.RecordingRepository
+	HppSvc                       commonSvc.HppService
+	HppRepo                      commonRepo.HppCostRepository
 }
 
 func NewClosingKeuanganService(
-	closingKeuanganRepo repository.ClosingKeuanganRepository,
 	projectFlockRepo projectflockRepository.ProjectflockRepository,
 	projectFlockKandangRepo projectflockRepository.ProjectFlockKandangRepository,
 	marketingDeliveryProductRepo marketingDeliveryProductRepository.MarketingDeliveryProductRepository,
@@ -46,10 +65,11 @@ func NewClosingKeuanganService(
 	projectBudgetRepo projectflockRepository.ProjectBudgetRepository,
 	chickinRepo chickinRepository.ProjectChickinRepository,
 	recordingRepo recordingRepository.RecordingRepository,
+	hppSvc commonSvc.HppService,
+	hppRepo commonRepo.HppCostRepository,
 ) ClosingKeuanganService {
 	return &closingKeuanganService{
 		Log:                          utils.Log,
-		ClosingKeuanganRepo:          closingKeuanganRepo,
 		ProjectFlockRepo:             projectFlockRepo,
 		ProjectFlockKandangRepo:      projectFlockKandangRepo,
 		MarketingDeliveryProductRepo: marketingDeliveryProductRepo,
@@ -57,6 +77,8 @@ func NewClosingKeuanganService(
 		ProjectBudgetRepo:            projectBudgetRepo,
 		ChickinRepo:                  chickinRepo,
 		RecordingRepo:                recordingRepo,
+		HppSvc:                       hppSvc,
+		HppRepo:                      hppRepo,
 	}
 }
 
@@ -73,30 +95,12 @@ func (s closingKeuanganService) GetClosingKeuangan(c *fiber.Ctx, projectFlockID
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock")
 	}
 
-	budgets, err := s.ProjectBudgetRepo.GetByProjectFlockID(c.Context(), projectFlockID)
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch budgets")
-	}
-
-	// Preload Nonstock.Flags manually
-	var budgetIDs []uint
-	for _, b := range budgets {
-		budgetIDs = append(budgetIDs, b.Id)
-	}
-	if len(budgetIDs) > 0 {
-		err = s.ProjectBudgetRepo.DB().WithContext(c.Context()).
-			Preload("Nonstock.Flags").
-			Where("id IN ?", budgetIDs).
-			Find(&budgets).Error
-	}
-
-	// Get all kandang for this project flock
-	kandangs, err := s.ProjectFlockKandangRepo.GetByProjectFlockID(c.Context(), projectFlockID)
+	projectFlockKandangs, err := s.ProjectFlockKandangRepo.GetByProjectFlockID(c.Context(), projectFlockID)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch kandangs")
 	}
 
-	return s.calculateClosingKeuangan(c, projectFlock, budgets, kandangs, projectFlockID)
+	return s.calculateClosingKeuangan(c, projectFlock, projectFlockKandangs)
 }
 
 func (s closingKeuanganService) GetClosingKeuanganByKandang(c *fiber.Ctx, projectFlockID uint, projectFlockKandangID uint) (*dto.ClosingKeuanganData, error) {
@@ -107,12 +111,11 @@ func (s closingKeuanganService) GetClosingKeuanganByKandang(c *fiber.Ctx, projec
 		return nil, err
 	}
 
-	// Validate and fetch project flock kandang
-	kandang, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), projectFlockKandangID)
+	projectFlockKandang, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), projectFlockKandangID)
 	if err != nil {
 		return nil, fiber.NewError(fiber.StatusNotFound, "Project flock kandang not found")
 	}
-	if kandang.ProjectFlockId != projectFlockID {
+	if projectFlockKandang.ProjectFlockId != projectFlockID {
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang does not belong to this project flock")
 	}
 
@@ -121,417 +124,249 @@ func (s closingKeuanganService) GetClosingKeuanganByKandang(c *fiber.Ctx, projec
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock")
 	}
 
-	budgets, err := s.ProjectBudgetRepo.GetByProjectFlockID(c.Context(), projectFlockID)
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch budgets")
-	}
+	projectFlockKandangs := []entity.ProjectFlockKandang{*projectFlockKandang}
 
-	// Preload Nonstock.Flags manually
-	var budgetIDs []uint
-	for _, b := range budgets {
-		budgetIDs = append(budgetIDs, b.Id)
-	}
-	if len(budgetIDs) > 0 {
-		err = s.ProjectBudgetRepo.DB().WithContext(c.Context()).
-			Preload("Nonstock.Flags").
-			Where("id IN ?", budgetIDs).
-			Find(&budgets).Error
-	}
-
-	kandangs := []entity.ProjectFlockKandang{*kandang}
-
-	return s.calculateClosingKeuangan(c, projectFlock, budgets, kandangs, projectFlockID)
+	return s.calculateClosingKeuangan(c, projectFlock, projectFlockKandangs)
 }
 
-func (s closingKeuanganService) calculateClosingKeuangan(c *fiber.Ctx, projectFlock *entity.ProjectFlock, budgets []entity.ProjectBudget, kandangs []entity.ProjectFlockKandang, scopeID uint) (*dto.ClosingKeuanganData, error) {
-	// Define flag filters using constants
-	pakanFilters := []string{string(utils.FlagPakan), string(utils.FlagPreStarter), string(utils.FlagStarter), string(utils.FlagFinisher)}
-	ovkFilters := []string{string(utils.FlagOVK), string(utils.FlagObat), string(utils.FlagVitamin), string(utils.FlagKimia)}
-	ayamFilters := []string{string(utils.FlagDOC), string(utils.FlagPullet), string(utils.FlagLayer)}
-	allFilters := append(pakanFilters, ovkFilters...)
-	allFilters = append(allFilters, ayamFilters...)
+func (s closingKeuanganService) calculateClosingKeuangan(c *fiber.Ctx, projectFlock *entity.ProjectFlock, projectFlockKandangs []entity.ProjectFlockKandang) (*dto.ClosingKeuanganData, error) {
 
-	var allProductUsageRows []repository.ProductUsageRow
-
-	// Get ALL product usage
-	for _, kandang := range kandangs {
-		rows, err := s.ClosingKeuanganRepo.GetAllProductUsageByProjectFlockKandangID(c.Context(), kandang.Id, allFilters)
-		if err == nil {
-			allProductUsageRows = append(allProductUsageRows, rows...)
-		}
+	var projectFlockKandangIDs []uint
+	for _, projectFlockKandang := range projectFlockKandangs {
+		projectFlockKandangIDs = append(projectFlockKandangIDs, projectFlockKandang.Id)
 	}
 
-	// Classify into categories based on flag priority
-	var pakanProductUsageRows []repository.ProductUsageRow
-	var ovkProductUsageRows []repository.ProductUsageRow
-	var ayamProductUsageRows []repository.ProductUsageRow
-
-	for _, row := range allProductUsageRows {
-		// Parse flag names from comma-separated string
-		flagNames := strings.Split(row.FlagNames, ",")
-
-		hasPakanFlag := false
-		hasOvkFlag := false
-		hasAyamFlag := false
-
-		for _, flag := range flagNames {
-			flag = strings.TrimSpace(flag)
-			if containsItem(pakanFilters, flag) {
-				hasPakanFlag = true
-			}
-			if containsItem(ovkFilters, flag) {
-				hasOvkFlag = true
-			}
-			if containsItem(ayamFilters, flag) {
-				hasAyamFlag = true
-			}
-		}
-
-		// Priority: PAKAN > OVK > AYAM
-		if hasPakanFlag {
-			pakanProductUsageRows = append(pakanProductUsageRows, row)
-		} else if hasOvkFlag {
-			ovkProductUsageRows = append(ovkProductUsageRows, row)
-		} else if hasAyamFlag {
-			ayamProductUsageRows = append(ayamProductUsageRows, row)
-		} else {
-			continue
-		}
-	}
-
-
-	// Calculate total price for each category
-	var totalPakanPrice, totalOvkPrice, totalAyamPrice float64
-	for _, row := range pakanProductUsageRows {
-		totalPakanPrice += row.TotalPengeluaran
-	}
-	for _, row := range ovkProductUsageRows {
-		totalOvkPrice += row.TotalPengeluaran
-	}
-	for _, row := range ayamProductUsageRows {
-		totalAyamPrice += row.TotalPengeluaran
-	}
-
-	// Determine if this is per-kandang or per-project-flock scope
-	isPerKandang := len(kandangs) == 1
+	isPerKandang := len(projectFlockKandangs) == 1
 	var projectFlockKandangID *uint
 	if isPerKandang {
-		kandangID := kandangs[0].Id
+		kandangID := projectFlockKandangs[0].Id
 		projectFlockKandangID = &kandangID
 	}
 
+	costs, err := s.calculateCosts(c, projectFlock, projectFlockKandangs, projectFlockKandangIDs, projectFlockKandangID)
+	if err != nil {
+		return nil, err
+	}
+
+	productionData, err := s.calculateProductionData(c, projectFlock, projectFlockKandangIDs, projectFlockKandangID)
+	if err != nil {
+		return nil, err
+	}
+
+	hppSection := s.buildHPPSection(c, projectFlock, projectFlockKandangs, costs, productionData)
+
+	profitLossSection := s.buildProfitLossSection(projectFlock, costs, productionData)
+
+	data := dto.ToClosingKeuanganData(hppSection, profitLossSection)
+	return &data, nil
+}
+
+func (s closingKeuanganService) calculateCosts(c *fiber.Ctx, projectFlock *entity.ProjectFlock, projectFlockKandangs []entity.ProjectFlockKandang, projectFlockKandangIDs []uint, projectFlockKandangID *uint) (*CostData, error) {
+	costs := &CostData{}
 	var err error
 
-	// Fetch realizations
-	var realizations []entity.ExpenseRealization
-	if isPerKandang && projectFlockKandangID != nil {
-		realizations, err = s.ExpenseRealizationRepo.GetClosingOverhead(c.Context(), projectFlock.Id, projectFlockKandangID)
-	} else {
-		realizations, err = s.ExpenseRealizationRepo.GetClosingOverhead(c.Context(), projectFlock.Id, nil)
-	}
+	costs.FeedCost, err = s.HppRepo.GetFeedUsageCost(c.Context(), projectFlockKandangIDs, nil)
 	if err != nil {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch realizations")
+		costs.FeedCost = 0
 	}
 
-	deliveryProducts, err := s.MarketingDeliveryProductRepo.GetDeliveryProductsByProjectFlockID(c.Context(), projectFlock.Id, func(db *gorm.DB) *gorm.DB {
-		db = db.Preload("MarketingProduct").
-			Preload("MarketingProduct.ProductWarehouse").
-			Preload("MarketingProduct.ProductWarehouse.Product")
-		return db
-	})
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch delivery products")
-	}
-
-	// Filter by kandang if scope is per-kandang (manual filtering after fetch)
-	if isPerKandang && projectFlockKandangID != nil {
-		filteredProducts := make([]entity.MarketingDeliveryProduct, 0)
-		for _, dp := range deliveryProducts {
-			pfKandangID := dp.MarketingProduct.ProductWarehouse.ProjectFlockKandangId
-			if pfKandangID != nil && *pfKandangID == *projectFlockKandangID {
-				filteredProducts = append(filteredProducts, dp)
-			}
-		}
-		deliveryProducts = filteredProducts
-	}
-
-	// Fetch chickins
-	var chickins []entity.ProjectChickin
-	if isPerKandang && projectFlockKandangID != nil {
-		chickins, err = s.ChickinRepo.GetByProjectFlockKandangID(c.Context(), *projectFlockKandangID)
-	} else {
-		chickins, err = s.ChickinRepo.GetByProjectFlockID(c.Context(), projectFlock.Id)
-	}
+	costs.OvkCost, err = s.HppRepo.GetOvkUsageCost(c.Context(), projectFlockKandangIDs, nil)
 	if err != nil {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch chickins")
+		costs.OvkCost = 0
 	}
 
-	// Get total depletion
-	var totalDepletion float64
-	if isPerKandang && projectFlockKandangID != nil {
-		totalDepletion, err = s.ClosingKeuanganRepo.GetTotalDepletionByProjectFlockKandangID(c.Context(), *projectFlockKandangID)
-	} else {
-		totalDepletion, err = s.RecordingRepo.GetTotalDepletionByProjectFlockID(c.Context(), projectFlock.Id)
-	}
-	if err != nil {
-		totalDepletion = 0
-	}
-
-	totalWeightProduced, _, err := s.RecordingRepo.GetProductionWeightAndQtyByProjectFlockID(c.Context(), projectFlock.Id)
-	if err != nil {
-	}
-
-	// Try to get actual weight from uniformity data
-	var totalWeightFromUniformity float64
-	if isPerKandang && projectFlockKandangID != nil {
-		totalWeightFromUniformity, err = s.ClosingKeuanganRepo.GetTotalWeightProducedFromUniformityByProjectFlockKandangID(c.Context(), *projectFlockKandangID)
-	} else {
-		totalWeightFromUniformity, err = s.RecordingRepo.GetTotalWeightProducedFromUniformityByProjectFlockID(c.Context(), projectFlock.Id)
-	}
-	if err != nil {
-	} else if totalWeightFromUniformity > 0 {
-		totalWeightProduced = totalWeightFromUniformity
-	}
-
-	// Fetch egg data only for Laying category
-	var totalEggWeightKg float64
 	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
-		// TODO: Replace with actual method to get egg weight from RecordingRepo
-		// totalEggWeightKg, err = s.RecordingRepo.GetEggWeightByProjectFlockID(c.Context(), projectFlock.Id)
-		// For now, set to 0 as placeholder
-		totalEggWeightKg = 0
+		for _, projectFlockKandang := range projectFlockKandangs {
+			depresiasiCost, err := s.HppSvc.GetDepresiasiTransfer(projectFlockKandang.Id, nil)
+			if err == nil {
+				costs.ChickenCost += depresiasiCost
+			}
+			pulletCost, err := s.HppRepo.GetPulletCost(c.Context(), projectFlockKandang.Id)
+			if err == nil {
+				costs.ChickenCost += pulletCost
+			}
+		}
 	} else {
-		totalEggWeightKg = 0
+		for _, projectFlockKandang := range projectFlockKandangs {
+			pulletCost, err := s.HppRepo.GetPulletCost(c.Context(), projectFlockKandang.Id)
+			if err == nil {
+				costs.ChickenCost += pulletCost
+			}
+		}
 	}
 
-	// Build new DTO structure
-
-	// Calculate totals
-	var totalPopulation float64
-	for _, chickin := range chickins {
-		totalPopulation += chickin.UsageQty
+	costs.ExpeditionCost, err = s.HppRepo.GetExpedisionCost(c.Context(), projectFlockKandangIDs)
+	if err != nil {
+		costs.ExpeditionCost = 0
 	}
 
-	// Calculate actual population (total population - depletion)
-	actualPopulation := totalPopulation - totalDepletion
-
-	// Calculate budget totals by category
-	calculateBudgetByFlag := func(flags []string) float64 {
-		var total float64
+	if budgets, err := s.ProjectBudgetRepo.GetByProjectFlockID(c.Context(), projectFlock.Id); err == nil {
+		totalBudget := 0.0
 		for _, budget := range budgets {
-			if budget.Nonstock != nil {
-				for _, nonstockFlag := range budget.Nonstock.Flags {
-					flagName := strings.ToUpper(nonstockFlag.Name)
-					for _, targetFlag := range flags {
-						if flagName == strings.ToUpper(targetFlag) {
-							total += budget.Price * budget.Qty
-							break
-						}
-					}
-				}
+			totalBudget += budget.Price * budget.Qty
+		}
+		if projectFlockKandangID != nil {
+			allKandangs, errKandang := s.ProjectFlockKandangRepo.GetByProjectFlockID(c.Context(), projectFlock.Id)
+			if errKandang == nil && len(allKandangs) > 0 {
+				costs.BudgetOperational = totalBudget / float64(len(allKandangs))
+			}
+		} else {
+			costs.BudgetOperational = totalBudget
+		}
+	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
+		s.Log.Errorf("Failed to fetch budgets for project_flock_id=%d: %+v", projectFlock.Id, err)
+	}
+
+	if realizations, err := s.ExpenseRealizationRepo.GetClosingOverhead(c.Context(), projectFlock.Id, projectFlockKandangID); err == nil {
+		for _, realization := range realizations {
+			amount := realization.Price * realization.Qty
+			isEkspedisi := realization.ExpenseNonstock != nil &&
+				realization.ExpenseNonstock.Nonstock != nil &&
+				containsFlag(realization.ExpenseNonstock.Nonstock.Flags, "EKSPEDISI")
+			if !isEkspedisi {
+				costs.RealizationOperational += amount
 			}
 		}
-		return total
+	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
+		s.Log.Errorf("Failed to fetch realizations for project_flock_id=%d: %+v", projectFlock.Id, err)
 	}
 
-	// Budget per category
-	budgetPakan := calculateBudgetByFlag([]string{"PAKAN", "PRE-STARTER", "STARTER", "FINISHER"})
-	budgetOvk := calculateBudgetByFlag([]string{"OVK", "OBAT", "VITAMIN", "KIMIA"})
-	budgetAyam := calculateBudgetByFlag([]string{"DOC", "PULLET", "LAYER"})
-	budgetEkspedisi := calculateBudgetByFlag([]string{"EKSPEDISI"})
+	return costs, nil
+}
 
-	// Operational budget = total budget - pakan - ovk - ayam - ekspedisi
-	totalBudgetAmount := 0.0
-	for _, budget := range budgets {
-		totalBudgetAmount += budget.Price * budget.Qty
+func (s closingKeuanganService) calculateProductionData(c *fiber.Ctx, projectFlock *entity.ProjectFlock, projectFlockKandangIDs []uint, projectFlockKandangID *uint) (*ProductionData, error) {
+	data := &ProductionData{}
+	var err error
+
+	data.TotalPopulationIn, err = s.HppRepo.GetTotalPopulation(c.Context(), projectFlockKandangIDs)
+	if err != nil {
+		data.TotalPopulationIn = 0
 	}
-	budgetOperational := totalBudgetAmount - budgetPakan - budgetOvk - budgetAyam - budgetEkspedisi
 
+	if projectFlockKandangID != nil {
+		data.TotalDepletion, err = s.RecordingRepo.GetTotalDepletionByProjectFlockKandangID(c.Context(), *projectFlockKandangID)
+	} else {
+		data.TotalDepletion, err = s.RecordingRepo.GetTotalDepletionByProjectFlockID(c.Context(), projectFlock.Id)
+	}
+	if err != nil {
+		data.TotalDepletion = 0
+	}
 
-	// Calculate realization totals
-	var totalRealizationAmount float64
-	var totalEkspedisiRealization float64
-	for _, realization := range realizations {
-		amount := realization.Price * realization.Qty
-		totalRealizationAmount += amount
+	if projectFlockKandangID != nil {
+		data.TotalWeightProduced, err = s.RecordingRepo.GetTotalWeightProducedFromUniformityByProjectFlockKandangID(c.Context(), *projectFlockKandangID)
+	} else {
+		data.TotalWeightProduced, err = s.RecordingRepo.GetTotalWeightProducedFromUniformityByProjectFlockID(c.Context(), projectFlock.Id)
+	}
+	if err != nil {
+		data.TotalWeightProduced = 0
+	}
 
-		// Check if this is ekspedisi (need to check nonstock flags)
-		if realization.ExpenseNonstock != nil && realization.ExpenseNonstock.Nonstock != nil {
-			for _, flag := range realization.ExpenseNonstock.Nonstock.Flags {
-				if flag.Name == "EKSPEDISI" {
-					totalEkspedisiRealization += amount
-					break
-				}
-			}
+	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
+		_, data.TotalEggWeightKg, err = s.HppRepo.GetEggProduksiPiecesAndWeightKgByProjectFlockKandangIds(c.Context(), projectFlockKandangIDs, nil)
+		if err != nil {
+			data.TotalEggWeightKg = 0
 		}
 	}
 
-	totalOperationalRealization := totalRealizationAmount - totalEkspedisiRealization
+	var deliveryProducts []entity.MarketingDeliveryProduct
+	if projectFlockKandangID != nil {
+		deliveryProducts, err = s.MarketingDeliveryProductRepo.GetClosingPenjualan(c.Context(), projectFlock.Id, projectFlockKandangID, projectFlock.Category)
+	} else {
+		deliveryProducts, err = s.MarketingDeliveryProductRepo.GetClosingPenjualan(c.Context(), projectFlock.Id, nil, projectFlock.Category)
+	}
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data penjualan")
+	}
 
-	// Filter delivery products based on category
-	var filteredDeliveryProducts []entity.MarketingDeliveryProduct
 	for _, delivery := range deliveryProducts {
-		// Get product from delivery
 		if delivery.MarketingProduct.ProductWarehouse.Product.Id == 0 {
 			continue
 		}
-
-		product := delivery.MarketingProduct.ProductWarehouse.Product
-		isEggProduct := false
-		isChickenProduct := false
-
-		// Check product flags
-		for _, flag := range product.Flags {
-			flagName := strings.ToUpper(flag.Name)
-
-			// Egg product flags
-			if flagName == "TELUR" || flagName == "TELURUTUH" || flagName == "TELURPECAH" ||
-				flagName == "TELURPUTIH" || flagName == "TELURRETAK" {
-				isEggProduct = true
-			}
-
-			// Chicken product flags
-			if flagName == "AYAMAFKIR" || flagName == "AYAMCULLING" || flagName == "AYAMMATI" {
-				isChickenProduct = true
-			}
-		}
-
-		// Filter based on project flock category
-		if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
-			// Laying: only egg products
-			if isEggProduct {
-				filteredDeliveryProducts = append(filteredDeliveryProducts, delivery)
-			}
-		} else {
-			// Growing/Contract Growing: only chicken products
-			if isChickenProduct || (!isEggProduct && !isChickenProduct) {
-				// Include if chicken product or if no specific flags (default to chicken)
-				filteredDeliveryProducts = append(filteredDeliveryProducts, delivery)
-			}
-		}
+		data.TotalWeightSold += delivery.TotalWeight
+		data.TotalSalesAmount += delivery.TotalPrice
 	}
 
+	return data, nil
+}
 
-	// Calculate total weight sold and sales amount from filtered products
-	var totalWeightSold float64
-	var totalSalesAmount float64
-	for _, delivery := range filteredDeliveryProducts {
-		totalWeightSold += delivery.TotalWeight
-		totalSalesAmount += delivery.TotalPrice
+func (s closingKeuanganService) buildHPPSection(c *fiber.Ctx, projectFlock *entity.ProjectFlock, projectFlockKandangs []entity.ProjectFlockKandang, costs *CostData, production *ProductionData) dto.HPPSection {
+
+	actualPopulation := production.TotalPopulationIn - production.TotalDepletion
+	totalWeightProduced := production.TotalWeightProduced
+	totalEggWeightKg := production.TotalEggWeightKg
+
+	weightForCalculation := totalWeightProduced
+	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
+		weightForCalculation = totalEggWeightKg
 	}
 
-
-	// Calculate metrics - always use kg ayam for rp_per_kg
 	calculateMetrics := func(amount float64) (rpPerBird, rpPerKg float64) {
 		if actualPopulation > 0 {
-			rpPerBird = amount / actualPopulation  // Use actual population
+			rpPerBird = amount / actualPopulation
 		}
-		if totalWeightProduced > 0 {
-			rpPerKg = amount / totalWeightProduced
+		if weightForCalculation > 0 {
+			rpPerKg = amount / weightForCalculation
 		}
 		return
 	}
 
-	// Calculate metrics for profit loss (use total population and total weight produced)
-	calculateProfitLossMetrics := func(amount float64) (rpPerBird, rpPerKg float64) {
-		if totalPopulation > 0 {
-			rpPerBird = amount / totalPopulation
-		}
-		if totalWeightProduced > 0 {
-			rpPerKg = amount / totalWeightProduced
-		}
-		return
+	createHPPItem := func(id uint, category, code, label string, budgetAmount, realizationAmount float64) dto.HPPItem {
+		budgetRpPerBird, budgetRpPerKg := calculateMetrics(budgetAmount)
+		realizationRpPerBird, realizationRpPerKg := calculateMetrics(realizationAmount)
+		return dto.ToHPPItem(
+			id,
+			category,
+			code,
+			label,
+			dto.ToFinancialMetrics(budgetRpPerBird, budgetRpPerKg, budgetAmount),
+			dto.ToFinancialMetrics(realizationRpPerBird, realizationRpPerKg, realizationAmount),
+		)
 	}
 
-	// Build HPP Items using constants
 	hppItems := []dto.HPPItem{}
 
-	// PAKAN item
-	pakanBudgetRpPerBird, pakanBudgetRpPerKg := calculateMetrics(budgetPakan)
-	pakanRealizationRpPerBird, pakanRealizationRpPerKg := calculateMetrics(totalPakanPrice)
-	hppItems = append(hppItems, dto.ToHPPItem(
-		1,
-		"purchase",
-		string(dto.HPPCodePakan),
-		"Pembelian Pakan",
-		dto.ToFinancialMetrics(pakanBudgetRpPerBird, pakanBudgetRpPerKg, budgetPakan),
-		dto.ToFinancialMetrics(pakanRealizationRpPerBird, pakanRealizationRpPerKg, totalPakanPrice),
-	))
+	hppItems = append(hppItems, createHPPItem(1, "purchase", string(dto.HPPCodePakan), "Pembelian Pakan", costs.FeedCost, costs.FeedCost))
+	hppItems = append(hppItems, createHPPItem(2, "purchase", string(dto.HPPCodeOVK), "Pembelian OVK", costs.OvkCost, costs.OvkCost))
 
-	// OVK item
-	ovkBudgetRpPerBird, ovkBudgetRpPerKg := calculateMetrics(budgetOvk)
-	ovkRealizationRpPerBird, ovkRealizationRpPerKg := calculateMetrics(totalOvkPrice)
-	hppItems = append(hppItems, dto.ToHPPItem(
-		2,
-		"purchase",
-		string(dto.HPPCodeOVK),
-		"Pembelian OVK",
-		dto.ToFinancialMetrics(ovkBudgetRpPerBird, ovkBudgetRpPerKg, budgetOvk),
-		dto.ToFinancialMetrics(ovkRealizationRpPerBird, ovkRealizationRpPerKg, totalOvkPrice),
-	))
-
-	// DOC/DEPRESIASI item
 	docCode := string(dto.HPPCodeDOC)
 	docLabel := "Pembelian DOC"
 	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
 		docCode = string(dto.HPPCodeDepresiasi)
 		docLabel = "Depresiasi"
 	}
-	docBudgetRpPerBird, docBudgetRpPerKg := calculateMetrics(budgetAyam)
-	docRealizationRpPerBird, docRealizationRpPerKg := calculateMetrics(totalAyamPrice)
-	hppItems = append(hppItems, dto.ToHPPItem(
-		3,
-		"purchase",
-		docCode,
-		docLabel,
-		dto.ToFinancialMetrics(docBudgetRpPerBird, docBudgetRpPerKg, budgetAyam),
-		dto.ToFinancialMetrics(docRealizationRpPerBird, docRealizationRpPerKg, totalAyamPrice),
-	))
+	hppItems = append(hppItems, createHPPItem(3, "purchase", docCode, docLabel, costs.ChickenCost, costs.ChickenCost))
+	hppItems = append(hppItems, createHPPItem(4, "overhead", string(dto.HPPCodeOverhead), "Pengeluaran Overhead", costs.BudgetOperational, costs.RealizationOperational))
+	hppItems = append(hppItems, createHPPItem(5, "overhead", string(dto.HPPCodeEkspedisi), "Beban Ekspedisi", costs.ExpeditionCost, costs.ExpeditionCost))
 
-	// OVERHEAD item
-	overheadBudgetRpPerBird, overheadBudgetRpPerKg := calculateMetrics(budgetOperational)
-	overheadRealizationRpPerBird, overheadRealizationRpPerKg := calculateMetrics(totalOperationalRealization)
-	hppItems = append(hppItems, dto.ToHPPItem(
-		4,
-		"overhead",
-		string(dto.HPPCodeOverhead),
-		"Pengeluaran Overhead",
-		dto.ToFinancialMetrics(overheadBudgetRpPerBird, overheadBudgetRpPerKg, budgetOperational),
-		dto.ToFinancialMetrics(overheadRealizationRpPerBird, overheadRealizationRpPerKg, totalOperationalRealization),
-	))
-
-	// EKSPEDISI item
-	ekspedisiBudgetRpPerBird, ekspedisiBudgetRpPerKg := calculateMetrics(budgetEkspedisi)
-	ekspedisiRealizationRpPerBird, ekspedisiRealizationRpPerKg := calculateMetrics(totalEkspedisiRealization)
-	hppItems = append(hppItems, dto.ToHPPItem(
-		5,
-		"overhead",
-		string(dto.HPPCodeEkspedisi),
-		"Beban Ekspedisi",
-		dto.ToFinancialMetrics(ekspedisiBudgetRpPerBird, ekspedisiBudgetRpPerKg, budgetEkspedisi),
-		dto.ToFinancialMetrics(ekspedisiRealizationRpPerBird, ekspedisiRealizationRpPerKg, totalEkspedisiRealization),
-	))
-
-	// HPP Summary
-	totalBudgetHpp := budgetPakan + budgetOvk + budgetAyam + budgetOperational + budgetEkspedisi
-	totalRealizationHpp := totalPakanPrice + totalOvkPrice + totalAyamPrice + totalOperationalRealization + totalEkspedisiRealization
+	totalBudgetHpp := costs.FeedCost + costs.OvkCost + costs.ChickenCost + costs.BudgetOperational + costs.ExpeditionCost
+	totalRealizationHpp := costs.FeedCost + costs.OvkCost + costs.ChickenCost + costs.RealizationOperational + costs.ExpeditionCost
 
 	hppBudgetRpPerBird, hppBudgetRpPerKg := calculateMetrics(totalBudgetHpp)
 	hppRealizationRpPerBird, hppRealizationRpPerKg := calculateMetrics(totalRealizationHpp)
 
 	var eggBudgeting, eggRealization *dto.FinancialMetrics
-	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) && totalEggWeightKg > 0 {
-		eggBudgetRpPerKg := totalBudgetHpp / totalEggWeightKg
-		eggRealizationRpPerKg := totalRealizationHpp / totalEggWeightKg
-		eggBudgeting = &dto.FinancialMetrics{
-			RpPerBird: 0,
-			RpPerKg:   eggBudgetRpPerKg,
-			Amount:    totalBudgetHpp,
+	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
+		accumulateEggMetrics := func(metrics **dto.FinancialMetrics, amount, rpPerKg float64) {
+			if *metrics == nil {
+				*metrics = &dto.FinancialMetrics{
+					RpPerBird: 0,
+					RpPerKg:   rpPerKg,
+					Amount:    amount,
+				}
+			} else {
+				(*metrics).Amount += amount
+				if totalEggWeightKg > 0 {
+					(*metrics).RpPerKg = (*metrics).Amount / totalEggWeightKg
+				}
+			}
 		}
-		eggRealization = &dto.FinancialMetrics{
-			RpPerBird: 0,
-			RpPerKg:   eggRealizationRpPerKg,
-			Amount:    totalRealizationHpp,
+
+		for _, projectFlockKandang := range projectFlockKandangs {
+			hppResponse, err := s.HppSvc.CalculateHppCost(projectFlockKandang.Id, nil)
+			if err == nil {
+				accumulateEggMetrics(&eggBudgeting, hppResponse.Estimation.Total, hppResponse.Estimation.HargaKg)
+				accumulateEggMetrics(&eggRealization, hppResponse.Real.Total, hppResponse.Real.HargaKg)
+			}
 		}
 	}
 
@@ -543,12 +378,48 @@ func (s closingKeuanganService) calculateClosingKeuangan(c *fiber.Ctx, projectFl
 		eggRealization,
 	)
 
-	hppSection := dto.ToHPPSection(hppItems, hppSummary)
+	return dto.ToHPPSection(hppItems, hppSummary)
+}
+
+func (s closingKeuanganService) buildProfitLossSection(projectFlock *entity.ProjectFlock, costs *CostData, production *ProductionData) dto.ProfitLossSection {
+
+	totalPopulationIn := production.TotalPopulationIn
+	totalWeightProduced := production.TotalWeightProduced
+	totalEggWeightKg := production.TotalEggWeightKg
+	totalSalesAmount := production.TotalSalesAmount
+	totalWeightSold := production.TotalWeightSold
+
+	weightForSales := totalWeightSold
+	weightForCalculation := totalWeightProduced
+	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
+		weightForSales = totalWeightSold
+		weightForCalculation = totalEggWeightKg
+	}
+
+	calculateProfitLossMetrics := func(amount float64) (rpPerBird, rpPerKg float64) {
+		if totalPopulationIn > 0 {
+			rpPerBird = amount / totalPopulationIn
+		}
+		if weightForSales > 0 {
+			rpPerKg = amount / weightForSales
+		}
+		return
+	}
+
+	actualPopulation := production.TotalPopulationIn - production.TotalDepletion
+
+	calculateMetrics := func(amount float64) (rpPerBird, rpPerKg float64) {
+		if actualPopulation > 0 {
+			rpPerBird = amount / actualPopulation
+		}
+		if weightForCalculation > 0 {
+			rpPerKg = amount / weightForCalculation
+		}
+		return
+	}
 
-	// Build Profit Loss Items using constants
 	plItems := []dto.ProfitLossItem{}
 
-	// SALES item
 	salesRpPerBird, salesRpPerKg := calculateProfitLossMetrics(totalSalesAmount)
 	salesLabel := "Penjualan Ayam"
 	if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
@@ -563,10 +434,13 @@ func (s closingKeuanganService) calculateClosingKeuangan(c *fiber.Ctx, projectFl
 		totalSalesAmount,
 	))
 
-	// SAPRONAK item - combines DOC/Depresiasi + PAKAN + OVK
-	totalSapronakAmount := totalAyamPrice + totalPakanPrice + totalOvkPrice
-	sapronakRpPerBird := docRealizationRpPerBird + pakanRealizationRpPerBird + ovkRealizationRpPerBird
-	sapronakRpPerKg := docRealizationRpPerKg + pakanRealizationRpPerKg + ovkRealizationRpPerKg
+	totalSapronakAmount := costs.ChickenCost + costs.FeedCost + costs.OvkCost
+	_, sapronakRpPerKg := calculateMetrics(totalSapronakAmount)
+	sapronakRpPerBird := 0.0
+	for _, amount := range []float64{costs.ChickenCost, costs.FeedCost, costs.OvkCost} {
+		rpPerBird, _ := calculateMetrics(amount)
+		sapronakRpPerBird += rpPerBird
+	}
 	sapronakLabel := "Pengeluaran Sapronak"
 	plItems = append(plItems, dto.ToProfitLossItem(
 		string(dto.PLCodeSapronak),
@@ -577,62 +451,54 @@ func (s closingKeuanganService) calculateClosingKeuangan(c *fiber.Ctx, projectFl
 		totalSapronakAmount,
 	))
 
-	// OVERHEAD item
-	overheadRpPerBird, overheadRpPerKg := calculateMetrics(totalOperationalRealization)
+	overheadRpPerBird, overheadRpPerKg := calculateProfitLossMetrics(costs.RealizationOperational)
 	plItems = append(plItems, dto.ToProfitLossItem(
 		string(dto.PLCodeOverhead),
 		"Overhead",
 		"overhead",
 		overheadRpPerBird,
 		overheadRpPerKg,
-		totalOperationalRealization,
+		costs.RealizationOperational,
 	))
 
-	// EKSPEDISI item
+	ekspedisiRpPerBird, ekspedisiRpPerKg := calculateProfitLossMetrics(costs.ExpeditionCost)
 	plItems = append(plItems, dto.ToProfitLossItem(
 		string(dto.PLCodeEkspedisi),
 		"Ekspedisi",
 		"overhead",
-		ekspedisiRealizationRpPerBird,
-		ekspedisiRealizationRpPerKg,
-		totalEkspedisiRealization,
+		ekspedisiRpPerBird,
+		ekspedisiRpPerKg,
+		costs.ExpeditionCost,
 	))
 
-	// Profit Loss Summary
-	// Gross Profit = Sales - (DOC + PAKAN + OVK) only
-	// Gross Profit should NOT include overhead and ekspedisi
-	costOfGoodsSold := totalAyamPrice + totalPakanPrice + totalOvkPrice
+	costOfGoodsSold := costs.ChickenCost + costs.FeedCost + costs.OvkCost
 	costOfGoodsSoldRpPerBird := sapronakRpPerBird
+	costOfGoodsSoldRpPerKg := sapronakRpPerKg
 
 	grossProfit := totalSalesAmount - costOfGoodsSold
 	grossProfitRpPerBird := salesRpPerBird - costOfGoodsSoldRpPerBird
+	grossProfitRpPerKg := salesRpPerKg - costOfGoodsSoldRpPerKg
 
-	// Operating Expenses (Overhead + Ekspedisi)
-	totalOperatingExpenses := totalOperationalRealization + totalEkspedisiRealization
-	totalOperatingExpensesRpPerBird := overheadRpPerBird + ekspedisiRealizationRpPerBird
+	totalOperatingExpenses := costs.RealizationOperational + costs.ExpeditionCost
+	totalOperatingExpensesRpPerBird := overheadRpPerBird + ekspedisiRpPerBird
+	totalOperatingExpensesRpPerKg := overheadRpPerKg + ekspedisiRpPerKg
 
-	// Net Profit = Gross Profit - Operating Expenses
 	netProfit := grossProfit - totalOperatingExpenses
 	netProfitRpPerBird := grossProfitRpPerBird - totalOperatingExpensesRpPerBird
+	netProfitRpPerKg := grossProfitRpPerKg - totalOperatingExpensesRpPerKg
 
 	plSummary := dto.ToProfitLossSummary(
-		dto.ToFinancialMetrics(grossProfitRpPerBird, 0, grossProfit),
-		dto.ToFinancialMetrics(totalOperatingExpensesRpPerBird, 0, totalOperatingExpenses),
-		dto.ToFinancialMetrics(netProfitRpPerBird, 0, netProfit),
+		dto.ToFinancialMetrics(grossProfitRpPerBird, grossProfitRpPerKg, grossProfit),
+		dto.ToFinancialMetrics(totalOperatingExpensesRpPerBird, totalOperatingExpensesRpPerKg, totalOperatingExpenses),
+		dto.ToFinancialMetrics(netProfitRpPerBird, netProfitRpPerKg, netProfit),
 	)
 
-	profitLossSection := dto.ToProfitLossSection(plItems, plSummary)
-
-	// Build complete response
-	data := dto.ToClosingKeuanganData(hppSection, profitLossSection)
-
-	return &data, nil
+	return dto.ToProfitLossSection(plItems, plSummary)
 }
 
-// containsItem checks if a string exists in a slice
-func containsItem(slice []string, item string) bool {
-	for _, s := range slice {
-		if strings.EqualFold(s, item) {
+func containsFlag(flags []entity.Flag, name string) bool {
+	for _, flag := range flags {
+		if flag.Name == name {
 			return true
 		}
 	}