django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/routing/callbacks.py

@@ -4,13 +4,15 @@ Dashboard Callback System
 Provides callback utilities for Unfold dashboard integration.
 """
 
-from typing import Dict, Any, List, Optional, Callable
 from datetime import datetime, timedelta
-from django.http import HttpRequest
+from typing import Any, Dict, List
+
+from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.db import connection
-from django.conf import settings
+from django.http import HttpRequest
+
 from ..modules.base import BaseCfgModule
 
 
@@ -21,15 +23,15 @@ def dashboard_callback(request: HttpRequest, context: Dict[str, Any]) -> Dict[st
     Returns enhanced context with dashboard data.
     """
     User = get_user_model()
-    
+
     # Get basic stats
     user_count = User.objects.count()
-    
+
     # Database info
     with connection.cursor() as cursor:
         cursor.execute("SELECT COUNT(*) FROM django_session")
         session_count = cursor.fetchone()[0]
-    
+
     # Add dashboard data to context
     context.update({
         "dashboard": [
@@ -50,7 +52,7 @@ def dashboard_callback(request: HttpRequest, context: Dict[str, Any]) -> Dict[st
             }
         ]
     })
-    
+
     return context
 
 
@@ -61,11 +63,11 @@ def environment_callback(request: HttpRequest) -> Dict[str, Any]:
     Returns environment information and system status.
     """
 
-    
+
     # Use BaseCfgModule to get config
     base_module = BaseCfgModule()
     config = base_module.get_config()
-    
+
     return {
         "environment": getattr(config, 'environment', 'development'),
         "debug": getattr(config, 'debug', False),
@@ -93,10 +95,10 @@ def permission_callback(request: HttpRequest) -> Dict[str, Any]:
     """
     if not request.user.is_authenticated:
         return {"permissions": [], "groups": []}
-    
+
     user_permissions = list(request.user.get_all_permissions())
     user_groups = list(request.user.groups.values_list('name', flat=True))
