ntc-dev-kit 1.0.0__py3-none-any.whl

ntc/templates/drf_structure/templates/django_project/management_command.py

@@ -0,0 +1,114 @@
+import os
+from django.core.management.base import BaseCommand
+from django.core.management import execute_from_command_line
+
+
+class Command(BaseCommand):
+    help = 'Create a new app with NTC structure'
+
+    def add_arguments(self, parser):
+        parser.add_argument('app_name', type=str, help='Name of the app to create')
+
+    def handle(self, *args, **options):
+        app_name = options['app_name']
+        
+        # Sanitize app name (remove domain extensions, replace dots with underscores)
+        app_name = self.sanitize_name(app_name)
+        
+        self.stdout.write(f'Creating app: {app_name}')
+        
+        # Create the app directory structure
+        self.create_app_structure(app_name)
+        
+        self.stdout.write(
+            self.style.SUCCESS(f'Successfully created app "{app_name}"')
+        )
+
+    def sanitize_name(self, name):
+        """Sanitize project/app name by removing TLD and replacing dots with underscores."""
+        # Common TLDs to remove
+        tlds = ['.com', '.org', '.net', '.io', '.co', '.app', '.dev', '.tech', '.ai']
+        
+        # Remove TLD if present
+        for tld in tlds:
+            if name.lower().endswith(tld):
+                name = name[:-len(tld)]
+                break
+        
+        # Replace dots with underscores
+        name = name.replace('.', '_')
+        
+        # Remove any other invalid characters and ensure it starts with a letter
+        import re
+        name = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+        if name and name[0].isdigit():
+            name = 'app_' + name
+            
+        return name.lower()
+
+    def create_app_structure(self, app_name):
+        """Create the app directory structure."""
+        base_path = os.path.join('apps', app_name)
+        
+        # Create directories
+        directories = [
+            base_path,
+            os.path.join(base_path, 'permissions'),
+            os.path.join(base_path, 'serializers'),
+            os.path.join(base_path, 'selectors'),
+            os.path.join(base_path, 'services'),
+            os.path.join(base_path, 'socket'),
+            os.path.join(base_path, 'tasks'),
+            os.path.join(base_path, 'tests'),
+        ]
+        
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
+            # Create __init__.py in each directory
+            init_file = os.path.join(directory, '__init__.py')
+            if not os.path.exists(init_file):
+                with open(init_file, 'w') as f:
+                    f.write('')
+        
+        # Create main app files
+        files_content = {
+            'admin.py': f'''from django.contrib import admin
+
+# Register your models here.
+''',
+            'apps.py': f'''from django.apps import AppConfig
+
+
+class {app_name.title()}Config(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'apps.{app_name}'
+''',
+            'models.py': f'''from django.db import models
+from apps.common.models import TimeStampedModel
+
+# Create your models here.
+''',
+            'urls.py': f'''from django.urls import path
+from . import views
+
+app_name = '{app_name}'
+
+urlpatterns = [
+    # Add your URL patterns here
+]
+''',
+            'views.py': f'''from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from core.response_wrapper import success_response, error_response
+
+# Create your views here.
+''',
+        }
+        
+        for filename, content in files_content.items():
+            file_path = os.path.join(base_path, filename)
+            with open(file_path, 'w') as f:
+                f.write(content)
+        
+        self.stdout.write(f'Created app structure in apps/{app_name}/')

ntc/templates/drf_structure/templates/django_project/prod_settings.py

@@ -0,0 +1,3 @@
+from .base import *
+DEBUG = False
+ALLOWED_HOSTS = ['*']

ntc/templates/drf_structure/templates/django_project/schema.py

@@ -0,0 +1,7 @@
+from drf_spectacular.views import SpectacularAPIView, SpectacularSwaggerView
+from django.urls import path
+
+urlpatterns = [
+    path('schema/', SpectacularAPIView.as_view(), name='schema'),
+    path('docs/', SpectacularSwaggerView.as_view(url_name='schema'), name='swagger-ui'),
+]

