popertots
e27db9202e
Extract computeAvailableHours as shared core between GetAvailableHours and GetPreviewAvailableHours, eliminating ~320 lines of duplication. Add GetConflictingBookingsForExceptionHandler (POST) for holiday hours conflict detection with batch service loading, int-based time comparison, and ActiveBookingStatuses constant. Add RESERVATION:placeholder cleanup (24h TTL). Fix scan error propagation in all scheduling row iterations. Add rows.Err() checks.
593 lines
18 KiB
Go
593 lines
18 KiB
Go
package scheduling
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"log"
|
|
"log/slog"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"crussell/db"
|
|
"crussell/internal/validators"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
type ExceptionalHours struct {
|
|
ID int `json:"id"`
|
|
GroupID int `json:"groupId"`
|
|
Weekday int `json:"weekday" validate:"gte=0,lte=6"`
|
|
StartTime string `json:"startTime" validate:"required"`
|
|
EndTime string `json:"endTime" validate:"required"`
|
|
IsOpen bool `json:"isOpen"`
|
|
}
|
|
|
|
type ExceptionalGroup struct {
|
|
ID int `json:"id"`
|
|
Name string `json:"name" validate:"required"`
|
|
Description string `json:"description" validate:"required"`
|
|
Hours []ExceptionalHours `json:"hours,omitempty" validate:"required,min=7,max=7,dive"`
|
|
WeekStarts []string `json:"weekStarts,omitempty" validate:"required,min=1,max=52,dive,required"`
|
|
}
|
|
|
|
// --- List Groups with Hours and Applications ---
|
|
func ListExceptionalGroups(w http.ResponseWriter, r *http.Request) {
|
|
rows, err := db.Conn.Query(r.Context(), `
|
|
SELECT id, name, description
|
|
FROM exceptional_working_hours_groups
|
|
ORDER BY id DESC
|
|
`)
|
|
if err != nil {
|
|
http.Error(w, "failed to fetch groups", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
|
|
// Collect all groups first, then close rows to avoid "conn busy" when
|
|
// the context carries a test transaction (single connection).
|
|
var groups []ExceptionalGroup
|
|
for rows.Next() {
|
|
var g ExceptionalGroup
|
|
if err := rows.Scan(&g.ID, &g.Name, &g.Description); err != nil {
|
|
rows.Close()
|
|
http.Error(w, "failed to scan group", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
groups = append(groups, g)
|
|
}
|
|
rows.Close() // explicit close before subsequent queries (hours/apps below); defer covers error path
|
|
|
|
if err := rows.Err(); err != nil {
|
|
http.Error(w, "error iterating groups", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Load hours and applications for each group (separate queries after rows are closed)
|
|
for i := range groups {
|
|
// Load 7-day hours
|
|
hoursRows, err := db.Conn.Query(r.Context(), `
|
|
SELECT id, weekday, start_time::text, end_time, is_open
|
|
FROM exceptional_working_hours
|
|
WHERE group_id=$1 ORDER BY weekday
|
|
`, groups[i].ID)
|
|
if err != nil {
|
|
http.Error(w, "failed to fetch group hours", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
for hoursRows.Next() {
|
|
var h ExceptionalHours
|
|
if err := hoursRows.Scan(&h.ID, &h.Weekday, &h.StartTime, &h.EndTime, &h.IsOpen); err != nil {
|
|
hoursRows.Close()
|
|
http.Error(w, "failed to scan hours", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
h.GroupID = groups[i].ID
|
|
groups[i].Hours = append(groups[i].Hours, h)
|
|
}
|
|
hoursRows.Close()
|
|
|
|
if err := hoursRows.Err(); err != nil {
|
|
http.Error(w, "error iterating hours", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Load applied week starts
|
|
weekRows, err := db.Conn.Query(r.Context(), `
|
|
SELECT week_start
|
|
FROM exceptional_group_applications
|
|
WHERE group_id=$1 ORDER BY week_start
|
|
`, groups[i].ID)
|
|
if err != nil {
|
|
http.Error(w, "failed to fetch applications", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
for weekRows.Next() {
|
|
var weekStart time.Time
|
|
if err := weekRows.Scan(&weekStart); err != nil {
|
|
weekRows.Close()
|
|
http.Error(w, "failed to scan week_start", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
groups[i].WeekStarts = append(groups[i].WeekStarts, weekStart.Format("2006-01-02"))
|
|
}
|
|
weekRows.Close()
|
|
|
|
if err := weekRows.Err(); err != nil {
|
|
http.Error(w, "error iterating applications", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
if err := json.NewEncoder(w).Encode(groups); err != nil {
|
|
log.Printf("Failed to encode JSON response: %v", err)
|
|
}
|
|
}
|
|
|
|
// --- Create Group with Hours and Applications (bulk) ---
|
|
func CreateExceptionalGroup(w http.ResponseWriter, r *http.Request) {
|
|
var g ExceptionalGroup
|
|
if err := json.NewDecoder(r.Body).Decode(&g); err != nil {
|
|
http.Error(w, "invalid payload", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validators.Validate.Struct(&g); err != nil {
|
|
log.Printf("Failed to process request: %v", err)
|
|
http.Error(w, "Invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// M8
|
|
// L5
|
|
|
|
if len(g.Hours) != 7 {
|
|
http.Error(w, "must provide exactly 7 weekday entries (0-6)", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Validate weekdays and parse week_starts
|
|
weekdaysSeen := make(map[int]bool)
|
|
for _, h := range g.Hours {
|
|
if h.Weekday < 0 || h.Weekday > 6 {
|
|
http.Error(w, "weekday must be 0-6", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if weekdaysSeen[h.Weekday] {
|
|
http.Error(w, "duplicate weekday entries", http.StatusBadRequest)
|
|
return
|
|
}
|
|
weekdaysSeen[h.Weekday] = true
|
|
if !isValidTime15Min(h.StartTime) {
|
|
http.Error(w, "start_time must be in 15-minute intervals (00, 15, 30, 45)", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if !isValidTime15Min(h.EndTime) {
|
|
http.Error(w, "end_time must be in 15-minute intervals (00, 15, 30, 45)", http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
var parsedWeeks []time.Time
|
|
for _, ws := range g.WeekStarts {
|
|
weekStart, err := time.Parse("2006-01-02", ws)
|
|
if err != nil {
|
|
http.Error(w, "invalid week_start format, expected YYYY-MM-DD", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if weekStart.Weekday() != time.Monday {
|
|
http.Error(w, "week_start must be a Monday", http.StatusBadRequest)
|
|
return
|
|
}
|
|
parsedWeeks = append(parsedWeeks, weekStart)
|
|
}
|
|
|
|
tx, err := db.Conn.Begin(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "failed to start transaction", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer func() {
|
|
if err := tx.Rollback(r.Context()); err != nil && !errors.Is(err, pgx.ErrTxClosed) {
|
|
slog.Error("failed to rollback transaction", "err", err)
|
|
}
|
|
}()
|
|
|
|
// Create group
|
|
err = tx.QueryRow(r.Context(), `
|
|
INSERT INTO exceptional_working_hours_groups (name, description)
|
|
VALUES ($1, $2) RETURNING id
|
|
`, g.Name, g.Description).Scan(&g.ID)
|
|
if err != nil {
|
|
http.Error(w, "failed to create group", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Insert hours and collect their IDs
|
|
inputHours := g.Hours
|
|
g.Hours = []ExceptionalHours{} // Clear and rebuild with IDs
|
|
for _, h := range inputHours {
|
|
var id int
|
|
err := tx.QueryRow(r.Context(), `
|
|
INSERT INTO exceptional_working_hours (group_id, weekday, start_time, end_time, is_open)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
RETURNING id
|
|
`, g.ID, h.Weekday, h.StartTime, h.EndTime, h.IsOpen).Scan(&id)
|
|
if err != nil {
|
|
http.Error(w, "failed to insert hours", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
h.ID = id
|
|
h.GroupID = g.ID
|
|
g.Hours = append(g.Hours, h)
|
|
}
|
|
|
|
// Insert applications
|
|
if _, err := tx.Exec(r.Context(), `
|
|
INSERT INTO exceptional_group_applications (group_id, week_start)
|
|
SELECT $1, unnest($2::date[])
|
|
`, g.ID, parsedWeeks); err != nil {
|
|
http.Error(w, "failed to insert applications", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if err := tx.Commit(r.Context()); err != nil {
|
|
http.Error(w, "failed to commit transaction", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusCreated)
|
|
if err := json.NewEncoder(w).Encode(g); err != nil {
|
|
log.Printf("Failed to encode JSON response: %v", err)
|
|
}
|
|
}
|
|
|
|
// --- Delete Group (cascades to hours and applications) ---
|
|
func DeleteExceptionalGroup(w http.ResponseWriter, r *http.Request) {
|
|
// Extract group ID from URL path or query params
|
|
// Assuming you have a router that provides this, e.g. chi, mux, etc.
|
|
// For this example, we'll use query param: DELETE /exceptional-groups?id=123
|
|
idStr := r.URL.Query().Get("id")
|
|
if idStr == "" {
|
|
http.Error(w, "missing id parameter", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
id, err := strconv.Atoi(idStr)
|
|
if err != nil {
|
|
http.Error(w, "invalid id parameter", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
tx, err := db.Conn.Begin(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer func() {
|
|
if err := tx.Rollback(r.Context()); err != nil && !errors.Is(err, pgx.ErrTxClosed) {
|
|
slog.Error("failed to rollback transaction", "err", err)
|
|
}
|
|
}()
|
|
|
|
result, err := tx.Exec(r.Context(), `
|
|
DELETE FROM exceptional_working_hours_groups WHERE id=$1
|
|
`, id)
|
|
if err != nil {
|
|
http.Error(w, "failed to delete group", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
rowsAffected := result.RowsAffected()
|
|
if rowsAffected == 0 {
|
|
http.Error(w, "group not found", http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
if err := tx.Commit(r.Context()); err != nil {
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
// --- Update Applied Weeks (replaces all applications for a group) ---
|
|
func UpdateExceptionalApplications(w http.ResponseWriter, r *http.Request) {
|
|
var req struct {
|
|
GroupID int `json:"groupId" validate:"required"`
|
|
WeekStarts []string `json:"weekStarts" validate:"required,min=1,max=52,dive,required"`
|
|
}
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid payload", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validators.Validate.Struct(&req); err != nil {
|
|
log.Printf("Failed to process request: %v", err)
|
|
http.Error(w, "Invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// M8
|
|
// L5
|
|
|
|
// Validate and parse weeks
|
|
var parsedWeeks []time.Time
|
|
for _, ws := range req.WeekStarts {
|
|
weekStart, err := time.Parse("2006-01-02", ws)
|
|
if err != nil {
|
|
http.Error(w, "invalid week_start format, expected YYYY-MM-DD", http.StatusBadRequest)
|
|
return
|
|
}
|
|
if weekStart.Weekday() != time.Monday {
|
|
http.Error(w, "week_start must be a Monday", http.StatusBadRequest)
|
|
return
|
|
}
|
|
parsedWeeks = append(parsedWeeks, weekStart)
|
|
}
|
|
|
|
tx, err := db.Conn.Begin(r.Context())
|
|
if err != nil {
|
|
http.Error(w, "failed to start transaction", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
defer func() {
|
|
if err := tx.Rollback(r.Context()); err != nil && !errors.Is(err, pgx.ErrTxClosed) {
|
|
slog.Error("failed to rollback transaction", "err", err)
|
|
}
|
|
}()
|
|
|
|
// Delete existing applications for this group
|
|
_, err = tx.Exec(r.Context(), `
|
|
DELETE FROM exceptional_group_applications WHERE group_id=$1
|
|
`, req.GroupID)
|
|
if err != nil {
|
|
http.Error(w, "failed to delete existing applications", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Insert new applications
|
|
if _, err := tx.Exec(r.Context(), `
|
|
INSERT INTO exceptional_group_applications (group_id, week_start)
|
|
SELECT $1, unnest($2::date[])
|
|
`, req.GroupID, parsedWeeks); err != nil {
|
|
http.Error(w, "failed to insert applications", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if err := tx.Commit(r.Context()); err != nil {
|
|
http.Error(w, "failed to commit transaction", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
// Response types mirroring bookings.OverlappingBooking, bookings.OverlappingBookingsResponse, and bookings.UserSummary
|
|
// (defined locally to avoid circular import: bookings → scheduling → bookings)
|
|
type (
|
|
UserSummary struct {
|
|
ID string `json:"id"`
|
|
FullName string `json:"full_name"`
|
|
Email *string `json:"email,omitempty"`
|
|
Phone *string `json:"phone,omitempty"`
|
|
PreviousFirstName *string `json:"previous_first_name,omitempty"`
|
|
PreviousLastName *string `json:"previous_last_name,omitempty"`
|
|
}
|
|
|
|
OverlappingBooking struct {
|
|
ID string `json:"id"`
|
|
StartTime time.Time `json:"start_time"`
|
|
Duration int `json:"duration_minutes"`
|
|
Status string `json:"status"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
User *UserSummary `json:"user,omitempty"`
|
|
Services []string `json:"services,omitempty"`
|
|
}
|
|
|
|
OverlappingBookingsResponse struct {
|
|
Bookings []OverlappingBooking `json:"bookings"`
|
|
}
|
|
|
|
ConflictingBookingsRequest struct {
|
|
WeekStarts []string `json:"weekStarts" validate:"required,max=52,dive,required"`
|
|
ProposedHours []ExceptionalHours `json:"proposedHours" validate:"required,len=7,dive"`
|
|
}
|
|
)
|
|
|
|
// GetConflictingBookingsForExceptionHandler accepts POST with proposed exceptional hours
|
|
// and week starts, queries active bookings that would conflict (bookings that overlap
|
|
// with the affected weeks but fall OUTSIDE the proposed open hours), and returns them
|
|
// in the existing OverlappingBookingsResponse format.
|
|
func GetConflictingBookingsForExceptionHandler(w http.ResponseWriter, r *http.Request) {
|
|
var req ConflictingBookingsRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, "invalid payload", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if err := validators.Validate.Struct(&req); err != nil {
|
|
log.Printf("Failed to process request: %v", err)
|
|
http.Error(w, "Invalid request", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if len(req.ProposedHours) != 7 {
|
|
http.Error(w, "must provide exactly 7 weekday entries (0-6)", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var allConflicts []OverlappingBooking
|
|
|
|
// Build weekday map for robust lookup (not relying on array index = weekday)
|
|
proposedByWeekday := map[int]ExceptionalHours{}
|
|
for _, h := range req.ProposedHours {
|
|
proposedByWeekday[h.Weekday] = h
|
|
}
|
|
|
|
for _, weekStart := range req.WeekStarts {
|
|
ws, err := time.Parse("2006-01-02", weekStart)
|
|
if err != nil {
|
|
log.Printf("Invalid week_start format: %v", err)
|
|
http.Error(w, "invalid week_start format, expected YYYY-MM-DD", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
wsLondon := ws.In(londonLocation)
|
|
rangeStart := time.Date(wsLondon.Year(), wsLondon.Month(), wsLondon.Day(), 0, 0, 0, 0, londonLocation)
|
|
rangeEnd := rangeStart.AddDate(0, 0, 7).Add(-time.Nanosecond) // Sun 23:59:59.999999999
|
|
|
|
rows, err := db.Conn.Query(r.Context(), `
|
|
SELECT
|
|
b.id,
|
|
b.start_time,
|
|
b.status,
|
|
b.created_at,
|
|
b.total_duration_minutes as duration,
|
|
u.id as user_id,
|
|
u.fn,
|
|
u.email,
|
|
u.phone
|
|
FROM bookings b
|
|
LEFT JOIN users u ON b.user_id = u.id
|
|
WHERE `+ActiveBookingStatuses+`
|
|
AND b.start_time < $2
|
|
AND b.end_time > $1
|
|
ORDER BY b.start_time ASC
|
|
`, rangeStart, rangeEnd)
|
|
if err != nil {
|
|
log.Printf("Failed to query conflicting bookings: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
for rows.Next() {
|
|
var ob OverlappingBooking
|
|
ob.User = &UserSummary{}
|
|
if err := rows.Scan(&ob.ID, &ob.StartTime, &ob.Status, &ob.CreatedAt, &ob.Duration, &ob.User.ID, &ob.User.FullName, &ob.User.Email, &ob.User.Phone); err != nil {
|
|
log.Printf("Failed to scan conflicting booking row: %v", err)
|
|
rows.Close()
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Determine which weekday this booking falls on (London wall-clock time)
|
|
bookingLondon := ob.StartTime.In(londonLocation)
|
|
// Go: Sun=0,Mon=1,...,Sat=6 → Our convention: Mon=0,...,Sun=6
|
|
ourWeekday := int((bookingLondon.Weekday() + 6) % 7)
|
|
|
|
proposed, _ := proposedByWeekday[ourWeekday]
|
|
|
|
isConflict := false
|
|
if !proposed.IsOpen {
|
|
// Salon is closed on this day — any active booking conflicts
|
|
isConflict = true
|
|
} else {
|
|
startMinutes := bookingLondon.Hour()*60 + bookingLondon.Minute()
|
|
endLondon := ob.StartTime.Add(time.Duration(ob.Duration) * time.Minute).In(londonLocation)
|
|
endMinutes := endLondon.Hour()*60 + endLondon.Minute()
|
|
|
|
propStartMinutes := parseTimeToMinutes(proposed.StartTime)
|
|
propEndMinutes := parseTimeToMinutes(proposed.EndTime)
|
|
|
|
// Check if booking starts before opening or ends after closing.
|
|
// For midnight-crossing bookings (endMinutes < startMinutes), the booking
|
|
// extends past midnight and always conflicts with daily hours since the
|
|
// day's open window cannot span past midnight.
|
|
if startMinutes < 0 || endMinutes < 0 {
|
|
// parse error — treat as conflict
|
|
isConflict = true
|
|
} else if endMinutes < startMinutes {
|
|
// Booking crosses midnight — always a conflict with daily hours
|
|
isConflict = true
|
|
} else if startMinutes < propStartMinutes || endMinutes > propEndMinutes {
|
|
isConflict = true
|
|
}
|
|
}
|
|
|
|
if isConflict {
|
|
allConflicts = append(allConflicts, ob)
|
|
}
|
|
}
|
|
rows.Close()
|
|
|
|
if err := rows.Err(); err != nil {
|
|
log.Printf("Error iterating conflicting bookings: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(allConflicts) > 0 {
|
|
ids := make([]string, len(allConflicts))
|
|
for i, ob := range allConflicts {
|
|
ids[i] = ob.ID
|
|
}
|
|
serviceRows, err := db.Conn.Query(r.Context(), `
|
|
SELECT booking_id, name FROM (
|
|
SELECT bs.booking_id, s.name
|
|
FROM booking_services bs
|
|
JOIN services s ON bs.service_id = s.id
|
|
WHERE bs.booking_id = ANY($1)
|
|
UNION ALL
|
|
SELECT bcs.booking_id, cs.name
|
|
FROM booking_custom_services bcs
|
|
JOIN custom_services cs ON bcs.custom_service_id = cs.id
|
|
WHERE bcs.booking_id = ANY($1)
|
|
) sub ORDER BY booking_id, name
|
|
`, ids)
|
|
if err != nil {
|
|
log.Printf("Failed to batch-load services for conflicting bookings: %v", err)
|
|
} else {
|
|
serviceMap := map[string][]string{}
|
|
for serviceRows.Next() {
|
|
var bookingID, name string
|
|
if err := serviceRows.Scan(&bookingID, &name); err != nil {
|
|
log.Printf("Failed to scan service row: %v", err)
|
|
continue
|
|
}
|
|
serviceMap[bookingID] = append(serviceMap[bookingID], name)
|
|
}
|
|
serviceRows.Close()
|
|
if err := serviceRows.Err(); err != nil {
|
|
log.Printf("Error iterating services for conflicting bookings: %v", err)
|
|
}
|
|
for i, ob := range allConflicts {
|
|
allConflicts[i].Services = serviceMap[ob.ID]
|
|
}
|
|
}
|
|
}
|
|
|
|
if allConflicts == nil {
|
|
allConflicts = []OverlappingBooking{}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if err := json.NewEncoder(w).Encode(OverlappingBookingsResponse{Bookings: allConflicts}); err != nil {
|
|
log.Printf("Failed to encode conflicting bookings response: %v", err)
|
|
http.Error(w, "Internal server error", http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
// parseTimeToMinutes converts a "HH:MM" string to minutes since midnight.
|
|
// Returns -1 on parse failure.
|
|
func parseTimeToMinutes(t string) int {
|
|
parts := strings.Split(t, ":")
|
|
if len(parts) < 2 {
|
|
return -1
|
|
}
|
|
h, err1 := strconv.Atoi(parts[0])
|
|
m, err2 := strconv.Atoi(parts[1])
|
|
if err1 != nil || err2 != nil || h < 0 || h > 23 || m < 0 || m > 59 {
|
|
return -1
|
|
}
|
|
return h*60 + m
|
|
}
|