Merge branch 'feat/BE/Sprint-7' of https://gitlab.com/mbugroup/lti-api into feat/BE/US-304/permission-middleware-adjustment

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

@@ -165,33 +165,6 @@ func (u *ProjectflockController) CreateOne(c *fiber.Ctx) error {
 		})
 }
 
-func (u *ProjectflockController) UpdateOne(c *fiber.Ctx) error {
-	req := new(validation.Update)
-	param := c.Params("id")
-
-	id, err := strconv.Atoi(param)
-	if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
-	}
-
-	if err := c.BodyParser(req); err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
-	}
-
-	result, err := u.ProjectflockService.UpdateOne(c, req, uint(id))
-	if err != nil {
-		return err
-	}
-
-	return c.Status(fiber.StatusOK).
-		JSON(response.Success{
-			Code:    fiber.StatusOK,
-			Status:  "success",
-			Message: "Update projectflock successfully",
-			Data:    dto.ToProjectFlockListDTO(*result),
-		})
-}
-
 func (u *ProjectflockController) DeleteOne(c *fiber.Ctx) error {
 	param := c.Params("id")
 
@@ -308,7 +281,6 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 	dtoResult := dto.ToProjectFlockKandangDTO(*result)
 	dtoResult.AvailableQuantity = float64(availableStock)
 
-	// populate available quantity for each kandang inside project_flock
 	if dtoResult.ProjectFlock != nil {
 		for i := range dtoResult.ProjectFlock.Kandangs {
 			kand := &dtoResult.ProjectFlock.Kandangs[i]
@@ -319,7 +291,7 @@ func (u *ProjectflockController) LookupProjectFlockKandang(c *fiber.Ctx) error {
 				kand.AvailableQuantity = q
 			}
 		}
-		// remove inner kandangs from project_flock to avoid duplication
+
 		dtoResult.ProjectFlock.Kandangs = nil
 	}
 

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

@@ -1,6 +1,8 @@
 package repository
 
 import (
+	"context"
+
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gorm.io/gorm"
@@ -8,6 +10,7 @@ import (
 
 type ProjectBudgetRepository interface {
 	repository.BaseRepository[entity.ProjectBudget]
+	GetByProjectFlockID(ctx context.Context, projectFlockID uint) ([]entity.ProjectBudget, error)
 }
 
 type ProjectBudgetRepositoryImpl struct {
@@ -21,3 +24,13 @@ func NewProjectBudgetRepository(db *gorm.DB) ProjectBudgetRepository {
 		db:                 db,
 	}
 }
+
+func (r *ProjectBudgetRepositoryImpl) GetByProjectFlockID(ctx context.Context, projectFlockID uint) ([]entity.ProjectBudget, error) {
+	var budgets []entity.ProjectBudget
+	err := r.db.WithContext(ctx).
+		Where("project_flock_id = ?", projectFlockID).
+		Preload("Nonstock").
+		Preload("Nonstock.Uom").
+		Find(&budgets).Error
+	return budgets, err
+}

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

@@ -3,6 +3,7 @@ package repository
 import (
 	"context"
 	"strings"
+	"time"
 
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
@@ -14,18 +15,21 @@ type ProjectFlockKandangRepository interface {
 	GetByID(ctx context.Context, id uint) (*entity.ProjectFlockKandang, error)
 	GetByProjectFlockAndKandang(ctx context.Context, projectFlockID uint, kandangID uint) (*entity.ProjectFlockKandang, error)
 	GetActiveByKandangID(ctx context.Context, kandangID uint) (*entity.ProjectFlockKandang, error)
+	UpdateClosedAt(ctx context.Context, id uint, t *time.Time) error
 	CreateMany(ctx context.Context, records []*entity.ProjectFlockKandang) error
 	DeleteMany(ctx context.Context, projectFlockID uint, kandangIDs []uint) error
 	GetAll(ctx context.Context, offset int, limit int, modifier func(*gorm.DB) *gorm.DB) ([]entity.ProjectFlockKandang, int64, error)
 	GetAllWithFilters(ctx context.Context, offset int, limit int, params interface{}) ([]entity.ProjectFlockKandang, int64, error)
+	GetByProjectFlockID(ctx context.Context, projectFlockID uint) ([]entity.ProjectFlockKandang, error)
 	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)
 	ProjectPeriodsByProjectIDs(ctx context.Context, projectIDs []uint) (map[uint]int, error)
+	HasOpenNewerPeriod(ctx context.Context, kandangID uint, currentPeriod int, excludeID *uint) (bool, error)
 	WithTx(tx *gorm.DB) ProjectFlockKandangRepository
-	IdExists(ctx context.Context, id uint) (bool, error)
 	DB() *gorm.DB
+	IdExists(ctx context.Context, id uint) (bool, error)
 }
 
 type projectFlockKandangRepositoryImpl struct {
@@ -75,6 +79,16 @@ func (r *projectFlockKandangRepositoryImpl) GetAll(ctx context.Context, offset i
 	return records, total, nil
 }
 
+func (r *projectFlockKandangRepositoryImpl) GetByProjectFlockID(ctx context.Context, projectFlockID uint) ([]entity.ProjectFlockKandang, error) {
+	var records []entity.ProjectFlockKandang
+	if err := r.db.WithContext(ctx).
+		Where("project_flock_id = ?", projectFlockID).
+		Find(&records).Error; err != nil {
+		return nil, err
+	}
+	return records, nil
+}
+
 func (r *projectFlockKandangRepositoryImpl) GetAllWithFilters(ctx context.Context, offset int, limit int, params interface{}) ([]entity.ProjectFlockKandang, int64, error) {
 	var records []entity.ProjectFlockKandang
 	var total int64
@@ -104,10 +118,10 @@ func (r *projectFlockKandangRepositoryImpl) GetAllWithFilters(ctx context.Contex
 				AND "approvals"."approvable_type" = ?
 				AND LOWER("approvals"."step_name") = LOWER(?)
 				AND "approvals"."id" IN (
-					SELECT "id" FROM "approvals"
-					WHERE "approvable_id" = "project_flock_kandangs"."id"
-					AND "approvable_type" = ?
-					ORDER BY "action_at" DESC
+					SELECT "approvals"."id" FROM "approvals"
+					WHERE "approvals"."approvable_id" = "project_flock_kandangs"."id"
+					AND "approvals"."approvable_type" = ?
+					ORDER BY "approvals"."id" DESC
 					LIMIT 1
 				)
 			)
@@ -223,32 +237,57 @@ func (r *projectFlockKandangRepositoryImpl) GetByProjectFlockAndKandang(ctx cont
 }
 
 func (r *projectFlockKandangRepositoryImpl) GetActiveByKandangID(ctx context.Context, kandangID uint) (*entity.ProjectFlockKandang, error) {
-	record := new(entity.ProjectFlockKandang)
+	latestApprovalSubQuery := r.db.
+		Table("approvals").
+		Select("DISTINCT ON (approvable_id) approvable_id, step_name, id").
+		Where("approvable_type = ?", "PROJECT_FLOCKS").
+		Order("approvable_id, id DESC")
+
+	var pfkID uint
 	if err := r.db.WithContext(ctx).
+		Model(&entity.ProjectFlockKandang{}).
 		Joins("JOIN project_flocks ON project_flocks.id = project_flock_kandangs.project_flock_id").
-		Joins(`
-			INNER JOIN (
-				SELECT DISTINCT ON (approvable_id) approvable_id, step_name, action_at
-				FROM approvals
-				WHERE approvable_type = 'PROJECT_FLOCKS'
-				ORDER BY approvable_id, action_at DESC
-			) latest_approval ON latest_approval.approvable_id = project_flocks.id
-		`).
+		Joins("JOIN (?) AS latest_approval ON latest_approval.approvable_id = project_flocks.id", latestApprovalSubQuery).
 		Where("project_flock_kandangs.kandang_id = ?", kandangID).
+		Where("project_flock_kandangs.closed_at IS NULL").
 		Where("LOWER(latest_approval.step_name) = LOWER(?)", "Aktif").
 		Order("project_flock_kandangs.id DESC").
-		Preload("ProjectFlock").
-		Preload("ProjectFlock.Fcr").
-		Preload("ProjectFlock.Area").
-		Preload("ProjectFlock.Location").
-		Preload("ProjectFlock.CreatedUser").
-		Preload("ProjectFlock.Kandangs").
-		Preload("ProjectFlock.KandangHistory").
-		Preload("Kandang").
-		First(record).Error; err != nil {
+		Limit(1).
+		Pluck("project_flock_kandangs.id", &pfkID).Error; err != nil {
 		return nil, err
 	}
-	return record, nil
+
+	if pfkID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	return r.GetByID(ctx, pfkID)
+}
+
+func (r *projectFlockKandangRepositoryImpl) UpdateClosedAt(ctx context.Context, id uint, t *time.Time) error {
+	return r.db.WithContext(ctx).
+		Model(&entity.ProjectFlockKandang{}).
+		Where("id = ?", id).
+		Update("closed_at", t).Error
+}
+
+func (r *projectFlockKandangRepositoryImpl) HasOpenNewerPeriod(ctx context.Context, kandangID uint, currentPeriod int, excludeID *uint) (bool, error) {
+	if kandangID == 0 {
+		return false, nil
+	}
+	q := r.db.WithContext(ctx).
+		Table("project_flock_kandangs").
+		Where("kandang_id = ?", kandangID).
+		Where("period > ?", currentPeriod).
+		Where("closed_at IS NULL")
+	if excludeID != nil {
+		q = q.Where("id <> ?", *excludeID)
+	}
+	var count int64
+	if err := q.Count(&count).Error; err != nil {
+		return false, err
+	}
+	return count > 0, nil
 }
 
 func (r *projectFlockKandangRepositoryImpl) ListExistingKandangIDs(ctx context.Context, projectFlockID uint, kandangIDs []uint) ([]uint, error) {
@@ -269,7 +308,8 @@ func (r *projectFlockKandangRepositoryImpl) HasKandangsLinkedToOtherProject(ctx
 	}
 	q := r.db.WithContext(ctx).
 		Table("project_flock_kandangs").
-		Where("kandang_id IN ?", kandangIDs)
+		Where("kandang_id IN ?", kandangIDs).
+		Where("closed_at IS NULL")
 	if exceptProjectID != nil {
 		q = q.Where("project_flock_id <> ?", *exceptProjectID)
 	}

internal/modules/production/project_flocks/route.go

@@ -18,7 +18,6 @@ func ProjectflockRoutes(v1 fiber.Router, u user.UserService, s projectflock.Proj
 	route.Get("/",m.RequirePermissions(m.P_ProjectFlockGetAll),ctrl.GetAll)
 	route.Post("/",m.RequirePermissions(m.P_ProjectFlockCreate), ctrl.CreateOne)
 	route.Get("/:id",m.RequirePermissions(m.P_ProjectFlockGetOne), ctrl.GetOne)
-	route.Patch("/:id",m.RequirePermissions(m.P_ProjectFlockUpdate), ctrl.UpdateOne)
 	route.Delete("/:id",m.RequirePermissions(m.P_ProjectFlockGetAll), ctrl.DeleteOne)
 	route.Get("/kandangs/lookup",m.RequirePermissions(m.P_ProjectFlockLookup), ctrl.LookupProjectFlockKandang)
 	route.Post("/approvals",m.RequirePermissions(m.P_ProjectFlockApprove), ctrl.Approval)

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

@@ -34,7 +34,6 @@ type ProjectflockService interface {
 	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, map[uint]*flockDTO.FlockRelationDTO, error)
 	GetOne(ctx *fiber.Ctx, id uint) (*entity.ProjectFlock, *flockDTO.FlockRelationDTO, error)
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.ProjectFlock, error)
-	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectFlock, error)
 	GetAvailableDocQuantity(ctx *fiber.Ctx, kandangID uint) (float64, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	GetProjectFlockKandangByProjectAndKandang(ctx *fiber.Ctx, projectFlockID uint, kandangID uint) (*entity.ProjectFlockKandang, float64, error)
@@ -255,6 +254,16 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 		return nil, err
 	}
 
+	var location entity.Location
+	if err := s.Repository.DB().WithContext(c.Context()).
+		Where("id = ? AND area_id = ?", req.LocationId, req.AreaId).
+		First(&location).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusBadRequest, "Lokasi tidak berada pada area yang diminta")
+		}
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Gagal memvalidasi relasi area-lokasi")
+	}
+
 	canonicalBase := baseName
 	if s.FlockRepo != nil {
 		baseFlock, err := s.ensureFlockByName(c.Context(), actorID, baseName)
@@ -348,365 +357,6 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 	return s.getOneEntityOnly(c, createBody.Id)
 }
 
-func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectFlock, error) {
-	if err := s.Validate.Struct(req); err != nil {
-		return nil, err
-	}
-
-	actorID, err := m.ActorIDFromContext(c)
-	if err != nil {
-		return nil, err
-	}
-
-	existing, err := s.Repository.GetByID(c.Context(), id, s.Repository.WithDefaultRelations())
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
-	}
-	if err != nil {
-		s.Log.Errorf("Failed to fetch projectflock %d before update: %+v", id, err)
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch project flock")
-	}
-	updateBody := make(map[string]any)
-	hasBodyChanges := false
-	var relationChecks []commonSvc.RelationCheck
-	existingBase := pfutils.DeriveBaseName(existing.FlockName)
-	targetBaseName := existingBase
-	needFlockNameRegenerate := false
-
-	if req.FlockName != nil {
-		trimmed := strings.TrimSpace(*req.FlockName)
-		if trimmed == "" {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Flock name cannot be empty")
-		}
-		canonicalBase := trimmed
-		if s.FlockRepo != nil {
-			flockEntity, err := s.ensureFlockByName(c.Context(), actorID, trimmed)
-			if err != nil {
-				return nil, err
-			}
-			canonicalBase = flockEntity.Name
-		}
-		if !strings.EqualFold(canonicalBase, existingBase) {
-			needFlockNameRegenerate = true
-			targetBaseName = canonicalBase
-			hasBodyChanges = true
-		}
-	}
-	if req.AreaId != nil {
-		updateBody["area_id"] = *req.AreaId
-		hasBodyChanges = true
-		relationChecks = append(relationChecks, commonSvc.RelationCheck{
-			Name:   "Area",
-			ID:     req.AreaId,
-			Exists: s.Repository.AreaExists,
-		})
-	}
-	if req.Category != nil {
-		cat := strings.ToUpper(*req.Category)
-		if !utils.IsValidProjectFlockCategory(cat) {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid category")
-		}
-
-		updateBody["category"] = cat
-	}
-	if req.FcrId != nil {
-		updateBody["fcr_id"] = *req.FcrId
-		hasBodyChanges = true
-		relationChecks = append(relationChecks, commonSvc.RelationCheck{
-			Name:   "FCR",
-			ID:     req.FcrId,
-			Exists: s.Repository.FcrExists,
-		})
-	}
-	if req.LocationId != nil {
-		updateBody["location_id"] = *req.LocationId
-		hasBodyChanges = true
-		relationChecks = append(relationChecks, commonSvc.RelationCheck{
-			Name:   "Location",
-			ID:     req.LocationId,
-			Exists: s.Repository.LocationExists,
-		})
-	}
-
-	if len(relationChecks) > 0 {
-		if err := commonSvc.EnsureRelations(c.Context(), relationChecks...); err != nil {
-			return nil, err
-		}
-	}
-
-	var newKandangIDs []uint
-	hasKandangChanges := false
-	if req.KandangIds != nil {
-		hasKandangChanges = true
-		if len(req.KandangIds) == 0 {
-			return nil, fiber.NewError(fiber.StatusBadRequest, "kandang_ids cannot be empty")
-		}
-		newKandangIDs = uniqueUintSlice(req.KandangIds)
-		kandangs, err := s.KandangRepo.GetByIDs(c.Context(), newKandangIDs, nil)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return nil, fiber.NewError(fiber.StatusNotFound, "Some kandangs not found")
-			}
-			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch kandangs")
-		}
-		if len(kandangs) != len(newKandangIDs) {
-			return nil, fiber.NewError(fiber.StatusNotFound, "Some kandangs not found")
-		}
-		targetLocationID := existing.LocationId
-		if req.LocationId != nil && *req.LocationId > 0 {
-			targetLocationID = *req.LocationId
-		}
-		for _, kandang := range kandangs {
-			if kandang.LocationId != targetLocationID {
-				return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Kandang %d tidak berada pada lokasi yang sama dengan project flock", kandang.Id))
-			}
-		}
-		if linked, err := s.pivotRepo().HasKandangsLinkedToOtherProject(c.Context(), newKandangIDs, &id); err != nil {
-			return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate kandangs linkage")
-		} else if linked {
-			return nil, fiber.NewError(fiber.StatusConflict, "Beberapa kandang sudah terikat dengan project flock lain")
-		}
-
-	}
-
-	hasChanges := hasBodyChanges || hasKandangChanges
-	if !hasChanges {
-		return s.getOneEntityOnly(c, id)
-	}
-
-	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
-		projectRepo := repository.NewProjectflockRepository(dbTransaction)
-
-		baseForGeneration := targetBaseName
-		if strings.TrimSpace(baseForGeneration) == "" {
-			baseForGeneration = existingBase
-		}
-		if strings.TrimSpace(baseForGeneration) == "" {
-			baseForGeneration = strings.TrimSpace(existing.FlockName)
-		}
-
-		if needFlockNameRegenerate {
-			newName, _, err := s.generateSequentialFlockName(c.Context(), projectRepo, baseForGeneration, 1, &id)
-			if err != nil {
-				return err
-			}
-			updateBody["flock_name"] = newName
-		}
-
-		if len(updateBody) > 0 {
-			if err := projectRepo.PatchOne(c.Context(), id, updateBody, nil); err != nil {
-				return err
-			}
-		} else {
-			if _, err := projectRepo.GetByID(c.Context(), id, nil); err != nil {
-				return err
-			}
-		}
-
-		if req.KandangIds != nil {
-			existingIDs := make(map[uint]struct{}, len(existing.Kandangs))
-			for _, k := range existing.Kandangs {
-				existingIDs[k.Id] = struct{}{}
-			}
-			newSet := make(map[uint]struct{}, len(newKandangIDs))
-			for _, kid := range newKandangIDs {
-				newSet[kid] = struct{}{}
-			}
-
-			var toDetach []uint
-			for kid := range existingIDs {
-				if _, ok := newSet[kid]; !ok {
-					toDetach = append(toDetach, kid)
-				}
-			}
-
-			var toAttach []uint
-			for kid := range newSet {
-				if _, ok := existingIDs[kid]; !ok {
-					toAttach = append(toAttach, kid)
-				}
-			}
-
-			if len(toDetach) > 0 {
-				if err := s.detachKandangs(c.Context(), dbTransaction, id, toDetach, true); err != nil {
-					return err
-				}
-			}
-
-			if len(toAttach) > 0 {
-				currentPeriod, err := projectRepo.GetCurrentProjectPeriod(c.Context(), id)
-				if err != nil {
-					return err
-				}
-
-				periods := make(map[uint]int, len(toAttach))
-				if currentPeriod > 0 {
-					for _, kid := range toAttach {
-						periods[kid] = currentPeriod
-					}
-				} else {
-					periods, err = projectRepo.GetNextPeriodsForKandangs(c.Context(), toAttach)
-					if err != nil {
-						return err
-					}
-				}
-
-				if err := s.attachKandangs(c.Context(), dbTransaction, id, toAttach, periods); err != nil {
-					return err
-				}
-			}
-		}
-
-		if hasChanges {
-			approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
-			if approvalSvc != nil {
-				latestBeforeReset, err := approvalSvc.LatestByTarget(c.Context(), s.approvalWorkflow, id, nil)
-				if err != nil {
-					return err
-				}
-				shouldRecordUpdate := latestBeforeReset == nil ||
-					latestBeforeReset.StepNumber != uint16(utils.ProjectFlockStepPengajuan) ||
-					latestBeforeReset.Action == nil ||
-					(latestBeforeReset.Action != nil && *latestBeforeReset.Action != entity.ApprovalActionUpdated)
-
-				if shouldRecordUpdate {
-					action := entity.ApprovalActionUpdated
-					if _, err := approvalSvc.CreateApproval(
-						c.Context(),
-						utils.ApprovalWorkflowProjectFlock,
-						id,
-						utils.ProjectFlockStepPengajuan,
-						&action,
-						actorID,
-						nil,
-					); err != nil {
-						return err
-					}
-				}
-			}
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		if fiberErr, ok := err.(*fiber.Error); ok {
-			return nil, fiberErr
-		}
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
-		}
-		s.Log.Errorf("Failed to update projectflock %d: %+v", id, err)
-		if errors.Is(err, gorm.ErrDuplicatedKey) {
-			return nil, fiber.NewError(fiber.StatusConflict, "Project flock period already exists")
-		}
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to update project flock")
-	}
-
-	return s.getOneEntityOnly(c, id)
-}
-
-func (s projectflockService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlock, error) {
-	if err := s.Validate.Struct(req); err != nil {
-		return nil, err
-	}
-
-	actorID, err := m.ActorIDFromContext(c)
-	if err != nil {
-		return nil, err
-	}
-
-	var action entity.ApprovalAction
-	switch strings.ToUpper(strings.TrimSpace(req.Action)) {
-	case string(entity.ApprovalActionRejected):
-		action = entity.ApprovalActionRejected
-	case string(entity.ApprovalActionApproved):
-		action = entity.ApprovalActionApproved
-	default:
-		return nil, fiber.NewError(fiber.StatusBadRequest, "action must be APPROVED or REJECTED")
-	}
-
-	approvableIDs := uniqueUintSlice(req.ApprovableIds)
-	if len(approvableIDs) == 0 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "approvable_ids must contain at least one id")
-	}
-
-	step := utils.ProjectFlockStepPengajuan
-	if action == entity.ApprovalActionApproved {
-		step = utils.ProjectFlockStepAktif
-	}
-
-	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
-		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
-		kandangRepoTx := kandangRepository.NewKandangRepository(dbTransaction)
-		projectRepoTx := repository.NewProjectflockRepository(dbTransaction)
-
-		for _, approvableID := range approvableIDs {
-			if _, err := projectRepoTx.GetByID(c.Context(), approvableID, nil); err != nil {
-				if errors.Is(err, gorm.ErrRecordNotFound) {
-					return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Projectflock %d not found", approvableID))
-				}
-				return err
-			}
-
-			if _, err := approvalSvc.CreateApproval(
-				c.Context(),
-				utils.ApprovalWorkflowProjectFlock,
-				approvableID,
-				step,
-				&action,
-				actorID,
-				req.Notes,
-			); err != nil {
-				return err
-			}
-
-			switch action {
-			case entity.ApprovalActionApproved:
-				if err := kandangRepoTx.UpdateStatusByProjectFlockID(
-					c.Context(),
-					approvableID,
-					utils.KandangStatusActive,
-				); err != nil {
-					return err
-				}
-			case entity.ApprovalActionRejected:
-				if err := kandangRepoTx.UpdateStatusByProjectFlockID(
-					c.Context(),
-					approvableID,
-					utils.KandangStatusNonActive,
-				); err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		if fiberErr, ok := err.(*fiber.Error); ok {
-			return nil, fiberErr
-		}
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
-		}
-		s.Log.Errorf("Failed to record approval for projectflocks %+v: %+v", approvableIDs, err)
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to record approval")
-	}
-
-	updated := make([]entity.ProjectFlock, 0, len(approvableIDs))
-	for _, approvableID := range approvableIDs {
-		project, err := s.getOneEntityOnly(c, approvableID)
-		if err != nil {
-			return nil, err
-		}
-		updated = append(updated, *project)
-	}
-
-	return updated, nil
-}
-
 func (s projectflockService) DeleteOne(c *fiber.Ctx, id uint) error {
 	existing, err := s.Repository.GetByID(c.Context(), id, s.Repository.WithDefaultRelations())
 	if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -827,6 +477,27 @@ func (s projectflockService) GetAvailableDocQuantity(ctx *fiber.Ctx, kandangID u
 	return total, nil
 }
 
+// getProjectFlockClosingDate mengembalikan tanggal closing Project Flock jika sudah mencapai step SELESAI (Approved).
+// func (s projectflockService) getProjectFlockClosingDate(ctx context.Context, projectFlockID uint) (*time.Time, error) {
+// 	if projectFlockID == 0 || s.ApprovalSvc == nil {
+// 		return nil, nil
+// 	}
+
+// 	latest, err := s.ApprovalSvc.LatestByTarget(ctx, utils.ApprovalWorkflowProjectFlock, projectFlockID, nil)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	if latest == nil || latest.Action == nil || *latest.Action != entity.ApprovalActionApproved {
+// 		return nil, nil
+// 	}
+// 	if latest.StepNumber != uint16(utils.ProjectFlockStepSelesai) {
+// 		return nil, nil
+// 	}
+
+// 	t := latest.ActionAt
+// 	return &t, nil
+// }
+
 func (s projectflockService) GetProjectPeriods(c *fiber.Ctx, projectIDs []uint) (map[uint]int, error) {
 	if len(projectIDs) == 0 {
 		return map[uint]int{}, nil
@@ -834,6 +505,133 @@ func (s projectflockService) GetProjectPeriods(c *fiber.Ctx, projectIDs []uint)
 	return s.pivotRepo().ProjectPeriodsByProjectIDs(c.Context(), projectIDs)
 }
 
+func (s projectflockService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.ProjectFlock, error) {
+	if err := s.Validate.Struct(req); err != nil {
+		return nil, err
+	}
+
+	actorID, err := m.ActorIDFromContext(c)
+	if err != nil {
+		return nil, err
+	}
+
+	var action entity.ApprovalAction
+	switch strings.ToUpper(strings.TrimSpace(req.Action)) {
+	case string(entity.ApprovalActionRejected):
+		action = entity.ApprovalActionRejected
+	case string(entity.ApprovalActionApproved):
+		action = entity.ApprovalActionApproved
+	default:
+		return nil, fiber.NewError(fiber.StatusBadRequest, "action must be APPROVED or REJECTED")
+	}
+
+	approvableIDs := uniqueUintSlice(req.ApprovableIds)
+	if len(approvableIDs) == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "approvable_ids must contain at least one id")
+	}
+
+	step := utils.ProjectFlockStepPengajuan
+	if action == entity.ApprovalActionApproved {
+		step = utils.ProjectFlockStepAktif
+	}
+
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
+		kandangRepoTx := kandangRepository.NewKandangRepository(dbTransaction)
+		projectRepoTx := repository.NewProjectflockRepository(dbTransaction)
+		projectFlockKandangRepoTx := repository.NewProjectFlockKandangRepository(dbTransaction)
+
+		for _, approvableID := range approvableIDs {
+			if _, err := projectRepoTx.GetByID(c.Context(), approvableID, nil); err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("Projectflock %d not found", approvableID))
+				}
+				return err
+			}
+
+			if _, err := approvalSvc.CreateApproval(
+				c.Context(),
+				utils.ApprovalWorkflowProjectFlock,
+				approvableID,
+				step,
+				&action,
+				actorID,
+				req.Notes,
+			); err != nil {
+				return err
+			}
+
+			switch action {
+			case entity.ApprovalActionApproved:
+				if err := kandangRepoTx.UpdateStatusByProjectFlockID(
+					c.Context(),
+					approvableID,
+					utils.KandangStatusActive,
+				); err != nil {
+					return err
+				}
+
+				pfks, err := projectFlockKandangRepoTx.GetByProjectFlockID(c.Context(), approvableID)
+				if err != nil {
+					return err
+				}
+				for _, pfk := range pfks {
+					latest, lerr := approvalSvc.LatestByTarget(c.Context(), utils.ApprovalWorkflowProjectFlockKandang, pfk.Id, nil)
+					if lerr != nil {
+						return lerr
+					}
+					if latest != nil && latest.StepNumber == uint16(utils.ProjectFlockKandangStepDisetujui) {
+						continue
+					}
+					if _, aerr := approvalSvc.CreateApproval(
+						c.Context(),
+						utils.ApprovalWorkflowProjectFlockKandang,
+						pfk.Id,
+						utils.ProjectFlockKandangStepDisetujui,
+						&action,
+						actorID,
+						req.Notes,
+					); aerr != nil && !errors.Is(aerr, gorm.ErrDuplicatedKey) {
+						return aerr
+					}
+				}
+			case entity.ApprovalActionRejected:
+				if err := kandangRepoTx.UpdateStatusByProjectFlockID(
+					c.Context(),
+					approvableID,
+					utils.KandangStatusNonActive,
+				); err != nil {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return nil, fiberErr
+		}
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
+		}
+		s.Log.Errorf("Failed to record approval for projectflocks %+v: %+v", approvableIDs, err)
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to record approval")
+	}
+
+	updated := make([]entity.ProjectFlock, 0, len(approvableIDs))
+	for _, approvableID := range approvableIDs {
+		project, err := s.getOneEntityOnly(c, approvableID)
+		if err != nil {
+			return nil, err
+		}
+		updated = append(updated, *project)
+	}
+
+	return updated, nil
+}
+
 func (s projectflockService) GetPeriodSummary(c *fiber.Ctx, locationID uint) ([]KandangPeriodSummary, error) {
 	if locationID == 0 {
 		return nil, fiber.NewError(fiber.StatusBadRequest, "location_id is required")

internal/modules/production/project_flocks/validations/projectflock.validation.go

@@ -10,15 +10,6 @@ type Create struct {
 	ProjectBudgets []ProjectBudget `json:"project_budgets" validate:"required,min=1,dive"`
 }
 
-type Update struct {
-	FlockName  *string `json:"flock_name,omitempty" validate:"omitempty"`
-	AreaId     *uint   `json:"area_id,omitempty" validate:"omitempty,number,gt=0"`
-	Category   *string `json:"category,omitempty" validate:"omitempty"`
-	FcrId      *uint   `json:"fcr_id,omitempty" validate:"omitempty,number,gt=0"`
-	LocationId *uint   `json:"location_id,omitempty" validate:"omitempty,number,gt=0"`
-	KandangIds []uint  `json:"kandang_ids,omitempty" validate:"omitempty,min=1,dive,gt=0"`
-}
-
 type Query struct {
 	Page       int    `query:"page" validate:"omitempty,number,min=1"`
 	Limit      int    `query:"limit" validate:"omitempty,number,min=1,max=100"`