1072 lines
30 KiB
Gleam
1072 lines
30 KiB
Gleam
import gleam/dynamic/decode.{type Decoder}
|
|
import gleam/json
|
|
import gleam/option.{type Option}
|
|
import models/agent.{type Agent}
|
|
import models/chart.{type Chart}
|
|
import models/chart_transaction.{type ChartTransaction}
|
|
import models/contract.{type Contract}
|
|
import models/cooldown.{type Cooldown}
|
|
import models/extraction.{type Extraction}
|
|
import models/market_transaction.{type MarketTransaction}
|
|
import models/module_symbol.{type ModuleSymbol}
|
|
import models/mount_symbol.{type MountSymbol}
|
|
import models/refinement_produce.{type RefinementProduce}
|
|
import models/refinement_yield.{type RefinementYield}
|
|
import models/repair_transaction.{type RepairTransaction}
|
|
import models/scanned_ship.{type ScannedShip}
|
|
import models/scanned_system.{type ScannedSystem}
|
|
import models/scanned_waypoint.{type ScannedWaypoint}
|
|
import models/scrap_transaction.{type ScrapTransaction}
|
|
import models/ship.{type Ship}
|
|
import models/ship_cargo.{type ShipCargo}
|
|
import models/ship_condition_event.{type ShipConditionEvent}
|
|
import models/ship_fuel.{type ShipFuel}
|
|
import models/ship_modification_transaction.{type ShipModificationTransaction}
|
|
import models/ship_module.{type ShipModule}
|
|
import models/ship_mount.{type ShipMount}
|
|
import models/ship_nav.{type ShipNav}
|
|
import models/ship_nav_flight_mode.{type ShipNavFlightMode}
|
|
import models/ship_symbol.{type ShipSymbol}
|
|
import models/ship_type.{type ShipType}
|
|
import models/shipyard_transaction.{type ShipyardTransaction}
|
|
import models/siphon.{type Siphon}
|
|
import models/survey.{type Survey}
|
|
import models/trade_symbol.{type TradeSymbol}
|
|
import models/waypoint.{type Waypoint}
|
|
import models/waypoint_modifier.{type WaypointModifier}
|
|
import models/waypoint_symbol.{type WaypointSymbol}
|
|
import utils/api.{type ApiResponse, type PagedData}
|
|
import utils/auth.{type AgentToken, AgentAuth}
|
|
|
|
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)
|
|
}
|
|
}
|