summaryrefslogtreecommitdiff
path: root/golang
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--golang/cmd/spacetraders/main.go5
-rw-r--r--golang/pkg/agent/contracting.go68
-rw-r--r--golang/pkg/agent/error.go15
-rw-r--r--golang/pkg/agent/run.go27
-rw-r--r--golang/pkg/agent/trading.go139
-rw-r--r--golang/pkg/agent/utils.go117
-rw-r--r--golang/pkg/agent/visit.go51
-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
-rw-r--r--golang/pkg/database/markets.go42
-rw-r--r--golang/pkg/database/shipyards.go42
-rw-r--r--golang/pkg/database/sql/001_trading.sql9
-rw-r--r--golang/pkg/database/systems.go32
-rw-r--r--golang/pkg/database/transactions.go2
-rw-r--r--golang/pkg/model/common.go4
-rw-r--r--golang/pkg/model/contract.go2
-rw-r--r--golang/pkg/model/market.go10
-rw-r--r--golang/pkg/model/shipyard.go35
-rw-r--r--golang/pkg/model/trade_good.go11
-rw-r--r--golang/pkg/model/waypoint.go8
23 files changed, 863 insertions, 133 deletions
diff --git a/golang/cmd/spacetraders/main.go b/golang/cmd/spacetraders/main.go
index bae6c27..0e50497 100644
--- a/golang/cmd/spacetraders/main.go
+++ b/golang/cmd/spacetraders/main.go
@@ -6,6 +6,7 @@ import (
"log/slog"
"os"
"os/signal"
+ "syscall"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/agent"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/api"
@@ -23,7 +24,7 @@ func main() {
logger := slog.New(slog.NewJSONHandler(os.Stdout, opts))
slog.SetDefault(logger)
- ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+ ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer cancel()
db, err := database.NewDB(
@@ -35,7 +36,7 @@ func main() {
os.Exit(1)
}
- apiClient := api.NewClient(ctx)
+ apiClient := api.NewClient(ctx, db)
defer apiClient.Close()
if err := agent.Run(
apiClient,
diff --git a/golang/pkg/agent/contracting.go b/golang/pkg/agent/contracting.go
index 0f07170..4e476a6 100644
--- a/golang/pkg/agent/contracting.go
+++ b/golang/pkg/agent/contracting.go
@@ -11,39 +11,79 @@ func (a *agent) autoContracting(ship *model.Ship) {
defer a.wg.Done()
contracts, err := a.client.MyContracts()
if err != nil {
- a.sendShipError(fmt.Errorf("failed to get my contracts: %w", err), ship)
+ a.channel <- fmt.Errorf("failed to get my contracts with ship %s: %w", ship.Symbol, err)
return
}
for _, contract := range contracts {
- if contract.Fullfilled {
+ if contract.Fulfilled {
continue
}
now := time.Now()
if now.Before(contract.Terms.Deadline) {
if err := a.runContract(&contract, ship); err != nil {
- a.sendShipError(fmt.Errorf("failed to run contracts: %w", err), ship)
+ a.channel <- fmt.Errorf("failed to run contract %s with ship %s: %w", contract.Id, ship.Symbol, err)
return
}
}
}
- a.sendShipError(fmt.Errorf("failed to run contracts: negotiating new contracts is not implemented yet"), ship)
- // TODO
- //for {
- // negotiate
- // runContract
- //}
+ a.channel <- fmt.Errorf("negotiating new contracts is not implemented yet")
+ for {
+ contract, err := a.client.NegotiateContract(ship)
+ if err != nil {
+ a.channel <- fmt.Errorf("failed to negotiate contract: %w", err)
+ return
+ }
+ if err := a.runContract(contract, ship); err != nil {
+ a.channel <- fmt.Errorf("failed to run contract %s: %w", contract.Id, err)
+ return
+ }
+ }
}
func (a *agent) runContract(contract *model.Contract, ship *model.Ship) error {
- if err := a.client.Accept(contract, a.db); err != nil {
- return fmt.Errorf("failed to run contract: %w", err)
+ if err := a.client.Accept(contract); err != nil {
+ return fmt.Errorf("failed to accept contract: %w", err)
}
//slog.Info("running contract", "contract", contract, "ship", ship.Symbol)
switch contract.Type {
- // TODO
- //case "PROCUREMENT":
+ case "PROCUREMENT":
+ if err := a.runProcurement(contract, ship); err != nil {
+ return fmt.Errorf("failed to run procurement: %w", err)
+ }
default:
- return fmt.Errorf("failed to run contract: handling contracts of type %s is not implemented yet", contract.Type)
+ return fmt.Errorf("handling contracts of type %s is not implemented yet", contract.Type)
}
return nil
}
+
+func (a *agent) runProcurement(contract *model.Contract, ship *model.Ship) error {
+ if contract.Fulfilled {
+ return nil
+ }
+ deliver := contract.Terms.Deliver[0]
+ // make sure we are not carrying useless stuff
+ if err := a.sellEverythingExcept(ship, deliver.TradeSymbol); err != nil {
+ return fmt.Errorf("failed to sell everything except %s for ship %s: %w", deliver.TradeSymbol, ship.Symbol, err)
+ }
+ // procure the desired goods
+ if ship.Cargo.Units < min(deliver.UnitsRequired-deliver.UnitsFulfilled, ship.Cargo.Capacity) {
+ if err := a.buyTradeGood(ship, deliver.TradeSymbol); err != nil {
+ return fmt.Errorf("failed to buy trade good %s with ship %s: %w", deliver.TradeSymbol, ship.Symbol, err)
+ }
+ }
+ // deliver the goods
+ if err := a.client.Navigate(ship, deliver.DestinationSymbol); err != nil {
+ return fmt.Errorf("failed to navigate to %s: %w", deliver.DestinationSymbol, err)
+ }
+ if err := a.client.Deliver(contract, ship); err != nil {
+ return fmt.Errorf("failed to deliver: %w", err)
+ }
+ deliver = contract.Terms.Deliver[0]
+ if deliver.UnitsRequired == deliver.UnitsFulfilled {
+ if err := a.client.Fulfill(contract); err != nil {
+ return fmt.Errorf("failed to fulfill: %w", err)
+ }
+ return nil
+ }
+ return a.runProcurement(contract, ship)
+}
diff --git a/golang/pkg/agent/error.go b/golang/pkg/agent/error.go
deleted file mode 100644
index 64e6b8d..0000000
--- a/golang/pkg/agent/error.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package agent
-
-import "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
-
-type shipError struct {
- err error
- ship *model.Ship
-}
-
-func (a *agent) sendShipError(err error, ship *model.Ship) {
- a.channel <- shipError{
- err: err,
- ship: ship,
- }
-}
diff --git a/golang/pkg/agent/run.go b/golang/pkg/agent/run.go
index 1d70be8..0591102 100644
--- a/golang/pkg/agent/run.go
+++ b/golang/pkg/agent/run.go
@@ -11,7 +11,7 @@ import (
)
type agent struct {
- channel chan shipError
+ channel chan error
client *api.Client
db *database.DB
getenv func(string) string
@@ -23,7 +23,8 @@ type State int
const (
start_running_contracts_with_the_command_ship = iota
- visit_all_shipyards
+ visit_all_shipyards_with_the_starting_probe
+ send_the_starting_probe_to_a_shipyard_that_sells_probes
)
func Run(
@@ -32,7 +33,7 @@ func Run(
getenv func(string) string,
) error {
agent := agent{
- channel: make(chan shipError),
+ channel: make(chan error),
client: client,
db: db,
getenv: getenv,
@@ -43,7 +44,7 @@ func Run(
}
if agent.ships, err = client.MyShips(); err != nil {
- return fmt.Errorf("failed to init the agent's ships: %w", err)
+ return fmt.Errorf("failed to get my ships: %w", err)
}
var state State = start_running_contracts_with_the_command_ship
agent.wg.Add(1)
@@ -55,14 +56,20 @@ func Run(
agent.wg.Add(1)
go agent.autoContracting(&agent.ships[0])
state++
- case visit_all_shipyards:
+ case visit_all_shipyards_with_the_starting_probe:
if err := agent.visitAllShipyards(&agent.ships[1]); err != nil {
- agent.sendShipError(fmt.Errorf("agent runner returned an error on state %d: %w", state, err), &agent.ships[1])
+ agent.channel <- fmt.Errorf("failed to visit all shipyards with ship %s: %w", agent.ships[1].Symbol, err)
+ return
+ }
+ state++
+ case send_the_starting_probe_to_a_shipyard_that_sells_probes:
+ if err := agent.sendShipToShipyardThatSells(&agent.ships[1], "SHIP_PROBE"); err != nil {
+ agent.channel <- fmt.Errorf("failed to send the starting probe to a shipyard that sells probes: %w", err)
+ return
}
state++
- return
default:
- agent.sendShipError(fmt.Errorf("agent runner reach an unknown state: %d", state), nil)
+ agent.channel <- fmt.Errorf("state not implemented: %d", state)
return
}
}
@@ -71,8 +78,8 @@ func Run(
errWg.Add(1)
go func() {
defer errWg.Done()
- for shipErr := range agent.channel {
- slog.Error("ship error", "err", shipErr.err, "ship", shipErr.ship.Symbol)
+ for err := range agent.channel {
+ slog.Error("agent run error", "err", err)
}
}()
agent.wg.Wait()
diff --git a/golang/pkg/agent/trading.go b/golang/pkg/agent/trading.go
new file mode 100644
index 0000000..b900f7a
--- /dev/null
+++ b/golang/pkg/agent/trading.go
@@ -0,0 +1,139 @@
+package agent
+
+import (
+ "fmt"
+ "slices"
+
+ "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+type TradeGoodNotFoundError struct{}
+
+func (err *TradeGoodNotFoundError) Error() string {
+ return "trade good not found"
+}
+
+func (a *agent) buyTradeGood(ship *model.Ship, tradeGoodToBuy string) error {
+ if ship.Cargo.Units == ship.Cargo.Capacity {
+ return nil
+ }
+ // list markets would sell our goods
+ markets, err := a.listMarketsInSystem(ship.Nav.SystemSymbol)
+ if err != nil {
+ return fmt.Errorf("failed to list markets in system %s: %w", ship.Nav.SystemSymbol, err)
+ }
+ markets = slices.DeleteFunc(markets, func(market model.Market) bool {
+ for _, item := range market.Exports {
+ if item.Symbol == tradeGoodToBuy {
+ return false
+ }
+ }
+ return true
+ })
+ if len(markets) == 0 {
+ return &TradeGoodNotFoundError{}
+ }
+ // find the closest place to buy TODO
+ waypoint, err := a.client.GetWaypoint(ship.Nav.WaypointSymbol)
+ if err != nil {
+ return fmt.Errorf("failed to get nav waypoint %s: %w", ship.Nav.WaypointSymbol, err)
+ }
+ waypoints := make([]model.Waypoint, 0)
+ for i := range markets {
+ waypoint, err := a.client.GetWaypoint(markets[i].Symbol)
+ if err != nil {
+ return fmt.Errorf("failed to get waypoint %s: %w", markets[i].Symbol, err)
+ }
+ waypoints = append(waypoints, *waypoint)
+ }
+ sortByDistanceFrom(waypoint, waypoints)
+ // Go there and refresh our market data
+ if err := a.client.Navigate(ship, waypoints[0].Symbol); err != nil {
+ return fmt.Errorf("failed to navigate to %s: %w", waypoints[0].Symbol, err)
+ }
+ market, err := a.client.GetMarket(waypoints[0].Symbol)
+ if err != nil {
+ return fmt.Errorf("failed to get market %s: %w", waypoints[0].Symbol, err)
+ }
+ // Buy until full
+ for _, tradeGood := range market.TradeGoods {
+ if tradeGood.Type == "EXPORT" && tradeGood.Symbol == tradeGoodToBuy {
+ for ship.Cargo.Units < ship.Cargo.Capacity {
+ increment := min(ship.Cargo.Capacity-ship.Cargo.Units, tradeGood.TradeVolume)
+ if err := a.client.Purchase(ship, tradeGoodToBuy, increment); err != nil {
+ return fmt.Errorf("failed to purchase %d units of %s: %w", increment, tradeGoodToBuy, err)
+ }
+ }
+ break
+ }
+ }
+ return a.buyTradeGood(ship, tradeGoodToBuy)
+}
+
+func (a *agent) sellEverythingExcept(ship *model.Ship, keep string) error {
+ // First lets see what we need to sell
+ cargo := ship.Cargo.Inventory
+ cargo = slices.DeleteFunc(cargo, func(inventory model.Inventory) bool {
+ return inventory.Symbol == keep
+ })
+ if len(cargo) == 0 {
+ return nil
+ }
+ // list markets would buy our goods
+ markets, err := a.listMarketsInSystem(ship.Nav.SystemSymbol)
+ if err != nil {
+ return fmt.Errorf("failed to list markets in system %s: %w", ship.Nav.SystemSymbol, err)
+ }
+ markets = slices.DeleteFunc(markets, func(market model.Market) bool {
+ for _, item := range market.Imports {
+ for _, cargoItem := range cargo {
+ if item.Symbol == cargoItem.Symbol {
+ return false
+ }
+ }
+ }
+ return true
+ })
+ if len(markets) == 0 {
+ return nil
+ }
+ // find the closest place to sell something TODO
+ waypoint, err := a.client.GetWaypoint(ship.Nav.WaypointSymbol)
+ if err != nil {
+ return fmt.Errorf("failed to get nav waypoint %s: %w", ship.Nav.WaypointSymbol, err)
+ }
+ waypoints := make([]model.Waypoint, 0)
+ for i := range markets {
+ waypoint, err := a.client.GetWaypoint(markets[i].Symbol)
+ if err != nil {
+ return fmt.Errorf("failed to get waypoint %s: %w", markets[i].Symbol, err)
+ }
+ waypoints = append(waypoints, *waypoint)
+ }
+ sortByDistanceFrom(waypoint, waypoints)
+ // Go there and refresh our market data
+ if err := a.client.Navigate(ship, waypoints[0].Symbol); err != nil {
+ return fmt.Errorf("failed to navigate to %s: %w", waypoints[0].Symbol, err)
+ }
+ market, err := a.client.GetMarket(waypoints[0].Symbol)
+ if err != nil {
+ return fmt.Errorf("failed to get market %s: %w", waypoints[0].Symbol, err)
+ }
+ // sell everything we can
+ for _, cargoItem := range cargo {
+ units := cargoItem.Units
+ for _, tradeGood := range market.TradeGoods {
+ if tradeGood.Type == "IMPORT" && tradeGood.Symbol == cargoItem.Symbol {
+ for units > 0 {
+ increment := min(units, tradeGood.TradeVolume)
+ if err := a.client.Sell(ship, cargoItem.Symbol, increment); err != nil {
+ return fmt.Errorf("failed to sell %d units of %s: %w", units, cargoItem.Symbol, err)
+ }
+ units = units - increment
+ }
+ break
+ }
+ }
+ }
+ return a.sellEverythingExcept(ship, keep)
+}
diff --git a/golang/pkg/agent/utils.go b/golang/pkg/agent/utils.go
new file mode 100644
index 0000000..7aa9c7b
--- /dev/null
+++ b/golang/pkg/agent/utils.go
@@ -0,0 +1,117 @@
+package agent
+
+import (
+ "cmp"
+ "fmt"
+ "math"
+ "slices"
+
+ "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+func distance2(a *model.Waypoint, b *model.Waypoint) int {
+ x2 := a.X - b.X
+ y2 := a.Y - b.Y
+ return x2*x2 + y2*y2
+}
+
+func (a *agent) isThereAShipAtWaypoint(waypointSymbol string) bool {
+ for _, ship := range a.ships {
+ if ship.Nav.WaypointSymbol == waypointSymbol {
+ return true
+ }
+ }
+ return false
+}
+
+func (a *agent) listWaypointsInSystemWithTrait(systemSymbol string, trait string) ([]model.Waypoint, error) {
+ waypoints, err := a.client.ListWaypointsInSystem(systemSymbol)
+ if err != nil {
+ return nil, fmt.Errorf("failed to list waypoints: %w", err)
+ }
+ waypoints = slices.DeleteFunc(waypoints, func(waypoint model.Waypoint) bool {
+ for _, t := range waypoint.Traits {
+ if t.Symbol == trait {
+ return false
+ }
+ }
+ return true
+ })
+ return waypoints, nil
+}
+
+func (a *agent) listMarketsInSystem(systemSymbol string) ([]model.Market, error) {
+ waypoints, err := a.listWaypointsInSystemWithTrait(systemSymbol, "MARKETPLACE")
+ if err != nil {
+ return nil, fmt.Errorf("failed to list waypoints in system %s with trait MARKETPLACE: %w", systemSymbol, err)
+ }
+ var markets []model.Market
+ for i := range waypoints {
+ market, err := a.client.GetMarket(waypoints[i].Symbol)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get market %s: %w", waypoints[i].Symbol, err)
+ }
+ markets = append(markets, *market)
+ }
+ return markets, nil
+}
+
+func (a *agent) listShipyardsInSystem(systemSymbol string) ([]model.Shipyard, error) {
+ waypoints, err := a.listWaypointsInSystemWithTrait(systemSymbol, "SHIPYARD")
+ if err != nil {
+ return nil, fmt.Errorf("failed to list waypoints in system %s with trait SHIPYARD: %w", systemSymbol, err)
+ }
+ var shipyards []model.Shipyard
+ for i := range waypoints {
+ shipyard, err := a.client.GetShipyard(waypoints[i].Symbol)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get shipyard %s: %w", waypoints[i].Symbol, err)
+ }
+ shipyards = append(shipyards, *shipyard)
+ }
+ return shipyards, nil
+}
+
+func (a *agent) sendShipToShipyardThatSells(ship *model.Ship, shipType string) error {
+ shipyards, err := a.listShipyardsInSystem(ship.Nav.SystemSymbol)
+ if err != nil {
+ return fmt.Errorf("failed to list shipyards in system %s: %w", ship.Nav.SystemSymbol, err)
+ }
+ // filter out the shipyards that do not sell our ship
+ shipyards = slices.DeleteFunc(shipyards, func(shipyard model.Shipyard) bool {
+ for _, t := range shipyard.ShipTypes {
+ if t.Type == shipType {
+ return false
+ }
+ }
+ return true
+ })
+ // sort by cheapest
+ slices.SortFunc(shipyards, func(a, b model.Shipyard) int {
+ aPrice := math.MaxInt
+ for _, ship := range a.Ships {
+ if ship.Type == shipType {
+ aPrice = ship.PurchasePrice
+ break
+ }
+ }
+ bPrice := math.MaxInt
+ for _, ship := range b.Ships {
+ if ship.Type == shipType {
+ bPrice = ship.PurchasePrice
+ break
+ }
+ }
+ return cmp.Compare(aPrice, bPrice)
+ })
+ if err := a.client.Navigate(ship, shipyards[0].Symbol); err != nil {
+ return fmt.Errorf("failed to navigate to %s: %w", shipyards[0].Symbol, err)
+ }
+ return nil
+}
+
+func sortByDistanceFrom(origin *model.Waypoint, destinations []model.Waypoint) {
+ slices.SortFunc(destinations, func(a, b model.Waypoint) int {
+ return cmp.Compare(distance2(origin, &a), distance2(origin, &b))
+ })
+}
diff --git a/golang/pkg/agent/visit.go b/golang/pkg/agent/visit.go
index 019a6e5..e420186 100644
--- a/golang/pkg/agent/visit.go
+++ b/golang/pkg/agent/visit.go
@@ -2,23 +2,54 @@ package agent
import (
"fmt"
- "log/slog"
+ "slices"
"git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
)
func (a *agent) visitAllShipyards(ship *model.Ship) error {
- system, err := a.client.GetSystem(ship.Nav.SystemSymbol, a.db)
+ shipyards, err := a.listShipyardsInSystem(ship.Nav.SystemSymbol)
if err != nil {
- return fmt.Errorf("failed to visit all shipyards: %w", err)
+ return fmt.Errorf("failed to list shipyards in system %s: %w", ship.Nav.SystemSymbol, err)
}
- waypoints, err := a.client.ListWaypointsInSystem(system, a.db)
+ shipyards = slices.DeleteFunc(shipyards, func(shipyard model.Shipyard) bool {
+ // filter out shipyards for which we already have ships prices
+ if shipyard.Ships != nil {
+ return true
+ }
+ // filter out shipyards for which a ship is either present or inbound
+ return a.isThereAShipAtWaypoint(shipyard.Symbol)
+ })
+ if len(shipyards) == 0 {
+ return nil
+ }
+ waypoint, err := a.client.GetWaypoint(ship.Nav.WaypointSymbol)
if err != nil {
- return fmt.Errorf("failed to visit all shipyards: %w", err)
+ return fmt.Errorf("failed to get nav waypoint %s: %w", ship.Nav.WaypointSymbol, err)
}
- //slog.Info("get system", "system", system.Waypoints, "err", err)
- //waypoint, err := a.client.GetWaypoint("X1-RR14-J88", a.db)
- slog.Info("get waypoint", "waypoint", waypoints[0])
-
- return fmt.Errorf("failed to visit all shipyards: not implemented yet")
+ waypoints := make([]model.Waypoint, 0)
+ for i := range shipyards {
+ waypoint, err := a.client.GetWaypoint(shipyards[i].Symbol)
+ if err != nil {
+ return fmt.Errorf("failed to get waypoint %s: %w", shipyards[i].Symbol, err)
+ }
+ waypoints = append(waypoints, *waypoint)
+ }
+ sortByDistanceFrom(waypoint, waypoints)
+ if err := a.client.Navigate(ship, waypoints[0].Symbol); err != nil {
+ return fmt.Errorf("failed to navigate to %s: %w", waypoints[0].Symbol, err)
+ }
+ if _, err := a.client.GetShipyard(waypoints[0].Symbol); err != nil {
+ return fmt.Errorf("failed to get shipyard %s: %w", waypoints[0].Symbol, err)
+ }
+ // If this waypoint is also a marketplace, get its data
+ for _, trait := range waypoints[0].Traits {
+ if trait.Symbol == "MARKETPLACE" {
+ if _, err := a.client.GetMarket(waypoints[0].Symbol); err != nil {
+ return fmt.Errorf("failed to get market %s: %w", waypoints[0].Symbol, err)
+ }
+ break
+ }
+ }
+ return a.visitAllShipyards(ship)
}
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
+}
diff --git a/golang/pkg/database/markets.go b/golang/pkg/database/markets.go
new file mode 100644
index 0000000..11498d2
--- /dev/null
+++ b/golang/pkg/database/markets.go
@@ -0,0 +1,42 @@
+package database
+
+import (
+ "database/sql"
+ "encoding/json"
+ "fmt"
+ "time"
+
+ "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+func (db *DB) LoadMarket(symbol string) (*model.Market, error) {
+ var buf []byte
+ if err := db.QueryRow(`SELECT data FROM markets WHERE data->>'symbol' = ?;`, symbol).Scan(&buf); err != nil {
+ return nil, fmt.Errorf("failed to query row: %w", err)
+ }
+ var market model.Market
+ if err := json.Unmarshal(buf, &market); err != nil {
+ return nil, fmt.Errorf("failed to unmarshal market: %w", err)
+ }
+ return &market, nil
+}
+
+func (db *DB) SaveMarket(market *model.Market) error {
+ data, err := json.Marshal(market)
+ if err != nil {
+ return fmt.Errorf("failed to marshal market: %w", err)
+ }
+ _, err = db.Exec(
+ `INSERT INTO markets(data, updated)
+ VALUES (json(:data), :updated)
+ ON CONFLICT DO UPDATE SET data = :data, updated = :updated
+ WHERE data->>'symbol' = :symbol;`,
+ sql.Named("data", data),
+ sql.Named("symbol", market.Symbol),
+ sql.Named("updated", time.Now()),
+ )
+ if err != nil {
+ return fmt.Errorf("failed to exec: %w", err)
+ }
+ return nil
+}
diff --git a/golang/pkg/database/shipyards.go b/golang/pkg/database/shipyards.go
new file mode 100644
index 0000000..4d44f9a
--- /dev/null
+++ b/golang/pkg/database/shipyards.go
@@ -0,0 +1,42 @@
+package database
+
+import (
+ "database/sql"
+ "encoding/json"
+ "fmt"
+ "time"
+
+ "git.adyxax.org/adyxax/spacetraders/golang/pkg/model"
+)
+
+func (db *DB) LoadShipyard(symbol string) (*model.Shipyard, error) {
+ var buf []byte
+ if err := db.QueryRow(`SELECT data FROM shipyards WHERE data->>'symbol' = ?;`, symbol).Scan(&buf); err != nil {
+ return nil, fmt.Errorf("failed to query row: %w", err)
+ }
+ var shipyard model.Shipyard
+ if err := json.Unmarshal(buf, &shipyard); err != nil {
+ return nil, fmt.Errorf("failed to unmarshal shipyard: %w", err)
+ }
+ return &shipyard, nil
+}
+
+func (db *DB) SaveShipyard(shipyard *model.Shipyard) error {
+ data, err := json.Marshal(shipyard)
+ if err != nil {
+ return fmt.Errorf("failed to marshal shipyard: %w", err)
+ }
+ _, err = db.Exec(
+ `INSERT INTO shipyards(data, updated)
+ VALUES (json(:data), :updated)
+ ON CONFLICT DO UPDATE SET data = :data, updated = :updated
+ WHERE data->>'symbol' = :symbol;`,
+ sql.Named("data", data),
+ sql.Named("symbol", shipyard.Symbol),
+ sql.Named("updated", time.Now()),
+ )
+ if err != nil {
+ return fmt.Errorf("failed to exec: %w", err)
+ }
+ return nil
+}
diff --git a/golang/pkg/database/sql/001_trading.sql b/golang/pkg/database/sql/001_trading.sql
index 68f2568..e218962 100644
--- a/golang/pkg/database/sql/001_trading.sql
+++ b/golang/pkg/database/sql/001_trading.sql
@@ -4,13 +4,16 @@ CREATE TABLE agents (
);
CREATE TABLE markets (
id INTEGER PRIMARY KEY,
- systemSymbol TEXT NOT NULL,
data JSON NOT NULL,
updated DATE NOT NULL
);
-CREATE INDEX markets_systemSymbol on markets (systemSymbol);
CREATE UNIQUE INDEX markets_data_symbol on markets(json_extract(data, '$.symbol'));
-
+CREATE TABLE shipyards (
+ id INTEGER PRIMARY KEY,
+ data JSON NOT NULL,
+ updated DATE DEFAULT NULL
+);
+CREATE UNIQUE INDEX shipyards_data_symbol on shipyards (json_extract(data, '$.symbol'));
CREATE TABLE systems (
id INTEGER PRIMARY KEY,
data JSON NOT NULL
diff --git a/golang/pkg/database/systems.go b/golang/pkg/database/systems.go
index 858c3dd..b5d533b 100644
--- a/golang/pkg/database/systems.go
+++ b/golang/pkg/database/systems.go
@@ -12,7 +12,7 @@ import (
func (db *DB) LoadSystem(symbol string) (*model.System, error) {
var buf []byte
if err := db.QueryRow(`SELECT data FROM systems WHERE data->>'symbol' = ?;`, symbol).Scan(&buf); err != nil {
- return nil, fmt.Errorf("failed to query system: %w", err)
+ return nil, fmt.Errorf("failed to query row: %w", err)
}
var system model.System
if err := json.Unmarshal(buf, &system); err != nil {
@@ -27,7 +27,7 @@ func (db *DB) SaveSystem(system *model.System) error {
return fmt.Errorf("failed to marshal system: %w", err)
}
if _, err := db.Exec(`INSERT INTO systems(data) VALUES (json(?));`, data); err != nil {
- return fmt.Errorf("failed to append system: %w", err)
+ return fmt.Errorf("failed to exec: %w", err)
}
return nil
}
@@ -36,7 +36,7 @@ func (db *DB) SaveSystem(system *model.System) error {
func (db *DB) LoadWaypoint(symbol string) (*model.Waypoint, error) {
var buf []byte
if err := db.QueryRow(`SELECT data FROM waypoints WHERE data->>'symbol' = ?;`, symbol).Scan(&buf); err != nil {
- return nil, fmt.Errorf("failed to query waypoint: %w", err)
+ return nil, fmt.Errorf("failed to query row: %w", err)
}
var waypoint model.Waypoint
if err := json.Unmarshal(buf, &waypoint); err != nil {
@@ -45,13 +45,37 @@ func (db *DB) LoadWaypoint(symbol string) (*model.Waypoint, error) {
return &waypoint, nil
}
+func (db *DB) LoadWaypointsInSystem(systemSymbol string) ([]model.Waypoint, error) {
+ rows, err := db.Query(`SELECT data FROM waypoints WHERE data->>'systemSymbol' = ?;`, systemSymbol)
+ if err != nil {
+ return nil, fmt.Errorf("failed to query rows: %w", err)
+ }
+ defer rows.Close()
+ waypoints := make([]model.Waypoint, 0)
+ for rows.Next() {
+ var buf []byte
+ if err := rows.Scan(&buf); err != nil {
+ return nil, fmt.Errorf("failed to scan row: %w", err)
+ }
+ var waypoint model.Waypoint
+ if err := json.Unmarshal(buf, &waypoint); err != nil {
+ return nil, fmt.Errorf("failed to unmarshal waypoint: %w", err)
+ }
+ waypoints = append(waypoints, waypoint)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, fmt.Errorf("failed to scan rows: %w", err)
+ }
+ return waypoints, nil
+}
+
func (db *DB) SaveWaypoint(waypoint *model.Waypoint) error {
data, err := json.Marshal(waypoint)
if err != nil {
return fmt.Errorf("failed to marshal waypoint: %w", err)
}
if _, err := db.Exec(`INSERT INTO waypoints(data, updated) VALUES (json(?), ?);`, data, time.Now()); err != nil {
- return fmt.Errorf("failed to append waypoint: %w", err)
+ return fmt.Errorf("failed to exec: %w", err)
}
return nil
}
diff --git a/golang/pkg/database/transactions.go b/golang/pkg/database/transactions.go
index 71719c7..08278a1 100644
--- a/golang/pkg/database/transactions.go
+++ b/golang/pkg/database/transactions.go
@@ -13,7 +13,7 @@ func (db *DB) AppendTransaction(transaction *model.Transaction) error {
return fmt.Errorf("failed to marshal transaction: %w", err)
}
if _, err := db.Exec(`INSERT INTO transactions(data) VALUES (json(?));`, data); err != nil {
- return fmt.Errorf("failed to append transaction: %w", err)
+ return fmt.Errorf("failed to exec: %w", err)
}
return nil
}
diff --git a/golang/pkg/model/common.go b/golang/pkg/model/common.go
index 058b43d..6a2c321 100644
--- a/golang/pkg/model/common.go
+++ b/golang/pkg/model/common.go
@@ -5,3 +5,7 @@ type Common struct {
//Name string `json:"name"`
Symbol string `json:"symbol"`
}
+
+type CommonType struct {
+ Type string `json:"type"`
+}
diff --git a/golang/pkg/model/contract.go b/golang/pkg/model/contract.go
index 24ed403..9d9c7bd 100644
--- a/golang/pkg/model/contract.go
+++ b/golang/pkg/model/contract.go
@@ -7,7 +7,7 @@ type Contract struct {
DeadlineToAccept time.Time `json:"deadlineToAccept"`
Expiration time.Time `json:"expiration"`
FactionSymbol string `json:"factionSymbol"`
- Fullfilled bool `json:"fulfilled"`
+ Fulfilled bool `json:"fulfilled"`
Id string `json:"id"`
Terms *Terms `json:"terms"`
Type string `json:"type"`
diff --git a/golang/pkg/model/market.go b/golang/pkg/model/market.go
new file mode 100644
index 0000000..6c11386
--- /dev/null
+++ b/golang/pkg/model/market.go
@@ -0,0 +1,10 @@
+package model
+
+type Market struct {
+ Exchange []Common `json:"exchange"`
+ Exports []Common `json:"exports"`
+ Imports []Common `json:"imports"`
+ Symbol string `json:"symbol"`
+ TradeGoods []TradeGood `json:"tradeGoods"`
+ Transactions []Transaction `json:"transactions"`
+}
diff --git a/golang/pkg/model/shipyard.go b/golang/pkg/model/shipyard.go
new file mode 100644
index 0000000..2ba2e95
--- /dev/null
+++ b/golang/pkg/model/shipyard.go
@@ -0,0 +1,35 @@
+package model
+
+import "time"
+
+type Shipyard struct {
+ ModificationFee int `json:"modificationFee"`
+ Symbol string `json:"symbol"`
+ ShipTypes []CommonType `json:"shipTypes"`
+ Transactions []ShipyardTransaction `json:"transactions"`
+ Ships []ShipyardShip `json:"ships"`
+}
+
+type ShipyardShip struct {
+ Activity string `json:"activity"`
+ // crew
+ //Description string `json:"description"`
+ // engine
+ // frame
+ // modules
+ // mounts
+ //Name string `json:"name"`
+ PurchasePrice int `json:"purchasePrice"`
+ // reactor
+ Supply string `json:"supply"`
+ Type string `json:"type"`
+}
+
+type ShipyardTransaction struct {
+ AgentSymbol string `json:"agentSymbol"`
+ Price int `json:"price"`
+ ShipSymbol string `json:"shipSymbol"`
+ ShipType string `json:"shipType"`
+ Timestamp time.Time `json:"timestamp"`
+ WaypointSymbol string `json:"waypointSymbol"`
+}
diff --git a/golang/pkg/model/trade_good.go b/golang/pkg/model/trade_good.go
new file mode 100644
index 0000000..602f667
--- /dev/null
+++ b/golang/pkg/model/trade_good.go
@@ -0,0 +1,11 @@
+package model
+
+type TradeGood struct {
+ Activity string `json:"activity"`
+ PurchasePrice int `json:"purchasePrice"`
+ SellPrice int `json:"sellPrice"`
+ Supply string `json:"supply"`
+ Symbol string `json:"symbol"`
+ TradeVolume int `json:"tradeVolume"`
+ Type string `json:"type"`
+}
diff --git a/golang/pkg/model/waypoint.go b/golang/pkg/model/waypoint.go
index 7b71e6a..d8bd5cd 100644
--- a/golang/pkg/model/waypoint.go
+++ b/golang/pkg/model/waypoint.go
@@ -14,3 +14,11 @@ type Waypoint struct {
X int `json:"x"`
Y int `json:"y"`
}
+
+func (w Waypoint) GetX() int {
+ return w.X
+}
+
+func (w Waypoint) GetY() int {
+ return w.Y
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-21 11:09:48 +0000