Merge branch 'feat/BE/Sprint-5' of https://gitlab.com/mbugroup/lti-api into dev/teguh

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

@@ -7,7 +7,6 @@ import (
 	"strconv"
 	"strings"
 
-	flockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/dto"
 	"gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/dto"
 	service "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/validations"
@@ -85,18 +84,20 @@ func (u *ProjectflockController) GetAll(c *fiber.Ctx) error {
 		query.KandangIds = ids
 	}
 
-	result, totalResults, flockMap, err := u.ProjectflockService.GetAll(c, query)
+	result, totalResults, _, err := u.ProjectflockService.GetAll(c, query)
 	if err != nil {
 		return err
 	}
 
-	data := make([]dto.ProjectFlockListDTO, 0)
-	for _, projectFlock := range result {
-		var flock *flockDTO.FlockBaseDTO
-		if flockMap != nil {
-			flock = flockMap[projectFlock.Id]
+	var periodMap map[uint]int
+	if len(result) > 0 {
+		ids := make([]uint, len(result))
+		for i, item := range result {
+			ids[i] = item.Id
+		}
+		if periods, err := u.ProjectflockService.GetProjectPeriods(c, ids); err == nil {
+			periodMap = periods
 		}
-		data = append(data, dto.ToProjectFlockListDTO(projectFlock, flock))
 	}
 
 	return c.Status(fiber.StatusOK).
@@ -110,7 +111,7 @@ func (u *ProjectflockController) GetAll(c *fiber.Ctx) error {
 				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
 				TotalResults: totalResults,
 			},
-			Data: data,
+			Data: dto.ToProjectFlockListDTOsWithPeriods(result, periodMap),
 		})
 }
 
@@ -122,17 +123,24 @@ func (u *ProjectflockController) GetOne(c *fiber.Ctx) error {
 		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
 	}
 
-	result, flock, err := u.ProjectflockService.GetOne(c, uint(id))
+	result, _, err := u.ProjectflockService.GetOne(c, uint(id))
 	if err != nil {
 		return err
 	}
 
+	var period int
+	if periods, err := u.ProjectflockService.GetProjectPeriods(c, []uint{uint(id)}); err == nil {
+		if p, ok := periods[uint(id)]; ok {
+			period = p
+		}
+	}
+
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{
 			Code:    fiber.StatusOK,
 			Status:  "success",
 			Message: "Get projectflock successfully",
-			Data:    dto.ToProjectFlockListDTO(*result, flock),
+			Data:    dto.ToProjectFlockListDTOWithPeriod(*result, period),
 		})
 }
 
@@ -153,7 +161,7 @@ func (u *ProjectflockController) CreateOne(c *fiber.Ctx) error {
 			Code:    fiber.StatusCreated,
 			Status:  "success",
 			Message: "Create projectflock successfully",
-			Data:    dto.ToProjectFlockListDTO(*result, nil),
+			Data:    dto.ToProjectFlockListDTO(*result),
 		})
 }
 
@@ -180,7 +188,7 @@ func (u *ProjectflockController) UpdateOne(c *fiber.Ctx) error {
 			Code:    fiber.StatusOK,
 			Status:  "success",
 			Message: "Update projectflock successfully",
-			Data:    dto.ToProjectFlockListDTO(*result, nil),
+			Data:    dto.ToProjectFlockListDTO(*result),
 		})
 }
 
@@ -219,11 +227,29 @@ func (u *ProjectflockController) Approval(c *fiber.Ctx) error {
 		data    interface{}
 		message = "Submit projectflock approval successfully"
 	)
+
+	var periodMap map[uint]int
+	if len(results) > 0 {
+		ids := make([]uint, len(results))
+		for i, item := range results {
+			ids[i] = item.Id
+		}
+		if periods, err := u.ProjectflockService.GetProjectPeriods(c, ids); err == nil {
+			periodMap = periods
+		}
+	}
+
 	if len(results) == 1 {
-		data = dto.ToProjectFlockListDTO(results[0], nil)
+		period := 0
+		if periodMap != nil {
+			if p, ok := periodMap[results[0].Id]; ok {
+				period = p
+			}
+		}
+		data = dto.ToProjectFlockListDTOWithPeriod(results[0], period)
 	} else {
 		message = "Submit projectflock approvals successfully"
-		data = dto.ToProjectFlockListDTOs(results)
+		data = dto.ToProjectFlockListDTOsWithPeriods(results, periodMap)
 	}
 
 	return c.Status(fiber.StatusOK).
@@ -236,25 +262,32 @@ func (u *ProjectflockController) Approval(c *fiber.Ctx) error {
 }
 
 func (u *ProjectflockController) GetFlockPeriodSummary(c *fiber.Ctx) error {
-	param := c.Params("project_flock_kandang_id")
+	param := c.Params("location_id")
 
 	id, err := strconv.Atoi(param)
 	if err != nil {
-		return fiber.NewError(fiber.StatusBadRequest, "Invalid project_flock_kandang_id")
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid location_id")
 	}
 
-	summary, err := u.ProjectflockService.GetFlockPeriodSummary(c, uint(id))
+	summaries, err := u.ProjectflockService.GetFlockPeriodSummary(c, uint(id))
 	if err != nil {
 		return err
 	}
 
-	responseBody := dto.ToFlockPeriodSummaryDTO(summary.Flock, summary.NextPeriod)
+	responseBody := make([]dto.KandangPeriodSummaryDTO, 0, len(summaries))
+	for _, item := range summaries {
+		responseBody = append(responseBody, dto.KandangPeriodSummaryDTO{
+			Id:     item.Id,
+			Name:   item.Name,
+			Period: item.Period,
+		})
+	}
 
 	return c.Status(fiber.StatusOK).
 		JSON(response.Success{
 			Code:    fiber.StatusOK,
 			Status:  "success",
-			Message: "Get flock period summary successfully",
+			Message: "Get kandang period summary successfully",
 			Data:    responseBody,
 		})
 }

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

