Go SDK

go get github.com/simiz-io/simiz-go

package main

import (
    "os"
    simiz "github.com/simiz-io/simiz-go"
)

func main() {
    // Creer le client
    client := simiz.NewClient(os.Getenv("SIMIZ_SECRET_KEY"))

    // Ou avec des options
    client := simiz.NewClient(
        os.Getenv("SIMIZ_SECRET_KEY"),
        simiz.WithAPIVersion("2024-01"),
        simiz.WithTimeout(30 * time.Second),
    )
}

package main

import (
    "context"
    "fmt"
    simiz "github.com/simiz-io/simiz-go"
)

func main() {
    client := simiz.NewClient(os.Getenv("SIMIZ_SECRET_KEY"))

    transaction, err := client.Transactions.Create(context.Background(), &simiz.TransactionCreateParams{
        Amount:        5000,
        Currency:      simiz.CurrencyXAF,
        PaymentMethod: simiz.PaymentMethodOrangeMoney,
        Payer: &simiz.Payer{
            Phone: "+237690000000",
            Name:  simiz.String("John Doe"),
            Email: simiz.String("john@example.com"),
        },
        Description: simiz.String("Achat sur Ma Boutique"),
        Reference:   simiz.String("ORDER-123"),
        Metadata: map[string]string{
            "order_id":    "123",
            "customer_id": "cust_456",
        },
        CallbackURL: simiz.String("https://votre-site.com/webhooks/simiz"),
        ReturnURL:   simiz.String("https://votre-site.com/payment/success"),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(transaction.ID)         // tx_xxx
    fmt.Println(transaction.Status)     // PENDING
    fmt.Println(transaction.PaymentURL) // URL de paiement
}

transaction, err := client.Transactions.Retrieve(ctx, "tx_xxx")
if err != nil {
    log.Fatal(err)
}

if transaction.Status == simiz.TransactionStatusCompleted {
    fmt.Println("Paiement reussi!")
}

params := &simiz.TransactionListParams{
    Limit:        simiz.Int64(20),
    Status:       simiz.String("COMPLETED"),
    CreatedAfter: simiz.String("2024-01-01"),
}

iter := client.Transactions.List(ctx, params)
for iter.Next() {
    tx := iter.Transaction()
    fmt.Printf("%s - %d\n", tx.ID, tx.Amount)
}
if err := iter.Err(); err != nil {
    log.Fatal(err)
}

package main

import (
    "encoding/json"
    "net/http"
    simiz "github.com/simiz-io/simiz-go"
)

var client = simiz.NewClient(os.Getenv("SIMIZ_SECRET_KEY"))

func checkoutHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Amount int64  `json:"amount"`
        Phone  string `json:"phone"`
    }
    json.NewDecoder(r.Body).Decode(&req)

    tx, err := client.Transactions.Create(r.Context(), &simiz.TransactionCreateParams{
        Amount:        req.Amount,
        Currency:      simiz.CurrencyXAF,
        PaymentMethod: simiz.PaymentMethodOrangeMoney,
        Payer:         &simiz.Payer{Phone: req.Phone},
        CallbackURL:   simiz.String("https://votre-site.com/webhooks"),
    })
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(map[string]string{
        "transaction_id": tx.ID,
        "payment_url":    tx.PaymentURL,
    })
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    payload, _ := io.ReadAll(r.Body)
    signature := r.Header.Get("X-Simiz-Signature")

    event, err := simiz.ConstructEvent(
        payload,
        signature,
        os.Getenv("SIMIZ_WEBHOOK_SECRET"),
    )
    if err != nil {
        http.Error(w, "Invalid signature", http.StatusBadRequest)
        return
    }

    switch event.Type {
    case "transaction.completed":
        var tx simiz.Transaction
        json.Unmarshal(event.Data, &tx)
        // Mettre a jour la commande
        updateOrder(tx.ID, "paid")
    case "transaction.failed":
        // Gerer l'echec
    }

    w.WriteHeader(http.StatusOK)
}

tx, err := client.Transactions.Create(ctx, params)
if err != nil {
    var authErr *simiz.AuthenticationError
    var invalidErr *simiz.InvalidRequestError
    var apiErr *simiz.APIError

    switch {
    case errors.As(err, &authErr):
        // Cle API invalide
        log.Println("Verifiez votre cle API")
    case errors.As(err, &invalidErr):
        // Parametres invalides
        log.Printf("Erreur: %s, Param: %s", invalidErr.Message, invalidErr.Param)
    case errors.As(err, &apiErr):
        // Erreur serveur
        log.Printf("Erreur API: %s", apiErr.Message)
    default:
        log.Printf("Erreur inconnue: %v", err)
    }
    return
}