Authentication

curl -X POST https://dev.api.baanx.com/v1/auth/login \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "SecurePassword123!"
  }'

const response = await fetch('https://dev.api.baanx.com/v1/auth/login', {
  method: 'POST',
  headers: {
    'x-client-key': 'YOUR_CLIENT_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    email: 'user@example.com',
    password: 'SecurePassword123!'
  })
});

const data = await response.json();

if (data.isOtpRequired) {
  console.log('OTP required for user:', data.userId);
} else {
  console.log('Access token:', data.accessToken);
}

import requests

response = requests.post(
    'https://dev.api.baanx.com/v1/auth/login',
    headers={
        'x-client-key': 'YOUR_CLIENT_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'email': 'user@example.com',
        'password': 'SecurePassword123!'
    }
)

data = response.json()

if data.get('isOtpRequired'):
    print(f"OTP required for user: {data['userId']}")
else:
    print(f"Access token: {data['accessToken']}")

curl -X POST https://dev.api.baanx.com/v1/auth/login/otp \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "b6b9168c-bb56-4c6a-9c0d-4650ea74f5f9"
  }'

async function sendOtpCode(userId: string): Promise<void> {
  const response = await fetch('https://dev.api.baanx.com/v1/auth/login/otp', {
    method: 'POST',
    headers: {
      'x-client-key': 'YOUR_CLIENT_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ userId })
  });

  if (!response.ok) {
    throw new Error('Failed to send OTP code');
  }

  const data = await response.json();
  console.log('OTP code sent:', data.success);
}

def send_otp_code(user_id: str) -> bool:
    response = requests.post(
        'https://dev.api.baanx.com/v1/auth/login/otp',
        headers={
            'x-client-key': 'YOUR_CLIENT_KEY',
            'Content-Type': 'application/json'
        },
        json={'userId': user_id}
    )

    response.raise_for_status()
    data = response.json()
    print(f"OTP code sent: {data['success']}")
    return data['success']

curl -X POST https://dev.api.baanx.com/v1/auth/login \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "SecurePassword123!",
    "otpCode": "123456"
  }'

async function loginWithOtp(
  email: string,
  password: string,
  otpCode: string
): Promise<string> {
  const response = await fetch('https://dev.api.baanx.com/v1/auth/login', {
    method: 'POST',
    headers: {
      'x-client-key': 'YOUR_CLIENT_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      email,
      password,
      otpCode
    })
  });

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

  const data = await response.json();
  return data.accessToken;
}

def login_with_otp(email: str, password: str, otp_code: str) -> str:
    response = requests.post(
        'https://dev.api.baanx.com/v1/auth/login',
        headers={
            'x-client-key': 'YOUR_CLIENT_KEY',
            'Content-Type': 'application/json'
        },
        json={
            'email': email,
            'password': password,
            'otpCode': otp_code
        }
    )

    response.raise_for_status()
    data = response.json()
    return data['accessToken']

class AuthService {
  private apiBase = 'https://dev.api.baanx.com';
  private clientKey = 'YOUR_CLIENT_KEY';

  async login(email: string, password: string): Promise<LoginResponse> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email, password })
    });

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

    return response.json();
  }

  async sendOtpCode(userId: string): Promise<void> {
    const response = await fetch(`${this.apiBase}/v1/auth/login/otp`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ userId })
    });

    if (!response.ok) {
      throw new Error('Failed to send OTP code');
    }
  }

  async loginWithOtp(
    email: string,
    password: string,
    otpCode: string
  ): Promise<string> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: {
        'x-client-key': this.clientKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ email, password, otpCode })
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(error.message || 'OTP login failed');
    }

    const data = await response.json();
    return data.accessToken;
  }

  async handleLogin(email: string, password: string): Promise<string> {
    const loginResult = await this.login(email, password);

    if (loginResult.isOtpRequired) {
      console.log('OTP required. Sending code to:', loginResult.phoneNumber);
      await this.sendOtpCode(loginResult.userId);

      const otpCode = await this.promptUserForOtpCode();

      return await this.loginWithOtp(email, password, otpCode);
    }

    return loginResult.accessToken;
  }

  private async promptUserForOtpCode(): Promise<string> {
    return new Promise((resolve) => {
      console.log('Please enter the OTP code:');
    });
  }
}

interface LoginResponse {
  accessToken: string;
  userId: string;
  isOtpRequired: boolean;
  phoneNumber?: string;
  verificationState: string;
}

const authService = new AuthService();