-    
+
     return {
         "permissions": user_permissions,
         "groups": user_groups,
@@ -112,37 +114,37 @@ def search_callback(request: HttpRequest, query: str) -> List[Dict[str, Any]]:
     Provides search functionality across models.
     """
 
-    
+
     results = []
-    
+
     if len(query) < 2:
         return results
-    
+
     # Search users
     User = get_user_model()
     users = User.objects.filter(
         username__icontains=query
     ).values('id', 'username', 'email')[:5]
-    
+
     for user in users:
         results.append({
             "title": f"User: {user['username']}",
             "url": f"/admin/auth/user/{user['id']}/change/",
             "description": user.get('email', ''),
         })
-    
+
     # Search content types (as a proxy for apps/models)
     content_types = ContentType.objects.filter(
         model__icontains=query
     ).values('app_label', 'model')[:5]
-    
+
     for ct in content_types:
         results.append({
             "title": f"Model: {ct['app_label']}.{ct['model']}",
             "url": f"/admin/{ct['app_label']}/{ct['model']}/",
             "description": f"Manage {ct['model']} objects",
         })
-    
+
     return results
 
 
@@ -153,16 +155,15 @@ def badge_callback(request: HttpRequest) -> List[Dict[str, Any]]:
     Returns notification badges and counters.
     """
     from django.contrib.auth import get_user_model
-    
+
     User = get_user_model()
-    
+
     # Count new users in last 24 hours
-    from datetime import datetime, timedelta
     yesterday = datetime.now() - timedelta(days=1)
     new_users = User.objects.filter(date_joined__gte=yesterday).count()
-    
+
     badges = []
-    
+
     if new_users > 0:
         badges.append({
             "title": "New Users",
@@ -170,7 +171,7 @@ def badge_callback(request: HttpRequest) -> List[Dict[str, Any]]:
             "color": "primary",
             "url": "/admin/auth/user/?date_joined__gte=" + yesterday.strftime('%Y-%m-%d'),
         })
-    
+
     # Add system health badge
     badges.append({
         "title": "System",
@@ -178,7 +179,7 @@ def badge_callback(request: HttpRequest) -> List[Dict[str, Any]]:
         "color": "success",
         "url": "/admin/",
     })
-    
+
     return badges
 
 
@@ -191,7 +192,7 @@ def get_unfold_callbacks() -> Dict[str, str]:
     """
     return {
         "dashboard_callback": "django_cfg.routing.callbacks.dashboard_callback",
-        "environment_callback": "django_cfg.routing.callbacks.environment_callback", 
+        "environment_callback": "django_cfg.routing.callbacks.environment_callback",
         "permission_callback": "django_cfg.routing.callbacks.permission_callback",
         "search_callback": "django_cfg.routing.callbacks.search_callback",
         "badge_callback": "django_cfg.routing.callbacks.badge_callback",

django_cfg/routing/routers.py

@@ -21,7 +21,7 @@ class DatabaseRouter:
         return rules.get(model._meta.app_label)
 
     def db_for_write(self, model, **hints):
-        """Route writes to correct database.""" 
+        """Route writes to correct database."""
         rules = getattr(settings, 'DATABASE_ROUTING_RULES', {})
         return rules.get(model._meta.app_label)
 
@@ -56,6 +56,6 @@ class DatabaseRouter:
         elif db in rules.values():
             # This app is NOT configured, but the target DB is used by other apps
             return db == 'default'
-        
+
         # Allow migration to default
         return None

django_cfg/static/js/api/accounts/client.mjs

@@ -0,0 +1,69 @@
+import { BaseAPIClient } from '../base.mjs';
+
+/**
+ * Accounts API Client
+ * Auto-generated from OpenAPI schema
+ * @module accounts
+ * @extends BaseAPIClient
+ */
+export class AccountsAPI extends BaseAPIClient {
+    /**
+     * Initialize accounts API client
+     * @param {string} [baseURL] - Optional base URL
+     */
+    constructor(baseURL) {
+        super(baseURL);
+    }
+
+    /**
+     * accountsOtpRequestCreate     * Request OTP code to email or phone.     * @param {OTPRequestRequest} data - Request body     * @returns {Promise<OTPRequestResponse>} Response data
+     */
+    async accountsOtpRequestCreate(data) {
+        const path = `/cfg/accounts/otp/request/`;        return this.post(path, data);    }
+    /**
+     * accountsOtpVerifyCreate     * Verify OTP code and return JWT tokens.     * @param {OTPVerifyRequest} data - Request body     * @returns {Promise<OTPVerifyResponse>} Response data
+     */
+    async accountsOtpVerifyCreate(data) {
+        const path = `/cfg/accounts/otp/verify/`;        return this.post(path, data);    }
+    /**
+     * Get current user profile     * Retrieve the current authenticated user's profile information.     * @returns {Promise<User>} Response data
+     */
+    async accountsProfileRetrieve() {
+        const path = `/cfg/accounts/profile/`;        return this.get(path);    }
+    /**
+     * Upload user avatar     * Upload avatar image for the current authenticated user. Accepts multipart/form-data with 'avatar' field.     * @param {any} data - Request body     * @returns {Promise<User>} Response data
+     */
+    async accountsProfileAvatarCreate(data) {
+        const path = `/cfg/accounts/profile/avatar/`;        return this.post(path, data);    }
+    /**
+     * Partial update user profile     * Partially update the current authenticated user's profile information. Supports avatar upload.     * @param {UserProfileUpdateRequest} data - Request body     * @returns {Promise<User>} Response data
+     */
+    async accountsProfilePartialUpdate(data) {
+        const path = `/cfg/accounts/profile/partial/`;        return this.put(path, data);    }
+    /**
+     * Partial update user profile     * Partially update the current authenticated user's profile information. Supports avatar upload.     * @param {PatchedUserProfileUpdateRequest} data - Request body     * @returns {Promise<User>} Response data
+     */
+    async accountsProfilePartialPartialUpdate(data) {
+        const path = `/cfg/accounts/profile/partial/`;        return this.patch(path, data);    }
+    /**
+     * Update user profile     * Update the current authenticated user's profile information.     * @param {UserProfileUpdateRequest} data - Request body     * @returns {Promise<User>} Response data
+     */
+    async accountsProfileUpdateUpdate(data) {
+        const path = `/cfg/accounts/profile/update/`;        return this.put(path, data);    }
+    /**
+     * Update user profile     * Update the current authenticated user's profile information.     * @param {PatchedUserProfileUpdateRequest} data - Request body     * @returns {Promise<User>} Response data
+     */
+    async accountsProfileUpdatePartialUpdate(data) {
+        const path = `/cfg/accounts/profile/update/`;        return this.patch(path, data);    }
+    /**
+     * accountsTokenRefreshCreate     * Refresh JWT token.     * @param {TokenRefreshRequest} data - Request body     * @returns {Promise<TokenRefresh>} Response data
+     */
+    async accountsTokenRefreshCreate(data) {
+        const path = `/cfg/accounts/token/refresh/`;        return this.post(path, data);    }
+}
+
+// Default instance for convenience
+export const accountsAPI = new AccountsAPI();
+
+// Default export
+export default AccountsAPI;

django_cfg/static/js/api/accounts/index.mjs

@@ -0,0 +1,13 @@
+/**
+ * Accounts API Module
+ * Re-exports the API client for convenient importing
+ * @module accounts
+ */
+
+import { AccountsAPI, accountsAPI } from './client.mjs';
+
+// Re-export the class and instance
+export { AccountsAPI, accountsAPI };
+
+// Default export is the instance for convenience
+export default accountsAPI;

django_cfg/static/js/api/base.mjs

@@ -0,0 +1,166 @@
+/**
+ * Base API Client for django-cfg
+ * Lightweight ES Module with JSDoc type annotations
+ * @module base
+ */
+
+/**
+ * Custom error class for API errors
+ * @class APIError
+ * @extends Error
+ */
+class APIError extends Error {
+    /**
+     * @param {string} message - Error message
+     * @param {number} status - HTTP status code
+     * @param {any} data - Additional error data
+     */
+    constructor(message, status, data) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+        this.data = data;
+    }
+}
+
+/**
+ * Get Django CSRF token from cookies
+ * @returns {string} CSRF token value
+ */
+function getCsrfToken() {
+    const cookie = document.cookie.split('; ')
+        .find(row => row.startsWith('csrftoken='));
+    return cookie ? cookie.split('=')[1] : '';
+}
+
+/**
+ * @typedef {Object} RequestOptions
+ * @property {string} [method='GET'] - HTTP method
+ * @property {Object} [headers={}] - Request headers
+ * @property {any} [body] - Request body
+ * @property {string} [credentials='same-origin'] - Credentials mode
+ */
+
+/**
+ * Base API client class with built-in Django CSRF support
+ * @class BaseAPIClient
+ */
+export class BaseAPIClient {
+    /**
+     * Initialize the API client
+     * @param {string} [baseURL=''] - Base URL for API requests (defaults to current origin)
+     */
+    constructor(baseURL = '') {
+        this.baseURL = baseURL || window.location.origin;
+    }
+
+    /**
+     * Make an API request
+     * @param {string} path - API endpoint path
+     * @param {RequestOptions} [options={}] - Request options
+     * @returns {Promise<any>} Response data
+     * @throws {APIError} When request fails
+     */
+    async request(path, options = {}) {
+        const url = `${this.baseURL}${path}`;
+
+        // Default headers with CSRF token
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-CSRFToken': getCsrfToken(),
+            ...options.headers
+        };
+
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers,
+                credentials: 'same-origin'
+            });
+
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new APIError(
+                    error.detail || `HTTP ${response.status}`,
+                    response.status,
+                    error
+                );
+            }
+
+            // Handle empty responses
+            if (response.status === 204) {
+                return null;
+            }
+
+            return await response.json();
+        } catch (error) {
+            if (error instanceof APIError) {
+                throw error;
+            }
+            throw new APIError(error.message, 0, null);
+        }
+    }
+
+    /**
+     * Make a GET request
+     * @param {string} path - API endpoint path
+     * @param {Object} [params={}] - Query parameters
+     * @returns {Promise<any>} Response data
+     */
+    async get(path, params = {}) {
+        const queryString = new URLSearchParams(params).toString();
+        const fullPath = queryString ? `${path}?${queryString}` : path;
+        return this.request(fullPath, { method: 'GET' });
+    }
+
+    /**
+     * Make a POST request
+     * @param {string} path - API endpoint path
+     * @param {any} [data={}] - Request body data
+     * @returns {Promise<any>} Response data
+     */
+    async post(path, data = {}) {
+        return this.request(path, {
+            method: 'POST',
+            body: JSON.stringify(data)
+        });
+    }
+
+    /**
+     * Make a PUT request
+     * @param {string} path - API endpoint path
+     * @param {any} [data={}] - Request body data
+     * @returns {Promise<any>} Response data
+     */
+    async put(path, data = {}) {
+        return this.request(path, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+        });
+    }
+
+    /**
+     * Make a PATCH request
+     * @param {string} path - API endpoint path
+     * @param {any} [data={}] - Request body data
+     * @returns {Promise<any>} Response data
+     */
+    async patch(path, data = {}) {
+        return this.request(path, {
+            method: 'PATCH',
+            body: JSON.stringify(data)
+        });
+    }
+
+    /**
+     * Make a DELETE request
+     * @param {string} path - API endpoint path
+     * @returns {Promise<any>} Response data
+     */
+    async delete(path) {
+        return this.request(path, { method: 'DELETE' });
+    }
+}
+
+// Export the error class as well
+export { APIError };

django_cfg/static/js/api/index.mjs

@@ -0,0 +1,100 @@
+/**
+ * Django CFG API Clients
+ * Lightweight ES Modules with JSDoc type annotations
+ * Organized by Django apps
+ *
+ * @module django-cfg-api
+ *
+ * @example
+ * // Import specific app API
+ * import { tasksAPI } from '/static/js/api/tasks/index.mjs';
+ * const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
+ *
+ * @example
+ * // Import multiple APIs from main index
+ * import { tasksAPI, paymentsAPI } from '/static/js/api/index.mjs';
+ *
+ * @example
+ * // Import with custom base URL
+ * import { TasksAPI } from '/static/js/api/tasks/index.mjs';
+ * const api = new TasksAPI('https://api.example.com');
+ */
+
+import { BaseAPIClient } from './base.mjs';
+import { AccountsAPI, accountsAPI } from './accounts/index.mjs';
+import { IpcAPI, ipcAPI } from './ipc/index.mjs';
+import { LeadsAPI, leadsAPI } from './leads/index.mjs';
+import { NewsletterAPI, newsletterAPI } from './newsletter/index.mjs';
+import { PaymentsAPI, paymentsAPI } from './payments/index.mjs';
+import { SupportAPI, supportAPI } from './support/index.mjs';
+import { TasksAPI, tasksAPI } from './tasks/index.mjs';
+
+/**
+ * Export all API classes for custom instantiation
+ * @exports
+ */
+export {
+    BaseAPIClient,
+    AccountsAPI,
+    IpcAPI,
+    LeadsAPI,
+    NewsletterAPI,
+    PaymentsAPI,
+    SupportAPI,
+    TasksAPI,
+};
+
+/**
+ * Export all default instances for convenience
+ * These instances use the current origin as base URL
+ * @exports
+ */
+export {
+    accountsAPI,
+    ipcAPI,
+    leadsAPI,
+    newsletterAPI,
+    paymentsAPI,
+    supportAPI,
+    tasksAPI,
+};
+
+/**
+ * Grouped exports by functionality
+ * Access APIs by app name: apis.tasks, apis.payments, etc.
+ * @type {Object.<string, BaseAPIClient>}
+ */
+export const apis = {
+    accounts: accountsAPI,
+    ipc: ipcAPI,
+    leads: leadsAPI,
+    newsletter: newsletterAPI,
+    payments: paymentsAPI,
+    support: supportAPI,
+    tasks: tasksAPI,
+};
+
+/**
+ * Helper function to get API by app name
+ * @param {string} appName - Name of the Django app
+ * @returns {BaseAPIClient|undefined} API instance for the app
+ * @example
+ * const tasksAPI = getAPI('tasks');
+ */
+export function getAPI(appName) {
+    return apis[appName];
+}
+
+/**
+ * List of all available apps
+ * @type {string[]}
+ */
+export const availableApps = [
+    'accounts',
+    'ipc',
+    'leads',
+    'newsletter',
+    'payments',
+    'support',
+    'tasks',
+];

django_cfg/static/js/api/ipc/client.mjs

@@ -0,0 +1,74 @@
+import { BaseAPIClient } from '../base.mjs';
+
+/**
+ * Ipc API Client
+ * Auto-generated from OpenAPI schema
+ * @module ipc
+ * @extends BaseAPIClient
+ */
+export class IpcAPI extends BaseAPIClient {
+    /**
+     * Initialize ipc API client
+     * @param {string} [baseURL] - Optional base URL
+     */
+    constructor(baseURL) {
+        super(baseURL);
+    }
+
+    /**
+     * Get RPC health status     * Returns the current health status of the RPC monitoring system.     * @returns {Promise<HealthCheck>} Response data
+     */
+    async ipcAdminApiMonitorHealthRetrieve() {
+        const path = `/cfg/ipc/admin/api/monitor/health/`;        return this.get(path);    }
+    /**
+     * Get method statistics     * Returns statistics grouped by RPC method.     * @returns {Promise<MethodStats>} Response data
+     */
+    async ipcAdminApiMonitorMethodsRetrieve() {
+        const path = `/cfg/ipc/admin/api/monitor/methods/`;        return this.get(path);    }
+    /**
+     * Get notification statistics     * Returns statistics about RPC notifications.     * @returns {Promise<NotificationStats>} Response data
+     */
+    async ipcAdminApiMonitorNotificationsRetrieve() {
+        const path = `/cfg/ipc/admin/api/monitor/notifications/`;        return this.get(path);    }
+    /**
+     * Get overview statistics     * Returns overview statistics for RPC monitoring.     * @returns {Promise<OverviewStats>} Response data
+     */
+    async ipcAdminApiMonitorOverviewRetrieve() {
+        const path = `/cfg/ipc/admin/api/monitor/overview/`;        return this.get(path);    }
+    /**
+     * Get recent RPC requests     * Returns a list of recent RPC requests with their details.     * @param {Object} [params={}] - Query parameters     * @param {number} [params.count] - Number of requests to return (default: 50, max: 200)     * @returns {Promise<RecentRequests>} Response data
+     */
+    async ipcAdminApiMonitorRequestsRetrieve(params = {}) {
+        const path = `/cfg/ipc/admin/api/monitor/requests/`;        return this.get(path, params);    }
+    /**
+     * Get RPC health status     * Returns the current health status of the RPC monitoring system.     * @returns {Promise<HealthCheck>} Response data
+     */
+    async ipcMonitorHealthRetrieve() {
+        const path = `/cfg/ipc/monitor/health/`;        return this.get(path);    }
+    /**
+     * Get method statistics     * Returns statistics grouped by RPC method.     * @returns {Promise<MethodStats>} Response data
+     */
+    async ipcMonitorMethodsRetrieve() {
+        const path = `/cfg/ipc/monitor/methods/`;        return this.get(path);    }
+    /**
+     * Get notification statistics     * Returns statistics about RPC notifications.     * @returns {Promise<NotificationStats>} Response data
+     */
+    async ipcMonitorNotificationsRetrieve() {
+        const path = `/cfg/ipc/monitor/notifications/`;        return this.get(path);    }
+    /**
+     * Get overview statistics     * Returns overview statistics for RPC monitoring.     * @returns {Promise<OverviewStats>} Response data
+     */
+    async ipcMonitorOverviewRetrieve() {
+        const path = `/cfg/ipc/monitor/overview/`;        return this.get(path);    }
+    /**
+     * Get recent RPC requests     * Returns a list of recent RPC requests with their details.     * @param {Object} [params={}] - Query parameters     * @param {number} [params.count] - Number of requests to return (default: 50, max: 200)     * @returns {Promise<RecentRequests>} Response data
+     */
+    async ipcMonitorRequestsRetrieve(params = {}) {
+        const path = `/cfg/ipc/monitor/requests/`;        return this.get(path, params);    }
+}
+
+// Default instance for convenience
+export const ipcAPI = new IpcAPI();
+
+// Default export
+export default IpcAPI;

django_cfg/static/js/api/ipc/index.mjs

@@ -0,0 +1,13 @@
+/**
+ * Ipc API Module
+ * Re-exports the API client for convenient importing
+ * @module ipc
+ */
+
+import { IpcAPI, ipcAPI } from './client.mjs';
+
+// Re-export the class and instance
+export { IpcAPI, ipcAPI };
+
+// Default export is the instance for convenience
+export default ipcAPI;