import os
import disruptive as dt
​
# It is good practice to fetch credentials from an environment or file.
key_id = os.environ.get('DT_SERVICE_ACCOUNT_KEY_ID', '')
secret = os.environ.get('DT_SERVICE_ACCOUNT_SECRET', '')
email = os.environ.get('DT_SERVICE_ACCOUNT_EMAIL', '')
​
# Using the fetched credentials, authenticate the package.
dt.default_auth = dt.Auth.service_account(key_id, secret, email)

const jwt = require('jsonwebtoken')    // npm install [email protected]
const axios = require('axios').default // npm install [email protected]
​
// authentication details
const serviceAccountKeyID  = process.env.DT_SERVICE_ACCOUNT_KEY_ID
const serviceAccountSecret = process.env.DT_SERVICE_ACCOUNT_SECRET
const serviceAccountEmail  = process.env.DT_SERVICE_ACCOUNT_EMAIL
​
// Creates a JWT from the arguments, and exchanges it for an 
// access token which is returned as a promise. If an error 
// occurs at any point, an error is thrown and the returned 
// promise is rejected.
async function getAccessToken(keyID, email, secret) {
    // Construct the JWT header.
    let jwtHeaders = {
        'alg': 'HS256',
        'kid': keyID,
    }
    
    // Construct the JWT payload.
    let jwtPayload = {
        'iat': Math.floor(Date.now() / 1000),        // current unixtime
        'exp': Math.floor(Date.now() / 1000) + 3600, // expiration unixtime
        'aud': 'https://identity.disruptive-technologies.com/oauth2/token',
        'iss': email,
    }
    
    // Sign and encode JWT with the secret.
    const jwtEncoded = jwt.sign(
        jwtPayload,
        secret,
        {
            header: jwtHeaders,
            algorithm: 'HS256',
        },
    )
​
    // Prepare POST request data.
    const requestObject = {
        'assertion': jwtEncoded,
        'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
    }
​
    // Converts the requestObject to a Form URL-Encoded string.
    const requestData = Object.keys(requestObject).map(function(key) {
        return encodeURIComponent(key) + '=' + encodeURIComponent(requestObject[key])
    }).join('&')
    
    // Exchange JWT for access token.
    const accessTokenResponse = await axios({
        method: 'POST',
        url: 'https://identity.disruptive-technologies.com/oauth2/token',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        data: requestData,
    }).catch(function (error) {
        // Prints the error response (if any), an re-throws the error.
        if (error.response) {
            console.log(error.response.data)
        }
        throw error
    })
​
    // Return the access token in the request.
    return accessTokenResponse.data.access_token
}
async function main() {
    // Get an access token using an OAuth2 authentication flow.
    const accessToken = await getAccessToken(
        serviceAccountKeyID,
        serviceAccountEmail,
        serviceAccountSecret,
    )
​
    // Test the token by sending a GET request for a list of projects.
    const response = await axios({
        method: 'GET',
        url: 'https://api.disruptive-technologies.com/v2/projects',
        headers: { 'Authorization': 'Bearer ' + accessToken },
    })
​
    // Print response data.
    console.log(JSON.stringify(response.data, null, 2))
}
main()

package main
​
import (
	"encoding/json"
	"fmt"
	jwt "github.com/dgrijalva/jwt-go" // go get github.com/dgrijalva/[email protected]
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)
​
const (
	tokenEndpoint       = "https://identity.disruptive-technologies.com/oauth2/token"
	listDevicesEndpoint = "https://api.d21s.com/v2/projects"
)
​
func getAccessToken(keyID string, secret string, email string) (string, error) {
	// Construct the JWT header.
	jwtHeader := map[string]interface{}{
		"alg": "HS256",
		"kid": keyID,
	}
​
	// Construct the JWT payload. (Claims in golang)
	jwtPayload := &jwt.StandardClaims{
		IssuedAt:  time.Now().Unix(),                    // current unixtime
		ExpiresAt: time.Now().Add(1 * time.Hour).Unix(), // expiration unixtime
		Audience:  tokenEndpoint,
		Issuer:    email,
	}
​
	// Sign and encode JWT with the secret.
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwtPayload)
	token.Header = jwtHeader
	encodedJwt, _ := token.SignedString([]byte(secret))
​
	// Prepare HTTP POST request data.
	// note: Form URL-Encode required and applied with .Encode()
	reqData := url.Values{
		"assertion":  {encodedJwt},
		"grant_type": {"urn:ietf:params:oauth:grant-type:jwt-bearer"},
	}.Encode()
​
	// Create a new request object.
	req, err := http.NewRequest(
		"POST",
		tokenEndpoint,
		strings.NewReader(reqData),
	)
	if err != nil {
		return "", err
	}
​
	// Set request headers.
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
​
	// Create a client and send the request.
	client := &http.Client{Timeout: time.Second * 3}
	res, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer res.Body.Close()
​
	type AuthResponse struct {
		AccessToken string `json:"access_token"`
		TokenType   string `json:"token_type"`
		ExpiresIn   int    `json:"expires_in"`
	}
