1768 lines
50 KiB
Gleam
1768 lines
50 KiB
Gleam
import gleam/dict.{type Dict}
|
|
import gleam/dynamic/decode.{type Decoder}
|
|
import gleam/json
|
|
import gleam/list
|
|
import gleam/option.{type Option}
|
|
import gleam/time/calendar.{type Date}
|
|
import gleam/time/timestamp.{type Timestamp}
|
|
import gleam/uri.{type Uri}
|
|
import spacetraders_models/account.{type Account}
|
|
import spacetraders_models/agent.{type Agent}
|
|
import spacetraders_models/agent_event.{type AgentEvent}
|
|
import spacetraders_models/agent_symbol.{type AgentSymbol}
|
|
import spacetraders_models/chart.{type Chart}
|
|
import spacetraders_models/chart_transaction.{type ChartTransaction}
|
|
import spacetraders_models/construction.{type Construction}
|
|
import spacetraders_models/contract.{type Contract}
|
|
import spacetraders_models/contract_id.{type ContractId}
|
|
import spacetraders_models/cooldown.{type Cooldown}
|
|
import spacetraders_models/extraction.{type Extraction}
|
|
import spacetraders_models/faction.{type Faction}
|
|
import spacetraders_models/faction_symbol.{type FactionSymbol}
|
|
import spacetraders_models/jump_gate.{type JumpGate}
|
|
import spacetraders_models/market.{type Market}
|
|
import spacetraders_models/market_transaction.{type MarketTransaction}
|
|
import spacetraders_models/module_symbol.{type ModuleSymbol}
|
|
import spacetraders_models/mount_symbol.{type MountSymbol}
|
|
import spacetraders_models/public_agent.{type PublicAgent}
|
|
import spacetraders_models/refinement_produce.{type RefinementProduce}
|
|
import spacetraders_models/refinement_yield.{type RefinementYield}
|
|
import spacetraders_models/repair_transaction.{type RepairTransaction}
|
|
import spacetraders_models/scanned_ship.{type ScannedShip}
|
|
import spacetraders_models/scanned_system.{type ScannedSystem}
|
|
import spacetraders_models/scanned_waypoint.{type ScannedWaypoint}
|
|
import spacetraders_models/scrap_transaction.{type ScrapTransaction}
|
|
import spacetraders_models/ship.{type Ship}
|
|
import spacetraders_models/ship_cargo.{type ShipCargo}
|
|
import spacetraders_models/ship_condition_event.{type ShipConditionEvent}
|
|
import spacetraders_models/ship_fuel.{type ShipFuel}
|
|
import spacetraders_models/ship_modification_transaction.{
|
|
type ShipModificationTransaction,
|
|
}
|
|
import spacetraders_models/ship_module.{type ShipModule}
|
|
import spacetraders_models/ship_mount.{type ShipMount}
|
|
import spacetraders_models/ship_nav.{type ShipNav}
|
|
import spacetraders_models/ship_nav_flight_mode.{type ShipNavFlightMode}
|
|
import spacetraders_models/ship_symbol.{type ShipSymbol}
|
|
import spacetraders_models/ship_type.{type ShipType}
|
|
import spacetraders_models/shipyard.{type Shipyard}
|
|
import spacetraders_models/shipyard_transaction.{type ShipyardTransaction}
|
|
import spacetraders_models/siphon.{type Siphon}
|
|
import spacetraders_models/survey.{type Survey}
|
|
import spacetraders_models/system.{type System}
|
|
import spacetraders_models/system_symbol.{type SystemSymbol}
|
|
import spacetraders_models/trade_symbol.{type TradeSymbol}
|
|
import spacetraders_models/waypoint.{type Waypoint}
|
|
import spacetraders_models/waypoint_modifier.{type WaypointModifier}
|
|
import spacetraders_models/waypoint_symbol.{type WaypointSymbol}
|
|
import spacetraders_models/waypoint_trait_symbol.{type WaypointTraitSymbol}
|
|
import spacetraders_models/waypoint_type.{type WaypointType}
|
|
import spacetraders_sdk.{
|
|
type AccountToken, type AgentToken, type ApiResponse, type PagedData,
|
|
AccountAuth, AgentAuth, NoAuth,
|
|
}
|
|
import spacetraders_sdk/internal/api
|
|
import spacetraders_sdk/internal/time
|
|
|
|
pub fn get_account(token: AgentToken) -> ApiResponse(Account) {
|
|
let request = api.get(AgentAuth(token), "/my/account")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("account", account.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type AgentRegistered {
|
|
AgentRegistered(
|
|
token: AgentToken,
|
|
agent: Agent,
|
|
faction: Faction,
|
|
contract: Contract,
|
|
ships: List(Ship),
|
|
)
|
|
}
|
|
|
|
pub fn register_new_agent(
|
|
token: AccountToken,
|
|
agent_symbol: AgentSymbol,
|
|
faction_symbol: FactionSymbol,
|
|
) -> ApiResponse(AgentRegistered) {
|
|
let request =
|
|
api.post_json(
|
|
AccountAuth(token),
|
|
"/register",
|
|
json.object([
|
|
#("symbol", agent_symbol.encode(agent_symbol)),
|
|
#("faction", faction_symbol.encode(faction_symbol)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use token <- decode.field(
|
|
"token",
|
|
spacetraders_sdk.agent_token_decoder(),
|
|
)
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use faction <- decode.field("faction", faction.decoder())
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use ships <- decode.field("ships", decode.list(ship.decoder()))
|
|
decode.success(AgentRegistered(
|
|
token:,
|
|
agent:,
|
|
faction:,
|
|
contract:,
|
|
ships:,
|
|
))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_public_agents(
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(PublicAgent))) {
|
|
let request = api.get_page(NoAuth, "/agents", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(
|
|
response,
|
|
decode.list(public_agent.decoder()),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_public_agent(agent_symbol: AgentSymbol) -> ApiResponse(PublicAgent) {
|
|
let request =
|
|
api.get(NoAuth, "/agents/" <> agent_symbol.to_string(agent_symbol))
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, public_agent.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_agent(token: AgentToken) -> ApiResponse(Agent) {
|
|
let request = api.get(AgentAuth(token), "/my/agent")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, agent.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_agent_events(token: AgentToken) -> ApiResponse(List(AgentEvent)) {
|
|
let request = api.get(AgentAuth(token), "/my/agent/events")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, decode.list(agent_event.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_contracts(
|
|
token: AgentToken,
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(Contract))) {
|
|
let request = api.get_page(AgentAuth(token), "/my/contracts", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(response, decode.list(contract.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(Contract) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/contracts/" <> contract_id.to_string(contract_id),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, contract.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ContractAccepted {
|
|
ContractAccepted(contract: Contract, agent: Agent)
|
|
}
|
|
|
|
pub fn accept_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(ContractAccepted) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/contracts/" <> contract_id.to_string(contract_id) <> "/accept",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(ContractAccepted(contract:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ContractFulfilled {
|
|
ContractFulfilled(contract: Contract, agent: Agent)
|
|
}
|
|
|
|
pub fn fulfill_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(ContractFulfilled) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/contracts/" <> contract_id.to_string(contract_id) <> "/fulfill",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(ContractFulfilled(contract:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ContractCargoDelivered {
|
|
ContractCargoDelivered(contract: Contract, cargo: ShipCargo)
|
|
}
|
|
|
|
pub fn deliver_contract_cargo(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
) -> ApiResponse(ContractCargoDelivered) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/contracts/" <> contract_id.to_string(contract_id) <> "/deliver",
|
|
json.object([
|
|
#("shipSymbol", ship_symbol.encode(ship_symbol)),
|
|
#("tradeSymbol", trade_symbol.encode(trade_symbol)),
|
|
#("units", json.int(units)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
decode.success(ContractCargoDelivered(contract:, cargo:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ExportToImportMap =
|
|
Dict(TradeSymbol, List(TradeSymbol))
|
|
|
|
pub fn get_supply_chain() -> ApiResponse(ExportToImportMap) {
|
|
let request = api.get(NoAuth, "/market/supply-chain")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field(
|
|
"exportToImportMap",
|
|
decode.dict(
|
|
trade_symbol.decoder(),
|
|
decode.list(trade_symbol.decoder()),
|
|
),
|
|
decode.success,
|
|
),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_factions(
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(Faction))) {
|
|
let request = api.get_page(NoAuth, "/factions", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(response, decode.list(faction.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_faction(symbol: FactionSymbol) -> ApiResponse(Faction) {
|
|
let request =
|
|
api.get(NoAuth, "/factions/" <> faction_symbol.to_string(symbol))
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, faction.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type FactionReputation {
|
|
FactionReputation(symbol: FactionSymbol, reputation: Int)
|
|
}
|
|
|
|
pub fn get_my_factions(
|
|
token: AgentToken,
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(FactionReputation))) {
|
|
let request = api.get_page(AgentAuth(token), "/my/factions", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(
|
|
response,
|
|
decode.list({
|
|
use symbol <- decode.field("symbol", faction_symbol.decoder())
|
|
use reputation <- decode.field("reputation", decode.int)
|
|
decode.success(FactionReputation(symbol:, reputation:))
|
|
}),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_ships(
|
|
token: AgentToken,
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(Ship))) {
|
|
let request = api.get_page(AgentAuth(token), "/my/ships", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_paged_data_response(response, decode.list(ship.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipPurchased {
|
|
ShipPurchased(ship: Ship, agent: Agent, transaction: ShipyardTransaction)
|
|
}
|
|
|
|
pub fn purchase_ship(
|
|
token: AgentToken,
|
|
ship_type: ShipType,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(ShipPurchased) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships",
|
|
json.object([
|
|
#("shipType", ship_type.encode(ship_type)),
|
|
#("waypointSymbol", waypoint_symbol.encode(waypoint_symbol)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use ship <- decode.field("ship", ship.decoder())
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
shipyard_transaction.decoder(),
|
|
)
|
|
decode.success(ShipPurchased(ship:, agent:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship(token: AgentToken, ship_symbol: ShipSymbol) -> ApiResponse(Ship) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, ship.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ChartCreated {
|
|
ChartCreated(
|
|
chart: Chart,
|
|
waypoint: Waypoint,
|
|
transaction: ChartTransaction,
|
|
agent: Agent,
|
|
)
|
|
}
|
|
|
|
pub fn create_chart(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ChartCreated) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/chart",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use chart <- decode.field("chart", chart.decoder())
|
|
use waypoint <- decode.field("waypoint", waypoint.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
chart_transaction.decoder(),
|
|
)
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(ChartCreated(chart:, waypoint:, transaction:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn negotiate_contract(
|
|
token: AgentToken,
|
|
ship_symbol: String,
|
|
) -> ApiResponse(Contract) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol <> "/negotiate/contract",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("contract", contract.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship_cooldown(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(Option(Cooldown)) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/cooldown",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("cooldown", cooldown.decoder(), fn(cooldown) {
|
|
decode.success(option.Some(cooldown))
|
|
}),
|
|
)
|
|
204 -> Ok(option.None)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn dock_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipNav) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/dock",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("nav", ship_nav.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ResourcesExtracted {
|
|
ResourcesExtracted(
|
|
extraction: Extraction,
|
|
cooldown: Cooldown,
|
|
cargo: ShipCargo,
|
|
modifiers: List(WaypointModifier),
|
|
events: List(ShipConditionEvent),
|
|
)
|
|
}
|
|
|
|
fn resources_extracted_decoder() -> Decoder(ResourcesExtracted) {
|
|
use extraction <- decode.field("extraction", extraction.decoder())
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use modifiers <- decode.field(
|
|
"modifiers",
|
|
decode.list(waypoint_modifier.decoder()),
|
|
)
|
|
use events <- decode.field(
|
|
"events",
|
|
decode.list(ship_condition_event.decoder()),
|
|
)
|
|
decode.success(ResourcesExtracted(
|
|
extraction:,
|
|
cooldown:,
|
|
cargo:,
|
|
modifiers:,
|
|
events:,
|
|
))
|
|
}
|
|
|
|
pub fn extract_resources(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ResourcesExtracted) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/extract",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 -> api.parse_data_response(response, resources_extracted_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn extract_resources_with_survey(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
survey: Survey,
|
|
) -> ApiResponse(ResourcesExtracted) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/extract/survey",
|
|
survey.encode(survey),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 -> api.parse_data_response(response, resources_extracted_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn jettison_cargo(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
) -> ApiResponse(ShipCargo) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/jettison",
|
|
json.object([
|
|
#("symbol", trade_symbol.encode(trade_symbol)),
|
|
#("units", json.int(units)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("cargo", ship_cargo.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipJumped {
|
|
ShipJumped(
|
|
nav: ShipNav,
|
|
cooldown: Cooldown,
|
|
transaction: MarketTransaction,
|
|
agent: Agent,
|
|
)
|
|
}
|
|
|
|
pub fn jump_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(ShipJumped) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/jump",
|
|
json.object([#("waypointSymbol", waypoint_symbol.encode(waypoint_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use nav <- decode.field("nav", ship_nav.decoder())
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
market_transaction.decoder(),
|
|
)
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(ShipJumped(nav:, cooldown:, transaction:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type Scan(data) {
|
|
Scan(cooldown: Cooldown, data: List(data))
|
|
}
|
|
|
|
fn scan_decoder(field: String, decoder: Decoder(data)) -> Decoder(Scan(data)) {
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use data <- decode.field(field, decode.list(decoder))
|
|
decode.success(Scan(cooldown:, data:))
|
|
}
|
|
|
|
pub fn scan_systems(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(Scan(ScannedSystem)) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/scan/systems",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(
|
|
response,
|
|
scan_decoder("systems", scanned_system.decoder()),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn scan_waypoints(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(Scan(ScannedWaypoint)) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/scan/waypoints",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(
|
|
response,
|
|
scan_decoder("waypoints", scanned_waypoint.decoder()),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn scan_ships(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(Scan(ScannedShip)) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/scan/ships",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(
|
|
response,
|
|
scan_decoder("ships", scanned_ship.decoder()),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipScrapped {
|
|
ShipScrapped(agent: Agent, transaction: ScrapTransaction)
|
|
}
|
|
|
|
pub fn scrap_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipScrapped) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/scrap",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
scrap_transaction.decoder(),
|
|
)
|
|
decode.success(ShipScrapped(agent:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_scrap_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ScrapTransaction) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/scrap",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("transaction", scrap_transaction.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipNavigated {
|
|
ShipNavigated(nav: ShipNav, fuel: ShipFuel, events: List(ShipConditionEvent))
|
|
}
|
|
|
|
pub fn navigate_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(ShipNavigated) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/navigate",
|
|
json.object([#("waypointSymbol", waypoint_symbol.encode(waypoint_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use nav <- decode.field("nav", ship_nav.decoder())
|
|
use fuel <- decode.field("fuel", ship_fuel.decoder())
|
|
use events <- decode.field(
|
|
"events",
|
|
decode.list(ship_condition_event.decoder()),
|
|
)
|
|
decode.success(ShipNavigated(nav:, fuel:, events:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipWarped {
|
|
ShipWarped(nav: ShipNav, fuel: ShipFuel, events: List(ShipConditionEvent))
|
|
}
|
|
|
|
pub fn warp_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(ShipWarped) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/warp",
|
|
json.object([#("waypointSymbol", waypoint_symbol.encode(waypoint_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use nav <- decode.field("nav", ship_nav.decoder())
|
|
use fuel <- decode.field("fuel", ship_fuel.decoder())
|
|
use events <- decode.field(
|
|
"events",
|
|
decode.list(ship_condition_event.decoder()),
|
|
)
|
|
decode.success(ShipWarped(nav:, fuel:, events:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn orbit_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipNav) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/orbit",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field("nav", ship_nav.decoder(), decode.success),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type CargoPurchased {
|
|
CargoPurchased(cargo: ShipCargo, transaction: MarketTransaction, agent: Agent)
|
|
}
|
|
|
|
pub fn purchase_cargo(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
) -> ApiResponse(CargoPurchased) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/purchase",
|
|
json.object([#("symbol", trade_symbol.encode(trade_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
market_transaction.decoder(),
|
|
)
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(CargoPurchased(cargo:, transaction:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipRefined {
|
|
ShipRefined(
|
|
cargo: ShipCargo,
|
|
cooldown: Cooldown,
|
|
produced: List(RefinementYield),
|
|
consumed: List(RefinementYield),
|
|
)
|
|
}
|
|
|
|
pub fn refine_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
produce: RefinementProduce,
|
|
) -> ApiResponse(ShipRefined) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/refine",
|
|
json.object([#("produce", refinement_produce.encode(produce))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use produced <- decode.field(
|
|
"produced",
|
|
decode.list(refinement_yield.decoder()),
|
|
)
|
|
use consumed <- decode.field(
|
|
"consumed",
|
|
decode.list(refinement_yield.decoder()),
|
|
)
|
|
decode.success(ShipRefined(cargo:, cooldown:, produced:, consumed:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipRefueled {
|
|
ShipRefueled(
|
|
agent: Agent,
|
|
fuel: ShipFuel,
|
|
cargo: ShipCargo,
|
|
transaction: MarketTransaction,
|
|
)
|
|
}
|
|
|
|
pub fn refuel_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
units: Option(Int),
|
|
from_cargo: Option(Bool),
|
|
) -> ApiResponse(ShipRefueled) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/refuel",
|
|
json.object([
|
|
#("units", json.nullable(units, json.int)),
|
|
#("fromCargo", json.nullable(from_cargo, json.bool)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use fuel <- decode.field("fuel", ship_fuel.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
market_transaction.decoder(),
|
|
)
|
|
decode.success(ShipRefueled(agent:, fuel:, cargo:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipRepaired {
|
|
ShipRepaired(agent: Agent, ship: Ship, transaction: RepairTransaction)
|
|
}
|
|
|
|
pub fn repair_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipRepaired) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/repair",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use ship <- decode.field("ship", ship.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
repair_transaction.decoder(),
|
|
)
|
|
decode.success(ShipRepaired(agent:, ship:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_repair_ship(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(RepairTransaction) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/repair",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(
|
|
response,
|
|
decode.field(
|
|
"transaction",
|
|
repair_transaction.decoder(),
|
|
decode.success,
|
|
),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type CargoSold {
|
|
CargoSold(cargo: ShipCargo, transaction: MarketTransaction, agent: Agent)
|
|
}
|
|
|
|
pub fn sell_cargo(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
) -> ApiResponse(CargoSold) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/sell",
|
|
json.object([
|
|
#("symbol", trade_symbol.encode(trade_symbol)),
|
|
#("units", json.int(units)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
market_transaction.decoder(),
|
|
)
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(CargoSold(cargo:, transaction:, agent:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ResourcesSiphoned {
|
|
ResourcesSiphoned(
|
|
siphon: Siphon,
|
|
cooldown: Cooldown,
|
|
cargo: ShipCargo,
|
|
events: List(ShipConditionEvent),
|
|
)
|
|
}
|
|
|
|
pub fn siphon_resources(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ResourcesSiphoned) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/siphon",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use siphon <- decode.field("siphon", siphon.decoder())
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use events <- decode.field(
|
|
"events",
|
|
decode.list(ship_condition_event.decoder()),
|
|
)
|
|
decode.success(ResourcesSiphoned(siphon:, cooldown:, cargo:, events:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type SurveyCreated {
|
|
SurveyCreated(cooldown: Cooldown, surveys: List(Survey))
|
|
}
|
|
|
|
pub fn create_survey(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(SurveyCreated) {
|
|
let request =
|
|
api.post(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/survey",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use cooldown <- decode.field("cooldown", cooldown.decoder())
|
|
use surveys <- decode.field("surveys", decode.list(survey.decoder()))
|
|
decode.success(SurveyCreated(cooldown:, surveys:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type CargoTransferred {
|
|
CargoTransferred(cargo: ShipCargo, target_cargo: ShipCargo)
|
|
}
|
|
|
|
pub fn transfer_cargo(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
target_ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(CargoTransferred) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/transfer",
|
|
json.object([
|
|
#("tradeSymbol", trade_symbol.encode(trade_symbol)),
|
|
#("units", json.int(units)),
|
|
#("shipSymbol", ship_symbol.encode(target_ship_symbol)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use target_cargo <- decode.field("targetCargo", ship_cargo.decoder())
|
|
decode.success(CargoTransferred(cargo:, target_cargo:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship_cargo(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipCargo) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/cargo",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, ship_cargo.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship_modules(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(List(ShipModule)) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/modules",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, decode.list(ship_module.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipModuleInstalled {
|
|
ShipModuleInstalled(
|
|
agent: Agent,
|
|
modules: List(ShipModule),
|
|
cargo: ShipCargo,
|
|
transaction: ShipModificationTransaction,
|
|
)
|
|
}
|
|
|
|
pub fn install_ship_module(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
module_symbol: ModuleSymbol,
|
|
) -> ApiResponse(ShipModuleInstalled) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/modules/install",
|
|
json.object([#("symbol", module_symbol.encode(module_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use modules <- decode.field(
|
|
"modules",
|
|
decode.list(ship_module.decoder()),
|
|
)
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
ship_modification_transaction.decoder(),
|
|
)
|
|
decode.success(ShipModuleInstalled(
|
|
agent:,
|
|
modules:,
|
|
cargo:,
|
|
transaction:,
|
|
))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipModuleRemoved {
|
|
ShipModuleRemoved(
|
|
agent: Agent,
|
|
modules: List(ShipModule),
|
|
cargo: ShipCargo,
|
|
transaction: ShipModificationTransaction,
|
|
)
|
|
}
|
|
|
|
pub fn remove_ship_module(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
module_symbol: ModuleSymbol,
|
|
) -> ApiResponse(ShipModuleRemoved) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/modules/remove",
|
|
json.object([#("symbol", module_symbol.encode(module_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use modules <- decode.field(
|
|
"modules",
|
|
decode.list(ship_module.decoder()),
|
|
)
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
ship_modification_transaction.decoder(),
|
|
)
|
|
decode.success(ShipModuleRemoved(agent:, modules:, cargo:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship_mounts(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(List(ShipMount)) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/mounts",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, decode.list(ship_mount.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipMountInstalled {
|
|
ShipMountInstalled(
|
|
agent: Agent,
|
|
mounts: List(ShipMount),
|
|
cargo: ShipCargo,
|
|
transaction: ShipModificationTransaction,
|
|
)
|
|
}
|
|
|
|
pub fn install_ship_mount(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
mount_symbol: MountSymbol,
|
|
) -> ApiResponse(ShipMountInstalled) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/mounts/install",
|
|
json.object([#("symbol", mount_symbol.encode(mount_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use mounts <- decode.field("mounts", decode.list(ship_mount.decoder()))
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
ship_modification_transaction.decoder(),
|
|
)
|
|
decode.success(ShipMountInstalled(agent:, mounts:, cargo:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipMountRemoved {
|
|
ShipMountRemoved(
|
|
agent: Agent,
|
|
mounts: List(ShipMount),
|
|
cargo: ShipCargo,
|
|
transaction: ShipModificationTransaction,
|
|
)
|
|
}
|
|
|
|
pub fn remove_ship_mount(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
mount_symbol: MountSymbol,
|
|
) -> ApiResponse(ShipMountRemoved) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/mounts/remove",
|
|
json.object([#("symbol", mount_symbol.encode(mount_symbol))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
use mounts <- decode.field("mounts", decode.list(ship_mount.decoder()))
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
use transaction <- decode.field(
|
|
"transaction",
|
|
ship_modification_transaction.decoder(),
|
|
)
|
|
decode.success(ShipMountRemoved(agent:, mounts:, cargo:, transaction:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_ship_nav(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
) -> ApiResponse(ShipNav) {
|
|
let request =
|
|
api.get(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/nav",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, ship_nav.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ShipNavPatched {
|
|
ShipNavPatched(nav: ShipNav, fuel: ShipFuel, events: List(ShipConditionEvent))
|
|
}
|
|
|
|
pub fn patch_ship_nav(
|
|
token: AgentToken,
|
|
ship_symbol: ShipSymbol,
|
|
flight_mode: ShipNavFlightMode,
|
|
) -> ApiResponse(ShipNavPatched) {
|
|
let request =
|
|
api.patch_json(
|
|
AgentAuth(token),
|
|
"/my/ships/" <> ship_symbol.to_string(ship_symbol) <> "/nav",
|
|
json.object([#("flightMode", ship_nav_flight_mode.encode(flight_mode))]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_data_response(response, {
|
|
use nav <- decode.field("nav", ship_nav.decoder())
|
|
use fuel <- decode.field("fuel", ship_fuel.decoder())
|
|
use events <- decode.field(
|
|
"events",
|
|
decode.list(ship_condition_event.decoder()),
|
|
)
|
|
decode.success(ShipNavPatched(nav:, fuel:, events:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type Stats {
|
|
Stats(
|
|
accounts: Option(Int),
|
|
agents: Int,
|
|
ships: Int,
|
|
systems: Int,
|
|
waypoints: Int,
|
|
)
|
|
}
|
|
|
|
fn stats_decoder() -> Decoder(Stats) {
|
|
use accounts <- decode.optional_field(
|
|
"accounts",
|
|
option.None,
|
|
decode.optional(decode.int),
|
|
)
|
|
use agents <- decode.field("agents", decode.int)
|
|
use ships <- decode.field("ships", decode.int)
|
|
use systems <- decode.field("systems", decode.int)
|
|
use waypoints <- decode.field("waypoints", decode.int)
|
|
decode.success(Stats(accounts:, agents:, ships:, systems:, waypoints:))
|
|
}
|
|
|
|
pub type Health {
|
|
Health(last_market_update: Option(Timestamp))
|
|
}
|
|
|
|
fn health_decoder() -> Decoder(Health) {
|
|
use last_market_update <- decode.optional_field(
|
|
"lastMarketUpdate",
|
|
option.None,
|
|
decode.optional(time.rfc3339_timestamp_decoder()),
|
|
)
|
|
decode.success(Health(last_market_update:))
|
|
}
|
|
|
|
pub type CreditLeaderboardEntry {
|
|
CreditLeaderboardEntry(agent_symbol: AgentSymbol, credits: Int)
|
|
}
|
|
|
|
fn credit_leaderboard_entry_decoder() -> Decoder(CreditLeaderboardEntry) {
|
|
use agent_symbol <- decode.field("agentSymbol", agent_symbol.decoder())
|
|
use credits <- decode.field("credits", decode.int)
|
|
decode.success(CreditLeaderboardEntry(agent_symbol:, credits:))
|
|
}
|
|
|
|
pub type ChartLeaderboardEntry {
|
|
ChartLeaderboardEntry(agent_symbol: AgentSymbol, chart_count: Int)
|
|
}
|
|
|
|
fn chart_leaderboard_entry_decoder() -> Decoder(ChartLeaderboardEntry) {
|
|
use agent_symbol <- decode.field("agentSymbol", agent_symbol.decoder())
|
|
use chart_count <- decode.field("chartCount", decode.int)
|
|
decode.success(ChartLeaderboardEntry(agent_symbol:, chart_count:))
|
|
}
|
|
|
|
pub type Leaderboards {
|
|
Leaderboards(
|
|
most_credits: List(CreditLeaderboardEntry),
|
|
most_submitted_charts: List(ChartLeaderboardEntry),
|
|
)
|
|
}
|
|
|
|
fn leaderboards_decoder() -> Decoder(Leaderboards) {
|
|
use most_credits <- decode.field(
|
|
"mostCredits",
|
|
decode.list(credit_leaderboard_entry_decoder()),
|
|
)
|
|
use most_submitted_charts <- decode.field(
|
|
"mostSubmittedCharts",
|
|
decode.list(chart_leaderboard_entry_decoder()),
|
|
)
|
|
decode.success(Leaderboards(most_credits:, most_submitted_charts:))
|
|
}
|
|
|
|
pub type ServerResets {
|
|
ServerResets(next: Timestamp, frequency: String)
|
|
}
|
|
|
|
fn server_resets_decoder() -> Decoder(ServerResets) {
|
|
use next <- decode.field("next", time.rfc3339_timestamp_decoder())
|
|
use frequency <- decode.field("frequency", decode.string)
|
|
decode.success(ServerResets(next:, frequency:))
|
|
}
|
|
|
|
pub type Announcement {
|
|
Announcement(title: String, body: String)
|
|
}
|
|
|
|
fn announcement_decoder() -> Decoder(Announcement) {
|
|
use title <- decode.field("title", decode.string)
|
|
use body <- decode.field("body", decode.string)
|
|
decode.success(Announcement(title:, body:))
|
|
}
|
|
|
|
pub type Link {
|
|
Link(name: String, url: Uri)
|
|
}
|
|
|
|
fn link_decoder() -> Decoder(Link) {
|
|
use name <- decode.field("name", decode.string)
|
|
use url <- decode.field("url", {
|
|
use value <- decode.then(decode.string)
|
|
case uri.parse(value) {
|
|
Ok(time) -> decode.success(time)
|
|
Error(Nil) -> decode.failure(uri.empty, "Uri")
|
|
}
|
|
})
|
|
decode.success(Link(name:, url:))
|
|
}
|
|
|
|
pub type ServerStatus {
|
|
ServerStatus(
|
|
status: String,
|
|
version: String,
|
|
reset_date: Date,
|
|
description: String,
|
|
stats: Stats,
|
|
health: Health,
|
|
leaderboards: Leaderboards,
|
|
server_resets: ServerResets,
|
|
announcements: List(Announcement),
|
|
links: List(Link),
|
|
)
|
|
}
|
|
|
|
fn server_status_decoder() -> Decoder(ServerStatus) {
|
|
use status <- decode.field("status", decode.string)
|
|
use version <- decode.field("version", decode.string)
|
|
use reset_date <- decode.field("resetDate", time.rfc3339_date_decoder())
|
|
use description <- decode.field("description", decode.string)
|
|
use stats <- decode.field("stats", stats_decoder())
|
|
use health <- decode.field("health", health_decoder())
|
|
use leaderboards <- decode.field("leaderboards", leaderboards_decoder())
|
|
use server_resets <- decode.field("serverResets", server_resets_decoder())
|
|
use announcements <- decode.field(
|
|
"announcements",
|
|
decode.list(announcement_decoder()),
|
|
)
|
|
use links <- decode.field("links", decode.list(link_decoder()))
|
|
decode.success(ServerStatus(
|
|
status:,
|
|
version:,
|
|
reset_date:,
|
|
description:,
|
|
stats:,
|
|
health:,
|
|
leaderboards:,
|
|
server_resets:,
|
|
announcements:,
|
|
links:,
|
|
))
|
|
}
|
|
|
|
pub fn get_server_status() -> ApiResponse(ServerStatus) {
|
|
let request = api.get(NoAuth, "/")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_response(response, server_status_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ErrorCode {
|
|
ErrorCode(code: Int, name: String)
|
|
}
|
|
|
|
fn error_code_decoder() -> Decoder(ErrorCode) {
|
|
use code <- decode.field("code", decode.int)
|
|
use name <- decode.field("name", decode.string)
|
|
decode.success(ErrorCode(code:, name:))
|
|
}
|
|
|
|
pub fn list_error_codes() -> ApiResponse(List(ErrorCode)) {
|
|
let request = api.get(NoAuth, "/error-codes")
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_response(
|
|
response,
|
|
decode.field(
|
|
"errorCodes",
|
|
decode.list(error_code_decoder()),
|
|
decode.success,
|
|
),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_systems(
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(List(System))) {
|
|
let request = api.get_page(NoAuth, "/systems", page, limit)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(response, decode.list(system.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_system(system_symbol: SystemSymbol) -> ApiResponse(System) {
|
|
let request =
|
|
api.get(NoAuth, "/systems/" <> system_symbol.to_string(system_symbol))
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, system.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn list_system_waypoints(
|
|
system_symbol: SystemSymbol,
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
type_: Option(WaypointType),
|
|
traits: List(WaypointTraitSymbol),
|
|
) -> ApiResponse(PagedData(List(Waypoint))) {
|
|
let query =
|
|
list.map(traits, fn(trait) {
|
|
#("traits", waypoint_trait_symbol.to_string(trait))
|
|
})
|
|
let query = case type_ {
|
|
option.Some(type_) -> [#("type", waypoint_type.to_string(type_)), ..query]
|
|
option.None -> query
|
|
}
|
|
let request =
|
|
api.get_page_with_query(
|
|
NoAuth,
|
|
"/systems/" <> system_symbol.to_string(system_symbol) <> "/waypoints",
|
|
page,
|
|
limit,
|
|
query,
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 ->
|
|
api.parse_paged_data_response(response, decode.list(waypoint.decoder()))
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_waypoint(
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(Waypoint) {
|
|
let request =
|
|
api.get(
|
|
NoAuth,
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, waypoint.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_construction_site(
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(Construction) {
|
|
let request =
|
|
api.get(
|
|
NoAuth,
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol)
|
|
<> "/construction",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, construction.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type ConstructionSiteSupplied {
|
|
ConstructionSiteSupplied(construction: Construction, cargo: ShipCargo)
|
|
}
|
|
|
|
pub fn supply_construction_site(
|
|
token: AgentToken,
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
) -> ApiResponse(ConstructionSiteSupplied) {
|
|
let request =
|
|
api.post_json(
|
|
AgentAuth(token),
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol)
|
|
<> "/construction/supply",
|
|
json.object([
|
|
#("shipSymbol", ship_symbol.encode(ship_symbol)),
|
|
#("tradeSymbol", trade_symbol.encode(trade_symbol)),
|
|
#("units", json.int(units)),
|
|
]),
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
201 ->
|
|
api.parse_data_response(response, {
|
|
use construction <- decode.field("construction", construction.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
decode.success(ConstructionSiteSupplied(construction:, cargo:))
|
|
})
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_market(
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(Market) {
|
|
let request =
|
|
api.get(
|
|
NoAuth,
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol)
|
|
<> "/market",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, market.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_jump_gate(
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(JumpGate) {
|
|
let request =
|
|
api.get(
|
|
NoAuth,
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol)
|
|
<> "/jump-gate",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, jump_gate.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub fn get_shipyard(
|
|
system_symbol: SystemSymbol,
|
|
waypoint_symbol: WaypointSymbol,
|
|
) -> ApiResponse(Shipyard) {
|
|
let request =
|
|
api.get(
|
|
NoAuth,
|
|
"/systems/"
|
|
<> system_symbol.to_string(system_symbol)
|
|
<> "/waypoints/"
|
|
<> waypoint_symbol.to_string(waypoint_symbol)
|
|
<> "/shipyard",
|
|
)
|
|
use response <- api.try_send(request)
|
|
case response.status {
|
|
200 -> api.parse_data_response(response, shipyard.decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|