fix: refactor availability logic for kathmandu/nepal time

Author: fullstacksherpa

Doc/availableTime.md

@@ -0,0 +1,154 @@
+## Booking Availability: Implementation and Data Flow
+
+### Overview
+
+This document summarizes the end-to-end implementation of the hourly availability feature for venues, covering both frontend and backend components, the data flow between them, potential flaws, and a sample output.
+
+---
+
+## Frontend Implementation
+
+### 1. `useAvailableTimes` Hook
+
+```ts
+export interface AvailableTimesVariables {
+  venueID: number | string;
+  /** Full RFC3339 timestamp in Kathmandu timezone. */
+  date: string; // e.g. `2025-06-28T00:00:00+05:45`
+}
+
+export const useAvailableTimes = createQuery<
+  AvailableTimesResponse,
+  AvailableTimesVariables,
+  AxiosError<APIError>
+>({
+  queryKey: ["venues", "available-times"],
+  fetcher: ({ venueID, date }) =>
+    client.get(`/venues/${venueID}/available-times`, { params: { date } }).then((res) => res.data),
+  staleTime: 40_000,
+  refetchInterval: 30_000,
+});
+```
+
+- Fetches availability slots by passing `date` as full ISO timestamp in Kathmandu time.
+- Caching and refetch intervals configured for responsiveness.
+
+### 2. `AvailableTimesScreen` Component
+
+```tsx
+const dates = useMemo(() => generateDatesArray(10), []);
+const [selectedDate, setSelectedDate] = useState(dates[0].fullDate);
+
+const { data, isLoading, error } = useAvailableTimes({
+  variables: { venueID: venueId.toString(), date: selectedDate },
+});
+```
+
+- Generates 10-day window using `generateDatesArray` (returns full ISO in +05:45).
+- Uses `FlatList` to render `TimeSlotCard` for each `HourlySlot`.
+
+---
+
+## Backend Implementation
+
+### 1. `availableTimesHandler`
+
+```go
+dateStr := r.URL.Query().Get("date")
+date, err := time.ParseInLocation(time.RFC3339, dateStr, loc)
+loc, _ := time.LoadLocation("Asia/Kathmandu")
+dateInKtm := date.In(loc)
+dayOfWeek := strings.ToLower(dateInKtm.Weekday().String())
+pricingSlots := store.GetPricingSlots(ctx, venueID, dayOfWeek)
+bookings := store.GetBookingsForDate(ctx, venueID, date)
+// convert bookings to Kathmandu intervals
+// generate hourly buckets and check overlaps
+```
+
+- Parses full timestamp, converts to Kathmandu to determine `dayOfWeek`.
+
+### 2. Data Access Layer
+
+#### a) `GetPricingSlots`
+
+- Queries `venue_pricing` for given `venueID` and `day_of_week`.
+- Returns list of `PricingSlot` with local-times in UTC `time.Time` fields.
+
+#### b) `GetBookingsForDate`
+
+```go
+loc, _ := time.LoadLocation("Asia/Kathmandu")
+localDate := date.In(loc)
+startOfDayLocal := time.Date(localDate.Year(), localDate.Month(), localDate.Day(), 0,0,0,0,loc)
+endOfDayLocal := startOfDayLocal.Add(24*time.Hour)
+// convert to UTC
+startUTC := startOfDayLocal.UTC()
+endUTC := endOfDayLocal.UTC()
+// SELECT ... WHERE start_time < $1 AND end_time > $2
+```
+
+- Computes local day bounds in Kathmandu, converts to UTC for querying `timestamptz` columns.
+
+---
+
+## Data Flow
+
+```text
+1. User Interaction:
+   → User selects a date via DateSelector
+   → selectedDate becomes e.g. 2025-06-28T00:00:00+05:45
+
+2. Frontend Request:
+   → useAvailableTimes sends:
+     GET /venues/{id}/available-times?date=2025-06-28T00:00:00+05:45
+
+3. Handler Parsing:
+   → availableTimesHandler parses `dateStr`
+   → converts to `dateInKtm`
+   → determines `dayOfWeek`
+
+4. Pricing Lookup:
+   → Calls GetPricingSlots(venueID, dayOfWeek)
+   → returns daily pricing windows
+
+5. Booking Lookup:
+   → Calls GetBookingsForDate(ctx, venueID, date)
+   → computes local day bounds and queries bookings
+
+6. Slot Generation:
+   → Handler breaks pricing windows into 1‑hour buckets
+   → Filters out past hours
+   → Marks availability by checking overlaps with existing bookings
+
+7. Response:
+   → Returns JSON array of HourlySlot objects
+   → Format: { start_time, end_time, price_per_hour, available }
+   → All timestamps in Kathmandu-local time
+```
+
+---
+
+## Server Log Sample
+
+```log
+⏰ dateStr: 2025-06-29T00:00:00+05:45
+⏰ date after Parse: 2025-06-29 00:00:00 +0545 +0545
+⏰ date in Ktm: 2025-06-29 00:00:00 +0545 +0545
+⏰ day of week in ktm: sunday
+```
+
+- ✅ You're receiving the date string in proper RFC3339 format with Kathmandu offset.
+- ✅ You're parsing it using `time.ParseInLocation`, attaching the named location `Asia/Kathmandu`.
+- ✅ You're converting and computing the local day correctly.
+- ✅ You're querying pricing and bookings properly.
+- ✅ You're generating hourly time slot output accurately.
+
+> **Note:** `+0545 +0545` appears twice because Go's internal formatting shows both the numeric offset and the fixed location (if not a named zone).
+
+You can verify the named location with:
+
+```go
+fmt.Printf("Time: %s | Location: %s\n", date.Format(time.RFC3339), date.Location())
+```
+
+---

