Profile Management

curl -X GET https://dev.api.baanx.com/v1/user \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

curl -X GET https://dev.api.baanx.com/v1/user/verification \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

class VerificationManager {
  private apiBase: string;
  private clientKey: string;

  constructor(apiBase: string, clientKey: string) {
    this.apiBase = apiBase;
    this.clientKey = clientKey;
  }

  async checkAndPromptVerification(accessToken: string): Promise<void> {
    const profile = await this.getUserProfile(accessToken);

    switch (profile.verificationState) {
      case 'UNVERIFIED':
        if (confirm('Identity verification required. Start now?')) {
          await this.startVerification(accessToken);
        }
        break;

      case 'PENDING':
        alert('Your verification is under review. This usually takes 1-3 business days.');
        break;

      case 'VERIFIED':
        console.log('User is verified');
        break;

      case 'REJECTED':
        alert('Your verification was rejected. Please contact support or try again.');
        break;
    }
  }

  async startVerification(accessToken: string): Promise<void> {
    try {
      const response = await fetch(`${this.apiBase}/v1/user/verification`, {
        method: 'GET',
        headers: {
          'x-client-key': this.clientKey,
          'Authorization': `Bearer ${accessToken}`
        }
      });

      if (!response.ok) {
        throw new Error('Failed to start verification');
      }

      const { sessionUrl } = await response.json();
      window.location.href = sessionUrl;
    } catch (error) {
      console.error('Verification error:', error);
      throw error;
    }
  }

  private async getUserProfile(accessToken: string): Promise<any> {
    const response = await fetch(`${this.apiBase}/v1/user`, {
      method: 'GET',
      headers: {
        'x-client-key': this.clientKey,
        'Authorization': `Bearer ${accessToken}`
      }
    });

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

    return response.json();
  }
}

const verificationManager = new VerificationManager(
  'https://dev.api.baanx.com',
  'YOUR_CLIENT_KEY'
);

verificationManager.checkAndPromptVerification('YOUR_ACCESS_TOKEN');

curl -X GET "https://dev.api.baanx.com/v1/auth/register?onboardingId=US_100a99cf-f4d3-4fa1-9be9-2e9828b20ebb" \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

import { useState, useEffect } from 'react';

interface UserProfile {
  id: string;
  email: string;
  firstName: string;
  lastName: string;
  verificationState: 'UNVERIFIED' | 'PENDING' | 'VERIFIED' | 'REJECTED';
  phoneNumber: string;
  phoneCountryCode: string;
  addressLine1: string;
  city: string;
  zip: string;
  countryOfResidence: string;
}

function UserProfileCard({ accessToken }: { accessToken: string }) {
  const [profile, setProfile] = useState<UserProfile | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    fetchProfile();
  }, []);

  const fetchProfile = async () => {
    try {
      const response = await fetch('https://dev.api.baanx.com/v1/user', {
        headers: {
          'x-client-key': 'YOUR_CLIENT_KEY',
          'Authorization': `Bearer ${accessToken}`
        }
      });

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

      const data = await response.json();
      setProfile(data);
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Unknown error');
    } finally {
      setLoading(false);
    }
  };

  const getVerificationBadge = (state: string) => {
    const badges = {
      VERIFIED: { color: 'green', text: 'Verified ✓' },
      PENDING: { color: 'yellow', text: 'Pending Review' },
      UNVERIFIED: { color: 'red', text: 'Not Verified' },
      REJECTED: { color: 'red', text: 'Rejected' }
    };

    const badge = badges[state as keyof typeof badges];
    return (
      <span style={{ color: badge.color, fontWeight: 'bold' }}>
        {badge.text}
      </span>
    );
  };

  if (loading) return <div>Loading profile...</div>;
  if (error) return <div>Error: {error}</div>;
  if (!profile) return <div>No profile data</div>;

  return (
    <div style={{ border: '1px solid #ccc', padding: '20px', borderRadius: '8px' }}>
      <h2>Profile Information</h2>

      <div style={{ marginBottom: '10px' }}>
        <strong>Name:</strong> {profile.firstName} {profile.lastName}
      </div>

      <div style={{ marginBottom: '10px' }}>
        <strong>Email:</strong> {profile.email}
      </div>

      <div style={{ marginBottom: '10px' }}>
        <strong>Phone:</strong> {profile.phoneCountryCode} {profile.phoneNumber}
      </div>

      <div style={{ marginBottom: '10px' }}>
        <strong>Address:</strong> {profile.addressLine1}, {profile.city} {profile.zip}
      </div>

      <div style={{ marginBottom: '10px' }}>
        <strong>Country:</strong> {profile.countryOfResidence}
      </div>

      <div style={{ marginBottom: '10px' }}>
        <strong>Verification Status:</strong>{' '}
        {getVerificationBadge(profile.verificationState)}
      </div>

      {profile.verificationState !== 'VERIFIED' && (
        <button
          onClick={() => window.location.href = '/verification'}
          style={{
            marginTop: '10px',
            padding: '10px 20px',
            backgroundColor: '#007bff',
            color: 'white',
            border: 'none',
            borderRadius: '5px',
            cursor: 'pointer'
          }}
        >
          Complete Verification
        </button>
      )}
    </div>
  );
}

