feat: added venue owner status change

fullstacksherpa · fullstacksherpa · commit d89cd9c1a536 · 2026-01-13T20:26:49.000-08:00
diff --git a/cmd/api/admin_dashboard.go b/cmd/api/admin_dashboard.go
@@ -2,7 +2,10 @@ package main
 
 import (
 	"context"
+	"khel/internal/domain/venues"
+	"khel/internal/params"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -30,3 +33,99 @@ func (app *application) adminOverviewHandler(w http.ResponseWriter, r *http.Requ
 
 	_ = app.jsonResponse(w, http.StatusOK, out)
 }
+
+// Filters applied to the venue list (admin)
+type AdminVenueListFilters struct {
+	Sport  string `json:"sport"`  // "" when not filtered
+	Status string `json:"status"` // "" when not filtered
+}
+
+// Full paginated response for admin venue listing
+type VenueListWithMetaResponse struct {
+	Venues     []VenueListResponse   `json:"venues"`
+	Pagination params.Pagination     `json:"pagination"`
+	Filters    AdminVenueListFilters `json:"filters"`
+}
+
+// @Summary      List venues (admin)
+// @Description  Paginated list of venues with optional filters (sport, status).
+// @Tags         superadmin-venue
+// @Produce      json
+// @Param        sport   query   string false "Filter by sport type"
+// @Param        status  query   string false "Filter by venue status (active|requested|inactive)"
+// @Param        page    query   int    false "Page number" default(1)
+// @Param        limit   query   int    false "Items per page" default(15)
+// @Success      200     {object} VenueListWithMetaResponse
+// @Security     ApiKeyAuth
+// @Router       /superadmin/venues/ [get]
+func (app *application) AdminlistVenuesHandler(w http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	q := r.URL.Query()
+
+	// ✅ shared pagination
+	p := params.ParsePagination(q)
+
+	// ✅ optional sport
+	var sportPtr *string
+	if s := strings.TrimSpace(q.Get("sport")); s != "" {
+		sportPtr = &s
+	}
+
+	// ✅ optional status (default handled in repo)
+	var statusPtr *string
+	if s := strings.TrimSpace(q.Get("status")); s != "" {
+		switch s {
+		case "active", "requested", "inactive":
+			statusPtr = &s
+		default:
+			app.badRequestResponse(w, r, errInvalidRequest("invalid status"))
+			return
+		}
+	}
+
+	filter := venues.AdminVenueFilter{
+		Sport:      sportPtr,
+		Status:     statusPtr,
+		Pagination: p,
+	}
+
+	result, err := app.store.Venues.ListWithTotal(ctx, filter)
+	if err != nil {
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	// ✅ compute pagination meta from total
+	p.ComputeMeta(result.Total)
+
+	// ✅ Convert to response format (no favorites)
+	respVenues := make([]VenueListResponse, 0, len(result.Venues))
+	for _, v := range result.Venues {
+		respVenues = append(respVenues, VenueListResponse{
+			ID:            v.ID,
+			Name:          v.Name,
+			Address:       v.Address,
+			Location:      []float64{v.Longitude, v.Latitude},
+			ImageURLs:     v.ImageURLs,
+			OpenTime:      v.OpenTime,
+			PhoneNumber:   v.PhoneNumber,
+			Sport:         v.Sport,
+			TotalReviews:  v.TotalReviews,
+			AverageRating: v.AverageRating,
+			// IsFavorite removed ✅
+		})
+	}
+
+	out := VenueListWithMetaResponse{
+		Venues:     respVenues,
+		Pagination: p,
+		Filters: AdminVenueListFilters{
+			Sport:  strings.TrimSpace(q.Get("sport")),
+			Status: strings.TrimSpace(q.Get("status")),
+		},
+	}
+
+	_ = app.jsonResponse(w, http.StatusOK, out)
+}
diff --git a/cmd/api/api.go b/cmd/api/api.go
@@ -198,6 +198,7 @@ func (app *application) mount() http.Handler {
 			// Routes that require venue ownership
 			r.Route("/{venueID}", func(r chi.Router) {
 				r.Use(app.IsOwnerMiddleware)
+				r.Patch("/status", app.updateVenueStatusOwnerHandler)
 				r.Post("/bookings/manual", app.createManualBookingHandler)
 				r.Get("/pricing", app.getVenuePricing)
 				r.Delete("/", app.deleteVenueHandler)
@@ -403,6 +404,7 @@ func (app *application) mount() http.Handler {
 			r.Get("/overview", app.adminOverviewHandler)
 
 			r.Get("/app-reviews", app.getAllAppReviewsHandler)
+			r.Get("/venues", app.AdminlistVenuesHandler)
 
 		})
 
diff --git a/cmd/api/venues.go b/cmd/api/venues.go
@@ -238,7 +238,7 @@ type VenueListResponse struct {
 	Sport         string    `json:"sport"`
 	TotalReviews  int       `json:"total_reviews"`
 	AverageRating float64   `json:"average_rating"`
-	IsFavorite    bool      `json:"is_favorite"`
+	IsFavorite    bool      `json:"is_favorite,omitempty"`
 }
 
 // @Summary		List venues
@@ -732,3 +732,85 @@ func (app *application) fullTextSearchVenuesHandler(w http.ResponseWriter, r *ht
 		"search_type": "full_text",
 	})
 }
+
+type updateVenueStatusPayload struct {
+	Status string `json:"status"` // "requested" or "active"
+}
+
+// UpdateVenueStatusOwner godoc
+//
+//	@Summary		Owner updates venue status
+//	@Description	Allows venue owner to change status only between requested and active.
+//	@Tags			Venue-Owner
+//	@Accept			json
+//	@Produce		json
+//	@Param			venueID	path		int64					true	"Venue ID"
+//	@Param			payload	body		updateVenueStatusPayload	true	"New status (requested|active)"
+//	@Success		200		{object}	map[string]string
+//	@Failure		400		{object}	error
+//	@Failure		401		{object}	error
+//	@Failure		403		{object}	error
+//	@Failure		404		{object}	error
+//	@Failure		500		{object}	error
+//	@Security		ApiKeyAuth
+//	@Router			/venues/{venueID}/status [patch]
+func (app *application) updateVenueStatusOwnerHandler(w http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	user := getUserFromContext(r)
+	if user == nil {
+		app.unauthorizedErrorResponse(w, r, fmt.Errorf("unauthorized"))
+		return
+	}
+
+	venueIDStr := chi.URLParam(r, "venueID")
+	venueID, err := strconv.ParseInt(venueIDStr, 10, 64)
+	if err != nil || venueID <= 0 {
+		app.badRequestResponse(w, r, fmt.Errorf("invalid venueID"))
+		return
+	}
+
+	var payload updateVenueStatusPayload
+	if err := readJSON(w, r, &payload); err != nil {
+		app.badRequestResponse(w, r, err)
+		return
+	}
+
+	next := strings.TrimSpace(payload.Status)
+	if next != "requested" && next != "active" {
+		app.badRequestResponse(w, r, errInvalidRequest("status must be requested or active"))
+		return
+	}
+
+	// ✅ Optional: friendly ownership check first (nicer errors)
+	isOwner, err := app.store.Venues.IsOwner(ctx, venueID, user.ID)
+	if err != nil {
+		// if you return "venue not found" from IsOwner, map that to 404
+		if strings.Contains(strings.ToLower(err.Error()), "not found") {
+			app.notFoundResponse(w, r, err)
+			return
+		}
+		app.internalServerError(w, r, err)
+		return
+	}
+	if !isOwner {
+		app.forbiddenResponse(w, r)
+		return
+	}
+
+	// ✅ DB enforces transition rules too
+	if err := app.store.Venues.UpdateVenueStatusOwner(ctx, venueID, user.ID, next); err != nil {
+		// If transition invalid or already same status, treat as 400 (better UX)
+		if strings.Contains(err.Error(), "not allowed") || strings.Contains(err.Error(), "invalid") {
+			app.badRequestResponse(w, r, errInvalidRequest("status change not allowed"))
+			return
+		}
+		app.internalServerError(w, r, err)
+		return
+	}
+
+	_ = app.jsonResponse(w, http.StatusOK, map[string]string{
+		"message": "venue status updated",
+	})
+}
diff --git a/internal/domain/venues/store.go b/internal/domain/venues/store.go
@@ -444,6 +444,112 @@ func (r *Repository) GetVenueDetail(ctx context.Context, venueID int64) (*VenueD
 	return &vd, nil
 }
 
+func (r *Repository) ListWithTotal(ctx context.Context, filter AdminVenueFilter) (*AdminVenueListResult, error) {
+	var (
+		where      []string
+		args       []interface{}
+		argCounter = 1
+	)
+
+	// ✅ Default behavior: if status not provided, show only active.
+	if filter.Status == nil || strings.TrimSpace(*filter.Status) == "" {
+		where = append(where, "v.status = 'active'")
+	} else {
+		// ✅ allow explicit status filter
+		where = append(where, fmt.Sprintf("v.status = $%d", argCounter))
+		args = append(args, strings.TrimSpace(*filter.Status))
+		argCounter++
+	}
+
+	// ✅ optional sport filter
+	if filter.Sport != nil && strings.TrimSpace(*filter.Sport) != "" {
+		where = append(where, fmt.Sprintf("v.sport = $%d", argCounter))
+		args = append(args, strings.TrimSpace(*filter.Sport))
+		argCounter++
+	}
+
+	whereSQL := " WHERE " + strings.Join(where, " AND ")
+
+	// ---- 1) total count ----
+	countQ := `SELECT COUNT(*) FROM venues v` + whereSQL
+
+	var total int
+	if err := r.db.QueryRow(ctx, countQ, args...).Scan(&total); err != nil {
+		return nil, fmt.Errorf("count venues: %w", err)
+	}
+
+	// ---- 2) list data ----
+	limitPos := argCounter
+	offsetPos := argCounter + 1
+
+	dataQ := fmt.Sprintf(`
+		WITH venue_stats AS (
+			SELECT venue_id, COUNT(*) AS total_reviews, AVG(rating) AS average_rating
+			FROM reviews
+			GROUP BY venue_id
+		)
+		SELECT
+			v.id,
+			v.name,
+			v.address,
+			ST_X(v.location::geometry) AS longitude,
+			ST_Y(v.location::geometry) AS latitude,
+			v.image_urls,
+			v.open_time,
+			v.phone_number,
+			v.sport,
+			COALESCE(vs.total_reviews, 0) AS total_reviews,
+			COALESCE(vs.average_rating, 0) AS average_rating
+		FROM venues v
+		LEFT JOIN venue_stats vs ON v.id = vs.venue_id
+		%s
+		ORDER BY v.created_at DESC
+		LIMIT $%d OFFSET $%d
+	`, whereSQL, limitPos, offsetPos)
+
+	args2 := append([]interface{}{}, args...)
+	args2 = append(args2, filter.Pagination.Limit, filter.Pagination.Offset)
+
+	rows, err := r.db.Query(ctx, dataQ, args2...)
+	if err != nil {
+		return nil, fmt.Errorf("list venues: %w", err)
+	}
+	defer rows.Close()
+
+	var out []VenueListing
+	for rows.Next() {
+		var v VenueListing
+		var openTime sql.NullString
+
+		if err := rows.Scan(
+			&v.ID,
+			&v.Name,
+			&v.Address,
+			&v.Longitude,
+			&v.Latitude,
+			&v.ImageURLs,
+			&openTime,
+			&v.PhoneNumber,
+			&v.Sport,
+			&v.TotalReviews,
+			&v.AverageRating,
+		); err != nil {
+			return nil, fmt.Errorf("scan venue row: %w", err)
+		}
+
+		if openTime.Valid {
+			v.OpenTime = &openTime.String
+		}
+		out = append(out, v)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("rows venues: %w", err)
+	}
+
+	return &AdminVenueListResult{Venues: out, Total: total}, nil
+}
+
 func (r *Repository) GetImageURLs(ctx context.Context, venueID int64) ([]string, error) {
 	query := `SELECT image_urls FROM venues WHERE id = $1`
 
@@ -768,3 +874,48 @@ func (r *Repository) FullTextSearchVenues(ctx context.Context, query string) ([]
 
 	return out, nil
 }
+
+func (r *Repository) UpdateVenueStatusOwner(
+	ctx context.Context,
+	venueID int64,
+	ownerID int64,
+	nextStatus string,
+) error {
+	nextStatus = strings.TrimSpace(nextStatus)
+
+	// ✅ Owner is only allowed requested <-> active
+	if nextStatus != string(VenueStatusRequested) && nextStatus != string(VenueStatusActive) {
+		return fmt.Errorf("invalid status transition")
+	}
+
+	/**
+	 * ✅ Enforce transitions at SQL level:
+	 * - requested -> active
+	 * - active -> requested
+	 * ✅ Ensure owner_id matches (only the owner can mutate).
+	 * ✅ CAST: text -> venue_status
+	 */
+	q := `
+		UPDATE venues
+		SET status = $1::venue_status,
+		    updated_at = NOW()
+		WHERE id = $2
+		  AND owner_id = $3
+		  AND (
+				($1::venue_status = 'active'::venue_status     AND status = 'requested'::venue_status)
+			OR  ($1::venue_status = 'requested'::venue_status  AND status = 'active'::venue_status)
+		  )
+	`
+
+	ct, err := r.db.Exec(ctx, q, nextStatus, venueID, ownerID)
+	if err != nil {
+		return fmt.Errorf("update venue status: %w", err)
+	}
+
+	if ct.RowsAffected() == 0 {
+		// Could be: venue not found, not owner, or invalid transition
+		return fmt.Errorf("status change not allowed")
+	}
+
+	return nil
+}
diff --git a/internal/domain/venues/types.go b/internal/domain/venues/types.go