​
	// Convert response body to AuthResponse.
	var authResponse AuthResponse
	if err := json.NewDecoder(res.Body).Decode(&authResponse); err != nil {
		return "", err
	}
​
	// Return the access token string.
	return authResponse.AccessToken, nil
}
​
func listProjects(accessToken string) error {
	// Create the request object with method, URL, but no optional body.
	req, err := http.NewRequest("GET", listDevicesEndpoint, nil)
	if err != nil {
		return err
	}
​
	// Set the authentication header with access token.
	req.Header.Set("Authorization", "Bearer "+accessToken)
​
	// Create a custom http Client with timeout.
	client := &http.Client{Timeout: time.Second * 3}
​
	// Send an HTTP request and return an HTTP response.
	res, err := client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
​
	type ProjectsResponse struct {
		Projects []struct {
			Name                    string `json:"name"`
			DisplayName             string `json:"displayName"`
			Inventory               bool   `json:"inventory"`
			Organization            string `json:"organization"`
			OrganizationDisplayName string `json:"organizationDisplayName"`
			SensorCount             int    `json:"sensorCount"`
			CloudConnectorCount     int    `json:"cloudConnectorCount"`
		}
		NextPageToken string `json:"nextPageToken"`
	}
​
	var response ProjectsResponse
	if err = json.NewDecoder(res.Body).Decode(&response); err != nil {
		return err
	}
​
	// Print information about the projects.
	for _, project := range response.Projects {
		fmt.Println(project.DisplayName)
		fmt.Printf("\t%d Sensors\n", project.SensorCount)
		fmt.Printf("\t%d Cloud Connectors\n", project.CloudConnectorCount)
	}
​
	return nil
}
​
func main() {
	// OAuth2 authentication flow
	accessToken, err := getAccessToken(
		os.Getenv("DT_SERVICE_ACCOUNT_KEY_ID"),
		os.Getenv("DT_SERVICE_ACCOUNT_SECRET"),
		os.Getenv("DT_SERVICE_ACCOUNT_EMAIL"),
	)
	if err != nil {
		log.Fatal(err)
	}
​
	// Test the access token by listing all projects.
	if err := listProjects(accessToken); err != nil {
		log.Fatal(err)
	}
}

// Construct the JWT header.
let jwtHeaders = {
    'alg': 'HS256',
    'kid': keyID,
}
​
// Construct the JWT payload.
let jwtPayload = {
    'iat': Math.floor(Date.now() / 1000),        // current unixtime
    'exp': Math.floor(Date.now() / 1000) + 3600, // expiration unixtime
    'aud': 'https://identity.disruptive-technologies.com/oauth2/token',
    'iss': email,
}

// Construct the JWT header.
jwtHeader := map[string]interface{}{
	"alg": "HS256",
	"kid": keyID,
}
​
// Construct the JWT payload. (Claims in golang)
jwtPayload := &jwt.StandardClaims{
	IssuedAt:  time.Now().Unix(),                    // current unixtime
	ExpiresAt: time.Now().Add(1 * time.Hour).Unix(), // expiration unixtime
	Audience:  tokenEndpoint,
	Issuer:    email,
}

// Sign and encode JWT with the secret.
const jwtEncoded = jwt.sign(
    jwtPayload,
    secret,
    {
        header: jwtHeaders,
        algorithm: 'HS256',
    },
)

// Sign and encode JWT with the secret.
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwtPayload)
token.Header = jwtHeader
encodedJwt, _ := token.SignedString([]byte(secret))

// Prepare POST request data.
const requestObject = {
    'assertion': jwtEncoded,
    'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
}
​
// Converts the requestObject to a Form URL-Encoded string.
const requestData = Object.keys(requestObject).map(function(key) {
    return encodeURIComponent(key) + '=' + encodeURIComponent(requestObject[key])
}).join('&')
​
// Exchange JWT for access token.
const accessTokenResponse = await axios({
    method: 'POST',
    url: 'https://identity.disruptive-technologies.com/oauth2/token',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    data: requestData,
}).catch(function (error) {
    if (error.response) {
        console.log(error.response.data)
    }
    throw error
})

// Prepare HTTP POST request data.
// note: Form URL-Encode required and applied with .Encode()
reqData := url.Values{
	"assertion":  {encodedJwt},
	"grant_type": {"urn:ietf:params:oauth:grant-type:jwt-bearer"},
}.Encode()
​
// Create a new request object.
req, err := http.NewRequest(
	"POST",
	tokenEndpoint,
	strings.NewReader(reqData),
)
if err != nil {
	return "", err
}
​
// Set request headers.
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
​
// Create a client and send the request.
client := &http.Client{Timeout: time.Second * 3}
res, err := client.Do(req)
if err != nil {
	return "", err
}
defer res.Body.Close()

// Test the token by sending a GET request for a list of projects.
const response = await axios({
    method: 'GET',
    url: 'https://api.disruptive-technologies.com/v2/projects',
    headers: { 'Authorization': 'Bearer ' + accessToken },
})

// Test the access token by listing all projects.
if err := listProjects(accessToken); err != nil {
	log.Fatal(err)
}