{
  "name": "unleash-live-api",
  "dependencies": {
    "amazon-cognito-identity-js": "^6.1.2",
    "aws-sdk": "^2.1336.0",
    "graphql-request": "^5.2.0",
    "jwt-decode": "^3.1.2"
  }
}

export const API_URL_DEFAULT = "api.unleashlive.com";
export const FLIGHTS_CDN_DEFAULT = "https://flights.unleashlive.com";
export const USER_NAME = 'test@user-name.com';
export const PASSWORD = 'test-password';
export const GRAPHQL_ENDPOINT = 'https://mediadrive-api.unleashlive.com/graphql';
export const FOLDER_ID = 'test-folder-id';
export const UPLOAD_BUCKET_NAME = 'library-upload-syd-cloud';
export const MEDIA_DRIVE_BUCKET_NAME = 'library-syd-cloud';
export const ACCOUNT_ID = '590171865298';

import AmazonCognitoIdentity from "amazon-cognito-identity-js";
import jwt_decode from "jwt-decode";
import AWS from "aws-sdk";
import {ACCOUNT_ID} from "../examples/exampleConfig.js";

const REGION = 'ap-southeast-2';
const IDENTITY_POOL_ID = 'ap-southeast-2:359c9d8b-02e4-457f-b185-4f3ff3f639d7';
const POOL_DATA = {
  UserPoolId: 'ap-southeast-2_UnpJmDeN5',
  ClientId: '7jhe1lfkb5pvhbkicc3d14m0ej'
};

export function initClient(idToken) {
  AWS.config.region = REGION;
  AWS.config.credentials = new AWS.CognitoIdentityCredentials({
    AccountId: ACCOUNT_ID,
    IdentityPoolId: IDENTITY_POOL_ID,
    Logins: {
      [`cognito-idp.${REGION}.amazonaws.com/${POOL_DATA.UserPoolId}`]: idToken
    },
  });
}
export function getUserPool() {
  return new AmazonCognitoIdentity.CognitoUserPool(POOL_DATA);
}

export function getCognitoUser(email) {
  const userData = {
    Username: email,
    Pool: getUserPool()
  };
  return new AmazonCognitoIdentity.CognitoUser(userData);
}

export function decodeJWTToken(token) {
  const {email, exp, auth_time, token_use, sub} = jwt_decode(token.idToken);
  return {token, email, exp, uid: sub, auth_time, token_use};
}

export function getAuthDetails(email, password) {
  const authenticationData = {
    Username: email,
    Password: password,
  };
  return new AmazonCognitoIdentity.AuthenticationDetails(authenticationData);
}

export function getCredentials() {
  return new AWS.CognitoIdentityCredentials({
    AccountId: ACCOUNT_ID,
    IdentityPoolId: AWS.config.credentials.params.IdentityPoolId,
    Logins: AWS.config.credentials.params.Logins,
  });
}

import {initClient, decodeJWTToken, getAuthDetails, getCognitoUser} from "./cognito.js";

export function signIn(email, password) {
  return new Promise((resolve) => {
    getCognitoUser(email).authenticateUser(getAuthDetails(email, password), {
      onSuccess: (result) => {

        const jwtTokenPayload = result.getIdToken().decodePayload();
        const token = {
          accessToken: result.getAccessToken().getJwtToken(),
          idToken: result.getIdToken().getJwtToken(),
          refreshToken: result.getRefreshToken().getToken(),
          identityId: jwtTokenPayload['custom:identityId'],
          companyId: jwtTokenPayload['custom:companyId'],
          teamId: jwtTokenPayload['custom:teamId'],
        }
        initClient(token.idToken);
        return resolve({statusCode: 200, response: decodeJWTToken(token)});
      },

      onFailure: (err) => {
        return resolve({statusCode: 400, response: err.message || JSON.stringify(err)});
      },
    });
  });
}

import {signIn} from "../src/actions.js";

signIn(USER_NAME, PASSWORD)
.then(async (response) => {
  // Perform media drive actions
})
.catch(e => {
  console.error(e);
});

