feat(BE): approval_workflow, adjusment project_flocks, common, and migration

internal/common/repository/common.approval.repository..go

@@ -0,0 +1,106 @@
+package repository
+
+import (
+	"context"
+	"errors"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	"gorm.io/gorm"
+)
+
+type ApprovalRepository interface {
+	BaseRepository[entity.Approval]
+	FindByTarget(ctx context.Context, workflow string, approvableID uint, modifier func(*gorm.DB) *gorm.DB) ([]entity.Approval, error)
+	LatestByTarget(ctx context.Context, workflow string, approvableID uint, modifier func(*gorm.DB) *gorm.DB) (*entity.Approval, error)
+	LatestByTargets(ctx context.Context, workflow string, approvableIDs []uint, modifier func(*gorm.DB) *gorm.DB) (map[uint]entity.Approval, error)
+}
+
+type approvalRepositoryImpl struct {
+	*BaseRepositoryImpl[entity.Approval]
+}
+
+func NewApprovalRepository(db *gorm.DB) ApprovalRepository {
+	return &approvalRepositoryImpl{
+		BaseRepositoryImpl: NewBaseRepository[entity.Approval](db),
+	}
+}
+
+func (r *approvalRepositoryImpl) FindByTarget(
+	ctx context.Context,
+	workflow string,
+	approvableID uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) ([]entity.Approval, error) {
+	var approvals []entity.Approval
+
+	q := r.DB().WithContext(ctx).Where("approvable_type = ? AND approvable_id = ?", workflow, approvableID)
+	if modifier != nil {
+		q = modifier(q)
+	}
+
+	if err := q.Order("action_at ASC").Find(&approvals).Error; err != nil {
+		return nil, err
+	}
+	return approvals, nil
+}
+
+func (r *approvalRepositoryImpl) LatestByTarget(
+	ctx context.Context,
+	workflow string,
+	approvableID uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) (*entity.Approval, error) {
+	var approval entity.Approval
+
+	q := r.DB().WithContext(ctx).
+		Where("approvable_type = ? AND approvable_id = ?", workflow, approvableID).
+		Order("action_at DESC")
+
+	if modifier != nil {
+		q = modifier(q)
+	}
+
+	if err := q.Limit(1).First(&approval).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	return &approval, nil
+}
+
+func (r *approvalRepositoryImpl) LatestByTargets(
+	ctx context.Context,
+	workflow string,
+	approvableIDs []uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) (map[uint]entity.Approval, error) {
+	if len(approvableIDs) == 0 {
+		return nil, nil
+	}
+
+	result := make(map[uint]entity.Approval, len(approvableIDs))
+
+	q := r.DB().WithContext(ctx).
+		Where("approvable_type = ? AND approvable_id IN ?", workflow, approvableIDs).
+		Order("action_at DESC")
+
+	if modifier != nil {
+		q = modifier(q)
+	}
+
+	var approvals []entity.Approval
+	if err := q.Find(&approvals).Error; err != nil {
+		return nil, err
+	}
+
+	for _, approval := range approvals {
+		if _, exists := result[approval.ApprovableId]; exists {
+			continue
+		}
+		result[approval.ApprovableId] = approval
+	}
+
+	return result, nil
+}

internal/common/service/common.approval.service.go

