first commit api production-result

2026-05-23 14:55:42 +00:00 · 2026-01-02 11:24:26 +07:00
parent 10f42ed9c4
commit 39909d1c2e
8 changed files with 523 additions and 3 deletions
@@ -35,6 +35,7 @@ type RepportService interface {
 	GetMarketing(ctx *fiber.Ctx, params *validation.MarketingQuery) ([]dto.RepportMarketingItemDTO, int64, error)
 	GetPurchaseSupplier(ctx *fiber.Ctx, params *validation.PurchaseSupplierQuery) ([]dto.PurchaseSupplierDTO, int64, error)
 	GetHppPerKandang(ctx *fiber.Ctx) (*dto.HppPerKandangResponseData, *dto.HppPerKandangMetaDTO, error)
+	GetProductionResult(ctx *fiber.Ctx, params *validation.ProductionResultQuery) ([]dto.ProductionResultDTO, int64, error)
 }

 type repportService struct {
@@ -48,6 +49,7 @@ type repportService struct {
 	ApprovalSvc            approvalService.ApprovalService
 	PurchaseSupplierRepo   repportRepo.PurchaseSupplierRepository
 	HppPerKandangRepo      repportRepo.HppPerKandangRepository
+	ProductionResultRepo   repportRepo.ProductionResultRepository
 }

 type HppCostAggregate struct {
@@ -69,6 +71,7 @@ func NewRepportService(
 	approvalSvc approvalService.ApprovalService,
 	purchaseSupplierRepo repportRepo.PurchaseSupplierRepository,
 	hppPerKandangRepo repportRepo.HppPerKandangRepository,
+	productionResultRepo repportRepo.ProductionResultRepository,
 ) RepportService {
 	return &repportService{
 		Log:                    utils.Log,
@@ -81,6 +84,7 @@ func NewRepportService(
 		ApprovalSvc:            approvalSvc,
 		PurchaseSupplierRepo:   purchaseSupplierRepo,
 		HppPerKandangRepo:      hppPerKandangRepo,
+		ProductionResultRepo:   productionResultRepo,
 	}
 }

@@ -230,6 +234,351 @@ func (s *repportService) getTotalProjectCost(ctx context.Context, projectFlockID
 	return cost
 }

+func (s *repportService) GetProductionResult(ctx *fiber.Ctx, params *validation.ProductionResultQuery) ([]dto.ProductionResultDTO, int64, error) {
+	if err := s.Validate.Struct(params); err != nil {
+		return nil, 0, err
+	}
+
+	const (
+		recordsPerWeek     = 7
+		defaultStartWoa    = 18
+		defaultStdBw       = 1951
+		defaultBw          = 0
+		defaultUniformText = "90% up"
+	)
+
+	if params.Limit <= 0 {
+		params.Limit = 10
+	}
+	if params.Page <= 0 {
+		params.Page = 1
+	}
+
+	weeksPerPage := params.Limit
+	recordLimit := weeksPerPage * recordsPerWeek
+	if recordLimit <= 0 {
+		recordLimit = recordsPerWeek
+	}
+	recordOffset := (params.Page - 1) * recordLimit
+	if recordOffset < 0 {
+		recordOffset = 0
+	}
+
+	recordings, totalRecordings, err := s.ProductionResultRepo.GetRecordingsByProjectFlockKandang(ctx.Context(), params.ProjectFlockKandangID, recordOffset, recordLimit)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	dailyResults := make([]dto.ProductionResultDTO, len(recordings))
+	for i := range recordings {
+		dailyResults[i] = mapRecordingToProductionResultDTO(recordings[i])
+		if dailyResults[i].StdUniformity == "" {
+			dailyResults[i].StdUniformity = defaultUniformText
+		}
+	}
+
+	weeklyResults := summarizeProductionResults(dailyResults, recordsPerWeek)
+
+	var cumulativeButir int64
+	var cumulativeKg float64
+	for i := range weeklyResults {
+		weeklyResults[i].Woa = float64(defaultStartWoa + i)
+		weeklyResults[i].StdBw = defaultStdBw
+		weeklyResults[i].Bw = defaultBw
+		if weeklyResults[i].StdUniformity == "" {
+			weeklyResults[i].StdUniformity = defaultUniformText
+		}
+
+		cumulativeButir += weeklyResults[i].ButiranJumlah
+		weeklyResults[i].TotalButir = cumulativeButir
+
+		cumulativeKg += weeklyResults[i].KgJumlah
+		weeklyResults[i].TotalKg = cumulativeKg
+	}
+
+	totalWeeks := int64(math.Ceil(float64(totalRecordings) / float64(recordsPerWeek)))
+
+	return weeklyResults, totalWeeks, nil
+}
+
+func mapRecordingToProductionResultDTO(record entity.Recording) dto.ProductionResultDTO {
+	result := dto.ProductionResultDTO{
+		CreatedAt:     record.CreatedAt,
+		UpdatedAt:     record.UpdatedAt,
+		StdUniformity: "90% up",
+		DepKum:        valueOrZero(record.CumDepletionRate),
+		DepStd:        valueOrZero(record.TotalDepletionQty),
+		Fcr:           valueOrZero(record.FcrValue),
+		Hh:            valueOrZero(record.TotalChickQty),
+	}
+
+	if record.Day != nil {
+		result.Woa = float64(*record.Day)
+	}
+	if record.CumIntake != nil {
+		result.Fi = float64(*record.CumIntake)
+	}
+
+	avgWeight := calculateAverageBodyWeight(record.BodyWeights)
+	if avgWeight > 0 {
+		result.Bw = avgWeight
+	}
+
+	eggSummary := summarizeEggs(record.Eggs)
+	result.ButiranUtuh = eggSummary.Utuh
+	result.ButiranPutih = eggSummary.Putih
+	result.ButiranRetak = eggSummary.Retak
+	result.ButiranPecah = eggSummary.Pecah
+	result.ButiranJumlah = eggSummary.TotalQty
+	result.TotalButir = eggSummary.TotalQty
+	result.KgUtuh = eggSummary.KgUtuh
+	result.KgPutih = eggSummary.KgPutih
+	result.KgRetak = eggSummary.KgRetak
+	result.KgPecah = eggSummary.KgPecah
+	result.KgJumlah = eggSummary.TotalKg
+	result.TotalKg = eggSummary.TotalKg
+
+	if eggSummary.TotalQty > 0 {
+		total := float64(eggSummary.TotalQty)
+		result.PersenUtuh = roundFloat((float64(result.ButiranUtuh)/total)*100, 2)
+		result.PersenPutih = roundFloat((float64(result.ButiranPutih)/total)*100, 2)
+		result.PersenRetak = roundFloat((float64(result.ButiranRetak)/total)*100, 2)
+		result.PersenPecah = roundFloat((float64(result.ButiranPecah)/total)*100, 2)
+		result.Ew = (eggSummary.TotalKg * 1000) / total
+		result.Em = eggSummary.TotalKg
+	}
+
+	return result
+}
+
+func calculateAverageBodyWeight(bodyWeights []entity.RecordingBW) float64 {
+	var totalQty float64
+	var totalWeight float64
+
+	for _, bw := range bodyWeights {
+		totalQty += bw.Qty
+		if bw.TotalWeight > 0 {
+			totalWeight += bw.TotalWeight
+		} else {
+			totalWeight += bw.AvgWeight * bw.Qty
+		}
+	}
+
+	if totalQty == 0 {
+		return 0
+	}
+
+	return totalWeight / totalQty
+}
+
+type eggSummary struct {
+	TotalQty int64
+	TotalKg  float64
+
+	Utuh  int64
+	Putih int64
+	Retak int64
+	Pecah int64
+
+	KgUtuh  float64
+	KgPutih float64
+	KgRetak float64
+	KgPecah float64
+}
+
+func summarizeEggs(eggs []entity.RecordingEgg) eggSummary {
+	var summary eggSummary
+
+	for _, egg := range eggs {
+		qty := int64(egg.Qty)
+		weightKg := valueOrZero(egg.Weight)
+
+		summary.TotalQty += qty
+		summary.TotalKg += weightKg
+
+		if flagType, ok := getEggFlagType(egg); ok {
+			switch flagType {
+			case utils.FlagTelurUtuh:
+				summary.Utuh += qty
+				summary.KgUtuh += weightKg
+			case utils.FlagTelurPutih:
+				summary.Putih += qty
+				summary.KgPutih += weightKg
+			case utils.FlagTelurRetak:
+				summary.Retak += qty
+				summary.KgRetak += weightKg
+			case utils.FlagTelurPecah:
+				summary.Pecah += qty
+				summary.KgPecah += weightKg
+			}
+		}
+	}
+
+	return summary
+}
+
+func valueOrZero(value *float64) float64 {
+	if value == nil {
+		return 0
+	}
+	return *value
+}
+
+func roundFloat(val float64, precision int) float64 {
+	if precision < 0 {
+		return val
+	}
+	factor := math.Pow(10, float64(precision))
+	return math.Round(val*factor) / factor
+}
+
+func getEggFlagType(egg entity.RecordingEgg) (utils.FlagType, bool) {
+	if egg.ProductFlagName == nil || *egg.ProductFlagName == "" {
+		return "", false
+	}
+
+	flagType := utils.FlagType(*egg.ProductFlagName)
+	switch flagType {
+	case utils.FlagTelurUtuh, utils.FlagTelurPutih, utils.FlagTelurRetak, utils.FlagTelurPecah:
+		return flagType, true
+	}
+
+	return "", false
+}
+
+func summarizeProductionResults(daily []dto.ProductionResultDTO, groupSize int) []dto.ProductionResultDTO {
+	if groupSize <= 0 || len(daily) == 0 {
+		return daily
+	}
+
+	result := make([]dto.ProductionResultDTO, 0, (len(daily)+groupSize-1)/groupSize)
+	for i := 0; i < len(daily); i += groupSize {
+		end := i + groupSize
+		if end > len(daily) {
+			end = len(daily)
+		}
+		result = append(result, aggregateProductionResultGroup(daily[i:end]))
+	}
+
+	return result
+}
+
+func aggregateProductionResultGroup(group []dto.ProductionResultDTO) dto.ProductionResultDTO {
+	count := len(group)
+	if count == 0 {
+		return dto.ProductionResultDTO{}
+	}
+
+	agg := dto.ProductionResultDTO{
+		CreatedAt:     group[0].CreatedAt,
+		UpdatedAt:     group[0].UpdatedAt,
+		StdUniformity: group[0].StdUniformity,
+	}
+
+	var sumBw, sumStdBw, sumUniformity float64
+	var sumDepStd float64
+	var sumKgUtuh, sumKgPutih, sumKgRetak, sumKgPecah float64
+	var sumKgJumlah, sumTotalKg float64
+	var sumPersenUtuh, sumPersenPutih, sumPersenRetak, sumPersenPecah float64
+	var percentSamples int
+	var sumHd, sumHdStd float64
+	var sumFi, sumFiStd float64
+	var sumEm, sumEmStd float64
+	var sumEw, sumEwStd float64
+	var sumFcr, sumFcrStd float64
+	var sumHh, sumHhStd float64
+
+	var sumButiranUtuh, sumButiranPutih int64
+	var sumButiranRetak, sumButiranPecah int64
+	var sumButiranJumlah, sumTotalButir int64
+
+	for _, item := range group {
+		sumBw += item.Bw
+		sumStdBw += item.StdBw
+		sumUniformity += item.Uniformity
+		sumDepStd += item.DepStd
+		sumKgUtuh += item.KgUtuh
+		sumKgPutih += item.KgPutih
+		sumKgRetak += item.KgRetak
+		sumKgPecah += item.KgPecah
+		sumKgJumlah += item.KgJumlah
+		sumTotalKg += item.TotalKg
+		if item.ButiranJumlah > 0 {
+			sumPersenUtuh += item.PersenUtuh
+			sumPersenPutih += item.PersenPutih
+			sumPersenRetak += item.PersenRetak
+			sumPersenPecah += item.PersenPecah
+			percentSamples++
+		}
+		sumHd += item.Hd
+		sumHdStd += item.HdStd
+		sumFi += item.Fi
+		sumFiStd += item.FiStd
+		sumEm += item.Em
+		sumEmStd += item.EmStd
+		sumEw += item.Ew
+		sumEwStd += item.EwStd
+		sumFcr += item.Fcr
+		sumFcrStd += item.FcrStd
+		sumHh += item.Hh
+		sumHhStd += item.HhStd
+
+		sumButiranUtuh += item.ButiranUtuh
+		sumButiranPutih += item.ButiranPutih
+		sumButiranRetak += item.ButiranRetak
+		sumButiranPecah += item.ButiranPecah
+		sumButiranJumlah += item.ButiranJumlah
+		sumTotalButir += item.TotalButir
+	}
+
+	divider := float64(count)
+	if divider == 0 {
+		divider = 1
+	}
+
+	agg.Bw = sumBw / divider
+	agg.StdBw = sumStdBw / divider
+	agg.Uniformity = sumUniformity / divider
+	agg.DepKum = group[count-1].DepKum
+	agg.DepStd = sumDepStd / divider
+	agg.KgUtuh = sumKgUtuh
+	agg.KgPutih = sumKgPutih
+	agg.KgRetak = sumKgRetak
+	agg.KgPecah = sumKgPecah
+	agg.KgJumlah = sumKgJumlah
+	agg.TotalKg = sumTotalKg
+
+	agg.ButiranUtuh = sumButiranUtuh
+	agg.ButiranPutih = sumButiranPutih
+	agg.ButiranRetak = sumButiranRetak
+	agg.ButiranPecah = sumButiranPecah
+	agg.ButiranJumlah = sumButiranJumlah
+	agg.TotalButir = sumTotalButir
+
+	if percentSamples > 0 {
+		percentDivider := float64(percentSamples)
+		agg.PersenUtuh = roundFloat(sumPersenUtuh/percentDivider, 2)
+		agg.PersenPutih = roundFloat(sumPersenPutih/percentDivider, 2)
+		agg.PersenRetak = roundFloat(sumPersenRetak/percentDivider, 2)
+		agg.PersenPecah = roundFloat(sumPersenPecah/percentDivider, 2)
+	}
+
+	agg.Hd = sumHd / divider
+	agg.HdStd = sumHdStd / divider
+	agg.Fi = sumFi / divider
+	agg.FiStd = sumFiStd / divider
+	agg.Em = sumEm / divider
+	agg.EmStd = sumEmStd / divider
+	agg.Ew = sumEw / divider
+	agg.EwStd = sumEwStd / divider
+	agg.Fcr = sumFcr / divider
+	agg.FcrStd = sumFcrStd / divider
+	agg.Hh = sumHh / divider
+	agg.HhStd = sumHhStd / divider
+
+	return agg
+}
+
 func (s *repportService) GetPurchaseSupplier(c *fiber.Ctx, params *validation.PurchaseSupplierQuery) ([]dto.PurchaseSupplierDTO, int64, error) {
 	if err := s.Validate.Struct(params); err != nil {
 		return nil, 0, err