lti-api/internal/utils/constant.go

package utils

import (
	"strings"

	approvalutils "gitlab.com/mbugroup/lti-api.git/internal/utils/approvals"
)

// -------------------------------------------------------------------
// FlagType & Groups
// -------------------------------------------------------------------

type FlagType string

type FlagGroup string

const (
	FlagIsActive FlagType = "IS_ACTIVE"

	FlagDOC        FlagType = "DOC"
	FlagPakan      FlagType = "PAKAN"
	FlagPreStarter FlagType = "PRE-STARTER"
	FlagStarter    FlagType = "STARTER"
	FlagFinisher   FlagType = "FINISHER"
	FlagOVK        FlagType = "OVK"
	FlagObat       FlagType = "OBAT"
	FlagVitamin    FlagType = "VITAMIN"
	FlagKimia      FlagType = "KIMIA"
	FlagEkspedisi  FlagType = "EKSPEDISI"
)

const (
	FlagGroupProduct  FlagGroup = "PRODUCT"
	FlagGroupNonstock FlagGroup = "NONSTOCK"
)

var flagGroupOptions = map[FlagGroup][]FlagType{
	FlagGroupProduct: {
		FlagDOC,
		FlagPakan,
		FlagPreStarter,
		FlagStarter,
		FlagFinisher,
		FlagOVK,
		FlagObat,
		FlagVitamin,
		FlagKimia,
	},
	FlagGroupNonstock: {
		FlagEkspedisi,
	},
}

var allFlagTypes = func() map[FlagType]struct{} {
	m := map[FlagType]struct{}{
		FlagIsActive: {},
	}
	for _, flags := range flagGroupOptions {
		for _, flag := range flags {
			m[flag] = struct{}{}
		}
	}
	return m
}()

func AllFlagTypes() map[FlagType]struct{} {
	return allFlagTypes
}

// -------------------------------------------------------------------
// WarehouseType
// -------------------------------------------------------------------

type WarehouseType string

const (
	WarehouseTypeArea    WarehouseType = "AREA"
	WarehouseTypeLokasi  WarehouseType = "LOKASI"
	WarehouseTypeKandang WarehouseType = "KANDANG"
)

// -------------------------------------------------------------------
// WarehouseType
// -------------------------------------------------------------------

type CustomerSupplierType string

const (
	CustomerSupplierTypeBisnis     CustomerSupplierType = "BISNIS"
	CustomerSupplierTypeIndividual CustomerSupplierType = "INDIVIDUAL"
)

// -------------------------------------------------------------------
// SupplierCategory
// -------------------------------------------------------------------

type SupplierCategory string

const (
	SupplierCategoryBOP      SupplierCategory = "BOP"
	SupplierCategorySapronak SupplierCategory = "SAPRONAK"
)

// -------------------------------------------------------------------
// Kandang Status
// -------------------------------------------------------------------

type KandangStatus string

const (
	KandangStatusNonActive KandangStatus = "NON_ACTIVE"
	KandangStatusPengajuan KandangStatus = "PENGAJUAN"
	KandangStatusActive    KandangStatus = "ACTIVE"
)

// -------------------------------------------------------------------
// ProjectFlockCategory
// -------------------------------------------------------------------

type ProjectFlockCategory string

const (
	ProjectFlockCategoryGrowing ProjectFlockCategory = "GROWING"
	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
// -------------------------------------------------------------------

func IsValidFlagType(v string) bool {
	_, ok := allFlagTypes[FlagType(strings.ToUpper(strings.TrimSpace(v)))]
	return ok
}

func AllowedFlagTypes(group FlagGroup) []FlagType {
	options, ok := flagGroupOptions[group]
	if !ok {
		return nil
	}
	result := make([]FlagType, len(options))
	copy(result, options)
	return result
}

func InvalidFlagsForGroup(flags []FlagType, group FlagGroup) []FlagType {
	if len(flags) == 0 {
		return nil
	}
	options, ok := flagGroupOptions[group]
	if !ok {
		return flags
	}
	allowed := make(map[FlagType]struct{}, len(options))
	for _, flag := range options {
		allowed[flag] = struct{}{}
	}
	invalid := make([]FlagType, 0)
	for _, flag := range flags {
		if _, ok := allowed[flag]; !ok {
			invalid = append(invalid, flag)
		}
	}
	return invalid
}

func NormalizeFlagTypes(flags []string) []FlagType {
	if len(flags) == 0 {
		return nil
	}
	seen := make(map[FlagType]struct{}, len(flags))
	result := make([]FlagType, 0, len(flags))
	for _, flag := range flags {
		normalized := FlagType(strings.ToUpper(strings.TrimSpace(flag)))
		if normalized == "" {
			continue
		}
		if _, exists := seen[normalized]; exists {
			continue
		}
		seen[normalized] = struct{}{}
		result = append(result, normalized)
	}
	if len(result) == 0 {
		return nil
	}
	return result
}

func FlagTypesToStrings(flags []FlagType) []string {
	if len(flags) == 0 {
		return nil
	}
	result := make([]string, len(flags))
	for i, flag := range flags {
		result[i] = string(flag)
	}
	return result
}

func NormalizeFlagsForGroup(raw []string, group FlagGroup) (normalized []FlagType, invalid []FlagType) {
	normalized = NormalizeFlagTypes(raw)
	if len(normalized) == 0 {
		return nil, nil
	}
	invalid = InvalidFlagsForGroup(normalized, group)
	if len(invalid) == 0 {
		return normalized, nil
	}
	return normalized, invalid
}

func IsValidWarehouseType(v string) bool {
	switch WarehouseType(v) {
	case WarehouseTypeArea, WarehouseTypeLokasi, WarehouseTypeKandang:
		return true
	}
	return false
}

func IsValidKandangStatus(v string) bool {
	switch KandangStatus(v) {
	case KandangStatusNonActive, KandangStatusPengajuan, KandangStatusActive:
		return true
	}
	return false
}

func IsValidCustomerSupplierType(v string) bool {
	switch CustomerSupplierType(v) {
	case CustomerSupplierTypeBisnis, CustomerSupplierTypeIndividual:
		return true
	}
	return false
}

func IsValidProjectFlockCategory(v string) bool {
	switch ProjectFlockCategory(v) {
	case ProjectFlockCategoryGrowing, ProjectFlockCategoryLaying:
		return true
	}
	return false
}

func IsValidSupplierCategory(v string) bool {
	switch SupplierCategory(v) {
	case SupplierCategoryBOP, SupplierCategorySapronak:
		return true
	}
	return false
}

// example use

/**
if !utils.IsValidFlagType(req.FlagName) {
    return fiber.NewError(fiber.StatusBadRequest, "Invalid flag type")
}
*/