Feat[BE]: refactored Chickin createone and implement approvals and add more needed constant

internal/modules/production/chickins/controllers/chickin.controller.go

@@ -139,23 +139,33 @@ func (u *ChickinController) DeleteOne(c *fiber.Ctx) error {
 		})
 }
 
-func (u *ChickinController) Approve(c *fiber.Ctx) error {
-	param := c.Params("id")
-
-	id, err := strconv.Atoi(param)
-	if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+func (u *ChickinController) Approval(c *fiber.Ctx) error {
+	req := new(validation.Approve)
+	if err := c.BodyParser(req); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
 	}
 
-	if err := u.ChickinService.Approve(c, uint(id)); err != nil {
+	results, err := u.ChickinService.Approval(c, req)
+	if err != nil {
 		return err
 	}
 
+	var (
+		data    interface{}
+		message = "Submit chickin approval successfully"
+	)
+	if len(results) == 1 {
+		data = dto.ToChickinListDTO(results[0])
+	} else {
+		message = "Submit chickin approvals successfully"
+		data = dto.ToChickinListDTOs(results)
+	}
+
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{
 			Code:    fiber.StatusOK,
 			Status:  "success",
-			Message: "Approve chickin successfully",
-			Data:    nil,
+			Message: message,
+			Data:    data,
 		})
 }

internal/modules/production/chickins/dto/chickin.dto.go