authService.handleLogin('user@example.com', 'SecurePassword123!')
  .then(accessToken => {
    console.log('Login successful! Token:', accessToken);
    localStorage.setItem('accessToken', accessToken);
  })
  .catch(error => {
    console.error('Login failed:', error);
  });

import requests
from typing import Dict, Optional

class AuthService:
    def __init__(self, api_base: str, client_key: str):
        self.api_base = api_base
        self.client_key = client_key
        self.headers = {
            'x-client-key': client_key,
            'Content-Type': 'application/json'
        }

    def login(self, email: str, password: str) -> Dict:
        response = requests.post(
            f'{self.api_base}/v1/auth/login',
            headers=self.headers,
            json={'email': email, 'password': password}
        )
        response.raise_for_status()
        return response.json()

    def send_otp_code(self, user_id: str) -> None:
        response = requests.post(
            f'{self.api_base}/v1/auth/login/otp',
            headers=self.headers,
            json={'userId': user_id}
        )
        response.raise_for_status()

    def login_with_otp(
        self,
        email: str,
        password: str,
        otp_code: str
    ) -> str:
        response = requests.post(
            f'{self.api_base}/v1/auth/login',
            headers=self.headers,
            json={
                'email': email,
                'password': password,
                'otpCode': otp_code
            }
        )
        response.raise_for_status()
        data = response.json()
        return data['accessToken']

    def handle_login(self, email: str, password: str) -> str:
        login_result = self.login(email, password)

        if login_result.get('isOtpRequired'):
            print(f"OTP required. Sending code to: {login_result['phoneNumber']}")
            self.send_otp_code(login_result['userId'])

            otp_code = input('Please enter the OTP code: ')

            return self.login_with_otp(email, password, otp_code)

        return login_result['accessToken']

auth_service = AuthService(
    'https://dev.api.baanx.com',
    'YOUR_CLIENT_KEY'
)

try:
    access_token = auth_service.handle_login(
        'user@example.com',
        'SecurePassword123!'
    )
    print(f'Login successful! Token: {access_token}')
except requests.exceptions.HTTPError as error:
    print(f'Login failed: {error}')

curl -X POST https://dev.api.baanx.com/v1/auth/logout \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer US_b6b9168a-bb56-4c6a-9c0d-4650ea74f5f9"

async function logout(accessToken: string): Promise<void> {
  const response = await fetch('https://dev.api.baanx.com/v1/auth/logout', {
    method: 'POST',
    headers: {
      'x-client-key': 'YOUR_CLIENT_KEY',
      'Authorization': `Bearer ${accessToken}`
    }
  });

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

  localStorage.removeItem('accessToken');
  localStorage.removeItem('tokenIssuedAt');
  console.log('Logout successful');
}

def logout(access_token: str) -> None:
    response = requests.post(
        'https://dev.api.baanx.com/v1/auth/logout',
        headers={
            'x-client-key': 'YOUR_CLIENT_KEY',
            'Authorization': f'Bearer {access_token}'
        }
    )

    response.raise_for_status()
    print('Logout successful')

class AuthManager {
  private apiBase: string;
  private clientKey: string;
  private tokenKey = 'accessToken';
  private tokenTimeKey = 'tokenIssuedAt';

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

  private get headers() {
    return {
      'x-client-key': this.clientKey,
      'Content-Type': 'application/json'
    };
  }

  private get authHeaders() {
    const token = this.getToken();
    return {
      ...this.headers,
      'Authorization': `Bearer ${token}`
    };
  }

  async login(email: string, password: string): Promise<string> {
    try {
      const response = await fetch(`${this.apiBase}/v1/auth/login`, {
        method: 'POST',
        headers: this.headers,
        body: JSON.stringify({ email, password })
      });

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

      const data = await response.json();

      if (data.isOtpRequired) {
        await this.sendOtpCode(data.userId);
        const otpCode = await this.getOtpFromUser();
        return await this.loginWithOtp(email, password, otpCode);
      }

      this.storeToken(data.accessToken);
      return data.accessToken;
    } catch (error) {
      console.error('Login error:', error);
      throw error;
    }
  }

