feat/BE/US-76/US-78/US-79/TASK-112,120,133,121-Recording growing/TASK-187,189,202,190-Recording Laying/TASK-191,192,194,197,203-Grading Telur

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

@@ -222,11 +222,11 @@ func (u *ProjectflockController) Approval(c *fiber.Ctx) error {
 }
 
 func (u *ProjectflockController) GetFlockPeriodSummary(c *fiber.Ctx) error {
-	param := c.Params("flock_id")
+	param := c.Params("project_flock_kandang_id")
 
 	id, err := strconv.Atoi(param)
 	if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid Flock Id")
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid project_flock_kandang_id")
 	}
 
 	summary, err := u.ProjectflockService.GetFlockPeriodSummary(c, uint(id))

internal/modules/production/project_flocks/repositories/projectflock_kandang.repository.go

@@ -2,6 +2,7 @@ package repository
 
 import (
 	"context"
+	"strings"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gorm.io/gorm"
@@ -16,6 +17,7 @@ type ProjectFlockKandangRepository interface {
 	ListExistingKandangIDs(ctx context.Context, projectFlockID uint, kandangIDs []uint) ([]uint, error)
 	HasKandangsLinkedToOtherProject(ctx context.Context, kandangIDs []uint, exceptProjectID *uint) (bool, error)
 	FindKandangsWithRecordings(ctx context.Context, projectFlockID uint, kandangIDs []uint) ([]entity.Kandang, error)
+	MaxPeriodByBaseName(ctx context.Context, baseName string) (int, error)
 	WithTx(tx *gorm.DB) ProjectFlockKandangRepository
 	DB() *gorm.DB
 }
@@ -24,6 +26,8 @@ type projectFlockKandangRepositoryImpl struct {
 	db *gorm.DB
 }
 
+const flockBaseNameExpression = "LOWER(TRIM(regexp_replace(project_flocks.flock_name, '\\s+\\d+(\\s+\\d+)*$', '', 'g')))"
+
 func NewProjectFlockKandangRepository(db *gorm.DB) ProjectFlockKandangRepository {
 	return &projectFlockKandangRepositoryImpl{db: db}
 }
@@ -149,3 +153,17 @@ func (r *projectFlockKandangRepositoryImpl) FindKandangsWithRecordings(ctx conte
 		Scan(&kandangs).Error
 	return kandangs, err
 }
+
+func (r *projectFlockKandangRepositoryImpl) MaxPeriodByBaseName(ctx context.Context, baseName string) (int, error) {
+	if strings.TrimSpace(baseName) == "" {
+		return 0, nil
+	}
+	var max int
+	err := r.db.WithContext(ctx).
+		Table("project_flock_kandangs pfk").
+		Joins("JOIN project_flocks pf ON pf.id = pfk.project_flock_id").
+		Where(flockBaseNameExpression+" = LOWER(?)", baseName).
+		Select("COALESCE(MAX(pf.period), 0)").
+		Scan(&max).Error
+	return max, err
+}

internal/modules/production/project_flocks/route.go

@@ -27,6 +27,6 @@ func ProjectflockRoutes(v1 fiber.Router, u user.UserService, s projectflock.Proj
 	route.Delete("/:id", ctrl.DeleteOne)
 	route.Get("/kandangs/lookup", ctrl.LookupProjectFlockKandang)
 	route.Post("/approvals", ctrl.Approval)
-	route.Get("/flocks/:flock_id/periods", ctrl.GetFlockPeriodSummary)
+	route.Get("/kandangs/:project_flock_kandang_id/periods", ctrl.GetFlockPeriodSummary)
 	
 }

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

@@ -52,8 +52,8 @@ type projectflockService struct {
 }
 
 type FlockPeriodSummary struct {
-	Flock      entity.Flock
-	NextPeriod int
+    Flock      entity.Flock
+    NextPeriod int
 }
 
 func NewProjectflockService(
@@ -719,28 +719,57 @@ func (s projectflockService) GetAvailableDocQuantity(ctx *fiber.Ctx, kandangID u
 	return total, nil
 }
 
-func (s projectflockService) GetFlockPeriodSummary(c *fiber.Ctx, flockID uint) (*FlockPeriodSummary, error) {
-	flock, err := s.FlockRepo.GetByID(c.Context(), flockID, func(db *gorm.DB) *gorm.DB {
-		return db.Preload("CreatedUser")
-	})
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusNotFound, "Flock not found")
-	}
-	if err != nil {
-		s.Log.Errorf("Failed get flock %d for period summary: %+v", flockID, err)
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch flock")
-	}
+func (s projectflockService) GetFlockPeriodSummary(c *fiber.Ctx, projectFlockKandangID uint) (*FlockPeriodSummary, error) {
+    if projectFlockKandangID == 0 {
+        return nil, fiber.NewError(fiber.StatusBadRequest, "project_flock_kandang_id is required")
+    }
 
-	maxPeriod, err := s.Repository.GetMaxPeriodByBaseName(c.Context(), flock.Name)
-	if err != nil {
-		s.Log.Errorf("Failed to compute next period for flock %d: %+v", flockID, err)
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to compute next period")
-	}
+    pivot, err := s.pivotRepo().GetByID(c.Context(), projectFlockKandangID)
+    if errors.Is(err, gorm.ErrRecordNotFound) {
+        return nil, fiber.NewError(fiber.StatusNotFound, "Project flock kandang not found")
+    }
+    if err != nil {
+        s.Log.Errorf("Failed to fetch project_flock_kandang %d: %+v", projectFlockKandangID, err)
+        return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock kandang")
+    }
 
-	return &FlockPeriodSummary{
-		Flock:      *flock,
-		NextPeriod: maxPeriod + 1,
-	}, nil
+    var baseName string
+    var referenceFlock *entity.Flock
+    if pivot.ProjectFlock.Id != 0 {
+        baseName = pfutils.DeriveBaseName(pivot.ProjectFlock.FlockName)
+    }
+
+    if strings.TrimSpace(baseName) != "" {
+        referenceFlock, err = s.FlockRepo.GetByName(c.Context(), baseName)
+        if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+            s.Log.Errorf("Failed to fetch flock %q: %+v", baseName, err)
+            return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch flock")
+        }
+    }
+
+    if referenceFlock == nil {
+        referenceFlock = &entity.Flock{Name: pivot.ProjectFlock.FlockName}
+    }
+
+    maxPeriod := pivot.ProjectFlock.Period
+    if strings.TrimSpace(baseName) != "" {
+        if headerMax, err := s.Repository.GetMaxPeriodByBaseName(c.Context(), baseName); err != nil {
+            s.Log.Warnf("Unable to compute header period for base %q: %+v", baseName, err)
+        } else if headerMax > maxPeriod {
+            maxPeriod = headerMax
+        }
+
+        if pivotMax, err := s.pivotRepo().MaxPeriodByBaseName(c.Context(), baseName); err != nil {
+            s.Log.Warnf("Unable to compute pivot period for base %q: %+v", baseName, err)
+        } else if pivotMax > maxPeriod {
+            maxPeriod = pivotMax
+        }
+    }
+
+    return &FlockPeriodSummary{
+        Flock:      *referenceFlock,
+        NextPeriod: maxPeriod + 1,
+    }, nil
 }
 
 func uniqueUintSlice(values []uint) []uint {