@@ -18,8 +18,10 @@ type ChickinBaseDTO struct {
 	Id                  uint                    `json:"id"`
 	ProjectFlockKandang *ProjectFlockKandangDTO `json:"project_flock_kandang"`
 	ChickInDate         time.Time               `json:"chick_in_date"`
-	Quantity            float64                 `json:"quantity"`
-	Note                string                  `json:"note"`
+	ProductWarehouseId  uint                    `json:"product_warehouse_id"`
+	UsageQty            float64                 `json:"usage_qty"`
+	PendingUsageQty     float64                 `json:"pending_usage_qty"`
+	Notes               string                  `json:"notes"`
 }
 
 type ProjectFlockDTO struct {
@@ -44,8 +46,10 @@ type ChickinSimpleDTO struct {
 	Id                    uint      `json:"id"`
 	ProjectFlockKandangId uint      `json:"project_flock_kandang_id"`
 	ChickInDate           time.Time `json:"chick_in_date"`
-	Quantity              float64   `json:"quantity"`
-	Note                  string    `json:"note"`
+	ProductWarehouseId    uint      `json:"product_warehouse_id"`
+	UsageQty              float64   `json:"usage_qty"`
+	PendingUsageQty       float64   `json:"pending_usage_qty"`
+	Notes                 string    `json:"notes"`
 	CreatedBy             uint      `json:"created_by"`
 }
 
@@ -138,16 +142,18 @@ func ToProjectFlockKandangDTO(e entity.ProjectFlockKandang) ProjectFlockKandangD
 
 func ToChickinBaseDTO(e entity.ProjectChickin) ChickinBaseDTO {
 	var pfk *ProjectFlockKandangDTO
-	if e.ProjectFlockKandang.Id != 0 {
-		mapped := ToProjectFlockKandangDTO(e.ProjectFlockKandang)
+	if e.ProjectFlockKandang != nil && e.ProjectFlockKandang.Id != 0 {
+		mapped := ToProjectFlockKandangDTO(*e.ProjectFlockKandang)
 		pfk = &mapped
 	}
 	return ChickinBaseDTO{
 		Id:                  e.Id,
 		ProjectFlockKandang: pfk,
 		ChickInDate:         e.ChickInDate,
-		Quantity:            e.Quantity,
-		Note:                e.Note,
+		ProductWarehouseId:  e.ProductWarehouseId,
+		UsageQty:            e.UsageQty,
+		PendingUsageQty:     e.PendingUsageQty,
+		Notes:               e.Notes,
 	}
 }
 
@@ -156,21 +162,23 @@ func ToChickinSimpleDTO(e entity.ProjectChickin) ChickinSimpleDTO {
 		Id:                    e.Id,
 		ProjectFlockKandangId: e.ProjectFlockKandangId,
 		ChickInDate:           e.ChickInDate,
-		Quantity:              e.Quantity,
-		Note:                  e.Note,
+		ProductWarehouseId:    e.ProductWarehouseId,
+		UsageQty:              e.UsageQty,
+		PendingUsageQty:       e.PendingUsageQty,
+		Notes:                 e.Notes,
 		CreatedBy:             e.CreatedBy,
 	}
 }
 
 func ToChickinListDTO(e entity.ProjectChickin) ChickinListDTO {
 	var createdUser *userBaseDTO.UserBaseDTO
-	if e.CreatedUser.Id != 0 {
-		mapped := userBaseDTO.ToUserBaseDTO(e.CreatedUser)
+	if e.CreatedUser != nil && e.CreatedUser.Id != 0 {
+		mapped := userBaseDTO.ToUserBaseDTO(*e.CreatedUser)
 		createdUser = &mapped
 	}
 	var pfk *ProjectFlockKandangDTO
-	if e.ProjectFlockKandang.Id != 0 {
-		mapped := ToProjectFlockKandangDTO(e.ProjectFlockKandang)
+	if e.ProjectFlockKandang != nil && e.ProjectFlockKandang.Id != 0 {
+		mapped := ToProjectFlockKandangDTO(*e.ProjectFlockKandang)
 		pfk = &mapped
 	}
 	return ChickinListDTO{

internal/modules/production/chickins/module.go

@@ -1,10 +1,15 @@
 package chickins
 
 import (
+	"fmt"
+
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
 	"gorm.io/gorm"
 
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+
 	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	rKandang "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
 	rWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/master/warehouses/repositories"
@@ -15,6 +20,8 @@ import (
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+
+	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
 )
 
 type ChickinModule struct{}
@@ -32,6 +39,12 @@ func (ChickinModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *
 
 	userRepo := rUser.NewUserRepository(db)
 
+	approvalRepo := commonRepo.NewApprovalRepository(db)
+	approvalService := commonSvc.NewApprovalService(approvalRepo)
+	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowProjectFlockKandang, utils.ProjectFlockKandangApprovalSteps); err != nil {
+		panic(fmt.Sprintf("failed to register project flock kandang approval workflow: %v", err))
+	}
+
 	chickinService := sChickin.NewChickinService(chickinRepo, kandangRepo, warehouseRepo, productWarehouseRepo, projectFlockRepo, projectflockkandangrepo, projectflockpopulationrepo, chickinDetailRepo, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 

internal/modules/production/chickins/route.go

@@ -25,5 +25,5 @@ func ChickinRoutes(v1 fiber.Router, u user.UserService, s chickin.ChickinService
 	route.Get("/:id", ctrl.GetOne)
 	route.Patch("/:id", ctrl.UpdateOne)
 	route.Delete("/:id", ctrl.DeleteOne)
-	route.Post("/:id/approve", ctrl.Approve)
+	route.Post("/approvals", ctrl.Approval)
 }

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

@@ -2,7 +2,11 @@ package service
 
 import (
 	"errors"
+	"fmt"
+	"strings"
 
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	rProductWarehouse "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	KandangRepo "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
@@ -24,7 +28,7 @@ type ChickinService interface {
 	CreateOne(ctx *fiber.Ctx, req *validation.Create) (*entity.ProjectChickin, error)
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
-	Approve(ctx *fiber.Ctx, id uint) error
+	Approval(ctx *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error)
 }
 
 type chickinService struct {
@@ -110,107 +114,98 @@ func (s *chickinService) CreateOne(c *fiber.Ctx, req *validation.Create) (*entit
 		return nil, err
 	}
 
-	projectflockkandang, err := s.ProjectflockKandangRepo.GetByID(c.Context(), req.ProjectFlockKandangId)
+	projectFlockKandang, err := s.ProjectflockKandangRepo.GetByID(c.Context(), req.ProjectFlockKandangId)
 	if err != nil {
-		s.Log.Errorf("Failed to get projectflock kandang: %+v", err)
-		return nil, err
+		return nil, fiber.NewError(fiber.StatusNotFound, "Project Flock Kandang not found")
 	}
 
-	warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), projectflockkandang.KandangId)
+	warehouse, err := s.WarehouseRepo.GetByKandangID(c.Context(), projectFlockKandang.KandangId)
 	if err != nil {
-		s.Log.Errorf("Failed to get warehouse: %+v", err)
-		return nil, err
+		return nil, fiber.NewError(fiber.StatusNotFound, "Warehouse for Kandang not found")
 	}
 
-	// move complex DB query into repository for cleaner service
-	productWarehouses, err := s.ProductWarehouseRepo.GetByCategoryCodeAndWarehouseID(c.Context(), "DOC", warehouse.Id)
-	if err != nil {
-		s.Log.Errorf("Failed to get product warehouses: %+v", err)
-		return nil, err
-	}
-	if len(productWarehouses) == 0 {
-		return nil, fiber.NewError(fiber.StatusNotFound, "Product Warehouse not found for the given Project Flock and Warehouse")
-	}
-	totalQuantity := 0.0
-	for _, pw := range productWarehouses {
-		totalQuantity += pw.Quantity
-	}
+	var productWarehouses []entity.ProductWarehouse
 
-	if totalQuantity < 1 {
-		return nil, fiber.NewError(fiber.StatusBadRequest, "Insufficient quantity in Product Warehouses")
+	if strings.ToUpper(strings.TrimSpace(projectFlockKandang.ProjectFlock.Category)) == string(utils.ProjectFlockCategoryGrowing) {
+
+		productWarehouses, err = s.ProductWarehouseRepo.GetByCategoryCodeAndWarehouseID(c.Context(), "DOC", warehouse.Id)
+		if err != nil || len(productWarehouses) == 0 {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Product for growing category in the Kandang's warehouse not found")
+		}
 	}
 
 	chickinDate, err := utils.ParseDateString(req.ChickInDate)
 	if err != nil {
-		s.Log.Errorf("Failed to parse chickin date: %+v", err)
 		return nil, fiber.NewError(fiber.StatusBadRequest, "Invalid ChickInDate format")
 	}
-	newChickin := &entity.ProjectChickin{
-		ProjectFlockKandangId: projectflockkandang.Id,
-		ChickInDate:           chickinDate,
-		Quantity:              totalQuantity,
-		Note:                  req.Note,
-		CreatedBy:             1, //todo: ganti dengan user login
+
+	actorID := uint(1) // todo nanti ambil dari auth context
+	newChikins := make([]*entity.ProjectChickin, 0)
+	for _, productWarehouse := range productWarehouses {
+
+		if productWarehouse.Quantity > 0 {
+			newChickin := &entity.ProjectChickin{
+				ProjectFlockKandangId: req.ProjectFlockKandangId,
+				ChickInDate:           chickinDate,
+				UsageQty:              0,
+				PendingUsageQty:       productWarehouse.Quantity,
+				ProductWarehouseId:    productWarehouse.Id,
+				Notes:                 req.Note,
+				CreatedBy:             actorID,
+			}
+
+			newChikins = append(newChikins, newChickin)
+		}
 	}
-	err = s.Repository.CreateOne(c.Context(), newChickin, nil)
+
+	if len(newChikins) == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "No chickins to create")
+	}
+
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+
+		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
+		productWarehouseTx := s.ProductWarehouseRepo.WithTx(dbTransaction)
+
+		if err := s.Repository.WithTx(dbTransaction).CreateMany(c.Context(), newChikins, nil); err != nil {
+			return err
+		}
+
+		latest, err := approvalSvcTx.LatestByTarget(c.Context(), utils.ApprovalWorkflowProjectFlockKandang, projectFlockKandang.Id, nil)
+		if err != nil {
+			return err
+		}
+
+		for _, chickin := range newChikins {
+
+			updates := map[string]any{"quantity": 0}
+
+			if err := productWarehouseTx.PatchOne(c.Context(), chickin.ProductWarehouseId, updates, nil); err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return fmt.Errorf("failed to update product warehouse quantity for id %d", chickin.ProductWarehouseId)
+				}
+				return err
+			}
+		}
+
+		if latest == nil {
+
+			action := entity.ApprovalActionCreated
+			if _, err := approvalSvcTx.CreateApproval(c.Context(), utils.ApprovalWorkflowProjectFlockKandang, projectFlockKandang.Id, utils.ProjectFlockKandangStepPengajuan, &action, actorID, nil); err != nil {
+				lower := strings.ToLower(err.Error())
+				if !(strings.Contains(lower, "duplicate") || strings.Contains(lower, "unique constraint") || strings.Contains(lower, "23505")) {
+					return err
+				}
+			}
+		}
+
+		return nil
+	})
 	if err != nil {
-		s.Log.Errorf("Failed to create chickin: %+v", err)
-		return nil, err
+		return nil, fiber.NewError(fiber.StatusBadRequest, err.Error())
 	}
 
-	// Update semua product warehouse: set quantity jadi 0
-	for _, pw := range productWarehouses {
-		err = s.ProductWarehouseRepo.PatchOne(c.Context(), pw.Id, map[string]any{
-			"quantity": 0,
-		}, nil)
-		if err != nil {
-			s.Log.Errorf("Failed to update product warehouse quantity: %+v", err)
-			return nil, err
-		}
-
-		newChickinDetail := &entity.ProjectChickinDetail{
-			ProjectChickinId:   newChickin.Id,
-			ProductWarehouseId: pw.Id,
-			Quantity:           pw.Quantity,
-			CreatedBy:          1, // todo: ganti dengan user login
-		}
-		err = s.ProjectChickinDetailRepo.CreateOne(c.Context(), newChickinDetail, nil)
-		if err != nil {
-			s.Log.Errorf("Failed to create chickin detail: %+v", err)
-			return nil, err
-		}
-	}
-
-	existingPopulation, err := s.ProjectflockPopulationRepo.GetByProjectFlockKandangID(c.Context(), req.ProjectFlockKandangId)
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		s.Log.Errorf("Failed to get project flock population: %+v", err)
-		return nil, err
-	}
-	if existingPopulation != nil {
-
-		err = s.ProjectflockPopulationRepo.PatchOne(c.Context(), existingPopulation.Id, map[string]any{
-			"reserved_quantity": newChickin.Quantity + existingPopulation.ReservedQuantity,
-		}, nil)
-		if err != nil {
-			s.Log.Errorf("Failed to update project flock population: %+v", err)
-			return nil, err
-		}
-	} else {
-		newPopulation := &entity.ProjectFlockPopulation{
-			ProjectFlockKandangId: req.ProjectFlockKandangId,
-			InitialQuantity:       0,
-			CurrentQuantity:       0,
-			ReservedQuantity:      newChickin.Quantity,
-			CreatedBy:             1, // todo: ganti dengan user login
-		}
-		err = s.ProjectflockPopulationRepo.CreateOne(c.Context(), newPopulation, nil)
-		if err != nil {
-			s.Log.Errorf("Failed to create project flock population: %+v", err)
-			return nil, err
-		}
-	}
-
-	return s.GetOne(c, newChickin.Id)
+	return newChikins[0], nil
 }
 
 func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectChickin, error) {
@@ -224,7 +219,8 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 		updateBody["chick_in_date"] = req.ChickInDate
 	}
 	if req.Note != "" {
-		updateBody["note"] = req.Note
+		// entity uses `Notes` => column `notes`
+		updateBody["notes"] = req.Note
 	}
 	if len(updateBody) == 0 {
 		return s.GetOne(c, id)
@@ -243,160 +239,140 @@ func (s chickinService) UpdateOne(c *fiber.Ctx, req *validation.Update, id uint)
 
 func (s chickinService) DeleteOne(c *fiber.Ctx, id uint) error {
 
+	// Simplified delete: directly call repository delete. Complex restore logic removed for now.
+	if err := s.Repository.DeleteOne(c.Context(), id); err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (s chickinService) Approval(c *fiber.Ctx, req *validation.Approve) ([]entity.ProjectChickin, error) {
+	if err := s.Validate.Struct(req); err != nil {
+		return nil, err
+	}
+
+	actorID := uint(1) // todo nanti ambil dari auth context
+
+	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.ProjectFlockKandangStepPengajuan
+	if action == entity.ApprovalActionApproved {
+		step = utils.ProjectFlockKandangStepDisetujui
+	}
+
 	err := s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
+		approvalSvc := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(dbTransaction))
+		ProjectFlockPopulationRepotx := s.ProjectflockPopulationRepo.WithTx(dbTransaction)
+		chickinRepoTx := s.Repository.WithTx(dbTransaction)
 
-		chickinRepo := repository.NewChickinRepository(dbTransaction)
-		projectFlockKandangRepo := s.ProjectflockKandangRepo.WithTx(dbTransaction)
-		productWarehouseRepo := s.ProductWarehouseRepo.WithTxRepo(dbTransaction)
-		projectFlockPopulationRepo := s.ProjectflockPopulationRepo.WithTx(dbTransaction)
-		projectChickinDetailRepo := s.ProjectChickinDetailRepo.WithTxRepo(dbTransaction)
-		warehouseRepoTx := rWarehouse.NewWarehouseRepository(dbTransaction)
+		for _, approvableID := range approvableIDs {
 
-		chickin, err := chickinRepo.GetByID(c.Context(), id, nil)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
-			}
-			return err
-		}
-
-		population, err := projectFlockPopulationRepo.GetByProjectFlockKandangID(c.Context(), chickin.ProjectFlockKandangId)
-		if err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fiber.NewError(fiber.StatusNotFound, "Project flock population not found")
-			}
-			return err
-		}
-
-		newReserved := population.ReservedQuantity - chickin.Quantity
-		if newReserved < 0 {
-			newReserved = 0
-		}
-
-		err = projectFlockPopulationRepo.PatchOne(c.Context(), population.Id, map[string]any{
-			"reserved_quantity": newReserved,
-		}, nil)
-		if err != nil {
-			return err
-		}
-
-		restoreFromDetails := func() (bool, error) {
-
-			details, err := projectChickinDetailRepo.GetByProjectChickinID(c.Context(), chickin.Id)
+			exists, err := s.ProjectflockKandangRepo.WithTx(dbTransaction).IdExists(c.Context(), approvableID)
 			if err != nil {
-				return false, err
+				return err
+			}
+			if !exists {
+				return fiber.NewError(fiber.StatusNotFound, fmt.Sprintf("ProjectFlockKandang %d not found", approvableID))
 			}
 
-			for _, d := range details {
-				productWarehouse, err := productWarehouseRepo.GetByID(c.Context(), d.ProductWarehouseId, nil)
-				if err != nil {
-					if errors.Is(err, gorm.ErrRecordNotFound) {
-						continue
+			if _, err := approvalSvc.CreateApproval(
+				c.Context(),
+				utils.ApprovalWorkflowProjectFlockKandang,
+				approvableID,
+				step,
+				&action,
+				actorID,
+				req.Notes,
+			); err != nil {
+
+				lower := strings.ToLower(err.Error())
+				if !(strings.Contains(lower, "duplicate") || strings.Contains(lower, "unique constraint") || strings.Contains(lower, "23505")) {
+					return err
+				}
+				s.Log.Infof("ignored duplicate approval for kandang %d: %v", approvableID, err)
+			}
+
+			if action == entity.ApprovalActionApproved {
+
+				var chickins []entity.ProjectChickin
+				if err := chickinRepoTx.DB().WithContext(c.Context()).Where("project_flock_kandang_id = ?", approvableID).Find(&chickins).Error; err != nil {
+					return err
+				}
+
+				for _, chickin := range chickins {
+					population := &entity.ProjectFlockPopulation{
+						ProjectChickinId:   chickin.Id,
+						ProductWarehouseId: chickin.ProductWarehouseId,
+						TotalQty:           chickin.PendingUsageQty,
+						TotalUsedQty:       0,
+						Notes:              chickin.Notes,
+						CreatedBy:          actorID,
+					}
+					if err := ProjectFlockPopulationRepotx.CreateOne(c.Context(), population, nil); err != nil {
+						lower := strings.ToLower(err.Error())
+						if !(strings.Contains(lower, "duplicate") || strings.Contains(lower, "unique constraint") || strings.Contains(lower, "23505")) {
+							return err
+						}
+						s.Log.Infof("ignored duplicate population for chickin %d: %v", chickin.Id, err)
 					}
-					return false, err
 				}
 
-				updatedQuantity := productWarehouse.Quantity + d.Quantity
-				if err := productWarehouseRepo.PatchOne(c.Context(), productWarehouse.Id, map[string]any{"quantity": updatedQuantity}, nil); err != nil {
-					return false, err
-				}
 			}
 
-			if err := projectChickinDetailRepo.DeleteMany(c.Context(), func(db *gorm.DB) *gorm.DB {
-				return db.Where("project_chickin_id = ?", chickin.Id)
-			}); err != nil {
-				return false, err
-			}
-
-			return true, nil
-		}
-
-		restored, err := restoreFromDetails()
-		if err != nil {
-			return err
-		}
-
-		if !restored {
-			projectflockkandang, err := projectFlockKandangRepo.GetByID(c.Context(), population.ProjectFlockKandangId)
-			if err != nil {
-				if errors.Is(err, gorm.ErrRecordNotFound) {
-					return fiber.NewError(fiber.StatusNotFound, "Project flock kandang not found")
-				}
-				return err
-			}
-
-			warehouse, err := warehouseRepoTx.GetByKandangID(c.Context(), projectflockkandang.KandangId)
-			if err != nil {
-				if errors.Is(err, gorm.ErrRecordNotFound) {
-					return fiber.NewError(fiber.StatusNotFound, "Warehouse not found for kandang")
-				}
-				return err
-			}
-
-			productWarehouse, err := productWarehouseRepo.GetLatestByCategoryCodeAndWarehouseID(c.Context(), "DOC", warehouse.Id)
-			if err != nil {
-				if errors.Is(err, gorm.ErrRecordNotFound) {
-					return fiber.NewError(fiber.StatusNotFound, "Product Warehouse not found for the given Project Flock and Warehouse")
-				}
-				return err
-			}
-
-			updatedQuantity := productWarehouse.Quantity + chickin.Quantity
-
-			if err := productWarehouseRepo.PatchOne(c.Context(), productWarehouse.Id, map[string]any{"quantity": updatedQuantity}, nil); err != nil {
-				return err
-			}
-		}
-
-		if err := chickinRepo.DeleteOne(c.Context(), id); err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
-			}
-			return err
 		}
 
 		return nil
 	})
 
 	if err != nil {
-		if ferr, ok := err.(*fiber.Error); ok {
-			return ferr
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return nil, fiberErr
 		}
-		return err
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, fiber.NewError(fiber.StatusNotFound, "Chickin not found")
+		}
+		s.Log.Errorf("Failed to record approval for chickins %+v: %+v", approvableIDs, err)
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to record approval")
 	}
 
