Delegated Stats¶

// Fetch latest delegated stats, returns only entries
func (c *Client) FetchDelegatedEntries(ctx context.Context) ([]DelegatedEntry, error)

// Cached variant - fetches fresh data if cache expired
func (c *Client) GetDelegatedEntries(ctx context.Context) ([]DelegatedEntry, error)

// Fetch by specific date (YYYYMMDD format, e.g., "20240115")
func (c *Client) FetchDelegatedEntriesByDate(ctx context.Context, date string) ([]DelegatedEntry, error)

// Full result including header and summaries
func (c *Client) FetchDelegatedResult(ctx context.Context, date string) (*DelegatedResult, error)

// Fetch by year (returns data from December 31 of that year)
func (c *Client) FetchDelegatedByYear(ctx context.Context, year int) ([]DelegatedEntry, error)

func (c *Client) FetchDelegatedResultByYear(ctx context.Context, year int) (*DelegatedResult, error)

type DelegatedEntry struct {
    Registry   string    // "apnic"
    Country    string    // ISO 3166-1 alpha-2 country code (e.g., "JP", "CN", "AU")
    Type       string    // "ipv4", "ipv6", or "asn"
    Start      string    // Starting address or AS number
    Value      int64     // Count (IPv4: number of IPs, IPv6: prefix length, ASN: count)
    Date       time.Time // Allocation/assignment date
    Status     string    // "allocated", "assigned", "available", "reserved"
    Extensions []string  // Additional fields (opaque-id in extended format)
}

type DelegatedResult struct {
    Header    StatsFileHeader  // File metadata
    Summaries []StatsSummary   // Per-type summaries
    Entries   []DelegatedEntry // Data records
}

type StatsFileHeader struct {
    Version   string    // File format version
    Registry  string    // "apnic"
    Serial    int64     // Serial number
    Records   int64     // Total record count
    StartDate time.Time // Data start date
    EndDate   time.Time // Data end date
    UTCOffset int       // UTC offset in seconds
}

type StatsSummary struct {
    Registry string // "apnic"
    Type     string // "asn", "ipv4", or "ipv6"
    Count    int64  // Number of records
}

package main

import (
    "context"
    "fmt"
    "log"

    apnic "github.com/cyberspacesec/apnic-skills"
)

func main() {
    client := apnic.NewClient()
    ctx := context.Background()

    // Fetch latest delegated stats
    entries, err := client.FetchDelegatedEntries(ctx)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Total entries: %d\n", len(entries))

    // Print first 5 IPv4 entries
    count := 0
    for _, entry := range entries {
        if entry.Type == "ipv4" && count < 5 {
            fmt.Printf("%s: %s/%d (%s) - %s\n",
                entry.Country, entry.Start, entry.Value, entry.Status, entry.Date.Format("2006-01-02"))
            count++
        }
    }
}

// Fetch delegated stats for a specific date
result, err := client.FetchDelegatedResult(ctx, "20240115")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("File version: %s\n", result.Header.Version)
fmt.Printf("Records: %d\n", result.Header.Records)
fmt.Printf("Date range: %s to %s\n",
    result.Header.StartDate.Format("2006-01-02"),
    result.Header.EndDate.Format("2006-01-02"))

// Print summaries
for _, summary := range result.Summaries {
    fmt.Printf("%s: %d records\n", summary.Type, summary.Count)
}

// Fetch delegated stats from December 31, 2023
entries, err := client.FetchDelegatedByYear(ctx, 2023)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("2023 year-end entries: %d\n", len(entries))

// First call fetches from network
entries1, err := client.GetDelegatedEntries(ctx)
if err != nil {
    log.Fatal(err)
}

// Second call returns cached data (within TTL)
entries2, err := client.GetDelegatedEntries(ctx)
if err != nil {
    log.Fatal(err)
}

// Both return the same data
fmt.Printf("Same data: %v\n", len(entries1) == len(entries2))

// Filter by country and type
entries, err := client.GetDelegatedEntries(ctx)
if err != nil {
    log.Fatal(err)
}

// Use chain filtering
cnIPv4 := apnic.NewFilter(entries).
    ByCountry("CN").
    ByType("ipv4").
    ByStatus("allocated").
    Result()

fmt.Printf("China allocated IPv4 entries: %d\n", len(cnIPv4))

// Filter by date range
start, _ := time.Parse("2006-01-02", "2023-01-01")
end, _ := time.Parse("2006-01-02", "2023-12-31")

recentAllocs := apnic.NewFilter(entries).
    ByType("ipv4").
    ByDateRange(start, end).
    Result()

// Convert entry to CIDR notation
entries, _ := client.GetDelegatedEntries(ctx)

for _, entry := range entries {
    if entry.Type == "ipv4" {
        cidr, err := entry.CIDR()
        if err != nil {
            continue
        }
        fmt.Printf("%s -> %s (size: %d IPs)\n",
            entry.Start, cidr.String(), entry.Value)
        break // Just show first
    }
}