Code snippets examples

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.connecteam.com/attachments/v1/files"
HEADERS = {
    "X-API-KEY": API_KEY,
    "Content-Type": "application/json"
}

def upload_file(file_path: str, file_name: str, mime_type: str, feature_type: str = "chat"):
    # Step 1: Generate upload URL
    response = requests.post(
        f"{BASE_URL}/generate-upload-url",
        headers=HEADERS,
        json={
            "fileName": file_name,
            "fileTypeHint": mime_type,
            "featureType": feature_type
        }
    )
    response.raise_for_status()
    data = response.json()["data"]
    file_id = data["fileId"]
    upload_url = data["uploadFileUrl"]
    
    print(f"Generated upload URL for file ID: {file_id}")
    
    # Step 2: Upload file to pre-signed URL
    with open(file_path, "rb") as f:
        upload_response = requests.put(
            upload_url,
            headers={"Content-Type": mime_type},
            data=f
        )
        upload_response.raise_for_status()
    
    print("File uploaded to cloud storage")
    
    # Step 3: Complete upload
    complete_response = requests.put(
        f"{BASE_URL}/complete-upload/{file_id}",
        headers={"X-API-KEY": API_KEY}
    )
    complete_response.raise_for_status()
    
    print("Upload completed")
    
    # Step 4: Verify upload
    status_response = requests.get(
        f"{BASE_URL}/{file_id}",
        headers={"X-API-KEY": API_KEY}
    )
    status_response.raise_for_status()
    
    return status_response.json()["data"]


# Example usage
if __name__ == "__main__":
    result = upload_file(
        file_path="./report.pdf",
        file_name="report.pdf",
        mime_type="application/pdf",
        feature_type="chat"
    )
    print(f"File uploaded successfully: {result}")

const fs = require('fs');
const fetch = require('node-fetch');

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.connecteam.com/attachments/v1/files';

async function uploadFile(filePath, fileName, mimeType, featureType = 'chat') {
    // Step 1: Generate upload URL
    const generateResponse = await fetch(`${BASE_URL}/generate-upload-url`, {
        method: 'POST',
        headers: {
            'X-API-KEY': API_KEY,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            fileName: fileName,
            fileTypeHint: mimeType,
            featureType: featureType
        })
    });
    
    if (!generateResponse.ok) {
        throw new Error(`Failed to generate URL: ${await generateResponse.text()}`);
    }
    
    const { data } = await generateResponse.json();
    const { fileId, uploadFileUrl } = data;
    
    console.log(`Generated upload URL for file ID: ${fileId}`);
    
    // Step 2: Upload file to pre-signed URL
    const fileBuffer = fs.readFileSync(filePath);
    const uploadResponse = await fetch(uploadFileUrl, {
        method: 'PUT',
        headers: { 'Content-Type': mimeType },
        body: fileBuffer
    });
    
    if (!uploadResponse.ok) {
        throw new Error(`Failed to upload file: ${await uploadResponse.text()}`);
    }
    
    console.log('File uploaded to cloud storage');
    
    // Step 3: Complete upload
    const completeResponse = await fetch(`${BASE_URL}/complete-upload/${fileId}`, {
        method: 'PUT',
        headers: { 'X-API-KEY': API_KEY }
    });
    
    if (!completeResponse.ok) {
        throw new Error(`Failed to complete upload: ${await completeResponse.text()}`);
    }
    
    console.log('Upload completed');
    
    // Step 4: Verify upload
    const statusResponse = await fetch(`${BASE_URL}/${fileId}`, {
        headers: { 'X-API-KEY': API_KEY }
    });
    
    return (await statusResponse.json()).data;
}

// Example usage
uploadFile('./report.pdf', 'report.pdf', 'application/pdf', 'chat')
    .then(result => console.log('File uploaded:', result))
    .catch(error => console.error('Error:', error));

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.connecteam.com/attachments/v1/files';

async function uploadFile(file, featureType = 'chat') {
    // Step 1: Generate upload URL
    const generateResponse = await fetch(`${BASE_URL}/generate-upload-url`, {
        method: 'POST',
        headers: {
            'X-API-KEY': API_KEY,
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            fileName: file.name,
            fileTypeHint: file.type,
            featureType: featureType
        })
    });
    
    const { data } = await generateResponse.json();
    const { fileId, uploadFileUrl } = data;
    
    // Step 2: Upload file
    await fetch(uploadFileUrl, {
        method: 'PUT',
        headers: { 'Content-Type': file.type },
        body: file
    });
    
    // Step 3: Complete upload
    await fetch(`${BASE_URL}/complete-upload/${fileId}`, {
        method: 'PUT',
        headers: { 'X-API-KEY': API_KEY }
    });
    
    // Step 4: Get file info
    const statusResponse = await fetch(`${BASE_URL}/${fileId}`, {
        headers: { 'X-API-KEY': API_KEY }
    });
    
    return (await statusResponse.json()).data;
}