query GetLibraryItem {
  get(
    item: {id: "ItemId1"}
  ) {
    teamId
    location
    type
    tags
    createdAt
    deviceId
    id
    name
    parentId
    s3Path
    updatedAt
    mimeType
    annotations
    metadata {
      addonId
      camaperturevalue
      camfnumber
      camfocallength
      camfocallengthin35mmformat
      camiso
      childItemsNumber
      exifimageheight
      exifimagewidth
      gpsalt
      gpslat
      gpslatref
      gpslng
      gpslngref
      height
      isPanoramic
      lastmodified
      make
      model
      orientation
      size
      software
      type
      width
    }
  }
}

import * as graphQlRequest from 'graphql-request'
import {signIn} from "../src/actions.js";
import {FOLDER_ID, GRAPHQL_ENDPOINT, PASSWORD, USER_NAME} from "./exampleConfig.js";

const GraphQLClient = graphQlRequest.GraphQLClient;
const gql = graphQlRequest.gql;

export function getFolderItem(signInResponse, id) {
  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const getQuery = gql`
    query GetLibraryItem{
      get(item: {id: "${id}"}) {
        id,
        location
      }
    }`

  return graphQLClient.request(getQuery);
}

signIn(USER_NAME, PASSWORD)
  .then(async (signInResponse) => {
    const folderItem = (await getFolderItem(signInResponse,FOLDER_ID)).get;
    console.log(folderItem);
  })
  .catch(e => {
    console.error(e);
  });

{
  "data": {
    "get": {
      "teamId": "teamId1",
      "location": "teamId1",
      "type": "F",
      "tags": "aiResultsNum:1",
      "createdAt": 1678802206809,
      "deviceId": null,
      "id": "ItemId1",
      "name": "Sample folder",
      "parentId": "teamId1",
      "s3Path": "12345/78910.mp4",
      "updatedAt": 1678976523362,
      "mimeType": "application/vnd.unleashlive.folder",
      "annotations": null,
      "metadata": {
        "addonId": null,
        "camaperturevalue": null,
        "camfnumber": null,
        "camfocallength": null,
        "camfocallengthin35mmformat": null,
        "camiso": null,
        "childItemsNumber": 13,
        "exifimageheight": null,
        "exifimagewidth": null,
        "gpsalt": null,
        "gpslat": null,
        "gpslatref": null,
        "gpslng": null,
        "gpslngref": null,
        "height": null,
        "isPanoramic": null,
        "lastmodified": null,
        "make": null,
        "model": null,
        "orientation": null,
        "size": 0,
        "software": null,
        "type": null,
        "width": null,
      },
    }
  }
}

query list {
  list(
    sort: desc
    location: "teamId1/folderId1"
    limit: 48
  ) {
    items {
      teamId
      location
      type
      tags
      createdAt
      deviceId
      id
      name
      parentId
      s3Path
      updatedAt
      mimeType
      metadata {
        isPanoramic
        duration
      }
    }
    nextToken {
      pk
      sk
      locationCreatedAt
      teamId
      teamIdType
      createdAt
      searchNameCreatedAt
      searchName
      deviceId
      type
    }
  }
}

import {signIn} from "../src/actions.js";
import {FOLDER_ID, GRAPHQL_ENDPOINT, PASSWORD, USER_NAME} from "./exampleConfig.js";
import * as graphQlRequest from "graphql-request";
import {getFolderItem} from "./exampleGet.js";
const GraphQLClient = graphQlRequest.GraphQLClient;
const gql = graphQlRequest.gql;

export function listItems(signInResponse, location) {
  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const listQuery = gql`
    query list {
      list(
        sort: desc
        location: "${location}"
        limit: 2
      ) {
        items {
          teamId
          location
          type
          tags
          createdAt
          deviceId
          id
          name
          parentId
          s3Path
          updatedAt
          mimeType
          metadata {
            isPanoramic
            duration
          }
        },
        nextToken {
          pk
          sk
          locationCreatedAt
          teamId
          teamIdType
          createdAt
          searchNameCreatedAt
          searchName
          deviceId
          type
        }
      }
    }`

  return graphQLClient.request(listQuery);
}

signIn(USER_NAME, PASSWORD)
  .then(async (signInResponse) => {
    const folderItem = (await getFolderItem(signInResponse, FOLDER_ID)).get;
    const location = [folderItem.location, folderItem.id].join("/");

    const listResponse = await listItems(signInResponse, location);
    console.log(listResponse);
  })
  .catch(e => {
    console.error(e);
  });

