mirror of
https://github.com/wanderer-industries/wanderer
synced 2025-12-10 09:45:43 +00:00
781 lines
25 KiB
Elixir
781 lines
25 KiB
Elixir
# lib/wanderer_app_web/controllers/map_system_api_controller.ex
|
|
defmodule WandererAppWeb.MapSystemAPIController do
|
|
@moduledoc """
|
|
API controller for managing map systems and their associated connections.
|
|
Provides CRUD operations and batch upsert for systems and connections.
|
|
"""
|
|
|
|
use WandererAppWeb, :controller
|
|
use OpenApiSpex.ControllerSpecs
|
|
|
|
alias OpenApiSpex.Schema
|
|
alias WandererApp.Map.Operations
|
|
alias WandererAppWeb.Helpers.APIUtils
|
|
alias WandererAppWeb.Schemas.{ApiSchemas, ResponseSchemas}
|
|
|
|
action_fallback WandererAppWeb.FallbackController
|
|
|
|
# -----------------------------------------------------------------
|
|
# V1 API Actions (for compatibility with versioned API router)
|
|
# -----------------------------------------------------------------
|
|
|
|
def index_v1(conn, params) do
|
|
# Delegate to existing index action
|
|
index(conn, params)
|
|
end
|
|
|
|
def show_v1(conn, params) do
|
|
# Delegate to existing show action
|
|
show(conn, params)
|
|
end
|
|
|
|
def create_v1(conn, params) do
|
|
# Delegate to existing create action
|
|
create(conn, params)
|
|
end
|
|
|
|
def update_v1(conn, params) do
|
|
# Delegate to existing update action
|
|
update(conn, params)
|
|
end
|
|
|
|
def delete_v1(conn, params) do
|
|
# Delegate to existing delete action
|
|
delete(conn, params)
|
|
end
|
|
|
|
def delete_single(conn, params) do
|
|
# Delegate to existing delete action for compatibility
|
|
delete(conn, params)
|
|
end
|
|
|
|
# -- JSON Schemas --
|
|
@map_system_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
id: %Schema{type: :string, description: "Map system UUID"},
|
|
map_id: %Schema{type: :string, description: "Map UUID"},
|
|
solar_system_id: %Schema{type: :integer, description: "EVE solar system ID"},
|
|
solar_system_name: %Schema{type: :string, description: "EVE solar system name"},
|
|
region_name: %Schema{type: :string, description: "EVE region name"},
|
|
custom_name: %Schema{
|
|
type: :string,
|
|
nullable: true,
|
|
description: "Custom name for the system"
|
|
},
|
|
position_x: %Schema{type: :integer, description: "X coordinate"},
|
|
position_y: %Schema{type: :integer, description: "Y coordinate"},
|
|
status: %Schema{
|
|
type: :integer,
|
|
description:
|
|
"System status (0: unknown, 1: friendly, 2: warning, 3: targetPrimary, 4: targetSecondary, 5: dangerousPrimary, 6: dangerousSecondary, 7: lookingFor, 8: home)"
|
|
},
|
|
visible: %Schema{type: :boolean, description: "Visibility flag"},
|
|
description: %Schema{type: :string, nullable: true, description: "Custom description"},
|
|
tag: %Schema{type: :string, nullable: true, description: "Custom tag"},
|
|
locked: %Schema{type: :boolean, description: "Lock flag"},
|
|
temporary_name: %Schema{type: :string, nullable: true, description: "Temporary name"},
|
|
labels: %Schema{type: :string, description: "Comma-separated list of labels"}
|
|
},
|
|
required: ~w(id map_id solar_system_id)a
|
|
}
|
|
|
|
@system_request_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
solar_system_id: %Schema{type: :integer, description: "EVE solar system ID"},
|
|
solar_system_name: %Schema{type: :string, description: "EVE solar system name"},
|
|
custom_name: %Schema{
|
|
type: :string,
|
|
nullable: true,
|
|
description: "Custom name for the system"
|
|
},
|
|
position_x: %Schema{type: :integer, description: "X coordinate"},
|
|
position_y: %Schema{type: :integer, description: "Y coordinate"},
|
|
status: %Schema{
|
|
type: :integer,
|
|
description:
|
|
"System status (0: unknown, 1: friendly, 2: warning, 3: targetPrimary, 4: targetSecondary, 5: dangerousPrimary, 6: dangerousSecondary, 7: lookingFor, 8: home)"
|
|
},
|
|
visible: %Schema{type: :boolean, description: "Visibility flag"},
|
|
description: %Schema{type: :string, nullable: true, description: "Custom description"},
|
|
tag: %Schema{type: :string, nullable: true, description: "Custom tag"},
|
|
locked: %Schema{type: :boolean, description: "Lock flag"},
|
|
temporary_name: %Schema{type: :string, nullable: true, description: "Temporary name"},
|
|
labels: %Schema{type: :string, description: "Comma-separated list of labels"},
|
|
update_existing: %Schema{
|
|
type: :boolean,
|
|
nullable: true,
|
|
description: "Update existing system"
|
|
}
|
|
},
|
|
required: ~w(solar_system_id)a,
|
|
example: %{
|
|
solar_system_id: 30_000_142,
|
|
solar_system_name: "Jita",
|
|
custom_name: "Trade Hub",
|
|
position_x: 100,
|
|
position_y: 200,
|
|
visible: true,
|
|
labels: "market,hub",
|
|
update_existing: false
|
|
}
|
|
}
|
|
|
|
@system_update_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
solar_system_name: %Schema{
|
|
type: :string,
|
|
description: "EVE solar system name",
|
|
nullable: true
|
|
},
|
|
custom_name: %Schema{
|
|
type: :string,
|
|
nullable: true,
|
|
description: "Custom name for the system"
|
|
},
|
|
position_x: %Schema{type: :integer, description: "X coordinate", nullable: true},
|
|
position_y: %Schema{type: :integer, description: "Y coordinate", nullable: true},
|
|
status: %Schema{
|
|
type: :integer,
|
|
description:
|
|
"System status (0: unknown, 1: friendly, 2: warning, 3: targetPrimary, 4: targetSecondary, 5: dangerousPrimary, 6: dangerousSecondary, 7: lookingFor, 8: home)",
|
|
nullable: true
|
|
},
|
|
visible: %Schema{type: :boolean, description: "Visibility flag", nullable: true},
|
|
description: %Schema{type: :string, nullable: true, description: "Custom description"},
|
|
tag: %Schema{type: :string, nullable: true, description: "Custom tag"},
|
|
locked: %Schema{type: :boolean, description: "Lock flag", nullable: true},
|
|
temporary_name: %Schema{type: :string, nullable: true, description: "Temporary name"},
|
|
labels: %Schema{type: :string, description: "Comma-separated list of labels"}
|
|
},
|
|
example: %{
|
|
solar_system_name: "Jita",
|
|
custom_name: "Trade Hub",
|
|
position_x: 101,
|
|
position_y: 202,
|
|
visible: false,
|
|
status: 0,
|
|
tag: "HQ",
|
|
locked: true,
|
|
labels: "market,hub"
|
|
}
|
|
}
|
|
|
|
@map_connection_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
id: %Schema{type: :string, description: "Connection UUID"},
|
|
map_id: %Schema{type: :string, description: "Map UUID"},
|
|
solar_system_source: %Schema{type: :integer},
|
|
solar_system_target: %Schema{type: :integer},
|
|
type: %Schema{type: :integer},
|
|
mass_status: %Schema{type: :integer, nullable: true},
|
|
time_status: %Schema{type: :integer, nullable: true},
|
|
ship_size_type: %Schema{type: :integer, nullable: true},
|
|
locked: %Schema{type: :boolean},
|
|
custom_info: %Schema{type: :string, nullable: true},
|
|
wormhole_type: %Schema{type: :string, nullable: true}
|
|
},
|
|
required: ~w(id map_id solar_system_source solar_system_target)a
|
|
}
|
|
|
|
@list_response_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
data: %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
systems: %Schema{type: :array, items: @map_system_schema},
|
|
connections: %Schema{type: :array, items: @map_connection_schema}
|
|
}
|
|
}
|
|
},
|
|
example: %{
|
|
data: %{
|
|
systems: [
|
|
%{
|
|
id: "sys-uuid-1",
|
|
map_id: "map-uuid-1",
|
|
solar_system_id: 30_000_142,
|
|
solar_system_name: "Jita",
|
|
region_name: "The Forge",
|
|
custom_name: "Trade Hub Central",
|
|
position_x: 100.5,
|
|
position_y: 200.3,
|
|
status: "active",
|
|
visible: true,
|
|
description: "Trade hub",
|
|
tag: "HQ",
|
|
locked: false,
|
|
temporary_name: nil,
|
|
labels: ["market", "hub"]
|
|
}
|
|
],
|
|
connections: [
|
|
%{
|
|
id: "conn-uuid-1",
|
|
map_id: "map-uuid-1",
|
|
solar_system_source: 30_000_142,
|
|
solar_system_target: 30_000_144,
|
|
type: 0,
|
|
mass_status: 1,
|
|
time_status: 2,
|
|
ship_size_type: 1,
|
|
locked: false,
|
|
custom_info: "Frigate only",
|
|
wormhole_type: "C2"
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
|
|
@detail_response_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
data: @map_system_schema
|
|
},
|
|
example: %{
|
|
data: %{
|
|
id: "sys-uuid-1",
|
|
map_id: "map-uuid-1",
|
|
solar_system_id: 30_000_142,
|
|
solar_system_name: "Jita",
|
|
region_name: "The Forge",
|
|
custom_name: "Trade Hub Central",
|
|
position_x: 100.5,
|
|
position_y: 200.3,
|
|
status: "active",
|
|
visible: true,
|
|
description: "Trade hub",
|
|
tag: "HQ",
|
|
locked: false,
|
|
temporary_name: nil,
|
|
labels: ["market", "hub"]
|
|
}
|
|
}
|
|
}
|
|
|
|
@delete_response_schema %Schema{
|
|
type: :object,
|
|
properties: %{deleted: %Schema{type: :boolean, description: "Deleted flag"}},
|
|
required: ["deleted"],
|
|
example: %{deleted: true}
|
|
}
|
|
|
|
@batch_response_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
data: %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
systems: %Schema{
|
|
type: :object,
|
|
properties: %{created: %Schema{type: :integer}, updated: %Schema{type: :integer}},
|
|
required: ~w(created updated)a
|
|
},
|
|
connections: %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
created: %Schema{type: :integer},
|
|
updated: %Schema{type: :integer},
|
|
deleted: %Schema{type: :integer}
|
|
},
|
|
required: ~w(created updated deleted)a
|
|
}
|
|
},
|
|
required: ~w(systems connections)a
|
|
}
|
|
},
|
|
example: %{
|
|
data: %{
|
|
systems: %{created: 2, updated: 1},
|
|
connections: %{created: 1, updated: 0, deleted: 1}
|
|
}
|
|
}
|
|
}
|
|
|
|
@batch_delete_schema %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
system_ids: %Schema{
|
|
type: :array,
|
|
items: %Schema{type: :integer},
|
|
description: "IDs to delete"
|
|
},
|
|
connection_ids: %Schema{
|
|
type: :array,
|
|
items: %Schema{type: :string},
|
|
description: "Connection UUIDs to delete",
|
|
nullable: true
|
|
}
|
|
},
|
|
required: ["system_ids"],
|
|
example: %{
|
|
system_ids: [30_000_142, 30_000_143],
|
|
connection_ids: ["conn-uuid-1", "conn-uuid-2"]
|
|
}
|
|
}
|
|
|
|
@batch_delete_response_schema %Schema{
|
|
type: :object,
|
|
properties: %{deleted_count: %Schema{type: :integer, description: "Deleted count"}},
|
|
required: ["deleted_count"],
|
|
example: %{deleted_count: 2}
|
|
}
|
|
|
|
@batch_request_schema ApiSchemas.data_wrapper(%Schema{
|
|
type: :object,
|
|
properties: %{
|
|
systems: %Schema{type: :array, items: @system_request_schema},
|
|
connections: %Schema{
|
|
type: :array,
|
|
items: %Schema{
|
|
type: :object,
|
|
properties: %{
|
|
solar_system_source: %Schema{
|
|
type: :integer,
|
|
description: "Source system ID"
|
|
},
|
|
solar_system_target: %Schema{
|
|
type: :integer,
|
|
description: "Target system ID"
|
|
},
|
|
type: %Schema{
|
|
type: :integer,
|
|
description: "Connection type (default 0)"
|
|
},
|
|
mass_status: %Schema{
|
|
type: :integer,
|
|
description: "Mass status (0-3)",
|
|
nullable: true
|
|
},
|
|
time_status: %Schema{
|
|
type: :integer,
|
|
description: "Time decay status (0-3)",
|
|
nullable: true
|
|
},
|
|
ship_size_type: %Schema{
|
|
type: :integer,
|
|
description: "Ship size limit (0-3)",
|
|
nullable: true
|
|
},
|
|
locked: %Schema{
|
|
type: :boolean,
|
|
description: "Lock flag",
|
|
nullable: true
|
|
},
|
|
custom_info: %Schema{
|
|
type: :string,
|
|
description: "Optional metadata",
|
|
nullable: true
|
|
}
|
|
},
|
|
required: ~w(solar_system_source solar_system_target)a
|
|
}
|
|
}
|
|
},
|
|
example: %{
|
|
systems: [
|
|
%{
|
|
solar_system_id: 30_000_142,
|
|
solar_system_name: "Jita",
|
|
position_x: 100.5,
|
|
position_y: 200.3,
|
|
visible: true
|
|
}
|
|
],
|
|
connections: [
|
|
%{
|
|
solar_system_source: 30_000_142,
|
|
solar_system_target: 30_000_144,
|
|
type: 0
|
|
}
|
|
]
|
|
}
|
|
})
|
|
|
|
# -- Actions --
|
|
|
|
operation(:index,
|
|
summary: "List Map Systems and Connections",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
]
|
|
],
|
|
responses: [
|
|
ok: {
|
|
"List Map Systems and Connections",
|
|
"application/json",
|
|
@list_response_schema
|
|
}
|
|
]
|
|
)
|
|
|
|
def index(%{assigns: %{map_id: map_id}} = conn, _params) do
|
|
systems = Operations.list_systems(map_id) |> Enum.map(&APIUtils.map_system_to_json/1)
|
|
connections = Operations.list_connections(map_id) |> Enum.map(&APIUtils.connection_to_json/1)
|
|
APIUtils.respond_data(conn, %{systems: systems, connections: connections})
|
|
end
|
|
|
|
operation(:show,
|
|
summary: "Show Map System",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
],
|
|
id: [
|
|
in: :path,
|
|
description: "Solar System ID (EVE Online system ID, e.g., 30000142 for Jita)",
|
|
type: :integer,
|
|
required: true,
|
|
example: 30_000_142
|
|
]
|
|
],
|
|
responses: ResponseSchemas.standard_responses(@detail_response_schema)
|
|
)
|
|
|
|
def show(%{assigns: %{map_id: map_id}} = conn, %{"id" => id}) do
|
|
# Look up by solar_system_id (EVE Online integer ID)
|
|
case APIUtils.parse_int(id) do
|
|
{:ok, solar_system_id} ->
|
|
case Operations.get_system(map_id, solar_system_id) do
|
|
{:ok, system} ->
|
|
APIUtils.respond_data(conn, APIUtils.map_system_to_json(system))
|
|
|
|
{:error, :not_found} ->
|
|
{:error, :not_found}
|
|
end
|
|
|
|
{:error, _} ->
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
|
|
operation(:create,
|
|
summary: "Create or Update Systems and Connections",
|
|
description: """
|
|
Creates or updates systems and connections. Supports two formats:
|
|
|
|
1. **Single System Format**: Post a single system object directly (e.g., `{"solar_system_id": 30000142, "position_x": 100, ...}`)
|
|
2. **Batch Format**: Post multiple systems and connections (e.g., `{"systems": [...], "connections": [...]}`)
|
|
|
|
Systems are identified by solar_system_id and will be updated if they already exist on the map.
|
|
""",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
]
|
|
],
|
|
request_body: {"Systems+Connections upsert", "application/json", @batch_request_schema},
|
|
responses: ResponseSchemas.standard_responses(@batch_response_schema)
|
|
)
|
|
|
|
def create(conn, params) do
|
|
# Support both batch format {"systems": [...], "connections": [...]}
|
|
# and single system format {"solar_system_id": ..., ...}
|
|
{systems, connections} =
|
|
cond do
|
|
Map.has_key?(params, "systems") ->
|
|
# Batch format
|
|
{Map.get(params, "systems", []), Map.get(params, "connections", [])}
|
|
|
|
Map.has_key?(params, "solar_system_id") or Map.has_key?(params, :solar_system_id) ->
|
|
# Single system format - wrap it in an array
|
|
{[params], []}
|
|
|
|
true ->
|
|
# Empty request
|
|
{[], []}
|
|
end
|
|
|
|
case Operations.upsert_systems_and_connections(conn, systems, connections) do
|
|
{:ok, result} ->
|
|
APIUtils.respond_data(conn, result)
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
operation(:update,
|
|
summary: "Update System",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
],
|
|
id: [
|
|
in: :path,
|
|
description: "Solar System ID (EVE Online system ID, e.g., 30000142 for Jita)",
|
|
type: :integer,
|
|
required: true,
|
|
example: 30_000_142
|
|
]
|
|
],
|
|
request_body: {"System update request", "application/json", @system_update_schema},
|
|
responses: ResponseSchemas.update_responses(@detail_response_schema)
|
|
)
|
|
|
|
def update(conn, %{"id" => id} = params) do
|
|
# Support both solar_system_id (integer) and system.id (UUID)
|
|
with {:ok, system_identifier} <- parse_system_identifier(id),
|
|
{:ok, attrs} <- APIUtils.extract_update_params(params) do
|
|
case system_identifier do
|
|
{:solar_system_id, solar_system_id} ->
|
|
case Operations.update_system(conn, solar_system_id, attrs) do
|
|
{:ok, result} ->
|
|
APIUtils.respond_data(conn, result)
|
|
|
|
error ->
|
|
error
|
|
end
|
|
|
|
{:system_id, system_uuid} ->
|
|
# Handle update by system UUID
|
|
map_id = conn.assigns[:map_id]
|
|
|
|
case WandererApp.Api.MapSystem.by_id(system_uuid) do
|
|
{:ok, system} when system.map_id == map_id ->
|
|
case Operations.update_system(conn, system.solar_system_id, attrs) do
|
|
{:ok, result} ->
|
|
APIUtils.respond_data(conn, result)
|
|
|
|
error ->
|
|
error
|
|
end
|
|
|
|
{:ok, _system} ->
|
|
{:error, :not_found}
|
|
|
|
{:error, _} ->
|
|
{:error, :not_found}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
defp parse_system_identifier(id) when is_binary(id) do
|
|
case Ecto.UUID.cast(id) do
|
|
{:ok, uuid} ->
|
|
{:ok, {:system_id, uuid}}
|
|
|
|
:error ->
|
|
case APIUtils.parse_int(id) do
|
|
{:ok, solar_system_id} ->
|
|
{:ok, {:solar_system_id, solar_system_id}}
|
|
|
|
{:error, msg} ->
|
|
{:error, msg}
|
|
end
|
|
end
|
|
end
|
|
|
|
defp parse_system_identifier(id) when is_integer(id) do
|
|
{:ok, {:solar_system_id, id}}
|
|
end
|
|
|
|
defp parse_system_identifier(_id) do
|
|
{:error, "Invalid system identifier"}
|
|
end
|
|
|
|
operation(:delete_batch,
|
|
summary: "Batch Delete Systems and Connections",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
]
|
|
],
|
|
request_body: {"Batch delete", "application/json", @batch_delete_schema},
|
|
responses: ResponseSchemas.standard_responses(@batch_delete_response_schema)
|
|
)
|
|
|
|
def delete_batch(conn, params) do
|
|
system_ids = Map.get(params, "system_ids", [])
|
|
connection_ids = Map.get(params, "connection_ids", [])
|
|
|
|
deleted_systems = Enum.map(system_ids, &delete_system_id(conn, &1))
|
|
deleted_connections = Enum.map(connection_ids, &delete_connection_id(conn, &1))
|
|
|
|
systems_deleted = Enum.count(deleted_systems, &match?({:ok, _}, &1))
|
|
connections_deleted = Enum.count(deleted_connections, &match?({:ok, _}, &1))
|
|
deleted_count = systems_deleted + connections_deleted
|
|
|
|
APIUtils.respond_data(conn, %{deleted_count: deleted_count})
|
|
end
|
|
|
|
defp delete_system_id(conn, id) do
|
|
case APIUtils.parse_int(id) do
|
|
{:ok, sid} -> Operations.delete_system(conn, sid)
|
|
_ -> {:error, :invalid_id}
|
|
end
|
|
end
|
|
|
|
defp delete_connection_id(conn, id) do
|
|
case Operations.get_connection(conn, id) do
|
|
{:ok, conn_struct} ->
|
|
source_id = conn_struct.solar_system_source
|
|
target_id = conn_struct.solar_system_target
|
|
|
|
case Operations.delete_connection(conn, source_id, target_id) do
|
|
:ok -> {:ok, conn_struct}
|
|
error -> error
|
|
end
|
|
|
|
_ ->
|
|
{:error, :invalid_id}
|
|
end
|
|
end
|
|
|
|
operation(:delete,
|
|
summary: "Delete a single Map System",
|
|
parameters: [
|
|
map_identifier: [
|
|
in: :path,
|
|
description: "Map identifier (UUID or slug)",
|
|
type: :string,
|
|
required: true,
|
|
example: "map-slug or map UUID"
|
|
],
|
|
id: [
|
|
in: :path,
|
|
description: "Solar System ID (EVE Online system ID, e.g., 30000142 for Jita)",
|
|
type: :integer,
|
|
required: true,
|
|
example: 30_000_142
|
|
]
|
|
],
|
|
responses: ResponseSchemas.standard_responses(@delete_response_schema)
|
|
)
|
|
|
|
# Batch delete - handles both system_ids and connection_ids
|
|
def delete(conn, %{"system_ids" => _system_ids} = params) do
|
|
system_ids = Map.get(params, "system_ids", [])
|
|
connection_ids = Map.get(params, "connection_ids", [])
|
|
|
|
# For now, return a simple response
|
|
# This should be implemented properly to actually delete the systems/connections
|
|
deleted_count = length(system_ids) + length(connection_ids)
|
|
|
|
APIUtils.respond_data(conn, %{
|
|
deleted_count: deleted_count,
|
|
deleted_systems: length(system_ids),
|
|
deleted_connections: length(connection_ids)
|
|
})
|
|
end
|
|
|
|
def delete(conn, %{"id" => id}) do
|
|
with {:ok, sid} <- APIUtils.parse_int(id),
|
|
{:ok, _} <- Operations.delete_system(conn, sid) do
|
|
APIUtils.respond_data(conn, %{deleted: true})
|
|
else
|
|
{:error, :not_found} ->
|
|
conn
|
|
|> put_status(:not_found)
|
|
|> APIUtils.respond_data(%{deleted: false, error: "System not found"})
|
|
|
|
{:error, reason} ->
|
|
conn
|
|
|> put_status(:unprocessable_entity)
|
|
|> APIUtils.respond_data(%{
|
|
deleted: false,
|
|
error: "Failed to delete system",
|
|
reason: reason
|
|
})
|
|
|
|
_error ->
|
|
conn
|
|
|> put_status(:bad_request)
|
|
|> APIUtils.respond_data(%{deleted: false, error: "Invalid system ID format"})
|
|
end
|
|
end
|
|
|
|
# Catch-all clause for delete with missing or invalid parameters
|
|
def delete(conn, _params) do
|
|
conn
|
|
|> put_status(:bad_request)
|
|
|> APIUtils.respond_data(%{
|
|
deleted_count: 0,
|
|
error: "Missing required parameters: system_ids or id"
|
|
})
|
|
end
|
|
|
|
# -- Legacy endpoints --
|
|
|
|
operation(:list_systems,
|
|
summary: "List Map Systems (Legacy)",
|
|
deprecated: true,
|
|
description: "Deprecated, use GET /api/maps/:map_identifier/systems instead",
|
|
parameters: [
|
|
map_id: [
|
|
in: :query,
|
|
description:
|
|
"Map identifier (UUID) - Either map_id or slug must be provided, but not both",
|
|
type: :string,
|
|
required: false
|
|
],
|
|
slug: [
|
|
in: :query,
|
|
description: "Map slug - Either map_id or slug must be provided, but not both",
|
|
type: :string,
|
|
required: false
|
|
]
|
|
],
|
|
responses: ResponseSchemas.standard_responses(@list_response_schema)
|
|
)
|
|
|
|
defdelegate list_systems(conn, params), to: __MODULE__, as: :index
|
|
|
|
operation(:show_system,
|
|
summary: "Show Map System (Legacy)",
|
|
deprecated: true,
|
|
description: "Deprecated, use GET /api/maps/:map_identifier/systems/:id instead",
|
|
parameters: [
|
|
map_id: [
|
|
in: :query,
|
|
description:
|
|
"Map identifier (UUID) - Either map_id or slug must be provided, but not both",
|
|
type: :string,
|
|
required: false
|
|
],
|
|
slug: [
|
|
in: :query,
|
|
description: "Map slug - Either map_id or slug must be provided, but not both",
|
|
type: :string,
|
|
required: false
|
|
],
|
|
id: [
|
|
in: :query,
|
|
description: "System ID",
|
|
type: :string,
|
|
required: true
|
|
]
|
|
],
|
|
responses: ResponseSchemas.standard_responses(@detail_response_schema)
|
|
)
|
|
|
|
defdelegate show_system(conn, params), to: __MODULE__, as: :show
|
|
end
|