-	return nil
+	updated := make([]entity.ProjectChickin, 0)
+	for _, kandangID := range approvableIDs {
+		var chickins []entity.ProjectChickin
+		if err := s.Repository.DB().WithContext(c.Context()).Where("project_flock_kandang_id = ?", kandangID).Find(&chickins).Error; err != nil {
+			return nil, err
+		}
+		updated = append(updated, chickins...)
+	}
+
+	return updated, nil
 }
 
-func (s *chickinService) Approve(c *fiber.Ctx, id uint) error {
-
-	// todo: ini contoh akhir jika sudah approved
-
-	chickin, err := s.Repository.GetByID(c.Context(), id, nil)
-
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return fiber.NewError(fiber.StatusNotFound, "Chickin not found")
+func uniqueUintSlice(values []uint) []uint {
+	seen := make(map[uint]struct{}, len(values))
+	result := make([]uint, 0, len(values))
+	for _, v := range values {
+		if _, ok := seen[v]; ok {
+			continue
+		}
+		seen[v] = struct{}{}
+		result = append(result, v)
 	}
-	if err != nil {
-		s.Log.Errorf("Failed get chickin by id: %+v", err)
-		return err
-	}
-
-	population, err := s.ProjectflockPopulationRepo.GetByProjectFlockKandangID(c.Context(), chickin.ProjectFlockKandangId)
-	if err != nil {
-		s.Log.Errorf("Failed to get project flock population: %+v", err)
-		return err
-	}
-
-	err = s.ProjectflockPopulationRepo.PatchOne(c.Context(), population.Id, map[string]any{
-		"reserved_quantity": population.ReservedQuantity - chickin.Quantity,
-		"initial_quantity":  population.InitialQuantity + chickin.Quantity,
-		"current_quantity":  population.CurrentQuantity + chickin.Quantity,
-	}, nil)
-	if err != nil {
-		s.Log.Errorf("Failed to update project flock population: %+v", err)
-		return err
-	}
-
-	return nil
+	return result
 }

internal/modules/production/chickins/validations/chickin.validation.go

@@ -3,7 +3,7 @@ package validation
 type Create struct {
 	ProjectFlockKandangId uint   `json:"project_flock_kandang_id" validate:"required,number,min=1"`
 	ChickInDate           string `json:"chick_in_date" validate:"required,datetime=2006-01-02"`
-	Note                  string `json:"note" validate:"omitempty`
+	Note                  string `json:"note" validate:"omitempty"`
 }
 
 type Update struct {
@@ -16,3 +16,9 @@ type Query struct {
 	Limit                 int  `query:"limit" validate:"omitempty,number,min=1,max=100"`
 	ProjectFlockKandangId uint `query:"project_flock_kandang_id" validate:"omitempty,number,min=1"`
 }
+
+type Approve struct {
+	Action        string  `json:"action" validate:"required_strict"`
+	ApprovableIds []uint  `json:"approvable_ids" validate:"required_strict,min=1,dive,gt=0"`
+	Notes         *string `json:"notes,omitempty" validate:"omitempty,max=500"`
+}