django-cfg 1.3.3__py3-none-any.whl → 1.3.7__py3-none-any.whl

django_cfg/apps/payments/views/overview/serializers.py

@@ -0,0 +1,205 @@
+"""
+💰 Payments Overview Dashboard Serializers
+
+DRF serializers for payments dashboard data with drf-spectacular integration.
+"""
+from rest_framework import serializers
+from drf_spectacular.utils import extend_schema_field
+from typing import Dict, Any
+
+
+class BalanceOverviewSerializer(serializers.Serializer):
+    """
+    User balance overview metrics
+    """
+    current_balance = serializers.FloatField(help_text="Current balance in USD")
+    balance_display = serializers.CharField(help_text="Formatted balance display")
+    total_deposited = serializers.FloatField(help_text="Total amount deposited (lifetime)")
+    total_spent = serializers.FloatField(help_text="Total amount spent (lifetime)")
+    last_transaction_at = serializers.DateTimeField(allow_null=True, help_text="Last transaction timestamp")
+    has_transactions = serializers.BooleanField(help_text="Whether user has any transactions")
+    is_empty = serializers.BooleanField(help_text="Whether balance is zero")
+
+
+class SubscriptionOverviewSerializer(serializers.Serializer):
+    """
+    Current subscription overview
+    """
+    tier = serializers.CharField(help_text="Subscription tier")
+    tier_display = serializers.CharField(help_text="Human-readable tier name")
+    status = serializers.CharField(help_text="Subscription status")
+    status_display = serializers.CharField(help_text="Human-readable status")
+    status_color = serializers.CharField(help_text="Color for status display")
+    is_active = serializers.BooleanField(help_text="Whether subscription is active")
+    is_expired = serializers.BooleanField(help_text="Whether subscription is expired")
+    days_remaining = serializers.IntegerField(help_text="Days until expiration")
+    
+    # Limits and usage
+    requests_per_hour = serializers.IntegerField(help_text="Hourly request limit")
+    requests_per_day = serializers.IntegerField(help_text="Daily request limit")
+    total_requests = serializers.IntegerField(help_text="Total requests made")
+    usage_percentage = serializers.FloatField(help_text="Usage percentage for current period")
+    
+    # Billing
+    monthly_cost_usd = serializers.FloatField(help_text="Monthly cost in USD")
+    cost_display = serializers.CharField(help_text="Formatted cost display")
+    
+    # Dates
+    starts_at = serializers.DateTimeField(help_text="Subscription start date")
+    expires_at = serializers.DateTimeField(help_text="Subscription expiration date")
+    last_request_at = serializers.DateTimeField(allow_null=True, help_text="Last API request timestamp")
+    
+    # Access
+    endpoint_groups_count = serializers.IntegerField(help_text="Number of accessible endpoint groups")
+    endpoint_groups = serializers.ListField(
+        child=serializers.CharField(),
+        help_text="List of accessible endpoint group names"
+    )
+
+
+class APIKeysOverviewSerializer(serializers.Serializer):
+    """
+    API keys overview metrics
+    """
+    total_keys = serializers.IntegerField(help_text="Total number of API keys")
+    active_keys = serializers.IntegerField(help_text="Number of active API keys")
+    expired_keys = serializers.IntegerField(help_text="Number of expired API keys")
+    total_requests = serializers.IntegerField(help_text="Total requests across all keys")
+    last_used_at = serializers.DateTimeField(allow_null=True, help_text="When any key was last used")
+    
+    # Recent keys info
+    most_used_key_name = serializers.CharField(allow_null=True, help_text="Name of most used API key")
+    most_used_key_requests = serializers.IntegerField(help_text="Requests count for most used key")
+    
+    # Expiring keys warning
+    expiring_soon_count = serializers.IntegerField(help_text="Number of keys expiring within 7 days")
+
+
+class PaymentOverviewSerializer(serializers.Serializer):
+    """
+    Payments overview metrics
+    """
+    total_payments = serializers.IntegerField(help_text="Total number of payments")
+    completed_payments = serializers.IntegerField(help_text="Number of completed payments")
+    pending_payments = serializers.IntegerField(help_text="Number of pending payments")
+    failed_payments = serializers.IntegerField(help_text="Number of failed payments")
+    
+    # Amounts
+    total_amount_usd = serializers.FloatField(help_text="Total payment amount in USD")
+    completed_amount_usd = serializers.FloatField(help_text="Total completed amount in USD")
+    average_payment_usd = serializers.FloatField(help_text="Average payment amount in USD")
+    
+    # Success rate
+    success_rate = serializers.FloatField(help_text="Payment success rate percentage")
+    
+    # Recent activity
+    last_payment_at = serializers.DateTimeField(allow_null=True, help_text="Last payment timestamp")
+    payments_this_month = serializers.IntegerField(help_text="Number of payments this month")
+    amount_this_month = serializers.FloatField(help_text="Total amount this month")
+    
+    # Popular currencies
+    top_currency = serializers.CharField(allow_null=True, help_text="Most used currency")
+    top_currency_count = serializers.IntegerField(help_text="Usage count for top currency")
+
+
+class PaymentsMetricsSerializer(serializers.Serializer):
+    """
+    Complete payments dashboard metrics
+    """
+    balance = BalanceOverviewSerializer(help_text="Balance overview")
+    subscription = SubscriptionOverviewSerializer(allow_null=True, help_text="Subscription overview")
+    api_keys = APIKeysOverviewSerializer(help_text="API keys overview")
+    payments = PaymentOverviewSerializer(help_text="Payments overview")
+
+
+class RecentPaymentSerializer(serializers.Serializer):
+    """
+    Recent payment item
+    """
+    id = serializers.UUIDField(help_text="Payment ID")
+    internal_payment_id = serializers.CharField(help_text="Internal payment ID")
+    amount_usd = serializers.FloatField(help_text="Payment amount in USD")
+    amount_display = serializers.CharField(help_text="Formatted amount display")
+    currency_code = serializers.CharField(help_text="Currency code")
+    status = serializers.CharField(help_text="Payment status")
+    status_display = serializers.CharField(help_text="Human-readable status")
+    status_color = serializers.CharField(help_text="Color for status display")
+    provider = serializers.CharField(help_text="Payment provider")
+    created_at = serializers.DateTimeField(help_text="Payment creation timestamp")
+    completed_at = serializers.DateTimeField(allow_null=True, help_text="Payment completion timestamp")
+    
+    # Status flags
+    is_pending = serializers.BooleanField(help_text="Whether payment is pending")
+    is_completed = serializers.BooleanField(help_text="Whether payment is completed")
+    is_failed = serializers.BooleanField(help_text="Whether payment failed")
+
+
+class RecentTransactionSerializer(serializers.Serializer):
+    """
+    Recent transaction item
+    """
+    id = serializers.UUIDField(help_text="Transaction ID")
+    transaction_type = serializers.CharField(help_text="Transaction type")
+    amount_usd = serializers.FloatField(help_text="Transaction amount in USD")
+    amount_display = serializers.CharField(help_text="Formatted amount display")
+    balance_after = serializers.FloatField(help_text="Balance after transaction")
+    description = serializers.CharField(help_text="Transaction description")
+    created_at = serializers.DateTimeField(help_text="Transaction timestamp")
+    payment_id = serializers.CharField(allow_null=True, help_text="Related payment ID")
+    
+    # Type info
+    is_credit = serializers.BooleanField(help_text="Whether this is a credit transaction")
+    is_debit = serializers.BooleanField(help_text="Whether this is a debit transaction")
+    type_color = serializers.CharField(help_text="Color for transaction type display")
+
+
+class ChartDataPointSerializer(serializers.Serializer):
+    """
+    Chart data point for payments analytics
+    """
+    x = serializers.CharField(help_text="X-axis value (date)")
+    y = serializers.FloatField(help_text="Y-axis value (amount or count)")
+
+
+class ChartSeriesSerializer(serializers.Serializer):
+    """
+    Chart series data for payments visualization
+    """
+    name = serializers.CharField(help_text="Series name")
+    data = ChartDataPointSerializer(many=True, help_text="Data points")
+    color = serializers.CharField(help_text="Series color")
+
+
+class PaymentsChartResponseSerializer(serializers.Serializer):
+    """
+    Complete chart response for payments analytics
+    """
+    series = ChartSeriesSerializer(many=True, help_text="Chart series data")
+    period = serializers.CharField(help_text="Time period")
+    total_amount = serializers.FloatField(help_text="Total amount for period")
+    total_payments = serializers.IntegerField(help_text="Total payments for period")
+    success_rate = serializers.FloatField(help_text="Success rate for period")
+
+
+class PaymentsDashboardOverviewSerializer(serializers.Serializer):
+    """
+    Complete payments dashboard overview response
+    """
+    metrics = PaymentsMetricsSerializer(help_text="Dashboard metrics")
+    recent_payments = RecentPaymentSerializer(many=True, help_text="Recent payments")
+    recent_transactions = RecentTransactionSerializer(many=True, help_text="Recent transactions")
+    chart_data = PaymentsChartResponseSerializer(help_text="Chart data for analytics")
+
+
+class TimePeriodSerializer(serializers.Serializer):
+    """
+    Time period filter for charts and analytics
+    """
+    PERIOD_CHOICES = [
+        ('7d', 'Last 7 days'),
+        ('30d', 'Last 30 days'),
+        ('90d', 'Last 90 days'),
+        ('1y', 'Last year'),
+    ]
+    
+    period = serializers.ChoiceField(choices=PERIOD_CHOICES, default='30d')

