/api/program/list-serial-numbers

# Get list of serial numbers
curl -X GET "http://localhost:8080/api/program/list-serial-numbers"

# Pretty print with jq
curl -X GET "http://localhost:8080/api/program/list-serial-numbers" | jq '.'

# Get only coins in Bank folder
curl -X GET "http://localhost:8080/api/program/list-serial-numbers" \
  | jq '.coins[] | select(.folder == "Bank")'

# Count coins by folder
curl -X GET "http://localhost:8080/api/program/list-serial-numbers" \
  | jq '.coins | group_by(.folder) | map({folder: .[0].folder, count: length})'

# Find specific serial number
curl -X GET "http://localhost:8080/api/program/list-serial-numbers" \
  | jq '.coins[] | select(.serial_number == 1234567)'

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

const ApiHost = "http://localhost:8080"

type Coin struct {
    SerialNumber int    `json:"serial_number"`
    Denomination int    `json:"denomination"`
    Folder       string `json:"folder"`
}

type ListResponse struct {
    Status     string `json:"status"`
    Operation  string `json:"operation"`
    Wallet     string `json:"wallet"`
    Coins      []Coin `json:"coins"`
    TotalCoins int    `json:"total_coins"`
}

// Denomination code to value mapping
var denominationValues = map[int]float64{
    -8: 0.00000001, -7: 0.0000001, -1: 0.1,
    0: 1, 1: 5, 2: 25, 3: 100, 4: 250, 5: 1000,
    6: 5000, 7: 25000, 8: 100000, 9: 250000, 10: 1000000,
}

func main() {
    resp, err := http.Get(fmt.Sprintf("%s/api/program/list-serial-numbers", ApiHost))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)

    var result ListResponse
    if err := json.Unmarshal(body, &result); err != nil {
        panic(err)
    }

    if result.Status == "error" {
        fmt.Println("Error:", result.Operation)
        return
    }

    fmt.Printf("Wallet: %s\n", result.Wallet)
    fmt.Printf("Total Coins: %d\n\n", result.TotalCoins)

    // Group by folder
    byFolder := make(map[string][]Coin)
    for _, coin := range result.Coins {
        byFolder[coin.Folder] = append(byFolder[coin.Folder], coin)
    }

    // Display coins by folder
    for folder, coins := range byFolder {
        fmt.Printf("%s (%d coins):\n", folder, len(coins))
        for _, coin := range coins {
            value := denominationValues[coin.Denomination]
            fmt.Printf("  SN %d - %.2fcc\n", coin.SerialNumber, value)
        }
        fmt.Println()
    }

    // Calculate total value
    var totalValue float64
    for _, coin := range result.Coins {
        if val, ok := denominationValues[coin.Denomination]; ok {
            totalValue += val
        }
    }
    fmt.Printf("Total Value: %.2fcc\n", totalValue)
}

import requests
from collections import defaultdict

API_HOST = "http://localhost:8080"

# Denomination code to value mapping
DENOMINATION_MAP = {
    -8: 0.00000001, -7: 0.0000001, -1: 0.1,
    0: 1, 1: 5, 2: 25, 3: 100, 4: 250, 5: 1000,
    6: 5000, 7: 25000, 8: 100000, 9: 250000, 10: 1000000,
    11: 'Special'
}

def list_serial_numbers():
    try:
        response = requests.get(f"{API_HOST}/api/program/list-serial-numbers")
        result = response.json()

        if result['status'] == 'error':
            print(f"Error: {result['message']}")
            return

        print(f"Wallet: {result['wallet']}")
        print(f"Total Coins: {result['total_coins']}\n")

        # Group by folder
        by_folder = defaultdict(list)
        for coin in result['coins']:
            by_folder[coin['folder']].append(coin)

        # Display coins by folder
        for folder, coins in by_folder.items():
            print(f"\n{folder} ({len(coins)} coins):")
            for coin in coins:
                value = DENOMINATION_MAP[coin['denomination']]
                print(f"  SN {coin['serial_number']} - {value}cc")

        # Calculate total value
        total_value = sum(
            DENOMINATION_MAP[coin['denomination']]
            for coin in result['coins']
            if isinstance(DENOMINATION_MAP[coin['denomination']], (int, float))
        )
        print(f"\nTotal Value: {total_value}cc")

        # Find duplicates
        serial_counts = defaultdict(int)
        for coin in result['coins']:
            serial_counts[coin['serial_number']] += 1

        duplicates = {sn: count for sn, count in serial_counts.items() if count > 1}
        if duplicates:
            print("\n⚠️  Duplicate Serial Numbers:")
            for sn, count in duplicates.items():
                print(f"  SN {sn} appears {count} times")

    except requests.RequestException as e:
        print(f"Error fetching serial numbers: {e}")

if __name__ == "__main__":
    list_serial_numbers()