  async sendOtpCode(userId: string): Promise<void> {
    const response = await fetch(`${this.apiBase}/v1/auth/login/otp`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ userId })
    });

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

  async loginWithOtp(
    email: string,
    password: string,
    otpCode: string
  ): Promise<string> {
    const response = await fetch(`${this.apiBase}/v1/auth/login`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ email, password, otpCode })
    });

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

    const data = await response.json();
    this.storeToken(data.accessToken);
    return data.accessToken;
  }

  async logout(): Promise<void> {
    try {
      await fetch(`${this.apiBase}/v1/auth/logout`, {
        method: 'POST',
        headers: this.authHeaders
      });
    } finally {
      this.clearToken();
    }
  }

  storeToken(token: string): void {
    localStorage.setItem(this.tokenKey, token);
    localStorage.setItem(this.tokenTimeKey, Date.now().toString());
  }

  getToken(): string | null {
    const token = localStorage.getItem(this.tokenKey);
    if (!token) return null;

    if (!this.isTokenValid()) {
      this.clearToken();
      return null;
    }

    return token;
  }

  clearToken(): void {
    localStorage.removeItem(this.tokenKey);
    localStorage.removeItem(this.tokenTimeKey);
  }

  isTokenValid(): boolean {
    const issuedAt = localStorage.getItem(this.tokenTimeKey);
    if (!issuedAt) return false;

    const SIX_HOURS_MS = 6 * 60 * 60 * 1000;
    const elapsed = Date.now() - parseInt(issuedAt);
    return elapsed < SIX_HOURS_MS;
  }

  isAuthenticated(): boolean {
    return this.getToken() !== null;
  }

  private async getOtpFromUser(): Promise<string> {
    return prompt('Enter OTP code:') || '';
  }
}

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

authManager.login('user@example.com', 'SecurePassword123!')
  .then(() => console.log('Login successful'))
  .catch(error => console.error('Login failed:', error));

import time
from typing import Optional
import requests

class AuthManager:
    TOKEN_LIFETIME_MS = 6 * 60 * 60 * 1000

    def __init__(self, api_base: str, client_key: str):
        self.api_base = api_base
        self.client_key = client_key
        self.token: Optional[str] = None
        self.token_issued_at: Optional[int] = None

    @property
    def headers(self):
        return {
            'x-client-key': self.client_key,
            'Content-Type': 'application/json'
        }

    @property
    def auth_headers(self):
        return {
            **self.headers,
            'Authorization': f'Bearer {self.token}'
        }

    def login(self, email: str, password: str) -> str:
        try:
            response = requests.post(
                f'{self.api_base}/v1/auth/login',
                headers=self.headers,
                json={'email': email, 'password': password}
            )
            response.raise_for_status()
            data = response.json()

            if data.get('isOtpRequired'):
                self.send_otp_code(data['userId'])
                otp_code = input('Enter OTP code: ')
                return self.login_with_otp(email, password, otp_code)

            self.store_token(data['accessToken'])
            return data['accessToken']
        except requests.exceptions.HTTPError as error:
            print(f'Login error: {error}')
            raise

    def send_otp_code(self, user_id: str) -> None:
        response = requests.post(
            f'{self.api_base}/v1/auth/login/otp',
            headers=self.headers,
            json={'userId': user_id}
        )
        response.raise_for_status()

    def login_with_otp(
        self,
        email: str,
        password: str,
        otp_code: str
    ) -> str:
        response = requests.post(
            f'{self.api_base}/v1/auth/login',
            headers=self.headers,
            json={
                'email': email,
                'password': password,
                'otpCode': otp_code
            }
        )
        response.raise_for_status()
        data = response.json()
        self.store_token(data['accessToken'])
        return data['accessToken']

    def logout(self) -> None:
        try:
            requests.post(
                f'{self.api_base}/v1/auth/logout',
                headers=self.auth_headers
            )
        finally:
            self.clear_token()

    def store_token(self, token: str) -> None:
        self.token = token
        self.token_issued_at = int(time.time() * 1000)

    def get_token(self) -> Optional[str]:
        if not self.token:
            return None

        if not self.is_token_valid():
            self.clear_token()
            return None

        return self.token

    def clear_token(self) -> None:
        self.token = None
        self.token_issued_at = None

    def is_token_valid(self) -> bool:
        if not self.token_issued_at:
            return False

        elapsed = (int(time.time() * 1000) - self.token_issued_at)
        return elapsed < self.TOKEN_LIFETIME_MS

    def is_authenticated(self) -> bool:
        return self.get_token() is not None

auth_manager = AuthManager(
    'https://dev.api.baanx.com',
    'YOUR_CLIENT_KEY'
)

try:
    auth_manager.login('user@example.com', 'SecurePassword123!')
    print('Login successful')
except Exception as error:
    print(f'Login failed: {error}')