Golang: Validate inner Struct field based on the values of one of its enclosing struct's field using required_if tag

user_934005 0
Viewed 357

golang version: 1.18.3

validator: github.com/go-playground/validator/v10

I want to validate an incoming JSON payload after loaded into nested struct data structure. Here's my incoming JSON payload,

 {
        "irn": 1,
        "firstName": "Testing",
        "lastName": "Test",
        "cardType": "RECIPROCAL",
        "number": "2248974514",
        "cardExpiry": {
            "month": "01",
            "year": "2025"
        }
}

here's my medicare.go file

 package main

import (
    "encoding/json"

    "github.com/go-playground/validator/v10"
)

type Medicare struct {
    IRN           uint8
    FirstName     string
    MiddleInitial string
    LastName      string
    CardType      string `validate:"required,eq=RESIDENT|eq=RECIPROCAL|eq=INTERIM"`
    Number        string
    CardExpiry    *CardExpiry `validate:"required"`
}

type CardExpiry struct {
    Day   string
    Month string `validate:"required"`
    Year  string `validate:"required"`
}

Here's my test function

    func TestUserPayload(t *testing.T) {
    var m Medicare

    err := json.Unmarshal([]byte(jsonData), &m)
    if err != nil {
        panic(err)
    }

    validate := validator.New()
    err = validate.Struct(m)
    if err != nil {
        t.Errorf("error %v", err)
    }
}

I want to do the following validation using validator/v10's required_if tag. Here's the validation logic,

if (m.CardType == "RECIPROCAL" || m.CardType == "INTERIM") &&
    m.CardExpiry.Day == "" {
    //validation error
}

required_if can be used based on the field values which are in the same struct (in this case CardExpiry)

Day   string `validate:"required_if=Month 01"`

My question is,

can it be done based on the values of one of its enclosing struct's field (in this case Medicare struct)? for ex:

Day   string `validate:"required_if=Medicare.CardType RECIPROCAL"`

if can, how?

Here's the go playground code

go validation struct json
2 Answers

you could write custom validation, playground-solution, documentation for custom validation is available here https://pkg.go.dev/github.com/go-playground/validator#CustomTypeFunc.

user_39565890

Slightly old question, but valix (https://github.com/marrow16/valix) can do such things 'out-of-the-box' using conditions. Example...

package main

import (
    "fmt"
    "net/http"
    "strings"

    "github.com/marrow16/valix"
)

type Medicare struct {
    IRN           uint8  `json:"irn"`
    FirstName     string `json:"firstName"`
    MiddleInitial string `json:"middleInitial"`
    LastName      string `json:"lastName"`
    // set order on this property so that it is evaluated before 'CardExpiry' object is checked...
    // (and set a condition based on its value)
    CardType   string      `json:"cardType" v8n:"order:-1,required,&StringValidToken{['RESIDENT','RECIPROCAL','INTERIM']},&SetConditionFrom{Global:true}"`
    Number     string      `json:"number"`
    CardExpiry *CardExpiry `json:"cardExpiry" v8n:"required,notNull"`
}

type CardExpiry struct {
    // this property is required when a condition of `RECIPROCAL` has been set (and unwanted when that condition has not been set)...
    Day   string `json:"day" v8n:"required:RECIPROCAL,unwanted:!RECIPROCAL"`
    Month string `json:"month" v8n:"required"`
    Year  string `json:"year" v8n:"required"`
}


var medicareValidator = valix.MustCompileValidatorFor(Medicare{}, nil)

func main() {
    jsonData := `{
        "irn": 1,
        "firstName": "Testing",
        "lastName": "Test",
        "cardType": "RECIPROCAL",
        "number": "2248974514",
        "cardExpiry": {
            "month": "01",
            "year": "2025"
        }
    }`

    medicare := &Medicare{}
    ok, violations, _ := medicareValidator.ValidateStringInto(jsonData, medicare)
    // should fail with 1 violation...
    fmt.Printf("First ok?: %v\n", ok)
    for i, v := range violations {
        fmt.Printf("Violation[%d]: Message:%s, Property:%s, Path:%s\n", i+1, v.Message, v.Property, v.Path)
    }

    jsonData = `{
            "irn": 1,
            "firstName": "Testing",
            "lastName": "Test",
            "cardType": "RECIPROCAL",
            "number": "2248974514",
            "cardExpiry": {
                "day": "01",
                "month": "01",
                "year": "2025"
            }
        }`
    ok, _, _ = medicareValidator.ValidateStringInto(jsonData, medicare)
    // should be ok...
    fmt.Printf("Second ok?: %v\n", ok)

    jsonData = `{
            "irn": 1,
            "firstName": "Testing",
            "lastName": "Test",
            "cardType": "INTERIM",
            "number": "2248974514",
            "cardExpiry": {
                "month": "01",
                "year": "2025"
            }
        }`
    ok, _, _ = medicareValidator.ValidateStringInto(jsonData, medicare)
    // should be ok...
    fmt.Printf("Third ok?: %v\n", ok)

    jsonData = `{
            "irn": 1,
            "firstName": "Testing",
            "lastName": "Test",
            "cardType": "INTERIM",
            "number": "2248974514",
            "cardExpiry": {
                "day": "01",
                "month": "01",
                "year": "2025"
            }
        }`
    ok, violations, _ = medicareValidator.ValidateStringInto(jsonData, medicare)
    fmt.Printf("Fourth ok?: %v\n", ok)
    for i, v := range violations {
        fmt.Printf("Violation[%d]: Message:%s, Property:%s, Path:%s\n", i+1, v.Message, v.Property, v.Path)
    }

    // or validate directly from a http request...
    req, _ := http.NewRequest("POST", "", strings.NewReader(jsonData))
    ok, violations, _ = medicareValidator.RequestValidateInto(req, medicare)
    fmt.Printf("Fourth (as http.Request) ok?: %v\n", ok)
    for i, v := range violations {
        fmt.Printf("Violation[%d]: Message:%s, Property:%s, Path:%s\n", i+1, v.Message, v.Property, v.Path)
    }
}

On go-playground

Disclosure: I am the author of Valix

user_18917430
Related