@@ -7,7 +7,6 @@ import (
 	approvalDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/dto"
 	areaDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/areas/dto"
 	fcrDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/fcrs/dto"
-	flockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/dto"
 	kandangDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/dto"
 	locationDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/locations/dto"
 
@@ -17,44 +16,45 @@ import (
 	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 )
 
-type ProjectFlockBaseDTO struct {
+type ProjectFlockRelationDTO struct {
 	Id        uint   `json:"id"`
 	Period    int    `json:"period"`
 	FlockName string `json:"flock_name"`
 }
 
 type ProjectFlockListDTO struct {
-	ProjectFlockBaseDTO
-	Flock       *flockDTO.FlockBaseDTO         `json:"flock,omitempty"`
-	Area        *areaDTO.AreaBaseDTO           `json:"area,omitempty"`
-	Category    string                         `json:"category"`
-	Fcr         *fcrDTO.FcrBaseDTO             `json:"fcr,omitempty"`
-	Location    *locationDTO.LocationBaseDTO   `json:"location,omitempty"`
-	Kandangs    []KandangWithProjectFlockIdDTO `json:"kandangs,omitempty"`
-	CreatedUser *userDTO.UserBaseDTO           `json:"created_user"`
-	CreatedAt   time.Time                      `json:"created_at"`
-	UpdatedAt   time.Time                      `json:"updated_at"`
-	Approval    approvalDTO.ApprovalBaseDTO    `json:"approval"`
+	ProjectFlockRelationDTO
+	Area        *areaDTO.AreaRelationDTO         `json:"area,omitempty"`
+	Category    string                           `json:"category"`
+	Fcr         *fcrDTO.FcrRelationDTO           `json:"fcr,omitempty"`
+	Location    *locationDTO.LocationRelationDTO `json:"location,omitempty"`
+	Kandangs    []KandangWithProjectFlockIdDTO   `json:"kandangs,omitempty"`
+	CreatedUser *userDTO.UserRelationDTO         `json:"created_user"`
+	CreatedAt   time.Time                        `json:"created_at"`
+	UpdatedAt   time.Time                        `json:"updated_at"`
+	Approval    approvalDTO.ApprovalRelationDTO  `json:"approval"`
 }
 
 type KandangWithProjectFlockIdDTO struct {
-	kandangDTO.KandangBaseDTO
+	kandangDTO.KandangRelationDTO
 	ProjectFlockKandangId uint `json:"project_flock_kandang_id"`
+	Period                int  `json:"period"`
 }
 
 type ProjectFlockDetailDTO struct {
 	ProjectFlockListDTO
 }
 
-type FlockPeriodDTO struct {
-	Flock      flockDTO.FlockBaseDTO `json:"flock"`
-	NextPeriod int                   `json:"next_period"`
+type KandangPeriodSummaryDTO struct {
+	Id     uint   `json:"id"`
+	Name   string `json:"name"`
+	Period int    `json:"period"`
 }
 
-func ToProjectFlockListDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockListDTO {
-	var createdUser *userDTO.UserBaseDTO
+func ToProjectFlockListDTOWithPeriod(e entity.ProjectFlock, period int) ProjectFlockListDTO {
+	var createdUser *userDTO.UserRelationDTO
 	if e.CreatedUser.Id != 0 {
-		mapped := userDTO.ToUserBaseDTO(e.CreatedUser)
+		mapped := userDTO.ToUserRelationDTO(e.CreatedUser)
 		createdUser = &mapped
 	}
 
@@ -63,43 +63,43 @@ func ToProjectFlockListDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO)
 		kandangSummaries = make([]KandangWithProjectFlockIdDTO, len(e.Kandangs))
 		for i, kandang := range e.Kandangs {
 
-			var pfkId uint
+			var (
+				pfkId  uint
+				period int
+			)
 			for _, kh := range e.KandangHistory {
 				if kh.KandangId == kandang.Id {
 					pfkId = kh.Id
+					period = kh.Period
 					break
 				}
 			}
 			kandangSummaries[i] = KandangWithProjectFlockIdDTO{
-				KandangBaseDTO:        kandangDTO.ToKandangBaseDTO(kandang),
+				KandangRelationDTO:    kandangDTO.ToKandangRelationDTO(kandang),
 				ProjectFlockKandangId: pfkId,
+				Period:                period,
 			}
 		}
 	}
 
-	var areaSummary *areaDTO.AreaBaseDTO
+	var areaSummary *areaDTO.AreaRelationDTO
 	if e.Area.Id != 0 {
-		mapped := areaDTO.ToAreaBaseDTO(e.Area)
+		mapped := areaDTO.ToAreaRelationDTO(e.Area)
 		areaSummary = &mapped
 	}
 
-	var fcrSummary *fcrDTO.FcrBaseDTO
+	var fcrSummary *fcrDTO.FcrRelationDTO
 	if e.Fcr.Id != 0 {
-		mapped := fcrDTO.ToFcrBaseDTO(e.Fcr)
+		mapped := fcrDTO.ToFcrRelationDTO(e.Fcr)
 		fcrSummary = &mapped
 	}
 
-	var locationSummary *locationDTO.LocationBaseDTO
+	var locationSummary *locationDTO.LocationRelationDTO
 	if e.Location.Id != 0 {
-		mapped := locationDTO.ToLocationBaseDTO(e.Location)
+		mapped := locationDTO.ToLocationRelationDTO(e.Location)
 		locationSummary = &mapped
 	}
 
-	var flockSummary *flockDTO.FlockBaseDTO
-	if flock != nil && flock.Id != 0 {
-		flockSummary = flock
-	}
-
 	latestApproval := defaultProjectFlockLatestApproval(e)
 	if e.LatestApproval != nil {
 		snapshot := approvalDTO.ToApprovalDTO(*e.LatestApproval)
@@ -107,57 +107,53 @@ func ToProjectFlockListDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO)
 	}
 
 	return ProjectFlockListDTO{
-		ProjectFlockBaseDTO: createProjectFlockBaseDTO(e),
-		Flock:               flockSummary,
-		Area:                areaSummary,
-		Kandangs:            kandangSummaries,
-		Category:            e.Category,
-		Fcr:                 fcrSummary,
-		Location:            locationSummary,
-		CreatedAt:           e.CreatedAt,
-		UpdatedAt:           e.UpdatedAt,
-		CreatedUser:         createdUser,
-		Approval:            latestApproval,
+		ProjectFlockRelationDTO: createProjectFlockRelationDTO(e, period),
+		Area:                    areaSummary,
+		Kandangs:                kandangSummaries,
+		Category:                e.Category,
+		Fcr:                     fcrSummary,
+		Location:                locationSummary,
+		CreatedAt:               e.CreatedAt,
+		UpdatedAt:               e.UpdatedAt,
+		CreatedUser:             createdUser,
+		Approval:                latestApproval,
 	}
 }
 
-func ToProjectFlockListDTOWithFlock(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockListDTO {
-	return ToProjectFlockListDTO(e, flock)
-}
-
 func ToProjectFlockListDTOs(items []entity.ProjectFlock) []ProjectFlockListDTO {
 	result := make([]ProjectFlockListDTO, len(items))
 	for i, item := range items {
-		result[i] = ToProjectFlockListDTO(item, nil)
+		result[i] = ToProjectFlockListDTOWithPeriod(item, 0)
 	}
 	return result
 }
 
-func ToProjectFlockListDTOsWithFlocks(items []entity.ProjectFlock, flocks map[uint]*entity.Flock) []ProjectFlockListDTO {
+func ToProjectFlockListDTO(e entity.ProjectFlock) ProjectFlockListDTO {
+	return ToProjectFlockListDTOWithPeriod(e, 0)
+}
+
+func ToProjectFlockListDTOsWithPeriods(items []entity.ProjectFlock, periods map[uint]int) []ProjectFlockListDTO {
 	result := make([]ProjectFlockListDTO, len(items))
 	for i, item := range items {
-		var flock *flockDTO.FlockBaseDTO
-		if flocks != nil {
-			if f := flocks[item.Id]; f != nil {
-				flock = &flockDTO.FlockBaseDTO{
-					Id:   f.Id,
-					Name: f.Name,
-				}
+		p := 0
+		if periods != nil {
+			if v, ok := periods[item.Id]; ok {
+				p = v
 			}
 		}
-		result[i] = ToProjectFlockListDTOWithFlock(item, flock)
+		result[i] = ToProjectFlockListDTOWithPeriod(item, p)
 	}
 	return result
 }
 
-func ToProjectFlockDetailDTO(e entity.ProjectFlock, flock *flockDTO.FlockBaseDTO) ProjectFlockDetailDTO {
+func ToProjectFlockDetailDTO(e entity.ProjectFlock) ProjectFlockDetailDTO {
 	return ProjectFlockDetailDTO{
-		ProjectFlockListDTO: ToProjectFlockListDTO(e, flock),
+		ProjectFlockListDTO: ToProjectFlockListDTOWithPeriod(e, 0),
 	}
 }
 
-func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.ApprovalBaseDTO {
-	result := approvalDTO.ApprovalBaseDTO{}
+func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.ApprovalRelationDTO {
+	result := approvalDTO.ApprovalRelationDTO{}
 
 	step := utils.ProjectFlockStepPengajuan
 	if step > 0 {
@@ -170,9 +166,9 @@ func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.Approv
 	}
 
 	if e.CreatedUser.Id != 0 {
-		result.ActionBy = userDTO.ToUserBaseDTO(e.CreatedUser)
+		result.ActionBy = userDTO.ToUserRelationDTO(e.CreatedUser)
 	} else if e.CreatedBy != 0 {
-		result.ActionBy = userDTO.UserBaseDTO{
+		result.ActionBy = userDTO.UserRelationDTO{
 			Id:     e.CreatedBy,
 			IdUser: int64(e.CreatedBy),
 		}
@@ -181,24 +177,10 @@ func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.Approv
 	return result
 }
 
-func createProjectFlockBaseDTO(e entity.ProjectFlock) ProjectFlockBaseDTO {
-	return ProjectFlockBaseDTO{
+func createProjectFlockRelationDTO(e entity.ProjectFlock, period int) ProjectFlockRelationDTO {
+	return ProjectFlockRelationDTO{
 		Id:        e.Id,
-		Period:    e.Period,
+		Period:    period,
 		FlockName: e.FlockName,
 	}
 }
-
-func ToFlockSummaryDTO(e entity.Flock) flockDTO.FlockBaseDTO {
-	return flockDTO.FlockBaseDTO{
-		Id:   e.Id,
-		Name: e.Name,
-	}
-}
-
-func ToFlockPeriodSummaryDTO(flock entity.Flock, next int) FlockPeriodDTO {
-	return FlockPeriodDTO{
-		Flock:      ToFlockSummaryDTO(flock),
-		NextPeriod: next,
-	}
-}

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

@@ -4,43 +4,40 @@ import (
 	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"
-	flockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/dto"
 	kandangDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/dto"
 	locationDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/locations/dto"
-	pfutils "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/utils"
 	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
 )
 
 type KandangWithPivotDTO struct {
-	kandangDTO.KandangBaseDTO
+	kandangDTO.KandangRelationDTO
 	AvailableQuantity float64 `json:"available_quantity"`
 }
 
 type ProjectFlockWithPivotDTO struct {
-	ProjectFlockBaseDTO
-	Flock       *flockDTO.FlockBaseDTO       `json:"flock,omitempty"`
-	Area        *areaDTO.AreaBaseDTO         `json:"area,omitempty"`
-	Category    string                       `json:"category"`
-	Fcr         *fcrDTO.FcrBaseDTO           `json:"fcr,omitempty"`
-	Location    *locationDTO.LocationBaseDTO `json:"location,omitempty"`
-	Kandangs    []KandangWithPivotDTO        `json:"kandangs,omitempty"`
-	CreatedUser *userDTO.UserBaseDTO         `json:"created_user,omitempty"`
+	ProjectFlockRelationDTO
+	Area        *areaDTO.AreaRelationDTO         `json:"area,omitempty"`
+	Category    string                           `json:"category"`
+	Fcr         *fcrDTO.FcrRelationDTO           `json:"fcr,omitempty"`
+	Location    *locationDTO.LocationRelationDTO `json:"location,omitempty"`
+	Kandangs    []KandangWithPivotDTO            `json:"kandangs,omitempty"`
+	CreatedUser *userDTO.UserRelationDTO         `json:"created_user,omitempty"`
 }
 
 type ProjectFlockKandangDTO struct {
-	Id                    uint                       `json:"id"`
-	ProjectFlockKandangId uint                       `json:"project_flock_kandang_id"`
-	ProjectFlockId        uint                       `json:"project_flock_id"`
-	KandangId             uint                       `json:"kandang_id"`
-	Kandang               *kandangDTO.KandangBaseDTO `json:"kandang,omitempty"`
-	ProjectFlock          *ProjectFlockWithPivotDTO  `json:"project_flock,omitempty"`
-	AvailableQuantity     float64                    `json:"available_quantity"`
+	Id                    uint                           `json:"id"`
+	ProjectFlockKandangId uint                           `json:"project_flock_kandang_id"`
+	ProjectFlockId        uint                           `json:"project_flock_id"`
+	KandangId             uint                           `json:"kandang_id"`
+	Kandang               *kandangDTO.KandangRelationDTO `json:"kandang,omitempty"`
+	ProjectFlock          *ProjectFlockWithPivotDTO      `json:"project_flock,omitempty"`
+	AvailableQuantity     float64                        `json:"available_quantity"`
 }
 
 func ToProjectFlockKandangDTO(e entity.ProjectFlockKandang) ProjectFlockKandangDTO {
-	var kandang *kandangDTO.KandangBaseDTO
+	var kandang *kandangDTO.KandangRelationDTO
 	if e.Kandang.Id != 0 {
-		mapped := kandangDTO.ToKandangBaseDTO(e.Kandang)
+		mapped := kandangDTO.ToKandangRelationDTO(e.Kandang)
 		kandang = &mapped
 	}
 
@@ -48,40 +45,36 @@ func ToProjectFlockKandangDTO(e entity.ProjectFlockKandang) ProjectFlockKandangD
 	if e.ProjectFlock.Id != 0 {
 
 		pfLocal := ProjectFlockWithPivotDTO{
-			ProjectFlockBaseDTO: ProjectFlockBaseDTO{
+			ProjectFlockRelationDTO: ProjectFlockRelationDTO{
 				Id:        e.ProjectFlock.Id,
-				Period:    e.ProjectFlock.Period,
+				Period:    e.Period,
 				FlockName: e.ProjectFlock.FlockName,
 			},
 			Category: e.ProjectFlock.Category,
 		}
 
-		if base := pfutils.DeriveBaseName(e.ProjectFlock.FlockName); base != "" {
-			summary := flockDTO.FlockBaseDTO{Id: 0, Name: base}
-			pfLocal.Flock = &summary
-		}
 		if e.ProjectFlock.Area.Id != 0 {
-			mapped := areaDTO.ToAreaBaseDTO(e.ProjectFlock.Area)
+			mapped := areaDTO.ToAreaRelationDTO(e.ProjectFlock.Area)
 			pfLocal.Area = &mapped
 		}
 		if e.ProjectFlock.Fcr.Id != 0 {
-			mapped := fcrDTO.ToFcrBaseDTO(e.ProjectFlock.Fcr)
+			mapped := fcrDTO.ToFcrRelationDTO(e.ProjectFlock.Fcr)
 			pfLocal.Fcr = &mapped
 		}
 		if e.ProjectFlock.Location.Id != 0 {
-			mapped := locationDTO.ToLocationBaseDTO(e.ProjectFlock.Location)
+			mapped := locationDTO.ToLocationRelationDTO(e.ProjectFlock.Location)
 			pfLocal.Location = &mapped
 		}
 		if e.ProjectFlock.CreatedUser.Id != 0 {
-			mapped := userDTO.ToUserBaseDTO(e.ProjectFlock.CreatedUser)
+			mapped := userDTO.ToUserRelationDTO(e.ProjectFlock.CreatedUser)
 			pfLocal.CreatedUser = &mapped
 		}
 
 		for _, k := range e.ProjectFlock.Kandangs {
-			kb := kandangDTO.ToKandangBaseDTO(k)
+			kb := kandangDTO.ToKandangRelationDTO(k)
 			pfLocal.Kandangs = append(pfLocal.Kandangs, KandangWithPivotDTO{
-				KandangBaseDTO:    kb,
-				AvailableQuantity: 0,
+				KandangRelationDTO: kb,
+				AvailableQuantity:  0,
 			})
 		}
 

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

@@ -2,7 +2,6 @@ package repository
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strings"
 
@@ -10,17 +9,12 @@ import (
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/validations"
 	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
 )
 
 const baseNameExpression = "LOWER(TRIM(regexp_replace(flock_name, '\\\\s+\\\\d+(\\\\s+\\\\d+)*$', '', 'g')))"
 
 type ProjectflockRepository interface {
 	repository.BaseRepository[entity.ProjectFlock]
-	GetAllByBaseName(ctx context.Context, baseName string) ([]entity.ProjectFlock, error)
-	GetActiveByBaseName(ctx context.Context, baseName string) (*entity.ProjectFlock, error)
-	GetMaxPeriodByBaseName(ctx context.Context, baseName string) (int, error)
-	GetNextSequenceForBase(ctx context.Context, baseName string) (int, error)
 	GetAllWithFilters(ctx context.Context, offset, limit int, params *validation.Query) ([]entity.ProjectFlock, int64, error)
 	WithDefaultRelations() func(*gorm.DB) *gorm.DB
 	ExistsByFlockName(ctx context.Context, flockName string, excludeID *uint) (bool, error)
@@ -39,65 +33,6 @@ func NewProjectflockRepository(db *gorm.DB) ProjectflockRepository {
 	}
 }
 
-func (r *ProjectflockRepositoryImpl) GetAllByBaseName(ctx context.Context, baseName string) ([]entity.ProjectFlock, error) {
-	var records []entity.ProjectFlock
-	if err := r.DB().WithContext(ctx).
-		Unscoped().
-		Where(baseNameExpression+" = LOWER(?)", baseName).
-		Order("period ASC").
-		Find(&records).Error; err != nil {
-		return nil, err
-	}
-	return records, nil
-}
-
-func (r *ProjectflockRepositoryImpl) GetActiveByBaseName(ctx context.Context, baseName string) (*entity.ProjectFlock, error) {
-	var record entity.ProjectFlock
-	err := r.DB().WithContext(ctx).
-		Where(baseNameExpression+" = LOWER(?)", baseName).
-		Order("period DESC").
-		First(&record).Error
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, err
-	}
-	if err != nil {
-		return nil, err
-	}
-	return &record, nil
-}
-
-func (r *ProjectflockRepositoryImpl) GetMaxPeriodByBaseName(ctx context.Context, baseName string) (int, error) {
-	var max int
-	if err := r.DB().WithContext(ctx).
-		Model(&entity.ProjectFlock{}).
-		Where(baseNameExpression+" = LOWER(?)", baseName).
-		Select("COALESCE(MAX(period), 0)").
-		Scan(&max).Error; err != nil {
-		return 0, err
-	}
-	return max, nil
-}
-
-func (r *ProjectflockRepositoryImpl) GetNextSequenceForBase(ctx context.Context, baseName string) (int, error) {
-	var payload struct {
-		Period int
-	}
-	if err := r.DB().WithContext(ctx).
-		Model(&entity.ProjectFlock{}).
-		Where(baseNameExpression+" = LOWER(?)", baseName).
-		Clauses(clause.Locking{Strength: "UPDATE"}).
-		Order("period DESC").
-		Limit(1).
-		Select("period").
-		Scan(&payload).Error; err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return 1, nil
-		}
-		return 0, err
-	}
-	return payload.Period + 1, nil
-}
-
 func (r *ProjectflockRepositoryImpl) GetAllWithFilters(ctx context.Context, offset, limit int, params *validation.Query) ([]entity.ProjectFlock, int64, error) {
 	return r.GetAll(ctx, offset, limit, func(db *gorm.DB) *gorm.DB {
 		db = r.withDefaultRelations(db)
@@ -137,7 +72,13 @@ func (r *ProjectflockRepositoryImpl) applyQueryFilters(db *gorm.DB, params *vali
 		db = db.Where("project_flocks.location_id = ?", params.LocationId)
 	}
 	if params.Period > 0 {
-		db = db.Where("project_flocks.period = ?", params.Period)
+		db = db.Where(`
+        EXISTS (
+            SELECT 1
+            FROM project_flock_kandangs pfk
+            WHERE pfk.project_flock_id = project_flocks.id
+              AND pfk.period = ?
+        )`, params.Period)
 	}
 	if len(params.KandangIds) > 0 {
 		db = db.Where(`
@@ -184,10 +125,15 @@ func (r *ProjectflockRepositoryImpl) applySearchFilters(db *gorm.DB, rawSearch s
 			OR LOWER(created_users.email) LIKE ?
 			OR LOWER(project_flocks.flock_name) LIKE ?
 			OR LOWER(TRIM(regexp_replace(project_flocks.flock_name, '\\s+\\d+(\\s+\\d+)*$', '', 'g'))) LIKE ?
-			OR LOWER(CAST(project_flocks.period AS TEXT)) LIKE ?
+			OR EXISTS (
+				SELECT 1 FROM project_flock_kandangs
+				WHERE project_flock_kandangs.project_flock_id = project_flocks.id
+				  AND LOWER(CAST(project_flock_kandangs.period AS TEXT)) LIKE ?
+			)
 			OR EXISTS (
 				SELECT 1 FROM kandangs
-				WHERE kandangs.project_flock_id = project_flocks.id
+				JOIN project_flock_kandangs pfk ON pfk.kandang_id = kandangs.id
+				WHERE pfk.project_flock_id = project_flocks.id
 				AND LOWER(kandangs.name) LIKE ?
 			)
 		`,
@@ -241,7 +187,7 @@ func (r *ProjectflockRepositoryImpl) buildOrderExpressions(sortBy, sortOrder str
 		}
 	case "period":
 		return []string{
-			fmt.Sprintf("project_flocks.period %s", direction),
+			fmt.Sprintf("(SELECT COALESCE(MAX(period), 0) FROM project_flock_kandangs pfk WHERE pfk.project_flock_id = project_flocks.id) %s", direction),
 			fmt.Sprintf("project_flocks.id %s", direction),
 		}
 	default:

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

@@ -22,6 +22,7 @@ type ProjectFlockKandangRepository interface {
 	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)
 	WithTx(tx *gorm.DB) ProjectFlockKandangRepository
 	IdExists(ctx context.Context, id uint) (bool, error)
 	DB() *gorm.DB
@@ -304,7 +305,33 @@ func (r *projectFlockKandangRepositoryImpl) MaxPeriodByBaseName(ctx context.Cont
 		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)").
+		Select("COALESCE(MAX(pfk.period), 0)").
 		Scan(&max).Error
 	return max, err
 }
+
+func (r *projectFlockKandangRepositoryImpl) ProjectPeriodsByProjectIDs(ctx context.Context, projectIDs []uint) (map[uint]int, error) {
+	result := make(map[uint]int)
+	if len(projectIDs) == 0 {
+		return result, nil
+	}
+
+	type row struct {
+		ProjectFlockID uint
+		Period         int
+	}
+	var rows []row
+	if err := r.db.WithContext(ctx).
+		Table("project_flock_kandangs").
+		Where("project_flock_id IN ?", projectIDs).
+		Select("project_flock_id, COALESCE(MAX(period), 0) AS period").
+		Group("project_flock_id").
+		Scan(&rows).Error; err != nil {
+		return nil, err
+	}
+
+	for _, item := range rows {
+		result[item.ProjectFlockID] = item.Period
+	}
+	return result, nil
+}

internal/modules/production/project_flocks/route.go

@@ -1,6 +1,7 @@
 package project_flocks
 
 import (
+	// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/controllers"
 	projectflock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
 	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -12,12 +13,6 @@ func ProjectflockRoutes(v1 fiber.Router, u user.UserService, s projectflock.Proj
 	ctrl := controller.NewProjectflockController(s)
 
 	route := v1.Group("/project-flocks")
-
-	// route.Get("/", m.Auth(u), ctrl.GetAll)
-	// route.Post("/", m.Auth(u), ctrl.CreateOne)
-	// route.Get("/:id", m.Auth(u), ctrl.GetOne)
-	// route.Patch("/:id", m.Auth(u), ctrl.UpdateOne)
-	// route.Delete("/:id", m.Auth(u), ctrl.DeleteOne)
 	// route.Use(m.Auth(u))
 
 	route.Get("/", ctrl.GetAll)
@@ -28,6 +23,6 @@ func ProjectflockRoutes(v1 fiber.Router, u user.UserService, s projectflock.Proj
 	route.Get("/kandangs/:project_flock_kandang_id/periods", ctrl.GetFlockPeriodSummary)
 	route.Get("/kandangs/lookup", ctrl.LookupProjectFlockKandang)
 	route.Post("/approvals", ctrl.Approval)
-	route.Get("/kandangs/:project_flock_kandang_id/periods", ctrl.GetFlockPeriodSummary)
+	route.Get("/kandangs/:location_id/periods", ctrl.GetFlockPeriodSummary)
 
 }

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

@@ -10,6 +10,8 @@ import (
 	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"
+
+	// authmiddleware "gitlab.com/mbugroup/lti-api.git/internal/middleware"
 	productWarehouseRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/inventory/product-warehouses/repositories"
 	flockDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/dto"
 	flockRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/repositories"
@@ -28,14 +30,15 @@ import (
 )
 
 type ProjectflockService interface {
-	GetAll(ctx *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, map[uint]*flockDTO.FlockBaseDTO, error)
-	GetOne(ctx *fiber.Ctx, id uint) (*entity.ProjectFlock, *flockDTO.FlockBaseDTO, error)
+	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)
-	GetFlockPeriodSummary(ctx *fiber.Ctx, flockID uint) (*FlockPeriodSummary, error)
+	GetFlockPeriodSummary(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)
 }
 
@@ -52,9 +55,10 @@ type projectflockService struct {
 	approvalWorkflow     approvalutils.ApprovalWorkflowKey
 }
 
-type FlockPeriodSummary struct {
-	Flock      entity.Flock
-	NextPeriod int
+type KandangPeriodSummary struct {
+	Id     uint
+	Name   string
+	Period int
 }
 
 func NewProjectflockService(
@@ -93,7 +97,7 @@ func (s projectflockService) withRelations(db *gorm.DB) *gorm.DB {
 		Preload("KandangHistory.Kandang")
 }
 
-func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, map[uint]*flockDTO.FlockBaseDTO, error) {
+func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, map[uint]*flockDTO.FlockRelationDTO, error) {
 	if err := s.Validate.Struct(params); err != nil {
 		return nil, 0, nil, err
 	}
@@ -121,7 +125,7 @@ func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]e
 		}
 
 		latestMap, err := s.ApprovalSvc.LatestByTargets(c.Context(), s.approvalWorkflow, ids, func(db *gorm.DB) *gorm.DB {
-			return db.Preload("ActionUser")
+			return s.withRelations(db)
 		})
 		if err != nil {
 			s.Log.Warnf("Unable to load latest approvals for projectflocks: %+v", err)
@@ -134,7 +138,7 @@ func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]e
 		}
 	}
 
-	flockMap := make(map[uint]*flockDTO.FlockBaseDTO)
+	flockMap := make(map[uint]*flockDTO.FlockRelationDTO)
 	for i := range projectflocks {
 		if projectflocks[i].FlockName != "" {
 			baseName := pfutils.DeriveBaseName(projectflocks[i].FlockName)
@@ -143,7 +147,7 @@ func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]e
 				if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 					s.Log.Warnf("Failed to fetch flock %q: %+v", baseName, err)
 				} else if flock != nil {
-					flockMap[projectflocks[i].Id] = &flockDTO.FlockBaseDTO{
+					flockMap[projectflocks[i].Id] = &flockDTO.FlockRelationDTO{
 						Id:   flock.Id,
 						Name: flock.Name,
 					}
@@ -167,7 +171,7 @@ func (s projectflockService) getOneEntityOnly(c *fiber.Ctx, id uint) (*entity.Pr
 
 	if s.ApprovalSvc != nil {
 		approvals, err := s.ApprovalSvc.ListByTarget(c.Context(), s.approvalWorkflow, id, func(db *gorm.DB) *gorm.DB {
-			return db.Preload("ActionUser")
+			return s.withRelations(db)
 		})
 		if err != nil {
 			s.Log.Warnf("Unable to load approvals for projectflock %d: %+v", id, err)
@@ -184,7 +188,7 @@ func (s projectflockService) getOneEntityOnly(c *fiber.Ctx, id uint) (*entity.Pr
 	return projectflock, nil
 }
 
-func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock, *flockDTO.FlockBaseDTO, error) {
+func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock, *flockDTO.FlockRelationDTO, error) {
 	projectflock, err := s.Repository.GetByID(c.Context(), id, s.Repository.WithDefaultRelations())
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
@@ -196,7 +200,7 @@ func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock
 
 	if s.ApprovalSvc != nil {
 		approvals, err := s.ApprovalSvc.ListByTarget(c.Context(), s.approvalWorkflow, id, func(db *gorm.DB) *gorm.DB {
-			return db.Preload("ActionUser")
+			return s.withRelations(db)
 		})
 		if err != nil {
 			s.Log.Warnf("Unable to load approvals for projectflock %d: %+v", id, err)
@@ -211,7 +215,7 @@ func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock
 	}
 
 	// Fetch Flock master data for this ProjectFlock
-	var flockResult *flockDTO.FlockBaseDTO
+	var flockResult *flockDTO.FlockRelationDTO
 	if projectflock.FlockName != "" {
 		baseName := pfutils.DeriveBaseName(projectflock.FlockName)
 		if baseName != "" {
@@ -219,7 +223,7 @@ func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock
 			if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 				s.Log.Warnf("Failed to fetch flock %q: %+v", baseName, err)
 			} else if flock != nil {
-				flockResult = &flockDTO.FlockBaseDTO{
+				flockResult = &flockDTO.FlockRelationDTO{
 					Id:   flock.Id,
 					Name: flock.Name,
 				}
@@ -282,6 +286,11 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 	if len(kandangs) != len(kandangIDs) {
 		return nil, fiber.NewError(fiber.StatusNotFound, "Some kandangs not found")
 	}
+	for _, kandang := range kandangs {
+		if kandang.LocationId != req.LocationId {
+			return nil, fiber.NewError(fiber.StatusBadRequest, fmt.Sprintf("Kandang %d tidak berada pada lokasi yang sama dengan project flock", kandang.Id))
+		}
+	}
 	// larang kalau ada yg sudah terikat ke project lain
 	if linked, err := s.pivotRepo().HasKandangsLinkedToOtherProject(c.Context(), kandangIDs, nil); err != nil {
 		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate kandangs linkage")
@@ -300,22 +309,24 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(dbTransaction *gorm.DB) error {
 		projectRepo := repository.NewProjectflockRepository(dbTransaction)
 
-		nextSeq, err := projectRepo.GetNextSequenceForBase(c.Context(), canonicalBase)
-		if err != nil {
-			return err
-		}
-		generatedName, seq, err := s.generateSequentialFlockName(c.Context(), projectRepo, canonicalBase, nextSeq, nil)
+		// Generate unique flock name (sequential per base name, starting from 1)
+		generatedName, _, err := s.generateSequentialFlockName(c.Context(), projectRepo, canonicalBase, 1, nil)
 		if err != nil {
 			return err
 		}
 		createBody.FlockName = generatedName
-		createBody.Period = seq
 
 		if err := projectRepo.CreateOne(c.Context(), createBody, nil); err != nil {
 			return err
 		}
 
-		if err := s.attachKandangs(c.Context(), dbTransaction, createBody.Id, kandangIDs); err != nil {
+		// Compute period based on location history (max period in that location + 1),
+		// and store it on project_flock_kandangs only.
+		nextPeriod, err := s.nextLocationPeriod(c.Context(), dbTransaction, req.LocationId)
+		if err != nil {
+			return err
+		}
+		if err := s.attachKandangs(c.Context(), dbTransaction, createBody.Id, kandangIDs, nextPeriod); err != nil {
 			return err
 		}
 
@@ -451,6 +462,15 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 		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 {
@@ -476,18 +496,11 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 		}
 
 		if needFlockNameRegenerate {
-			nextSeq, err := projectRepo.GetNextSequenceForBase(c.Context(), baseForGeneration)
-			if err != nil {
-				return err
-			}
-			newName, seq, err := s.generateSequentialFlockName(c.Context(), projectRepo, baseForGeneration, nextSeq, &id)
+			newName, _, err := s.generateSequentialFlockName(c.Context(), projectRepo, baseForGeneration, 1, &id)
 			if err != nil {
 				return err
 			}
 			updateBody["flock_name"] = newName
-			if seq != existing.Period {
-				updateBody["period"] = seq
-			}
 		}
 
 		if len(updateBody) > 0 {
@@ -531,7 +544,19 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 			}
 
 			if len(toAttach) > 0 {
-				if err := s.attachKandangs(c.Context(), dbTransaction, id, toAttach); err != nil {
+				var currentPeriod int
+				if err := dbTransaction.WithContext(c.Context()).
+					Table("project_flock_kandangs").
+					Where("project_flock_id = ?", id).
+					Select("COALESCE(MAX(period), 0)").
+					Scan(&currentPeriod).Error; err != nil {
+					return err
+				}
+				if currentPeriod <= 0 {
+					currentPeriod = 1
+				}
+
+				if err := s.attachKandangs(c.Context(), dbTransaction, id, toAttach, currentPeriod); err != nil {
 					return err
 				}
 			}
@@ -807,57 +832,90 @@ func (s projectflockService) GetAvailableDocQuantity(ctx *fiber.Ctx, kandangID u
 	return total, nil
 }
 
-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")
+// nextLocationPeriod computes the next period number for a given location
+// based on the maximum period that has ever been used by any kandang in that location.
+func (s projectflockService) nextLocationPeriod(ctx context.Context, tx *gorm.DB, locationID uint) (int, error) {
+	if locationID == 0 {
+		return 0, fiber.NewError(fiber.StatusBadRequest, "location_id is required to compute 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")
+	db := s.Repository.DB()
+	if tx != nil {
+		db = tx
 	}
+
+	var maxPeriod int
+	if err := db.WithContext(ctx).
+		Table("project_flock_kandangs pfk").
+		Joins("JOIN kandangs k ON k.id = pfk.kandang_id").
+		Where("k.location_id = ?", locationID).
+		Select("COALESCE(MAX(pfk.period), 0)").
+		Scan(&maxPeriod).Error; err != nil {
+		s.Log.Errorf("Failed to compute max period for location %d: %+v", locationID, err)
+		return 0, fiber.NewError(fiber.StatusInternalServerError, "Failed to compute period for location")
+	}
+
+	return maxPeriod + 1, nil
+}
+
+func (s projectflockService) GetProjectPeriods(c *fiber.Ctx, projectIDs []uint) (map[uint]int, error) {
+	if len(projectIDs) == 0 {
+		return map[uint]int{}, nil
+	}
+	return s.pivotRepo().ProjectPeriodsByProjectIDs(c.Context(), projectIDs)
+}
+
+func (s projectflockService) GetFlockPeriodSummary(c *fiber.Ctx, locationID uint) ([]KandangPeriodSummary, error) {
+	if locationID == 0 {
+		return nil, fiber.NewError(fiber.StatusBadRequest, "location_id is required")
+	}
+
+	exists, err := s.Repository.LocationExists(c.Context(), locationID)
 	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")
+		s.Log.Errorf("Failed to validate location %d: %+v", locationID, err)
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to validate location")
+	}
+	if !exists {
+		return nil, fiber.NewError(fiber.StatusNotFound, "Location not found")
 	}
 
-	var baseName string
-	var referenceFlock *entity.Flock
-	if pivot.ProjectFlock.Id != 0 {
-		baseName = pfutils.DeriveBaseName(pivot.ProjectFlock.FlockName)
+	type kandangPeriodRow struct {
+		Id           uint
+		Name         string
+		LatestPeriod int
 	}
 
-	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")
-		}
+	var rows []kandangPeriodRow
+
+	db := s.Repository.DB().WithContext(c.Context())
+	if err := db.
+		Table("kandangs AS k").
+		Select("k.id, k.name, COALESCE(MAX(pfk.period), 0) AS latest_period").
+		Joins("LEFT JOIN project_flock_kandangs AS pfk ON pfk.kandang_id = k.id").
+		Where("k.location_id = ?", locationID).
+		Where("k.deleted_at IS NULL").
+		Group("k.id, k.name").
+		Order("k.id ASC").
+		Scan(&rows).Error; err != nil {
+		s.Log.Errorf("Failed to fetch kandang period summary for location %d: %+v", locationID, err)
+		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to fetch kandang period summary")
 	}
 
-	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
+	summaries := make([]KandangPeriodSummary, 0, len(rows))
+	for _, row := range rows {
+		nextPeriod := 0
+		if row.LatestPeriod > 0 {
+			nextPeriod = row.LatestPeriod + 1
 		}
 
-		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
-		}
+		summaries = append(summaries, KandangPeriodSummary{
+			Id:     row.Id,
+			Name:   row.Name,
+			Period: nextPeriod,
+		})
 	}
 
-	return &FlockPeriodSummary{
-		Flock:      *referenceFlock,
-		NextPeriod: maxPeriod + 1,
-	}, nil
+	return summaries, nil
 }
 
 func uniqueUintSlice(values []uint) []uint {
@@ -933,7 +991,7 @@ func (s projectflockService) ensureFlockByName(ctx context.Context, actorID uint
 	return newFlock, nil
 }
 
-func (s projectflockService) attachKandangs(ctx context.Context, dbTransaction *gorm.DB, projectFlockID uint, kandangIDs []uint) error {
+func (s projectflockService) attachKandangs(ctx context.Context, dbTransaction *gorm.DB, projectFlockID uint, kandangIDs []uint, period int) error {
 	if len(kandangIDs) == 0 {
 		return nil
 	}
@@ -971,6 +1029,7 @@ func (s projectflockService) attachKandangs(ctx context.Context, dbTransaction *
 		records = append(records, &entity.ProjectFlockKandang{
 			ProjectFlockId: projectFlockID,
 			KandangId:      id,
+			Period:         period,
 		})
 	}
 	if err := s.pivotRepoWithTx(dbTransaction).CreateMany(ctx, records); err != nil {
@@ -1040,10 +1099,11 @@ func (s projectflockService) kandangRepoWithTx(tx *gorm.DB) kandangRepository.Ka
 	return kandangRepository.NewKandangRepository(s.Repository.DB())
 }
 
-func actorIDFromContext(c *fiber.Ctx) (uint, error) {
+func actorIDFromContext(_ *fiber.Ctx) (uint, error) {
 	// user, ok := authmiddleware.AuthenticatedUser(c)
 	// if !ok || user == nil || user.Id == 0 {
 	// 	return 0, fiber.NewError(fiber.StatusUnauthorized, "Please authenticate")
 	// }
+	// return user.Id, nil
 	return 1, nil
 }