@djangocfg/api 1.0.1

package/src/cfg/services/payments/SubscriptionsService.ts

@@ -0,0 +1,202 @@
+/**
+ * Subscriptions Service
+ *
+ * Manages user subscriptions and tariffs
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgPaymentsTypes } from '../../generated';
+
+export class SubscriptionsService extends BaseClient {
+  /**
+   * List subscriptions (admin)
+   */
+  static async list(params?: {
+    ordering?: string;
+    page?: number;
+    page_size?: number;
+    search?: string;
+    status?: string;
+    tier?: string;
+    user?: number;
+  }): Promise<{
+    success: boolean;
+    subscriptions?: CfgPaymentsTypes.PaginatedSubscriptionListList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.subscriptionsList(
+        params?.ordering,
+        params?.page,
+        params?.page_size,
+        params?.search,
+        params?.status,
+        params?.tier,
+        params?.user
+      );
+      return { success: true, subscriptions: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Create subscription
+   */
+  static async create(
+    data: CfgPaymentsTypes.SubscriptionCreateRequest
+  ): Promise<{
+    success: boolean;
+    subscription?: CfgPaymentsTypes.SubscriptionCreate;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const subscription = await this.api.cfg_payments.subscriptionsCreate(data);
+      return { success: true, subscription };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get subscription details
+   */
+  static async get(id: string): Promise<{
+    success: boolean;
+    subscription?: CfgPaymentsTypes.Subscription;
+    error?: string;
+  }> {
+    try {
+      const subscription = await this.api.cfg_payments.subscriptionsRetrieve(id);
+      return { success: true, subscription };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update subscription
+   */
+  static async update(
+    id: string,
+    data: CfgPaymentsTypes.PatchedSubscriptionRequest
+  ): Promise<{
+    success: boolean;
+    subscription?: CfgPaymentsTypes.Subscription;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const subscription = await this.api.cfg_payments.subscriptionsPartialUpdate(id, data);
+      return { success: true, subscription };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Delete subscription
+   */
+  static async delete(id: string): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_payments.subscriptionsDestroy(id);
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get subscriptions analytics
+   */
+  static async getAnalytics(): Promise<{
+    success: boolean;
+    analytics?: CfgPaymentsTypes.Subscription;
+    error?: string;
+  }> {
+    try {
+      const analytics = await this.api.cfg_payments.subscriptionsAnalyticsRetrieve();
+      return { success: true, analytics };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * List tariffs
+   */
+  static async listTariffs(params?: {
+    is_active?: boolean;
+    ordering?: string;
+    page?: number;
+    page_size?: number;
+    search?: string;
+  }): Promise<{
+    success: boolean;
+    tariffs?: CfgPaymentsTypes.PaginatedTariffList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.tariffsList(
+        params?.is_active,
+        params?.ordering,
+        params?.page,
+        params?.page_size,
+        params?.search
+      );
+      return { success: true, tariffs: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get tariff details
+   */
+  static async getTariff(id: number): Promise<{
+    success: boolean;
+    tariff?: CfgPaymentsTypes.Tariff;
+    error?: string;
+  }> {
+    try {
+      const tariff = await this.api.cfg_payments.tariffsRetrieve(id);
+      return { success: true, tariff };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/payments/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Payments Module
+ *
+ * Export all payment-related services
+ */
+
+export { ApiKeysService } from './ApiKeysService';
+export { PaymentsService } from './PaymentsService';
+export { SubscriptionsService } from './SubscriptionsService';
+export { PaymentDashboardService } from './DashboardService';

package/src/cfg/services/support/SupportService.ts

@@ -0,0 +1,142 @@
+/**
+ * Support Service
+ *
+ * Handles support tickets and messages
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgSupportTypes } from '../../generated';
+
+export class SupportService extends BaseClient {
+  /**
+   * Get tickets list
+   */
+  static async getTickets(): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_support.ticketsList();
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get ticket by ID
+   */
+  static async getTicket(id: string): Promise<{
+    success: boolean;
+    ticket?: CfgSupportTypes.Ticket;
+    error?: string;
+  }> {
+    try {
+      const ticket = await this.api.cfg_support.ticketsRetrieve(id);
+      return { success: true, ticket };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Create ticket
+   */
+  static async createTicket(data: CfgSupportTypes.TicketRequest): Promise<{
+    success: boolean;
+    ticket?: CfgSupportTypes.Ticket;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const ticket = await this.api.cfg_support.ticketsCreate(data);
+      return { success: true, ticket };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update ticket
+   */
+  static async updateTicket(
+    id: string,
+    data: CfgSupportTypes.PatchedTicketRequest
+  ): Promise<{
+    success: boolean;
+    ticket?: CfgSupportTypes.Ticket;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const ticket = await this.api.cfg_support.ticketsPartialUpdate(id, data);
+      return { success: true, ticket };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get ticket messages
+   */
+  static async getMessages(ticketId: string): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_support.ticketsMessagesList(ticketId);
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Send message to ticket
+   */
+  static async sendMessage(
+    ticketId: string,
+    text: string
+  ): Promise<{
+    success: boolean;
+    message?: CfgSupportTypes.MessageCreate;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const message = await this.api.cfg_support.ticketsMessagesCreate(ticketId, {
+        text,
+      });
+      return { success: true, message };
+    } catch (error) {
+      if (error instanceof APIError) {
+        if (error.isValidationError && error.fieldErrors) {
+          return { success: false, fieldErrors: error.fieldErrors };
+        }
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/support/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Support Module
+ *
+ * Support tickets and messaging
+ */
+
+export { SupportService } from './SupportService';

package/src/cfg/services/tasks/TasksService.ts

@@ -0,0 +1,170 @@
+/**
+ * Tasks Service
+ *
+ * Manages background tasks, queues, and workers
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgTasksTypes } from '../../generated';
+
+export class TasksService extends BaseClient {
+  /**
+   * Get queue status
+   */
+  static async getQueuesStatus(): Promise<{
+    success: boolean;
+    status?: CfgTasksTypes.QueueStatus;
+    error?: string;
+  }> {
+    try {
+      const status = await this.api.cfg_tasks.apiQueuesStatusRetrieve();
+      return { success: true, status };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Manage queue operations
+   */
+  static async manageQueue(
+    data: CfgTasksTypes.QueueActionRequest
+  ): Promise<{
+    success: boolean;
+    result?: CfgTasksTypes.QueueAction;
+    error?: string;
+  }> {
+    try {
+      const result = await this.api.cfg_tasks.apiQueuesManageCreate(data);
+      return { success: true, result };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Clear all queues
+   */
+  static async clearQueues(
+    data: CfgTasksTypes.APIResponseRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgTasksTypes.APIResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_tasks.apiClearQueuesCreate(data);
+      return { success: true, response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Purge failed tasks
+   */
+  static async purgeFailed(
+    data: CfgTasksTypes.APIResponseRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgTasksTypes.APIResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_tasks.apiPurgeFailedCreate(data);
+      return { success: true, response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get task statistics
+   */
+  static async getTaskStats(): Promise<{
+    success: boolean;
+    stats?: CfgTasksTypes.TaskStatistics;
+    error?: string;
+  }> {
+    try {
+      const stats = await this.api.cfg_tasks.apiTasksStatsRetrieve();
+      return { success: true, stats };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get tasks list
+   */
+  static async getTasksList(): Promise<{
+    success: boolean;
+    tasks?: CfgTasksTypes.APIResponse;
+    error?: string;
+  }> {
+    try {
+      const tasks = await this.api.cfg_tasks.apiTasksListRetrieve();
+      return { success: true, tasks };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get workers list
+   */
+  static async getWorkersList(): Promise<{
+    success: boolean;
+    workers?: CfgTasksTypes.APIResponse;
+    error?: string;
+  }> {
+    try {
+      const workers = await this.api.cfg_tasks.apiWorkersListRetrieve();
+      return { success: true, workers };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Manage worker operations
+   */
+  static async manageWorker(
+    data: CfgTasksTypes.WorkerActionRequest
+  ): Promise<{
+    success: boolean;
+    result?: CfgTasksTypes.WorkerAction;
+    error?: string;
+  }> {
+    try {
+      const result = await this.api.cfg_tasks.apiWorkersManageCreate(data);
+      return { success: true, result };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/tasks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Tasks Module
+ *
+ * Background tasks and workers management
+ */
+
+export { TasksService } from './TasksService';

package/src/cfg/services/webhooks/WebhooksService.ts

@@ -0,0 +1,108 @@
+/**
+ * Webhooks Service
+ *
+ * Manages payment webhooks
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgWebhooksTypes } from '../../generated';
+
+export class WebhooksService extends BaseClient {
+  /**
+   * Get webhook info
+   */
+  static async getInfo(provider: string): Promise<{
+    success: boolean;
+    webhook?: CfgWebhooksTypes.WebhookResponse;
+    error?: string;
+  }> {
+    try {
+      const webhook = await this.api.cfg_webhooks.paymentsWebhooksRetrieve(provider);
+      return { success: true, webhook };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Process webhook
+   */
+  static async process(
+    provider: string,
+    data: CfgWebhooksTypes.WebhookResponseRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgWebhooksTypes.WebhookResponse;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_webhooks.paymentsWebhooksCreate(provider, data);
+      return { success: true, response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get webhook health
+   */
+  static async getHealth(): Promise<{
+    success: boolean;
+    health?: CfgWebhooksTypes.WebhookHealth;
+    error?: string;
+  }> {
+    try {
+      const health = await this.api.cfg_webhooks.paymentsWebhooksHealthRetrieve();
+      return { success: true, health };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get supported providers
+   */
+  static async getProviders(): Promise<{
+    success: boolean;
+    providers?: CfgWebhooksTypes.SupportedProviders;
+    error?: string;
+  }> {
+    try {
+      const providers = await this.api.cfg_webhooks.paymentsWebhooksProvidersRetrieve();
+      return { success: true, providers };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get webhook stats
+   */
+  static async getStats(days?: number): Promise<{
+    success: boolean;
+    stats?: CfgWebhooksTypes.WebhookStats;
+    error?: string;
+  }> {
+    try {
+      const stats = await this.api.cfg_webhooks.paymentsWebhooksStatsRetrieve({ days });
+      return { success: true, stats };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/webhooks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Webhooks Module
+ *
+ * Payment webhooks handling
+ */
+
+export { WebhooksService } from './WebhooksService';

package/src/index.ts

@@ -0,0 +1,35 @@
+/**
+ * @djangocfg/api - Complete API Package
+ *
+ * Auto-generated TypeScript API clients with JWT authentication and service layer
+ *
+ * Usage:
+ * ```typescript
+ * import { AuthService, LeadsService } from '@djangocfg/api';
+ *
+ * // Authenticate with OTP
+ * const result = await AuthService.verifyOTP('user@example.com', '123456');
+ * if (result.success) {
+ *   console.log('Logged in:', result.user);
+ * }
+ *
+ * // Use services
+ * const leadsResult = await LeadsService.getLeads(1, 20);
+ * if (leadsResult.success) {
+ *   console.log('Leads:', leadsResult.data);
+ * }
+ *
+ * // Logout
+ * AuthService.logout();
+ * ```
+ */
+
+// Export everything from generated SDK (types, enums, errors)
+export * from './cfg/generated';
+
+// Export API instance (advanced usage)
+export { api } from './cfg/BaseClient';
+export { api as default } from './cfg/BaseClient';
+
+// Export all services (recommended usage)
+export * from './cfg/services';