django_cfg/apps/payments/views/overview/services.py

@@ -0,0 +1,439 @@
+"""
+💰 Payments Overview Dashboard Services
+
+Services for aggregating payments dashboard data from existing models.
+"""
+from django.db.models import Count, Sum, Avg, Q, Max
+from django.utils import timezone
+from datetime import timedelta, date
+from decimal import Decimal
+from typing import Dict, List, Any, Optional
+
+from ...models import (
+    UniversalPayment,
+    UserBalance,
+    Transaction,
+    Subscription,
+    EndpointGroup,
+    APIKey,
+)
+
+
+class PaymentsDashboardMetricsService:
+    """
+    Service for calculating payments dashboard metrics
+    """
+    
+    def __init__(self, user):
+        self.user = user
+        self.now = timezone.now()
+        self.today = self.now.date()
+        self.month_start = self.today.replace(day=1)
+        self.last_month_start = (self.month_start - timedelta(days=1)).replace(day=1)
+        self.last_month_end = self.month_start - timedelta(days=1)
+    
+    def get_dashboard_metrics(self) -> Dict[str, Any]:
+        """
+        Get complete payments dashboard metrics
+        """
+        return {
+            'balance': self.get_balance_overview(),
+            'subscription': self.get_subscription_overview(),
+            'api_keys': self.get_api_keys_overview(),
+            'payments': self.get_payments_overview(),
+        }
+    
+    def get_balance_overview(self) -> Dict[str, Any]:
+        """
+        Get user balance overview using manager methods
+        """
+        balance = UserBalance.objects.get_or_create_for_user(self.user)
+        
+        return {
+            'current_balance': balance.balance_usd,
+            'balance_display': balance.balance_display,
+            'total_deposited': balance.total_deposited,
+            'total_spent': balance.total_spent,
+            'last_transaction_at': balance.last_transaction_at,
+            'has_transactions': balance.has_transactions,
+            'is_empty': balance.is_empty,
+        }
+    
+    def get_subscription_overview(self) -> Optional[Dict[str, Any]]:
+        """
+        Get current subscription overview using manager methods
+        """
+        subscription = Subscription.objects.get_active_for_user(self.user)
+        
+        if not subscription:
+            return None
+        
+        # Get endpoint groups info
+        endpoint_groups = subscription.endpoint_groups.filter(is_enabled=True)
+        endpoint_groups_names = list(endpoint_groups.values_list('name', flat=True))
+        
+        return {
+            'tier': subscription.tier,
+            'tier_display': subscription.tier_display,
+            'status': subscription.status,
+            'status_display': subscription.get_status_display(),
+            'status_color': subscription.status_color,
+            'is_active': subscription.is_active,
+            'is_expired': subscription.is_expired,
+            'days_remaining': subscription.days_remaining,
+            
+            # Limits and usage
+            'requests_per_hour': subscription.requests_per_hour,
+            'requests_per_day': subscription.requests_per_day,
+            'total_requests': subscription.total_requests,
+            'usage_percentage': subscription.usage_percentage,
+            
+            # Billing
+            'monthly_cost_usd': subscription.monthly_cost_usd,
+            'cost_display': f"${subscription.monthly_cost_usd:.2f}/month",
+            
+            # Dates
+            'starts_at': subscription.starts_at,
+            'expires_at': subscription.expires_at,
+            'last_request_at': subscription.last_request_at,
+            
+            # Access
+            'endpoint_groups_count': endpoint_groups.count(),
+            'endpoint_groups': endpoint_groups_names,
+        }
+    
+    def get_api_keys_overview(self) -> Dict[str, Any]:
+        """
+        Get API keys overview using manager methods
+        """
+        api_keys = APIKey.objects.by_user(self.user)
+        
+        total_keys = api_keys.count()
+        active_keys = api_keys.active().count()
+        expired_keys = api_keys.expired().count()
+        
+        # Total requests across all keys
+        total_requests = api_keys.aggregate(
+            total=Sum('total_requests')
+        )['total'] or 0
+        
+        # Last used timestamp
+        last_used_at = api_keys.aggregate(
+            last_used=Max('last_used_at')
+        )['last_used']
+        
+        # Most used key
+        most_used_key = api_keys.order_by('-total_requests').first()
+        most_used_key_name = most_used_key.name if most_used_key else None
+        most_used_key_requests = most_used_key.total_requests if most_used_key else 0
+        
+        # Keys expiring soon (within 7 days)
+        expiring_soon = api_keys.expiring_soon(7).count()
+        
+        return {
+            'total_keys': total_keys,
+            'active_keys': active_keys,
+            'expired_keys': expired_keys,
+            'total_requests': total_requests,
+            'last_used_at': last_used_at,
+            'most_used_key_name': most_used_key_name,
+            'most_used_key_requests': most_used_key_requests,
+            'expiring_soon_count': expiring_soon,
+        }
+    
+    def get_payments_overview(self) -> Dict[str, Any]:
+        """
+        Get payments overview using manager methods
+        """
+        payments = UniversalPayment.objects.by_user(self.user)
+        
+        # Basic counts using manager methods
+        total_payments = payments.count()
+        completed_payments = payments.completed().count()
+        pending_payments = payments.pending().count()
+        failed_payments = payments.failed().count()
+        
+        # Amount calculations
+        total_amount_usd = payments.total_amount()
+        completed_amount_usd = payments.completed().total_amount()
+        average_payment_usd = payments.average_amount()
+        
+        # Success rate
+        success_rate = (completed_payments / total_payments * 100) if total_payments > 0 else 0.0
+        
+        # Recent activity
+        last_payment = payments.order_by('-created_at').first()
+        last_payment_at = last_payment.created_at if last_payment else None
+        
+        # This month stats using manager methods
+        payments_this_month = payments.this_month().count()
+        amount_this_month = payments.this_month().total_amount()
+        
+        # Top currency
+        top_currency_data = payments.values('currency__code').annotate(
+            count=Count('id')
+        ).order_by('-count').first()
+        
+        top_currency = top_currency_data['currency__code'] if top_currency_data else None
+        top_currency_count = top_currency_data['count'] if top_currency_data else 0
+        
+        return {
+            'total_payments': total_payments,
+            'completed_payments': completed_payments,
+            'pending_payments': pending_payments,
+            'failed_payments': failed_payments,
+            
+            'total_amount_usd': total_amount_usd,
+            'completed_amount_usd': completed_amount_usd,
+            'average_payment_usd': average_payment_usd,
+            
+            'success_rate': round(success_rate, 2),
+            
+            'last_payment_at': last_payment_at,
+            'payments_this_month': payments_this_month,
+            'amount_this_month': amount_this_month,
+            
+            'top_currency': top_currency,
+            'top_currency_count': top_currency_count,
+        }
+
+
+class PaymentsUsageChartService:
+    """
+    Service for generating payments usage chart data
+    """
+    
+    def __init__(self, user):
+        self.user = user
+    
+    def get_chart_data(self, period: str = '30d') -> Dict[str, Any]:
+        """
+        Get chart data for payments analytics
+        """
+        days_map = {
+            '7d': 7,
+            '30d': 30,
+            '90d': 90,
+            '1y': 365
+        }
+        
+        days = days_map.get(period, 30)
+        start_date = timezone.now().date() - timedelta(days=days)
+        
+        # Get payments for the period using manager methods
+        payments = UniversalPayment.objects.by_user(self.user).filter(
+            created_at__date__gte=start_date
+        ).values('created_at__date').annotate(
+            total_amount=Sum('amount_usd'),
+            completed_amount=Sum(
+                'actual_amount_usd',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ),
+            payment_count=Count('id'),
+            completed_count=Count(
+                'id',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ),
+            failed_count=Count(
+                'id',
+                filter=Q(status__in=[
+                    UniversalPayment.PaymentStatus.FAILED,
+                    UniversalPayment.PaymentStatus.EXPIRED,
+                    UniversalPayment.PaymentStatus.CANCELLED
+                ])
+            )
+        ).order_by('created_at__date')
+        
+        # Generate chart series data
+        amounts_data = []
+        completed_data = []
+        failed_data = []
+        
+        # Create data points for each day
+        for i in range(days):
+            current_date = start_date + timedelta(days=i)
+            date_str = current_date.strftime('%Y-%m-%d')
+            
+            # Find payments for this date
+            day_data = next(
+                (p for p in payments if p['created_at__date'] == current_date),
+                None
+            )
+            
+            total_amount = day_data['total_amount'] if day_data else 0.0
+            completed_amount = day_data['completed_amount'] if day_data else 0.0
+            failed_count = day_data['failed_count'] if day_data else 0
+            
+            amounts_data.append({'x': date_str, 'y': total_amount})
+            completed_data.append({'x': date_str, 'y': completed_amount})
+            failed_data.append({'x': date_str, 'y': failed_count})
+        
+        # Calculate totals
+        total_amount = sum(p['y'] for p in amounts_data)
+        total_payments = sum(1 for p in amounts_data if p['y'] > 0)
+        completed_amount = sum(p['y'] for p in completed_data)
+        success_rate = (completed_amount / total_amount * 100) if total_amount > 0 else 0.0
+        
+        return {
+            'series': [
+                {
+                    'name': 'Total Amount',
+                    'data': amounts_data,
+                    'color': '#3B82F6'
+                },
+                {
+                    'name': 'Completed Amount',
+                    'data': completed_data,
+                    'color': '#10B981'
+                },
+                {
+                    'name': 'Failed Payments',
+                    'data': failed_data,
+                    'color': '#EF4444'
+                }
+            ],
+            'period': period,
+            'total_amount': total_amount,
+            'total_payments': total_payments,
+            'success_rate': round(success_rate, 2)
+        }
+
+
+class RecentPaymentsService:
+    """
+    Service for getting recent payments and transactions
+    """
+    
+    def __init__(self, user):
+        self.user = user
+    
+    def get_recent_payments(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent payments for the user using manager methods
+        """
+        payments = UniversalPayment.objects.by_user(self.user).optimized().order_by('-created_at')[:limit]
+        
+        result = []
+        for payment in payments:
+            result.append({
+                'id': payment.id,
+                'internal_payment_id': payment.internal_payment_id,
+                'amount_usd': payment.amount_usd,
+                'amount_display': payment.amount_display,
+                'currency_code': payment.currency.code,
+                'status': payment.status,
+                'status_display': payment.get_status_display(),
+                'status_color': payment.status_color,
+                'provider': payment.provider,
+                'created_at': payment.created_at,
+                'completed_at': payment.completed_at,
+                
+                # Status flags
+                'is_pending': payment.is_pending,
+                'is_completed': payment.is_completed,
+                'is_failed': payment.is_failed,
+            })
+        
+        return result
+    
+    def get_recent_transactions(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent transactions for the user using manager methods
+        """
+        transactions = Transaction.objects.by_user(self.user).optimized().order_by('-created_at')[:limit]
+        
+        result = []
+        for transaction in transactions:
+            result.append({
+                'id': transaction.id,
+                'transaction_type': transaction.transaction_type,
+                'amount_usd': transaction.amount_usd,
+                'amount_display': transaction.amount_display,
+                'balance_after': transaction.balance_after,
+                'description': transaction.description,
+                'created_at': transaction.created_at,
+                'payment_id': transaction.payment_id,
+                
+                # Type info
+                'is_credit': transaction.is_credit,
+                'is_debit': transaction.is_debit,
+                'type_color': transaction.type_color,
+            })
+        
+        return result
+
+
+class PaymentsAnalyticsService:
+    """
+    Service for payments analytics and insights
+    """
+    
+    def __init__(self, user):
+        self.user = user
+    
+    def get_payment_analytics(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get payment analytics by currency, provider, etc.
+        """
+        # Analytics by currency using manager methods
+        currency_stats = UniversalPayment.objects.by_user(self.user).values(
+            'currency__code', 'currency__name'
+        ).annotate(
+            total_payments=Count('id'),
+            total_amount=Sum('amount_usd'),
+            completed_payments=Count(
+                'id',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ),
+            avg_amount=Avg('amount_usd'),
+            success_rate=Count(
+                'id',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ) * 100.0 / Count('id')
+        ).order_by('-total_amount')[:limit]
+        
+        result = []
+        for stat in currency_stats:
+            result.append({
+                'currency_code': stat['currency__code'],
+                'currency_name': stat['currency__name'],
+                'total_payments': stat['total_payments'],
+                'total_amount': stat['total_amount'] or 0.0,
+                'completed_payments': stat['completed_payments'],
+                'average_amount': stat['avg_amount'] or 0.0,
+                'success_rate': round(stat['success_rate'] or 0.0, 2),
+            })
+        
+        return result
+    
+    def get_provider_analytics(self) -> List[Dict[str, Any]]:
+        """
+        Get analytics by payment provider
+        """
+        provider_stats = UniversalPayment.objects.by_user(self.user).values('provider').annotate(
+            total_payments=Count('id'),
+            total_amount=Sum('amount_usd'),
+            completed_payments=Count(
+                'id',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ),
+            success_rate=Count(
+                'id',
+                filter=Q(status=UniversalPayment.PaymentStatus.COMPLETED)
+            ) * 100.0 / Count('id')
+        ).order_by('-total_payments')
+        
+        result = []
+        for stat in provider_stats:
+            result.append({
+                'provider': stat['provider'],
+                'provider_display': dict(UniversalPayment.PaymentProvider.choices).get(
+                    stat['provider'], stat['provider']
+                ),
+                'total_payments': stat['total_payments'],
+                'total_amount': stat['total_amount'] or 0.0,
+                'completed_payments': stat['completed_payments'],
+                'success_rate': round(stat['success_rate'] or 0.0, 2),
+            })
+        
+        return result

django_cfg/apps/payments/views/overview/urls.py

@@ -0,0 +1,27 @@
+"""
+💰 Payments Overview Dashboard URLs
+
+Nested router configuration for payments dashboard API endpoints.
+"""
+from rest_framework.routers import DefaultRouter
+from .views import PaymentsDashboardViewSet
+
+# Create router
+router = DefaultRouter()
+
+# Register payments dashboard viewset
+router.register(r'dashboard', PaymentsDashboardViewSet, basename='payments-dashboard')
+
+# URL patterns
+urlpatterns = router.urls
+
+# Available endpoints:
+# GET /api/payments/overview/dashboard/overview/ - Complete payments dashboard overview
+# GET /api/payments/overview/dashboard/metrics/ - Payments dashboard metrics only  
+# GET /api/payments/overview/dashboard/chart_data/?period=30d - Payments chart data
+# GET /api/payments/overview/dashboard/recent_payments/?limit=10 - Recent payments
+# GET /api/payments/overview/dashboard/recent_transactions/?limit=10 - Recent transactions
+# GET /api/payments/overview/dashboard/payment_analytics/?limit=10 - Payment analytics
+# GET /api/payments/overview/dashboard/balance_overview/ - Balance overview only
+# GET /api/payments/overview/dashboard/subscription_overview/ - Subscription overview only
+# GET /api/payments/overview/dashboard/api_keys_overview/ - API keys overview only