Go SDK¶

package main

import (
    "context"
    "fmt"
    "github.com/ubiship/amp-go"
)

func main() {
    client := amp.NewClient("amp_live_xxxxxxxxxxxxx")

    // Create a mission
    mission, err := client.Missions.Create(context.Background(), &amp.MissionCreateParams{
        Name:       "Go SDK Test",
        Objectives: []string{"Test the SDK"},
        Platforms:  []string{"twitter"},
        Duration:   7,
    })
    if err != nil {
        panic(err)
    }

    fmt.Printf("Created mission: %s\n", mission.ID)
}

client := amp.NewClient(
    "amp_live_xxx",
    amp.WithBaseURL("https://custom.api.url"),
    amp.WithTimeout(60 * time.Second),
    amp.WithHTTPClient(customHTTPClient),
)

// Reads AMP_API_KEY from environment
client := amp.NewClientFromEnv()

// List missions
missions, err := client.Missions.List(ctx, &amp.MissionListParams{
    Status: amp.String("active"),
    Limit:  amp.Int64(20),
})

// Create mission
mission, err := client.Missions.Create(ctx, &amp.MissionCreateParams{
    Name:       "My Mission",
    Objectives: []string{"Drive awareness"},
    Platforms:  []string{"twitter", "linkedin"},
    Constraints: &amp.MissionConstraints{
        Tone:            "professional",
        Cadence:         "daily",
        PostsPerDay:     2,
        RequireApproval: true,
    },
    Duration: 30,
})

// Get mission
mission, err := client.Missions.Get(ctx, "msn_xxx")

// Update mission
mission, err := client.Missions.Update(ctx, "msn_xxx", &amp.MissionUpdateParams{
    Constraints: &amp.MissionConstraints{
        PostsPerDay: 3,
    },
})

// Pause mission
mission, err := client.Missions.Pause(ctx, "msn_xxx")

// Resume mission
mission, err := client.Missions.Resume(ctx, "msn_xxx")

// Delete mission
err := client.Missions.Delete(ctx, "msn_xxx")

// List content
content, err := client.Content.List(ctx, &amp.ContentListParams{
    MissionID: amp.String("msn_xxx"),
    Status:    amp.String("pending_review"),
})

// Get content
content, err := client.Content.Get(ctx, "cnt_xxx")

// Approve content
content, err := client.Content.Approve(ctx, "cnt_xxx", &amp.ContentApproveParams{
    Notes: amp.String("Looks good"),
})

// Reject content
content, err := client.Content.Reject(ctx, "cnt_xxx", &amp.ContentRejectParams{
    Reason:     "Too casual",
    Feedback:   amp.String("Use professional tone"),
    Regenerate: amp.Bool(true),
})

// Get overview
analytics, err := client.Analytics.Overview(ctx, &amp.AnalyticsParams{
    Period: "30d",
})

// Get mission analytics
analytics, err := client.Analytics.Mission(ctx, "msn_xxx")

// Get costs
costs, err := client.Analytics.Costs(ctx, &amp.AnalyticsParams{
    Period: "30d",
})

mission, err := client.Missions.Get(ctx, "msn_xxx")
if err != nil {
    var apiErr *amp.Error
    if errors.As(err, &apiErr) {
        switch apiErr.Code {
        case "not_found":
            // Handle not found
        case "unauthorized":
            // Handle auth error
        case "rate_limit_exceeded":
            // Handle rate limit
            time.Sleep(time.Duration(apiErr.RetryAfter) * time.Second)
        default:
            // Handle other errors
        }
    }
    return err
}

// Iterate through all missions
params := &amp.MissionListParams{Limit: amp.Int64(20)}

for {
    missions, err := client.Missions.List(ctx, params)
    if err != nil {
        return err
    }

    for _, mission := range missions.Data {
        fmt.Println(mission.ID)
    }

    if !missions.HasMore {
        break
    }
    params.StartingAfter = amp.String(missions.Data[len(missions.Data)-1].ID)
}

func handleWebhook(w http.ResponseWriter, r *http.Request) {
    payload, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Error reading body", http.StatusBadRequest)
        return
    }

    signature := r.Header.Get("X-AMP-Signature")
    timestamp := r.Header.Get("X-AMP-Timestamp")

    event, err := amp.ConstructEvent(payload, signature, timestamp, webhookSecret)
    if err != nil {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }

    switch event.Type {
    case "content.published":
        var content amp.Content
        if err := json.Unmarshal(event.Data, &content); err != nil {
            http.Error(w, "Error parsing event", http.StatusBadRequest)
            return
        }
        // Handle published content
    }

    w.WriteHeader(http.StatusOK)
}

// Use test mode
client := amp.NewClient("amp_test_xxx")

// Or mock client
mockClient := amp.NewMockClient()
mockClient.Missions.On("Create", mock.Anything, mock.Anything).Return(&amp.Mission{
    ID:     "msn_test",
    Status: "active",
}, nil)