~repos /gromer

package gromer

import (
  "fmt"
  "reflect"
  "strings"
  "time"

  "github.com/go-playground/validator/v10"
  "github.com/imdario/mergo"
  "github.com/segmentio/go-camelcase"
)

var Validator = validator.New()
var ValidatorErrorMap = map[string]string{
  "required": "is required",
}

type timeTransformer struct {
}

func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
  if typ == reflect.TypeOf(time.Time{}) {
    return func(dst, src reflect.Value) error {
      if dst.CanSet() {
        srcResult := src.MethodByName("IsZero").Call([]reflect.Value{})
        if !srcResult[0].Bool() {
          dst.Set(src)
        }
      }
      return nil
    }
  }
  return nil
}

func Merge(dst interface{}, src interface{}) error {
  err := mergo.Merge(dst, src, mergo.WithOverride, mergo.WithTransformers(timeTransformer{}))
  if err != nil {
    return err
  }
  return Validate(dst)
}

func Validate(dst interface{}) error {
  return Validator.Struct(dst)
}

func RegisterValidation(k, msg string, validate func(fl validator.FieldLevel) bool) {
  ValidatorErrorMap[k] = msg
  Validator.RegisterValidation(k, validate)
}

func GetValidationError(err validator.ValidationErrors) map[string]string {
  emap := map[string]string{}
  for _, e := range err {
    parts := strings.Split(e.StructNamespace(), ".")
    lowerParts := []string{}
    for _, p := range parts[1:] {
      lowerParts = append(lowerParts, camelcase.Camelcase(p))
    }
    k := strings.Join(lowerParts, ".")
    errorMsg, ok := ValidatorErrorMap[e.Tag()]
    if ok {
      emap[k] = errorMsg
    } else {
      emap[k] = "is not valid" // e.Error()
    }
  }
  return emap
}

func Zero[T any](s ...T) T {
  var zero T
  return zero
}

func Default[S any](a, b S) S {
  va := fmt.Sprintf("%v", a)
  if va == "" || va == "0" {
    return b
  }
  return a
}