validator_time.go

package valgo

import (
	"time"
)

func isTimeEqualTo(v0 time.Time, v1 time.Time) bool {
	return v0.Equal(v1)
}

func isTimeAfter(v0 time.Time, v1 time.Time) bool {
	return v0.After(v1)
}

func isTimeAfterOrEqualTo(v0 time.Time, v1 time.Time) bool {
	return v0.After(v1) || v0.Equal(v1)
}

func isTimeBefore(v0 time.Time, v1 time.Time) bool {
	return v0.Before(v1)
}

func isTimeBeforeOrEqualTo(v0 time.Time, v1 time.Time) bool {
	return v0.Before(v1) || v0.Equal(v1)
}

func isTimeZero(v time.Time) bool {
	return v.IsZero()
}

func isTimeBetween(v time.Time, min time.Time, max time.Time) bool {
	return (v.After(min) || v.Equal(min)) && (v.Before(max) || v.Equal(max))
}

func isTimeInSlice(v time.Time, slice []time.Time) bool {
	for _, _v := range slice {
		if v.Equal(_v) {
			return true
		}
	}
	return false
}

// The `ValidatorTime` structure provides a set of methods to perform validation
// checks on time.Time values, utilizing Go's native time package.
type ValidatorTime struct {
	context *ValidatorContext
}

// The Time function initiates a new `ValidatorTime` instance to validate a given
// time value. The optional name and title parameters can be used for enhanced
// error reporting. If a name is provided without a title, the name is humanized
// to be used as the title.
//
// For example:
//
//	startTime := time.Now()
//	v := ValidatorTime{}
//	v.Time(startTime, "start_time", "Start Time")
func Time(value time.Time, nameAndTitle ...string) *ValidatorTime {
	return &ValidatorTime{context: NewContext(value, nameAndTitle...)}
}

// The Context method returns the current context of the validator, which can
// be utilized to create custom validations by extending this validator.
func (validator *ValidatorTime) Context() *ValidatorContext {
	return validator.context
}

// The Not method inverts the boolean value associated with the next validator
// method. This can be used to negate the check performed by the next validation
// method in the chain.
//
// For example:
//
//	// Will return false because Not() inverts the boolean value of the Zero() function
//	startTime := time.Now()
//	Is(v.Time(startTime).Not().Zero()).Valid()
func (validator *ValidatorTime) Not() *ValidatorTime {
	validator.context.Not()
	return validator
}

// Or introduces a logical OR boundary in the current validator chain.
//
// Or groups adjacent validation fragments into a single OR-group that is
// evaluated left-to-right until one fragment succeeds. The OR-group succeeds
// if any fragment succeeds; it fails only if all fragments fail.
//
// Precedence: the OR-group is evaluated as a unit before the implicit AND
// that continues the chain. For example:
//
//	A.Or().B.C   == (A OR B) AND C
//
// Error reporting: if the OR-group fails, the error message for that group is
// a single message composed by joining the failing fragments' messages using
// the localized OR list format.
//
// Example:
//
//	// Passes because time is Zero (Zero() OR BeforeOrEqualTo(time.Now())).
//	t := time.Time{}
//	isValid := v.Is(v.Time(t).Zero().Or().BeforeOrEqualTo(time.Now())).Valid()
func (validator *ValidatorTime) Or() *ValidatorTime {
	validator.context.Or()
	return validator
}

// OrElse introduces a logical OR boundary with a cut (short-circuit) in the
// validator chain.
//
// OrElse behaves like Or for building an OR-group, but with an additional rule:
// if the left side (a single fragment, or the entire OR-group accumulated to
// the left of OrElse) succeeds, validation stops and no fragments to the right
// of OrElse are evaluated.
//
// This is primarily used to express "accept X, otherwise validate the rest"
// without repeating X across multiple OR fragments.
//
// Precedence: OrElse still participates in OR-grouping precedence. For example:
//
//	A.OrElse().B.C  == A OR (B AND C)   (with a cut if A succeeds)
//
// Error reporting: if the OR-group fails, its message is composed the same way
// as Or (localized OR list join).
//
// Example:
//
//	// If time is Zero, the chain succeeds and After/Before are not evaluated.
//	// Otherwise, time must be After(t1) AND Before(t2).
//	t := time.Time{}
//	t1 := time.Now().Add(-time.Hour)
//	t2 := time.Now().Add(time.Hour)
//	isValid := v.Is(v.Time(t).Zero().OrElse().After(t1).Before(t2)).Valid()
func (validator *ValidatorTime) OrElse() *ValidatorTime {
	validator.context.OrElse()
	return validator
}

