155 lines
4.6 KiB
Gleam
155 lines
4.6 KiB
Gleam
import endpoints/fleet
|
|
import gleam/dynamic/decode.{type Decoder}
|
|
import gleam/json
|
|
import gleam/option.{type Option}
|
|
import models/agent.{type Agent}
|
|
import models/contract.{type Contract}
|
|
import models/contract_id.{type ContractId}
|
|
import models/ship_cargo.{type ShipCargo}
|
|
import models/ship_symbol.{type ShipSymbol}
|
|
import models/trade_symbol.{type TradeSymbol}
|
|
import utils/api.{type ApiResponse, type PagedData}
|
|
import utils/auth.{type AgentToken, AgentAuth}
|
|
|
|
pub type ListContractsResponse {
|
|
ListContractsResponse(contracts: List(Contract))
|
|
}
|
|
|
|
fn list_contracts_response_decoder() -> Decoder(ListContractsResponse) {
|
|
use contracts <- decode.then(decode.list(contract.decoder()))
|
|
decode.success(ListContractsResponse(contracts:))
|
|
}
|
|
|
|
pub fn list_contracts(
|
|
token: AgentToken,
|
|
page: Option(Int),
|
|
limit: Option(Int),
|
|
) -> ApiResponse(PagedData(ListContractsResponse)) {
|
|
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, list_contracts_response_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type GetContractResponse {
|
|
GetContractResponse(contract: Contract)
|
|
}
|
|
|
|
fn get_contract_response_decoder() -> Decoder(GetContractResponse) {
|
|
use contract <- decode.then(contract.decoder())
|
|
decode.success(GetContractResponse(contract:))
|
|
}
|
|
|
|
pub fn get_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(GetContractResponse) {
|
|
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, get_contract_response_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type AcceptContractResponse {
|
|
AcceptContractResponse(contract: Contract, agent: Agent)
|
|
}
|
|
|
|
fn accept_contract_response_decoder() -> Decoder(AcceptContractResponse) {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(AcceptContractResponse(contract:, agent:))
|
|
}
|
|
|
|
pub fn accept_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(AcceptContractResponse) {
|
|
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, accept_contract_response_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type FulfillContractResponse {
|
|
FulfillContractResponse(contract: Contract, agent: Agent)
|
|
}
|
|
|
|
fn fulfill_contract_response_decoder() -> Decoder(FulfillContractResponse) {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use agent <- decode.field("agent", agent.decoder())
|
|
decode.success(FulfillContractResponse(contract:, agent:))
|
|
}
|
|
|
|
pub fn fulfill_contract(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
) -> ApiResponse(FulfillContractResponse) {
|
|
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, fulfill_contract_response_decoder())
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub type DeliverContractCargoResponse {
|
|
DeliverContractCargoResponse(contract: Contract, cargo: ShipCargo)
|
|
}
|
|
|
|
fn deliver_contract_cargo_response_decoder() -> Decoder(
|
|
DeliverContractCargoResponse,
|
|
) {
|
|
use contract <- decode.field("contract", contract.decoder())
|
|
use cargo <- decode.field("cargo", ship_cargo.decoder())
|
|
decode.success(DeliverContractCargoResponse(contract:, cargo:))
|
|
}
|
|
|
|
pub fn deliver_contract_cargo(
|
|
token: AgentToken,
|
|
contract_id: ContractId,
|
|
ship_symbol: ShipSymbol,
|
|
trade_symbol: TradeSymbol,
|
|
units: Int,
|
|
) -> ApiResponse(DeliverContractCargoResponse) {
|
|
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,
|
|
deliver_contract_cargo_response_decoder(),
|
|
)
|
|
_ -> api.parse_error_response(response)
|
|
}
|
|
}
|
|
|
|
pub const negotiate_contract = fleet.negotiate_contract
|