@djangocfg/ext-payments 1.0.0

package/src/api/generated/ext_payments/errors.ts

@@ -0,0 +1,116 @@
+/**
+ * API Error Classes
+ *
+ * Typed error classes with Django REST Framework support.
+ */
+
+/**
+ * HTTP API Error with DRF field-specific validation errors.
+ *
+ * Usage:
+ * ```typescript
+ * try {
+ *   await api.users.create(userData);
+ * } catch (error) {
+ *   if (error instanceof APIError) {
+ *     if (error.isValidationError) {
+ *       console.log('Field errors:', error.fieldErrors);
+ *       // { "email": ["Email already exists"], "username": ["Required"] }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class APIError extends Error {
+  constructor(
+    public statusCode: number,
+    public statusText: string,
+    public response: any,
+    public url: string,
+    message?: string
+  ) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.name = 'APIError';
+  }
+
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details(): Record<string, any> | null {
+    if (typeof this.response === 'object' && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors(): Record<string, string[]> | null {
+    const details = this.details;
+    if (!details) return null;
+
+    // DRF typically returns: { "field": ["error1", "error2"] }
+    const fieldErrors: Record<string, string[]> = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage(): string {
+    const details = this.details;
+    if (!details) return this.message;
+
+    // Check for "detail" field (common in DRF)
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(', ') : String(details.detail);
+    }
+
+    // Check for "message" field
+    if (details.message) {
+      return String(details.message);
+    }
+
+    // Return first field error
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(', ')}`;
+      }
+    }
+
+    return this.message;
+  }
+
+  // Helper methods for common HTTP status codes
+  get isValidationError(): boolean { return this.statusCode === 400; }
+  get isAuthError(): boolean { return this.statusCode === 401; }
+  get isPermissionError(): boolean { return this.statusCode === 403; }
+  get isNotFoundError(): boolean { return this.statusCode === 404; }
+  get isServerError(): boolean { return this.statusCode >= 500 && this.statusCode < 600; }
+}
+
+/**
+ * Network Error (connection failed, timeout, etc.)
+ */
+export class NetworkError extends Error {
+  constructor(
+    message: string,
+    public url: string,
+    public originalError?: Error
+  ) {
+    super(message);
+    this.name = 'NetworkError';
+  }
+}

package/src/api/generated/ext_payments/ext_payments__payments/client.ts

