/api/transactions/locker/download

# Download coins from locker
curl -X GET "http://localhost:8080/api/transactions/locker/download?locker_key=0123456789abcdef0123456789abcdef"

# Example output:
# {
#   "status": "success",
#   "operation": "locker_download",
#   "coins_found": 5,
#   "coins_saved": 5,
#   "destination": "Import",
#   "locker_key": "0123456789abcdef0123456789abcdef"
# }

# Complete workflow: Download, authenticate, and grade
curl -X GET "http://localhost:8080/api/transactions/locker/download?locker_key=0123456789abcdef0123456789abcdef"
curl -X GET "http://localhost:8080/api/coins/authenticate"
curl -X GET "http://localhost:8080/api/coins/grade"

package main

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

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

type LockerDownloadResponse struct {
    Status      string `json:"status"`
    Operation   string `json:"operation"`
    CoinsFound  int    `json:"coins_found"`
    CoinsSaved  int    `json:"coins_saved"`
    Destination string `json:"destination"`
    LockerKey   string `json:"locker_key"`
}

type ErrorResponse struct {
    Status   string `json:"status"`
    Error    string `json:"error"`
    HTTPCode int    `json:"http_code"`
}

func downloadFromLocker(lockerKey string) error {
    url := fmt.Sprintf("%s/api/transactions/locker/download?locker_key=%s",
        ApiHost, lockerKey)

    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

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

    if resp.StatusCode == 200 {
        var result LockerDownloadResponse
        if err := json.Unmarshal(body, &result); err != nil {
            return err
        }

        fmt.Printf("Success! Downloaded %d coins to %s folder\n",
            result.CoinsSaved, result.Destination)
        fmt.Printf("Total coins found: %d\n", result.CoinsFound)
        fmt.Printf("Locker key: %s\n", result.LockerKey)

        // Next steps: authenticate and grade
        authenticateCoins()
        gradeCoins()

        return nil
    } else {
        var errResp ErrorResponse
        if err := json.Unmarshal(body, &errResp); err != nil {
            return err
        }
        return fmt.Errorf("Error %d: %s", errResp.HTTPCode, errResp.Error)
    }
}

func authenticateCoins() error {
    resp, err := http.Get(fmt.Sprintf("%s/api/coins/authenticate", ApiHost))
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    fmt.Println("Authentication complete")
    return nil
}

func gradeCoins() error {
    resp, err := http.Get(fmt.Sprintf("%s/api/coins/grade", ApiHost))
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    fmt.Println("Grading complete")
    return nil
}

func main() {
    lockerKey := "0123456789abcdef0123456789abcdef"

    if err := downloadFromLocker(lockerKey); err != nil {
        fmt.Printf("Error: %v\n", err)
    }
}