browser/platform/api/scum_handlers.go

package api

import (
	"net/http"
	"strconv"

	"browser.local/platform/domain"
	"browser.local/platform/dto"
)

func (h *coreHandlers) serverSCUMPlayers(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMPlayerLiveStatesForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMPlayerLiveStatesFromDomain(items))
}

func (h *coreHandlers) serverSCUMUsers(w http.ResponseWriter, r *http.Request) {
	h.serverSCUMDataSet(w, r, domain.SCUMDataSetUsers)
}

func (h *coreHandlers) serverSCUMDataSquads(w http.ResponseWriter, r *http.Request) {
	h.serverSCUMDataSet(w, r, domain.SCUMDataSetSquads)
}

func (h *coreHandlers) serverSCUMActivity(w http.ResponseWriter, r *http.Request) {
	h.serverSCUMDataSet(w, r, domain.SCUMDataSetActivity)
}

func (h *coreHandlers) serverSCUMGifts(w http.ResponseWriter, r *http.Request) {
	h.serverSCUMDataSet(w, r, domain.SCUMDataSetGiftEvents)
}

func (h *coreHandlers) serverSCUMMapPoints(w http.ResponseWriter, r *http.Request) {
	h.serverSCUMDataSet(w, r, domain.SCUMDataSetMapPoints)
}

func (h *coreHandlers) serverSCUMDataSet(w http.ResponseWriter, r *http.Request, target domain.SCUMDataSet) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	filter := scumProjectionFilterFromRequest(r, r.PathValue("id"))
	filter.TargetTable = target
	items, err := h.core.ListSCUMDataRowsForSession(bearerToken(r), filter)
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMDataRowsFromDomain(items))
}

func (h *coreHandlers) serverSCUMSquads(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMSquadsForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMSquadsFromDomain(items))
}

func (h *coreHandlers) serverSCUMSquadMembers(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMSquadMembersForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMSquadMembersFromDomain(items))
}

func (h *coreHandlers) serverSCUMVehicles(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMVehiclesForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMVehiclesFromDomain(items))
}

func (h *coreHandlers) serverSCUMFlags(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMFlagsForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMFlagsFromDomain(items))
}

func (h *coreHandlers) serverSCUMPositions(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMCurrentPositionsForSession(bearerToken(r), scumProjectionFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMCurrentPositionsFromDomain(items))
}

func (h *coreHandlers) serverSCUMOperations(w http.ResponseWriter, r *http.Request) {
	serverID := r.PathValue("id")
	switch r.Method {
	case http.MethodGet:
		items, err := h.core.ListSCUMOperationsForSession(bearerToken(r), scumOperationFilterFromRequest(r, serverID))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusOK, dto.SCUMOperationsFromDomain(items))
	case http.MethodPost:
		request, err := decodeJSON[dto.SCUMOperationRequestBody](r)
		if err != nil {
			writeDecodeError(w, err)
			return
		}
		operation, err := h.core.RequestSCUMOperationForSession(bearerToken(r), serverID, dto.SCUMOperationRequestBodyToDomain(request))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusCreated, dto.SCUMOperationFromDomain(operation))
	default:
		writeMethodNotAllowed(w, "GET, POST")
	}
}

func (h *coreHandlers) serverSCUMOperationApprove(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		writeMethodNotAllowed(w, http.MethodPost)
		return
	}
	operation, err := h.core.ApproveSCUMOperationForSession(bearerToken(r), r.PathValue("operationId"))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMOperationFromDomain(operation))
}

func (h *coreHandlers) serverSCUMWorkflows(w http.ResponseWriter, r *http.Request) {
	serverID := r.PathValue("id")
	switch r.Method {
	case http.MethodGet:
		items, err := h.core.ListSCUMWorkflowsForSession(bearerToken(r), scumWorkflowFilterFromRequest(r, serverID))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusOK, dto.SCUMWorkflowsFromDomain(items))
	case http.MethodPost:
		request, err := decodeJSON[dto.SCUMWorkflowCreateRequest](r)
		if err != nil {
			writeDecodeError(w, err)
			return
		}
		workflow, err := h.core.CreateSCUMWorkflowForSession(bearerToken(r), serverID, dto.SCUMWorkflowCreateRequestToDomain(request))
		if err != nil {
			writeServiceError(w, err)
			return
		}
		writeJSON(w, http.StatusCreated, dto.SCUMWorkflowFromDomain(workflow))
	default:
		writeMethodNotAllowed(w, "GET, POST")
	}
}

func (h *coreHandlers) serverSCUMWorkflowSteps(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		writeMethodNotAllowed(w, http.MethodGet)
		return
	}
	items, err := h.core.ListSCUMWorkflowStepsForSession(bearerToken(r), scumWorkflowStepFilterFromRequest(r, r.PathValue("id")))
	if err != nil {
		writeServiceError(w, err)
		return
	}
	writeJSON(w, http.StatusOK, dto.SCUMWorkflowStepsFromDomain(items))
}

func scumProjectionFilterFromRequest(r *http.Request, serverID string) domain.SCUMProjectionFilter {
	query := r.URL.Query()
	return domain.SCUMProjectionFilter{ServerInstanceID: serverID, GamePlayerID: query.Get("gamePlayerId"), GamePlayerRecordID: query.Get("gamePlayerRecordId"), UserProfileID: query.Get("userProfileId"), SteamID: query.Get("steamId"), SquadID: query.Get("squadId"), VehicleID: query.Get("vehicleId"), FlagID: query.Get("flagId"), SubjectType: domain.SCUMProjectionSubject(query.Get("subjectType")), QueryKey: query.Get("queryKey"), Freshness: domain.SCUMProjectionFreshness(query.Get("freshness")), Search: query.Get("search"), Limit: boundedQueryLimit(query.Get("limit"), 200)}
}

func scumOperationFilterFromRequest(r *http.Request, serverID string) domain.SCUMOperationRequestFilter {
	query := r.URL.Query()
	return domain.SCUMOperationRequestFilter{ServerInstanceID: serverID, TemplateKey: query.Get("templateKey"), PlayerID: query.Get("playerId"), RequesterID: query.Get("requesterId"), Status: domain.SCUMWorkflowStepStatus(query.Get("status")), IdempotencyKey: query.Get("idempotencyKey"), Limit: boundedQueryLimit(query.Get("limit"), 100)}
}

func scumWorkflowFilterFromRequest(r *http.Request, serverID string) domain.SCUMWorkflowInstanceFilter {
	query := r.URL.Query()
	return domain.SCUMWorkflowInstanceFilter{ServerInstanceID: serverID, TemplateKey: query.Get("templateKey"), RequestedBy: query.Get("requestedBy"), Status: domain.SCUMWorkflowStatus(query.Get("status")), IdempotencyKey: query.Get("idempotencyKey"), Limit: boundedQueryLimit(query.Get("limit"), 100)}
}

func scumWorkflowStepFilterFromRequest(r *http.Request, serverID string) domain.SCUMWorkflowStepFilter {
	query := r.URL.Query()
	return domain.SCUMWorkflowStepFilter{ServerInstanceID: serverID, WorkflowID: query.Get("workflowId"), StepKey: query.Get("stepKey"), Status: domain.SCUMWorkflowStepStatus(query.Get("status")), Limit: boundedQueryLimit(query.Get("limit"), 200)}
}

func boundedQueryLimit(raw string, fallback int) int {
	if raw == "" {
		return fallback
	}
	parsed, err := strconv.Atoi(raw)
	if err != nil || parsed < 1 {
		return fallback
	}
	if parsed > 500 {
		return 500
	}
	return parsed
}