Get Registration Settings

curl -X GET "https://api.example.com/v1/auth/settings" \
  -H "x-client-key: your-client-key"

async function loadRegistrationSettings() {
  const response = await fetch('https://api.example.com/v1/auth/settings', {
    headers: {
      'x-client-key': 'your-client-key'
    }
  });

  const settings = await response.json();

  // Populate country dropdown
  const countrySelect = document.getElementById('country');
  settings.countries
    .filter(c => c.canSignUp)
    .forEach(country => {
      const option = document.createElement('option');
      option.value = country.iso3166alpha2;
      option.textContent = country.name;
      option.dataset.callingCode = country.callingCode;
      countrySelect.appendChild(option);
    });

  // Populate US states dropdown (if applicable)
  if (settings.usStates.length > 0) {
    const stateSelect = document.getElementById('state');
    settings.usStates
      .filter(s => s.canSignUp)
      .forEach(state => {
        const option = document.createElement('option');
        option.value = state.postalAbbreviation;
        option.textContent = state.name;
        stateSelect.appendChild(option);
      });
  }

  // Display legal links
  const isUS = detectUserRegion() === 'US';
  const links = isUS ? settings.links.us : settings.links.intl;

  document.getElementById('terms-link').href = links.termsAndConditions;
  if (isUS) {
    document.getElementById('disclosure-link').href = links.accountOpeningDisclosure;
    document.getElementById('privacy-link').href = links.noticeOfPrivacy;
  }

  // Store config for validation
  sessionStorage.setItem('registrationConfig', JSON.stringify(settings.config));

  return settings;
}

import { useState, useEffect } from 'react';

interface Country {
  id: string;
  iso3166alpha2: string;
  name: string;
  callingCode: string;
  canSignUp: boolean;
}

interface USState {
  id: string;
  name: string;
  postalAbbreviation: string;
  canSignUp: boolean;
}

interface RegistrationSettings {
  countries: Country[];
  usStates: USState[];
  links: {
    us: any;
    intl: any;
  };
  config: {
    us: any;
    intl: any;
  };
}

export function useRegistrationSettings() {
  const [settings, setSettings] = useState<RegistrationSettings | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    async function fetchSettings() {
      try {
        const response = await fetch('https://api.example.com/v1/auth/settings', {
          headers: {
            'x-client-key': process.env.NEXT_PUBLIC_CLIENT_KEY!
          }
        });

        if (!response.ok) {
          throw new Error('Failed to fetch registration settings');
        }

        const data = await response.json();
        setSettings(data);
      } catch (err) {
        setError(err as Error);
      } finally {
        setLoading(false);
      }
    }

    fetchSettings();
  }, []);

  return { settings, loading, error };
}

// Usage in component
function RegistrationForm() {
  const { settings, loading, error } = useRegistrationSettings();

  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <form>
      <select name="country">
        {settings?.countries
          .filter(c => c.canSignUp)
          .map(country => (
            <option key={country.id} value={country.iso3166alpha2}>
              {country.name}
            </option>
          ))
        }
      </select>

      <select name="state">
        {settings?.usStates
          .filter(s => s.canSignUp)
          .map(state => (
            <option key={state.id} value={state.postalAbbreviation}>
              {state.name}
            </option>
          ))
        }
      </select>
    </form>
  );
}

import requests
from typing import Dict, Any
from datetime import datetime, timedelta

class RegistrationSettingsCache:
    def __init__(self, client_key: str):
        self.client_key = client_key
        self.cache: Dict[str, Any] = {}
        self.cache_expiry: datetime = datetime.min

    def get_settings(self, region: str = 'intl') -> Dict[str, Any]:
        # Check cache validity (1 hour)
        if datetime.now() > self.cache_expiry:
            self._refresh_cache()

        return self.cache

    def _refresh_cache(self):
        response = requests.get(
            'https://api.example.com/v1/auth/settings',
            headers={'x-client-key': self.client_key}
        )

        if response.status_code == 200:
            self.cache = response.json()
            self.cache_expiry = datetime.now() + timedelta(hours=1)
        else:
            raise Exception(f"Failed to fetch settings: {response.status_code}")

    def get_country_by_code(self, code: str) -> Dict[str, Any]:
        for country in self.cache.get('countries', []):
            if country['iso3166alpha2'] == code:
                return country
        return None

    def get_allowed_countries(self) -> list:
        return [
            c for c in self.cache.get('countries', [])
            if c.get('canSignUp', False)
        ]

# Usage
settings_cache = RegistrationSettingsCache('your-client-key')
settings = settings_cache.get_settings()

allowed_countries = settings_cache.get_allowed_countries()
print(f"Registration enabled for {len(allowed_countries)} countries")