summaryrefslogtreecommitdiff
path: root/golang/pkg/api
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--golang/pkg/api/api.go89
-rw-r--r--golang/pkg/api/client.go6
-rw-r--r--golang/pkg/api/contracts.go60
-rw-r--r--golang/pkg/api/ships.go123
-rw-r--r--golang/pkg/api/systems.go99
5 files changed, 304 insertions, 73 deletions
diff --git a/golang/pkg/api/api.go b/golang/pkg/api/api.go
index 472d9e5..6520251 100644
--- a/golang/pkg/api/api.go
+++ b/golang/pkg/api/api.go
@@ -9,6 +9,7 @@ import (
"log/slog"
"net/http"
"net/url"
+ "strconv"
"time"
)
@@ -25,7 +26,13 @@ func (e *APIError) Error() string {
type APIMessage struct {
Data json.RawMessage `json:"data"`
Error *APIError `json:"error"`
- //meta
+ Meta *Meta `json:"meta"`
+}
+
+type Meta struct {
+ Limit int `json:"limit"`
+ Page int `json:"page"`
+ Total int `json:"total"`
}
type Request struct {
@@ -45,30 +52,62 @@ type Response struct {
func (c *Client) Send(method string, uriRef *url.URL, payload any, response any) error {
responseChannel := make(chan *Response)
- c.requestsChannel <- &Request{
- method: method,
- payload: payload,
- priority: 10,
- responseChannel: responseChannel,
- uri: c.baseURI.ResolveReference(uriRef),
- }
- res := <-responseChannel
- if res.Err != nil {
- return res.Err
+ uri := c.baseURI.ResolveReference(uriRef)
+ query := uri.Query()
+ query.Add("limit", "20")
+ page := 1
+ var rawResponses []json.RawMessage
+ for {
+ query.Set("page", strconv.Itoa(page))
+ uri.RawQuery = query.Encode()
+ c.requestsChannel <- &Request{
+ method: method,
+ payload: payload,
+ priority: 10,
+ responseChannel: responseChannel,
+ uri: uri,
+ }
+ res := <-responseChannel
+ if res.Err != nil {
+ return res.Err
+ }
+ if err := res.Message.Error; err != nil {
+ switch err.Code {
+ case 4214:
+ e := decodeShipInTransitError(err.Data)
+ select {
+ case <-c.ctx.Done():
+ return fmt.Errorf("failed to send: ctx cancelled")
+ case <-time.After(e.SecondsToArrival.Duration() * time.Second):
+ }
+ return c.Send(method, uriRef, payload, response)
+ default:
+ return err
+ }
+ }
+ if res.Message.Meta == nil {
+ // This is not a paginated request, we are done
+ if err := json.Unmarshal(res.Message.Data, &response); err != nil {
+ return fmt.Errorf("failed to unmarshal message: %w", err)
+ }
+ return nil
+ }
+ var oneResponse []json.RawMessage
+ if err := json.Unmarshal(res.Message.Data, &oneResponse); err != nil {
+ return fmt.Errorf("failed to unmarshal message: %w", err)
+ }
+ rawResponses = append(rawResponses, oneResponse...)
+ if res.Message.Meta.Limit*res.Message.Meta.Page >= res.Message.Meta.Total {
+ break
+ }
+ page++
}
- err := res.Message.Error
+ responses, err := json.Marshal(rawResponses)
if err != nil {
- switch err.Code {
- case 4214:
- e := decodeShipInTransitError(err.Data)
- time.Sleep(e.SecondsToArrival.Duration() * time.Second)
- return c.Send(method, uriRef, payload, response)
- default:
- return err
- }
+ return fmt.Errorf("failed to marshal raw responses to paginated request: %w", err)
}
- if err := json.Unmarshal(res.Message.Data, &response); err != nil {
- return fmt.Errorf("failed to unmarshal message: %w", err)
+ if err := json.Unmarshal(responses, &response); err != nil {
+ return fmt.Errorf("failed to unmarshal paginated request responses: %w", err)
}
return nil
}
@@ -154,7 +193,11 @@ func (c *Client) sendOne(method string, uri *url.URL, payload any) (*APIMessage,
switch resp.StatusCode {
case 429:
e := decodeRateLimitError(msg.Error.Data)
- time.Sleep(e.RetryAfter.Duration() * time.Second)
+ select {
+ case <-c.ctx.Done():
+ return nil, fmt.Errorf("failed to sendOne: ctx cancelled")
+ case <-time.After(e.RetryAfter.Duration() * time.Second):
+ }
return c.sendOne(method, uri, payload)
}
return &msg, nil
diff --git a/golang/pkg/api/client.go b/golang/pkg/api/client.go
index 2ea555e..e6a1883 100644
--- a/golang/pkg/api/client.go
+++ b/golang/pkg/api/client.go
@@ -6,10 +6,13 @@ import (
"net/http"
"net/url"
"time"
+
+ "git.adyxax.org/adyxax/spacetraders/golang/pkg/database"
)
type Client struct {
baseURI *url.URL
+ db *database.DB
requestsChannel chan *Request
ctx context.Context
headers *http.Header
@@ -17,7 +20,7 @@ type Client struct {
pq *PriorityQueue
}
-func NewClient(ctx context.Context) *Client {
+func NewClient(ctx context.Context, db *database.DB) *Client {
baseURI, err := url.Parse("https://api.spacetraders.io/v2/")
if err != nil {
panic("baseURI failed to parse")
@@ -26,6 +29,7 @@ func NewClient(ctx context.Context) *Client {
heap.Init(&pq)
client := &Client{
baseURI: baseURI,
+ db: db,
requestsChannel: make(chan *Request),
ctx: ctx,
headers: &http.Header{
diff --git a/golang/pkg/api/contracts.go b/golang/pkg/api/contracts.go
index 9478d4f..fd20cce 100644
--- a/golang/pkg/api/contracts.go
+++ b/golang/pkg/api/contracts.go
@@ -5,11 +5,10 @@ import (
"net/url"
"path"
- "git.adyxax.org/adyxax/spacetraders/golang/pkg/database"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
)
-func (c *Client) Accept(contract *model.Contract, db *database.DB) error {
+func (c *Client) Accept(contract *model.Contract) error {
if contract.Accepted {
return nil
}
@@ -20,21 +19,70 @@ func (c *Client) Accept(contract *model.Contract, db *database.DB) error {
}
var response acceptResponse
if err := c.Send("POST", &uriRef, nil, &response); err != nil {
- return fmt.Errorf("failed to accept contract %s: %w", contract.Id, err)
+ return fmt.Errorf("failed API request: %w", err)
}
- if err := db.SaveAgent(response.Agent); err != nil {
- return fmt.Errorf("failed to accept contract %s: %w", contract.Id, err)
+ if err := c.db.SaveAgent(response.Agent); err != nil {
+ return fmt.Errorf("failed to save agent: %w", err)
}
contract.Accepted = response.Contract.Accepted
contract.Terms = response.Contract.Terms
return nil
}
+func (c *Client) Deliver(contract *model.Contract, ship *model.Ship) error {
+ deliver := contract.Terms.Deliver[0]
+ var units int
+ for _, cargoItem := range ship.Cargo.Inventory {
+ if cargoItem.Symbol == deliver.TradeSymbol {
+ units = min(deliver.UnitsRequired-deliver.UnitsFulfilled, cargoItem.Units)
+ break
+ }
+ }
+ uriRef := url.URL{Path: path.Join("my/contracts", contract.Id, "deliver")}
+ type deliverRequest struct {
+ ShipSymbol string `json:"shipSymbol"`
+ TradeSymbol string `json:"tradeSymbol"`
+ Units int `json:"units"`
+ }
+ type deliverResponse struct {
+ Cargo *model.Cargo `json:"cargo"`
+ Contract *model.Contract `json:"contract"`
+ }
+ var response deliverResponse
+ if err := c.Send("POST", &uriRef, deliverRequest{ship.Symbol, deliver.TradeSymbol, units}, &response); err != nil {
+ return fmt.Errorf("failed API request: %w", err)
+ }
+ ship.Cargo = response.Cargo
+ contract.Terms = response.Contract.Terms
+ return nil
+}
+
+func (c *Client) Fulfill(contract *model.Contract) error {
+ if contract.Fulfilled {
+ return nil
+ }
+ uriRef := url.URL{Path: path.Join("my/contracts", contract.Id, "fulfill")}
+ type fulfillResponse struct {
+ Agent *model.Agent `json:"agent"`
+ Contract *model.Contract `json:"contract"`
+ }
+ var response fulfillResponse
+ if err := c.Send("POST", &uriRef, nil, &response); err != nil {
+ return fmt.Errorf("failed API request: %w", err)
+ }
+ if err := c.db.SaveAgent(response.Agent); err != nil {
+ return fmt.Errorf("failed to save agent: %w", err)
+ }
+ contract.Fulfilled = response.Contract.Fulfilled
+ contract.Terms = response.Contract.Terms
+ return nil
+}
+
func (c *Client) MyContracts() ([]model.Contract, error) {
uriRef := url.URL{Path: "my/contracts"}
var contracts []model.Contract
if err := c.Send("GET", &uriRef, nil, &contracts); err != nil {
- return nil, fmt.Errorf("failed to get contracts: %w", err)
+ return nil, fmt.Errorf("failed API request: %w", err)
}
return contracts, nil
}
diff --git a/golang/pkg/api/ships.go b/golang/pkg/api/ships.go
index 93963c3..c3b7074 100644
--- a/golang/pkg/api/ships.go
+++ b/golang/pkg/api/ships.go
@@ -4,8 +4,8 @@ import (
"fmt"
"net/url"
"path"
+ "time"
- "git.adyxax.org/adyxax/spacetraders/golang/pkg/database"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
)
@@ -19,7 +19,7 @@ func (c *Client) dock(s *model.Ship) error {
}
var response dockResponse
if err := c.Send("POST", &uriRef, nil, &response); err != nil {
- return fmt.Errorf("failed to dock ship %s: %w", s.Symbol, err)
+ return fmt.Errorf("failed API request: %w", err)
}
s.Nav = response.Nav
return nil
@@ -29,11 +29,56 @@ func (c *Client) MyShips() ([]model.Ship, error) {
uriRef := url.URL{Path: "my/ships"}
var ships []model.Ship
if err := c.Send("GET", &uriRef, nil, &ships); err != nil {
- return nil, fmt.Errorf("failed to get ships: %w", err)
+ return nil, fmt.Errorf("failed API request: %w", err)
}
return ships, nil
}
+func (c *Client) Navigate(s *model.Ship, waypointSymbol string) error {
+ if s.Nav.WaypointSymbol == waypointSymbol {
+ return nil
+ }
+ if err := c.orbit(s); err != nil {
+ return fmt.Errorf("failed to orbit: %w", err)
+ }
+ // TODO shortest path
+ // TODO go refuel if necessary
+ uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "navigate")}
+ type navigateRequest struct {
+ WaypointSymbol string `json:"waypointSymbol"`
+ }
+ type navigateResponse struct {
+ //Events []model.Event `json:"events"`
+ Fuel *model.Fuel `json:"fuel"`
+ Nav *model.Nav `json:"nav"`
+ }
+ var response navigateResponse
+ if err := c.Send("POST", &uriRef, navigateRequest{waypointSymbol}, &response); err != nil {
+ return fmt.Errorf("failed API request: %w", err)
+ }
+ s.Fuel = response.Fuel
+ s.Nav = response.Nav
+ select {
+ case <-c.ctx.Done():
+ return fmt.Errorf("failed: context cancelled")
+ case <-time.After(s.Nav.Route.Arrival.Sub(time.Now())):
+ }
+ s.Nav.Status = "IN_ORBIT"
+ return nil
+}
+
+func (c *Client) NegotiateContract(s *model.Ship) (*model.Contract, error) {
+ uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "negotiate", "contract")}
+ type negotiateResponse struct {
+ Contract *model.Contract `json:"contract"`
+ }
+ var response negotiateResponse
+ if err := c.Send("POST", &uriRef, nil, &response); err != nil {
+ return nil, fmt.Errorf("failed API request: %w", err)
+ }
+ return response.Contract, nil
+}
+
func (c *Client) orbit(s *model.Ship) error {
if s.Nav.Status == "IN_ORBIT" {
return nil
@@ -44,18 +89,46 @@ func (c *Client) orbit(s *model.Ship) error {
}
var response orbitResponse
if err := c.Send("POST", &uriRef, nil, &response); err != nil {
- return fmt.Errorf("failed to orbit ship %s: %w", s.Symbol, err)
+ return fmt.Errorf("failed API request: %w", err)
}
s.Nav = response.Nav
return nil
}
-func (c *Client) Refuel(s *model.Ship, db *database.DB) error {
+func (c *Client) Purchase(s *model.Ship, cargoItem string, units int) error {
+ if err := c.dock(s); err != nil {
+ return fmt.Errorf("failed to dock: %w", err)
+ }
+ uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "purchase")}
+ type purchaseRequest struct {
+ Symbol string `json:"symbol"`
+ Units int `json:"units"`
+ }
+ type purchaseResponse struct {
+ Agent *model.Agent `json:"agent"`
+ Cargo *model.Cargo `json:"cargo"`
+ Transaction *model.Transaction `json:"transaction"`
+ }
+ var response purchaseResponse
+ if err := c.Send("POST", &uriRef, purchaseRequest{cargoItem, units}, &response); err != nil {
+ return fmt.Errorf("failed API request: %w", err)
+ }
+ if err := c.db.SaveAgent(response.Agent); err != nil {
+ return fmt.Errorf("failed to save agent: %w", err)
+ }
+ s.Cargo = response.Cargo
+ if err := c.db.AppendTransaction(response.Transaction); err != nil {
+ return fmt.Errorf("failed to append transaction: %w", err)
+ }
+ return nil
+}
+
+func (c *Client) refuel(s *model.Ship, db *database.DB) error {
if s.Fuel.Current == s.Fuel.Capacity {
return nil
}
if err := c.dock(s); err != nil {
- return fmt.Errorf("failed to refuel ship %s: %w", s.Symbol, err)
+ return fmt.Errorf("failed to dock: %w", err)
}
uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "refuel")}
type refuelResponse struct {
@@ -65,14 +138,42 @@ func (c *Client) Refuel(s *model.Ship, db *database.DB) error {
}
var response refuelResponse
if err := c.Send("POST", &uriRef, nil, &response); err != nil {
- return fmt.Errorf("failed to refuel ship %s: %w", s.Symbol, err)
+ return fmt.Errorf("failed API request: %w", err)
}
- if err := db.SaveAgent(response.Agent); err != nil {
- return fmt.Errorf("failed to refuel ship %s: %w", s.Symbol, err)
+ if err := c.db.SaveAgent(response.Agent); err != nil {
+ return fmt.Errorf("failed to save agent: %w", err)
}
s.Fuel = response.Fuel
- if err := db.AppendTransaction(response.Transaction); err != nil {
- return fmt.Errorf("failed to refuel ship %s: %w", s.Symbol, err)
+ if err := c.db.AppendTransaction(response.Transaction); err != nil {
+ return fmt.Errorf("failed to append transaction: %w", err)
+ }
+ return nil
+}
+
+func (c *Client) Sell(s *model.Ship, cargoItem string, units int) error {
+ if err := c.dock(s); err != nil {
+ return fmt.Errorf("failed to dock: %w", err)
+ }
+ uriRef := url.URL{Path: path.Join("my/ships", s.Symbol, "sell")}
+ type sellRequest struct {
+ Symbol string `json:"symbol"`
+ Units int `json:"units"`
+ }
+ type sellResponse struct {
+ Agent *model.Agent `json:"agent"`
+ Cargo *model.Cargo `json:"cargo"`
+ Transaction *model.Transaction `json:"transaction"`
+ }
+ var response sellResponse
+ if err := c.Send("POST", &uriRef, sellRequest{cargoItem, units}, &response); err != nil {
+ return fmt.Errorf("failed API request: %w", err)
+ }
+ if err := c.db.SaveAgent(response.Agent); err != nil {
+ return fmt.Errorf("failed to save agent: %w", err)
+ }
+ s.Cargo = response.Cargo
+ if err := c.db.AppendTransaction(response.Transaction); err != nil {
+ return fmt.Errorf("failed to append transaction: %w", err)
}
return nil
}
diff --git a/golang/pkg/api/systems.go b/golang/pkg/api/systems.go
index 3d3a373..2cdfeca 100644
--- a/golang/pkg/api/systems.go
+++ b/golang/pkg/api/systems.go
@@ -5,55 +5,90 @@ import (
"net/url"
"path"
- "git.adyxax.org/adyxax/spacetraders/golang/pkg/database"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
)
-func (c *Client) GetSystem(symbol string, db *database.DB) (*model.System, error) {
- if system, err := db.LoadSystem(symbol); err == nil && system != nil {
- return system, nil
+func (c *Client) GetMarket(waypointSymbol string) (*model.Market, error) {
+ if market, err := c.db.LoadMarket(waypointSymbol); err == nil && market != nil {
+ // TODO check last updated time
+ return market, nil
}
- uriRef := url.URL{Path: path.Join("systems", symbol)}
- var system model.System
- if err := c.Send("GET", &uriRef, nil, &system); err != nil {
- return nil, fmt.Errorf("failed to get system %s: %w", symbol, err)
+ systemSymbol := WaypointSymbolToSystemSymbol(waypointSymbol)
+ uriRef := url.URL{Path: path.Join("systems", systemSymbol, "waypoints", waypointSymbol, "market")}
+ var market model.Market
+ if err := c.Send("GET", &uriRef, nil, &market); err != nil {
+ return nil, fmt.Errorf("failed API request: %w", err)
}
- if err := db.SaveSystem(&system); err != nil {
- return nil, fmt.Errorf("failed to get system %s: %w", symbol, err)
+ if err := c.db.SaveMarket(&market); err != nil {
+ return nil, fmt.Errorf("failed to save market %s: %w", market.Symbol, err)
}
- return &system, nil
+ return &market, nil
}
-func (c *Client) ListWaypointsInSystem(system *model.System, db *database.DB) ([]model.Waypoint, error) {
- // TODO database caching
- // TODO pagination
- // TODO check updated
- uriRef := url.URL{Path: path.Join("systems", system.Symbol, "waypoints")}
- var waypoints []model.Waypoint
- if err := c.Send("GET", &uriRef, nil, &waypoints); err != nil {
- return nil, fmt.Errorf("failed to list waypoints in system %s: %w", system.Symbol, err)
+func (c *Client) GetShipyard(waypointSymbol string) (*model.Shipyard, error) {
+ if shipyard, err := c.db.LoadShipyard(waypointSymbol); err == nil && shipyard != nil &&
+ (shipyard.Ships != nil) { // TODO || !IsThereAShipAtWaypoint(waypoint)) {
+ // TODO check last updated time
+ return shipyard, nil
}
- for _, waypoint := range waypoints {
- if err := db.SaveWaypoint(&waypoint); err != nil {
- return nil, fmt.Errorf("failed to list waypoints in system %s: %w", system.Symbol, err)
- }
+ systemSymbol := WaypointSymbolToSystemSymbol(waypointSymbol)
+ uriRef := url.URL{Path: path.Join("systems", systemSymbol, "waypoints", waypointSymbol, "shipyard")}
+ var shipyard model.Shipyard
+ if err := c.Send("GET", &uriRef, nil, &shipyard); err != nil {
+ return nil, fmt.Errorf("failed API request: %w", err)
}
- return waypoints, nil
+ if err := c.db.SaveShipyard(&shipyard); err != nil {
+ return nil, fmt.Errorf("failed to save shipyard %s: %w", shipyard.Symbol, err)
+ }
+ return &shipyard, nil
}
-func (c *Client) GetWaypoint(symbol string, db *database.DB) (*model.Waypoint, error) {
- // TODO check updated
- if waypoint, err := db.LoadWaypoint(symbol); err == nil && waypoint != nil {
+func (c *Client) GetSystem(systemSymbol string) (*model.System, error) {
+ if system, err := c.db.LoadSystem(systemSymbol); err == nil && system != nil {
+ return system, nil
+ }
+ uriRef := url.URL{Path: path.Join("systems", systemSymbol)}
+ var system model.System
+ if err := c.Send("GET", &uriRef, nil, &system); err != nil {
+ return nil, fmt.Errorf("failed API request: %w", err)
+ }
+ if err := c.db.SaveSystem(&system); err != nil {
+ return nil, fmt.Errorf("failed to save system %s: %w", system.Symbol, err)
+ }
+ return &system, nil
+}
+
+func (c *Client) GetWaypoint(waypointSymbol string) (*model.Waypoint, error) {
+ if waypoint, err := c.db.LoadWaypoint(waypointSymbol); err == nil && waypoint != nil {
+ // TODO check last updated time
return waypoint, nil
}
- systemSymbol := WaypointSymbolToSystemSymbol(symbol)
- uriRef := url.URL{Path: path.Join("systems", systemSymbol, "waypoints", symbol)}
+ systemSymbol := WaypointSymbolToSystemSymbol(waypointSymbol)
+ uriRef := url.URL{Path: path.Join("systems", systemSymbol, "waypoints", waypointSymbol)}
var waypoint model.Waypoint
if err := c.Send("GET", &uriRef, nil, &waypoint); err != nil {
- return nil, fmt.Errorf("failed to get waypoint %s: %w", symbol, err)
+ return nil, fmt.Errorf("failed API request: %w", err)
}
- if err := db.SaveWaypoint(&waypoint); err != nil {
- return nil, fmt.Errorf("failed to get waypoint %s: %w", symbol, err)
+ if err := c.db.SaveWaypoint(&waypoint); err != nil {
+ return nil, fmt.Errorf("failed to save waypoint %s: %w", waypoint.Symbol, err)
}
return &waypoint, nil
}
+
+func (c *Client) ListWaypointsInSystem(systemSymbol string) ([]model.Waypoint, error) {
+ if waypoints, err := c.db.LoadWaypointsInSystem(systemSymbol); err == nil && waypoints != nil {
+ // TODO check last updated time
+ return waypoints, nil
+ }
+ uriRef := url.URL{Path: path.Join("systems", systemSymbol, "waypoints")}
+ var waypoints []model.Waypoint
+ if err := c.Send("GET", &uriRef, nil, &waypoints); err != nil {
+ return nil, fmt.Errorf("failed API request: %w", err)
+ }
+ for _, waypoint := range waypoints {
+ if err := c.db.SaveWaypoint(&waypoint); err != nil {
+ return nil, fmt.Errorf("failed to save waypoint %s: %w", waypoint.Symbol, err)
+ }
+ }
+ return waypoints, nil
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-22 14:16:24 +0000