Orders

import (
    "log"
    aries "github.com/aries-exchange/go-sdk"
)

client := aries.NewClient(
    aries.WithClientID("your_client_id"),
    aries.WithClientSecret("your_client_secret"),
)

order, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:      "AAPL",
    Quantity:    10,
    Side:        "buy",
    OrderType:   "market",
    TimeInForce: "day",
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Order ID: %s\n", order.ID)
fmt.Printf("Status: %s\n", order.Status)

updated, err := client.Orders.UpdateOrder("ord_123456", &aries.OrderUpdate{
    Quantity: 15,
    Price:    150.50,
})
if err != nil {
    log.Fatal(err)
}

err := client.Orders.CancelOrder("ord_123456")
if err != nil {
    log.Fatal(err)
}

preview, err := client.Orders.PreviewOrder(&aries.OrderRequest{
    Symbol:    "AAPL",
    Quantity:  100,
    Side:      "buy",
    OrderType: "market",
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Estimated cost: $%.2f\n", preview.EstimatedCost)

marketBuy, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:    "AAPL",
    Quantity:  10,
    Side:      "buy",
    OrderType: "market",
})

limitBuy, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:    "AAPL",
    Quantity:  10,
    Side:      "buy",
    OrderType: "limit",
    Price:     150.00,
})

stopLoss, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:    "AAPL",
    Quantity:  10,
    Side:      "sell",
    OrderType: "stop",
    StopPrice: 145.00,
})

stopLimit, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:      "AAPL",
    Quantity:    10,
    Side:        "sell",
    OrderType:   "stop_limit",
    StopPrice:   145.00,
    Price:       144.50,
})

preview, err := client.Orders.PreviewOrder(&aries.OrderRequest{
    Symbol:    "TSLA",
    Quantity:  5,
    Side:      "buy",
    OrderType: "market",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println("Order Preview:")
fmt.Printf("Estimated price: $%.2f\n", preview.EstimatedPrice)
fmt.Printf("Estimated cost: $%.2f\n", preview.EstimatedCost)
fmt.Printf("Commission: $%.2f\n", preview.Commission)
fmt.Printf("Total: $%.2f\n", preview.Total)

if preview.Total <= 5000 {
    order, err := client.Orders.PlaceOrder(&aries.OrderRequest{
        Symbol:    "TSLA",
        Quantity:  5,
        Side:      "buy",
        OrderType: "market",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Order placed: %s\n", order.ID)
}

entry, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:    "NVDA",
    Quantity:  10,
    Side:      "buy",
    OrderType: "limit",
    Price:     500.00,
})
if err != nil {
    log.Fatal(err)
}

if entry.Status == "filled" {
    entryPrice := entry.AverageFillPrice

    profitTarget, err := client.Orders.PlaceOrder(&aries.OrderRequest{
        Symbol:      "NVDA",
        Quantity:    10,
        Side:        "sell",
        OrderType:   "limit",
        Price:       entryPrice * 1.05,
        TimeInForce: "gtc",
    })

    stopLoss, err := client.Orders.PlaceOrder(&aries.OrderRequest{
        Symbol:      "NVDA",
        Quantity:    10,
        Side:        "sell",
        OrderType:   "stop",
        StopPrice:   entryPrice * 0.97,
        TimeInForce: "gtc",
    })

    fmt.Printf("Profit target: %s\n", profitTarget.ID)
    fmt.Printf("Stop loss: %s\n", stopLoss.ID)
}

type OrderRequest struct {
    Symbol      string   `json:"symbol"`
    Quantity    int      `json:"quantity"`
    Side        string   `json:"side"`
    OrderType   string   `json:"order_type"`
    Price       float64  `json:"price,omitempty"`
    StopPrice   float64  `json:"stop_price,omitempty"`
    TimeInForce string   `json:"time_in_force"`
}

type Order struct {
    ID               string    `json:"id"`
    Symbol           string    `json:"symbol"`
    Quantity         int       `json:"quantity"`
    Side             string    `json:"side"`
    OrderType        string    `json:"order_type"`
    Price            float64   `json:"price"`
    Status           string    `json:"status"`
    FilledQuantity   int       `json:"filled_quantity"`
    AverageFillPrice float64   `json:"average_fill_price"`
    TimeInForce      string    `json:"time_in_force"`
    CreatedAt        time.Time `json:"created_at"`
}

type OrderPreview struct {
    Symbol        string  `json:"symbol"`
    Quantity      int     `json:"quantity"`
    EstimatedPrice float64 `json:"estimated_price"`
    EstimatedCost float64 `json:"estimated_cost"`
    Commission    float64 `json:"commission"`
    Total         float64 `json:"total"`
}

order, err := client.Orders.PlaceOrder(&aries.OrderRequest{
    Symbol:    "AAPL",
    Quantity:  10,
    Side:      "buy",
    OrderType: "market",
})

if err != nil {
    var apiErr *aries.APIError
    if errors.As(err, &apiErr) {
        switch apiErr.Code {
        case "insufficient_funds":
            log.Println("Not enough buying power")
        case "invalid_symbol":
            log.Println("Invalid stock symbol")
        case "market_closed":
            log.Println("Market is closed")
        default:
            log.Printf("Error: %s", apiErr.Message)
        }
    }
}