Developer Documentation

<?php
// Add to your theme's functions.php or custom plugin

// Initialize HomAI
function init_homai_client() {
    return new HomAI_Client([
        'api_key' => get_option('homai_api_key'),
        'environment' => 'production'
    ]);
}

// Shortcode for property analysis
function homai_analysis_shortcode($atts) {
    $atts = shortcode_atts([
        'property_id' => '',
        'show_form' => 'true'
    ], $atts);
    
    ob_start();
    include 'templates/property-analysis-form.php';
    return ob_get_clean();
}
add_shortcode('homai_analysis', 'homai_analysis_shortcode');
?>

import React, { useState } from 'react';
import { HomAIClient } from '@homai/react-sdk';

const PropertyAnalysis = () => {
  const [analysis, setAnalysis] = useState(null);
  const [loading, setLoading] = useState(false);
  
  const client = new HomAIClient({
    apiKey: process.env.REACT_APP_HOMAI_API_KEY
  });

  const handleAnalysis = async (imageFile, location) => {
    setLoading(true);
    try {
      const result = await client.analyze({
        image: imageFile,
        location: location,
        options: {
          includeRiskAssessment: true,
          generatePDF: true
        }
      });
      setAnalysis(result);
    } catch (error) {
      console.error('Analysis failed:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="property-analysis">
      <PropertyUpload onAnalysis={handleAnalysis} />
      {loading && <LoadingSpinner />}
      {analysis && <AnalysisResults data={analysis} />}
    </div>
  );
};

export default PropertyAnalysis;

// Batch processing multiple properties
const analyzeMultipleProperties = async (properties) => {
  const results = await Promise.allSettled(
    properties.map(async (property) => {
      try {
        const analysis = await client.analyze({
          image: property.imageFile,
          location: property.location,
          options: {
            includeRiskAssessment: true,
            generatePDF: false // Skip PDF for batch processing
          }
        });
        
        return {
          propertyId: property.id,
          status: 'completed',
          data: analysis
        };
      } catch (error) {
        return {
          propertyId: property.id,
          status: 'failed',
          error: error.message
        };
      }
    })
  );
  
  // Process results
  const successful = results.filter(r => r.value?.status === 'completed');
  const failed = results.filter(r => r.value?.status === 'failed');
  
  console.log(`Processed ${successful.length} properties successfully`);
  console.log(`${failed.length} properties failed`);
  
  return results;
};

// Real-time progress tracking
const analyzeWithProgress = async (imageFile, location, onProgress) => {
  // Start analysis
  const analysisId = await client.startAnalysis({
    image: imageFile,
    location: location,
    options: { includeRiskAssessment: true }
  });
  
  // Poll for progress updates
  let analysis;
  let attempts = 0;
  const maxAttempts = 60; // 5 minutes max
  
  while (attempts < maxAttempts) {
    try {
      analysis = await client.getAnalysis(analysisId);
      
      // Update progress
      onProgress({
        stage: analysis.stage,
        progress: analysis.progress,
        estimated_time: analysis.estimatedTimeRemaining
      });
      
      if (analysis.status === 'completed') {
        break;
      } else if (analysis.status === 'failed') {
        throw new Error(analysis.error);
      }
      
      // Wait 5 seconds before next check
      await new Promise(resolve => setTimeout(resolve, 5000));
      attempts++;
      
    } catch (error) {
      console.error('Progress check failed:', error);
      break;
    }
  }
  
  return analysis;
};

// Usage
const progressCallback = (progress) => {
  console.log(`Stage: ${progress.stage}, Progress: ${progress.progress}%`);
  updateProgressBar(progress.progress);
};

const result = await analyzeWithProgress(imageFile, location, progressCallback);

// Configure webhook endpoint
const express = require('express');
const app = express();

app.use(express.json());

// Webhook endpoint for analysis completion
app.post('/webhooks/homai/analysis-complete', (req, res) => {
  const { analysisId, status, data } = req.body;
  
  // Verify webhook signature
  const signature = req.headers['x-homai-signature'];
  if (!verifyWebhookSignature(req.body, signature)) {
    return res.status(401).send('Invalid signature');
  }

  // Process analysis completion
  handleAnalysisCompletion(analysisId, data);
  
  res.status(200).send('OK');
});

// Verify webhook signature for security
const crypto = require('crypto');

function verifyWebhookSignature(payload, signature) {
  const expectedSignature = crypto
    .createHmac('sha256', process.env.HOMAI_WEBHOOK_SECRET)
    .update(JSON.stringify(payload))
    .digest('hex');
    
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(`sha256=${expectedSignature}`)
  );
}