@@ -0,0 +1,234 @@
+package service
+
+import (
+	"context"
+	"strings"
+
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
+	"gorm.io/gorm"
+)
+
+type ApprovalService interface {
+	RegisterWorkflowSteps(workflow approvalutils.ApprovalWorkflowKey, steps map[approvalutils.ApprovalStep]string) error
+	WorkflowSteps(workflow approvalutils.ApprovalWorkflowKey) map[approvalutils.ApprovalStep]string
+	WorkflowStepName(workflow approvalutils.ApprovalWorkflowKey, step approvalutils.ApprovalStep) (string, bool)
+	CreateApproval(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, step approvalutils.ApprovalStep, action *entity.ApprovalAction, actorID uint, note *string) (*entity.Approval, error)
+	List(ctx context.Context, module string, approvableID *uint, page, limit int, search string) ([]entity.Approval, int64, error)
+	ListByTarget(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, modifier func(*gorm.DB) *gorm.DB) ([]entity.Approval, error)
+	LatestByTarget(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableID uint, modifier func(*gorm.DB) *gorm.DB) (*entity.Approval, error)
+	LatestByTargets(ctx context.Context, workflow approvalutils.ApprovalWorkflowKey, approvableIDs []uint, modifier func(*gorm.DB) *gorm.DB) (map[uint]*entity.Approval, error)
+}
+
+type approvalService struct {
+	repo commonRepo.ApprovalRepository
+}
+
+func NewApprovalService(repo commonRepo.ApprovalRepository) ApprovalService {
+	return &approvalService{repo: repo}
+}
+
+func (s *approvalService) RegisterWorkflowSteps(workflow approvalutils.ApprovalWorkflowKey, steps map[approvalutils.ApprovalStep]string) error {
+	return approvalutils.RegisterWorkflowSteps(workflow, steps)
+}
+
+func (s *approvalService) WorkflowSteps(workflow approvalutils.ApprovalWorkflowKey) map[approvalutils.ApprovalStep]string {
+	return approvalutils.WorkflowSteps(workflow)
+}
+
+func (s *approvalService) WorkflowStepName(workflow approvalutils.ApprovalWorkflowKey, step approvalutils.ApprovalStep) (string, bool) {
+	return approvalutils.ApprovalStepName(workflow, step)
+}
+
+func (s *approvalService) CreateApproval(
+	ctx context.Context,
+	workflow approvalutils.ApprovalWorkflowKey,
+	approvableID uint,
+	step approvalutils.ApprovalStep,
+	action *entity.ApprovalAction,
+	actorID uint,
+	note *string,
+) (*entity.Approval, error) {
+	record, err := approvalutils.NewApproval(workflow, approvableID, step, action, actorID, note)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := s.repo.CreateOne(ctx, record, nil); err != nil {
+		return nil, err
+	}
+
+	s.decorateApproval(workflow, record)
+
+	return record, nil
+}
+
+func (s *approvalService) List(
+	ctx context.Context,
+	module string,
+	approvableID *uint,
+	page, limit int,
+	search string,
+) ([]entity.Approval, int64, error) {
+	module = strings.TrimSpace(strings.ToUpper(module))
+	search = strings.TrimSpace(search)
+
+	if limit <= 0 {
+		limit = 10
+	}
+	if page <= 0 {
+		page = 1
+	}
+
+	offset := (page - 1) * limit
+
+	records, total, err := s.repo.GetAll(
+		ctx,
+		offset,
+		limit,
+		func(db *gorm.DB) *gorm.DB {
+			query := db.
+				Where("approvable_type = ?", module).
+				Order("action_at DESC").
+				Preload("ActionUser")
+
+			if approvableID != nil {
+				query = query.Where("approvable_id = ?", *approvableID)
+			}
+
+			if search != "" {
+				like := "%" + strings.ToLower(search) + "%"
+				query = query.Where("(LOWER(step_name) LIKE ? OR LOWER(action) LIKE ? OR LOWER(notes) LIKE ?)", like, like, like)
+			}
+
+			return query
+		},
+	)
+	if err != nil {
+		if s.isApprovalTableMissing(err) {
+			return nil, 0, nil
+		}
+		return nil, 0, err
+	}
+	if len(records) == 0 {
+		return nil, total, nil
+	}
+
+	workflow := approvalutils.ApprovalWorkflowKey(module)
+	for i := range records {
+		s.decorateApproval(workflow, &records[i])
+	}
+
+	return records, total, nil
+}
+
+func (s *approvalService) ListByTarget(
+	ctx context.Context,
+	workflow approvalutils.ApprovalWorkflowKey,
+	approvableID uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) ([]entity.Approval, error) {
+	records, err := s.repo.FindByTarget(ctx, workflow.String(), approvableID, modifier)
+	if err != nil {
+		if s.isApprovalTableMissing(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	for i := range records {
+		s.decorateApproval(workflow, &records[i])
+	}
+
+	return records, nil
+}
+
+func (s *approvalService) LatestByTarget(
+	ctx context.Context,
+	workflow approvalutils.ApprovalWorkflowKey,
+	approvableID uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) (*entity.Approval, error) {
+	record, err := s.repo.LatestByTarget(ctx, workflow.String(), approvableID, modifier)
+	if err != nil {
+		if s.isApprovalTableMissing(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	if record == nil {
+		return nil, nil
+	}
+	s.decorateApproval(workflow, record)
+	return record, nil
+}
+
+func (s *approvalService) LatestByTargets(
+	ctx context.Context,
+	workflow approvalutils.ApprovalWorkflowKey,
+	approvableIDs []uint,
+	modifier func(*gorm.DB) *gorm.DB,
+) (map[uint]*entity.Approval, error) {
+	records, err := s.repo.LatestByTargets(ctx, workflow.String(), approvableIDs, modifier)
+	if err != nil {
+		if s.isApprovalTableMissing(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	if len(records) == 0 {
+		return nil, nil
+	}
+
+	result := make(map[uint]*entity.Approval, len(records))
+	for approvableID, approval := range records {
+		approvalCopy := approval
+		s.decorateApproval(workflow, &approvalCopy)
+		result[approvableID] = &approvalCopy
+	}
+
+	return result, nil
+}
+
+func (s *approvalService) decorateApproval(workflow approvalutils.ApprovalWorkflowKey, approval *entity.Approval) {
+	if approval == nil {
+		return
+	}
+	currentName := strings.TrimSpace(approval.StepName)
+	if currentName == "" {
+		if name, ok := approvalutils.ApprovalStepName(workflow, approvalutils.ApprovalStep(approval.StepNumber)); ok {
+			approval.StepName = name
+		}
+	} else {
+		approval.StepName = currentName
+	}
+}
+
+func (s *approvalService) isApprovalTableMissing(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	errMsg := strings.ToLower(err.Error())
+
+	if strings.Contains(errMsg, "no such table: approvals") {
+		return true
+	}
+
+	schemaIssues := []string{
+		`relation "approvals" does not exist`,
+		`column "step_name" does not exist`,
+		`column "step_number" does not exist`,
+		`column "action" does not exist`,
+		`column "status" does not exist`,
+		`column "step" does not exist`,
+	}
+	for _, issue := range schemaIssues {
+		if strings.Contains(errMsg, issue) {
+			return true
+		}
+	}
+
+	return false
+}

internal/database/migrations/20251015162158_create_approvals_table.down.sql

@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS approvals_approvable_lookup;
+DROP TABLE IF EXISTS approvals;

internal/database/migrations/20251015162158_create_approvals_table.up.sql

@@ -0,0 +1,12 @@
+CREATE TABLE approvals (
+    id BIGSERIAL PRIMARY KEY,
+    approvable_type VARCHAR(50) NOT NULL,
+    approvable_id BIGINT NOT NULL,
+    step SMALLINT NOT NULL,
+    status VARCHAR(20) NOT NULL,
+    notes TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+    action_by BIGINT REFERENCES users (id) ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+CREATE INDEX approvals_approvable_lookup ON approvals (approvable_type, approvable_id);

internal/database/migrations/20251017071755_rename_approval_status_to_action.down.sql

@@ -0,0 +1,18 @@
+ALTER TABLE approvals
+    RENAME COLUMN action TO status;
+
+UPDATE approvals
+SET status = 'PENDING'
+WHERE status IS NULL;
+
+ALTER TABLE approvals
+    ALTER COLUMN status SET NOT NULL;
+
+ALTER TABLE approvals
+    RENAME COLUMN step_number TO step;
+
+ALTER TABLE approvals
+    DROP COLUMN step_name;
+
+ALTER TABLE approvals
+    RENAME COLUMN action_at TO created_at;

internal/database/migrations/20251017071755_rename_approval_status_to_action.up.sql

@@ -0,0 +1,14 @@
+ALTER TABLE approvals
+    RENAME COLUMN status TO action;
+
+ALTER TABLE approvals
+    ALTER COLUMN action DROP NOT NULL;
+
+ALTER TABLE approvals
+    RENAME COLUMN step TO step_number;
+
+ALTER TABLE approvals
+    ADD COLUMN step_name VARCHAR NOT NULL;
+
+ALTER TABLE approvals
+    RENAME COLUMN created_at TO action_at;

internal/database/seed/seeder.go

@@ -8,6 +8,7 @@ import (
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 
 	"gorm.io/gorm"
 )
@@ -322,12 +323,68 @@ func seedProjectFlocks(tx *gorm.DB, createdBy uint, flocks, areas, fcrs, locatio
 				return nil, err
 			}
 		}
+
+		if err := ensureProjectFlockApprovals(tx, projectFlock.Id, createdBy); err != nil {
+			return nil, err
+		}
 		result[seed.Key] = projectFlock.Id
 	}
 
 	return result, nil
 }
 
+func ensureProjectFlockApprovals(tx *gorm.DB, projectFlockID uint, actorID uint) error {
+	if projectFlockID == 0 || actorID == 0 {
+		return nil
+	}
+
+	workflow := utils.ApprovalWorkflowProjectFlock.String()
+
+	steps := []struct {
+		step   approvalutils.ApprovalStep
+		action entity.ApprovalAction
+	}{
+		{step: utils.ProjectFlockStepPengajuan, action: entity.ApprovalActionCreated},
+		{step: utils.ProjectFlockStepAktif, action: entity.ApprovalActionApproved},
+	}
+
+	for _, cfg := range steps {
+		var count int64
+		if err := tx.Model(&entity.Approval{}).
+			Where("approvable_type = ? AND approvable_id = ? AND step_number = ?", workflow, projectFlockID, uint16(cfg.step)).
+			Count(&count).Error; err != nil {
+			return err
+		}
+		if count > 0 {
+			continue
+		}
+
+		stepName, ok := utils.ProjectFlockApprovalSteps[cfg.step]
+		if !ok || strings.TrimSpace(stepName) == "" {
+			stepName = fmt.Sprintf("Step %d", cfg.step)
+		}
+
+		var actionPtr *entity.ApprovalAction
+		action := cfg.action
+		actionPtr = &action
+
+		record := entity.Approval{
+			ApprovableType: workflow,
+			ApprovableId:   projectFlockID,
+			StepNumber:     uint16(cfg.step),
+			StepName:       stepName,
+			Action:         actionPtr,
+			ActionBy:       uintPtr(actorID),
+		}
+
+		if err := tx.Create(&record).Error; err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func seedKandangs(tx *gorm.DB, createdBy uint, locations map[string]uint, users map[string]uint, projectFlocks map[string]uint) (map[string]uint, error) {
 	seeds := []struct {
 		Name            string

internal/entities/approval.go

@@ -0,0 +1,28 @@
+package entities
+
+import (
+	"time"
+)
+
+type ApprovalAction string
+
+const (
+	ApprovalActionApproved ApprovalAction = "APPROVED"
+	ApprovalActionRejected ApprovalAction = "REJECTED"
+	ApprovalActionCreated  ApprovalAction = "CREATED"
+	ApprovalActionUpdated  ApprovalAction = "UPDATED"
+)
+
+type Approval struct {
+	Id             uint            `gorm:"primaryKey"`
+	ApprovableType string          `gorm:"size:50;not null;index:approvals_approvable_lookup,priority:1"`
+	ApprovableId   uint            `gorm:"not null;index:approvals_approvable_lookup,priority:2"`
+	StepNumber     uint16          `gorm:"not null"`
+	StepName       string          `gorm:"not null"`
+	Action         *ApprovalAction `gorm:"type:VARCHAR(20)"`
+	Notes          *string         `gorm:"type:text"`
+	ActionAt       time.Time       `gorm:"autoCreateTime"`
+	ActionBy       *uint           `gorm:"index"`
+
+	ActionUser *User `gorm:"foreignKey:ActionBy;references:Id"`
+}

internal/entities/projectfloc.go

@@ -1,28 +0,0 @@
-package entities
-
-import (
-	"time"
-
-	"gorm.io/gorm"
-)
-
-type ProjectFlock struct {
-	Id             uint                  `gorm:"primaryKey"`
-	FlockId        uint                  `gorm:"not null;uniqueIndex:project_flocks_flock_period_unique"`
-	AreaId         uint                  `gorm:"not null"`
-	Category       string                `gorm:"type:varchar(20);not null"`
-	FcrId          uint                  `gorm:"not null"`
-	LocationId     uint                  `gorm:"not null"`
-	Period         int                   `gorm:"not null;uniqueIndex:project_flocks_flock_period_unique"`
-	CreatedBy      uint                  `gorm:"not null"`
-	CreatedAt      time.Time             `gorm:"autoCreateTime"`
-	UpdatedAt      time.Time             `gorm:"autoUpdateTime"`
-	DeletedAt      gorm.DeletedAt        `gorm:"index" json:"-"`
-	Flock          Flock                 `gorm:"foreignKey:FlockId;references:Id"`
-	Area           Area                  `gorm:"foreignKey:AreaId;references:Id"`
-	Fcr            Fcr                   `gorm:"foreignKey:FcrId;references:Id"`
-	Location       Location              `gorm:"foreignKey:LocationId;references:Id"`
-	CreatedUser    User                  `gorm:"foreignKey:CreatedBy;references:Id"`
-	Kandangs       []Kandang             `gorm:"foreignKey:ProjectFlockId;references:Id"`
-	KandangHistory []ProjectFlockKandang `gorm:"foreignKey:ProjectFlockId;references:Id"`
-}

internal/entities/projectflock.go

@@ -0,0 +1,29 @@
+package entities
+
+import (
+	"time"
+
+	"gorm.io/gorm"
+)
+
+type ProjectFlock struct {
+	Id         uint           `gorm:"primaryKey"`
+	FlockId    uint           `gorm:"not null;uniqueIndex:project_flocks_flock_period_unique"`
+	AreaId     uint           `gorm:"not null"`
+	Category   string         `gorm:"type:varchar(20);not null"`
+	FcrId      uint           `gorm:"not null"`
+	LocationId uint           `gorm:"not null"`
+	Period     int            `gorm:"not null;uniqueIndex:project_flocks_flock_period_unique"`
+	CreatedBy  uint           `gorm:"not null"`
+	CreatedAt  time.Time      `gorm:"autoCreateTime"`
+	UpdatedAt  time.Time      `gorm:"autoUpdateTime"`
+	DeletedAt  gorm.DeletedAt `gorm:"index" json:"-"`
+
+	Flock          Flock                 `gorm:"foreignKey:FlockId;references:Id"`
+	Area           Area                  `gorm:"foreignKey:AreaId;references:Id"`
+	Fcr            Fcr                   `gorm:"foreignKey:FcrId;references:Id"`
+	Location       Location              `gorm:"foreignKey:LocationId;references:Id"`
+	CreatedUser    User                  `gorm:"foreignKey:CreatedBy;references:Id"`
+	Kandangs       []Kandang             `gorm:"foreignKey:ProjectFlockId;references:Id"`
+	KandangHistory []ProjectFlockKandang `gorm:"foreignKey:ProjectFlockId;references:Id"`
+}

internal/modules/approvals/controllers/approval.controller.go

@@ -0,0 +1,100 @@
+package controller
+
+import (
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/gofiber/fiber/v2"
+	common "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	"gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/dto"
+	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/validations"
+	"gitlab.com/mbugroup/lti-api.git/internal/response"
+)
+
+type ApprovalController struct {
+	ApprovalService common.ApprovalService
+}
+
+func NewApprovalController(approvalService common.ApprovalService) *ApprovalController {
+	return &ApprovalController{
+		ApprovalService: approvalService,
+	}
+}
+
+func (u *ApprovalController) GetAll(c *fiber.Ctx) error {
+	moduleName := strings.TrimSpace(c.Query("module_name", ""))
+	if moduleName == "" {
+		return fiber.NewError(fiber.StatusBadRequest, "`module_name` is required")
+	}
+
+	moduleIDParam := strings.TrimSpace(c.Query("module_id", ""))
+	var moduleID *uint
+	if moduleIDParam != "" {
+		value, err := strconv.ParseUint(moduleIDParam, 10, 64)
+		if err != nil || value == 0 {
+			return fiber.NewError(fiber.StatusBadRequest, "module_id must be a positive integer")
+		}
+		id := uint(value)
+		moduleID = &id
+	}
+
+	groupByStep := c.QueryBool("group_step_number", false)
+
+	page := c.QueryInt("page", 1)
+	limit := c.QueryInt("limit", 10)
+	search := strings.TrimSpace(c.Query("search", ""))
+
+	query := &validation.Query{
+		ModuleName:  moduleName,
+		ModuleId:    moduleID,
+		GroupByStep: groupByStep,
+		Page:        page,
+		Limit:       limit,
+		Search:      search,
+	}
+
+	records, totalResults, err := u.ApprovalService.List(
+		c.Context(),
+		query.ModuleName,
+		query.ModuleId,
+		query.Page,
+		query.Limit,
+		query.Search,
+	)
+	if err != nil {
+		return err
+	}
+
+	if query.GroupByStep {
+		data := dto.ToApprovalGroupDTOs(records)
+		return c.Status(fiber.StatusOK).
+			JSON(response.SuccessWithPaginate[dto.ApprovalGroupDTO]{
+				Code:    fiber.StatusOK,
+				Status:  "success",
+				Message: "Get All approvals successfully",
+				Meta: response.Meta{
+					Page:         query.Page,
+					Limit:        query.Limit,
+					TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+					TotalResults: totalResults,
+				},
+				Data: data,
+			})
+	}
+
+	flat := dto.ToApprovalDTOs(records)
+	return c.Status(fiber.StatusOK).
+		JSON(response.SuccessWithPaginate[dto.ApprovalBaseDTO]{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Get All approvals successfully",
+			Meta: response.Meta{
+				Page:         query.Page,
+				Limit:        query.Limit,
+				TotalPages:   int64(math.Ceil(float64(totalResults) / float64(query.Limit))),
+				TotalResults: totalResults,
+			},
+			Data: flat,
+		})
+}

internal/modules/approvals/dto/approval.dto.go

@@ -0,0 +1,122 @@
+package dto
+
+import (
+	"sort"
+	"strings"
+	"time"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
+)
+
+type ApprovalBaseDTO struct {
+	StepNumber uint16              `json:"step_number"`
+	StepName   string              `json:"step_name"`
+	Action     *string             `json:"action"`
+	Notes      *string             `json:"notes"`
+	ActionBy   userDTO.UserBaseDTO `json:"action_by"`
+	ActionAt   time.Time           `json:"action_at"`
+}
+
+type ApprovalGroupDTO struct {
+	StepNumber uint16            `json:"step_number"`
+	StepName   string            `json:"step_name"`
+	Approvals  []ApprovalBaseDTO `json:"approvals"`
+}
+
+func ToApprovalDTO(e entity.Approval) ApprovalBaseDTO {
+	dto := ApprovalBaseDTO{
+		Notes: e.Notes,
+	}
+
+	if e.StepNumber > 0 {
+		stepCopy := uint16(e.StepNumber)
+		dto.StepNumber = stepCopy
+	}
+
+	stepName := strings.TrimSpace(e.StepName)
+	if stepName == "" && e.ApprovableType != "" && e.StepNumber > 0 {
+		if label, ok := approvalutils.ApprovalStepName(approvalutils.ApprovalWorkflowKey(e.ApprovableType), approvalutils.ApprovalStep(e.StepNumber)); ok {
+			stepName = label
+		}
+	}
+	dto.StepName = stepName
+
+	if e.Action != nil {
+		value := strings.TrimSpace(string(*e.Action))
+		if value != "" {
+			valueCopy := value
+			dto.Action = &valueCopy
+		}
+	}
+
+	if e.ActionUser != nil && e.ActionUser.Id != 0 {
+		user := userDTO.ToUserBaseDTO(*e.ActionUser)
+		dto.ActionBy = user
+	} else if e.ActionBy != nil && *e.ActionBy != 0 {
+		dto.ActionBy = userDTO.UserBaseDTO{
+			Id:     *e.ActionBy,
+			IdUser: int64(*e.ActionBy),
+		}
+	}
+
+	if !e.ActionAt.IsZero() {
+		at := e.ActionAt
+		dto.ActionAt = at
+	}
+
+	return dto
+}
+
+func ToApprovalDTOs(items []entity.Approval) []ApprovalBaseDTO {
+	result := make([]ApprovalBaseDTO, len(items))
+	for i, item := range items {
+		result[i] = ToApprovalDTO(item)
+	}
+	return result
+}
+
+func ToApprovalGroupDTOs(items []entity.Approval) []ApprovalGroupDTO {
+	if len(items) == 0 {
+		return nil
+	}
+
+	type groupAccumulator struct {
+		StepName  string
+		Approvals []ApprovalBaseDTO
+	}
+
+	groups := make(map[uint16]*groupAccumulator)
+	order := make([]uint16, 0)
+	for _, item := range items {
+		step := item.StepNumber
+		acc, exists := groups[step]
+		if !exists {
+			stepName := strings.TrimSpace(item.StepName)
+			if stepName == "" && item.ApprovableType != "" && item.StepNumber > 0 {
+				if label, ok := approvalutils.ApprovalStepName(approvalutils.ApprovalWorkflowKey(item.ApprovableType), approvalutils.ApprovalStep(item.StepNumber)); ok {
+					stepName = label
+				}
+			}
+			acc = &groupAccumulator{StepName: stepName}
+			groups[step] = acc
+			order = append(order, step)
+		}
+		acc.Approvals = append(acc.Approvals, ToApprovalDTO(item))
+	}
+
+	sort.Slice(order, func(i, j int) bool { return order[i] < order[j] })
+
+	result := make([]ApprovalGroupDTO, len(order))
+	for i, step := range order {
+		acc := groups[step]
+		result[i] = ApprovalGroupDTO{
+			StepNumber: step,
+			StepName:   acc.StepName,
+			Approvals:  acc.Approvals,
+		}
+	}
+
+	return result
+}

internal/modules/approvals/module.go

@@ -0,0 +1,25 @@
+package approvals
+
+import (
+	"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"
+
+	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
+	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+type ApprovalModule struct{}
+
+func (ApprovalModule) RegisterRoutes(router fiber.Router, db *gorm.DB, validate *validator.Validate) {
+	approvalRepo := commonRepo.NewApprovalRepository(db)
+	userRepo := rUser.NewUserRepository(db)
+
+	approvalService := commonSvc.NewApprovalService(approvalRepo)
+	userService := sUser.NewUserService(userRepo, validate)
+
+	ApprovalRoutes(router, userService, approvalService)
+}

internal/modules/approvals/route.go

@@ -0,0 +1,19 @@
+package approvals
+
+import (
+	// m "gitlab.com/mbugroup/lti-api.git/internal/middleware"
+	"github.com/gofiber/fiber/v2"
+
+	common "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	controller "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals/controllers"
+	user "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
+)
+
+func ApprovalRoutes(v1 fiber.Router, u user.UserService, s common.ApprovalService) {
+	_ = u
+	ctrl := controller.NewApprovalController(s)
+
+	route := v1.Group("/approvals")
+
+	route.Get("/", ctrl.GetAll)
+}

internal/modules/approvals/validations/approval.validation.go

@@ -0,0 +1,10 @@
+package validation
+
+type Query struct {
+	ModuleName  string `json:"module_name" validate:"required_strict"`
+	ModuleId    *uint  `json:"module_id,omitempty" validate:"omitempty,gt=0"`
+	GroupByStep bool   `json:"group_by_step"`
+	Page        int    `query:"page" validate:"omitempty,number,min=1"`
+	Limit       int    `query:"limit" validate:"omitempty,number,min=1,max=100,gt=0"`
+	Search      string `query:"search" validate:"omitempty,max=50"`
+}

internal/modules/constants/repositories/constant.repository.go

@@ -1,9 +1,13 @@
 package repository
 
 import (
+	"sort"
+	"strconv"
+
 	"gitlab.com/mbugroup/lti-api.git/internal/common/repository"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 	"gorm.io/gorm"
 )
 
@@ -26,6 +30,50 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 	for f := range utils.AllFlagTypes() {
 		flagList = append(flagList, string(f))
 	}
+	sort.Strings(flagList)
+
+	type approvalStepConstant struct {
+		StepNumber uint16 `json:"step_number"`
+		StepName   string `json:"step_name"`
+	}
+
+	workflowConstants := approvalutils.WorkflowConstants()
+	workflowKeys := make([]string, 0, len(workflowConstants))
+	for key := range workflowConstants {
+		workflowKeys = append(workflowKeys, key)
+	}
+	sort.Strings(workflowKeys)
+
+	approvalWorkflows := make([]map[string]interface{}, 0, len(workflowKeys))
+	for _, key := range workflowKeys {
+		stepMap := workflowConstants[key]
+		if len(stepMap) == 0 {
+			continue
+		}
+
+		stepList := make([]approvalStepConstant, 0, len(stepMap))
+		for stepStr, label := range stepMap {
+			stepNum, err := strconv.ParseUint(stepStr, 10, 16)
+			if err != nil || stepNum == 0 {
+				continue
+			}
+			stepList = append(stepList, approvalStepConstant{
+				StepNumber: uint16(stepNum),
+				StepName:   label,
+			})
+		}
+		if len(stepList) == 0 {
+			continue
+		}
+		sort.Slice(stepList, func(i, j int) bool {
+			return stepList[i].StepNumber < stepList[j].StepNumber
+		})
+
+		approvalWorkflows = append(approvalWorkflows, map[string]interface{}{
+			"key":   key,
+			"steps": stepList,
+		})
+	}
 
 	return map[string]interface{}{
 		"flags": flagList,
@@ -42,5 +90,6 @@ func (r *ConstantRepositoryImpl) GetConstants() map[string]interface{} {
 			"BISNIS",
 			"INDIVIDUAL",
 		},
+		"approval_workflows": approvalWorkflows,
 	}
 }

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

@@ -190,6 +190,33 @@ func (u *ProjectflockController) DeleteOne(c *fiber.Ctx) error {
 		})
 }
 
+func (u *ProjectflockController) Approval(c *fiber.Ctx) error {
+	param := c.Params("id")
+
+	id, err := strconv.Atoi(param)
+	if err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid Id")
+	}
+
+	req := new(validation.Approve)
+	if err := c.BodyParser(req); err != nil {
+		return fiber.NewError(fiber.StatusBadRequest, "Invalid request body")
+	}
+
+	result, err := u.ProjectflockService.Approval(c, uint(id), req)
+	if err != nil {
+		return err
+	}
+
+	return c.Status(fiber.StatusOK).
+		JSON(response.Success{
+			Code:    fiber.StatusOK,
+			Status:  "success",
+			Message: "Submit projectflock approval successfully",
+			Data:    dto.ToProjectFlockListDTO(*result),
+		})
+}
+
 func (u *ProjectflockController) GetFlockPeriodSummary(c *fiber.Ctx) error {
 	param := c.Params("flock_id")
 

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

@@ -4,12 +4,15 @@ import (
 	"time"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+	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"
 	userDTO "gitlab.com/mbugroup/lti-api.git/internal/modules/users/dto"
+	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 )
 
 type ProjectFlockBaseDTO struct {
@@ -22,55 +25,25 @@ type ProjectFlockBaseDTO struct {
 	Location *locationDTO.LocationBaseDTO `json:"location"`
 }
 
-func ToProjectFlockBaseDTO(e entity.ProjectFlock) ProjectFlockBaseDTO {
-	var flock *flockDTO.FlockBaseDTO
-	if e.Flock.Id != 0 {
-		mapped := flockDTO.ToFlockBaseDTO(e.Flock)
-		flock = &mapped
-	}
-
-	var area *areaDTO.AreaBaseDTO
-	if e.Area.Id != 0 {
-		mapped := areaDTO.ToAreaBaseDTO(e.Area)
-		area = &mapped
-	}
-
-	var fcr *fcrDTO.FcrBaseDTO
-	if e.Fcr.Id != 0 {
-		mapped := fcrDTO.ToFcrBaseDTO(e.Fcr)
-		fcr = &mapped
-	}
-
-	var location *locationDTO.LocationBaseDTO
-	if e.Location.Id != 0 {
-		mapped := locationDTO.ToLocationBaseDTO(e.Location)
-		location = &mapped
-	}
-
-	return ProjectFlockBaseDTO{
-		Id:       e.Id,
-		Period:   e.Period,
-		Category: e.Category,
-		Flock:    flock,
-		Area:     area,
-		Fcr:      fcr,
-		Location: location,
-	}
-}
-
 type ProjectFlockListDTO struct {
 	ProjectFlockBaseDTO
-	Kandangs    []kandangDTO.KandangBaseDTO `json:"kandangs,omitempty"`
-	CreatedUser *userDTO.UserBaseDTO        `json:"created_user"`
-	CreatedAt   time.Time                   `json:"created_at"`
-	UpdatedAt   time.Time                   `json:"updated_at"`
+	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    []kandangDTO.KandangBaseDTO  `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"`
 }
 
 type ProjectFlockDetailDTO struct {
 	ProjectFlockListDTO
 }
 
-type FlockPeriodSummaryDTO struct {
+type FlockPeriodDTO struct {
 	Flock      flockDTO.FlockBaseDTO `json:"flock"`
 	NextPeriod int                   `json:"next_period"`
 }
@@ -90,12 +63,19 @@ func ToProjectFlockListDTO(e entity.ProjectFlock) ProjectFlockListDTO {
 		}
 	}
 
+	latestApproval := defaultProjectFlockLatestApproval(e)
+	if e.LatestApproval != nil {
+		snapshot := approvalDTO.ToApprovalDTO(*e.LatestApproval)
+		latestApproval = snapshot
+	}
+
 	return ProjectFlockListDTO{
 		ProjectFlockBaseDTO: ToProjectFlockBaseDTO(e),
 		Kandangs:            kandangSummaries,
 		CreatedAt:           e.CreatedAt,
 		UpdatedAt:           e.UpdatedAt,
 		CreatedUser:         createdUser,
+		Approval:            latestApproval,
 	}
 }
 
@@ -113,9 +93,48 @@ func ToProjectFlockDetailDTO(e entity.ProjectFlock) ProjectFlockDetailDTO {
 	}
 }
 
-func ToFlockPeriodSummaryDTO(flock entity.Flock, next int) FlockPeriodSummaryDTO {
-	return FlockPeriodSummaryDTO{
-		Flock:      flockDTO.ToFlockBaseDTO(flock),
+func defaultProjectFlockLatestApproval(e entity.ProjectFlock) approvalDTO.ApprovalBaseDTO {
+	result := approvalDTO.ApprovalBaseDTO{}
+
+	step := utils.ProjectFlockStepPengajuan
+	if step > 0 {
+		result.StepNumber = uint16(step)
+		if label, ok := approvalutils.ApprovalStepName(utils.ApprovalWorkflowProjectFlock, step); ok {
+			result.StepName = label
+		} else if label, ok := utils.ProjectFlockApprovalSteps[step]; ok {
+			result.StepName = label
+		}
+	}
+	if result.StepName == "" {
+		result.StepName = "Pengajuan"
+	}
+
+	if !e.CreatedAt.IsZero() {
+		result.ActionAt = e.CreatedAt
+	}
+
+	if e.CreatedUser.Id != 0 {
+		result.ActionBy = userDTO.ToUserBaseDTO(e.CreatedUser)
+	} else if e.CreatedBy != 0 {
+		result.ActionBy = userDTO.UserBaseDTO{
+			Id:     e.CreatedBy,
+			IdUser: int64(e.CreatedBy),
+		}
+	}
+
+	return result
+}
+
+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/module.go

@@ -1,8 +1,12 @@
 package project_flocks
 
 import (
+	"fmt"
+
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
+	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	"gorm.io/gorm"
 
 	rFlock "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/repositories"
@@ -10,6 +14,7 @@ import (
 	rProjectflock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 
 	sProjectflock "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/services"
+	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
 
 	rUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/repositories"
 	sUser "gitlab.com/mbugroup/lti-api.git/internal/modules/users/services"
@@ -24,7 +29,13 @@ func (ProjectflockModule) RegisterRoutes(router fiber.Router, db *gorm.DB, valid
 	projectflockKandangRepo := rProjectflock.NewProjectFlockKandangRepository(db)
 	userRepo := rUser.NewUserRepository(db)
 
-	projectflockService := sProjectflock.NewProjectflockService(projectflockRepo, flockRepo, kandangRepo, projectflockKandangRepo, validate)
+	approvalRepo := commonRepo.NewApprovalRepository(db)
+	approvalService := commonSvc.NewApprovalService(approvalRepo)
+	if err := approvalService.RegisterWorkflowSteps(utils.ApprovalWorkflowProjectFlock, utils.ProjectFlockApprovalSteps); err != nil {
+		panic(fmt.Sprintf("failed to register project flock approval workflow: %v", err))
+	}
+
+	projectflockService := sProjectflock.NewProjectflockService(projectflockRepo, flockRepo, kandangRepo, projectflockKandangRepo, approvalService, validate)
 	userService := sUser.NewUserService(userRepo, validate)
 
 	ProjectflockRoutes(router, userService, projectflockService)

internal/modules/production/project_flocks/route.go

@@ -25,5 +25,6 @@ func ProjectflockRoutes(v1 fiber.Router, u user.UserService, s projectflock.Proj
 	route.Get("/:id", ctrl.GetOne)
 	route.Patch("/:id", ctrl.UpdateOne)
 	route.Delete("/:id", ctrl.DeleteOne)
+	route.Post("/:id/approvals", ctrl.Approval)
 	route.Get("/flocks/:flock_id/periods", ctrl.GetFlockPeriodSummary)
 }

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

@@ -7,13 +7,14 @@ import (
 	"strings"
 
 	commonRepo "gitlab.com/mbugroup/lti-api.git/internal/common/repository"
-	common "gitlab.com/mbugroup/lti-api.git/internal/common/service"
+	commonSvc "gitlab.com/mbugroup/lti-api.git/internal/common/service"
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	flockRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/master/flocks/repositories"
 	kandangRepository "gitlab.com/mbugroup/lti-api.git/internal/modules/master/kandangs/repositories"
 	repository "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/repositories"
 	validation "gitlab.com/mbugroup/lti-api.git/internal/modules/production/project_flocks/validations"
-	"gitlab.com/mbugroup/lti-api.git/internal/utils"
+	utils "gitlab.com/mbugroup/lti-api.git/internal/utils"
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
 
 	"github.com/go-playground/validator/v10"
 	"github.com/gofiber/fiber/v2"
@@ -28,15 +29,18 @@ type ProjectflockService interface {
 	UpdateOne(ctx *fiber.Ctx, req *validation.Update, id uint) (*entity.ProjectFlock, error)
 	DeleteOne(ctx *fiber.Ctx, id uint) error
 	GetFlockPeriodSummary(ctx *fiber.Ctx, flockID uint) (*FlockPeriodSummary, error)
+	Approval(ctx *fiber.Ctx, id uint, req *validation.Approve) (*entity.ProjectFlock, error)
 }
 
 type projectflockService struct {
-	Log         *logrus.Logger
-	Validate    *validator.Validate
-	Repository  repository.ProjectflockRepository
-	FlockRepo   flockRepository.FlockRepository
-	KandangRepo kandangRepository.KandangRepository
+	Log              *logrus.Logger
+	Validate         *validator.Validate
+	Repository       repository.ProjectflockRepository
+	FlockRepo        flockRepository.FlockRepository
+	KandangRepo      kandangRepository.KandangRepository
 	PivotRepo   repository.ProjectFlockKandangRepository
+	ApprovalSvc      commonSvc.ApprovalService
+	approvalWorkflow approvalutils.ApprovalWorkflowKey
 }
 
 type FlockPeriodSummary struct {
@@ -49,15 +53,18 @@ func NewProjectflockService(
 	flockRepo flockRepository.FlockRepository,
 	kandangRepo kandangRepository.KandangRepository,
 	pivotRepo repository.ProjectFlockKandangRepository,
+	approvalSvc commonSvc.ApprovalService,
 	validate *validator.Validate,
 ) ProjectflockService {
 	return &projectflockService{
-		Log:         utils.Log,
-		Validate:    validate,
-		Repository:  repo,
-		FlockRepo:   flockRepo,
-		KandangRepo: kandangRepo,
+		Log:              utils.Log,
+		Validate:         validate,
+		Repository:       repo,
+		FlockRepo:        flockRepo,
+		KandangRepo:      kandangRepo,
 		PivotRepo:   pivotRepo,
+		ApprovalSvc:      approvalSvc,
+		approvalWorkflow: utils.ApprovalWorkflowProjectFlock,
 	}
 }
 
@@ -68,7 +75,7 @@ func (s projectflockService) withRelations(db *gorm.DB) *gorm.DB {
 		Preload("Area").
 		Preload("Fcr").
 		Preload("Location").
-		Preload("Kandangs")
+		Preload("Kandangs.Location")
 }
 
 func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]entity.ProjectFlock, int64, error) {
@@ -154,6 +161,27 @@ func (s projectflockService) GetAll(c *fiber.Ctx, params *validation.Query) ([]e
 		s.Log.Errorf("Failed to get projectflocks: %+v", err)
 		return nil, 0, err
 	}
+
+	if s.ApprovalSvc != nil && len(projectflocks) > 0 {
+		ids := make([]uint, len(projectflocks))
+		for i, item := range projectflocks {
+			ids[i] = item.Id
+		}
+
+		latestMap, err := s.ApprovalSvc.LatestByTargets(c.Context(), s.approvalWorkflow, ids, func(db *gorm.DB) *gorm.DB {
+			return db.Preload("ActionUser")
+		})
+		if err != nil {
+			s.Log.Warnf("Unable to load latest approvals for projectflocks: %+v", err)
+		} else if len(latestMap) > 0 {
+			for i := range projectflocks {
+				if approval, ok := latestMap[projectflocks[i].Id]; ok {
+					projectflocks[i].LatestApproval = approval
+				}
+			}
+		}
+	}
+
 	return projectflocks, total, nil
 }
 
@@ -166,6 +194,23 @@ func (s projectflockService) GetOne(c *fiber.Ctx, id uint) (*entity.ProjectFlock
 		s.Log.Errorf("Failed get projectflock by id: %+v", err)
 		return nil, err
 	}
+
+	if s.ApprovalSvc != nil {
+		approvals, err := s.ApprovalSvc.ListByTarget(c.Context(), s.approvalWorkflow, id, func(db *gorm.DB) *gorm.DB {
+			return db.Preload("ActionUser")
+		})
+		if err != nil {
+			s.Log.Warnf("Unable to load approvals for projectflock %d: %+v", id, err)
+		} else if len(approvals) > 0 {
+			if projectflock.LatestApproval == nil {
+				latest := approvals[len(approvals)-1]
+				projectflock.LatestApproval = &latest
+			}
+		} else {
+			projectflock.LatestApproval = nil
+		}
+	}
+
 	return projectflock, nil
 }
 
@@ -183,11 +228,11 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 		return nil, fiber.NewError(fiber.StatusBadRequest, "kandang_ids is required")
 	}
 
-	if err := common.EnsureRelations(c.Context(),
-		common.RelationCheck{Name: "Flock", ID: &req.FlockId, Exists: relationExistsChecker[entity.Flock](s.Repository.DB())},
-		common.RelationCheck{Name: "Area", ID: &req.AreaId, Exists: relationExistsChecker[entity.Area](s.Repository.DB())},
-		common.RelationCheck{Name: "FCR", ID: &req.FcrId, Exists: relationExistsChecker[entity.Fcr](s.Repository.DB())},
-		common.RelationCheck{Name: "Location", ID: &req.LocationId, Exists: relationExistsChecker[entity.Location](s.Repository.DB())},
+	if err := commonSvc.EnsureRelations(c.Context(),
+		commonSvc.RelationCheck{Name: "Flock", ID: &req.FlockId, Exists: relationExistsChecker[entity.Flock](s.Repository.DB())},
+		commonSvc.RelationCheck{Name: "Area", ID: &req.AreaId, Exists: relationExistsChecker[entity.Area](s.Repository.DB())},
+		commonSvc.RelationCheck{Name: "FCR", ID: &req.FcrId, Exists: relationExistsChecker[entity.Fcr](s.Repository.DB())},
+		commonSvc.RelationCheck{Name: "Location", ID: &req.LocationId, Exists: relationExistsChecker[entity.Location](s.Repository.DB())},
 	); err != nil {
 		return nil, err
 	}
@@ -209,19 +254,6 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 		}
 	}
 
-	tx := s.Repository.DB().Begin()
-	if tx.Error != nil {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to start transaction")
-	}
-
-	projectRepo := repository.NewProjectflockRepository(tx)
-	nextPeriod, err := projectRepo.GetNextPeriodForFlock(c.Context(), req.FlockId)
-	if err != nil {
-		tx.Rollback()
-		s.Log.Errorf("Failed to determine next period for flock %d: %+v", req.FlockId, err)
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to determine next period")
-	}
-
 	createBody := &entity.ProjectFlock{
 		FlockId:    req.FlockId,
 		AreaId:     req.AreaId,
@@ -232,8 +264,60 @@ func (s *projectflockService) CreateOne(c *fiber.Ctx, req *validation.Create) (*
 		CreatedBy:  1,
 	}
 
-	if err := projectRepo.CreateOne(c.Context(), createBody, nil); err != nil {
-		tx.Rollback()
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		projectRepo := repository.NewProjectflockRepository(tx)
+		// kandangRepo := kandangRepository.NewKandangRepository(tx)
+
+		period, err := projectRepo.GetNextPeriodForFlock(c.Context(), req.FlockId)
+		if err != nil {
+			return err
+		}
+		createBody.Period = period
+
+		if err := projectRepo.CreateOne(c.Context(), createBody, nil); err != nil {
+			return err
+		}
+
+		// kandangUpdates := make([]*entity.Kandang, len(kandangs))
+		// for i := range kandangs {
+		// 	kandangs[i].ProjectFlockId = &createBody.Id
+		// 	kandangUpdates[i] = &kandangs[i]
+		// }
+		// if err := kandangRepo.UpdateMany(
+		// 	c.Context(),
+		// 	kandangUpdates,
+		// 	func(db *gorm.DB) *gorm.DB {
+		// 		return db.Select("project_flock_id")
+		// 	},
+		// ); err != nil {
+		// 	return err
+		// }
+
+		if err := tx.Model(&entity.Kandang{}).
+			Where("id IN ?", kandangIDs).
+			Updates(map[string]any{
+				"project_flock_id": createBody.Id,
+				"status":           string(utils.KandangStatusPengajuan),
+			}).Error; err != nil {
+			return err
+		}
+
+		actorID := uint(1) //TODO: Change From Auth
+		action := entity.ApprovalActionCreated
+		approvalSvcTx := commonSvc.NewApprovalService(commonRepo.NewApprovalRepository(tx))
+		_, err = approvalSvcTx.CreateApproval(
+			c.Context(),
+			utils.ApprovalWorkflowProjectFlock,
+			createBody.Id,
+			utils.ProjectFlockStepPengajuan,
+			&action,
+			actorID,
+			nil,
+		)
+		return err
+	})
+
+	if err != nil {
 		if errors.Is(err, gorm.ErrDuplicatedKey) {
 			return nil, fiber.NewError(fiber.StatusConflict, "Project flock period already exists")
 		}
@@ -268,13 +352,14 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 		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)
-	var relationChecks []common.RelationCheck
+	hasBodyChanges := false
+	var relationChecks []commonSvc.RelationCheck
 
 	if req.FlockId != nil {
 		updateBody["flock_id"] = *req.FlockId
-		relationChecks = append(relationChecks, common.RelationCheck{
+		hasBodyChanges = true
+		relationChecks = append(relationChecks, commonSvc.RelationCheck{
 			Name:   "Flock",
 			ID:     req.FlockId,
 			Exists: relationExistsChecker[entity.Flock](s.Repository.DB()),
@@ -282,7 +367,8 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 	}
 	if req.AreaId != nil {
 		updateBody["area_id"] = *req.AreaId
-		relationChecks = append(relationChecks, common.RelationCheck{
+		hasBodyChanges = true
+		relationChecks = append(relationChecks, commonSvc.RelationCheck{
 			Name:   "Area",
 			ID:     req.AreaId,
 			Exists: relationExistsChecker[entity.Area](s.Repository.DB()),
@@ -297,7 +383,8 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 	}
 	if req.FcrId != nil {
 		updateBody["fcr_id"] = *req.FcrId
-		relationChecks = append(relationChecks, common.RelationCheck{
+		hasBodyChanges = true
+		relationChecks = append(relationChecks, commonSvc.RelationCheck{
 			Name:   "FCR",
 			ID:     req.FcrId,
 			Exists: relationExistsChecker[entity.Fcr](s.Repository.DB()),
@@ -305,7 +392,8 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 	}
 	if req.LocationId != nil {
 		updateBody["location_id"] = *req.LocationId
-		relationChecks = append(relationChecks, common.RelationCheck{
+		hasBodyChanges = true
+		relationChecks = append(relationChecks, commonSvc.RelationCheck{
 			Name:   "Location",
 			ID:     req.LocationId,
 			Exists: relationExistsChecker[entity.Location](s.Repository.DB()),
@@ -313,16 +401,19 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 	}
 	if req.Period != nil {
 		updateBody["period"] = *req.Period
+		hasBodyChanges = true
 	}
 
 	if len(relationChecks) > 0 {
-		if err := common.EnsureRelations(c.Context(), relationChecks...); err != nil {
+		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")
 		}
@@ -344,46 +435,47 @@ func (s projectflockService) UpdateOne(c *fiber.Ctx, req *validation.Update, id
 		}
 	}
 
-	tx := s.Repository.DB().Begin()
-	if tx.Error != nil {
-		return nil, fiber.NewError(fiber.StatusInternalServerError, "Failed to start transaction")
+	hasChanges := hasBodyChanges || hasKandangChanges
+	if !hasChanges {
+		return s.GetOne(c, id)
 	}
 
-	projectRepo := repository.NewProjectflockRepository(tx)
-	if len(updateBody) > 0 {
-		if err := projectRepo.PatchOne(c.Context(), id, updateBody, nil); err != nil {
-			tx.Rollback()
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return nil, fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
+	err = s.Repository.DB().WithContext(c.Context()).Transaction(func(tx *gorm.DB) error {
+		projectRepo := repository.NewProjectflockRepository(tx)
+
+		if len(updateBody) > 0 {
+			if err := projectRepo.PatchOne(c.Context(), id, updateBody, nil); err != nil {
+				return err
 			}
-			s.Log.Errorf("Failed to update projectflock: %+v", err)
-			return nil, 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 _, id := range newKandangIDs {
-			newSet[id] = struct{}{}
-		}
-
-		var toDetach []uint
-		for id := range existingIDs {
-			if _, ok := newSet[id]; !ok {
-				toDetach = append(toDetach, id)
+		} else {
+			if _, err := projectRepo.GetByID(c.Context(), id, nil); err != nil {
+				return err
 			}
 		}
 
-		var toAttach []uint
-		for id := range newSet {
-			if _, ok := existingIDs[id]; !ok {
-				toAttach = append(toAttach, id)
+		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(), tx, id, toDetach, false); err != nil {
@@ -437,18 +529,21 @@ func (s projectflockService) DeleteOne(c *fiber.Ctx, id uint) error {
 		}
 	}
 
-	if err := repository.NewProjectflockRepository(tx).DeleteOne(c.Context(), id); err != nil {
-		tx.Rollback()
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
+		if err := repository.NewProjectflockRepository(tx).DeleteOne(c.Context(), id); err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fiber.NewError(fiber.StatusNotFound, "Projectflock not found")
+			}
+			return err
 		}
-		s.Log.Errorf("Failed to delete projectflock: %+v", err)
-		return err
-	}
 
-	if err := tx.Commit().Error; err != nil {
-		tx.Rollback()
-		return fiber.NewError(fiber.StatusInternalServerError, "Failed to commit transaction")
+		return nil
+	})
+	if err != nil {
+		if fiberErr, ok := err.(*fiber.Error); ok {
+			return fiberErr
+		}
+		s.Log.Errorf("Failed to delete projectflock %d: %+v", id, err)
+		return err
 	}
 
 	return nil

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

@@ -30,3 +30,8 @@ type Query struct {
 	Period     int    `query:"period" validate:"omitempty,number,gt=0"`
 	KandangIds []uint `query:"kandang_id" validate:"omitempty,dive,gt=0"`
 }
+
+type Approve struct {
+	Action string  `json:"action" validate:"required_strict"`
+	Notes  *string `json:"notes,omitempty" validate:"omitempty,max=500"`
+}

internal/route/route.go

@@ -13,6 +13,7 @@ import (
 	master "gitlab.com/mbugroup/lti-api.git/internal/modules/master"
 	users "gitlab.com/mbugroup/lti-api.git/internal/modules/users"
 		production "gitlab.com/mbugroup/lti-api.git/internal/modules/production"
+		approvals "gitlab.com/mbugroup/lti-api.git/internal/modules/approvals"
 	// MODULE IMPORTS
 )
 
@@ -28,6 +29,7 @@ func Routes(app *fiber.App, db *gorm.DB) {
 		constants.ConstantModule{},
 		inventory.InventoryModule{},
 				production.ProductionModule{},
+				approvals.ApprovalModule{},
 		// MODULE REGISTRY
 	}
 

internal/utils/approvals/util.approval_workflow.go

@@ -0,0 +1,243 @@
+package approvals
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
+)
+
+type ApprovalStep uint16
+
+type ApprovalWorkflowKey string
+
+func (k ApprovalWorkflowKey) String() string {
+	return string(k)
+}
+
+type NextStepCallback func(current ApprovalStep, decision entity.ApprovalAction) (ApprovalStep, bool)
+
+var (
+	approvalActions = map[entity.ApprovalAction]struct{}{
+		entity.ApprovalActionApproved: {},
+		entity.ApprovalActionRejected: {},
+		entity.ApprovalActionCreated:  {},
+		entity.ApprovalActionUpdated:  {},
+	}
+
+	approvalWorkflows   = make(map[ApprovalWorkflowKey]map[ApprovalStep]string)
+	approvalWorkflowsMu sync.RWMutex
+)
+
+// WorkflowConstants prepares the registered workflows for exposure via constants endpoints.
+func WorkflowConstants() map[string]map[string]string {
+	approvalWorkflowsMu.RLock()
+	defer approvalWorkflowsMu.RUnlock()
+
+	if len(approvalWorkflows) == 0 {
+		return nil
+	}
+
+	result := make(map[string]map[string]string, len(approvalWorkflows))
+	for workflow, steps := range approvalWorkflows {
+		if len(steps) == 0 {
+			continue
+		}
+		stepMap := make(map[string]string, len(steps))
+		for step, label := range steps {
+			stepMap[fmt.Sprintf("%d", step)] = label
+		}
+		result[workflow.String()] = stepMap
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+// RegisterWorkflowSteps stores the available steps for a workflow key (usually matching approvable type).
+func RegisterWorkflowSteps(workflow ApprovalWorkflowKey, steps map[ApprovalStep]string) error {
+	workflowStr := strings.TrimSpace(workflow.String())
+	if workflowStr == "" {
+		return errors.New("workflow key is required")
+	}
+	if len(steps) == 0 {
+		return fmt.Errorf("no steps defined for workflow %q", workflowStr)
+	}
+
+	copied := make(map[ApprovalStep]string, len(steps))
+	for step, label := range steps {
+		if step == 0 {
+			return fmt.Errorf("workflow %q contains step 0 which is not allowed", workflowStr)
+		}
+		trimmed := strings.TrimSpace(label)
+		if trimmed == "" {
+			return fmt.Errorf("workflow %q contains empty label for step %d", workflowStr, step)
+		}
+		copied[step] = trimmed
+	}
+
+	approvalWorkflowsMu.Lock()
+	defer approvalWorkflowsMu.Unlock()
+	approvalWorkflows[ApprovalWorkflowKey(workflowStr)] = copied
+	return nil
+}
+
+// WorkflowSteps returns the steps registered for the given workflow key.
+func WorkflowSteps(workflow ApprovalWorkflowKey) map[ApprovalStep]string {
+	approvalWorkflowsMu.RLock()
+	defer approvalWorkflowsMu.RUnlock()
+
+	workflowStr := strings.TrimSpace(workflow.String())
+	if workflowStr == "" {
+		return nil
+	}
+
+	steps, ok := approvalWorkflows[ApprovalWorkflowKey(workflowStr)]
+	if !ok || len(steps) == 0 {
+		return nil
+	}
+
+	copied := make(map[ApprovalStep]string, len(steps))
+	for step, label := range steps {
+		copied[step] = label
+	}
+	return copied
+}
+
+// ApprovalStepName fetches the label for the target step inside the workflow.
+func ApprovalStepName(workflow ApprovalWorkflowKey, step ApprovalStep) (string, bool) {
+	steps := WorkflowSteps(workflow)
+	if len(steps) == 0 {
+		return "", false
+	}
+	label, ok := steps[step]
+	return label, ok
+}
+
+// ValidateApprovalStep ensures the workflow contains the provided step.
+func ValidateApprovalStep(workflow ApprovalWorkflowKey, step ApprovalStep) error {
+	if _, ok := ApprovalStepName(workflow, step); ok {
+		return nil
+	}
+	return fmt.Errorf("invalid approval step %d for workflow %s", step, workflow)
+}
+
+// IsValidApprovalAction reports whether the action is supported.
+func IsValidApprovalAction(action entity.ApprovalAction) bool {
+	_, ok := approvalActions[action]
+	return ok
+}
+
+// NewApproval creates an approval record for the given approvable target.
+func NewApproval(workflow ApprovalWorkflowKey, approvableId uint, step ApprovalStep, action *entity.ApprovalAction, actorId uint, note *string) (*entity.Approval, error) {
+	if approvableId == 0 {
+		return nil, errors.New("approvable id is required")
+	}
+
+	workflowStr := strings.TrimSpace(workflow.String())
+	if workflowStr == "" {
+		return nil, errors.New("approval workflow key is required")
+	}
+
+	key := ApprovalWorkflowKey(workflowStr)
+
+	if err := ValidateApprovalStep(key, step); err != nil {
+		return nil, err
+	}
+
+	var actionPtr *entity.ApprovalAction
+	if action != nil {
+		if !IsValidApprovalAction(*action) {
+			return nil, fmt.Errorf("invalid approval action %q", *action)
+		}
+		actionCopy := *action
+		actionPtr = &actionCopy
+	}
+
+	if actorId == 0 {
+		return nil, errors.New("actor id is required")
+	}
+
+	var notes *string
+	if note != nil {
+		trimmed := strings.TrimSpace(*note)
+		if trimmed != "" {
+			notes = &trimmed
+		}
+	}
+
+	actor := actorId
+	var stepName string
+	if label, ok := ApprovalStepName(key, step); ok {
+		labelCopy := label
+		stepName = labelCopy
+	}
+
+	return &entity.Approval{
+		ApprovableType: workflowStr,
+		ApprovableId:   approvableId,
+		StepNumber:     uint16(step),
+		StepName:       stepName,
+		Action:         actionPtr,
+		Notes:          notes,
+		ActionBy:       &actor,
+	}, nil
+}
+
+// SetApprovalAction updates the approval action, notes, and optionally advances to another step.
+func SetApprovalAction(approval *entity.Approval, action entity.ApprovalAction, actorId uint, note *string, nextStep NextStepCallback) error {
+	if approval == nil {
+		return errors.New("approval is nil")
+	}
+	if !IsValidApprovalAction(action) {
+		return fmt.Errorf("invalid approval action %q", action)
+	}
+	if actorId == 0 {
+		return errors.New("actor id is required for approval decision")
+	}
+
+	act := action
+	approval.Action = &act
+	approval.ActionBy = &actorId
+
+	if note != nil {
+		trimmed := strings.TrimSpace(*note)
+		if trimmed == "" {
+			approval.Notes = nil
+		} else {
+			approval.Notes = &trimmed
+		}
+	} else {
+		approval.Notes = nil
+	}
+
+	if nextStep != nil {
+		current := ApprovalStep(approval.StepNumber)
+		if proposed, ok := nextStep(current, action); ok {
+			if err := ValidateApprovalStep(ApprovalWorkflowKey(approval.ApprovableType), proposed); err != nil {
+				return err
+			}
+			approval.StepNumber = uint16(proposed)
+		}
+	}
+
+	if label, ok := ApprovalStepName(ApprovalWorkflowKey(approval.ApprovableType), ApprovalStep(approval.StepNumber)); ok {
+		labelCopy := label
+		approval.StepName = labelCopy
+	}
+
+	return nil
+}
+
+// Approve marks the approval as approved by the given actor, applying the optional step callback.
+func Approve(approval *entity.Approval, actorId uint, note *string, nextStep NextStepCallback) error {
+	return SetApprovalAction(approval, entity.ApprovalActionApproved, actorId, note, nextStep)
+}
+
+// Reject marks the approval as rejected by the given actor, applying the optional step callback.
+func Reject(approval *entity.Approval, actorId uint, note *string, nextStep NextStepCallback) error {
+	return SetApprovalAction(approval, entity.ApprovalActionRejected, actorId, note, nextStep)
+}

internal/utils/constant.go

@@ -1,6 +1,10 @@
 package utils
 
-import "strings"
+import (
+	"strings"
+
+	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
+)
 
 // -------------------------------------------------------------------
 // FlagType & Groups
@@ -120,6 +124,22 @@ const (
 	ProjectFlockCategoryLaying  ProjectFlockCategory = "LAYING"
 )
 
+// -------------------------------------------------------------------
+// Project Flock Approval
+// -------------------------------------------------------------------
+
+const (
+	ApprovalWorkflowProjectFlock approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PROJECT_FLOCKS")
+	ProjectFlockStepPengajuan    approvalutils.ApprovalStep        = 1
+	ProjectFlockStepAktif        approvalutils.ApprovalStep        = 2
+)
+
+// projectFlockApprovalSteps keeps the workflow step definitions for project flock approvals.
+var ProjectFlockApprovalSteps = map[approvalutils.ApprovalStep]string{
+	ProjectFlockStepPengajuan: "Pengajuan",
+	ProjectFlockStepAktif:     "Aktif",
+}
+
 // -------------------------------------------------------------------
 // Validators
 // -------------------------------------------------------------------