jellydator / validation Goto Github PK

if I set a type alias of basic type,like []string ,then, I neet to add two function,such as ( value and scan ,mysql json need this)， the bug is appened.
the entire code under:

package main

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"

	validation "github.com/go-ozzo/ozzo-validation"
)

type Tags []string

// mysql 8.0 json need value and scan function, so I need type alias
type Courses struct {
	Tag Tags `gorm:"type:json;comment:体系名是json格式" json:"tag"`
}

// !!!!!! IF YOU REMOVE THIS FUNCTION, IT IS VALIDETED !!!!!
// !!!!!! IF YOU ADD PONITER IN P, IT IS VALIDETED  !!!!
func (p Tags) Value() (driver.Value, error) {
	b, err := json.Marshal(p)
	return b, err
}


func (p *Tags) Scan(input any) error {
	return json.Unmarshal(input.([]byte), p)
}

func main() {

	var courseDto Courses
	courseDto.Tag = Tags{"student", "engineer"}
	err := validation.ValidateStruct(&courseDto,
		validation.Field(&courseDto.Tag, validation.Required, validation.Length(1, 3)),
	)
	fmt.Println(err)
}

Something strange is coming in function value !!!
If p without pointer can't pass validate!

func (p Tags) Value() (driver.Value, error) {
	//b, err := json.Marshal(p)
	return nil, nil
}

But, if add pointer, it pass!

I want validate value if it is greater than 0 and less than 1

validation.Field(&o.Foo, validation.Min(float64(0)).Exclusive(), validation.Max(float64(1)).Exclusive()),

Zero is not validated. How can I resolve this?

Over the past 8 months there have been a handful of meaningful additions and changes to this project. It would be nice if these updates were available as an official release. Please consider creating a new release, v1.1.0

Is there a builtin function to check if a string contains chars(ASCII LETTERS), integer and special character?

whats the different between is.Domain and is.DNSName?

This code panics

EnsureString(nil)

Currently the In and NotIn rules work just fine with strings but these two rules only work in a case sensitive way. This feature request is to add support for case insensitive In and NotIn rules.

examples:

• In (case sensitive)
  • ("A", "B"), "A" = valid
  • ("A", "B"), "a" = invalid
• NotIn (case insensitive)
  • ("A", "B"), "A" = invalid
  • ("A", "B"), "a" = invalid
  • ("A", "B"), "c" = valid

This is my mode and validation receiver:

type UserSignup struct {
	ID        int        `json:"id"`
	FirstName string     `json:"first_name"`
	LastName  *string    `json:"last_name"`
	Username  *string    `json:"username"`
	Email     *string    `json:"email"`
	Phone     *string    `json:"phone"`
	Password  string    `json:"password"`
	PasswordConfirmation string `json:"password_confirmation"`
	CreatedAt *time.Time `json:"created_at"`
}

func (u *UserSignup) Validate() error {
	return validation.ValidateStruct(
		u,
		validation.Field(
			&u.FirstName,
			validation.Required,
			validation.Length(3, 80),
		),
		validation.Field(&u.LastName, validation.Length(3, 80)),
		validation.Field(&u.Username, validation.Length(3, 20)),
		validation.Field(&u.Email, is.Email, validation.When(
			&u.Phone == nil,
			validation.Required,
		)),
		validation.Field(&u.Phone, is.E164, validation.When(
			&u.Email == nil,
			validation.Required,
		)),
		validation.Field(
			&u.Password,
			validation.Required,
			validation.Length(6, 0),
		),
		validation.Field(
			&u.PasswordConfirmation,
			validation.Length(6, 0),
			validation.Required,
			validation.When(
				u.Password != u.PasswordConfirmation,
				validation.Required.Error("must be equal to `password`"),
			),
		),
	)
}

This is the validation call:

if err := validation.Validate(userSignup); err != nil {
        return err
}

These are the call args and the error:

What is happening?

Validation is returning first_name -> the length must be between 3 and 80 only

What should happen?

Validation should return email or phone is required and also password_confirmations must be equal to password

type Abc struct {
    A int
    B struct {
        C int
    }
}

To validate the nested struct B, a simple ValidateStruct(*Abc, Field(*Abc.B.C)) is not enough (an error is returned).

Either Field() needs to be improved or a new FieldStruct() should be created.

While using the In and NotIn rules, I've noticed that their implementations are inconsistent. The former uses DeepEqual to verify equality, whereas the latter uses the equality operator. In cases where pointers are being passed with the same underlying data, the former would work, but the latter falls short.

Can we have a discussion on whether NotIn should incorporate DeepEqual?

Title.

I want to check field has not more than N decimal places

Sorry if this is a dumb question, but I've not found a way of doing this.

I have a struct like:

type Foo struct {
    A string
    B int
    C Bar
}

I would like to ensure that Foo (and any subsequent structs like Bar) do not have any empty fields. i.e. something like:

f := Foo {} // All fields are 0-valued

if err := validation.Validate(&f, validation.Required); err != nil {
		log.Fatal(err)
	}

However, from examples it seems the only way to do this is to implement the Validatable interface for all structs you want to check. The above code excerpt will not return an error because Foo does not implement the Validatable interface.

Is there any "default" way, like the one linked above, which will be able to iterate over each field and check if the fields are non-empty? Otherwise it seems if new fields are added, the validator method(s) needs to be updated.