cmd/api/api.go

@@ -119,7 +119,6 @@ func (app *application) mount() http.Handler {
 			r.Use(app.AuthTokenMiddleware)
 			r.Get("/list-venues", app.listVenuesHandler)
 			r.Get("/favorites", app.listFavoritesHandler)
-			// Expects URL: /venues/{venueID}/available-times?date=YYYY-MM-DD
 			r.Get("/{venueID}/available-times", app.availableTimesHandler)
 			r.Get("/is-venue-owner", app.isVenueOwnerHandler)
 			r.Post("/", app.createVenueHandler)
@@ -209,7 +208,6 @@ func (app *application) mount() http.Handler {
 		r.Post("/authentication/reset-password", app.requestResetPasswordHandler)
 		r.Patch("/authentication/reset-password", app.resetPasswordHandler)
 
-		// Public routes
 		r.Route("/authentication", func(r chi.Router) {
 			r.Post("/user", app.registerUserHandler)
 			r.Post("/token", app.createTokenHandler)
@@ -228,7 +226,7 @@ func (app *application) run(mux http.Handler) error {
 
 	port := os.Getenv("PORT")
 	if port == "" {
-		port = "8080" // Fallback to 8080 if PORT is not set
+		port = "8080"
 	}
 
 	srv := &http.Server{

cmd/api/auth.go

@@ -113,7 +113,6 @@ func (app *application) registerUserHandler(w http.ResponseWriter, r *http.Reque
 
 	activationURL := fmt.Sprintf("%s/confirm?token=%s", app.config.frontendURL, plainToken)
 
-	isProdEnv := app.config.env == "production"
 	vars := struct {
 		Username      string
 		ActivationURL string
@@ -123,7 +122,7 @@ func (app *application) registerUserHandler(w http.ResponseWriter, r *http.Reque
 	}
 
 	//send email
-	status, err := app.mailer.Send(mailer.UserWelcomeTemplate, user.FirstName, user.Email, vars, !isProdEnv)
+	status, err := app.mailer.Send(mailer.UserWelcomeTemplate, user.FirstName, user.Email, vars)
 	if err != nil {
 		app.logger.Errorw("error sending welcome email", "error", err)
 
@@ -428,8 +427,7 @@ func (app *application) requestResetPasswordHandler(w http.ResponseWriter, r *ht
 		ResetURL: resetURL,
 	}
 
-	isProdEnv := app.config.env == "production"
-	status, err := app.mailer.Send(mailer.ResetPasswordTemplate, payload.Email, payload.Email, vars, !isProdEnv)
+	status, err := app.mailer.Send(mailer.ResetPasswordTemplate, payload.Email, payload.Email, vars)
 	if err != nil {
 		app.logger.Errorw("error sending reset password email", "error", err)
 		app.internalServerError(w, r, err)

cmd/api/booking.go

@@ -38,47 +38,87 @@ type HourlySlot struct {
 //	@Accept			json
 //	@Produce		json
 //	@Param			venueID	path		int			true	"Venue ID"
-//	@Param			date	query		string		true	"Date in YYYY-MM-DD format"
+//	@Param			date	query		string		true	"Date in 2025-06-28T00:00:00+05:45 format"
 //	@Success		200		{array}		HourlySlot	"Hourly availability"
 //	@Failure		400		{object}	error		"Bad Request"
 //	@Failure		500		{object}	error		"Internal Server Error"
 //	@Security		ApiKeyAuth
 //	@Router			/venues/{venueID}/available-times [get]
 func (app *application) availableTimesHandler(w http.ResponseWriter, r *http.Request) {
-	// Step 1: Parse venueID from URL path
+	// Parse venueID from URL path to int64
 	venueID, err := strconv.ParseInt(chi.URLParam(r, "venueID"), 10, 64)
 	if err != nil {
 		app.badRequestResponse(w, r, err)
 		return
 	}
 
-	// Step 2: Parse `date` from query param in format YYYY-MM-DD
+	//  Parse `date` from query param in format 2025-06-28T00:00:00+05:45
 	dateStr := r.URL.Query().Get("date")
 	if dateStr == "" {
 		app.badRequestResponse(w, r, fmt.Errorf("missing date"))
 		return
 	}
-	date, err := time.Parse("2006-01-02", dateStr)
+	fmt.Printf("⏰ dateStr: %s\n", dateStr)
+
+	//  Set the target timezone to Asia/Kathmandu
+	loc, err := time.LoadLocation("Asia/Kathmandu")
 	if err != nil {
-		app.badRequestResponse(w, r, err)
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	// Parse into named location so date.Location()==Asia/Kathmandu date will be
+	// 2025-06-30 00:00:00 +0545 +0545. first +0545 is for offset and second is for location
+	date, err := time.ParseInLocation(time.RFC3339, dateStr, loc)
+	if err != nil {
+		app.badRequestResponse(w, r, fmt.Errorf("invalid date format: %w", err))
 		return
 	}
-	dayOfWeek := strings.ToLower(date.Weekday().String())
+
+	fmt.Printf("⏰ date after Parse: %s\n", date)
+
+	dateInKtm := date.In(loc)
+	fmt.Printf("⏰ date in Ktm: %s\n", dateInKtm)
+	dayOfWeek := strings.ToLower(dateInKtm.Weekday().String())
+	fmt.Printf("⏰day of week in ktm: %s\n", dayOfWeek)
 
 	// Step 3: Load pricing slots and bookings for the venue and the selected date
 	pricingSlots, err := app.store.Bookings.GetPricingSlots(r.Context(), venueID, dayOfWeek)
 	if err != nil {
 		app.internalServerError(w, r, err)
 		return
 	}
-	bookings, err := app.store.Bookings.GetBookingsForDate(r.Context(), venueID, date)
-	if err != nil {
-		app.internalServerError(w, r, err)
+	if len(pricingSlots) == 0 {
+		app.jsonResponse(w, http.StatusOK, []HourlySlot{}) // no slots for this day
 		return
 	}
 
-	// Step 4: Set the target timezone to Asia/Kathmandu
-	loc, err := time.LoadLocation("Asia/Kathmandu")
+	//Prevents generating duplicate time buckets in output.
+	// !unique[key]
+	//This line checks:
+	//unique[key] looks up the value for that key in the map.
+	//If it does not exist, Go returns the zero value for the type bool, which is false.
+	//!false → true
+	//So !unique[key] becomes true the first time you encounter that key.
+	unique := make(map[string]bool)
+	var filtered []store.PricingSlot
+
+	for _, ps := range pricingSlots {
+		key := fmt.Sprintf("%s-%s-%d", ps.StartTime.Format("15:04"), ps.EndTime.Format("15:04"), ps.Price)
+		if !unique[key] {
+			unique[key] = true
+			filtered = append(filtered, ps)
+		}
+	}
+
+	pricingSlots = filtered
+
+	fmt.Println("📊 Pricing slots:")
+	for _, ps := range pricingSlots {
+		fmt.Printf("- %s to %s at %d\n", ps.StartTime.Format("15:04"), ps.EndTime.Format("15:04"), ps.Price)
+	}
+
+	bookings, err := app.store.Bookings.GetBookingsForDate(r.Context(), venueID, date)
 	if err != nil {
 		app.internalServerError(w, r, err)
 		return
@@ -109,6 +149,14 @@ func (app *application) availableTimesHandler(w http.ResponseWriter, r *http.Req
 
 	// Step 7: Generate hourly time slots and mark availability
 	var out []HourlySlot
+	// Round current time to the next full hour in Kathmandu timezone
+	now := time.Now().In(loc)
+	if now.Minute() > 0 || now.Second() > 0 || now.Nanosecond() > 0 {
+		now = now.Truncate(time.Hour).Add(time.Hour)
+	} else {
+		now = now.Truncate(time.Hour)
+	}
+
 	for _, ps := range pricingSlots {
 		// Convert pricing slot times into the selected date in Nepal timezone
 		slotStart := time.Date(date.Year(), date.Month(), date.Day(),
@@ -120,6 +168,10 @@ func (app *application) availableTimesHandler(w http.ResponseWriter, r *http.Req
 		for t := slotStart; !t.Add(time.Hour).After(slotEnd); t = t.Add(time.Hour) {
 			tEnd := t.Add(time.Hour)
 
+			if t.Before(now) {
+				continue
+			}
+
 			out = append(out, HourlySlot{
 				StartTime:    t,
 				EndTime:      tEnd,