From 8ed0806f10f61327d57b43ea7d5f4eb799e2a0bb Mon Sep 17 00:00:00 2001 From: William Perron Date: Wed, 31 Aug 2022 13:27:41 +0000 Subject: [PATCH] add list claims and improve error handling --- store.go | 115 ++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 88 insertions(+), 27 deletions(-) diff --git a/store.go b/store.go index 49648ee..a75217d 100644 --- a/store.go +++ b/store.go @@ -5,6 +5,7 @@ import ( "database/sql" _ "embed" "fmt" + "strings" _ "github.com/mattn/go-sqlite3" ) @@ -12,34 +13,55 @@ import ( //go:embed migrations/init.sql var initScript string -const ( - CLAIM_TYPE_AREA = iota - CLAIM_TYPE_REGION - CLAIM_TYPE_TRADE -) +type ClaimType string -var claimTypeEnum = map[string]int{ - "area": CLAIM_TYPE_AREA, - "region": CLAIM_TYPE_REGION, - "trade": CLAIM_TYPE_TRADE, +func ClaimTypeFromString(s string) (ClaimType, error) { + switch s { + case CLAIM_TYPE_AREA: + return CLAIM_TYPE_AREA, nil + case CLAIM_TYPE_REGION: + return CLAIM_TYPE_REGION, nil + case CLAIM_TYPE_TRADE: + return CLAIM_TYPE_TRADE, nil + } + return "", fmt.Errorf("no claim type matching '%s'", s) } -var claimTypeEnumVals = map[int]string{ +const ( + CLAIM_TYPE_AREA = "area" + CLAIM_TYPE_REGION = "region" + CLAIM_TYPE_TRADE = "trade" +) + +var claimTypeToColumn = map[ClaimType]string{ CLAIM_TYPE_AREA: "area", CLAIM_TYPE_REGION: "region", - CLAIM_TYPE_TRADE: "trade", -} - -var claimTypeToColumn = map[string]string{ - "area": "area", - "region": "region", - "trade": "trade_node", + CLAIM_TYPE_TRADE: "trade_node", } type Store struct { db *sql.DB } +type Claim struct { + ID int + Player string + Name string + Type ClaimType +} + +func (c Claim) String() string { + return fmt.Sprintf("id=%d player=%s claim_type=%s name=%s", c.ID, c.Player, c.Type, c.Name) +} + +type ErrConflict struct { + Conflicts []string +} + +func (ec ErrConflict) Error() string { + return fmt.Sprintf("found conflicting provinces: %s", strings.Join(ec.Conflicts, ", ")) +} + func NewStore(conn string) (*Store, error) { db, err := sql.Open("sqlite3", conn) if err != nil { @@ -56,7 +78,7 @@ func NewStore(conn string) (*Store, error) { }, nil } -func (s *Store) Claim(ctx context.Context, player, province string, typ int) error { +func (s *Store) Claim(ctx context.Context, player, province string, claimType ClaimType) error { tx, err := s.db.Begin() if err != nil { return fmt.Errorf("failed to begin transaction: %w", err) @@ -64,24 +86,32 @@ func (s *Store) Claim(ctx context.Context, player, province string, typ int) err defer tx.Commit() // Check conflicts - stmt, err := s.db.PrepareContext(ctx, fmt.Sprintf(`SELECT COUNT(1) FROM provinces WHERE provinces.%s = ? and provinces.name in ( + stmt, err := s.db.PrepareContext(ctx, fmt.Sprintf(`SELECT provinces.name FROM provinces WHERE provinces.%s = ? and provinces.name in ( SELECT provinces.name FROM claims LEFT JOIN provinces ON claims.val = provinces.trade_node WHERE claims.claim_type = 'trade' UNION SELECT provinces.name from claims LEFT JOIN provinces ON claims.val = provinces.region WHERE claims.claim_type = 'region' UNION SELECT provinces.name from claims LEFT JOIN provinces ON claims.val = provinces.area WHERE claims.claim_type = 'area' -)`, claimTypeToColumn[claimTypeEnumVals[typ]])) +)`, claimTypeToColumn[claimType])) if err != nil { return fmt.Errorf("failed to prepare conflicts query: %w", err) } - row := stmt.QueryRowContext(ctx, province) - var count int - err = row.Scan(&count) + rows, err := stmt.QueryContext(ctx, province) if err != nil { - return fmt.Errorf("failed to get count of conflicting provinces: %w", err) + return fmt.Errorf("failed to get conflicting provinces: %w", err) + } + + conflicts := make([]string, 0) + for rows.Next() { + var p string + err = rows.Scan(&p) + if err != nil { + return fmt.Errorf("failed to scan row: %w", err) + } + conflicts = append(conflicts, p) } - if count > 0 { - return fmt.Errorf("found %d conflicting provinces", count) + if len(conflicts) > 0 { + return ErrConflict{Conflicts: conflicts} } stmt, err = s.db.PrepareContext(ctx, "INSERT INTO claims (player, claim_type, val) VALUES (?, ?, ?)") @@ -89,10 +119,41 @@ func (s *Store) Claim(ctx context.Context, player, province string, typ int) err return fmt.Errorf("failed to prepare claim query: %w", err) } - _, err = stmt.ExecContext(ctx, player, claimTypeEnumVals[typ], province) + _, err = stmt.ExecContext(ctx, player, claimType, province) if err != nil { return fmt.Errorf("failed to insert claim: %w", err) } return nil } + +func (s *Store) ListClaims(ctx context.Context) ([]Claim, error) { + stmt, err := s.db.PrepareContext(ctx, `SELECT id, player, claim_type, val FROM claims`) + if err != nil { + return nil, fmt.Errorf("failed to prepare query: %w", err) + } + + rows, err := stmt.QueryContext(ctx) + if err != nil { + return nil, fmt.Errorf("failed to execute query: %w", err) + } + + claims := make([]Claim, 0) + for rows.Next() { + c := Claim{} + var rawType string + err = rows.Scan(&c.ID, &c.Player, &rawType, &c.Name) + if err != nil { + return nil, fmt.Errorf("failed to scan row: %w", err) + } + cl, err := ClaimTypeFromString(rawType) + if err != nil { + return nil, fmt.Errorf("unexpected error converting raw claim type: %w", err) + } + c.Type = cl + + claims = append(claims, c) + } + + return claims, nil +}