it/comparison.go - Code Metrics - Inspection of "Merge pull request #60 from muonsoft/is-numeric" - muonsoft/validation - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( aa8c07...4607a7 )

by Igor
created 2021-10-31 06:59 UTC
it/comparison.go F

↳ Parent: Project
Size/Duplication

Total Lines	788
Duplicated Lines	0 %
Test Coverage

Coverage
97.33%
Importance

Changes
Metric	Value
cc	118
eloc	412
dl	0
loc	788
ccs	146
cts	150
cp	0.9733
crap	118.265
rs	2
c	0
b	0
f	0
66 Methods

Rating	Name	Size	Complexity
A	it.IsGreaterThanInteger	9	2
A	it.RangeConstraint.ValidateNumber	9	4
A	it.TimeRangeConstraint.newViolation	10	1
A	it.TimeComparisonConstraint.Code	3	1
A	it.IsNegativeOrZero	9	3
A	it.IsLessThanInteger	9	2
A	it.IsLessThanFloat	9	2
A	it.IsLessThanOrEqualInteger	9	3
A	it.RangeConstraint.Message	4	1
A	it.IsGreaterThanOrEqualFloat	9	3
A	it.IsEarlierThan	8	2
A	it.IsPositiveOrZero	9	3
A	it.IsEqualToFloat	9	2
A	it.StringComparisonConstraint.SetUp	2	1
A	it.IsEarlierThanOrEqual	8	3
A	it.IsLaterThan	8	2
A	it.UniqueConstraint.SetUp	2	1
A	it.IsNotEqualToString	7	2
A	it.IsGreaterThanFloat	9	2
A	it.TimeRangeConstraint.ValidateTime	9	5
A	it.NumberComparisonConstraint.Name	2	1
A	it.NumberComparisonConstraint.Message	7	1
A	it.StringComparisonConstraint.Message	7	1
A	it.StringComparisonConstraint.When	3	1
A	it.IsEqualToInteger	9	2
A	it.IsNotEqualToFloat	9	2
A	it.TimeRangeConstraint.SetUp	6	3
A	it.StringComparisonConstraint.ValidateString	13	4
A	it.IsNotEqualToInteger	9	2
A	it.TimeComparisonConstraint.When	3	1
A	it.RangeConstraint.Name	2	1
A	it.IsBetweenFloats	6	1
A	it.UniqueConstraint.Code	3	1
A	it.RangeConstraint.When	3	1
A	it.UniqueConstraint.Name	2	1
A	it.RangeConstraint.newViolation	10	1
A	it.TimeComparisonConstraint.Name	2	1
A	it.IsBetweenIntegers	6	1
A	it.NumberComparisonConstraint.Code	3	1
A	it.UniqueConstraint.When	3	1
A	it.IsGreaterThanOrEqualInteger	9	3
A	it.TimeRangeConstraint.Layout	3	1
A	it.IsLessThanOrEqualFloat	9	3
A	it.IsPositive	9	2
A	it.NumberComparisonConstraint.SetUp	2	1
A	it.TimeComparisonConstraint.Message	7	1
A	it.RangeConstraint.Code	3	1
A	it.IsEqualToString	7	2
A	it.NumberComparisonConstraint.ValidateNumber	13	4
A	it.TimeRangeConstraint.Message	4	1
A	it.IsLaterThanOrEqual	8	3
A	it.StringComparisonConstraint.Name	2	1
A	it.TimeRangeConstraint.When	3	1
A	it.TimeComparisonConstraint.ValidateTime	13	4
A	it.TimeRangeConstraint.Name	2	1
A	it.TimeComparisonConstraint.Layout	3	1
A	it.RangeConstraint.SetUp	6	3
A	it.IsBetweenTime	7	1
A	it.StringComparisonConstraint.Code	3	1
A	it.UniqueConstraint.ValidateStrings	8	3
A	it.NumberComparisonConstraint.When	3	1
A	it.TimeComparisonConstraint.SetUp	2	1
A	it.IsNegative	9	2
A	it.HasUniqueValues	4	1
A	it.TimeRangeConstraint.Code	3	1
A	it.UniqueConstraint.Message	4	1
package it

import (
	"strconv"
	"time"

	"github.com/muonsoft/validation"
	"github.com/muonsoft/validation/code"
	"github.com/muonsoft/validation/generic"
	"github.com/muonsoft/validation/is"
	"github.com/muonsoft/validation/message"
)

// NumberComparisonConstraint is used for various numeric comparisons between integer and float values.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
type NumberComparisonConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
	comparedValue     string
	isValid           func(value generic.Number) bool
}