ntc/templates/drf_structure/templates/django_project/urls.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+from django.urls import path, include
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+]

ntc/templates/drf_structure/templates/django_project/wsgi.py

@@ -0,0 +1,5 @@
+import os
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', '{project_name}.settings.prod')
+application = get_wsgi_application()

ntc/templates/drf_structure/templates/docker/docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3'
+services:
+  web:
+    build: .
+    command: python manage.py runserver 0.0.0.0:8000
+    ports:
+      - '8000:8000'
+    volumes:
+      - .:/app
+    env_file:
+      - .env

ntc/templates/drf_structure/templates/knowledge/knowledge_description.md

@@ -0,0 +1,201 @@
+# Project Description - {project_name}
+
+This document provides a comprehensive overview of the project architecture, purpose, and technical stack for AI assistants.
+
+## 🎯 Project Purpose
+
+**{project_name}** is a Django REST Framework (DRF) project built using the **NTC (Nexent Toolkit Console)** structure. This project follows enterprise-grade patterns and best practices for building scalable, maintainable API-driven applications.
+
+## 🏛️ Architecture Overview
+
+### **API-First Design**
+- **Backend**: Django REST Framework providing JSON APIs
+- **Frontend**: Separate frontend applications (React, Angular, Vue, etc.)
+- **Communication**: RESTful APIs with standardized JSON responses
+- **Authentication**: JWT-based authentication with refresh tokens
+
+### **Modular Structure**
+- **Apps**: Feature-based Django applications in `apps/` directory
+- **Core**: Shared utilities, base classes, and framework extensions
+- **Services**: External integrations (AWS, Azure, payment gateways)
+- **Common**: Shared models, serializers, and utilities
+
+## 🛠️ Technical Stack
+
+### **Backend Framework**
+- **Django 4.2+**: Web framework
+- **Django REST Framework**: API framework
+- **PostgreSQL/SQLite**: Database (configurable)
+- **Redis**: Caching and session storage
+- **Celery**: Background task processing
+- **JWT**: Authentication tokens
+- **Uvicorn**: ASGI server for async performance
+- **Gunicorn**: WSGI HTTP server
+- **Nginx**: Reverse proxy and static file serving
+
+### **Development Tools**
+- **Docker**: Containerization (Python 3.12-slim)
+- **Docker Compose**: Local development environment
+- **CapRover**: Deployment platform
+- **Environment Variables**: Configuration management via django-environ
+
+### **API Features**
+- **OpenAPI/Swagger**: Auto-generated API documentation at `/docs/`
+- **CORS**: Cross-origin resource sharing configured
+- **Pagination**: Standardized pagination for list endpoints
+- **Error Handling**: Consistent error response format
+- **Logging**: Structured logging with custom formatters
+
+## 🔧 Key Components
+
+### **Authentication System**
+- **JWT Access Tokens**: Short-lived (15 minutes default)
+- **Refresh Tokens**: Long-lived (14 days default)
+- **Token Blacklisting**: Secure logout functionality
+- **Cookie Support**: Optional cookie-based authentication
+
+### **Response Format**
+All API responses follow a standardized format:
+
+```json
+{
+  "status": "success|error",
+  "message": "Human-readable message",
+  "data": { /* Response data */ }
+}
+```
+
+### **Database Models**
+- **TimeStampedModel**: Base model with `created_at` and `updated_at`
+- **BaseModel**: Enhanced base model with BigAutoField primary key
+- **Abstract Models**: Reusable model patterns in `apps.common`
+
+### **Business Logic Pattern**
+- **Views**: Handle HTTP requests/responses only
+- **Services**: Contain business logic and complex operations
+- **Selectors**: Handle data querying and filtering
+- **Serializers**: Data validation and transformation
+
+## 🌐 External Integrations
+
+### **Cloud Services**
+- **Cloudflare R2**: S3-compatible object storage (fully implemented)
+- **Azure Communication Services**: Email backend (fully implemented)
+- **AWS Services**: S3, SES, SNS (configured but not implemented)
+- **Azure Services**: Storage, SMS (configured but not implemented)
+
+### **Monitoring & Error Tracking**
+- **Sentry**: Error tracking and performance monitoring (fully configured)
+
+### **Payment Gateways** (Tanzania-focused)
+- **SELCOM**: Mobile payments
+- **ClickPesa**: Payment processing
+- **Beem**: SMS and payment services
+- **Polar**: Payment gateway
+
+### **Communication**
+- **Email**: Azure Communication Services Email backend with template support
+- **SMS**: Integration ready for Beem and other providers
+- **WebSocket**: Socket handlers in app structure
+
+## 🔄 Development Patterns
+
+### **Service/Selector Pattern**
+```python
+# services/user_service.py
+def create_user(email, password):
+    # Business logic here
+    pass
+
+# selectors/user_selector.py  
+def get_active_users():
+    # Data querying here
+    pass
+
+# views.py
+def create_user_view(request):
+    # Use service for business logic
+    user = create_user(email, password)
+    return success_response(data=user)
+```
+
+### **Response Wrapper Usage**
+```python
+from core.response_wrapper import success_response, error_response
+
+# Success response
+return success_response(
+    data={"user_id": 123},
+    message="User created successfully"
+)
+
+# Error response
+return error_response(
+    message="Invalid credentials",
+    code=400
+)
+```
+
+## 📊 Environment Configuration
+
+### **Development Settings** (`settings/dev.py`)
+- **DEBUG**: True
+- **Database**: SQLite (default)
+- **CORS**: Localhost allowed
+- **Logging**: Console output
+
+### **Production Settings** (`settings/prod.py`)
+- **DEBUG**: False
+- **Database**: PostgreSQL (via environment variables)
+- **Security**: HTTPS redirects, secure cookies
+- **Logging**: File-based logging
+
+## 🚀 Deployment
+
+### **Docker Support**
+- **Multi-stage builds**: Optimized for production with Python 3.12-slim
+- **Nginx Reverse Proxy**: Handles HTTP/WebSocket traffic and static files
+- **Uvicorn Workers**: ASGI server for async performance
+- **Gunicorn**: WSGI HTTP server with Uvicorn workers
+- **Entry Scripts**: `.entry/start_core_backend.sh` and `.entry/start_tasks_backend.sh`
+- **Configuration Files**: `config/gunicorn_config.py` and `config/http.conf`
+- **Environment Variables**: Configurable via `.env`
+- **Health checks**: Built-in health monitoring
+- **Production Settings**: ASGI/WSGI use `settings.prod` by default
+- **DEBUG=False**: Production-ready default configuration
+
+### **CapRover Deployment**
+- **One-click deployment**: Using `captain-definition`
+- **Auto-scaling**: Configurable scaling rules
+- **SSL**: Automatic SSL certificate management
+
+## 📝 API Documentation
+
+### **Auto-generated Docs**
+- **Swagger UI**: Available at `/docs/`
+- **OpenAPI Schema**: Available at `/schema/`
+- **Interactive Testing**: Built-in API testing interface
+
+### **Response Examples**
+The API provides consistent, well-documented responses with examples for all endpoints.
+
+## 🎯 Best Practices Implemented
+
+1. **Separation of Concerns**: Clear separation between views, services, and data access
+2. **DRY Principle**: Reusable components and base classes
+3. **Security First**: JWT authentication, CORS, secure headers
+4. **Scalability**: Modular app structure, background tasks with Celery
+5. **Maintainability**: Clear naming conventions, comprehensive documentation
+6. **Testing Ready**: Test directories in every app, test utilities available
+
+## 🤖 AI Assistant Guidelines
+
+When working with this project:
+- **Follow NTC patterns** and conventions
+- **Use the service/selector pattern** for business logic
+- **Leverage existing utilities** in `core/` and `apps.common/`
+- **Maintain consistent API responses** using response wrappers
+- **Add proper error handling** and validation
+- **Update documentation** when adding new features
+- **Use environment variables** for configuration
+- **Follow Django and DRF best practices**