Feat(BE-36,37,38,39): finish master data management api

internal/utils/constant.go

@@ -1,14 +1,68 @@
 package utils
 
+import "strings"
+
 // -------------------------------------------------------------------
-// FlagType
+// 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
 // -------------------------------------------------------------------
@@ -32,16 +86,101 @@ const (
 	CustomerSupplierTypeIndividual CustomerSupplierType = "INDIVIDUAL"
 )
 
+// -------------------------------------------------------------------
+// SupplierCategory
+// -------------------------------------------------------------------
+
+type SupplierCategory string
+
+const (
+	SupplierCategoryBOP      SupplierCategory = "BOP"
+	SupplierCategorySapronak SupplierCategory = "SAPRONAK"
+)
+
 // -------------------------------------------------------------------
 // Validators
 // -------------------------------------------------------------------
 
 func IsValidFlagType(v string) bool {
-	switch FlagType(v) {
-	case FlagIsActive:
-		return true
+	_, ok := allFlagTypes[FlagType(strings.ToUpper(strings.TrimSpace(v)))]
+	return ok
+}
+
+func AllowedFlagTypes(group FlagGroup) []FlagType {
+	options, ok := flagGroupOptions[group]
+	if !ok {
+		return nil
 	}
-	return false
+	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 {
@@ -60,10 +199,18 @@ func IsValidCustomerSupplierType(v string) bool {
 	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")
+    return fiber.NewError(fiber.StatusBadRequest, "Invalid flag type")
 }
 */

internal/utils/slice.go

@@ -0,0 +1,34 @@
+package utils
+
+// UniqueUintSlice returns a new slice containing distinct values in the order of first appearance.
+func UniqueUintSlice(values []uint) []uint {
+	if len(values) == 0 {
+		return nil
+	}
+
+	seen := make(map[uint]struct{}, len(values))
+	result := make([]uint, 0, len(values))
+	for _, v := range values {
+		if _, ok := seen[v]; ok {
+			continue
+		}
+		seen[v] = struct{}{}
+		result = append(result, v)
+	}
+	return result
+}
+
+// MissingUintIDs returns the values present in expected but missing from actual.
+func MissingUintIDs(expected, actual []uint) []uint {
+	lookup := make(map[uint]struct{}, len(actual))
+	for _, v := range actual {
+		lookup[v] = struct{}{}
+	}
+	missing := make([]uint, 0)
+	for _, v := range expected {
+		if _, ok := lookup[v]; !ok {
+			missing = append(missing, v)
+		}
+	}
+	return missing
+}