Accessful API

public boolean verifyHmac(String payload, String signature, String secret) {
    try {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        byte[] rawHmac = mac.doFinal(payload.getBytes(StandardCharsets.UTF_8));
        String expected = Base64.getEncoder().encodeToString(rawHmac);
        return MessageDigest.isEqual(expected.getBytes(), signature.getBytes());
    } catch (Exception e) {
        return false;
    }
}

const crypto = require('crypto');

function verifyHmac(payload, signature, secret) {
    const hmac = crypto.createHmac('sha256', secret);
    hmac.update(payload);
    const expected = hmac.digest('base64');
    return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

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

class AccessfulClient {
    constructor(baseUrl, tokenUrl, clientId, username, password) {
        this.baseUrl = baseUrl;
        this.tokenUrl = tokenUrl;
        this.clientId = clientId;
        this.username = username;
        this.password = password;
        this.accessToken = null;
    }

    async authenticate() {
        const params = new URLSearchParams();
        params.append('grant_type', 'password');
        params.append('client_id', this.clientId);
        params.append('username', this.username);
        params.append('password', this.password);

        const response = await axios.post(this.tokenUrl, params);
        this.accessToken = response.data.access_token;
        return this.accessToken;
    }

    async uploadPdf(filePath, webhookUrl = null, secret = null) {
        if (!this.accessToken) {
            await this.authenticate();
        }

        const form = new FormData();
        form.append('files', fs.createReadStream(filePath));
        
        if (webhookUrl) {
            form.append('webhookUrl', webhookUrl);
        }
        if (secret) {
            form.append('secret', secret);
        }

        const response = await axios.post(`${this.baseUrl}/api/v1/upload-service/pdf/upload`, form, {
            headers: {
                ...form.getHeaders(),
                'Authorization': `Bearer ${this.accessToken}`
            }
        });

        return response.data;
    }

    async getJobStatus(caseId) {
        const response = await axios.get(`${this.baseUrl}/api/v1/upload-service/job-status/${caseId}`, {
            headers: {
                'Authorization': `Bearer ${this.accessToken}`
            }
        });
        return response.data;
    }

    async downloadPdf(caseId, outputPath) {
        const response = await axios.get(`${this.baseUrl}/api/v1/upload-service/download/${caseId}`, {
            headers: {
                'Authorization': `Bearer ${this.accessToken}`
            },
            responseType: 'stream'
        });

        const writer = fs.createWriteStream(outputPath);
        response.data.pipe(writer);
        
        return new Promise((resolve, reject) => {
            writer.on('finish', resolve);
            writer.on('error', reject);
        });
    }
}

// Usage
const client = new AccessfulClient(
    'https://gateway.accessful.de',
    'https://iam.accessful.de/realms/accessful-realm/protocol/openid-connect/token',
    'accessful-api',
    'your_username',
    'your_password'
);

async function convertPdf() {
    try {
        // Upload PDF
        const uploadResponse = await client.uploadPdf('./document.pdf');
        const caseId = uploadResponse.successfulUploads[0];
        console.log('Upload successful, case ID:', caseId);

        // Poll for completion
        let status = 'queued';
        while (status !== 'completed' && status !== 'failed') {
            await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
            status = await client.getJobStatus(caseId);
            console.log('Status:', status);
        }

        if (status === 'completed') {
            // Download converted PDF
            await client.downloadPdf(caseId, './converted-document.pdf');
            console.log('Download complete!');
        }
    } catch (error) {
        console.error('Error:', error.message);
    }
}

convertPdf();

// AuthService - Handles JWT token retrieval
@Service
public class AuthService {
    public String retrieveJwt() {
        // Keycloak token request implementation
    }
}

// AccessfulApiService - Main API interaction
@Service
public class AccessfulApiService {
    public void cleanup(UUID caseId) {
        // Optional cleanup of processed files
    }
}

// CallbackRestController - Webhook endpoint
@RestController
@RequestMapping("/api/callback")
public class CallbackRestController {
    @PostMapping("/{caseId}")
    public ResponseEntity<Void> receiveCallback(
            @PathVariable UUID caseId,
            @RequestHeader("X-Signature") String signature,
            @RequestBody String payloadJson) {
        // HMAC verification and processing
    }
}

# application.properties
spring.application.name=accessful-api-demo
server.port=8866
accessful.api.base-url=https://gateway.accessful.de
accessful.keycloak.token-url=https://iam.accessful.de/realms/accessful-realm/protocol/openid-connect/token
pilot.account.name=your-username
pilot.account.password=your-password
pilot.account.client-id=accessful-api
callback.hmac.secret=your-hmac-secret
callback.url=https://your-server.com/api/callback/

// Example error handling patterns
try {
    const response = await uploadPdf(file);
} catch (error) {
    if (error.response?.status === 429) {
        // Rate limited – implement backoff
        await delay(Math.pow(2, retryCount) * 1000);
        return retry();
    } else if (error.response?.status === 400) {
        // Invalid file format
        throw new Error('Invalid PDF file format');
    } else {
        // Other errors
        throw error;
    }
}