Refactor TradingHours struct and validation

date_utils/date_utils.go

@@ -2,15 +2,15 @@ package date_utils
 
 import (
 	"fmt"
-	"github.com/jinzhu/now"
 	"reflect"
 	"strconv"
 	"strings"
 	"time"
 
+	"github.com/jinzhu/now"
+
 	"github.com/araddon/dateparse"
 	"gitlab.bob.co.za/bob-public-utils/bobgroup-go-utils/errors"
-	"gitlab.bob.co.za/bob-public-utils/bobgroup-go-utils/utils"
 )
 
 const TimeZoneString = "Africa/Johannesburg"
@@ -325,146 +325,155 @@ func formatTimestampsWithTimeZoneInSlice(fieldValue reflect.Value, location *tim
 	return nil
 }
 
-// TradingHours represents an array of (StartTime,EndTime) pairs, one for each day of the week.
-// The array is 0 indexed, with 0 being Sunday and 6 being Saturday and 7 being public holidays.
-type TradingHours []struct {
-	StartTime string `json:"start_time"`
-	EndTime   string `json:"end_time"`
+type TradingHours struct {
+	Monday    TradingHoursDay `json:"monday"`
+	Tuesday   TradingHoursDay `json:"tuesday"`
+	Wednesday TradingHoursDay `json:"wednesday"`
+	Thursday  TradingHoursDay `json:"thursday"`
+	Friday    TradingHoursDay `json:"friday"`
+	Saturday  TradingHoursDay `json:"saturday"`
+	Sunday    TradingHoursDay `json:"sunday"`
+	Holidays  TradingHoursDay `json:"holidays"`
 }
 
 func (t TradingHours) Validate() error {
-	if len(t) != 8 {
-		return errors.Error("Trading hours must have 8 days, 7 for every day of the week and 1 for public holidays")
+	if err := t.Monday.Validate(); err != nil {
+		return errors.Wrapf(err, "Monday failed validation: %v", err.Error())
+	}
+	if err := t.Tuesday.Validate(); err != nil {
+		return errors.Wrapf(err, "Tuesday failed validation: %v", err.Error())
+	}
+	if err := t.Wednesday.Validate(); err != nil {
+		return errors.Wrapf(err, "Wednesday failed validation: %v", err.Error())
+	}
+	if err := t.Thursday.Validate(); err != nil {
+		return errors.Wrapf(err, "Thursday failed validation: %v", err.Error())
+	}
+	if err := t.Friday.Validate(); err != nil {
+		return errors.Wrapf(err, "Friday failed validation: %v", err.Error())
+	}
+	if err := t.Saturday.Validate(); err != nil {
+		return errors.Wrapf(err, "Saturday failed validation: %v", err.Error())
+	}
+	if err := t.Sunday.Validate(); err != nil {
+		return errors.Wrapf(err, "Sunday failed validation: %v", err.Error())
+	}
+	if err := t.Holidays.Validate(); err != nil {
+		return errors.Wrapf(err, "Holidays failed validation: %v", err.Error())
 	}
 
-	for _, day := range t {
-		if day.StartTime == "" || day.EndTime == "" {
-			// Allow empty trading hours for a day to represent closed
-			continue
+	return nil
 }
 
-		if !TimeBefore(day.StartTime, day.EndTime) {
-			return errors.Error("Start time must be before end time")
+func (day TradingHoursDay) Validate() error {
+	if day.StartTime == "" || day.EndTime == "" {
+		// Allow empty trading hours for a day to represent closed
+		return nil
 	}
 
 	if len(day.StartTime) != 5 || len(day.EndTime) != 5 {
-			return errors.Error("Time must be in the format HH:MM")
+		return errors.Error("time must be in the format HH:MM")
 	}
-
 	startHourMinSlice := strings.Split(day.StartTime, ":")
 	if len(startHourMinSlice) != 2 {
-			return errors.Error("Time must be in the format HH:MM")
+		return errors.Error("time must be in the format HH:MM")
 	}
 	startHour, startMin := startHourMinSlice[0], startHourMinSlice[1]
 	startHourInt, err := strconv.Atoi(startHour)
 	if err != nil || startHourInt < 0 || startHourInt > 23 {
-			return errors.Error("Start hour must be between 0 and 23")
+		return errors.Error("start hour must be between 0 and 23")
 	}
 	startMinInt, err := strconv.Atoi(startMin)
 	if err != nil || !(startMinInt == 0 || startMinInt == 30) {
-			return errors.Error("Start minute must be 0 or 30")
+		return errors.Error("start minute must be 0 or 30")
 	}
 
 	endHourMinSlice := strings.Split(day.EndTime, ":")
 	if len(endHourMinSlice) != 2 {
-			return errors.Error("Time must be in the format HH:MM")
+		return errors.Error("time must be in the format HH:MM")
 	}
 	endHour, endMin := endHourMinSlice[0], endHourMinSlice[1]
 	endHourInt, err := strconv.Atoi(endHour)
 	if err != nil || endHourInt < 0 || endHourInt > 23 {
-			return errors.Error("End hour must be between 0 and 23")
+		return errors.Error("end hour must be between 0 and 23")
 	}
 	endMinInt, err := strconv.Atoi(endMin)
 	if err != nil || !(endMinInt == 0 || endMinInt == 30 || endMinInt == 59) {
-			return errors.Error("End minute must be 0, 30 or 59")
+		return errors.Error("end minute must be 0, 30 or 59")
 	}
+
+	if !TimeBefore(day.StartTime, day.EndTime) {
+		return errors.Error("start time must be before end time")
 	}
 
 	return nil
 }
 
 func (t TradingHours) String() string {
-	var result strings.Builder
-	const numberOfDaysInWeek = 7
-	copyOfT := utils.DeepCopy(t).(TradingHours)
-	weekdays, publicHolidays := copyOfT[:numberOfDaysInWeek], copyOfT[numberOfDaysInWeek]
-	weekdays = append(weekdays, weekdays[0]) // Add the first day (Sunday) to the end because we want Monday to be first in the string
-
-	rangeStartIndex := 1
-	for i := 1; i < len(weekdays); i++ {
-		currentDay := weekdays[i]
-		nextDay := currentDay
-		if i+1 < len(weekdays) {
-			nextDay = weekdays[i+1]
-		}
-
-		// Determine times
-		var times string
-		if currentDay.StartTime != "" && currentDay.EndTime != "" {
-			startTime, err := time.Parse("15:04", currentDay.StartTime)
-			if err != nil {
-				return ""
-			}
+	var (
+		result            strings.Builder
+		weekdays          = []TradingHoursDay{t.Monday, t.Tuesday, t.Wednesday, t.Thursday, t.Friday, t.Saturday, t.Sunday}
+		rangeStartWeekday = time.Monday
+	)
 
-			endTime, err := time.Parse("15:04", currentDay.EndTime)
-			if err != nil {
-				return ""
-			}
+	for i := range weekdays {
+		currentTradingHoursDay := weekdays[i]
 
-			times = startTime.Format("3:04pm") + " – " + endTime.Format("3:04pm")
-			if currentDay.StartTime == "00:00" && currentDay.EndTime == "23:59" {
-				times = "All day"
-			}
+		// Here the index is wrapped so we will never go out of bounds. The next day after Sunday is Monday at index 0 because (6+1)%7 = 0
+		nextTradingHoursDay := weekdays[(i+1)%len(weekdays)]
+
+		// Here we use the same value, as above, but for a different purpose of being compatible with the time package
+		// This is because the time package uses 0 for Sunday and 1 for Monday. This means when we get to index 6 (Sunday),
+		// to get the time.Weekday value for Sunday we need to use 0, and as before (6+1)%7 = 0
+		currentWeekday := time.Weekday((i + 1) % len(weekdays))
+		nextWeekday := time.Weekday((i + 2) % len(weekdays))
+
+		// Determine range description
+		var rangeDescription string
+		if currentWeekday == rangeStartWeekday {
+			rangeDescription = currentWeekday.String()[:3]
 		} else {
-			times = "Closed"
+			rangeDescription = fmt.Sprintf("%s – %s", rangeStartWeekday.String()[:3], currentWeekday.String()[:3])
 		}
 
-		// If we're at the last element or the next day doesn't have the same times, we end the current range
-		if i == len(weekdays)-1 || currentDay.StartTime != nextDay.StartTime || currentDay.EndTime != nextDay.EndTime {
-			if rangeStartIndex == i {
-				day := time.Weekday(rangeStartIndex).String()[:3]
-				if rangeStartIndex == numberOfDaysInWeek {
-					day = time.Sunday.String()[:3]
-				}
-				result.WriteString(fmt.Sprintf("%s: %s", day, times))
-			} else {
-				rangeStartDay := time.Weekday(rangeStartIndex).String()[:3]
-				rangeEndDay := time.Weekday(i).String()[:3]
-				if i == numberOfDaysInWeek {
-					rangeEndDay = time.Sunday.String()[:3]
+		// If the next day has the same times and we're not at the last element, we continue the current range
+		if nextTradingHoursDay.StartTime == currentTradingHoursDay.StartTime && nextTradingHoursDay.EndTime == currentTradingHoursDay.EndTime && i < len(weekdays)-1 {
+			continue
 		}
-				result.WriteString(fmt.Sprintf("%s – %s: %s", rangeStartDay, rangeEndDay, times))
+
+		result.WriteString(fmt.Sprintf("%s: %s, ", rangeDescription, currentTradingHoursDay.String()))
+		rangeStartWeekday = nextWeekday
 	}
 
-			if i < len(weekdays)-1 {
-				result.WriteString(", ")
+	// Public holidays
+	result.WriteString(fmt.Sprintf("Public holidays: %s", t.Holidays.String()))
+
+	return result.String()
 }
 
-			rangeStartIndex = i + 1
+type TradingHoursDay struct {
+	StartTime string `json:"start_time"`
+	EndTime   string `json:"end_time"`
 }
+
+func (day TradingHoursDay) String() string {
+	if day.StartTime == "" || day.EndTime == "" {
+		return "Closed"
 	}
 
-	// Public holidays
-	var times string
-	if publicHolidays.StartTime != "" && publicHolidays.EndTime != "" {
-		startTime, err := time.Parse("15:04", publicHolidays.StartTime)
+	startTime, err := time.Parse("15:04", day.StartTime)
 	if err != nil {
 		return ""
 	}
 
-		endTime, err := time.Parse("15:04", publicHolidays.EndTime)
+	endTime, err := time.Parse("15:04", day.EndTime)
 	if err != nil {
 		return ""
 	}
 
-		times = startTime.Format("3:04pm") + " – " + endTime.Format("3:04pm")
-		if publicHolidays.StartTime == "00:00" && publicHolidays.EndTime == "23:59" {
-			times = "All day"
+	if day.StartTime == "00:00" && day.EndTime == "23:59" {
+		return "All day"
 	}
-	} else {
-		times = "Closed"
-	}
-	result.WriteString(fmt.Sprintf(", Public holidays: %s", times))
 
-	return result.String()
+	return startTime.Format("3:04pm") + " – " + endTime.Format("3:04pm")
 }