// IsEqualToInteger checks that the number (integer or float) is equal to the specified integer value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsEqualToInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.Equal,
		messageTemplate: message.Equal,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsEqualTo(v)
		},
	}
}

// IsEqualToFloat checks that the number (integer or float) is equal to the specified float value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsEqualToFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.Equal,
		messageTemplate: message.Equal,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsEqualTo(v)
		},
	}
}

// IsNotEqualToInteger checks that the number (integer or float) is not equal to the specified integer value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsNotEqualToInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.NotEqual,
		messageTemplate: message.NotEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return !n.IsEqualTo(v)
		},
	}
}

// IsNotEqualToFloat checks that the number (integer or float) is not equal to the specified float value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsNotEqualToFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.NotEqual,
		messageTemplate: message.NotEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return !n.IsEqualTo(v)
		},
	}
}

// IsLessThanInteger checks that the number (integer or float) is less than the specified integer value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsLessThanInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.TooHigh,
		messageTemplate: message.TooHigh,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v)
		},
	}
}

// IsLessThanFloat checks that the number (integer or float) is less than the specified float value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsLessThanFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.TooHigh,
		messageTemplate: message.TooHigh,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v)
		},
	}
}

// IsLessThanOrEqualInteger checks that the number (integer or float) is less than or
// equal to the specified integer value. Values are compared as integers if the compared
// and specified values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsLessThanOrEqualInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.TooHighOrEqual,
		messageTemplate: message.TooHighOrEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v) || n.IsEqualTo(v)
		},
	}
}

// IsLessThanOrEqualFloat checks that the number (integer or float) is less than or
// equal to the specified float value. Values are compared as integers if the compared
// and specified values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsLessThanOrEqualFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.TooHighOrEqual,
		messageTemplate: message.TooHighOrEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v) || n.IsEqualTo(v)
		},
	}
}

// IsGreaterThanInteger checks that the number (integer or float) is greater than the specified integer value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsGreaterThanInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.TooLow,
		messageTemplate: message.TooLow,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v)
		},
	}
}

// IsGreaterThanFloat checks that the number (integer or float) is greater than the specified float value.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
func IsGreaterThanFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.TooLow,
		messageTemplate: message.TooLow,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v)
		},
	}
}

// IsGreaterThanOrEqualInteger checks that the number (integer or float) is greater than or
// equal to the specified integer value. Values are compared as integers if the compared
// and specified values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsGreaterThanOrEqualInteger(value int64) NumberComparisonConstraint {
	v := generic.NewNumberFromInt(value)

	return NumberComparisonConstraint{
		code:            code.TooLowOrEqual,
		messageTemplate: message.TooLowOrEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v) || n.IsEqualTo(v)
		},
	}
}

// IsGreaterThanOrEqualFloat checks that the number (integer or float) is greater than or
// equal to the specified float value. Values are compared as integers if the compared
// and specified values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsGreaterThanOrEqualFloat(value float64) NumberComparisonConstraint {
	v := generic.NewNumberFromFloat(value)

	return NumberComparisonConstraint{
		code:            code.TooLowOrEqual,
		messageTemplate: message.TooLowOrEqual,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v) || n.IsEqualTo(v)
		},
	}
}

// IsPositive checks that the value is a positive number (integer or float). Zero is neither
// positive nor negative. If you want to allow zero use IsPositiveOrZero comparison.
func IsPositive() NumberComparisonConstraint {
	v := generic.NewNumberFromInt(0)

	return NumberComparisonConstraint{
		code:            code.NotPositive,
		messageTemplate: message.NotPositive,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v)
		},
	}
}

// IsPositiveOrZero checks that the value is a positive number (integer or float) or equal to zero.
// If you don't want to allow zero as a valid value, use IsPositive comparison.
func IsPositiveOrZero() NumberComparisonConstraint {
	v := generic.NewNumberFromInt(0)

	return NumberComparisonConstraint{
		code:            code.NotPositiveOrZero,
		messageTemplate: message.NotPositiveOrZero,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsGreaterThan(v) || n.IsEqualTo(v)
		},
	}
}

// IsNegative checks that the value is a negative number (integer or float). Zero is neither
// positive nor negative. If you want to allow zero use IsNegativeOrZero comparison.
func IsNegative() NumberComparisonConstraint {
	v := generic.NewNumberFromInt(0)

	return NumberComparisonConstraint{
		code:            code.NotNegative,
		messageTemplate: message.NotNegative,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v)
		},
	}
}