@@ -0,0 +1,118 @@
+import * as Models from "./models";
+
+
+/**
+ * API endpoints for Payments.
+ */
+export class ExtPaymentsPayments {
+  private client: any;
+
+  constructor(client: any) {
+    this.client = client;
+  }
+
+  /**
+   * Get user balance
+   * 
+   * Get current user balance and transaction statistics
+   */
+  async balanceRetrieve(): Promise<Models.Balance> {
+    const response = await this.client.request('GET', "/cfg/payments/balance/");
+    return response;
+  }
+
+  /**
+   * Get available currencies
+   * 
+   * Returns list of available currencies with token+network info
+   */
+  async currenciesList(): Promise<any> {
+    const response = await this.client.request('GET', "/cfg/payments/currencies/");
+    return response;
+  }
+
+  async paymentsList(page?: number, page_size?: number): Promise<Models.PaginatedPaymentListList>;
+  async paymentsList(params?: { page?: number; page_size?: number }): Promise<Models.PaginatedPaymentListList>;
+
+  /**
+   * ViewSet for payment operations. Endpoints: - GET /payments/ - List
+   * user's payments - GET /payments/{id}/ - Get payment details - POST
+   * /payments/create/ - Create new payment - GET /payments/{id}/status/ -
+   * Check payment status - POST /payments/{id}/confirm/ - Confirm payment
+   */
+  async paymentsList(...args: any[]): Promise<Models.PaginatedPaymentListList> {
+    const isParamsObject = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0]);
+    
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request('GET', "/cfg/payments/payments/", { params });
+    return response;
+  }
+
+  /**
+   * ViewSet for payment operations. Endpoints: - GET /payments/ - List
+   * user's payments - GET /payments/{id}/ - Get payment details - POST
+   * /payments/create/ - Create new payment - GET /payments/{id}/status/ -
+   * Check payment status - POST /payments/{id}/confirm/ - Confirm payment
+   */
+  async paymentsRetrieve(id: string): Promise<Models.PaymentDetail> {
+    const response = await this.client.request('GET', `/cfg/payments/payments/${id}/`);
+    return response;
+  }
+
+  /**
+   * POST /api/v1/payments/{id}/confirm/ Confirm payment (user clicked "I
+   * have paid"). Checks status with provider and creates transaction if
+   * completed.
+   */
+  async paymentsConfirmCreate(id: string): Promise<Models.PaymentList> {
+    const response = await this.client.request('POST', `/cfg/payments/payments/${id}/confirm/`);
+    return response;
+  }
+
+  /**
+   * GET /api/v1/payments/{id}/status/?refresh=true Check payment status
+   * (with optional refresh from provider). Query params: - refresh: boolean
+   * (default: false) - Force refresh from provider
+   */
+  async paymentsStatusRetrieve(id: string): Promise<Models.PaymentList[]> {
+    const response = await this.client.request('GET', `/cfg/payments/payments/${id}/status/`);
+    return (response as any).results || response;
+  }
+
+  /**
+   * POST /api/v1/payments/create/ Create new payment. Request body: {
+   * "amount_usd": "100.00", "currency_code": "USDTTRC20", "description":
+   * "Optional description" }
+   */
+  async paymentsCreateCreate(): Promise<Models.PaymentList> {
+    const response = await this.client.request('POST', "/cfg/payments/payments/create/");
+    return response;
+  }
+
+  async transactionsList(limit?: number, offset?: number, type?: string): Promise<any>;
+  async transactionsList(params?: { limit?: number; offset?: number; type?: string }): Promise<any>;
+
+  /**
+   * Get user transactions
+   * 
+   * Get user transactions with pagination and filtering
+   */
+  async transactionsList(...args: any[]): Promise<any> {
+    const isParamsObject = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0]);
+    
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { limit: args[0], offset: args[1], type: args[2] };
+    }
+    const response = await this.client.request('GET', "/cfg/payments/transactions/", { params });
+    return response;
+  }
+
+}

package/src/api/generated/ext_payments/ext_payments__payments/index.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * as Models from "./models";

package/src/api/generated/ext_payments/ext_payments__payments/models.ts

