mirror of
https://gitlab.com/mbugroup/lti-api.git
synced 2026-05-20 13:31:56 +00:00
aguhh18
641 lines
23 KiB
Go
641 lines
23 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
|
|
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"
|
|
)
|
|
|
|
// ClosingKeuanganService handles closing keuangan business logic
|
|
type ClosingKeuanganService interface {
|
|
GetClosingKeuangan(ctx *fiber.Ctx, projectFlockID uint) (*dto.ClosingKeuanganData, error)
|
|
GetClosingKeuanganByKandang(ctx *fiber.Ctx, projectFlockID uint, projectFlockKandangID uint) (*dto.ClosingKeuanganData, error)
|
|
}
|
|
|
|
type closingKeuanganService struct {
|
|
Log *logrus.Logger
|
|
ClosingKeuanganRepo repository.ClosingKeuanganRepository
|
|
ProjectFlockRepo projectflockRepository.ProjectflockRepository
|
|
ProjectFlockKandangRepo projectflockRepository.ProjectFlockKandangRepository
|
|
MarketingDeliveryProductRepo marketingDeliveryProductRepository.MarketingDeliveryProductRepository
|
|
ExpenseRealizationRepo expenseRealizationRepository.ExpenseRealizationRepository
|
|
ProjectBudgetRepo projectflockRepository.ProjectBudgetRepository
|
|
ChickinRepo chickinRepository.ProjectChickinRepository
|
|
RecordingRepo recordingRepository.RecordingRepository
|
|
}
|
|
|
|
func NewClosingKeuanganService(
|
|
closingKeuanganRepo repository.ClosingKeuanganRepository,
|
|
projectFlockRepo projectflockRepository.ProjectflockRepository,
|
|
projectFlockKandangRepo projectflockRepository.ProjectFlockKandangRepository,
|
|
marketingDeliveryProductRepo marketingDeliveryProductRepository.MarketingDeliveryProductRepository,
|
|
expenseRealizationRepo expenseRealizationRepository.ExpenseRealizationRepository,
|
|
projectBudgetRepo projectflockRepository.ProjectBudgetRepository,
|
|
chickinRepo chickinRepository.ProjectChickinRepository,
|
|
recordingRepo recordingRepository.RecordingRepository,
|
|
) ClosingKeuanganService {
|
|
return &closingKeuanganService{
|
|
Log: utils.Log,
|
|
ClosingKeuanganRepo: closingKeuanganRepo,
|
|
ProjectFlockRepo: projectFlockRepo,
|
|
ProjectFlockKandangRepo: projectFlockKandangRepo,
|
|
MarketingDeliveryProductRepo: marketingDeliveryProductRepo,
|
|
ExpenseRealizationRepo: expenseRealizationRepo,
|
|
ProjectBudgetRepo: projectBudgetRepo,
|
|
ChickinRepo: chickinRepo,
|
|
RecordingRepo: recordingRepo,
|
|
}
|
|
}
|
|
|
|
func (s closingKeuanganService) GetClosingKeuangan(c *fiber.Ctx, projectFlockID uint) (*dto.ClosingKeuanganData, error) {
|
|
|
|
if err := commonSvc.EnsureRelations(c.Context(),
|
|
commonSvc.RelationCheck{Name: "Project Flock", ID: &projectFlockID, Exists: s.ProjectFlockRepo.IdExists},
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
projectFlock, err := s.ProjectFlockRepo.GetByID(c.Context(), projectFlockID, nil)
|
|
if err != nil {
|
|
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)
|
|
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)
|
|
}
|
|
|
|
func (s closingKeuanganService) GetClosingKeuanganByKandang(c *fiber.Ctx, projectFlockID uint, projectFlockKandangID uint) (*dto.ClosingKeuanganData, error) {
|
|
|
|
if err := commonSvc.EnsureRelations(c.Context(),
|
|
commonSvc.RelationCheck{Name: "Project Flock", ID: &projectFlockID, Exists: s.ProjectFlockRepo.IdExists},
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Validate and fetch project flock kandang
|
|
kandang, 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 {
|
|
return nil, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang does not belong to this project flock")
|
|
}
|
|
|
|
projectFlock, err := s.ProjectFlockRepo.GetByID(c.Context(), projectFlockID, nil)
|
|
if err != nil {
|
|
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
|
|
}
|
|
|
|
kandangs := []entity.ProjectFlockKandang{*kandang}
|
|
|
|
return s.calculateClosingKeuangan(c, projectFlock, budgets, kandangs, projectFlockID)
|
|
}
|
|
|
|
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...)
|
|
|
|
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...)
|
|
}
|
|
}
|
|
|
|
// 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
|
|
var projectFlockKandangID *uint
|
|
if isPerKandang {
|
|
kandangID := kandangs[0].Id
|
|
projectFlockKandangID = &kandangID
|
|
}
|
|
|
|
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)
|
|
}
|
|
if err != nil {
|
|
return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch realizations")
|
|
}
|
|
|
|
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)
|
|
}
|
|
if err != nil {
|
|
return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch chickins")
|
|
}
|
|
|
|
// 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
|
|
} else {
|
|
totalEggWeightKg = 0
|
|
}
|
|
|
|
// Build new DTO structure
|
|
|
|
// Calculate totals
|
|
var totalPopulation float64
|
|
for _, chickin := range chickins {
|
|
totalPopulation += chickin.UsageQty
|
|
}
|
|
|
|
// Calculate actual population (total population - depletion)
|
|
actualPopulation := totalPopulation - totalDepletion
|
|
|
|
// Calculate budget totals by category
|
|
calculateBudgetByFlag := func(flags []string) float64 {
|
|
var total float64
|
|
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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return total
|
|
}
|
|
|
|
// 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"})
|
|
|
|
// Operational budget = total budget - pakan - ovk - ayam - ekspedisi
|
|
totalBudgetAmount := 0.0
|
|
for _, budget := range budgets {
|
|
totalBudgetAmount += budget.Price * budget.Qty
|
|
}
|
|
budgetOperational := totalBudgetAmount - budgetPakan - budgetOvk - budgetAyam - budgetEkspedisi
|
|
|
|
|
|
// Calculate realization totals
|
|
var totalRealizationAmount float64
|
|
var totalEkspedisiRealization float64
|
|
for _, realization := range realizations {
|
|
amount := realization.Price * realization.Qty
|
|
totalRealizationAmount += amount
|
|
|
|
// 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
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
totalOperationalRealization := totalRealizationAmount - totalEkspedisiRealization
|
|
|
|
// 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 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
|
|
}
|
|
|
|
|
|
// 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
|
|
}
|
|
if totalWeightProduced > 0 {
|
|
rpPerKg = amount / totalWeightProduced
|
|
}
|
|
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
|
|
}
|
|
|
|
// 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),
|
|
))
|
|
|
|
// 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),
|
|
))
|
|
|
|
// 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
|
|
|
|
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,
|
|
}
|
|
eggRealization = &dto.FinancialMetrics{
|
|
RpPerBird: 0,
|
|
RpPerKg: eggRealizationRpPerKg,
|
|
Amount: totalRealizationHpp,
|
|
}
|
|
}
|
|
|
|
hppSummary := dto.ToHPPSummary(
|
|
"HPP",
|
|
dto.ToFinancialMetrics(hppBudgetRpPerBird, hppBudgetRpPerKg, totalBudgetHpp),
|
|
dto.ToFinancialMetrics(hppRealizationRpPerBird, hppRealizationRpPerKg, totalRealizationHpp),
|
|
eggBudgeting,
|
|
eggRealization,
|
|
)
|
|
|
|
hppSection := dto.ToHPPSection(hppItems, hppSummary)
|
|
|
|
// Build Profit Loss Items using constants
|
|
plItems := []dto.ProfitLossItem{}
|
|
|
|
// SALES item
|
|
salesRpPerBird, salesRpPerKg := calculateProfitLossMetrics(totalSalesAmount)
|
|
salesLabel := "Penjualan Ayam"
|
|
if projectFlock.Category == string(utils.ProjectFlockCategoryLaying) {
|
|
salesLabel = "Penjualan Telur"
|
|
}
|
|
plItems = append(plItems, dto.ToProfitLossItem(
|
|
string(dto.PLCodeSales),
|
|
salesLabel,
|
|
"income",
|
|
salesRpPerBird,
|
|
salesRpPerKg,
|
|
totalSalesAmount,
|
|
))
|
|
|
|
// SAPRONAK item - combines DOC/Depresiasi + PAKAN + OVK
|
|
totalSapronakAmount := totalAyamPrice + totalPakanPrice + totalOvkPrice
|
|
sapronakRpPerBird := docRealizationRpPerBird + pakanRealizationRpPerBird + ovkRealizationRpPerBird
|
|
sapronakRpPerKg := docRealizationRpPerKg + pakanRealizationRpPerKg + ovkRealizationRpPerKg
|
|
sapronakLabel := "Pengeluaran Sapronak"
|
|
plItems = append(plItems, dto.ToProfitLossItem(
|
|
string(dto.PLCodeSapronak),
|
|
sapronakLabel,
|
|
"purchase",
|
|
sapronakRpPerBird,
|
|
sapronakRpPerKg,
|
|
totalSapronakAmount,
|
|
))
|
|
|
|
// OVERHEAD item
|
|
overheadRpPerBird, overheadRpPerKg := calculateMetrics(totalOperationalRealization)
|
|
plItems = append(plItems, dto.ToProfitLossItem(
|
|
string(dto.PLCodeOverhead),
|
|
"Overhead",
|
|
"overhead",
|
|
overheadRpPerBird,
|
|
overheadRpPerKg,
|
|
totalOperationalRealization,
|
|
))
|
|
|
|
// EKSPEDISI item
|
|
plItems = append(plItems, dto.ToProfitLossItem(
|
|
string(dto.PLCodeEkspedisi),
|
|
"Ekspedisi",
|
|
"overhead",
|
|
ekspedisiRealizationRpPerBird,
|
|
ekspedisiRealizationRpPerKg,
|
|
totalEkspedisiRealization,
|
|
))
|
|
|
|
// Profit Loss Summary
|
|
// Gross Profit = Sales - (DOC + PAKAN + OVK) only
|
|
// Gross Profit should NOT include overhead and ekspedisi
|
|
costOfGoodsSold := totalAyamPrice + totalPakanPrice + totalOvkPrice
|
|
costOfGoodsSoldRpPerBird := sapronakRpPerBird
|
|
|
|
grossProfit := totalSalesAmount - costOfGoodsSold
|
|
grossProfitRpPerBird := salesRpPerBird - costOfGoodsSoldRpPerBird
|
|
|
|
// Operating Expenses (Overhead + Ekspedisi)
|
|
totalOperatingExpenses := totalOperationalRealization + totalEkspedisiRealization
|
|
totalOperatingExpensesRpPerBird := overheadRpPerBird + ekspedisiRealizationRpPerBird
|
|
|
|
// Net Profit = Gross Profit - Operating Expenses
|
|
netProfit := grossProfit - totalOperatingExpenses
|
|
netProfitRpPerBird := grossProfitRpPerBird - totalOperatingExpensesRpPerBird
|
|
|
|
plSummary := dto.ToProfitLossSummary(
|
|
dto.ToFinancialMetrics(grossProfitRpPerBird, 0, grossProfit),
|
|
dto.ToFinancialMetrics(totalOperatingExpensesRpPerBird, 0, totalOperatingExpenses),
|
|
dto.ToFinancialMetrics(netProfitRpPerBird, 0, netProfit),
|
|
)
|
|
|
|
profitLossSection := dto.ToProfitLossSection(plItems, plSummary)
|
|
|
|
// Build complete response
|
|
data := dto.ToClosingKeuanganData(hppSection, profitLossSection)
|
|
|
|
return &data, nil
|
|
}
|
|
|
|
// 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) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|