// IsNegativeOrZero checks that the value is a negative number (integer or float) or equal to zero.
// If you don't want to allow zero as a valid value, use IsNegative comparison.
func IsNegativeOrZero() NumberComparisonConstraint {
	v := generic.NewNumberFromInt(0)

	return NumberComparisonConstraint{
		code:            code.NotNegativeOrZero,
		messageTemplate: message.NotNegativeOrZero,
		comparedValue:   v.String(),
		isValid: func(n generic.Number) bool {
			return n.IsLessThan(v) || n.IsEqualTo(v)
		},
	}
}

// SetUp always returns no error.
func (c NumberComparisonConstraint) SetUp() error {
	return nil
}

// Name is the constraint name.
func (c NumberComparisonConstraint) Name() string {
	return "NumberComparisonConstraint"
}

// Code overrides default code for produced violation.
func (c NumberComparisonConstraint) Code(code string) NumberComparisonConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//  {{ comparedValue }} - the expected value;
//  {{ value }} - the current (invalid) value.
func (c NumberComparisonConstraint) Message(
	template string,
	parameters ...validation.TemplateParameter,
) NumberComparisonConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c NumberComparisonConstraint) When(condition bool) NumberComparisonConstraint {
	c.isIgnored = !condition
	return c
}

func (c NumberComparisonConstraint) ValidateNumber(value generic.Number, scope validation.Scope) error {
	if c.isIgnored || value.IsNil() || c.isValid(value) {
		return nil
	}

	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ comparedValue }}", Value: c.comparedValue},
				validation.TemplateParameter{Key: "{{ value }}", Value: value.String()},
			)...,
		).
		CreateViolation()
}

// RangeConstraint is used to check that a given number value is between some minimum and maximum.
// Values are compared as integers if the compared and specified values are integers.
// Otherwise, numbers are always compared as floating point numbers.
type RangeConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
	min               generic.Number
	max               generic.Number
}

// IsBetweenIntegers checks that the number (integer or float) is between specified minimum and
// maximum integer values. Values are compared as integers if the compared and specified
// values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsBetweenIntegers(min, max int64) RangeConstraint {
	return RangeConstraint{
		min:             generic.NewNumberFromInt(min),
		max:             generic.NewNumberFromInt(max),
		code:            code.NotInRange,
		messageTemplate: message.NotInRange,
	}
}

// IsBetweenFloats checks that the number (integer or float) is between specified minimum and
// maximum float values. Values are compared as integers if the compared and specified
// values are integers. Otherwise, numbers are always compared as floating point numbers.
func IsBetweenFloats(min, max float64) RangeConstraint {
	return RangeConstraint{
		min:             generic.NewNumberFromFloat(min),
		max:             generic.NewNumberFromFloat(max),
		code:            code.NotInRange,
		messageTemplate: message.NotInRange,
	}
}

// SetUp returns an error if min is greater than or equal to max.
func (c RangeConstraint) SetUp() error {
	if c.min.IsGreaterThan(c.max) || c.min.IsEqualTo(c.max) {
		return errInvalidRange
	}

	return nil
}

// Name is the constraint name.
func (c RangeConstraint) Name() string {
	return "RangeConstraint"
}

// Code overrides default code for produced violation.
func (c RangeConstraint) Code(code string) RangeConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//  {{ max }} - the upper limit;
//  {{ min }} - the lower limit;
//  {{ value }} - the current (invalid) value.
func (c RangeConstraint) Message(template string, parameters ...validation.TemplateParameter) RangeConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c RangeConstraint) When(condition bool) RangeConstraint {
	c.isIgnored = !condition
	return c
}

func (c RangeConstraint) ValidateNumber(value generic.Number, scope validation.Scope) error {
	if c.isIgnored {
		return nil
	}
	if value.IsLessThan(c.min) || value.IsGreaterThan(c.max) {
		return c.newViolation(value, scope)
	}

	return nil
}

func (c RangeConstraint) newViolation(value generic.Number, scope validation.Scope) error {
	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ min }}", Value: c.min.String()},
				validation.TemplateParameter{Key: "{{ max }}", Value: c.max.String()},
				validation.TemplateParameter{Key: "{{ value }}", Value: value.String()},
			)...,
		).
		CreateViolation()
}

// StringComparisonConstraint is used to compare strings.
type StringComparisonConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
	comparedValue     string
	isValid           func(value string) bool
}

// IsEqualToString checks that the string value is equal to the specified string value.
func IsEqualToString(value string) StringComparisonConstraint {
	return StringComparisonConstraint{
		code:            code.Equal,
		messageTemplate: message.Equal,
		comparedValue:   value,
		isValid: func(actualValue string) bool {
			return value == actualValue
		},
	}
}

