update endpoint to use apiRequest and adjust payload in admin pluto image endpoint

Author: roaldchristesen

api/admin_create_event.go

@@ -17,6 +17,9 @@ import (
 	"github.com/sndcds/uranus/model"
 )
 
+// TODO: Insert event, add ticket_link
+// TODO: Implement simulation mode without inserting data
+
 type eventPayload struct {
 	ContentLanguage   string                            `json:"content_language" binding:"required"`
 	ReleaseStatus     *string                           `json:"release_status" binding:"required"`
@@ -27,6 +30,7 @@ type eventPayload struct {
 	Summary           *string                           `json:"summary"`
 	Tags              []string                          `json:"tags"`
 	SourceUrl         *string                           `json:"source_url"`
+	SourceImageUrl    *string                           `json:"source_image_url"`
 	OnlineLink        *string                           `json:"online_link"`
 	OrganizationId    *int                              `json:"organization_id" binding:"required"`
 	OrganizationKey   *string                           `json:"organization_key" binding:"required"`
@@ -42,6 +46,7 @@ type eventPayload struct {
 	MaxAttendees      *int                              `json:"max_attendees"`
 	PriceType         model.PriceType                   `json:"price_type"`
 	Currency          *string                           `json:"currency"`
+	TicketLink        *string                           `json:"ticket_link"`
 	TicketFlags       []string                          `json:"ticket_flags"`
 	Custom            *string                           `json:"custom"`
 	Style             *string                           `json:"style"`
@@ -59,10 +64,12 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 	// Read the body
 	body, err := io.ReadAll(gc.Request.Body)
 	if err != nil {
+		debugf("Error: %v", err)
 		apiRequest.Error(http.StatusBadRequest, "failed to read request body")
 		return
 	}
 	if len(body) == 0 {
+		debugf("empty request body")
 		apiRequest.Error(http.StatusBadRequest, "empty request body")
 		return
 	}
@@ -75,6 +82,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 	if err != nil {
 		var syntaxErr *json.SyntaxError
 		var typeErr *json.UnmarshalTypeError
+		debugf("Error: %v", err)
 
 		switch {
 		case errors.As(err, &syntaxErr):
@@ -95,6 +103,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 		return
 	}
 	if decoder.More() {
+		debugf("Error decoder.More()")
 		apiRequest.Error(http.StatusBadRequest, "multiple JSON objects are not allowed")
 		return
 	}
@@ -105,6 +114,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 		var unmarshalTypeError *json.UnmarshalTypeError
 		var syntaxErr *json.SyntaxError
 		var invalidUnmarshalError *json.InvalidUnmarshalError
+		debugf("Error: %v", err)
 
 		switch {
 		case errors.As(err, &syntaxErr):
@@ -136,11 +146,13 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 	// Validation
 	validationErr := payload.Validate()
 	if validationErr != nil {
+		debugf("Error: %v", validationErr)
 		apiRequest.Error(http.StatusBadRequest, validationErr.Error())
 		return
 	}
 
 	if payload.OrganizationId == nil {
+		debugf("payload.OrganizationId == nil")
 		apiRequest.Error(http.StatusBadRequest, "organizationId is required")
 		return
 	}
@@ -159,6 +171,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 		if payload.VenueId != nil {
 			venuePermissions, err := h.GetUserEffectiveVenuePermissions(gc, tx, userId, *payload.VenueId)
 			if err != nil {
+				debugf("Error: %v", err)
 				return &ApiTxError{Code: http.StatusForbidden, Err: err}
 			}
 			if !venuePermissions.Has(app.PermChooseVenue) {
@@ -229,6 +242,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 					return &ApiTxError{Code: http.StatusInternalServerError, Err: err}
 				}
 				if !venuePermissions.Has(app.PermChooseVenue) {
+					debugf("Forbidden userId %d, venueId: %d", userId, *d.VenueId)
 					return ApiErrForbidden("")
 				}
 
@@ -259,6 +273,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 				d.AllDay,
 				userId)
 			if err != nil {
+				debugf("Error: %v", err)
 				return &ApiTxError{
 					Code: http.StatusInternalServerError,
 					Err:  fmt.Errorf("failed to insert event_date: %v", err),
@@ -287,6 +302,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 
 		err = RefreshEventProjections(ctx, tx, "event", []int{newEventId})
 		if err != nil {
+			debugf("Error: %v", err)
 			return &ApiTxError{
 				Code: http.StatusInternalServerError,
 				Err:  fmt.Errorf("refresh projection tables failed: %v", err),
@@ -295,6 +311,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 
 		err = RefreshEventProjections(ctx, tx, "event", []int{newEventId})
 		if err != nil {
+			debugf("Error: %v", err)
 			return &ApiTxError{
 				Code: http.StatusInternalServerError,
 				Err:  fmt.Errorf("refresh projection tables failed: %v", err),
@@ -308,8 +325,7 @@ func (h *ApiHandler) AdminCreateEvent(gc *gin.Context) {
 		return
 	}
 
-	apiRequest.Metadata["created_event_id"] = newEventId
-	apiRequest.SuccessNoData(http.StatusCreated, "")
+	apiRequest.Success(http.StatusCreated, gin.H{"created_event_id": newEventId}, "")
 }
 
 // Validate validates the eventPayload struct
@@ -365,9 +381,11 @@ func (e *eventPayload) Validate() error {
 	}
 
 	// Validate VenueId
+	/* 2026-03-01, venueId not neccessary anymore in event
 	if !e.hasVenue() {
 		errs = append(errs, "event must have venueId")
 	}
+	*/
 
 	// Validate ExternalId (optional)
 	if err := app.ValidateOptionalNonEmptyString("external_id", e.ExternalId); err != nil {

api/admin_get_event.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -113,7 +112,7 @@ func (h *ApiHandler) AdminGetEvent(gc *gin.Context) {
 	for rows.Next() {
 		var img model.Image
 		rows.Scan(&img.Id, &img.Identifier, &img.FocusX, &img.FocusY, &img.Alt, &img.Copyright, &img.Creator, &img.License)
-		img.Url = fmt.Sprintf("%s/api/image/%d", h.Config.BaseApiUrl, img.Id)
+		img.Url = ImageUrl(img.Id)
 		event.Images = append(event.Images, img)
 	}
 

api/admin_pluto_image.go

@@ -62,6 +62,8 @@ func (h *ApiHandler) AdminUpsertPlutoImage(gc *gin.Context) {
 	userId := h.userId(gc)
 	apiRequest := grains_api.NewRequest(gc, "admin-upsert-pluto-image")
 
+	// TODO: Check user permissions for different contexts
+
 	context := gc.Param("context")
 	debugf("context: %s", context)
 	apiRequest.SetMeta("pluto_context", context)
@@ -99,16 +101,20 @@ func (h *ApiHandler) AdminUpsertPlutoImage(gc *gin.Context) {
 		apiRequest.InternalServerError()
 		return
 	}
+	debugf("fileNamePrefix: %s", fileNamePrefix)
 
 	// Upsert image in Pluto
 	plutoUpsertImageResult, err := pluto.UpsertImage(
 		gc, context, contextId, identifier, &fileNamePrefix, userId,
 		refresher(context, []int{contextId}))
 	if err != nil || plutoUpsertImageResult.HttpStatus != http.StatusOK {
+		debugf("err: %v", err)
 		gc.JSON(plutoUpsertImageResult.HttpStatus, gin.H{"error": plutoUpsertImageResult.Message})
 		return
 	}
 
+	debugf("ok")
+
 	apiRequest.SetMeta("file_replaced", plutoUpsertImageResult.FileRemovedFlag)
 	apiRequest.SetMeta("cache_removed_count", plutoUpsertImageResult.CacheFilesRemoved)
 	apiRequest.SetMeta("image_id", plutoUpsertImageResult.ImageId)

api/api_image_helper.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sndcds/uranus/app"
 )
 
 func IsEventImageIdentifier(identifier string) bool {
@@ -85,3 +86,11 @@ func (h *ApiHandler) UpsertImage(
 
 	return plutoImageId, nil
 }
+
+func ImageUrl(imageID int) string {
+	return fmt.Sprintf(
+		"%s/api/image/%d",
+		app.UranusInstance.Config.BaseApiUrl,
+		imageID,
+	)
+}

api/get_event.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"encoding/json"
-	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -166,15 +165,15 @@ func (h *ApiHandler) GetEventByDateId(gc *gin.Context) {
 
 		// Generate VenueLogoUrl if logo exists
 		if edd.VenueLogoImageId != nil {
-			url := fmt.Sprintf("%s/api/image/%d", app.UranusInstance.Config.BaseApiUrl, *edd.VenueLogoImageId)
+			url := ImageUrl(*edd.VenueLogoImageId)
 			edd.VenueLogoUrl = &url
 		}
 		if edd.VenueLightThemeLogoImageId != nil {
-			url := fmt.Sprintf("%s/api/image/%d", app.UranusInstance.Config.BaseApiUrl, *edd.VenueLightThemeLogoImageId)
+			url := ImageUrl(*edd.VenueLightThemeLogoImageId)
 			edd.VenueLightThemeLogoUrl = &url
 		}
 		if edd.VenueDarkThemeLogoImageId != nil {
-			url := fmt.Sprintf("%s/api/image/%d", app.UranusInstance.Config.BaseApiUrl, *edd.VenueDarkThemeLogoImageId)
+			url := ImageUrl(*edd.VenueDarkThemeLogoImageId)
 			edd.VenueDarkThemeLogoUrl = &url
 		}
 

api/get_events.go

@@ -331,11 +331,13 @@ func (h *ApiHandler) GetEvents(gc *gin.Context) {
 	query = strings.Replace(query, "{{conditions}}", conditionsStr, 1)
 	query = strings.Replace(query, "{{limit}}", limitClause, 1)
 
-	fmt.Println(query)
-	fmt.Printf("ARGS (%d):\n", len(args))
-	for i, arg := range args {
-		fmt.Printf("  $%d = %#v (type %T)\n", i+1, arg, arg)
-	}
+	/*
+		fmt.Println(query)
+		fmt.Printf("ARGS (%d):\n", len(args))
+		for i, arg := range args {
+			fmt.Printf("  $%d = %#v (type %T)\n", i+1, arg, arg)
+		}
+	*/
 
 	rows, err := h.DbPool.Query(ctx, query, args...)
 	if err != nil {
@@ -410,7 +412,7 @@ func (h *ApiHandler) GetEvents(gc *gin.Context) {
 		}
 
 		if e.ImageId != nil {
-			path := fmt.Sprintf("%s/api/image/%d", h.Config.BaseApiUrl, *e.ImageId)
+			path := ImageUrl(*e.ImageId)
 			e.ImagePath = &path
 		}
 

api/get_organization.go

@@ -4,44 +4,47 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sndcds/grains/grains_api"
 	"github.com/sndcds/uranus/app"
 )
 
-// TODO: Review code
-
 func (h *ApiHandler) GetOrganization(gc *gin.Context) {
 	ctx := gc.Request.Context()
+	apiRequest := grains_api.NewRequest(gc, "get-organization")
 
 	organizationId, ok := ParamInt(gc, "organizationId")
 	if !ok {
-		gc.JSON(http.StatusBadRequest, gin.H{"error": "organization Id is required"})
+		apiRequest.Error(http.StatusBadRequest, "organizationId is required")
 		return
 	}
+	apiRequest.SetMeta("organizationId", organizationId)
 
 	query := app.UranusInstance.SqlGetOrganization
 	rows, err := h.DbPool.Query(ctx, query, organizationId)
 	if err != nil {
-		gc.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		apiRequest.InternalServerError()
 		return
 	}
 	defer rows.Close()
 
 	if !rows.Next() {
-		gc.JSON(http.StatusNotFound, gin.H{"error": "organization not found"})
+		apiRequest.NotFound("organization not found")
 		return
 	}
 
 	fieldDescriptions := rows.FieldDescriptions()
 	values, err := rows.Values()
 	if err != nil {
-		gc.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		apiRequest.InternalServerError()
 		return
 	}
 
-	result := make(map[string]interface{}, len(values))
+	response := make(map[string]interface{}, len(values))
 	for i, fd := range fieldDescriptions {
-		result[string(fd.Name)] = values[i]
+		if values[i] != nil {
+			response[string(fd.Name)] = values[i]
+		}
 	}
 
-	gc.JSON(http.StatusOK, result)
+	apiRequest.Success(http.StatusOK, response, "")
 }

api/get_organizations.go

@@ -6,26 +6,29 @@ import (
 	"strings"
 
 	"github.com/gin-gonic/gin"
+	"github.com/sndcds/grains/grains_api"
 )
 
-// TODO: Review code
-
-type Organization struct {
-	ID           int     `json:"id"`
-	Name         *string `json:"name"`
-	City         *string `json:"city"`
-	Country      *string `json:"country"`
-	ContactEmail *string `json:"contact_email"`
-}
+// TODO: Add filter options, e.g. lat/lon/radius
 
 func (h *ApiHandler) GetOrganizations(gc *gin.Context) {
 	ctx := gc.Request.Context()
+	apiRequest := grains_api.NewRequest(gc, "get organizations")
+
+	type OrganizationResult struct {
+		Id           int     `json:"id"`
+		Name         *string `json:"name"`
+		City         *string `json:"city"`
+		Country      *string `json:"country"`
+		ContactEmail *string `json:"contact_email"`
+	}
 
 	searchStr := strings.TrimSpace(gc.Query("search"))
 	if len(searchStr) < 1 {
-		gc.JSON(http.StatusBadRequest, gin.H{"error": "URL argument search is required"})
+		apiRequest.Error(http.StatusBadRequest, "URL argument search is required")
 		return
 	}
+	apiRequest.SetMeta("search", searchStr)
 	var isEmail = strings.Contains(searchStr, "@")
 
 	var query string
@@ -38,20 +41,24 @@ func (h *ApiHandler) GetOrganizations(gc *gin.Context) {
 	searchPattern := "%" + searchStr + "%"
 	rows, err := h.DbPool.Query(ctx, query, searchPattern)
 	if err != nil {
-		gc.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		apiRequest.InternalServerError()
 		return
 	}
 	defer rows.Close()
 
-	var organizations []Organization
+	var organizations []OrganizationResult
 	for rows.Next() {
-		var o Organization
-		if err := rows.Scan(&o.ID, &o.Name, &o.City, &o.Country, &o.ContactEmail); err != nil {
-			gc.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		var o OrganizationResult
+		if err := rows.Scan(&o.Id, &o.Name, &o.City, &o.Country, &o.ContactEmail); err != nil {
+			apiRequest.InternalServerError()
 			return
 		}
 		organizations = append(organizations, o)
 	}
-
-	gc.JSON(http.StatusOK, organizations)
+	if len(organizations) == 0 {
+		apiRequest.NotFound("no organizations found")
+		return
+	}
+	apiRequest.SetMeta("organization_count", len(organizations))
+	apiRequest.Success(http.StatusOK, organizations, "")
 }

api/get_venues_for_map.go

@@ -8,8 +8,7 @@ import (
 	"github.com/sndcds/uranus/app"
 )
 
-// TODO: Review code
-// TODO: Add url parameter
+// TODO: Add query parameters for filtering
 
 func (h *ApiHandler) GetVenuesGeoJSON(gc *gin.Context) {
 	ctx := gc.Request.Context()