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"
	FlagPullet     FlagType = "PULLET"
	FlagLayer      FlagType = "LAYER"
	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"

	// flag ayam
	FlagAyamAfkir   FlagType = "AYAM-AFKIR"
	FlagAyamCulling FlagType = "AYAM-CULLING"
	FlagAyamMati    FlagType = "AYAM-MATI"

	//flag telur
	FlagTelur      FlagType = "TELUR"
	FlagTelurUtuh  FlagType = "TELUR-UTUH"
	FlagTelurPecah FlagType = "TELUR-PECAH"
	FlagTelurPutih FlagType = "TELUR-PUTIH"
	FlagTelurRetak FlagType = "TELUR-RETAK"
)

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

var flagGroupOptions = map[FlagGroup][]FlagType{
	FlagGroupProduct: {
		FlagDOC,
		FlagPullet,
		FlagLayer,
		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"
)

// -------------------------------------------------------------------
// Stock log
// -------------------------------------------------------------------

type StockLogTransactionType string

const (
	StockLogTransactionTypeIncrease StockLogTransactionType = "INCREASE"
	StockLogTransactionTypeDecrease StockLogTransactionType = "DECREASE"
)

type StockLogType string

const (
	StockLogTypeAdjustment StockLogType = "ADJUSTMENT"
	StockLogTypeTransfer   StockLogType = "TRANSFER"
)

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

type CustomerSupplierType string

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

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

type SupplierCategory string

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

// -------------------------------------------------------------------
// ExpenseCategory
// -------------------------------------------------------------------

type ExpenseCategory string

const (
	ExpenseCategoryBOP    ExpenseCategory = "BOP"
	ExpenseCategoryNonBOP ExpenseCategory = "NON-BOP"
)

// -------------------------------------------------------------------
// Payment Method
// -------------------------------------------------------------------

type PaymentMethod string

const (
	PaymentMethodTransfer PaymentMethod = "TRANSFER"
	PaymentMethodCash     PaymentMethod = "CASH"
	PaymentMethodCard     PaymentMethod = "CARD"
	PaymentMethodCheque   PaymentMethod = "CHEQUE"
	PaymentMethodSaldo    PaymentMethod = "SALDO"
)

// -------------------------------------------------------------------
// Trasaction Type
// -------------------------------------------------------------------

type TransactionType string

const (
	TransactionTypePenjualan TransactionType = "PENJUALAN"
	TransactionTypePembelian TransactionType = "PEMBELIAN"
	TransactionTypeBiaya     TransactionType = "BIAYA"
	TransactionTypeInjection TransactionType = "INJECTION"
	TransactionTypeSaldoAwal TransactionType = "SALDO_AWAL"
)

// -------------------------------------------------------------------
// Payment Party
// -------------------------------------------------------------------

type PaymentParty string

const (
	PaymentPartyCustomer PaymentParty = "CUSTOMER"
	PaymentPartySupplier PaymentParty = "SUPPLIER"
)

// -------------------------------------------------------------------
// 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
	ProjectFlockStepSelesai      approvalutils.ApprovalStep        = 3
)

// projectFlockApprovalSteps keeps the workflow step definitions for project flock approvals.
var ProjectFlockApprovalSteps = map[approvalutils.ApprovalStep]string{
	ProjectFlockStepPengajuan: "Pengajuan",
	ProjectFlockStepAktif:     "Aktif",
	ProjectFlockStepSelesai:   "Selesai",
}

// -------------------------------------------------------------------
// Chickin Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowChickin approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("CHICKINS")
	ChickinStepPengajuan    approvalutils.ApprovalStep        = 1
	ChickinStepDisetujui    approvalutils.ApprovalStep        = 2
)

var ChickinApprovalSteps = map[approvalutils.ApprovalStep]string{
	ChickinStepPengajuan: "Pengajuan",
	ChickinStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// Project-Flock kandang Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowProjectFlockKandang approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PROJECT_FLOCK_KANDANGS")
	ProjectFlockKandangStepPengajuan    approvalutils.ApprovalStep        = 1
	ProjectFlockKandangStepDisetujui    approvalutils.ApprovalStep        = 2
	ProjectFlockKandangStepClosed       approvalutils.ApprovalStep        = 3
)

var ProjectFlockKandangApprovalSteps = map[approvalutils.ApprovalStep]string{
	ProjectFlockKandangStepPengajuan: "Pengajuan",
	ProjectFlockKandangStepDisetujui: "Disetujui",
	ProjectFlockKandangStepClosed:    "Selesai",
}

// -------------------------------------------------------------------
// Transfer To laying Approval
// -------------------------------------------------------------------
const (
	ApprovalWorkflowTransferToLaying approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("TRANSFER_TO_LAYINGS")
	TransferToLayingStepPengajuan    approvalutils.ApprovalStep        = 1
	TransferToLayingStepDisetujui    approvalutils.ApprovalStep        = 2
)

var TransferToLayingApprovalSteps = map[approvalutils.ApprovalStep]string{
	TransferToLayingStepPengajuan: "Pengajuan",
	TransferToLayingStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------
// Recording Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowRecording approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("RECORDINGS")
	RecordingStepPengajuan    approvalutils.ApprovalStep        = 1
	RecordingStepDisetujui    approvalutils.ApprovalStep        = 2
)