// IsNotEqualToString checks that the string value is not equal to the specified string value.
func IsNotEqualToString(value string) StringComparisonConstraint {
	return StringComparisonConstraint{
		code:            code.NotEqual,
		messageTemplate: message.NotEqual,
		comparedValue:   value,
		isValid: func(actualValue string) bool {
			return value != actualValue
		},
	}
}

// SetUp always returns no error.
func (c StringComparisonConstraint) SetUp() error {
	return nil
}

// Name is the constraint name.
func (c StringComparisonConstraint) Name() string {
	return "StringComparisonConstraint"
}

// Code overrides default code for produced violation.
func (c StringComparisonConstraint) Code(code string) StringComparisonConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//  {{ comparedValue }} - the expected value;
//  {{ value }} - the current (invalid) value.
//
// All string values are quoted strings.
func (c StringComparisonConstraint) Message(
	template string,
	parameters ...validation.TemplateParameter,
) StringComparisonConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c StringComparisonConstraint) When(condition bool) StringComparisonConstraint {
	c.isIgnored = !condition
	return c
}

func (c StringComparisonConstraint) ValidateString(value *string, scope validation.Scope) error {
	if c.isIgnored || value == nil || c.isValid(*value) {
		return nil
	}

	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ comparedValue }}", Value: strconv.Quote(c.comparedValue)},
				validation.TemplateParameter{Key: "{{ value }}", Value: strconv.Quote(*value)},
			)...,
		).
		CreateViolation()
}

// TimeComparisonConstraint is used to compare time values.
type TimeComparisonConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
	comparedValue     time.Time
	layout            string
	isValid           func(value time.Time) bool
}

// IsEarlierThan checks that the given time is earlier than the specified value.
func IsEarlierThan(value time.Time) TimeComparisonConstraint {
	return TimeComparisonConstraint{
		code:            code.TooLate,
		messageTemplate: message.TooLate,
		comparedValue:   value,
		layout:          time.RFC3339,
		isValid: func(actualValue time.Time) bool {
			return actualValue.Before(value)
		},
	}
}

// IsEarlierThanOrEqual checks that the given time is earlier or equal to the specified value.
func IsEarlierThanOrEqual(value time.Time) TimeComparisonConstraint {
	return TimeComparisonConstraint{
		code:            code.TooLateOrEqual,
		messageTemplate: message.TooLateOrEqual,
		comparedValue:   value,
		layout:          time.RFC3339,
		isValid: func(actualValue time.Time) bool {
			return actualValue.Before(value) || actualValue.Equal(value)
		},
	}
}

// IsLaterThan checks that the given time is later than the specified value.
func IsLaterThan(value time.Time) TimeComparisonConstraint {
	return TimeComparisonConstraint{
		code:            code.TooEarly,
		messageTemplate: message.TooEarly,
		comparedValue:   value,
		layout:          time.RFC3339,
		isValid: func(actualValue time.Time) bool {
			return actualValue.After(value)
		},
	}
}

// IsLaterThanOrEqual checks that the given time is later or equal to the specified value.
func IsLaterThanOrEqual(value time.Time) TimeComparisonConstraint {
	return TimeComparisonConstraint{
		code:            code.TooEarlyOrEqual,
		messageTemplate: message.TooEarlyOrEqual,
		comparedValue:   value,
		layout:          time.RFC3339,
		isValid: func(actualValue time.Time) bool {
			return actualValue.After(value) || actualValue.Equal(value)
		},
	}
}

// SetUp always returns no error.
func (c TimeComparisonConstraint) SetUp() error {
	return nil
}

// Name is the constraint name.
func (c TimeComparisonConstraint) Name() string {
	return "TimeComparisonConstraint"
}

// Code overrides default code for produced violation.
func (c TimeComparisonConstraint) Code(code string) TimeComparisonConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//  {{ comparedValue }} - the expected value;
//  {{ value }} - the current (invalid) value.
//
// All values are formatted by the layout that can be defined by the Layout method.
// Default layout is time.RFC3339.
func (c TimeComparisonConstraint) Message(
	template string,
	parameters ...validation.TemplateParameter,
) TimeComparisonConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// Layout can be used to set the layout that is used to format time values.
func (c TimeComparisonConstraint) Layout(layout string) TimeComparisonConstraint {
	c.layout = layout
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c TimeComparisonConstraint) When(condition bool) TimeComparisonConstraint {
	c.isIgnored = !condition
	return c
}