// The EqualTo method validates if the time value is equal to another given time
// value. It uses the equality (`==`) operator from Go for the comparison.
//
// For example:
//
//	timeA := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	timeB := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	Is(v.Time(timeA).EqualTo(timeB)).Valid()
func (validator *ValidatorTime) EqualTo(value time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeEqualTo(validator.context.Value().(time.Time), value)
		},
		ErrorKeyEqualTo, value, template...)

	return validator
}

// The After method checks if the time value is after a specified time.
//
// For example:
//
//	startTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	endTime := time.Date(2023, 1, 1, 1, 0, 0, 0, time.UTC)
//	Is(v.Time(endTime).After(startTime)).Valid()
func (validator *ValidatorTime) After(value time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeAfter(validator.context.Value().(time.Time), value)
		},
		ErrorKeyAfter, value, template...)

	return validator
}

// The AfterOrEqualTo method checks if the time value is either after or equal to
// a specified time.
//
// For example:
//
//	timeA := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	timeB := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	Is(v.Time(timeA).AfterOrEqualTo(timeB)).Valid()
func (validator *ValidatorTime) AfterOrEqualTo(value time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeAfterOrEqualTo(validator.context.Value().(time.Time), value)
		},
		ErrorKeyAfterOrEqualTo, value, template...)

	return validator
}

// The Before method checks if the time value is before a specified time.
//
// For example:
//
//	startTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	endTime := time.Date(2023, 1, 1, 1, 0, 0, 0, time.UTC)
//	Is(v.Time(startTime).Before(endTime)).Valid()
func (validator *ValidatorTime) Before(value time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeBefore(validator.context.Value().(time.Time), value)
		},
		ErrorKeyBefore, value, template...)

	return validator
}

// The BeforeOrEqualTo method checks if the time value is either before or equal to
// a specified time.
//
// For example:
//
//	timeA := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	timeB := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	Is(v.Time(timeA).BeforeOrEqualTo(timeB)).Valid()
func (validator *ValidatorTime) BeforeOrEqualTo(value time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeBeforeOrEqualTo(validator.context.Value().(time.Time), value)
		},
		ErrorKeyBeforeOrEqualTo, value, template...)

	return validator
}

// The Between method verifies if the time value falls within a given time range, inclusive.
//
// For example:
//
//	minTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	maxTime := time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC)
//	checkTime := time.Date(2023, 1, 1, 6, 0, 0, 0, time.UTC)
//	Is(v.Time(checkTime).Between(minTime, maxTime)).Valid()
func (validator *ValidatorTime) Between(min time.Time, max time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithParams(
		func() bool {
			return isTimeBetween(validator.context.Value().(time.Time), min, max)
		},
		ErrorKeyBetween,
		map[string]any{"title": validator.context.title, "min": min, "max": max},
		template...)

	return validator
}

// The Zero method verifies if the time value is a zero time, which means it hasn't
// been initialized yet.
//
// For example:
//
//	zeroTime := time.Time{}
//	Is(v.Time(zeroTime).Zero()).Valid()
func (validator *ValidatorTime) Zero(template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeZero(validator.context.Value().(time.Time))
		},
		ErrorKeyZero, validator.context.Value(), template...)

	return validator
}

// The Passing method allows for custom validation logic by accepting a function
// that returns a boolean indicating whether the validation passed or failed.
//
// For example:
//
//	checkTime := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	Is(v.Time(checkTime).Passing(func(t time.Time) bool {
//	    return t.Year() == 2023
//	})).Valid()
func (validator *ValidatorTime) Passing(function func(v0 time.Time) bool, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return function(validator.context.Value().(time.Time))
		},
		ErrorKeyPassing, validator.context.Value(), template...)

	return validator
}

// The InSlice method validates if the time value is found within a provided slice
// of time values.
//
// For example:
//
//	timeA := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
//	timeB := time.Date(2023, 1, 1, 1, 0, 0, 0, time.UTC)
//	timeSlice := []time.Time{timeA, timeB}
//	checkTime := time.Date(2023, 1, 1, 1, 0, 0, 0, time.UTC)
//	Is(v.Time(checkTime).InSlice(timeSlice)).Valid()
func (validator *ValidatorTime) InSlice(slice []time.Time, template ...string) *ValidatorTime {
	validator.context.AddWithValue(
		func() bool {
			return isTimeInSlice(validator.context.Value().(time.Time), slice)
		},
		ErrorKeyInSlice, validator.context.Value(), template...)

	return validator
}