var RecordingApprovalSteps = map[approvalutils.ApprovalStep]string{
	RecordingStepPengajuan: "Pengajuan",
	RecordingStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// Purchase Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowPurchase  approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PURCHASES")
	PurchaseStepPengajuan     approvalutils.ApprovalStep        = 1
	PurchaseStepStaffPurchase approvalutils.ApprovalStep        = 2
	PurchaseStepManager       approvalutils.ApprovalStep        = 3
	PurchaseStepReceiving     approvalutils.ApprovalStep        = 4
	PurchaseStepCompleted     approvalutils.ApprovalStep        = 5

	PurchasePRNumberPrefix = "PR-LTI-"
	PurchasePONumberPrefix = "PO-LTI-"
	PurchaseNumberPadding  = 4
)

var PurchaseApprovalSteps = map[approvalutils.ApprovalStep]string{
	PurchaseStepPengajuan:     "Pengajuan",
	PurchaseStepStaffPurchase: "Staff Purchase",
	PurchaseStepManager:       "Manager Purchase",
	PurchaseStepReceiving:     "Penerimaan Produk",
	PurchaseStepCompleted:     "Selesai",
}

// -------------------------------------------------------------------
// Marketings Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowMarketing approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("MARKETINGS")
	MarketingStepPengajuan    approvalutils.ApprovalStep        = 1
	MarketingStepSalesOrder   approvalutils.ApprovalStep        = 2
	MarketingDeliveryOrder    approvalutils.ApprovalStep        = 3

	MarketingSoNumberPrefix = "SO-"
	MarketingNumberPadding  = 5
)

var MarketingApprovalSteps = map[approvalutils.ApprovalStep]string{
	MarketingStepPengajuan:  "Pengajuan",
	MarketingStepSalesOrder: "Sales Order",
	MarketingDeliveryOrder:  "Delivery Order",
}

// -------------------------------------------------------------------
// Expense Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowExpense approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("EXPENSES")
	ExpenseStepPengajuan    approvalutils.ApprovalStep        = 1
	ExpenseStepManager      approvalutils.ApprovalStep        = 2
	ExpenseStepFinance      approvalutils.ApprovalStep        = 3
	ExpenseStepRealisasi    approvalutils.ApprovalStep        = 4
	ExpenseStepSelesai      approvalutils.ApprovalStep        = 5
)

var ExpenseApprovalSteps = map[approvalutils.ApprovalStep]string{
	ExpenseStepPengajuan: "Pengajuan",
	ExpenseStepManager:   "Approval Manager",
	ExpenseStepFinance:   "Approval Finance",
	ExpenseStepRealisasi: "Realisasi",
	ExpenseStepSelesai:   "Selesai",
}

// -------------------------------------------------------------------
// Payment Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowPayment approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("PAYMENTS")
	PaymentStepPengajuan    approvalutils.ApprovalStep        = 1
	PaymentStepDisetujui    approvalutils.ApprovalStep        = 2
)

var PaymentApprovalSteps = map[approvalutils.ApprovalStep]string{
	PaymentStepPengajuan: "Pengajuan",
	PaymentStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// Inisial Balance Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowInitial approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("INITIAL_BALANCES")
	InitialStepPengajuan    approvalutils.ApprovalStep        = 1
	InitialStepDisetujui    approvalutils.ApprovalStep        = 2
)

var InitialApprovalSteps = map[approvalutils.ApprovalStep]string{
	InitialStepPengajuan: "Pengajuan",
	InitialStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// Injection Approval
// -------------------------------------------------------------------

const (
	ApprovalWorkflowInjection approvalutils.ApprovalWorkflowKey = approvalutils.ApprovalWorkflowKey("INJECTIONS")
	InjectionStepPengajuan    approvalutils.ApprovalStep        = 1
	InjectionStepDisetujui    approvalutils.ApprovalStep        = 2
)

var InjectionApprovalSteps = map[approvalutils.ApprovalStep]string{
	InjectionStepPengajuan: "Pengajuan",
	InjectionStepDisetujui: "Disetujui",
}

// -------------------------------------------------------------------
// 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
}

func IsValidExpenseCategory(v string) bool {
	switch ExpenseCategory(v) {
	case ExpenseCategoryBOP, ExpenseCategoryNonBOP:
		return true
	}
	return false
}

func IsValidPaymentMethod(v string) bool {
	switch PaymentMethod(v) {
	case PaymentMethodTransfer, PaymentMethodCash, PaymentMethodCard, PaymentMethodCheque, PaymentMethodSaldo:
		return true
	}
	return false
}

func IsValidTransactionType(v string) bool {
	switch TransactionType(v) {
	case TransactionTypePenjualan, TransactionTypePembelian, TransactionTypeBiaya, TransactionTypeInjection, TransactionTypeSaldoAwal:
		return true
	}
	return false
}

func IsValidPaymentParty(v string) bool {
	switch PaymentParty(v) {
	case PaymentPartyCustomer, PaymentPartySupplier:
		return true
	}
	return false
}

// example use

// Recording helper

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