Working with Business Areas

curl -X GET "https://api.pretectum.io/v1/my/businessareas" \
  -H "Authorization: your_access_token" \
  -H "Accept: application/json"

# Get business areas
curl -X GET "https://api.pretectum.io/v1/my/businessareas" \
  -H "Authorization: your_access_token"

# Search within the "Customer" business area
curl -X GET "https://api.pretectum.io/dataobjects/search?query=John&businessArea=Customer" \
  -H "Authorization: your_access_token"

const API_BASE = 'https://api.pretectum.io';

class PretectumClient {
  constructor(clientId, clientSecret) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.accessToken = null;
    this.tokenExpiry = null;
    this.businessAreas = null;
  }

  async authenticate() {
    const response = await fetch(`${API_BASE}/oauth2/token`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        client_id: this.clientId,
        client_secret: this.clientSecret
      })
    });

    if (!response.ok) {
      throw new Error('Authentication failed');
    }

    const data = await response.json();
    this.accessToken = data.access_token;
    this.tokenExpiry = Date.now() + (data.expires_in * 1000);
  }

  async ensureAuthenticated() {
    if (!this.accessToken || Date.now() >= this.tokenExpiry) {
      await this.authenticate();
    }
  }

  async getBusinessAreas(forceRefresh = false) {
    await this.ensureAuthenticated();

    if (this.businessAreas && !forceRefresh) {
      return this.businessAreas;
    }

    const response = await fetch(`${API_BASE}/v1/my/businessareas`, {
      headers: {
        'Authorization': this.accessToken,
        'Accept': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`Failed to fetch business areas: ${response.statusText}`);
    }

    this.businessAreas = await response.json();
    return this.businessAreas;
  }

  async getActiveBusinessAreas() {
    const areas = await this.getBusinessAreas();
    return areas.filter(area => area.active);
  }

  async getBusinessAreaNames() {
    const areas = await this.getActiveBusinessAreas();
    return areas.map(area => area.name);
  }

  async hasAccessTo(businessAreaName) {
    const areas = await this.getBusinessAreas();
    return areas.some(
      area => area.name === businessAreaName && area.active
    );
  }

  async search(query, options = {}) {
    await this.ensureAuthenticated();

    // Validate business area if provided
    if (options.businessArea) {
      const hasAccess = await this.hasAccessTo(options.businessArea);
      if (!hasAccess) {
        throw new Error(`No access to business area: ${options.businessArea}`);
      }
    }

    const params = new URLSearchParams({ query, ...options });
    const response = await fetch(
      `${API_BASE}/dataobjects/search?${params}`,
      {
        headers: { 'Authorization': this.accessToken }
      }
    );

    if (!response.ok) {
      throw new Error(`Search failed: ${response.statusText}`);
    }

    return response.json();
  }

  async searchAllBusinessAreas(query, options = {}) {
    const areas = await this.getActiveBusinessAreas();
    const results = {};

    for (const area of areas) {
      const searchResults = await this.search(query, {
        ...options,
        businessArea: area.name
      });
      results[area.name] = searchResults;
    }

    return results;
  }
}

// Usage
const client = new PretectumClient('your_client_id', 'your_secret');

// Get available business areas
const businessAreas = await client.getBusinessAreas();
console.log('Available business areas:');
businessAreas.forEach(area => {
  console.log(`  - ${area.name}: ${area.description}`);
});

// Get just the names for a dropdown
const areaNames = await client.getBusinessAreaNames();
console.log('Business area names:', areaNames);

// Search within a specific business area
const results = await client.search('John', { businessArea: 'Customer' });
console.log(`Found ${results.total} customers`);

// Search across all business areas
const allResults = await client.searchAllBusinessAreas('Smith');
for (const [areaName, data] of Object.entries(allResults)) {
  console.log(`${areaName}: ${data.total} results`);
}

import { useState, useEffect } from 'react';

function BusinessAreaSelector({ client, onSelect }) {
  const [businessAreas, setBusinessAreas] = useState([]);
  const [selected, setSelected] = useState('all');
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    async function loadBusinessAreas() {
      try {
        const areas = await client.getActiveBusinessAreas();
        setBusinessAreas(areas);
      } catch (error) {
        console.error('Failed to load business areas:', error);
      } finally {
        setLoading(false);
      }
    }
    loadBusinessAreas();
  }, [client]);

  const handleChange = (event) => {
    const value = event.target.value;
    setSelected(value);
    onSelect(value === 'all' ? null : value);
  };

  if (loading) return <span>Loading...</span>;

  return (
    <select value={selected} onChange={handleChange}>
      <option value="all">All Business Areas</option>
      {businessAreas.map(area => (
        <option key={area.businessAreaId} value={area.name}>
          {area.name}
        </option>
      ))}
    </select>
  );
}

async function safeGetBusinessAreas(client) {
  try {
    return await client.getBusinessAreas();
  } catch (error) {
    if (error.message.includes('401')) {
      // Token expired, re-authenticate and retry
      await client.authenticate();
      return await client.getBusinessAreas();
    }
    if (error.message.includes('403')) {
      console.error('No permission to access business areas');
      return [];
    }
    throw error;
  }
}