Code Examples

React Native Component

import React, { useState } from 'react';
import { View, Text, TextInput, Button, Alert } from 'react-native';

const InsuranceChecker = () => {
  const [registration, setRegistration] = useState('');
  const [loading, setLoading] = useState(false);

  const checkInsurance = async () => {
    setLoading(true);
    try {
      const response = await fetch('https://api.cornucopia.net/v1/vehicle/' + registration + '/insurance', {
        headers: {
          'X-API-Key': 'your_api_key_here'
        }
      });

      const data = await response.json();

      if (data.insured) {
        Alert.alert('Insurance Status', 'Vehicle is insured and compliant');
      } else {
        Alert.alert('Insurance Status', 'Vehicle is not insured');
      }
    } catch (error) {
      Alert.alert('Error', 'Failed to check insurance status');
    }
    setLoading(false);
  };

  return (
    <View style={{ padding: 20 }}>
      <TextInput
        placeholder="Enter vehicle registration"
        value={registration}
        onChangeText={setRegistration}
        style={{ borderWidth: 1, padding: 10, marginBottom: 10 }}
      />
      <Button
        title={loading ? "Checking..." : "Check Insurance"}
        onPress={checkInsurance}
        disabled={loading}
      />
    </View>
  );
};

Swift (iOS)

import Foundation

class CornucopiaService {
    private let apiKey = "your_api_key_here"
    private let baseURL = "https://api.cornucopia.net/v1"

    func checkInsurance(registration: String) async throws -> InsuranceStatus {
        let url = URL(string: "(baseURL)/vehicle/(registration)/insurance")!
        var request = URLRequest(url: url)
        request.setValue(apiKey, forHTTPHeaderField: "X-API-Key")

        let (data, response) = try await URLSession.shared.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw CornucopiaError.invalidResponse
        }

        let decoder = JSONDecoder()
        return try decoder.decode(InsuranceStatus.self, from: data)
    }
}

struct InsuranceStatus: Codable {
    let registration: String
    let insured: Bool
    let policy: Policy?
}

struct Policy: Codable {
    let number: String
    let insurer: String
    let validFrom: String
    let validTo: String
}

enum CornucopiaError: Error {
    case invalidResponse
}

Express.js Webhook Handler

const express = require('express');
const crypto = require('crypto');
const router = express.Router();

// Webhook secret for verification (set in Content Hub dashboard)
const WEBHOOK_SECRET = process.env.CONTENT_HUB_WEBHOOK_SECRET;

router.post('/webhook/insurance-updates', express.raw({ type: 'application/json' }), (req, res) => {
  // Verify webhook signature
  const signature = req.headers['x-cornucopia-signature'];
  const expectedSignature = crypto
    .createHmac('sha256', WEBHOOK_SECRET)
    .update(req.body)
    .digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const event = JSON.parse(req.body);
  console.log('Received webhook:', event.type);

  switch (event.type) {
    case 'insurance.expired':
      handleInsuranceExpired(event.data);
      break;
    case 'vehicle.registered':
      handleVehicleRegistered(event.data);
      break;
    case 'compliance.violation':
      handleComplianceViolation(event.data);
      break;
  }

  res.json({ received: true });
});

function handleInsuranceExpired(data) {
  // Send notification to fleet manager
  console.log(`Insurance expired for vehicle: ${data.registration}`);
  // Update database, send alerts, etc.
}

function handleVehicleRegistered(data) {
  // Process new vehicle registration
  console.log(`New vehicle registered: ${data.registration}`);
}

function handleComplianceViolation(data) {
  // Handle compliance issues
  console.log(`Compliance violation: ${data.registration} - ${data.violation_type}`);
}

module.exports = router;

Webhook Event Types