update go.mod and imports

internal/validators/custom.go

@@ -0,0 +1,110 @@
+package validators
+
+import "github.com/go-playground/validator/v10"
+
+// accountCUTypeValidator is used to validate CUType field.
+func accountCUTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, accountCUTypeValues)
+}
+
+// accountAccessTypeValidator is used to validate AccessType field.
+func accountAccessTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, accountAccessTypeValues)
+}
+
+// bserviceDriverValidator is used to validate Driver field.
+func bserviceDriverValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, bserviceDriverValues)
+}
+
+// bserviceModeValidator is used to validate Mode field.
+func bserviceModeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, bserviceModeValues)
+}
+
+// computeTopologyValidator is used to validate Topology field.
+func computeTopologyValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computeTopologyValues)
+}
+
+// computePolicyValidator is used to validate Policy field.
+func computePolicyValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computePolicyValues)
+}
+
+// computeModeValidator is used to validate Mode field.
+func computeModeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computeModeValues)
+}
+
+// computeDiskTypeValidator is used to validate DiskType field.
+func computeDiskTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computeDiskTypeValues)
+}
+
+// computeNetTypeValidator is used to validate NetType field.
+func computeNetTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computeNetTypeValues)
+}
+
+// computeProtoValidator is used to validate Proto field.
+func computeProtoValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, computeProtoValues)
+}
+
+// imageBootTypeValidator is used to validate BootType field.
+func imageBootTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, imageBootTypeValues)
+}
+
+// imageTypeValidator is used to validate ImageType field.
+func imageTypeValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, imageTypeValues)
+}
+
+// imageDriversValidator is used to validate Drivers field.
+func imageDriversValidator(fe validator.FieldLevel) bool {
+	fieldSlice, ok := fe.Field().Interface().([]string)
+	if !ok {
+		return false
+	}
+
+	for _, item := range fieldSlice {
+		if !StringInSlice(item, imageDriversValues) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// imageArchitectureValidator is used to validate Architecture field.
+func imageArchitectureValidator(fe validator.FieldLevel) bool {
+	fieldValue := fe.Field().String()
+
+	return StringInSlice(fieldValue, imageArchitectureValues)
+}

internal/validators/helper.go

@@ -1,5 +1,25 @@
 package validators
 
+import (
+	"errors"
+
+	"github.com/go-playground/validator/v10"
+)
+
+func ValidateRequest(req interface{}) error {
+	validate := getDecortValidator()
+	return validate.Struct(req)
+}
+
+func ValidationError(fe validator.FieldError) error {
+	return errors.New(errorMessage(fe))
+}
+
+//nolint:errorlint
+func GetErrors(err error) validator.ValidationErrors {
+	return err.(validator.ValidationErrors)
+}
+
 func StringInSlice(str string, target []string) bool {
 	for _, v := range target {
 		if v == str {

internal/validators/messages.go

@@ -0,0 +1,124 @@
+package validators
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-playground/validator/v10"
+)
+
+func errorMessage(fe validator.FieldError) string {
+	prefix := "validation-error:"
+
+	switch fe.Tag() {
+
+	// Default Validators
+	case "required":
+		return fmt.Sprintf("%s %s is required", prefix, fe.Field())
+	case "gt":
+		return fmt.Sprintf("%s %s can't be less or equal to zero", prefix, fe.Field())
+	case "min":
+		return fmt.Sprintf("%s %s: not enough elements", prefix, fe.Field())
+	case "max":
+		return fmt.Sprintf("%s %s: too many elements", prefix, fe.Field())
+	case "url":
+		return fmt.Sprintf("%s %s: unexpected URL format", prefix, fe.Field())
+	case "email":
+		return fmt.Sprintf("%s %s: unexpected E-Mail format", prefix, fe.Field())
+
+	// Account Validators
+	case "accountAccessType":
+		return fmt.Sprintf("%s %s must be one of the followng: %s",
+			prefix,
+			fe.Field(),
+			joinValues(accountAccessTypeValues))
+
+	case "accountCUType":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(accountCUTypeValues))
+
+	// BService Validators
+	case "bserviceDriver":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(bserviceDriverValues))
+
+	case "bserviceMode":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(bserviceModeValues))
+
+	// Compute Validators
+	case "computeTopology":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computeTopologyValues))
+
+	case "computePolicy":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computePolicyValues))
+
+	case "computeMode":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computeModeValues))
+
+	case "computeDiskType":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computeDiskTypeValues))
+
+	case "computeNetType":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computeNetTypeValues))
+
+	case "computeProto":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(computeProtoValues))
+
+	// Image Validators
+	case "bootType":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(imageBootTypeValues))
+
+	case "imageType":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(imageTypeValues))
+
+	case "imageDrivers":
+		return fmt.Sprintf("%s %s must contain only the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(imageDriversValues))
+
+	case "imageArchitecture":
+		return fmt.Sprintf("%s %s must be one of the following: %s",
+			prefix,
+			fe.Field(),
+			joinValues(imageArchitectureValues))
+
+	}
+
+	return fe.Error()
+}
+
+func joinValues(values []string) string {
+	return strings.Join(values, ", ")
+}