export default UserProfileCard;

class ProfileManager {
  private apiBase: string;
  private clientKey: string;
  private cache: Map<string, { data: any; timestamp: number }> = new Map();
  private cacheTTL = 5 * 60 * 1000;

  constructor(apiBase: string, clientKey: string) {
    this.apiBase = apiBase;
    this.clientKey = clientKey;
  }

  async getProfile(
    accessToken: string,
    useCache = true
  ): Promise<UserProfile> {
    if (useCache) {
      const cached = this.cache.get('profile');
      if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
        return cached.data;
      }
    }

    try {
      const response = await fetch(`${this.apiBase}/v1/user`, {
        headers: {
          'x-client-key': this.clientKey,
          'Authorization': `Bearer ${accessToken}`
        }
      });

      if (!response.ok) {
        if (response.status === 401) {
          throw new Error('UNAUTHORIZED');
        }
        throw new Error(`HTTP ${response.status}`);
      }

      const data = await response.json();
      this.cache.set('profile', { data, timestamp: Date.now() });
      return data;
    } catch (error) {
      console.error('Failed to fetch profile:', error);
      throw error;
    }
  }

  async startVerification(accessToken: string): Promise<string> {
    try {
      const response = await fetch(`${this.apiBase}/v1/user/verification`, {
        headers: {
          'x-client-key': this.clientKey,
          'Authorization': `Bearer ${accessToken}`
        }
      });

      if (!response.ok) {
        throw new Error('Failed to start verification');
      }

      const { sessionUrl } = await response.json();
      return sessionUrl;
    } catch (error) {
      console.error('Verification error:', error);
      throw error;
    }
  }

  clearCache(): void {
    this.cache.clear();
  }

  isVerified(profile: UserProfile): boolean {
    return profile.verificationState === 'VERIFIED';
  }

  needsVerification(profile: UserProfile): boolean {
    return ['UNVERIFIED', 'REJECTED'].includes(profile.verificationState);
  }

  formatAddress(profile: UserProfile): string {
    const parts = [
      profile.addressLine1,
      profile.addressLine2,
      profile.city,
      profile.zip,
      profile.countryOfResidence
    ].filter(Boolean);

    return parts.join(', ');
  }

  formatPhone(profile: UserProfile): string {
    return `${profile.phoneCountryCode} ${profile.phoneNumber}`;
  }

  maskSsn(ssn?: string): string {
    if (!ssn) return 'Not provided';
    return `***-**-${ssn.slice(-4)}`;
  }
}

interface UserProfile {
  id: string;
  email: string;
  firstName: string;
  lastName: string;
  dateOfBirth: string;
  phoneNumber: string;
  phoneCountryCode: string;
  verificationState: 'UNVERIFIED' | 'PENDING' | 'VERIFIED' | 'REJECTED';
  addressLine1: string;
  addressLine2?: string;
  city: string;
  zip: string;
  countryOfResidence: string;
  countryOfNationality: string;
  usState?: string;
  ssn?: string;
}

const profileManager = new ProfileManager(
  'https://dev.api.baanx.com',
  'YOUR_CLIENT_KEY'
);

async function displayUserDashboard(accessToken: string) {
  try {
    const profile = await profileManager.getProfile(accessToken);

    console.log('User Dashboard');
    console.log('==============');
    console.log(`Name: ${profile.firstName} ${profile.lastName}`);
    console.log(`Email: ${profile.email}`);
    console.log(`Phone: ${profileManager.formatPhone(profile)}`);
    console.log(`Address: ${profileManager.formatAddress(profile)}`);
    console.log(`Verification: ${profile.verificationState}`);

    if (profileManager.needsVerification(profile)) {
      console.log('\n⚠️  Verification required');
      const sessionUrl = await profileManager.startVerification(accessToken);
      console.log(`Complete verification at: ${sessionUrl}`);
    }
  } catch (error) {
    if (error.message === 'UNAUTHORIZED') {
      console.error('Session expired. Please login again.');
    } else {
      console.error('Error:', error);
    }
  }
}