@@ -0,0 +1,135 @@
+import * as Enums from "../enums";
+
+/**
+ * User balance serializer.
+ * 
+ * Response model (includes read-only fields).
+ */
+export interface Balance {
+  /** Current balance in USD */
+  balance_usd: string;
+  balance_display: string;
+  /** Total amount deposited (lifetime) */
+  total_deposited: string;
+  /** Total amount withdrawn (lifetime) */
+  total_withdrawn: string;
+  /** When the last transaction occurred */
+  last_transaction_at?: string | null;
+}
+
+/**
+ * 
+ * Response model (includes read-only fields).
+ */
+export interface PaginatedPaymentListList {
+  /** Total number of items across all pages */
+  count: number;
+  /** Current page number (1-based) */
+  page: number;
+  /** Total number of pages */
+  pages: number;
+  /** Number of items per page */
+  page_size: number;
+  /** Whether there is a next page */
+  has_next: boolean;
+  /** Whether there is a previous page */
+  has_previous: boolean;
+  /** Next page number (null if no next page) */
+  next_page?: number | null;
+  /** Previous page number (null if no previous page) */
+  previous_page?: number | null;
+  /** Array of items for current page */
+  results: Array<PaymentList>;
+}
+
+/**
+ * Detailed payment information.
+ * 
+ * Response model (includes read-only fields).
+ */
+export interface PaymentDetail {
+  /** Unique identifier for this record */
+  id: string;
+  /** Internal payment identifier (PAY_YYYYMMDDHHMMSS_UUID) */
+  internal_payment_id: string;
+  /** Payment amount in USD */
+  amount_usd: string;
+  currency_code: string;
+  currency_name: string;
+  currency_token: string;
+  currency_network: string;
+  /** Amount to pay in cryptocurrency */
+  pay_amount?: string | null;
+  /** Actual amount received in cryptocurrency */
+  actual_amount?: string | null;
+  /** Actual amount received in USD */
+  actual_amount_usd?: string | null;
+  /** Current payment status
+
+  * `pending` - Pending
+  * `confirming` - Confirming
+  * `confirmed` - Confirmed
+  * `completed` - Completed
+  * `partially_paid` - Partially Paid
+  * `failed` - Failed
+  * `expired` - Expired
+  * `cancelled` - Cancelled */
+  status: Enums.PaymentDetailStatus;
+  status_display: string;
+  /** Cryptocurrency payment address */
+  pay_address?: string | null;
+  /** Get QR code URL. */
+  qr_code_url?: string | null;
+  /** Payment page URL (if provided by provider) */
+  payment_url?: string | null;
+  /** Blockchain transaction hash */
+  transaction_hash?: string | null;
+  /** Get blockchain explorer link. */
+  explorer_link?: string | null;
+  /** Number of blockchain confirmations */
+  confirmations_count: number;
+  /** When this payment expires (typically 30 minutes) */
+  expires_at?: string | null;
+  /** When this payment was completed */
+  completed_at?: string | null;
+  /** When this record was created */
+  created_at: string;
+  is_completed: boolean;
+  is_failed: boolean;
+  is_expired: boolean;
+  /** Payment description */
+  description: string;
+}
+
+/**
+ * Payment list item (lighter than detail).
+ * 
+ * Response model (includes read-only fields).
+ */
+export interface PaymentList {
+  /** Unique identifier for this record */
+  id: string;
+  /** Internal payment identifier (PAY_YYYYMMDDHHMMSS_UUID) */
+  internal_payment_id: string;
+  /** Payment amount in USD */
+  amount_usd: string;
+  currency_code: string;
+  currency_token: string;
+  /** Current payment status
+
+  * `pending` - Pending
+  * `confirming` - Confirming
+  * `confirmed` - Confirmed
+  * `completed` - Completed
+  * `partially_paid` - Partially Paid
+  * `failed` - Failed
+  * `expired` - Expired
+  * `cancelled` - Cancelled */
+  status: Enums.PaymentListStatus;
+  status_display: string;
+  /** When this record was created */
+  created_at: string;
+  /** When this payment was completed */
+  completed_at?: string | null;
+}
+

package/src/api/generated/ext_payments/http.ts

@@ -0,0 +1,103 @@
+/**
+ * HTTP Client Adapter Pattern
+ *
+ * Allows switching between fetch/axios/httpx without changing generated code.
+ * Provides unified interface for making HTTP requests.
+ */
+
+export interface HttpRequest {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: any;
+  params?: Record<string, any>;
+  /** FormData for file uploads (multipart/form-data) */
+  formData?: FormData;
+}
+
+export interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+}
+
+/**
+ * HTTP Client Adapter Interface.
+ * Implement this to use custom HTTP clients (axios, httpx, etc.)
+ */
+export interface HttpClientAdapter {
+  request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/**
+ * Default Fetch API adapter.
+ * Uses native browser fetch() with proper error handling.
+ */
+export class FetchAdapter implements HttpClientAdapter {
+  async request<T = any>(request: HttpRequest): Promise<HttpResponse<T>> {
+    const { method, url, headers, body, params, formData } = request;
+
+    // Build URL with query params
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes('?') ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+
+    // Build headers
+    const finalHeaders: Record<string, string> = { ...headers };
+
+    // Determine body and content-type
+    let requestBody: string | FormData | undefined;
+
+    if (formData) {
+      // For multipart/form-data, let browser set Content-Type with boundary
+      requestBody = formData;
+      // Don't set Content-Type - browser will set it with boundary
+    } else if (body) {
+      // JSON request
+      finalHeaders['Content-Type'] = 'application/json';
+      requestBody = JSON.stringify(body);
+    }
+
+    // Make request
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: 'include',  // Include Django session cookies
+    });
+
+    // Parse response
+    let data: any = null;
+    const contentType = response.headers.get('content-type');
+
+    if (response.status !== 204 && contentType?.includes('application/json')) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+
+    // Convert Headers to plain object
+    const responseHeaders: Record<string, string> = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+    };
+  }
+}