// Usage with file input
document.getElementById('fileInput').addEventListener('change', async (e) => {
    const file = e.target.files[0];
    const result = await uploadFile(file);
    console.log('Uploaded:', result);
});

#!/bin/bash

API_KEY="YOUR_API_KEY"
BASE_URL="https://api.connecteam.com/attachments/v1/files"

FILE_PATH="./report.pdf"
FILE_NAME="report.pdf"
MIME_TYPE="application/pdf"
FEATURE_TYPE="chat"

# Step 1: Generate upload URL
echo "Generating upload URL..."
GENERATE_RESPONSE=$(curl -s -X POST "$BASE_URL/generate-upload-url" \
  -H "X-API-KEY: $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"fileName\": \"$FILE_NAME\",
    \"fileTypeHint\": \"$MIME_TYPE\",
    \"featureType\": \"$FEATURE_TYPE\"
  }")

FILE_ID=$(echo "$GENERATE_RESPONSE" | jq -r '.data.fileId')
UPLOAD_URL=$(echo "$GENERATE_RESPONSE" | jq -r '.data.uploadFileUrl')

echo "File ID: $FILE_ID"

# Step 2: Upload file
echo "Uploading file..."
curl -s -X PUT "$UPLOAD_URL" \
  -H "Content-Type: $MIME_TYPE" \
  --data-binary @"$FILE_PATH"

echo "File uploaded"

# Step 3: Complete upload
echo "Completing upload..."
curl -s -X PUT "$BASE_URL/complete-upload/$FILE_ID" \
  -H "X-API-KEY: $API_KEY"

echo "Upload completed"

# Step 4: Verify
echo "Verifying upload..."
curl -s -X GET "$BASE_URL/$FILE_ID" \
  -H "X-API-KEY: $API_KEY" | jq

require 'net/http'
require 'json'
require 'uri'

API_KEY = 'YOUR_API_KEY'
BASE_URL = 'https://api.connecteam.com/attachments/v1/files'

def upload_file(file_path, file_name, mime_type, feature_type = 'chat')
  # Step 1: Generate upload URL
  uri = URI("#{BASE_URL}/generate-upload-url")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  
  request = Net::HTTP::Post.new(uri)
  request['X-API-KEY'] = API_KEY
  request['Content-Type'] = 'application/json'
  request.body = {
    fileName: file_name,
    fileTypeHint: mime_type,
    featureType: feature_type
  }.to_json
  
  response = http.request(request)
  data = JSON.parse(response.body)['data']
  file_id = data['fileId']
  upload_url = data['uploadFileUrl']
  
  puts "Generated upload URL for file ID: #{file_id}"
  
  # Step 2: Upload file
  upload_uri = URI(upload_url)
  upload_http = Net::HTTP.new(upload_uri.host, upload_uri.port)
  upload_http.use_ssl = true
  
  upload_request = Net::HTTP::Put.new(upload_uri)
  upload_request['Content-Type'] = mime_type
  upload_request.body = File.read(file_path)
  
  upload_http.request(upload_request)
  puts 'File uploaded'
  
  # Step 3: Complete upload
  complete_uri = URI("#{BASE_URL}/complete-upload/#{file_id}")
  complete_http = Net::HTTP.new(complete_uri.host, complete_uri.port)
  complete_http.use_ssl = true
  
  complete_request = Net::HTTP::Put.new(complete_uri)
  complete_request['X-API-KEY'] = API_KEY
  
  complete_http.request(complete_request)
  puts 'Upload completed'
  
  # Step 4: Verify
  status_uri = URI("#{BASE_URL}/#{file_id}")
  status_http = Net::HTTP.new(status_uri.host, status_uri.port)
  status_http.use_ssl = true
  
  status_request = Net::HTTP::Get.new(status_uri)
  status_request['X-API-KEY'] = API_KEY
  
  status_response = status_http.request(status_request)
  JSON.parse(status_response.body)['data']
end

# Example usage
result = upload_file('./report.pdf', 'report.pdf', 'application/pdf')
puts "Uploaded: #{result}"