{
  "data": {
    "list": {
      "items": [
        {
          "teamId": "teamId1",
          "location": "teamId1/folderId1",
          "type": "D",
          "tags": null,
          "createdAt": 1678976522491,
          "deviceId": "deviceId1",
          "id": "1",
          "name": "testDocument.json",
          "parentId": "folderId1",
          "s3Path": "1234/2b0d6d59-d221-4dc1-9cf4-78677a002127.json",
          "updatedAt": 1678976539957,
          "mimeType": "application/json",
          "metadata": {
            "isPanoramic": null,
            "duration": null,
          },
        },
        {
          "teamId": "teamId1",
          "location": "teamId1/folderId1",
          "type": "V",
          "tags": null,
          "createdAt": 1678976459317,
          "deviceId": "deviceId1",
          "id": "2",
          "name": "testClip.mp4",
          "parentId": "folderId1",
          "s3Path": "1234/2453702b-8764-4f55-bd81-487f58ec556a.mp4",
          "updatedAt": 1678976491797,
          "mimeType": "video/mp4",
          "metadata": {
            "isPanoramic": null,
            "duration": 1202.003,
          },
        },
        {
          "teamId": "teamId1",
          "location": "teamId1/folderId1",
          "type": "F",
          "tags": "aiResultsNum:1",
          "createdAt": 1678124970355,
          "deviceId": "deviceId1",
          "id": "3",
          "name": "Test folder",
          "parentId": "folderId1",
          "s3Path": "<path-of-file>",
          "updatedAt": 1678976549956,
          "mimeType": "application/vnd.unleashlive.folder",
          "metadata": {
            "isPanoramic": null,
            "duration": null,
          },
        },
        {
          "teamId": "teamId1",
          "location": "teamId1/folderId1",
          "type": "I",
          "tags": "MTY2MDg0NzMyNDMzOSNmYjcwNGIwMy02MjhhLTQyNDEtYmY5OC00NWNkNTFiN2MyNzc#MTY1ODc1NzkwNTUzOSM0OGUxZThiNi0zODA0LTRkMTQtYTJkYi0yOGY1ZmM4ZjUyMmM#aiResultsNum:1",
          "createdAt": 1524474282000,
          "deviceId": "deviceId1",
          "id": "4",
          "name": "DJI_0590.JPG",
          "parentId": "folderId1",
          "s3Path": "1234/efd72fa2-11a8-4369-84c0-8a159d8d3189.jpg",
          "updatedAt": 1678907063236,
          "mimeType": "image/jpeg",
          "metadata": {
            "isPanoramic": null,
            "duration": null,
          },
        }
      ],
      "nextToken": null,
    }
  }
}

mutation MoveItems {
    move(
        moveItems: [{id: "itemId1"}]
        to: {id: "itemId11"}
    ) {
        id
        parentId
        location
    }
}

import * as graphQlRequest from 'graphql-request'
import {signIn} from "../src/actions.js";
import {FOLDER_ID, GRAPHQL_ENDPOINT, PASSWORD, USER_NAME} from "./exampleConfig.js";
import {getFolderItem} from "./exampleGet.js";
const GraphQLClient = graphQlRequest.GraphQLClient;
const gql = graphQlRequest.gql;

export function moveItem(signInResponse, id, toId) {
  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const moveQuery = gql`
    mutation MoveItems {
      move(
        moveItems: [{id: "${id}"}]
        to: {id: "${toId}"}
      ) {
        id
        parentId
        location
      }
    }
  `
  return graphQLClient.request(moveQuery);
}

signIn(USER_NAME, PASSWORD)
  .then(async (signInResponse) => {
    const moveResponse = await moveItem(signInResponse, FOLDER_ID, 'itemId11');
    console.log(moveResponse);

    const folderItem = (await getFolderItem(signInResponse, FOLDER_ID)).get;
    console.log(folderItem);
  })
  .catch(e => {
    console.error(e);
  });

{
  "data": {
    "move": [
      {
        "id": "itemId1",
        "parentId": "itemId11",
        "location": "teamId1/itemId11",
      }
    ]
  }
}

mutation RenameItems {
  rename(
    item: {id: "itemId1"}
    newName: "New name"
  ) {
    id
  }
}

import * as graphQlRequest from 'graphql-request'
import {signIn} from "../src/actions.js";
import {FOLDER_ID, GRAPHQL_ENDPOINT, PASSWORD, USER_NAME} from "./exampleConfig.js";
import {getFolderItem} from "./exampleGet.js";
const GraphQLClient = graphQlRequest.GraphQLClient;
const gql = graphQlRequest.gql;