internal/validators/validator.go

@@ -0,0 +1,108 @@
+package validators
+
+import (
+	"sync"
+
+	"github.com/go-playground/validator/v10"
+)
+
+var (
+	once     sync.Once
+	instance *DecortValidator
+)
+
+type DecortValidator struct {
+	decortValidator *validator.Validate
+}
+
+// getDecortValidator returns singleton instance of DecortValidator.
+func getDecortValidator() *validator.Validate {
+	if instance == nil {
+		once.Do(func() {
+			instance = new(DecortValidator)
+			instance.decortValidator = validator.New()
+
+			err := registerAllValidators(instance.decortValidator)
+			if err != nil {
+				panic(err)
+			}
+		})
+	}
+
+	return instance.decortValidator
+}
+
+// registerAllValidators registers all custom validators in DecortValidator.
+func registerAllValidators(validate *validator.Validate) error {
+	err := validate.RegisterValidation("bootType", imageBootTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("imageType", imageTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("imageDrivers", imageDriversValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("imageArchitecture", imageArchitectureValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("accountAccessType", accountAccessTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("accountCUType", accountCUTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("bserviceDriver", bserviceDriverValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("bserviceMode", bserviceModeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computeTopology", computeTopologyValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computePolicy", computePolicyValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computeMode", computeModeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computeDiskType", computeDiskTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computeNetType", computeNetTypeValidator)
+	if err != nil {
+		return err
+	}
+
+	err = validate.RegisterValidation("computeProto", computeProtoValidator)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/validators/values.go

@@ -0,0 +1,21 @@
+package validators
+
+var (
+	accountAccessTypeValues = []string{"R", "RCX", "ARCXDU"}
+	accountCUTypeValues     = []string{"CU_M", "CU_C", "CU_D", "CU_S", "CU_A", "CU_NO", "CU_I", "CU_NP"}
+
+	bserviceDriverValues = []string{"KVM_X86, KVM_PPC"}
+	bserviceModeValues   = []string{"ABSOLUTE", "RELATIVE"}
+
+	computeTopologyValues = []string{"compute", "node"}
+	computePolicyValues   = []string{"RECOMMENDED", "REQUIRED"}
+	computeModeValues     = []string{"EQ", "EN", "ANY"}
+	computeDiskTypeValues = []string{"D", "B"}
+	computeNetTypeValues  = []string{"EXTNET", "VINS"}
+	computeProtoValues    = []string{"tcp", "udp"}
+
+	imageBootTypeValues     = []string{"uefi", "bios"}
+	imageTypeValues         = []string{"windows", "linux", "other"}
+	imageDriversValues      = []string{"KVM_X86"}
+	imageArchitectureValues = []string{"X86_64", "PPC64_LE"}
+)