// Process a document using fetch API
async function processDocument(file, endpoint = 'resumes') {
    const formData = new FormData();
    formData.append('file', file);
    
    try {
        const response = await fetch(`https://your-domain.com/api/${endpoint}`, {
            method: 'POST',
            headers: {
                'Authorization': 'Bearer YOUR_API_KEY'
            },
            body: formData
        });
        
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const result = await response.json();
        console.log('Processing result:', result);
        return result;
        
    } catch (error) {
        console.error('Error processing document:', error);
        throw error;
    }
}

// Example usage with file input
document.getElementById('fileInput').addEventListener('change', async (e) => {
    const file = e.target.files[0];
    if (file) {
        try {
            const result = await processDocument(file, 'resumes');
            // Handle the result
            displayResult(result);
        } catch (error) {
            alert('Error processing file: ' + error.message);
        }
    }
});

import requests
import json

class DocumentProcessor:
    def __init__(self, api_key, base_url="https://your-domain.com"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {api_key}'
        }
    
    def process_resume(self, file_path):
        """Process a resume document"""
        return self._process_document(file_path, 'resumes')
    
    def process_receipt(self, file_path):
        """Process a receipt document"""
        return self._process_document(file_path, 'receipts')
    
    def _process_document(self, file_path, endpoint):
        """Generic document processing method"""
        url = f"{self.base_url}/api/{endpoint}"
        
        try:
            with open(file_path, 'rb') as file:
                files = {'file': file}
                response = requests.post(url, headers=self.headers, files=files)
                response.raise_for_status()
                return response.json()
                
        except requests.exceptions.RequestException as e:
            print(f"Error processing document: {e}")
            raise
        except FileNotFoundError:
            print(f"File not found: {file_path}")
            raise

# Example usage
if __name__ == "__main__":
    # Initialize the processor with your API key
    processor = DocumentProcessor("YOUR_API_KEY")
    
    try:
        # Process a resume
        result = processor.process_resume("path/to/resume.pdf")
        print("Resume processing result:")
        print(json.dumps(result, indent=2))
        
    except Exception as e:
        print(f"Error: {e}")

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

class DocumentProcessor {
    constructor(apiKey, baseUrl = 'https://your-domain.com') {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl;
        this.headers = {
            'Authorization': \`Bearer \${apiKey}\`
        };
    }
    
    async processResume(filePath) {
        return this.processDocument(filePath, 'resumes');
    }
    
    async processReceipt(filePath) {
        return this.processDocument(filePath, 'receipts');
    }
    
    async processDocument(filePath, endpoint) {
        try {
            const form = new FormData();
            form.append('file', fs.createReadStream(filePath));
            
            const response = await axios.post(
                `${this.baseUrl}/api/${endpoint}`,
                form,
                {
                    headers: {
                        ...this.headers,
                        ...form.getHeaders()
                    }
                }
            );
            
            return response.data;
            
        } catch (error) {
            if (error.response) {
                console.error('API Error:', error.response.status, error.response.data);
            } else {
                console.error('Network Error:', error.message);
            }
            throw error;
        }
    }
}

// Example usage
async function main() {
    const processor = new DocumentProcessor('YOUR_API_KEY');
    
    try {
        const result = await processor.processResume('./resume.pdf');
        console.log('Processing result:', JSON.stringify(result, null, 2));
    } catch (error) {
        console.error('Error:', error.message);
    }
}

// Run the example
main();