export function renameItem(signInResponse, id) {
  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const renameQuery = gql`
    mutation RenameItems {
      rename(
        item: {id: "${id}"}
        newName: "New name"
      ) {
        id
      }
    }
  `
  return graphQLClient.request(renameQuery);
}

signIn(USER_NAME, PASSWORD)
  .then(async (signInResponse) => {
    const renameResponse = await renameItem(signInResponse, FOLDER_ID);
    console.log(renameResponse);

    const folderItem = (await getFolderItem(signInResponse, FOLDER_ID)).get;
    console.log(folderItem);
  })
  .catch(e => {
    console.error(e);
  });

{
  "data": {
    "rename": {
      "id": "itemId1",
    }
  }
}

import AWS from 'aws-sdk';
import {signIn} from "../src/actions.js";
import {FOLDER_ID, PASSWORD, UPLOAD_BUCKET_NAME, USER_NAME} from "./exampleConfig.js";
import * as uuid from "uuid";
import * as fs from "fs";
import {getCredentials} from "../src/cognito.js";
import {getFolderItem} from "./exampleGet.js";

const FILE_NAME = 'logo.png';
const FILE_PATH = `./assets/${FILE_NAME}`;

function getFileKey(companyId, teamId, identityId, fileName) {
  // return [companyId, teamId, identityId, uuid.v4(), fileName].join('/')
  return [identityId, uuid.v4(), fileName].join('/')
}

signIn(USER_NAME, PASSWORD)
  .then(async (response) => {
    const companyId = response.response.token.companyId;
    const teamId = response.response.token.teamId;
    const identityId = response.response.token.identityId;

    const folderItem = (await getFolderItem(FOLDER_ID)).get;
    const parentId = folderItem.id;
    const location = [folderItem.location, folderItem.id].join("/");

    // Upload file to it's destination
    fs.readFile(FILE_PATH, (err, data) => {
      if (err) throw err;
      const s3Client = new AWS.S3({
        credentials: getCredentials(),
        params: {Bucket: UPLOAD_BUCKET_NAME}
      });

      const params = {
        Bucket: UPLOAD_BUCKET_NAME, // pass your bucket name
        Key: getFileKey(companyId, teamId, identityId, FILE_NAME),
        Body: data,
        Metadata: {
          location: location,
          parentId: parentId,
          name: FILE_NAME,
        }
      };
      s3Client.upload(params, function(s3Err, data) {
        if (s3Err) throw s3Err
        console.log(`File uploaded successfully at ${data.Location}`)
      });
    });
  })
  .catch(e => {
    console.error(e);
  });

import { signIn } from "../../auth/src/actions.js";
import {
  FOLDER_ID,
  MEDIA_DRIVE_CDN,
  PASSWORD,
  USER_NAME,
} from "../../config/variables.js";
import { listItemsImages } from "./list.js";
import { getFolderItem } from "./get.js";

import * as https from "https";
import * as fs from "fs";
import {download} from "../../common/downloadFile.js";

signIn(USER_NAME, PASSWORD)
  .then(async (signInResponse) => {
    const folderItem = (await getFolderItem(signInResponse, FOLDER_ID)).get;
    const location = [folderItem.location, folderItem.id].join("/");

    const listResponse = (await listItemsImages(signInResponse, location)).list
      .items;

    const imageItem = listResponse.find((item) => item.type === "I");
    return download(MEDIA_DRIVE_CDN, imageItem.s3Path, imageItem.name);
  })
  .catch((e) => {
    console.error(e);
  });

mutation DeleteItems {
  delete(
    deleteItems: [{id: "itemId1"}, {id: "itemId2"}]
  ) {
    deleteItems {
      id
    }
    ownerId
  }
}

import * as graphQlRequest from 'graphql-request'
import {signIn} from "../src/actions.js";
import {GRAPHQL_ENDPOINT, PASSWORD, USER_NAME} from "./exampleConfig.js";

const GraphQLClient = graphQlRequest.GraphQLClient;
const gql = graphQlRequest.gql;

