Cloudbased Traceability
and HACCP for Businesses

import axios, { AxiosResponse } from 'axios';

const BASE_URL = 'https://api.traceage.io';
const API_TOKEN = process.env.API_TOKEN;

// Axios instance with headers
const apiClient = axios.create({
    baseURL: BASE_URL,
    headers: {
        'Authorization': `Bearer ${API_TOKEN}`,
        'Content-Type': 'application/json'
    }
});

// Interfaces for response types
interface TraceabilityInfo {
    productId: string;
    data: any;
}

// Get traceability information for a product
async function getTraceabilityInfo(productId: string): Promise<TraceabilityInfo> {
    const response: AxiosResponse<TraceabilityInfo> = await apiClient.get(`/traceability/${productId}`);
    return response.data;
}

// Create new account
async function createNewAccount(accountDetails: any): Promise<void> {
    await apiClient.post(`/accounts`, accountDetails);
}

// Create new user
async function createNewUser(userData: any): Promise<void> {
    await apiClient.post(`/users`, userData);
}

// Create new serial number
async function createNewSerialNumber(serialData: any): Promise<void> {
    await apiClient.post(`/serials`, serialData);
}

// Create new asset (assets may come as workflow data) 
async function createNewAsset(assetData: any): Promise<void> {
    await apiClient.post(`/assets`, assetData);
}

// Example usage
getTraceabilityInfo('12345').then(info => console.log(info));

import requests

BASE_URL = 'https://api.traceage.io'
API_TOKEN = os.environ.get('API_TOKEN')

# Headers
headers = {
    'Authorization': f'Bearer {API_TOKEN}',
    'Content-Type': 'application/json'
}

# Get traceability information for a product
def get_traceability_info(product_id: str):
    response = requests.get(f'{BASE_URL}/traceability/{product_id}', headers=headers)
    return response.json()

# Create new account
def create_new_account(account_details: dict):
    response = requests.post(f'{BASE_URL}/accounts', headers=headers, json=account_details)
    return response.json()

# Create new user
def create_new_user(user_data: dict):
    response = requests.post(f'{BASE_URL}/users', headers=headers, json=user_data)
    return response.json()

# Create new serial number
def create_new_serial_number(serial_data: dict):
    response = requests.post(f'{BASE_URL}/serials', headers=headers, json=serial_data)
    return response.json()

# Create new asset (assets may come as workflow data)
def create_new_asset(asset_data: dict):
    response = requests.post(f'{BASE_URL}/assets', headers=headers, json=asset_data)
    return response.json()

# Example usage
get_traceability_info('12345')

use reqwest;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::env;

const BASE_URL: &str = "https://api.traceage.io";
const API_TOKEN: &str = env::var("API_TOKEN").unwrap();

#[derive(Debug, Deserialize, Serialize)]
struct TraceabilityInfo {
    product_id: String,
    data: HashMap<String, String>,
}

// Get traceability information for a product
async fn get_traceability_info(product_id: &str) -> Result<TraceabilityInfo, reqwest::Error> {
    let url = format!("{}/traceability/{}", BASE_URL, product_id);
    let response = reqwest::get(&url).await?.json().await?;
    Ok(response)
}

// Create new account
async fn create_new_account(account_details: HashMap<String, String>) -> Result<(), reqwest::Error> {
    let url = format!("{}/accounts", BASE_URL);
    let client = reqwest::Client::new();
    let response = client.post(&url).json(&account_details).send().await?;
    Ok(())
}

// Create new user
async fn create_new_user(user_data: HashMap<String, String>) -> Result<(), reqwest::Error> {
    let url = format!("{}/users", BASE_URL);
    let client = reqwest::Client::new();
    let response = client.post(&url).json(&user_data).send().await?;
    Ok(())
}

// Create new serial number
async fn create_new_serial_number(serial_data: HashMap<String, String>) -> Result<(), reqwest::Error> {
    let url = format!("{}/serials", BASE_URL);
    let client = reqwest::Client::new();
    let response = client.post(&url).json(&serial_data).send().await?;
    Ok(())
}

// Create new asset (assets may come as workflow data)
async fn create_new_asset(asset_data: HashMap<String, String>) -> Result<(), reqwest::Error> {
    let url = format!("{}/assets", BASE_URL);
    let client = reqwest::Client::new();
    let response = client.post(&url).json(&asset_data).send().await?;
    Ok(())
}

// Example usage
#[tokio::main]
async fn main() {
    let traceability_info = get_traceability_info("12345").await;
}

# Get traceability information for a product
curl -X GET https://api.traceage.io/traceability/12345 \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/json'

# Create new account
curl -X POST https://api.traceage.io/accounts \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/json' \
    -d '{
        "name": "My Company",
        "email": "  ",
        "phone": "  ",
        "address": "  ",
        "city": "  ",
        "state": "  ",
        "zip": "  ",
        "country": "  "
    }'

# Create new user
curl -X POST https://api.traceage.io/users \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/json' \
    -d '{
        "first_name": "John",
        "last_name": "Doe",
        "email": "  ",
        "phone": "  ",
        "address": "  ",
        "city": "  ",
        "state": "  ",
        "zip": "  ",
        "country": "  "
    }'

# Create new serial number
curl -X POST https://api.traceage.io/serials \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/json' \
    -d '{
        "serial_number": "12345",
        "product_id": "  ",
        "account_id": "  ",
        "user_id": "  ",
        "data": {
            "key": "value"
        }
    }'

# Create new asset (assets may come as workflow data)
curl -X POST https://api.traceage.io/assets \
    -H 'Authorization: Bearer API_TOKEN' \
    -H 'Content-Type: application/json' \
    -d '{
        "asset_id": "12345",
        "serial_number": "  ",
        "product_id": "  ",
        "account_id": "  ",
        "user_id": "  ",
        "data": {
            "key": "value"
        }
    }'