Enterprise API

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

const (
    baseURL  = "https://detect.ac/auth/api/enterprise"
    apiToken = "dtc_your_token_here"
)

func checkStatus(pin string) (string, int, error) {
    req, _ := http.NewRequest("GET", baseURL+"/session/status/"+pin, nil)
    req.Header.Set("X-API-Key", apiToken)

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", 0, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    status := result["status"].(string)
    stage := int(result["stage"].(float64))
    return status, stage, nil
}

func main() {
    pin := "12345678"

    for {
        status, stage, err := checkStatus(pin)
        if err != nil {
            panic(err)
        }
        fmt.Printf("Status: %s | Stage: %d\n", status, stage)

        if status == "scan-completed" {
            fmt.Println("Scan complete! Fetching results...")
            break
        }
        time.Sleep(3 * time.Second)
    }
}

package main

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

const (
    baseURL  = "https://detect.ac/auth/api/enterprise"
    apiToken = "dtc_your_token_here"
)

    func getResults(accessToken string) (map[string]interface{}, error) {
    req, _ := http.NewRequest("GET", baseURL+"/session/results/"+accessToken, nil)
    req.Header.Set("X-API-Key", apiToken)

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    if resp.StatusCode != 200 {
        return nil, fmt.Errorf("error: %v", result["error"])
    }

    return result, nil
}

func main() {
    pin := "12345678"
    accessToken := "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx-12345678"

    results, err := getResults(accessToken)
    if err != nil {
        panic(err)
    }

    data, _ := json.MarshalIndent(results, "", "  ")
    fmt.Println(string(data))

    if saved, ok := results["saved"].(bool); ok && saved {
        fmt.Printf("Scan saved with access token: %s\n", results["access_token"])
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

const (
    baseURL  = "https://detect.ac/auth/api/enterprise"
    apiToken = "dtc_your_token_here"
)

func apiRequest(method, path string, body interface{}) (map[string]interface{}, int, error) {
    var reqBody *bytes.Reader
    if body != nil {
        data, _ := json.Marshal(body)
        reqBody = bytes.NewReader(data)
    } else {
        reqBody = bytes.NewReader(nil)
    }

    req, _ := http.NewRequest(method, baseURL+path, reqBody)
    req.Header.Set("X-API-Key", apiToken)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, 0, err
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    return result, resp.StatusCode, nil
}

func main() {
    result, code, err := apiRequest("POST", "/session/create", map[string]string{"game": "mc"})
    if err != nil || code != 200 {
        fmt.Printf("Failed to create session: %v (code: %d)\n", result["error"], code)
        return
    }

    pin := result["pin"].(string)
    accessToken := result["access_token"].(string)
    downloadURL := result["download_url"].(string)
    fmt.Printf("Session created!\n  PIN: %s\n  Token: %s\n  Download: %s\n\n", pin, accessToken, downloadURL)

    fmt.Println("Waiting for scan to complete...")
    for {
        result, _, err = apiRequest("GET", "/session/status/"+pin, nil)
        if err != nil {
            fmt.Printf("Status check failed: %v\n", err)
            return
        }

        status := result["status"].(string)
        stage := int(result["stage"].(float64))
        fmt.Printf("  Status: %-18s Stage: %d\n", status, stage)

        if status == "scan-completed" {
            break
        }
        if status == "scan-timed-out" {
            fmt.Println("Scanner timed out!")
            return
        }
        time.Sleep(3 * time.Second)
    }

    result, code, err = apiRequest("GET", "/session/results/"+accessToken, nil)
    if err != nil || code != 200 {
        fmt.Printf("Failed to get results: %v\n", result["error"])
        return
    }

    data, _ := json.MarshalIndent(result["results"], "", "  ")
    fmt.Printf("\nScan Results:\n%s\n", string(data))

    if token, ok := result["access_token"].(string); ok {
        fmt.Printf("\nSaved with access token: %s\n", token)
    }
}