export function deleteItem(signInResponse) {
  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const deleteQuery = gql`
    mutation DeleteItems {
      delete(
        deleteItems: [{id: "itemId1"}, {id: "itemId2"}]
      ) {
        deleteItems {
          id
        }
        ownerId
      }
    }
  `
  return graphQLClient.request(deleteQuery);
}

signIn(USER_NAME, PASSWORD)
.then(async (signInResponse) => {
  const deleteResponse = (await deleteItem(signInResponse))
  console.log(deleteResponse);

  const getQuery = gql`
      query GetLibraryItem{
        get(item: {id: "itemId1"}) {
          id,
          name
        }
      }`

  const graphQLClient = new GraphQLClient(GRAPHQL_ENDPOINT, {
    headers: {
      authorization: signInResponse.response.token.idToken,
    },
  })

  const getResponse = await graphQLClient.request(getQuery);
  console.log(getResponse);
})
.catch(e => {
  console.error(e);
});

{
  "data": {
    "delete": {
      "deleteItems": [
        {
          "id": "itemId1"
        }, {
          "id": "itemId2"
        }
      ],
      "ownerId": "userId1",
    }
  }
}

export async function listFlightLogs(signInResponse) {
  const requestOptions = {
    hostname: API_URL,
    port: 443,
    path: '/v1/flights',
    method: 'GET',
    headers: {
      'content-type': 'application/json',
      'x-amz-cognito-security-token': signInResponse.response.token.idToken
    },
  };
  return await sendGet(requestOptions);
}

import https from "https";
import fs from "fs";

export function download(cdn, filePath, name) {
  const file = fs.createWriteStream(name);
  return https.get(
    [cdn, filePath].join("/"),
    function (response) {
      response.pipe(file);

      // after download completed close filestream
      file.on("finish", () => {
        file.close();
        console.log("Download Completed");
      });
    }
  );

}


function getFileNameFromPath(filePath) {
  const filePathParts = filePath.split('/');
  return filePathParts[filePathParts.length - 1];
}

try {
  const signInResponse = await signIn(USER_NAME, PASSWORD);
  const flightLogs = await listFlightLogs(signInResponse);
  const firstItem = flightLogs[0];
  const localFileName = getFileNameFromPath(firstItem.s3Path);
  await download(FLIGHTS_CDN, firstItem.s3Path, localFileName);
} catch (e) {
  console.error(e);
}

export async function uploadMission(signInResponse) {
  const requestOptions = {
    hostname: API_URL,
    port: 443,
    path: '/v1/mission',
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      'x-amz-cognito-security-token': signInResponse.response.token.idToken
    },
  };
  return await sendPost(requestOptions, BODY);
}


try {
  const signInResponse = await signIn(USER_NAME, PASSWORD);
  const uploadResponse = await uploadMission(signInResponse);
  console.log(uploadResponse);
} catch (e) {
  console.error(e);
}

 curl -X GET -H "x-api-key: <API-KEY>" <URL>

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', <ENDPOINT>, headers={'x-api-key': <API-KEY>})
r.data

 curl -X GET -H "x-api-key: <API-KEY>" https://api.unleashlive.com/v1/analytics/version

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/version', headers={'x-api-key': <API-KEY>})
r.data

{"1.0.1"}

curl -X GET -H "x-api-key: <API-KEY>" https://api.unleashlive.com/v1/analytics/devices

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/devices', headers={'x-api-key': <API-KEY>})
r.data

["Wb8fabc31378ce07","W022abc5be35bb72","Weea288bc1faaddd"]

curl -X GET -H "x-api-key: <API-KEY>" https://api.unleashlive.com/v1/analytics/sessions

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/sessions', headers={'x-api-key': <API-KEY>})
r.data

["1595418530512","1595452859625","1595492155987"]

 curl -X GET -H "x-api-key: <API-KEY>" https://api.unleashlive.com/v1/analytics/{deviceId}/{unixUTCTimeStampFrom}/{unixUTCTimeStampTo}/{pageNumber}

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/{deviceId}/{unixUTCTimeStampFrom}/{unixUTCTimeStampTo}/{pageNumber}', headers={'x-api-key': <API-KEY>})
r.data

