@djangocfg/api 1.0.1

package/src/cfg/services/newsletter/NewsletterService.ts

@@ -0,0 +1,79 @@
+/**
+ * Newsletter Service
+ *
+ * Manages newsletter subscriptions
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgSubscriptionsTypes } from '../../generated';
+
+export class NewsletterService extends BaseClient {
+  /**
+   * Subscribe to newsletter
+   */
+  static async subscribe(
+    data: CfgSubscriptionsTypes.SubscribeRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgSubscriptionsTypes.SubscribeResponse;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_subscriptions.newsletterSubscribeCreate(data);
+      return { success: true, response };
+    } 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' };
+    }
+  }
+
+  /**
+   * Unsubscribe from newsletter
+   */
+  static async unsubscribe(
+    data: CfgSubscriptionsTypes.UnsubscribeRequest
+  ): Promise<{
+    success: boolean;
+    response?: CfgSubscriptionsTypes.SuccessResponse;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_subscriptions.newsletterUnsubscribeCreate(data);
+      return { success: true, response };
+    } 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' };
+    }
+  }
+
+  /**
+   * List user subscriptions
+   */
+  static async list(page?: number, pageSize?: number): Promise<{
+    success: boolean;
+    subscriptions?: CfgSubscriptionsTypes.PaginatedNewsletterSubscriptionList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_subscriptions.newsletterSubscriptionsList(page, pageSize);
+      return { success: true, subscriptions: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

package/src/cfg/services/newsletter/NewslettersListService.ts

@@ -0,0 +1,48 @@
+/**
+ * Newsletters List Service
+ *
+ * Manages available newsletters
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgNewslettersTypes } from '../../generated';
+
+export class NewslettersListService extends BaseClient {
+  /**
+   * List available newsletters
+   */
+  static async list(page?: number, pageSize?: number): Promise<{
+    success: boolean;
+    newsletters?: CfgNewslettersTypes.PaginatedNewsletterList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_newsletters.newsletterNewslettersList({ page, page_size: pageSize });
+      return { success: true, newsletters: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get newsletter details
+   */
+  static async get(id: number): Promise<{
+    success: boolean;
+    newsletter?: CfgNewslettersTypes.Newsletter;
+    error?: string;
+  }> {
+    try {
+      const newsletter = await this.api.cfg_newsletters.newsletterNewslettersRetrieve(id);
+      return { success: true, newsletter };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Newsletter Module
+ *
+ * Export all newsletter-related services
+ */
+
+export { CampaignsService } from './CampaignsService';
+export { NewslettersListService } from './NewslettersListService';
+export { BulkEmailService } from './BulkEmailService';
+export { NewsletterService } from './NewsletterService';

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

@@ -0,0 +1,183 @@
+/**
+ * API Keys Service
+ *
+ * Manages API keys - creation, validation, rotation, and management
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgPaymentsTypes } from '../../generated';
+
+export class ApiKeysService extends BaseClient {
+  /**
+   * List API keys (admin)
+   */
+  static async list(params?: {
+    is_active?: boolean;
+    ordering?: string;
+    page?: number;
+    page_size?: number;
+    search?: string;
+    user?: number;
+  }): Promise<{
+    success: boolean;
+    keys?: CfgPaymentsTypes.PaginatedAPIKeyListList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.apiKeysList(params);
+      return { success: true, keys: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Create API key
+   */
+  static async create(
+    data: CfgPaymentsTypes.APIKeyCreateRequest
+  ): Promise<{
+    success: boolean;
+    key?: CfgPaymentsTypes.APIKeyCreate;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.apiKeysCreate(data);
+      return { success: true, key: response };
+    } 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 API key details
+   */
+  static async get(id: string): Promise<{
+    success: boolean;
+    key?: CfgPaymentsTypes.APIKeyDetail;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.apiKeysRetrieve(id);
+      return { success: true, key: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Update API key
+   */
+  static async update(
+    id: string,
+    data: CfgPaymentsTypes.PatchedAPIKeyUpdateRequest
+  ): Promise<{
+    success: boolean;
+    key?: CfgPaymentsTypes.APIKeyUpdate;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.apiKeysPartialUpdate(id, data);
+      return { success: true, key: response };
+    } 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 API key
+   */
+  static async delete(id: string): Promise<{
+    success: boolean;
+    error?: string;
+  }> {
+    try {
+      await this.api.cfg_payments.apiKeysDestroy(id);
+      return { success: true };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Validate API key
+   */
+  static async validate(
+    data: CfgPaymentsTypes.APIKeyValidationRequest
+  ): Promise<{
+    success: boolean;
+    validation?: CfgPaymentsTypes.APIKeyValidationResponse;
+    error?: string;
+  }> {
+    try {
+      const validation = await this.api.cfg_payments.apiKeysValidateCreate(data);
+      return { success: true, validation };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get API keys analytics
+   */
+  static async getAnalytics(): Promise<{
+    success: boolean;
+    analytics?: CfgPaymentsTypes.APIKeyDetail;
+    error?: string;
+  }> {
+    try {
+      const analytics = await this.api.cfg_payments.apiKeysAnalyticsRetrieve();
+      return { success: true, analytics };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get API keys stats
+   */
+  static async getStats(): Promise<{
+    success: boolean;
+    stats?: CfgPaymentsTypes.APIKeyDetail;
+    error?: string;
+  }> {
+    try {
+      const stats = await this.api.cfg_payments.apiKeysStatsRetrieve();
+      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/payments/DashboardService.ts

@@ -0,0 +1,197 @@
+/**
+ * Payment Dashboard Service
+ *
+ * Provides dashboard metrics, overview, and analytics
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgPaymentsTypes } from '../../generated';
+
+export class PaymentDashboardService extends BaseClient {
+  /**
+   * Get complete dashboard overview
+   */
+  static async getOverview(): Promise<{
+    success: boolean;
+    overview?: CfgPaymentsTypes.PaymentsDashboardOverview;
+    error?: string;
+  }> {
+    try {
+      const overview = await this.api.cfg_payments.overviewDashboardOverviewRetrieve();
+      return { success: true, overview };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get dashboard metrics
+   */
+  static async getMetrics(): Promise<{
+    success: boolean;
+    metrics?: CfgPaymentsTypes.PaymentsMetrics;
+    error?: string;
+  }> {
+    try {
+      const metrics = await this.api.cfg_payments.overviewDashboardMetricsRetrieve();
+      return { success: true, metrics };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get balance overview
+   */
+  static async getBalanceOverview(): Promise<{
+    success: boolean;
+    balance?: CfgPaymentsTypes.BalanceOverview;
+    error?: string;
+  }> {
+    try {
+      const balance = await this.api.cfg_payments.overviewDashboardBalanceOverviewRetrieve();
+      return { success: true, balance };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get subscription overview
+   */
+  static async getSubscriptionOverview(): Promise<{
+    success: boolean;
+    subscription?: CfgPaymentsTypes.SubscriptionOverview;
+    error?: string;
+  }> {
+    try {
+      const subscription = await this.api.cfg_payments.overviewDashboardSubscriptionOverviewRetrieve();
+      return { success: true, subscription };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get API keys overview
+   */
+  static async getApiKeysOverview(): Promise<{
+    success: boolean;
+    apiKeys?: CfgPaymentsTypes.APIKeysOverview;
+    error?: string;
+  }> {
+    try {
+      const apiKeys = await this.api.cfg_payments.overviewDashboardApiKeysOverviewRetrieve();
+      return { success: true, apiKeys };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get chart data for payments
+   */
+  static async getChartData(period?: string): Promise<{
+    success: boolean;
+    chartData?: CfgPaymentsTypes.PaymentsChartResponse;
+    error?: string;
+  }> {
+    try {
+      const chartData = await this.api.cfg_payments.overviewDashboardChartDataRetrieve({ period });
+      return { success: true, chartData };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get payment analytics
+   */
+  static async getPaymentAnalytics(limit?: number): Promise<{
+    success: boolean;
+    analytics?: CfgPaymentsTypes.PaymentAnalyticsResponse;
+    error?: string;
+  }> {
+    try {
+      const analytics = await this.api.cfg_payments.overviewDashboardPaymentAnalyticsRetrieve(limit);
+      return { success: true, analytics };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get recent payments
+   */
+  static async getRecentPayments(params?: {
+    limit?: number;
+    page?: number;
+    page_size?: number;
+  }): Promise<{
+    success: boolean;
+    payments?: CfgPaymentsTypes.PaginatedRecentPaymentList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.overviewDashboardRecentPaymentsList(
+        params?.limit,
+        params?.page,
+        params?.page_size
+      );
+      return { success: true, payments: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get recent transactions
+   */
+  static async getRecentTransactions(params?: {
+    limit?: number;
+    page?: number;
+    page_size?: number;
+  }): Promise<{
+    success: boolean;
+    transactions?: CfgPaymentsTypes.PaginatedRecentTransactionList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.overviewDashboardRecentTransactionsList(
+        params?.limit,
+        params?.page,
+        params?.page_size
+      );
+      return { success: true, transactions: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}

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

@@ -0,0 +1,192 @@
+/**
+ * Payments Service
+ *
+ * Manages payment operations - create, check status, cancel
+ */
+
+import { BaseClient } from '../../BaseClient';
+import { APIError, CfgPaymentsTypes } from '../../generated';
+
+export class PaymentsService extends BaseClient {
+  /**
+   * List payments (admin)
+   */
+  static async list(params?: {
+    currency__code?: string;
+    ordering?: string;
+    page?: number;
+    page_size?: number;
+    provider?: string;
+    search?: string;
+    status?: string;
+    user?: number;
+  }): Promise<{
+    success: boolean;
+    payments?: CfgPaymentsTypes.PaginatedPaymentListList;
+    error?: string;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.paymentList(
+        params?.currency__code,
+        params?.ordering,
+        params?.page,
+        params?.page_size,
+        params?.provider,
+        params?.search,
+        params?.status,
+        params?.user
+      );
+      return { success: true, payments: response };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Create payment
+   */
+  static async create(
+    data: CfgPaymentsTypes.PaymentCreateRequest
+  ): Promise<{
+    success: boolean;
+    payment?: CfgPaymentsTypes.PaymentCreate;
+    error?: string;
+    fieldErrors?: Record<string, string[]>;
+  }> {
+    try {
+      const response = await this.api.cfg_payments.paymentCreate(data);
+      return { success: true, payment: response };
+    } 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 payment details
+   */
+  static async get(id: string): Promise<{
+    success: boolean;
+    payment?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const payment = await this.api.cfg_payments.paymentRetrieve(id);
+      return { success: true, payment };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get payment status
+   */
+  static async getStatus(id: string): Promise<{
+    success: boolean;
+    payment?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const payment = await this.api.cfg_payments.paymentStatusRetrieve(id);
+      return { success: true, payment };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Cancel payment
+   */
+  static async cancel(
+    id: string,
+    data: CfgPaymentsTypes.PaymentRequest
+  ): Promise<{
+    success: boolean;
+    payment?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const payment = await this.api.cfg_payments.paymentCancelCreate(id, data);
+      return { success: true, payment };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Check payment status with provider
+   */
+  static async checkStatus(
+    id: string,
+    data: CfgPaymentsTypes.PaymentRequest
+  ): Promise<{
+    success: boolean;
+    payment?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const payment = await this.api.cfg_payments.paymentCheckStatusCreate(id, data);
+      return { success: true, payment };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get payments analytics
+   */
+  static async getAnalytics(): Promise<{
+    success: boolean;
+    analytics?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const analytics = await this.api.cfg_payments.paymentAnalyticsRetrieve();
+      return { success: true, analytics };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+
+  /**
+   * Get payments stats
+   */
+  static async getStats(): Promise<{
+    success: boolean;
+    stats?: CfgPaymentsTypes.Payment;
+    error?: string;
+  }> {
+    try {
+      const stats = await this.api.cfg_payments.paymentStatsRetrieve();
+      return { success: true, stats };
+    } catch (error) {
+      if (error instanceof APIError) {
+        return { success: false, error: error.errorMessage };
+      }
+      return { success: false, error: 'Network error' };
+    }
+  }
+}