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

internal/modules/production/chickins/services/chickin.service.go

@@ -200,9 +200,9 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) ([]enti
 
 		newChikins = append(newChikins, newChickin)
 
-		totalPopulationQty, err := s.ProjectflockPopulationRepo.GetTotalQtyByProjectFlockKandangID(c.Context(), req.ProjectFlockKandangId)
+		totalPopulationQty, err := s.ProjectflockPopulationRepo.GetTotalQtyByProductWarehouseID(c.Context(), chickinReq.ProductWarehouseId)
 		if err != nil {
-			return nil, fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get total population quantity for project_flock_kandang %d", req.ProjectFlockKandangId))
+			return nil, fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Failed to get total population quantity for product warehouse %d", chickinReq.ProductWarehouseId))
 		}
 
 		availableQty := productWarehouse.Quantity - totalPopulationQty
@@ -584,7 +584,6 @@ func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entit
 	return updated, nil
 }
 
-// autoAddFlagToProduct adds target flag to product if not already present (idempotent)
 func (s *chickinService) autoAddFlagToProduct(ctx context.Context, tx *gorm.DB, productID uint, targetFlag utils.FlagType) error {
 	if s.ProductRepo == nil {
 		return nil

internal/modules/production/project-flock-kandangs/dto/project_flock_kandang.dto.go

@@ -1,6 +1,7 @@
 package dto
 
 import (
+	"strconv"
 	"time"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -53,6 +54,7 @@ type ProjectFlockKandangListDTO struct {
 	ProjectFlockKandangRelationDTO
 	ProjectFlock    *ProjectFlockDTO                 `json:"project_flock,omitempty"`
 	Kandang         *kandangDTO.KandangRelationDTO   `json:"kandang,omitempty"`
+	NameWithPeriod  string                           `json:"name_with_period"`
 	CreatedUser     *userDTO.UserRelationDTO         `json:"created_user,omitempty"`
 	CreatedAt       time.Time                        `json:"created_at"`
 	Approval        *approvalDTO.ApprovalRelationDTO `json:"approval,omitempty"`
@@ -104,6 +106,7 @@ func ToProjectFlockKandangDetailDTOWithAvailableQty(e entity.ProjectFlockKandang
 		ProjectFlockKandangRelationDTO: ToProjectFlockKandangRelationDTO(e),
 		ProjectFlock:                   toProjectFlockDTO(projectFlockSummary),
 		Kandang:                        toKandangRelation(e.Kandang),
+		NameWithPeriod:                 toNameWithPeriod(e.Kandang, e.Period),
 		CreatedAt:                      e.CreatedAt,
 		CreatedUser:                    toCreatedUserDTO(e.ProjectFlock),
 		Approval:                       toApprovalDTOSelector(e, func(x entity.ProjectFlockKandang) *entity.Approval { return x.LatestProjectFlockApproval }),
@@ -126,6 +129,16 @@ func toKandangRelation(kandang entity.Kandang) *kandangDTO.KandangRelationDTO {
 	return &mapped
 }
 
+func toNameWithPeriod(kandang entity.Kandang, period int) string {
+	if kandang.Name == "" {
+		return ""
+	}
+	if period == 0 {
+		return kandang.Name
+	}
+	return kandang.Name + " Period " + strconv.Itoa(period)
+}
+
 func toApprovalDTOSelector(
 	e entity.ProjectFlockKandang, selector func(entity.ProjectFlockKandang) *entity.Approval) *approvalDTO.ApprovalRelationDTO {
 	approval := selector(e)
@@ -147,6 +160,7 @@ func ToProjectFlockKandangListDTO(e entity.ProjectFlockKandang) ProjectFlockKand
 		ProjectFlockKandangRelationDTO: ToProjectFlockKandangRelationDTO(e),
 		ProjectFlock:                   toProjectFlockDTO(projectFlockSummary),
 		Kandang:                        toKandangRelation(e.Kandang),
+		NameWithPeriod:                 toNameWithPeriod(e.Kandang, e.Period),
 		CreatedAt:                      e.CreatedAt,
 		CreatedUser:                    toCreatedUserDTO(e.ProjectFlock),
 		Approval:                       toApprovalDTOSelector(e, func(x entity.ProjectFlockKandang) *entity.Approval { return x.LatestProjectFlockApproval }),

internal/modules/production/project_flocks/controllers/projectflock.controller.go

@@ -287,6 +287,11 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 	} else {
 		dtoResult.AvailableQuantity = population
 	}
+	if chickinDate, err := u.ProjectflockService.GetProjectFlockKandangChickinDate(c, result.Id); err != nil {
+		return err
+	} else if chickinDate != nil {
+		dtoResult.ChickInDate = chickinDate
+	}
 	if warehouse, werr := u.ProjectflockService.GetWarehouseByKandangID(c, result.KandangId); werr != nil {
 		return werr
 	} else if warehouse != nil {

internal/modules/production/project_flocks/dto/projectflock_kandang.dto.go

@@ -1,6 +1,8 @@
 package dto
 
 import (
+	"time"
+
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	areaDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/areas/dto"
 	fcrDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/fcrs/dto"
@@ -38,6 +40,7 @@ type ProjectFlockKandangDTO struct {
 	ProjectFlock          *ProjectFlockWithPivotDTO          `json:"project_flock,omitempty"`
 	AvailableQuantity     float64                            `json:"available_quantity"`
 	Population            *float64                           `json:"population,omitempty"`
+	ChickInDate           *time.Time                         `json:"chick_in_date,omitempty"`
 }
 
 func ToProjectFlockKandangDTO(e entity.ProjectFlockKandang) ProjectFlockKandangDTO {

internal/modules/production/project_flocks/repositories/project_flock_population_repository.go

@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+	"math"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -16,6 +17,7 @@ type ProjectFlockPopulationRepository interface {
 	GetTotalQtyByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (float64, error)
 	GetTotalQtyByProductWarehouseID(ctx context.Context, productWarehouseID uint) (float64, error)
 	GetAvailableQtyByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (float64, error)
+	GetTotalChickInByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (int64, error)
 
 	CreateOne(ctx context.Context, entity *entity.ProjectFlockPopulation, modifier func(*gorm.DB) *gorm.DB) error
 	PatchOne(ctx context.Context, id uint, updates map[string]any, modifier func(*gorm.DB) *gorm.DB) error
@@ -111,7 +113,7 @@ func (r *projectFlockPopulationRepositoryImpl) GetTotalQtyByProductWarehouseID(c
 	err := r.DB().WithContext(ctx).
 		Model(&entity.ProjectFlockPopulation{}).
 		Where("product_warehouse_id = ?", productWarehouseID).
-		Select("COALESCE(SUM(total_qty), 0)").
+		Select("COALESCE(SUM(total_qty - total_used_qty), 0)").
 		Scan(&total).Error
 	if err != nil {
 		return 0, err
@@ -135,3 +137,22 @@ func (r *projectFlockPopulationRepositoryImpl) GetAvailableQtyByProjectFlockKand
 	}
 	return total, nil
 }
+
+func (r *projectFlockPopulationRepositoryImpl) GetTotalChickInByProjectFlockKandangID(ctx context.Context, projectFlockKandangID uint) (int64, error) {
+	var total float64
+	err := r.DB().WithContext(ctx).
+		Table("project_flock_populations").
+		Select("COALESCE(SUM(project_flock_populations.total_qty - project_flock_populations.total_used_qty), 0) AS total_qty").
+		Joins("JOIN project_chickins ON project_chickins.id = project_flock_populations.project_chickin_id").
+		Where("project_chickins.project_flock_kandang_id = ?", projectFlockKandangID).
+		Scan(&total).Error
+	if err != nil {
+		return 0, err
+	}
+
+	if total < 0 {
+		total = 0
+	}
+
+	return int64(math.Round(total)), nil
+}

internal/modules/production/project_flocks/services/projectflock.service.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"time"
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
@@ -42,6 +43,7 @@ type ProjectflockService interface {
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	GetProjectFlockKandangByProjectAndKandang(ctx *fiber.Ctx, projectFlockID uint, kandangID uint) (*entity.ProjectFlockKandang, float64, error)
 	GetProjectFlockKandangPopulation(ctx *fiber.Ctx, projectFlockKandangID uint) (float64, error)
+	GetProjectFlockKandangChickinDate(ctx *fiber.Ctx, projectFlockKandangID uint) (*time.Time, error)
 	GetPeriodSummary(ctx *fiber.Ctx, locationID uint) ([]KandangPeriodSummary, error)
 	GetProjectPeriods(ctx *fiber.Ctx, projectIDs []uint) (map[uint]int, error)
 	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlock, error)
@@ -473,6 +475,35 @@ func (s projectflockService) GetProjectFlockKandangPopulation(ctx *fiber.Ctx, pr
 	return total, nil
 }
 
+func (s projectflockService) GetProjectFlockKandangChickinDate(ctx *fiber.Ctx, projectFlockKandangID uint) (*time.Time, error) {
+	if s.PopulationRepo == nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Project flock population repository is not configured")
+	}
+	if projectFlockKandangID == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
+	}
+
+	populations, err := s.PopulationRepo.GetByProjectFlockKandangID(ctx.Context(), projectFlockKandangID)
+	if err != nil {
+		s.Log.Errorf("Failed to fetch populations for project flock kandang %d: %+v", projectFlockKandangID, err)
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock kandang chick in date")
+	}
+
+	var earliest *time.Time
+	for _, pop := range populations {
+		if pop.ProjectChickin == nil || pop.ProjectChickin.ChickInDate.IsZero() {
+			continue
+		}
+		chickinDate := pop.ProjectChickin.ChickInDate
+		if earliest == nil || chickinDate.Before(*earliest) {
+			copy := chickinDate
+			earliest = &copy
+		}
+	}
+
+	return earliest, nil
+}
+
 func (s projectflockService) GetProjectFlockKandangByParams(ctx *fiber.Ctx, idStr string, projectFlockIdStr string, kandangIdStr string) (*entity.ProjectFlockKandang, float64, error) {
 	idStr = strings.TrimSpace(idStr)
 	projectFlockIdStr = strings.TrimSpace(projectFlockIdStr)

internal/modules/production/recordings/controllers/recording.controller.go

@@ -3,6 +3,8 @@ package controller
 import (
 	"math"
 	"strconv"
+	"strings"
+	"time"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
@@ -26,8 +28,9 @@ func (u *RecordingController) GetAll(c *fiber.Ctx) error {
 	projectFlockID := c.QueryInt("project_flock_kandang_id", 0)
 
 	query := &validation.Query{
-		Page:  c.QueryInt("page", 1),
-		Limit: c.QueryInt("limit", 10),
+		Page:   c.QueryInt("page", 1),
+		Limit:  c.QueryInt("limit", 10),
+		Search: c.Query("search"),
 	}
 	if projectFlockID > 0 {
 		query.ProjectFlockKandangId = uint(projectFlockID)
@@ -81,7 +84,16 @@ func (u *RecordingController) GetNextDay(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
 	}
 
-	nextDay, err := u.RecordingService.GetNextDay(c, uint(projectFlockID))
+	recordTime := time.Now().UTC()
+	if recordDate := strings.TrimSpace(c.Query("record_date")); recordDate != "" {
+		parsed, err := time.Parse("2006-01-02", recordDate)
+		if err != nil {
+			return fiber.NewError(fiber.StatusBadRequest, "record_date must be in YYYY-MM-DD format")
+		}
+		recordTime = parsed.UTC()
+	}
+
+	nextDay, err := u.RecordingService.GetNextDay(c, uint(projectFlockID), recordTime)
 	if err != nil {
 		return err
 	}

internal/modules/production/recordings/dto/recording.dto.go

@@ -15,13 +15,13 @@ import (
 // === DTO Structs ===
 
 type RecordingProjectFlockDTO struct {
-	ProjectFlockKandangId uint                              `json:"project_flock_kandang_id"`
-	FlockName             string                            `json:"flock_name"`
-	ProjectFlockCategory  string                            `json:"project_flock_category"`
-	Period                int                               `json:"period"`
-	ProductionStandart    *RecordingProductionStandardDTO   `json:"production_standart,omitempty"`
-	Fcr                   *RecordingFcrDTO                  `json:"fcr,omitempty"`
-	TotalChickQty         float64                           `json:"total_chick_qty"`
+	ProjectFlockKandangId uint                            `json:"project_flock_kandang_id"`
+	FlockName             string                          `json:"flock_name"`
+	ProjectFlockCategory  string                          `json:"project_flock_category"`
+	Period                int                             `json:"period"`
+	ProductionStandart    *RecordingProductionStandardDTO `json:"production_standart,omitempty"`
+	Fcr                   *RecordingFcrDTO                `json:"fcr,omitempty"`
+	TotalChickQty         float64                         `json:"total_chick_qty"`
 }
 
 type RecordingProductionStandardDTO struct {
@@ -53,6 +53,13 @@ type RecordingLocationDTO struct {
 	Address string `json:"address"`
 }
 
+type RecordingKandangDTO struct {
+	Id       uint    `json:"id"`
+	Name     string  `json:"name"`
+	Status   string  `json:"status"`
+	Capacity float64 `json:"capacity"`
+}
+
 type RecordingWarehouseDTO struct {
 	Id       uint                  `json:"id"`
 	Name     string                `json:"name"`
@@ -82,12 +89,14 @@ type RecordingListDTO struct {
 	CreatedUser *userDTO.UserRelationDTO `json:"created_user,omitempty"`
 	CreatedAt   time.Time                `json:"created_at"`
 	UpdatedAt   time.Time                `json:"updated_at"`
+	Kandang     *RecordingKandangDTO     `json:"kandang,omitempty"`
+	Location    *RecordingLocationDTO    `json:"location,omitempty"`
 }
 
 type RecordingDetailDTO struct {
 	RecordingListDTO
-	Warehouse       *RecordingWarehouseDTO `json:"warehouse,omitempty"`
-	ProductCategory string                 `json:"product_category"`
+	ProductCategory string                  `json:"product_category"`
+	Warehouse       *RecordingWarehouseDTO  `json:"warehouse,omitempty"`
 	Depletions      []RecordingDepletionDTO `json:"depletions"`
 	Stocks          []RecordingStockDTO     `json:"stocks"`
 	Eggs            []RecordingEggDTO       `json:"eggs"`
@@ -133,11 +142,11 @@ func ToRecordingDetailDTO(e entity.Recording) RecordingDetailDTO {
 
 	return RecordingDetailDTO{
 		RecordingListDTO: listDTO,
-		Warehouse:       recordingWarehouseDTO(e),
-		ProductCategory: recordingProductCategory(e),
-		Depletions:      ToRecordingDepletionDTOs(e.Depletions),
-		Stocks:          ToRecordingStockDTOs(e.Stocks),
-		Eggs:            ToRecordingEggDTOs(e.Eggs),
+		ProductCategory:  recordingProductCategory(e),
+		Warehouse:        recordingWarehouseDTO(e),
+		Depletions:       ToRecordingDepletionDTOs(e.Depletions),
+		Stocks:           ToRecordingStockDTOs(e.Stocks),
+		Eggs:             ToRecordingEggDTOs(e.Eggs),
 	}
 }
 
@@ -203,6 +212,8 @@ func toRecordingListDTO(e entity.Recording) RecordingListDTO {
 		CreatedAt:            e.CreatedAt,
 		UpdatedAt:            e.UpdatedAt,
 		CreatedUser:          createdUser,
+		Kandang:              recordingKandangDTO(e),
+		Location:             recordingKandangLocationDTO(e),
 	}
 }
 
@@ -214,20 +225,20 @@ func toRecordingRelationDTO(e entity.Recording) RecordingRelationDTO {
 	}
 
 	return RecordingRelationDTO{
-		Id:                 e.Id,
-		ProjectFlock:       toRecordingProjectFlockDTO(e),
-		RecordDatetime:     e.RecordDatetime,
-		Day:                intValue(e.Day),
-		TotalDepletionQty:  floatValue(e.TotalDepletionQty),
-		CumDepletionRate:   floatValue(e.CumDepletionRate),
-		CumIntake:          intValue(e.CumIntake),
-		FcrValue:           floatValue(e.FcrValue),
-		HenDay:             floatValue(e.HenDay),
-		HenHouse:           floatValue(e.HenHouse),
-		FeedIntake:         floatValue(e.FeedIntake),
-		EggMass:            floatValue(e.EggMass),
-		EggWeight:          floatValue(e.EggWeight),
-		Approval:           latestApproval,
+		Id:                e.Id,
+		ProjectFlock:      toRecordingProjectFlockDTO(e),
+		RecordDatetime:    e.RecordDatetime,
+		Day:               intValue(e.Day),
+		TotalDepletionQty: floatValue(e.TotalDepletionQty),
+		CumDepletionRate:  floatValue(e.CumDepletionRate),
+		CumIntake:         intValue(e.CumIntake),
+		FcrValue:          floatValue(e.FcrValue),
+		HenDay:            floatValue(e.HenDay),
+		HenHouse:          floatValue(e.HenHouse),
+		FeedIntake:        floatValue(e.FeedIntake),
+		EggMass:           floatValue(e.EggMass),
+		EggWeight:         floatValue(e.EggWeight),
+		Approval:          latestApproval,
 	}
 }
 
@@ -321,6 +332,34 @@ func recordingWarehouseDTO(e entity.Recording) *RecordingWarehouseDTO {
 	return mapWarehouseDTO(&pw.Warehouse)
 }
 
+func recordingKandangDTO(e entity.Recording) *RecordingKandangDTO {
+	if e.ProjectFlockKandang == nil || e.ProjectFlockKandang.Kandang.Id == 0 {
+		return nil
+	}
+	kandang := e.ProjectFlockKandang.Kandang
+	return &RecordingKandangDTO{
+		Id:       kandang.Id,
+		Name:     kandang.Name,
+		Status:   kandang.Status,
+		Capacity: kandang.Capacity,
+	}
+}
+
+func recordingKandangLocationDTO(e entity.Recording) *RecordingLocationDTO {
+	if e.ProjectFlockKandang == nil || e.ProjectFlockKandang.Kandang.Id == 0 {
+		return nil
+	}
+	location := e.ProjectFlockKandang.Kandang.Location
+	if location.Id == 0 {
+		return nil
+	}
+	return &RecordingLocationDTO{
+		Id:      location.Id,
+		Name:    location.Name,
+		Address: location.Address,
+	}
+}
+
 func primaryProductWarehouse(e entity.Recording) *entity.ProductWarehouse {
 	if len(e.Stocks) > 0 {
 		pw := e.Stocks[0].ProductWarehouse

internal/modules/production/recordings/module.go

@@ -16,6 +16,7 @@ import (
 	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	rRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	sRecording "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/services"
+	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
 
@@ -31,6 +32,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	projectFlockPopulationRepo := rProjectFlock.NewProjectFlockPopulationRepository(db)
 	productWarehouseRepo := rProductWarehouse.NewProductWarehouseRepository(db)
 	stockAllocationRepo := commonRepo.NewStockAllocationRepository(db)
+	stockLogRepo := rStockLogs.NewStockLogRepository(db)
 	productionStandardRepo := rProductionStandard.NewProductionStandardRepository(db)
 	productionStandardDetailRepo := rProductionStandard.NewProductionStandardDetailRepository(db)
 	standardGrowthDetailRepo := rProductionStandard.NewStandardGrowthDetailRepository(db)
@@ -43,6 +45,22 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 	)
 
 	fifoService := commonSvc.NewFifoService(db, stockAllocationRepo, productWarehouseRepo, utils.Log)
+	if err := fifoService.RegisterStockable(fifo.StockableConfig{
+		Key:   fifo.StockableKeyRecordingEgg,
+		Table: "recording_eggs",
+		Columns: fifo.StockableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "product_warehouse_id",
+			TotalQuantity:      "total_qty",
+			TotalUsedQuantity:  "total_used",
+			CreatedAt:          "created_at",
+		},
+		OrderBy: []string{"created_at ASC", "id ASC"},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording egg stockable workflow: %v", err))
+		}
+	}
 	if err := fifoService.RegisterUsable(fifo.UsableConfig{
 		Key:   fifo.UsableKeyRecordingStock,
 		Table: "recording_stocks",
@@ -58,6 +76,28 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 			panic(fmt.Sprintf("failed to register recording usable workflow: %v", err))
 		}
 	}
+	if err := fifoService.RegisterUsable(fifo.UsableConfig{
+		Key:   fifo.UsableKeyRecordingDepletion,
+		Table: "recording_depletions",
+		Columns: fifo.UsableColumns{
+			ID:                 "id",
+			ProductWarehouseID: "source_product_warehouse_id",
+			UsageQuantity:      "qty",
+			PendingQuantity:    "pending_qty",
+			CreatedAt:          "id",
+		},
+		ExcludedStockables: []fifo.StockableKey{
+			fifo.StockableKeyTransferToLayingIn,
+			fifo.StockableKeyStockTransferIn,
+			fifo.StockableKeyAdjustmentIn,
+			fifo.StockableKeyPurchaseItems,
+			fifo.StockableKeyRecordingEgg,
+		},
+	}); err != nil {
+		if !strings.Contains(strings.ToLower(err.Error()), "already registered") {
+			panic(fmt.Sprintf("failed to register recording depletion usable workflow: %v", err))
+		}
+	}
 
 	approvalRepo := commonRepo.NewApprovalRepository(db)
 	approvalService := commonSvc.NewApprovalService(approvalRepo)
@@ -75,6 +115,7 @@ func (RecordingModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate
 		approvalRepo,
 		approvalService,
 		fifoService,
+		stockLogRepo,
 		productionStandardService,
 		validate,
 	)

internal/modules/production/recordings/repositories/recording.repository.go

@@ -17,6 +17,7 @@ type RecordingRepository interface {
 	repository.BaseRepository[entity.Recording]
 
 	WithRelations(db *gorm.DB) *gorm.DB
+	ApplySearchFilters(db *gorm.DB, rawSearch string) *gorm.DB
 	GetLatestByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (*entity.Recording, error)
 	GenerateNextDay(tx *gorm.DB, projectFlockKandangId uint) (int, error)
 
@@ -24,6 +25,7 @@ type RecordingRepository interface {
 	DeleteStocks(tx *gorm.DB, recordingID uint) error
 	ListStocks(tx *gorm.DB, recordingID uint) ([]entity.RecordingStock, error)
 	UpdateStockUsage(tx *gorm.DB, stockID uint, usageQty, pendingQty float64) error
+	UpdateDepletionPending(tx *gorm.DB, depletionID uint, pendingQty float64) error
 
 	CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error
 	DeleteDepletions(tx *gorm.DB, recordingID uint) error
@@ -44,6 +46,7 @@ type RecordingRepository interface {
 	GetEggSummaryByRecording(tx *gorm.DB, recordingID uint) (totalQty float64, totalWeightGrams float64, err error)
 	GetCumulativeEggQtyByProjectFlockKandang(tx *gorm.DB, projectFlockKandangId uint, recordTime time.Time) (float64, error)
 	GetFcrStandardNumber(tx *gorm.DB, fcrId uint, currentWeightKg float64) (float64, bool, error)
+	GetTotalWeightProducedFromUniformityByProjectFlockID(ctx context.Context, projectFlockID uint) (float64, error)
 	GetProductionWeightAndQtyByProjectFlockID(ctx context.Context, projectFlockID uint) (totalWeight float64, totalQty float64, err error)
 	GetTotalDepletionByProjectFlockID(ctx context.Context, projectFlockID uint) (totalDepletion float64, err error)
 	GetLatestAvgWeightByProjectFlockID(ctx context.Context, projectFlockID uint) (avgWeight float64, err error)
@@ -83,6 +86,7 @@ func (r *RecordingRepositoryImpl) WithRelations(db *gorm.DB) *gorm.DB {
 		Preload("CreatedUser").
 		Preload("ProjectFlockKandang").
 		Preload("ProjectFlockKandang.Kandang").
+		Preload("ProjectFlockKandang.Kandang.Location").
 		Preload("ProjectFlockKandang.ProjectFlock").
 		Preload("ProjectFlockKandang.ProjectFlock.ProductionStandard").
 		Preload("ProjectFlockKandang.ProjectFlock.Fcr").
@@ -106,6 +110,42 @@ func (r *RecordingRepositoryImpl) WithRelations(db *gorm.DB) *gorm.DB {
 		Preload("Eggs.ProductWarehouse.Warehouse.Location")
 }
 
+func (r *RecordingRepositoryImpl) ApplySearchFilters(db *gorm.DB, rawSearch string) *gorm.DB {
+	normalized := strings.ToLower(strings.TrimSpace(rawSearch))
+	if normalized == "" {
+		return db
+	}
+
+	likeQuery := "%" + normalized + "%"
+	subQuery := db.Session(&gorm.Session{NewDB: true}).
+		Table("recordings").
+		Select("recordings.id").
+		Joins("LEFT JOIN project_flock_kandangs pfk ON pfk.id = recordings.project_flock_kandangs_id").
+		Joins("LEFT JOIN project_flocks pf ON pf.id = pfk.project_flock_id").
+		Joins("LEFT JOIN kandangs k ON k.id = pfk.kandang_id").
+		Joins("LEFT JOIN locations l ON l.id = k.location_id").
+		Joins("LEFT JOIN recording_stocks rs ON rs.recording_id = recordings.id").
+		Joins("LEFT JOIN recording_depletions rd ON rd.recording_id = recordings.id").
+		Joins("LEFT JOIN recording_eggs re ON re.recording_id = recordings.id").
+		Joins("LEFT JOIN product_warehouses pws ON pws.id = rs.product_warehouse_id").
+		Joins("LEFT JOIN product_warehouses pwd ON pwd.id = rd.product_warehouse_id").
+		Joins("LEFT JOIN product_warehouses pwe ON pwe.id = re.product_warehouse_id").
+		Joins("LEFT JOIN warehouses ws ON ws.id = pws.warehouse_id").
+		Joins("LEFT JOIN warehouses wd ON wd.id = pwd.warehouse_id").
+		Joins("LEFT JOIN warehouses we ON we.id = pwe.warehouse_id").
+		Where(`
+			LOWER(pf.flock_name) LIKE ?
+			OR LOWER(k.name) LIKE ?
+			OR LOWER(l.name) LIKE ?
+			OR LOWER(l.address) LIKE ?
+			OR LOWER(ws.name) LIKE ?
+			OR LOWER(wd.name) LIKE ?
+			OR LOWER(we.name) LIKE ?`,
+			likeQuery, likeQuery, likeQuery, likeQuery, likeQuery, likeQuery, likeQuery,
+		)
+	return db.Where("recordings.id IN (?)", subQuery)
+}
+
 func (r *RecordingRepositoryImpl) GetLatestByProjectFlockKandangID(ctx context.Context, projectFlockKandangId uint) (*entity.Recording, error) {
 	if projectFlockKandangId == 0 {
 		return nil, errors.New("project_flock_kandang_id is required")
@@ -131,6 +171,7 @@ func (r *RecordingRepositoryImpl) GenerateNextDay(tx *gorm.DB, projectFlockKanda
 	var days []int
 	if err := tx.Model(&entity.Recording{}).
 		Where("project_flock_kandangs_id = ?", projectFlockKandangId).
+		Where("deleted_at IS NULL").
 		Where("day IS NOT NULL").
 		Pluck("day", &days).Error; err != nil {
 		return 0, err
@@ -166,6 +207,12 @@ func (r *RecordingRepositoryImpl) UpdateStockUsage(tx *gorm.DB, stockID uint, us
 		}).Error
 }
 
+func (r *RecordingRepositoryImpl) UpdateDepletionPending(tx *gorm.DB, depletionID uint, pendingQty float64) error {
+	return tx.Model(&entity.RecordingDepletion{}).
+		Where("id = ?", depletionID).
+		Update("pending_qty", pendingQty).Error
+}
+
 func (r *RecordingRepositoryImpl) CreateDepletions(tx *gorm.DB, depletions []entity.RecordingDepletion) error {
 	if len(depletions) == 0 {
 		return nil
@@ -321,38 +368,25 @@ func (r *RecordingRepositoryImpl) GetTotalChickinByProjectFlockKandang(tx *gorm.
 }
 
 func (r *RecordingRepositoryImpl) GetFeedUsageInGrams(tx *gorm.DB, recordingID uint) (float64, error) {
-	var rows []struct {
+	var result struct {
 		TotalQty float64
-		UomName  string
 	}
 
 	if err := tx.
 		Table("recording_stocks").
-		Select("COALESCE(recording_stocks.usage_qty, 0) + COALESCE(recording_stocks.pending_qty, 0) AS total_qty, LOWER(uoms.name) AS uom_name").
+		Select("COALESCE(SUM(COALESCE(recording_stocks.usage_qty, 0) + COALESCE(recording_stocks.pending_qty, 0)), 0) AS total_qty").
 		Joins("JOIN product_warehouses ON product_warehouses.id = recording_stocks.product_warehouse_id").
 		Joins("JOIN products ON products.id = product_warehouses.product_id").
-		Joins("JOIN uoms ON uoms.id = products.uom_id").
 		Joins("JOIN flags ON flags.flagable_id = products.id AND flags.flagable_type = ? AND UPPER(flags.name) = ?", entity.FlagableTypeProduct, "PAKAN").
 		Where("recording_stocks.recording_id = ?", recordingID).
-		Scan(&rows).Error; err != nil {
+		Scan(&result).Error; err != nil {
 		return 0, err
 	}
 
-	var total float64
-	for _, row := range rows {
-		if row.TotalQty <= 0 {
-			continue
-		}
-		switch strings.TrimSpace(row.UomName) {
-		case "kilogram", "kg", "kilograms", "kilo":
-			total += row.TotalQty * 1000
-		case "gram", "g", "grams":
-			total += row.TotalQty
-		default:
-			total += row.TotalQty
-		}
+	if result.TotalQty <= 0 {
+		return 0, nil
 	}
-	return total, nil
+	return result.TotalQty * 1000, nil
 }
 
 func (r *RecordingRepositoryImpl) GetEggSummaryByRecording(tx *gorm.DB, recordingID uint) (totalQty float64, totalWeightGrams float64, err error) {
@@ -366,7 +400,7 @@ func (r *RecordingRepositoryImpl) GetEggSummaryByRecording(tx *gorm.DB, recordin
 	}
 	err = tx.
 		Table("recording_eggs").
-		Select("COALESCE(SUM(recording_eggs.qty), 0) AS total_qty, COALESCE(SUM(recording_eggs.qty * COALESCE(recording_eggs.weight, 0)), 0) AS total_weight_grams").
+		Select("COALESCE(SUM(recording_eggs.qty), 0) AS total_qty, COALESCE(SUM(COALESCE(recording_eggs.weight, 0) * 1000), 0) AS total_weight_grams").
 		Where("recording_eggs.recording_id = ?", recordingID).
 		Scan(&result).Error
 	if err != nil {
@@ -452,7 +486,7 @@ func (r *RecordingRepositoryImpl) GetTotalEggProductionWeightByProjectFlockID(ct
 	var result float64
 	err := r.DB().WithContext(ctx).
 		Table("recording_eggs").
-		Select("COALESCE(SUM(recording_eggs.qty * recording_eggs.weight), 0) / 1000").
+		Select("COALESCE(SUM(recording_eggs.weight), 0)").
 		Joins("JOIN recordings ON recordings.id = recording_eggs.recording_id").
 		Joins("JOIN project_flock_kandangs ON project_flock_kandangs.id = recordings.project_flock_kandangs_id").
 		Where("project_flock_kandangs.project_flock_id = ?", projectFlockID).
@@ -548,3 +582,30 @@ func nextRecordingDay(days []int) int {
 
 	return len(normalized) + 1
 }
+
+// GetTotalWeightProducedFromUniformityByProjectFlockID calculates total weight produced from uniformity data
+// It takes the latest uniformity record per kandang and calculates: SUM(mean_weight * chick_qty_of_weight / 1000)
+func (r *RecordingRepositoryImpl) GetTotalWeightProducedFromUniformityByProjectFlockID(ctx context.Context, projectFlockID uint) (float64, error) {
+	if projectFlockID == 0 {
+		return 0, nil
+	}
+
+	var result struct {
+		TotalWeight float64
+	}
+
+	err := r.DB().WithContext(ctx).
+		Table("project_flock_kandang_uniformity").
+		Select("COALESCE(SUM((mean_up / 1.10) * chick_qty_of_weight / 1000), 0) as total_weight").
+		Joins("JOIN ("+
+			"	SELECT pfku.project_flock_kandang_id, MAX(pfku.id) as latest_id "+
+			"	FROM project_flock_kandang_uniformity pfku "+
+			"	JOIN project_flock_kandangs pfk ON pfk.id = pfku.project_flock_kandang_id "+
+			"	WHERE pfk.project_flock_id = ? "+
+			"	GROUP BY pfku.project_flock_kandang_id "+
+			") latest ON latest.project_flock_kandang_id = project_flock_kandang_uniformity.project_flock_kandang_id "+
+			"AND project_flock_kandang_uniformity.id = latest.latest_id", projectFlockID).
+		Scan(&result).Error
+
+	return result.TotalWeight, err
+}

internal/modules/production/recordings/services/recording.service.go

@@ -14,6 +14,7 @@ import (
 	rProjectFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/recordings/validations"
+	rStockLogs "gitlab.com/mbugroup/lti-api.git/internal/modules/shared/repositories"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils/fifo"
@@ -31,7 +32,7 @@ import (
 type RecordingService interface {
 	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.Recording, int64, error)
 	GetOne(ctx *fiber.Ctx, id uint) (*entity.Recording, error)
-	GetNextDay(ctx *fiber.Ctx, projectFlockKandangId uint) (int, error)
+	GetNextDay(ctx *fiber.Ctx, projectFlockKandangId uint, recordTime time.Time) (int, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.Recording, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.Recording, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
@@ -39,11 +40,12 @@ type RecordingService interface {
 }
 
 type RecordingFIFOIntegrationService interface {
-	ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error
-	ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error
+	ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
+	ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock, note string, actorID uint) error
 }
 
 var recordingStockUsableKey = fifo.UsableKeyRecordingStock
+var recordingDepletionUsableKey = fifo.UsableKeyRecordingDepletion
 
 type recordingService struct {
 	Log                        *logrus.Logger
@@ -56,6 +58,7 @@ type recordingService struct {
 	ApprovalSvc                commonSvc.ApprovalService
 	ProductionStandardSvc      sProductionStandard.ProductionStandardService
 	FifoSvc                    commonSvc.FifoService
+	StockLogRepo               rStockLogs.StockLogRepository
 }
 
 func NewRecordingService(
@@ -66,6 +69,7 @@ func NewRecordingService(
 	approvalRepo commonRepo.ApprovalRepository,
 	approvalSvc commonSvc.ApprovalService,
 	fifoSvc commonSvc.FifoService,
+	stockLogRepo rStockLogs.StockLogRepository,
 	productionStandardSvc sProductionStandard.ProductionStandardService,
 	validate *validator.Validate,
 ) RecordingService {
@@ -80,6 +84,7 @@ func NewRecordingService(
 		ApprovalSvc:                approvalSvc,
 		ProductionStandardSvc:      productionStandardSvc,
 		FifoSvc:                    fifoSvc,
+		StockLogRepo:               stockLogRepo,
 	}
 }
 
@@ -87,12 +92,14 @@ func NewRecordingFIFOIntegrationService(
 	repo repository.RecordingRepository,
 	productWarehouseRepo rProductWarehouse.ProductWarehouseRepository,
 	fifoSvc commonSvc.FifoService,
+	stockLogRepo rStockLogs.StockLogRepository,
 ) RecordingFIFOIntegrationService {
 	return &recordingService{
 		Log:                  utils.Log,
 		Repository:           repo,
 		ProductWarehouseRepo: productWarehouseRepo,
 		FifoSvc:              fifoSvc,
+		StockLogRepo:         stockLogRepo,
 	}
 }
 
@@ -127,7 +134,8 @@ func (s recordingService) GetAll(c *fiber.Ctx, params *validation.Query) ([]enti
 		if params.ProjectFlockKandangId != 0 {
 			db = db.Where("project_flock_kandangs_id = ?", params.ProjectFlockKandangId)
 		}
-		return db.Order("record_datetime DESC").Order("created_at DESC")
+		db = s.Repository.ApplySearchFilters(db, params.Search)
+		return db.Order("recordings.record_datetime DESC").Order("recordings.created_at DESC")
 	})
 
 	if scopeErr != nil {
@@ -170,7 +178,7 @@ func (s recordingService) GetOne(c *fiber.Ctx, id uint) (*entity.Recording, erro
 	return recording, nil
 }
 
-func (s recordingService) GetNextDay(c *fiber.Ctx, projectFlockKandangId uint) (int, error) {
+func (s recordingService) GetNextDay(c *fiber.Ctx, projectFlockKandangId uint, recordTime time.Time) (int, error) {
 	if projectFlockKandangId == 0 {
 		return 0, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
 	}
@@ -178,14 +186,16 @@ func (s recordingService) GetNextDay(c *fiber.Ctx, projectFlockKandangId uint) (
 		return 0, err
 	}
 
-	db := s.Repository.DB().WithContext(c.Context())
-	next, err := s.Repository.GenerateNextDay(db, projectFlockKandangId)
+	if recordTime.IsZero() {
+		recordTime = time.Now().UTC()
+	}
+	day, err := s.computeRecordingDay(c.Context(), projectFlockKandangId, recordTime)
 	if err != nil {
-		s.Log.Errorf("Failed to compute next recording day for project_flock_kandang_id=%d: %+v", projectFlockKandangId, err)
+		s.Log.Errorf("Failed to compute recording day for project_flock_kandang_id=%d: %+v", projectFlockKandangId, err)
 		return 0, err
 	}
 
-	return next, nil
+	return day, nil
 }
 
 func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entity.Recording, error) {
@@ -230,12 +240,14 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 		}
 	}
 
+	day, err := s.computeRecordingDay(ctx, pfk.Id, recordTime)
+	if err != nil {
+		return nil, err
+	}
+
 	if !isLaying && len(req.Eggs) > 0 {
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Egg details permitted only for laying project flocks")
 	}
-	if isLaying && len(req.Eggs) == 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Egg details are required for laying project flocks")
-	}
 
 	if err := s.ensureProductWarehousesExist(c, req.Stocks, req.Depletions, req.Eggs); err != nil {
 		return nil, err
@@ -246,13 +258,8 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 	}
 	var createdRecording entity.Recording
 	transactionErr := s.Repository.DB().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		nextDay, err := s.Repository.GenerateNextDay(tx, req.ProjectFlockKandangId)
-		if err != nil {
-			s.Log.Errorf("Failed to determine recording day: %+v", err)
-			return err
-		}
 		if s.ProductionStandardSvc != nil {
-			if err := s.ProductionStandardSvc.EnsureWeekAvailable(ctx, pfk.ProjectFlock.ProductionStandardId, category, nextDay); err != nil {
+			if err := s.ProductionStandardSvc.EnsureWeekAvailable(ctx, pfk.ProjectFlock.ProductionStandardId, category, day); err != nil {
 				return err
 			}
 		}
@@ -266,7 +273,6 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 			return fiber.NewError(fiber.StatusBadRequest, "Recording for this project flock today already exists")
 		}
 
-		day := nextDay
 		createdRecording = entity.Recording{
 			ProjectFlockKandangId: req.ProjectFlockKandangId,
 			RecordDatetime:        recordTime,
@@ -299,23 +305,47 @@ func (s *recordingService) CreateOne(c *fiber.Ctx, req *validation.Create) (*ent
 		}
 
 		applyStockDesiredQuantities(mappedStocks, stockDesired, s.FifoSvc != nil)
-		if err := s.consumeRecordingStocks(ctx, tx, mappedStocks); err != nil {
+		note := fmt.Sprintf("Recording-Create#%d", createdRecording.Id)
+		if err := s.consumeRecordingStocks(ctx, tx, mappedStocks, note, actorID); err != nil {
 			return err
 		}
 
 		mappedDepletions := recordingutil.MapDepletions(createdRecording.Id, req.Depletions)
+		if s.FifoSvc != nil && len(mappedDepletions) > 0 {
+			sourceWarehouseID, err := s.resolvePopulationWarehouseID(ctx, req.ProjectFlockKandangId)
+			if err != nil {
+				return err
+			}
+			for i := range mappedDepletions {
+				mappedDepletions[i].SourceProductWarehouseId = &sourceWarehouseID
+			}
+		}
 		if err := s.Repository.CreateDepletions(tx, mappedDepletions); err != nil {
 			s.Log.Errorf("Failed to persist depletions: %+v", err)
 			return err
 		}
+		if s.FifoSvc != nil {
+			note := fmt.Sprintf("Recording-Create#%d", createdRecording.Id)
+			if err := s.consumeRecordingDepletions(ctx, tx, mappedDepletions, note, actorID); err != nil {
+				return err
+			}
+		}
 
 		mappedEggs := recordingutil.MapEggs(createdRecording.Id, createdRecording.CreatedBy, req.Eggs)
 		if err := s.Repository.CreateEggs(tx, mappedEggs); err != nil {
 			s.Log.Errorf("Failed to persist eggs: %+v", err)
 			return err
 		}
+		if s.FifoSvc != nil {
+			note := fmt.Sprintf("Recording-Create#%d", createdRecording.Id)
+			if err := s.replenishRecordingEggs(ctx, tx, mappedEggs, note, actorID); err != nil {
+				return err
+			}
+		}
 
-		if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, mappedDepletions, nil, mappedEggs)); err != nil {
+		var warehouseDeltas map[uint]float64
+		warehouseDeltas = buildWarehouseDeltas(nil, mappedDepletions, nil, mappedEggs)
+		if err := s.adjustProductWarehouseQuantities(ctx, tx, warehouseDeltas); err != nil {
 			s.Log.Errorf("Failed to adjust product warehouses: %+v", err)
 			return err
 		}
@@ -353,6 +383,10 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 	}
 
 	ctx := c.Context()
+	actorID, err := m.ActorIDFromContext(c)
+	if err != nil {
+		return nil, err
+	}
 
 	var recordingEntity *entity.Recording
 	var updatedRecording *entity.Recording
@@ -423,9 +457,6 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 			if !isLaying && len(req.Eggs) > 0 {
 				return fiber.NewError(fiber.StatusBadRequest, "Egg details permitted only for laying project flocks")
 			}
-			if isLaying && len(req.Eggs) == 0 {
-				return fiber.NewError(fiber.StatusBadRequest, "Egg details are required for laying project flocks")
-			}
 		}
 
 		if hasStockChanges {
@@ -441,23 +472,47 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 		}
 
 		if hasStockChanges {
-			if err := s.syncRecordingStocks(ctx, tx, recordingEntity.Id, existingStocks, req.Stocks); err != nil {
+			note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
+			if err := s.syncRecordingStocks(ctx, tx, recordingEntity.Id, existingStocks, req.Stocks, note, actorID); err != nil {
 				return err
 			}
 		}
 
 		if hasDepletionChanges {
+			if s.FifoSvc != nil {
+				note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
+				if err := s.releaseRecordingDepletions(ctx, tx, existingDepletions, note, actorID); err != nil {
+					return err
+				}
+			}
+
 			if err := s.Repository.DeleteDepletions(tx, recordingEntity.Id); err != nil {
 				s.Log.Errorf("Failed to clear depletions: %+v", err)
 				return err
 			}
 
 			mappedDepletions := recordingutil.MapDepletions(recordingEntity.Id, req.Depletions)
+			if s.FifoSvc != nil && len(mappedDepletions) > 0 {
+				sourceWarehouseID, err := s.resolvePopulationWarehouseID(ctx, recordingEntity.ProjectFlockKandangId)
+				if err != nil {
+					return err
+				}
+				for i := range mappedDepletions {
+					mappedDepletions[i].SourceProductWarehouseId = &sourceWarehouseID
+				}
+			}
 			if err := s.Repository.CreateDepletions(tx, mappedDepletions); err != nil {
 				s.Log.Errorf("Failed to update depletions: %+v", err)
 				return err
 			}
 
+			if s.FifoSvc != nil {
+				note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
+				if err := s.consumeRecordingDepletions(ctx, tx, mappedDepletions, note, actorID); err != nil {
+					return err
+				}
+			}
+
 			if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(existingDepletions, mappedDepletions, nil, nil)); err != nil {
 				s.Log.Errorf("Failed to adjust product warehouses for depletions: %+v", err)
 				return err
@@ -465,6 +520,38 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 		}
 
 		if hasEggChanges {
+			if s.FifoSvc != nil {
+				if err := ensureRecordingEggsUnused(existingEggs); err != nil {
+					return err
+				}
+				if s.StockLogRepo != nil {
+					note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
+					logs := make([]*entity.StockLog, 0, len(existingEggs))
+					for _, egg := range existingEggs {
+						if egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
+							continue
+						}
+						logs = append(logs, &entity.StockLog{
+							ProductWarehouseId: egg.ProductWarehouseId,
+							CreatedBy:          actorID,
+							Decrease:           float64(egg.Qty),
+							LoggableType:       string(utils.StockLogTypeRecording),
+							LoggableId:         recordingEntity.Id,
+							Notes:              note,
+						})
+					}
+					if len(logs) > 0 {
+						if err := s.StockLogRepo.WithTx(tx).CreateMany(ctx, logs, nil); err != nil {
+							return err
+						}
+					}
+				}
+				if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, nil, existingEggs, nil)); err != nil {
+					s.Log.Errorf("Failed to adjust product warehouses for eggs: %+v", err)
+					return err
+				}
+			}
+
 			if err := s.Repository.DeleteEggs(tx, recordingEntity.Id); err != nil {
 				s.Log.Errorf("Failed to clear eggs: %+v", err)
 				return err
@@ -476,9 +563,16 @@ func (s recordingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uin
 				return err
 			}
 
-			if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, nil, existingEggs, mappedEggs)); err != nil {
-				s.Log.Errorf("Failed to adjust product warehouses for eggs: %+v", err)
-				return err
+			if s.FifoSvc != nil {
+				note := fmt.Sprintf("Recording-Edit#%d", recordingEntity.Id)
+				if err := s.replenishRecordingEggs(ctx, tx, mappedEggs, note, actorID); err != nil {
+					return err
+				}
+			} else {
+				if err := s.adjustProductWarehouseQuantities(ctx, tx, buildWarehouseDeltas(nil, nil, existingEggs, mappedEggs)); err != nil {
+					s.Log.Errorf("Failed to adjust product warehouses for eggs: %+v", err)
+					return err
+				}
 			}
 		}
 
@@ -655,12 +749,22 @@ func (s recordingService) DeleteOne(c *fiber.Ctx, id uint) error {
 			s.Log.Errorf("Failed to list depletions before delete: %+v", err)
 			return err
 		}
+		if s.FifoSvc != nil {
+			if err := s.releaseRecordingDepletions(ctx, tx, oldDepletions, "", 0); err != nil {
+				return err
+			}
+		}
 
 		oldEggs, err := s.Repository.ListEggs(tx, id)
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 			s.Log.Errorf("Failed to list eggs before delete: %+v", err)
 			return err
 		}
+		if s.FifoSvc != nil {
+			if err := ensureRecordingEggsUnused(oldEggs); err != nil {
+				return err
+			}
+		}
 
 		oldStocks, err := s.Repository.ListStocks(tx, id)
 		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -668,7 +772,7 @@ func (s recordingService) DeleteOne(c *fiber.Ctx, id uint) error {
 			return err
 		}
 
-		if err := s.releaseRecordingStocks(ctx, tx, oldStocks); err != nil {
+		if err := s.releaseRecordingStocks(ctx, tx, oldStocks, "", 0); err != nil {
 			return err
 		}
 
@@ -727,10 +831,19 @@ func (s *recordingService) ensureProductWarehousesExist(c *fiber.Ctx, stocks []v
 	return nil
 }
 
-func (s *recordingService) consumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+func (s *recordingService) consumeRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
 	if len(stocks) == 0 || s.FifoSvc == nil {
 		return nil
 	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
 
 	for _, stock := range stocks {
 		if stock.Id == 0 {
@@ -763,19 +876,134 @@ func (s *recordingService) consumeRecordingStocks(ctx context.Context, tx *gorm.
 		if err := s.Repository.UpdateStockUsage(tx, stock.Id, result.UsageQuantity, result.PendingQuantity); err != nil {
 			return err
 		}
+
+		logDecrease := result.UsageQuantity
+		if result.PendingQuantity > 0 {
+			logDecrease += result.PendingQuantity
+		}
+		if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: stock.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Decrease:           logDecrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         stock.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
 	}
 
 	return nil
 }
 
-func (s *recordingService) ConsumeRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
-	return s.consumeRecordingStocks(ctx, tx, stocks)
+func (s *recordingService) consumeRecordingDepletions(
+	ctx context.Context,
+	tx *gorm.DB,
+	depletions []entity.RecordingDepletion,
+	note string,
+	actorID uint,
+) error {
+	if len(depletions) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, depletion := range depletions {
+		if depletion.Id == 0 {
+			continue
+		}
+
+		sourceWarehouseID := uint(0)
+		if depletion.SourceProductWarehouseId != nil {
+			sourceWarehouseID = *depletion.SourceProductWarehouseId
+		}
+		if sourceWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
+		}
+
+		desired := depletion.Qty + depletion.PendingQty
+		result, err := s.FifoSvc.Consume(ctx, commonSvc.StockConsumeRequest{
+			UsableKey:          recordingDepletionUsableKey,
+			UsableID:           depletion.Id,
+			ProductWarehouseID: sourceWarehouseID,
+			Quantity:           desired,
+			AllowPending:       false,
+			Tx:                 tx,
+		})
+		if err != nil {
+			s.Log.Errorf("Failed to consume FIFO stock for recording depletion %d: %+v", depletion.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, result.PendingQuantity); err != nil {
+			return err
+		}
+
+		logDecrease := result.UsageQuantity
+		if result.PendingQuantity > 0 {
+			logDecrease += result.PendingQuantity
+		}
+		if logDecrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: sourceWarehouseID,
+				CreatedBy:          actorID,
+				Decrease:           logDecrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+
+		destDelta := depletion.Qty + depletion.PendingQty
+		if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: depletion.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           destDelta,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
 }
 
-func (s *recordingService) releaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
+func (s *recordingService) ConsumeRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	return s.consumeRecordingStocks(ctx, tx, stocks, note, actorID)
+}
+
+func (s *recordingService) releaseRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
 	if len(stocks) == 0 || s.FifoSvc == nil {
 		return nil
 	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
 
 	for _, stock := range stocks {
 		if stock.Id == 0 {
@@ -794,13 +1022,166 @@ func (s *recordingService) releaseRecordingStocks(ctx context.Context, tx *gorm.
 		if err := s.Repository.UpdateStockUsage(tx, stock.Id, 0, 0); err != nil {
 			return err
 		}
+
+		if stock.UsageQty != nil && *stock.UsageQty > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: stock.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           *stock.UsageQty,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         stock.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
 	}
 
 	return nil
 }
 
-func (s *recordingService) ReleaseRecordingStocks(ctx context.Context, tx *gorm.DB, stocks []entity.RecordingStock) error {
-	return s.releaseRecordingStocks(ctx, tx, stocks)
+func (s *recordingService) releaseRecordingDepletions(
+	ctx context.Context,
+	tx *gorm.DB,
+	depletions []entity.RecordingDepletion,
+	note string,
+	actorID uint,
+) error {
+	if len(depletions) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, depletion := range depletions {
+		if depletion.Id == 0 {
+			continue
+		}
+
+		sourceWarehouseID := uint(0)
+		if depletion.SourceProductWarehouseId != nil {
+			sourceWarehouseID = *depletion.SourceProductWarehouseId
+		}
+		if sourceWarehouseID == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "Source product warehouse tidak ditemukan untuk depletion")
+		}
+
+		if err := s.FifoSvc.ReleaseUsage(ctx, commonSvc.StockReleaseRequest{
+			UsableKey: recordingDepletionUsableKey,
+			UsableID:  depletion.Id,
+			Tx:        tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to release FIFO stock for recording depletion %d: %+v", depletion.Id, err)
+			return err
+		}
+
+		if err := s.Repository.UpdateDepletionPending(tx, depletion.Id, 0); err != nil {
+			return err
+		}
+
+		logIncrease := depletion.Qty
+		if depletion.PendingQty > 0 {
+			logIncrease += depletion.PendingQty
+		}
+		if logIncrease > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: sourceWarehouseID,
+				CreatedBy:          actorID,
+				Increase:           logIncrease,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+
+		destDelta := depletion.Qty + depletion.PendingQty
+		if depletion.ProductWarehouseId != 0 && destDelta > 0 && strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: depletion.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Decrease:           destDelta,
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         depletion.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *recordingService) ReleaseRecordingStocks(
+	ctx context.Context,
+	tx *gorm.DB,
+	stocks []entity.RecordingStock,
+	note string,
+	actorID uint,
+) error {
+	return s.releaseRecordingStocks(ctx, tx, stocks, note, actorID)
+}
+
+func (s *recordingService) resolvePopulationWarehouseID(ctx context.Context, projectFlockKandangID uint) (uint, error) {
+	if projectFlockKandangID == 0 {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
+	}
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, projectFlockKandangID)
+	if err != nil {
+		s.Log.Errorf("Failed to fetch populations for project_flock_kandang_id=%d: %+v", projectFlockKandangID, err)
+		return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data populasi")
+	}
+	for _, pop := range populations {
+		if pop.ProductWarehouseId > 0 && pop.TotalQty > 0 {
+			return pop.ProductWarehouseId, nil
+		}
+	}
+	for _, pop := range populations {
+		if pop.ProductWarehouseId > 0 {
+			return pop.ProductWarehouseId, nil
+		}
+	}
+	return 0, fiber.NewError(fiber.StatusBadRequest, "Source product warehouse populasi tidak ditemukan")
+}
+
+func (s *recordingService) computeRecordingDay(ctx context.Context, projectFlockKandangID uint, recordTime time.Time) (int, error) {
+	if projectFlockKandangID == 0 {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "Project flock kandang tidak valid")
+	}
+
+	populations, err := s.ProjectFlockPopulationRepo.GetByProjectFlockKandangID(ctx, projectFlockKandangID)
+	if err != nil {
+		s.Log.Errorf("Failed to fetch populations for project_flock_kandang_id=%d: %+v", projectFlockKandangID, err)
+		return 0, fiber.NewError(fiber.StatusInternalServerError, "Gagal mengambil data populasi")
+	}
+
+	var chickinDate time.Time
+	for _, pop := range populations {
+		if pop.ProjectChickin == nil || pop.ProjectChickin.ChickInDate.IsZero() {
+			continue
+		}
+		if chickinDate.IsZero() || pop.ProjectChickin.ChickInDate.Before(chickinDate) {
+			chickinDate = pop.ProjectChickin.ChickInDate
+		}
+	}
+	if chickinDate.IsZero() {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "Tanggal chick in tidak ditemukan")
+	}
+
+	chickinDay := time.Date(chickinDate.Year(), chickinDate.Month(), chickinDate.Day(), 0, 0, 0, 0, time.UTC)
+	recordDay := time.Date(recordTime.Year(), recordTime.Month(), recordTime.Day(), 0, 0, 0, 0, time.UTC)
+	diff := int(recordDay.Sub(chickinDay).Hours() / 24)
+	if diff < 0 {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "Record date tidak boleh sebelum tanggal chick in")
+	}
+
+	return diff + 1, nil
 }
 
 func buildWarehouseDeltas(
@@ -837,6 +1218,53 @@ func (s *recordingService) adjustProductWarehouseQuantities(ctx context.Context,
 	return s.ProductWarehouseRepo.AdjustQuantities(ctx, deltas, func(*gorm.DB) *gorm.DB { return tx })
 }
 
+func (s *recordingService) replenishRecordingEggs(
+	ctx context.Context,
+	tx *gorm.DB,
+	eggs []entity.RecordingEgg,
+	note string,
+	actorID uint,
+) error {
+	if len(eggs) == 0 || s.FifoSvc == nil {
+		return nil
+	}
+	if strings.TrimSpace(note) != "" && s.StockLogRepo == nil {
+		return errors.New("stock log repository is not available")
+	}
+
+	for _, egg := range eggs {
+		if egg.Id == 0 || egg.ProductWarehouseId == 0 || egg.Qty <= 0 {
+			continue
+		}
+		if _, err := s.FifoSvc.Replenish(ctx, commonSvc.StockReplenishRequest{
+			StockableKey:       fifo.StockableKeyRecordingEgg,
+			StockableID:        egg.Id,
+			ProductWarehouseID: egg.ProductWarehouseId,
+			Quantity:           float64(egg.Qty),
+			Tx:                 tx,
+		}); err != nil {
+			s.Log.Errorf("Failed to replenish FIFO stock for recording egg %d: %+v", egg.Id, err)
+			return err
+		}
+
+		if strings.TrimSpace(note) != "" && actorID != 0 {
+			log := &entity.StockLog{
+				ProductWarehouseId: egg.ProductWarehouseId,
+				CreatedBy:          actorID,
+				Increase:           float64(egg.Qty),
+				LoggableType:       string(utils.StockLogTypeRecording),
+				LoggableId:         egg.RecordingId,
+				Notes:              note,
+			}
+			if err := s.StockLogRepo.WithTx(tx).CreateOne(ctx, log, nil); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
 type desiredStock struct {
 	Usage   float64
 	Pending float64
@@ -882,6 +1310,8 @@ func (s *recordingService) syncRecordingStocks(
 	recordingID uint,
 	existing []entity.RecordingStock,
 	incoming []validation.Stock,
+	note string,
+	actorID uint,
 ) error {
 	if s.FifoSvc == nil {
 		if err := s.Repository.DeleteStocks(tx, recordingID); err != nil {
@@ -918,10 +1348,8 @@ func (s *recordingService) syncRecordingStocks(
 
 		desired := item.Qty
 		stock.UsageQty = &desired
-		if item.PendingQty != nil {
-			pending := *item.PendingQty
-			stock.PendingQty = &pending
-		}
+		zero := 0.0
+		stock.PendingQty = &zero
 		stocksToConsume = append(stocksToConsume, stock)
 	}
 
@@ -930,7 +1358,7 @@ func (s *recordingService) syncRecordingStocks(
 		leftovers = append(leftovers, list...)
 	}
 	if len(leftovers) > 0 {
-		if err := s.releaseRecordingStocks(ctx, tx, leftovers); err != nil {
+		if err := s.releaseRecordingStocks(ctx, tx, leftovers, note, actorID); err != nil {
 			return err
 		}
 		ids := make([]uint, 0, len(leftovers))
@@ -949,7 +1377,7 @@ func (s *recordingService) syncRecordingStocks(
 	if len(stocksToConsume) == 0 {
 		return nil
 	}
-	return s.consumeRecordingStocks(ctx, tx, stocksToConsume)
+	return s.consumeRecordingStocks(ctx, tx, stocksToConsume, note, actorID)
 }
 
 type eggTotals struct {
@@ -957,44 +1385,31 @@ type eggTotals struct {
 	Weight float64
 }
 
-func stocksMatch(existing []entity.RecordingStock, incoming []validation.Stock) bool {
-	hasPending := false
-	for _, item := range incoming {
-		if item.PendingQty != nil {
-			hasPending = true
-			break
+func ensureRecordingEggsUnused(eggs []entity.RecordingEgg) error {
+	for _, egg := range eggs {
+		if egg.TotalUsed > 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "Recording egg sudah digunakan sehingga tidak dapat diubah")
 		}
 	}
+	return nil
+}
+
+func stocksMatch(existing []entity.RecordingStock, incoming []validation.Stock) bool {
 
 	existingUsage := make(map[uint]float64)
-	existingTotal := make(map[uint]float64)
 	for _, stock := range existing {
 		var usage float64
-		var pending float64
 		if stock.UsageQty != nil {
 			usage = *stock.UsageQty
 		}
-		if stock.PendingQty != nil {
-			pending = *stock.PendingQty
-		}
 		existingUsage[stock.ProductWarehouseId] += usage
-		existingTotal[stock.ProductWarehouseId] += usage + pending
 	}
 
 	incomingUsage := make(map[uint]float64)
-	incomingTotal := make(map[uint]float64)
 	for _, item := range incoming {
-		var pending float64
-		if item.PendingQty != nil {
-			pending = *item.PendingQty
-		}
 		incomingUsage[item.ProductWarehouseId] += item.Qty
-		incomingTotal[item.ProductWarehouseId] += item.Qty + pending
 	}
 
-	if hasPending {
-		return floatMapsMatch(existingTotal, incomingTotal)
-	}
 	return floatMapsMatch(existingUsage, incomingUsage)
 }
 
@@ -1021,7 +1436,7 @@ func eggsMatch(existing []entity.RecordingEgg, incoming []validation.Egg) bool {
 		}
 		current := existingTotals[egg.ProductWarehouseId]
 		current.Qty += egg.Qty
-		current.Weight += float64(egg.Qty) * weight
+		current.Weight += weight
 		existingTotals[egg.ProductWarehouseId] = current
 	}
 
@@ -1033,7 +1448,7 @@ func eggsMatch(existing []entity.RecordingEgg, incoming []validation.Egg) bool {
 		}
 		current := incomingTotals[egg.ProductWarehouseId]
 		current.Qty += egg.Qty
-		current.Weight += float64(egg.Qty) * weight
+		current.Weight += weight
 		incomingTotals[egg.ProductWarehouseId] = current
 	}
 
@@ -1192,7 +1607,7 @@ func (s *recordingService) computeAndUpdateMetrics(ctx context.Context, tx *gorm
 
 	var eggMass float64
 	if remainingChick > 0 && totalEggWeightGrams > 0 {
-		eggMass = (totalEggWeightGrams / remainingChick) * 1000
+		eggMass = (totalEggWeightGrams / remainingChick) / 1000
 		updates["egg_mass"] = eggMass
 		recording.EggMass = &eggMass
 	} else {
@@ -1202,7 +1617,7 @@ func (s *recordingService) computeAndUpdateMetrics(ctx context.Context, tx *gorm
 
 	var eggWeight float64
 	if totalEggQty > 0 && totalEggWeightGrams > 0 {
-		eggWeight = (totalEggWeightGrams / totalEggQty) * 1000
+		eggWeight = totalEggWeightGrams / totalEggQty
 		updates["egg_weight"] = eggWeight
 		recording.EggWeight = &eggWeight
 	} else {

internal/modules/production/recordings/validations/recording.validation.go

@@ -2,9 +2,8 @@ package validation
 
 type (
 	Stock struct {
-		ProductWarehouseId uint     `json:"product_warehouse_id" validate:"required,number,min=1"`
-		Qty                float64  `json:"qty" validate:"required,gte=0"`
-		PendingQty         *float64 `json:"pending_qty,omitempty" validate:"omitempty,gte=0"`
+		ProductWarehouseId uint    `json:"product_warehouse_id" validate:"required,number,min=1"`
+		Qty                float64 `json:"qty" validate:"required,gte=0"`
 	}
 
 	Depletion struct {
@@ -20,23 +19,24 @@ type (
 )
 
 type Create struct {
-	ProjectFlockKandangId uint         `json:"project_flock_kandang_id" validate:"required,number,min=1"`
-	RecordDate            *string      `json:"record_date,omitempty" validate:"omitempty,datetime=2006-01-02"`
-	Stocks                []Stock      `json:"stocks" validate:"dive"`
-	Depletions            []Depletion  `json:"depletions" validate:"dive"`
-	Eggs                  []Egg        `json:"eggs" validate:"omitempty,dive"`
+	ProjectFlockKandangId uint        `json:"project_flock_kandang_id" validate:"required,number,min=1"`
+	RecordDate            *string     `json:"record_date,omitempty" validate:"omitempty,datetime=2006-01-02"`
+	Stocks                []Stock     `json:"stocks" validate:"dive"`
+	Depletions            []Depletion `json:"depletions,omitempty" validate:"omitempty,dive"`
+	Eggs                  []Egg       `json:"eggs" validate:"omitempty,dive"`
 }
 
 type Update struct {
-	Stocks      []Stock      `json:"stocks,omitempty" validate:"omitempty,dive"`
-	Depletions  []Depletion  `json:"depletions,omitempty" validate:"omitempty,dive"`
-	Eggs        []Egg        `json:"eggs,omitempty" validate:"omitempty,dive"`
+	Stocks     []Stock     `json:"stocks,omitempty" validate:"omitempty,dive"`
+	Depletions []Depletion `json:"depletions,omitempty" validate:"omitempty,dive"`
+	Eggs       []Egg       `json:"eggs,omitempty" validate:"omitempty,dive"`
 }
 
 type Query struct {
-	Page                  int  `query:"page" validate:"omitempty,number,min=1"`
-	Limit                 int  `query:"limit" validate:"omitempty,number,min=1,max=100"`
-	ProjectFlockKandangId uint `query:"project_flock_kandang_id" validate:"omitempty,number,min=1"`
+	Page                  int    `query:"page" validate:"omitempty,number,min=1"`
+	Limit                 int    `query:"limit" validate:"omitempty,number,min=1,max=100"`
+	ProjectFlockKandangId uint   `query:"project_flock_kandang_id" validate:"omitempty,number,min=1"`
+	Search                string `query:"search" validate:"omitempty,max=50"`
 }
 
 type Approve struct {

internal/modules/production/transfer_layings/controllers/transfer_laying.controller.go

@@ -25,8 +25,12 @@ func NewTransferLayingController(transferLayingService service.TransferLayingSer
 
 func (u *TransferLayingController) GetAll(c *fiber.Ctx) error {
 	query := &validation.Query{
-		Page:  c.QueryInt("page", 1),
-		Limit: c.QueryInt("limit", 10),
+		Page:             c.QueryInt("page", 1),
+		Limit:            c.QueryInt("limit", 10),
+		Search:           c.Query("search", ""),
+		TransferDate:     c.Query("transfer_date", ""),
+		FlockSource:      uint(c.QueryInt("flock_source", 0)),
+		FlockDestination: uint(c.QueryInt("flock_destination", 0)),
 	}
 
 	if query.Page < 1 || query.Limit < 1 {
@@ -66,7 +70,7 @@ func (u *TransferLayingController) GetOne(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
 	}
 
-	result, approval, err := u.TransferLayingService.GetOneWithApproval(c, uint(id))
+	result, approval, err := u.TransferLayingService.GetOne(c, uint(id))
 	if err != nil {
 		return err
 	}
@@ -179,7 +183,6 @@ func (u *TransferLayingController) Approval(c *fiber.Ctx) error {
 		})
 }
 
-
 func (u *TransferLayingController) GetAvailableQtyPerKandang(c *fiber.Ctx) error {
 	projectFlockID, err := strconv.ParseUint(c.Params("project_flock_id"), 10, 32)
 	if err != nil {

internal/modules/production/transfer_layings/dto/transfer_laying.dto.go

@@ -162,9 +162,19 @@ func ToProductWarehouseSummaryDTO(pw *entity.ProductWarehouse) *ProductWarehouse
 }
 
 func ToLayingTransferSourceDTO(source entity.LayingTransferSource) LayingTransferSourceDTO {
+	// Tampilkan requested qty sebelum approve, consumed qty setelah approve
+	var displayQty float64
+	if source.UsageQty > 0 {
+		// Sudah di-approve dan di-consume, tampilkan actual consumed quantity
+		displayQty = source.UsageQty
+	} else {
+		// Belum di-approve, tampilkan requested quantity
+		displayQty = source.RequestedQty
+	}
+
 	return LayingTransferSourceDTO{
 		SourceProjectFlockKandang: ToProjectFlockKandangSummaryDTO(source.SourceProjectFlockKandang),
-		Qty:                       source.UsageQty, // Ambil dari UsageQty (FIFO consumed quantity)
+		Qty:                       displayQty,
 		ProductWarehouse:          ToProductWarehouseSummaryDTO(source.ProductWarehouse),
 		Note:                      source.Note,
 	}

internal/modules/production/transfer_layings/services/transfer_laying.service.go

@@ -28,8 +28,7 @@ import (
 
 type TransferLayingService interface {
 	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.LayingTransfer, int64, error)
-	GetOne(ctx *fiber.Ctx, id uint) (*entity.LayingTransfer, error)
-	GetOneWithApproval(ctx *fiber.Ctx, id uint) (*entity.LayingTransfer, *entity.Approval, error)
+	GetOne(ctx *fiber.Ctx, id uint) (*entity.LayingTransfer, *entity.Approval, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.LayingTransfer, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.LayingTransfer, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
@@ -107,26 +106,34 @@ func (s transferLayingService) GetAll(c *fiber.Ctx, params *validation.Query) ([
 		return nil, 0, err
 	}
 
-	scope, err := m.ResolveLocationScope(c, s.Repository.DB())
-	if err != nil {
-		return nil, 0, err
-	}
-
 	offset := (params.Page - 1) * params.Limit
 
 	transferLayings, total, err := s.Repository.GetAll(c.Context(), offset, params.Limit, func(db *gorm.DB) *gorm.DB {
-		db = s.withRelations(db)
-		if scope.Restrict {
-			if len(scope.IDs) == 0 {
-				return db.Where("1 = 0")
-			}
-			db = db.
-				Joins("JOIN project_flocks pf_from ON pf_from.id = laying_transfers.from_project_flock_id").
-				Joins("JOIN project_flocks pf_to ON pf_to.id = laying_transfers.to_project_flock_id").
-				Where("(pf_from.location_id IN ? OR pf_to.location_id IN ?)", scope.IDs, scope.IDs).
-				Distinct("laying_transfers.*")
+		// Apply search and filters
+		if params.Search != "" {
+			searchPattern := "%" + params.Search + "%"
+			db = db.Joins("LEFT JOIN project_flocks AS pf_from ON laying_transfers.from_project_flock_id = pf_from.id").
+				Joins("LEFT JOIN project_flocks AS pf_to ON laying_transfers.to_project_flock_id = pf_to.id").
+				Where("laying_transfers.transfer_number ILIKE ? OR laying_transfers.notes ILIKE ? OR pf_from.flock_name ILIKE ? OR pf_to.flock_name ILIKE ?",
+					searchPattern, searchPattern, searchPattern, searchPattern)
 		}
+
+		if params.TransferDate != "" {
+			db = db.Where("transfer_date::date = ?::date", params.TransferDate)
+		}
+
+		if params.FlockSource > 0 {
+			db = db.Where("from_project_flock_id = ?", params.FlockSource)
+		}
+
+		if params.FlockDestination > 0 {
+			db = db.Where("to_project_flock_id = ?", params.FlockDestination)
+		}
+
 		db = db.Order("created_at DESC")
+
+		db = s.withRelations(db)
+
 		return db
 	})
 
@@ -148,18 +155,15 @@ func (s transferLayingService) GetAll(c *fiber.Ctx, params *validation.Query) ([
 	return transferLayings, total, nil
 }
 
-func (s transferLayingService) GetOne(c *fiber.Ctx, id uint) (*entity.LayingTransfer, error) {
-	if err := m.EnsureLayingTransferAccess(c, s.Repository.DB(), id); err != nil {
-		return nil, err
-	}
-
+func (s transferLayingService) GetOne(c *fiber.Ctx, id uint) (*entity.LayingTransfer, *entity.Approval, error) {
 	transferLaying, err := s.Repository.GetByID(c.Context(), id, s.withRelations)
+
 	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusNotFound, "TransferLaying not found")
+		return nil, nil, fiber.NewError(fiber.StatusNotFound, "TransferLaying not found")
 	}
 	if err != nil {
 		s.Log.Errorf("Failed get transferLaying by id: %+v", err)
-		return nil, err
+		return nil, nil, err
 	}
 
 	approvalRepo := commonRepo.NewApprovalRepository(s.Repository.DB())
@@ -170,15 +174,6 @@ func (s transferLayingService) GetOne(c *fiber.Ctx, id uint) (*entity.LayingTran
 		transferLaying.LatestApproval = latestApproval
 	}
 
-	return transferLaying, nil
-}
-
-func (s transferLayingService) GetOneWithApproval(c *fiber.Ctx, id uint) (*entity.LayingTransfer, *entity.Approval, error) {
-	transferLaying, err := s.GetOne(c, id)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	return transferLaying, transferLaying.LatestApproval, nil
 }
 
@@ -241,7 +236,7 @@ func (s *transferLayingService) CreateOne(c *fiber.Ctx, req *validation.Create)
 
 	for _, sourceDetail := range req.SourceKandangs {
 		if sourceDetail.Quantity <= 0 {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Jumlah kandang sumber harus lebih dari 0")
+			continue
 		}
 		totalSourceQty += sourceDetail.Quantity
 
@@ -272,11 +267,18 @@ func (s *transferLayingService) CreateOne(c *fiber.Ctx, req *validation.Create)
 
 	for _, targetDetail := range req.TargetKandangs {
 		if targetDetail.Quantity <= 0 {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Jumlah kandang tujuan harus lebih dari 0")
+			continue
 		}
 		totalTargetQty += targetDetail.Quantity
 	}
 
+	if totalSourceQty == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Minimal harus ada 1 kandang sumber dengan jumlah lebih dari 0")
+	}
+	if totalTargetQty == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "Minimal harus ada 1 kandang tujuan dengan jumlah lebih dari 0")
+	}
+
 	if totalSourceQty != totalTargetQty {
 		return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Jumlah total sumber (%.0f) harus sama dengan jumlah total tujuan (%.0f)", totalSourceQty, totalTargetQty))
 	}
@@ -304,11 +306,16 @@ func (s *transferLayingService) CreateOne(c *fiber.Ctx, req *validation.Create)
 		}
 
 		for _, sourceDetail := range req.SourceKandangs {
+			if sourceDetail.Quantity == 0 {
+				continue
+			}
+
 			productWarehouseId := sourceWarehouseMap[sourceDetail.ProjectFlockKandangId]
 
 			source := entity.LayingTransferSource{
 				LayingTransferId:            createBody.Id,
 				SourceProjectFlockKandangId: sourceDetail.ProjectFlockKandangId,
+				RequestedQty:                sourceDetail.Quantity, // Quantity yang diminta user
 				UsageQty:                    0,
 				PendingUsageQty:             0, // Di-set 0, biarkan FIFO Consume yang handle saat Approval
 				ProductWarehouseId:          &productWarehouseId,
@@ -320,6 +327,9 @@ func (s *transferLayingService) CreateOne(c *fiber.Ctx, req *validation.Create)
 		}
 
 		for _, targetDetail := range req.TargetKandangs {
+			if targetDetail.Quantity == 0 {
+				continue
+			}
 
 			targetprojectFlockKandang, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), targetDetail.ProjectFlockKandangId)
 			if err != nil {
@@ -393,7 +403,12 @@ func (s *transferLayingService) CreateOne(c *fiber.Ctx, req *validation.Create)
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal membuat transfer laying")
 	}
 
-	return s.GetOne(c, createBody.Id)
+	laying_transfer, _, err := s.GetOne(c, createBody.Id)
+	if err != nil {
+		return nil, err
+	}
+	return laying_transfer, nil
+
 }
 
 func (s *transferLayingService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.LayingTransfer, error) {
@@ -497,8 +512,9 @@ func (s *transferLayingService) UpdateOne(c *fiber.Ctx, req *validation.Update,
 			source := entity.LayingTransferSource{
 				LayingTransferId:            id,
 				SourceProjectFlockKandangId: sourceDetail.ProjectFlockKandangId,
+				RequestedQty:                sourceDetail.Quantity, // Quantity yang diminta user
 				UsageQty:                    0,
-				PendingUsageQty:             sourceDetail.Quantity,
+				PendingUsageQty:             0, // Di-set 0, biarkan FIFO Consume yang handle saat Approval
 				ProductWarehouseId:          &productWarehouseId,
 			}
 			if err := sourceRepo.CreateOne(c.Context(), &source, nil); err != nil {
@@ -577,7 +593,9 @@ func (s *transferLayingService) UpdateOne(c *fiber.Ctx, req *validation.Update,
 		return nil, err
 	}
 
-	return s.GetOne(c, id)
+	layingTransfer, _, err := s.GetOne(c, id)
+
+	return layingTransfer, err
 }
 
 func (s transferLayingService) DeleteOne(c *fiber.Ctx, id uint) error {
@@ -734,7 +752,7 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 						return fiber.NewError(fiber.StatusInternalServerError, fmt.Sprintf("Target product warehouse tidak ditemukan untuk transfer %d", approvableID))
 					}
 
-					note := fmt.Sprintf("Transfer to Laying #%s - Target Kandang", transfer.TransferNumber)
+					note := fmt.Sprintf("Transfer to Laying #%s", transfer.TransferNumber)
 					replenishResult, err := s.FifoSvc.Replenish(c.Context(), commonSvc.StockReplenishRequest{
 						StockableKey:       fifo.StockableKeyTransferToLayingIn,
 						StockableID:        target.Id,
@@ -768,7 +786,7 @@ func (s transferLayingService) Approval(c *fiber.Ctx, req *validation.Approve) (
 
 	updated := make([]entity.LayingTransfer, 0, len(approvableIDs))
 	for _, approvableID := range approvableIDs {
-		transfer, err := s.GetOne(c, approvableID)
+		transfer, _, err := s.GetOne(c, approvableID)
 		if err != nil {
 			return nil, err
 		}
@@ -848,15 +866,15 @@ func (s transferLayingService) GetAvailableQtyPerKandang(ctx *fiber.Ctx, project
 
 	kandangAvailableQty := make(map[uint]float64)
 	for _, kandang := range kandangs {
-
-		totalQty, err := s.ProjectFlockPopulationRepo.GetTotalQtyByProjectFlockKandangID(ctx.Context(), kandang.Id)
+		// Gunakan fungsi repository yang sama dengan recording service
+		totalAvailable, err := s.ProjectFlockPopulationRepo.GetAvailableQtyByProjectFlockKandangID(ctx.Context(), kandang.Id)
 		if err != nil {
-			s.Log.Warnf("Failed to get total qty for kandang %d: %+v", kandang.Id, err)
+			s.Log.Warnf("Failed to get available qty for kandang %d: %+v", kandang.Id, err)
 			kandangAvailableQty[kandang.Id] = 0
 			continue
 		}
 
-		kandangAvailableQty[kandang.Id] = totalQty
+		kandangAvailableQty[kandang.Id] = totalAvailable
 	}
 
 	return pf, kandangAvailableQty, nil

internal/modules/production/transfer_layings/validations/transfer_laying.validation.go

@@ -2,12 +2,12 @@ package validation
 
 type SourceKandangDetail struct {
 	ProjectFlockKandangId uint    `json:"project_flock_kandang_id" validate:"required"`
-	Quantity              float64 `json:"quantity" validate:"required,gt=0"`
+	Quantity              float64 `json:"quantity"`
 }
 
 type TargetKandangDetail struct {
 	ProjectFlockKandangId uint    `json:"project_flock_kandang_id" validate:"required"`
-	Quantity              float64 `json:"quantity" validate:"required,gt=0"`
+	Quantity              float64 `json:"quantity"`
 }
 
 type Create struct {
@@ -29,8 +29,12 @@ type Update struct {
 }
 
 type Query struct {
-	Page  int `query:"page" validate:"omitempty,number,min=1,gt=0"`
-	Limit int `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Page             int    `query:"page" validate:"omitempty,number,min=1,gt=0"`
+	Limit            int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Search           string `query:"search" validate:"omitempty"`
+	TransferDate     string `query:"transfer_date" validate:"omitempty"`
+	FlockSource      uint   `query:"flock_source" validate:"omitempty,number"`
+	FlockDestination uint   `query:"flock_destination" validate:"omitempty,number"`
 }
 
 type Approve struct {

internal/modules/production/uniformities/services/uniformity.service.go

@@ -363,7 +363,52 @@ func (s *uniformityService) CreateOne(c *fiber.Ctx, req *validation.Create, file
 	); err != nil {
 		return nil, err
 	}
-	if err := s.ensureUniqueUniformity(c.Context(), 0, req.ProjectFlockKandangId, req.Week, &uniformDate); err != nil {
+
+	pfk, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), req.ProjectFlockKandangId)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock Kandang not found")
+		}
+		return nil, err
+	}
+	category := strings.TrimSpace(pfk.ProjectFlock.Category)
+	if s.ProductionStandardRepo != nil && pfk.ProjectFlock.ProductionStandardId != 0 {
+		if standard, err := s.ProductionStandardRepo.GetByID(c.Context(), pfk.ProjectFlock.ProductionStandardId, nil); err == nil {
+			if strings.TrimSpace(standard.ProjectCategory) != "" {
+				category = standard.ProjectCategory
+			}
+		}
+	}
+	weekBase := 1
+	if strings.EqualFold(category, string(utils.ProjectFlockCategoryLaying)) {
+		weekBase = 18
+	}
+	if req.Week < weekBase {
+		if weekBase == 18 {
+			return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 18 for laying projects")
+		}
+		return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 1 for growing projects")
+	}
+
+	var latestWeek int
+	if err := s.Repository.DB().WithContext(c.Context()).
+		Model(&entity.ProjectFlockKandangUniformity{}).
+		Where("project_flock_kandang_id = ?", req.ProjectFlockKandangId).
+		Select("COALESCE(MAX(week), 0)").
+		Scan(&latestWeek).Error; err != nil {
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate uniformity week sequence")
+	}
+	if latestWeek == 0 && req.Week != weekBase {
+		if weekBase == 18 {
+			return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 18 for laying projects")
+		}
+		return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 1 for growing projects")
+	}
+	if latestWeek > 0 && req.Week > latestWeek+1 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "week must be sequential without skipping")
+	}
+
+	if err := s.ensureUniqueUniformity(c.Context(), 0, req.ProjectFlockKandangId, req.Week); err != nil {
 		return nil, err
 	}
 
@@ -508,8 +553,35 @@ func (s uniformityService) UpdateOne(c *fiber.Ctx, req *validation.Update, id ui
 		if req.ProjectFlockKandangId != nil {
 			targetPFKID = *req.ProjectFlockKandangId
 		}
+		if targetPFKID != 0 && targetWeek > 0 {
+			pfk, err := s.ProjectFlockKandangRepo.GetByID(c.Context(), targetPFKID)
+			if err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock Kandang not found")
+				}
+				return nil, err
+			}
+			category := strings.TrimSpace(pfk.ProjectFlock.Category)
+			if s.ProductionStandardRepo != nil && pfk.ProjectFlock.ProductionStandardId != 0 {
+				if standard, err := s.ProductionStandardRepo.GetByID(c.Context(), pfk.ProjectFlock.ProductionStandardId, nil); err == nil {
+					if strings.TrimSpace(standard.ProjectCategory) != "" {
+						category = standard.ProjectCategory
+					}
+				}
+			}
+			weekBase := 1
+			if strings.EqualFold(category, string(utils.ProjectFlockCategoryLaying)) {
+				weekBase = 18
+			}
+			if targetWeek < weekBase {
+				if weekBase == 18 {
+					return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 18 for laying projects")
+				}
+				return nil, fiber.NewError(fiber.StatusBadRequest, "week must start from 1 for growing projects")
+			}
+		}
 		if targetDate != nil {
-			if err := s.ensureUniqueUniformity(c.Context(), id, targetPFKID, targetWeek, targetDate); err != nil {
+			if err := s.ensureUniqueUniformity(c.Context(), id, targetPFKID, targetWeek); err != nil {
 				return nil, err
 			}
 		}
@@ -625,7 +697,7 @@ func (s uniformityService) UpdateOne(c *fiber.Ctx, req *validation.Update, id ui
 	return s.GetOne(c, id)
 }
 
-func (s *uniformityService) ensureUniqueUniformity(ctx context.Context, id uint, projectFlockKandangID uint, week int, uniformDate *time.Time) error {
+func (s *uniformityService) ensureUniqueUniformity(ctx context.Context, id uint, projectFlockKandangID uint, week int) error {
 	if projectFlockKandangID == 0 || week == 0 {
 		return nil
 	}