func (c TimeComparisonConstraint) ValidateTime(value *time.Time, scope validation.Scope) error {
	if c.isIgnored || value == nil || c.isValid(*value) {
		return nil
	}

	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ comparedValue }}", Value: c.comparedValue.Format(c.layout)},
				validation.TemplateParameter{Key: "{{ value }}", Value: value.Format(c.layout)},
			)...,
		).
		CreateViolation()
}

// TimeRangeConstraint is used to check that a given time value is between some minimum and maximum.
type TimeRangeConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
	layout            string
	min               time.Time
	max               time.Time
}

// IsBetweenTime checks that the time is between specified minimum and maximum time values.
func IsBetweenTime(min, max time.Time) TimeRangeConstraint {
	return TimeRangeConstraint{
		code:            code.NotInRange,
		messageTemplate: message.NotInRange,
		layout:          time.RFC3339,
		min:             min,
		max:             max,
	}
}

// SetUp returns an error if min is greater than or equal to max.
func (c TimeRangeConstraint) SetUp() error {
	if c.min.After(c.max) || c.min.Equal(c.max) {
		return errInvalidRange
	}

	return nil
}

// Name is the constraint name.
func (c TimeRangeConstraint) Name() string {
	return "TimeRangeConstraint"
}

// Code overrides default code for produced violation.
func (c TimeRangeConstraint) Code(code string) TimeRangeConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message. Also, you can use default parameters:
//
//  {{ max }} - the upper limit;
//  {{ min }} - the lower limit;
//  {{ value }} - the current (invalid) value.
//
// All values are formatted by the layout that can be defined by the Layout method.
// Default layout is time.RFC3339.
func (c TimeRangeConstraint) Message(template string, parameters ...validation.TemplateParameter) TimeRangeConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c TimeRangeConstraint) When(condition bool) TimeRangeConstraint {
	c.isIgnored = !condition
	return c
}

// Layout can be used to set the layout that is used to format time values.
func (c TimeRangeConstraint) Layout(layout string) TimeRangeConstraint {
	c.layout = layout
	return c
}

func (c TimeRangeConstraint) ValidateTime(value *time.Time, scope validation.Scope) error {
	if c.isIgnored || value == nil {
		return nil
	}
	if value.Before(c.min) || value.After(c.max) {
		return c.newViolation(value, scope)
	}

	return nil
}

func (c TimeRangeConstraint) newViolation(value *time.Time, scope validation.Scope) validation.Violation {
	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(
			c.messageParameters.Prepend(
				validation.TemplateParameter{Key: "{{ min }}", Value: c.min.Format(c.layout)},
				validation.TemplateParameter{Key: "{{ max }}", Value: c.max.Format(c.layout)},
				validation.TemplateParameter{Key: "{{ value }}", Value: value.Format(c.layout)},
			)...,
		).
		CreateViolation()
}

// UniqueConstraint is used to check that all elements of the given collection are unique.
type UniqueConstraint struct {
	isIgnored         bool
	code              string
	messageTemplate   string
	messageParameters validation.TemplateParameterList
}

// HasUniqueValues checks that all elements of the given collection are unique
// (none of them is present more than once).
func HasUniqueValues() UniqueConstraint {
	return UniqueConstraint{
		code:            code.NotUnique,
		messageTemplate: message.NotUnique,
	}
}

// SetUp always returns no error.
func (c UniqueConstraint) SetUp() error {
	return nil
}

// Name is the constraint name.
func (c UniqueConstraint) Name() string {
	return "UniqueConstraint"
}

// Code overrides default code for produced violation.
func (c UniqueConstraint) Code(code string) UniqueConstraint {
	c.code = code
	return c
}

// Message sets the violation message template. You can set custom template parameters
// for injecting its values into the final message.
func (c UniqueConstraint) Message(template string, parameters ...validation.TemplateParameter) UniqueConstraint {
	c.messageTemplate = template
	c.messageParameters = parameters
	return c
}

// When enables conditional validation of this constraint. If the expression evaluates to false,
// then the constraint will be ignored.
func (c UniqueConstraint) When(condition bool) UniqueConstraint {
	c.isIgnored = !condition
	return c
}

func (c UniqueConstraint) ValidateStrings(values []string, scope validation.Scope) error {
	if c.isIgnored || is.UniqueStrings(values) {
		return nil
	}

	return scope.BuildViolation(c.code, c.messageTemplate).
		SetParameters(c.messageParameters...).
		CreateViolation()
}

muonsoft / validation

Push — main ( aa8c07...4607a7 )

it/comparison.go F

Size/Duplication

Test Coverage

Importance

66 Methods

Duplication Side-by-Side

Filter issues like