{"keys": ["class_name","count","device_id","frame_number","model_id","session_id","source_file_name","timestamp"],
"total_num_pages":1,
"data":[["person",1,"Wabcdb35be35bb72",110251,"starter-ai","1597622730877","Wabcdb35be35bb72?token=sneaky-firefox-288","2020-08-17T02:08:49.000Z"],
  ["person",3,"Wabcdb35be35bb72",110252,"starter-ai","1597622730878","Wabcdb35be35bb72?token=sneaky-firefox-288","2020-08-17T02:08:49.000Z"]]}

 curl -X GET -H "x-api-key: <API-KEY>" https://api.unleashlive.com/v1/analytics/tableau/{deviceId}/{unixUTCTimeStampFrom}/{unixUTCTimeStampTo}/{pageNumber}

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/tableau/{deviceId}/{unixUTCTimeStampFrom}/{unixUTCTimeStampTo}/{pageNumber}', headers={'x-api-key': <API-KEY>})
r.data

{"total_num_pages":1,
"data":[{"timestamp":"2020-08-17T02:08:49.000Z","class_name":"person","count":1,"device_id":"Wabcdb35be35bb72","source_file_name":"Wabcdb35be35bb72?token=sneaky-firefox-288","frame_number":110251,"model_id":"starter-ai","session_id":"1597622730877"},
  {"timestamp":"2020-08-17T02:08:49.000Z","class_name":"truck","count":1,"device_id":"Wabcdb35be35bb72","source_file_name":"Wabcdb35be35bb72?token=sneaky-firefox-288","frame_number":110252,"model_id":"starter-ai","session_id":"1597622730877"}]}

curl "https://api.unleashlive.com/v1/inspections" \
  -H "Authorization: Bearer YOUR_API_KEY"

import requests

headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

r = requests.get("https://api.unleashlive.com/v1/inspections", headers=headers)

curl "https://api.unleashlive.com/v1/analytics/inspections" \
  -H "Authorization: Bearer YOUR_API_KEY"

import requests

url = "https://api.unleashlive.com/v1/analytics/inspections"
headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}
response = requests.get(url, headers=headers)
print(response.json())

// Response example
[
  {
    "id": "inspection1",
    "name": "Inspection 1",
    "teamId": "team123",
    "folderId": "folder456",
    "createdAt": 1631026800,
    "tasksCount": 5
  },
  {
    "id": "inspection2",
    "name": "Inspection 2",
    "teamId": "team789",
    "folderId": "folder123",
    "createdAt": 1631113200,
    "tasksCount": 3
  }
]

curl "https://api.unleashlive.com/v1/analytics/annotations" \
  -H "Authorization: Bearer YOUR_API_KEY"

import requests

url = "https://api.unleashlive.com/v1/analytics/annotations"
headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}
response = requests.get(url, headers=headers)
print(response.json())

// Response example
[
  {
    "category": "crack",
    "timestamp": 1234567890,
    "distance": 2.5,
    "area": 15,
    "description": "Long crack near edge",
    "severity": 3,
    "assetId": "asset123",
    "context": {
      "hubHeightM": 80,
      "turbineNo": "T01",
      "bladeManufacturer": "BladesCo",
      "siteName": "Wind Farm Alpha",
      "powerRatingMW": 2.5,
      "bladeLengthM": 50,
      "bladeType": "Type A",
      "rotorDiameterM": 100,
      "manufacturer": "TurbineCorp",
      "wtgType": "Horizontal Axis"
    }
  },
  {
    "category": "corrosion",
    "timestamp": 1234567891,
    "description": "Corrosion on surface",
    "severity": 2
  }
]

wget -O - https://unleash-stream-cli.s3.ap-southeast-2.amazonaws.com/linux-x86/install.sh | bash -s -- install

echo $PATH

unleash-stream-cli —help

unleash-stream-cli COMMAND —help

unleash-stream-cli add 'SOURCE_URL' -D 'UNLEASHLIVE_DEVICE_STREAM_URL'

 unleash-stream-cli list

unleash-stream-cli stop 'W123a4b5678c9de0'

wget -O - https://unleash-stream-cli.s3.ap-southeast-2.amazonaws.com/linux-x86/install.sh | bash -s -- update

wget -O - https://unleash-stream-cli.s3.ap-southeast-2.amazonaws.com/linux-x86/install.sh | bash -s -- uninstall

curl -X GET -H "x-api-key: none" https://api.unleashlive.com/v1/analytics/version

import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'https://api.unleashlive.com/v1/analytics/version', headers={'x-api-key': ''})
r.data

{"message":"Forbidden"}