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

ntc/composer/main.py

@@ -0,0 +1,443 @@
+import os
+import sys
+import yaml
+import msvcrt
+import shutil
+from colorama import Fore, Style
+from ntc.utils.output import print_success, print_error, print_warning, print_info
+
+def is_directory_empty(directory):
+    """Check if a directory is empty (ignoring hidden files)."""
+    if not os.path.exists(directory):
+        return True
+    
+    items = [item for item in os.listdir(directory) if not item.startswith('.')]
+    return len(items) == 0
+
+def get_project_choices():
+    """Get user choices for which projects to create using interactive menu."""
+    options = [
+        {"label": "Backend (Django REST Framework)", "value": "backend", "selected": False},
+        {"label": "Website (Next.js)", "value": "website", "selected": False},
+        {"label": "Mobile App (Flutter)", "value": "mobile", "selected": False},
+        {"label": "Admin Dashboard (React Admin)", "value": "admin", "selected": False},
+        {"label": "All of the above", "value": "all", "selected": False},
+    ]
+    
+    current_index = 0
+    
+    while True:
+        # Clear screen and redraw menu
+        os.system('cls' if os.name == 'nt' else 'clear')
+        print_info("Select the projects you want to create:")
+        print("─" * 50)
+        print("Use ↑↓ arrows to navigate, SPACE to select/deselect, ENTER to confirm")
+        print("─" * 50)
+        
+        for i, option in enumerate(options):
+            prefix = "→ " if i == current_index else "  "
+            checkmark = "✓" if option["selected"] else " "
+            label = option["label"]
+            
+            if i == current_index:
+                print(f"{Fore.GREEN}{prefix}[{checkmark}] {label}{Style.RESET_ALL}")
+            else:
+                print(f"{prefix}[{checkmark}] {label}")
+        
+        # Get key press
+        key = msvcrt.getch()
+        
+        if key == b'\r':  # Enter key
+            selected_projects = []
+            for option in options:
+                if option["selected"]:
+                    if option["value"] == "all":
+                        selected_projects = ["backend", "website", "mobile", "admin"]
+                        break
+                    else:
+                        selected_projects.append(option["value"])
+            
+            if not selected_projects:
+                print_warning("No projects selected. Defaulting to backend only.")
+                return ["backend"]
+            
+            return selected_projects
+        
+        elif key == b' ':  # Space bar
+            if options[current_index]["value"] == "all":
+                # Toggle "All" option
+                options[current_index]["selected"] = not options[current_index]["selected"]
+                if options[current_index]["selected"]:
+                    # Select all other options
+                    for i in range(len(options) - 1):
+                        options[i]["selected"] = True
+                else:
+                    # Deselect all other options
+                    for i in range(len(options) - 1):
+                        options[i]["selected"] = False
+            else:
+                # Toggle individual option
+                options[current_index]["selected"] = not options[current_index]["selected"]
+                # If any individual option is deselected, deselect "All"
+                if not options[current_index]["selected"]:
+                    options[-1]["selected"] = False
+                # If all individual options are selected, select "All"
+                elif all(options[i]["selected"] for i in range(len(options) - 1)):
+                    options[-1]["selected"] = True
+        
+        elif key == b'\x00' or key == b'\xe0':  # Arrow key prefix
+            key = msvcrt.getch()
+            if key == b'H':  # Up arrow
+                current_index = (current_index - 1) % len(options)
+            elif key == b'P':  # Down arrow
+                current_index = (current_index + 1) % len(options)
+
+def create_ntc_yml(project_name, projects, root_dir):
+    """Create ntc.yml configuration file."""
+    config = {
+        "project": {
+            "name": project_name,
+            "version": "1.0.0",
+            "description": f"{project_name} - Full stack application"
+        },
+        "components": {},
+        "deployment": {
+            "platform": "caprover",
+            "environment": "production"
+        }
+    }
+    
+    # Add component configurations
+    if "backend" in projects:
+        config["components"]["backend"] = {
+            "type": "django",
+            "path": f"{project_name}_backend",
+            "port": 8000,
+            "environment": {
+                "type": "venv",  # Default to venv, will be updated by user
+                "path": f"{project_name}_backend/env"
+            },
+            "dependencies": {
+                "file": "requirements.txt",
+                "manager": "pip"
+            },
+            "start_command": "python manage.py runserver"
+        }
+    
+    if "website" in projects:
+        config["components"]["website"] = {
+            "type": "nextjs",
+            "path": f"{project_name}_website",
+            "port": 3000,
+            "environment": {
+                "type": "node",
+                "path": None
+            },
+            "dependencies": {
+                "file": "package.json",
+                "manager": "npm"
+            },
+            "start_command": "npm run dev"
+        }
+    
+    if "mobile" in projects:
+        config["components"]["mobile"] = {
+            "type": "flutter",
+            "path": f"{project_name}_mobile",
+            "port": None,
+            "environment": {
+                "type": "flutter",
+                "path": None
+            },
+            "dependencies": {
+                "file": "pubspec.yaml",
+                "manager": "flutter"
+            },
+            "start_command": "flutter run"
+        }
+    
+    if "admin" in projects:
+        config["components"]["admin"] = {
+            "type": "react-admin",
+            "path": f"{project_name}_admin",
+            "port": 5173,
+            "environment": {
+                "type": "node",
+                "path": None
+            },
+            "dependencies": {
+                "file": "package.json",
+                "manager": "npm"
+            },
+            "start_command": "npm run dev"
+        }
+    
+    # Write ntc.yml
+    ntc_yml_path = os.path.join(root_dir, "ntc.yml")
+    with open(ntc_yml_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+    
+    print_success(f"Created ntc.yml configuration at: {ntc_yml_path}")
+
+def create_project(project_type, project_name, root_dir):
+    """Create a single project using the appropriate template."""
+    from ntc.templates.drf_structure.main import init_drf_project
+    from ntc.templates.nextjs.main import init_nextjs_project
+    from ntc.templates.flutter.main import init_flutter_project
+    from ntc.templates.react_admin.main import init_react_admin_project
+    
+    project_postfix_map = {
+        "backend": "_backend",
+        "website": "_website",
+        "mobile": "_mobile",
+        "admin": "_admin"
+    }
+    
+    project_postfix = project_postfix_map[project_type]
+    full_project_name = f"{project_name}{project_postfix}"
+    project_path = os.path.join(root_dir, full_project_name)
+    
+    print_info(f"Creating {project_type} project: {full_project_name}")
+    
+    try:
+        if project_type == "backend":
+            init_drf_project(root_dir, full_project_name)
+        elif project_type == "website":
+            init_nextjs_project(root_dir, full_project_name)
+        elif project_type == "mobile":
+            init_flutter_project(root_dir, full_project_name)
+        elif project_type == "admin":
+            init_react_admin_project(root_dir, full_project_name)
+        
+        print_success(f"Successfully created {project_type} project: {full_project_name}")
+        return True
+    except Exception as e:
+        print_error(f"Failed to create {project_type} project: {e}")
+        return False
+
+def compose_project(project_name, root_dir=None):
+    """Compose a full-stack project with multiple components."""
+    if root_dir is None:
+        root_dir = os.getcwd()
+    
+    # Check if directory is empty
+    if not is_directory_empty(root_dir):
+        print_error("Directory is not empty. The composer requires an empty directory.")
+        print_info("Please run this command in an empty directory.")
+        sys.exit(1)
+    
+    print_info(f"🎵 Composing project: {project_name}")
+    print_info(f"Root directory: {root_dir}")
+    print()
+    
+    # Get project choices
+    projects = get_project_choices()
+    
+    if not projects:
+        print_error("No projects selected. Exiting.")
+        sys.exit(1)
+    
+    # Clear screen after project selection
+    os.system('cls' if os.name == 'nt' else 'clear')
+    print_info(f"Selected projects: {', '.join(projects)}")
+    print()
+    
+    # Create each project
+    successful_projects = []
+    failed_projects = []
+    
+    for project_type in projects:
+        if create_project(project_type, project_name, root_dir):
+            successful_projects.append(project_type)
+        else:
+            failed_projects.append(project_type)
+    
+    # Create ntc.yml configuration
+    if successful_projects:
+        create_ntc_yml(project_name, successful_projects, root_dir)
+    
+    # Clear screen before showing summary
+    os.system('cls' if os.name == 'nt' else 'clear')
+    
+    # Summary
+    print("─" * 50)
+    print(f"{Fore.GREEN}COMPOSER SUMMARY{Style.RESET_ALL}")
+    print("─" * 50)
+    
+    if successful_projects:
+        print_success(f"Successfully created: {', '.join(successful_projects)}")
+    if failed_projects:
+        print_error(f"Failed to create: {', '.join(failed_projects)}")
+    
+    print()
+    print_info("Project structure:")
+    for project_type in successful_projects:
+        project_postfix_map = {
+            "backend": "_backend",
+            "website": "_website",
+            "mobile": "_mobile",
+            "admin": "_admin"
+        }
+        postfix = project_postfix_map[project_type]
+        print(f"  📁 {project_name}{postfix}")
+    
+    print()
+    print_info(f"Configuration file: ntc.yml")
+    print_info("Use this file to configure deployment and project settings.")
+    print()
+    print_success("🎉 Project composition complete!")
+
+def compose_project_in_current_dir(project_name):
+    """Compose a full-stack project in the current directory."""
+    compose_project(project_name, os.getcwd())
+
+def start_services(root_dir=None):
+    """Start all services defined in ntc.yml configuration in terminal splits."""
+    if root_dir is None:
+        root_dir = os.getcwd()
+    
+    ntc_yml_path = os.path.join(root_dir, "ntc.yml")
+    
+    if not os.path.exists(ntc_yml_path):
+        print_error("ntc.yml not found. Are you in a project root directory?")
+        return
+    
+    with open(ntc_yml_path, "r") as f:
+        config = yaml.safe_load(f)
+    
+    components = config.get("components", {})
+    project_name = config.get("project", {}).get("name", "project")
+    
+    if not components:
+        print_warning("No components found in ntc.yml configuration.")
+        return
+    
+    print_info(f"Starting services for {project_name}...")
+    print()
+    
+    # Check if Windows Terminal or tmux is available
+    wt_available = shutil.which("wt") is not None
+    tmux_available = shutil.which("tmux") is not None
+    
+    # Prepare commands with environment activation and dependency installation
+    prepared_commands = []
+    
+    for component_name, component_config in components.items():
+        component_type = component_config.get("type")
+        component_path = os.path.join(root_dir, component_config.get("path"))
+        
+        if not os.path.exists(component_path):
+            print_warning(f"Component path not found: {component_path}")
+            continue
+        
+        print_info(f"Preparing {component_name} ({component_type})...")
+        
+        # Build command with environment activation
+        env_config = component_config.get("environment", {})
+        env_type = env_config.get("type", "none")
+        env_path = env_config.get("path")
+        
+        # Check and install dependencies
+        dep_config = component_config.get("dependencies", {})
+        dep_file = dep_config.get("file")
+        dep_manager = dep_config.get("manager")
+        
+        install_command = ""
+        if dep_file and dep_manager:
+            dep_file_path = os.path.join(component_path, dep_file)
+            if os.path.exists(dep_file_path):
+                print_info(f"Checking dependencies for {component_name}...")
+                # Add dependency installation check to command
+                if dep_manager == "pip":
+                    install_command = f"pip install -r {dep_file}"
+                elif dep_manager == "npm":
+                    install_command = f"npm install --legacy-peer-deps"
+                elif dep_manager == "flutter":
+                    install_command = f"flutter pub get"
+            else:
+                print_warning(f"Dependency file not found: {dep_file_path}")
+        
+        # Build start command with environment activation and dependency installation
+        if env_type == "venv" and env_path:
+            env_full_path = os.path.join(root_dir, env_path)
+            activate_cmd = f"{env_full_path}\\Scripts\\activate" if os.name == 'nt' else f"source {env_full_path}/bin/activate"
+            if install_command:
+                start_command = f"cd {component_path} && {activate_cmd} && {install_command} && {component_config.get('start_command', '')}"
+            else:
+                start_command = f"cd {component_path} && {activate_cmd} && {component_config.get('start_command', '')}"
+        elif env_type == "conda" and env_path:
+            activate_cmd = f"conda activate {env_path}"
+            if install_command:
+                start_command = f"cd {component_path} && {activate_cmd} && {install_command} && {component_config.get('start_command', '')}"
+            else:
+                start_command = f"cd {component_path} && {activate_cmd} && {component_config.get('start_command', '')}"
+        elif env_type == "node":
+            if install_command:
+                start_command = f"cd {component_path} && {install_command} && {component_config.get('start_command', '')}"
+            else:
+                start_command = f"cd {component_path} && {component_config.get('start_command', '')}"
+        elif env_type == "flutter":
+            if install_command:
+                start_command = f"cd {component_path} && {install_command} && {component_config.get('start_command', '')}"
+            else:
+                start_command = f"cd {component_path} && {component_config.get('start_command', '')}"
+        else:
+            if install_command:
+                start_command = f"cd {component_path} && {install_command} && {component_config.get('start_command', '')}"
+            else:
+                start_command = f"cd {component_path} && {component_config.get('start_command', '')}"
+        
+        prepared_commands.append(start_command)
+    
+    # Launch services
+    if tmux_available:
+        # Use tmux for better pane management
+        print_info("Using tmux for terminal splitting...")
+        
+        # Start a new tmux session
+        session_name = f"{project_name}_services"
+        os.system(f"tmux kill-session -t {session_name} 2>/dev/null")
+        os.system(f"tmux new-session -d -s {session_name} -c {root_dir}")
+        
+        for i, start_command in enumerate(prepared_commands):
+            if i == 0:
+                # First pane already exists
+                os.system(f"tmux send-keys -t {session_name}:0 '{start_command}' C-m")
+            elif i == 1:
+                # Split vertically for second pane
+                os.system(f"tmux split-window -t {session_name}:0 -v -c {root_dir}")
+                os.system(f"tmux send-keys -t {session_name}:0.1 '{start_command}' C-m")
+            elif i == 2:
+                # Split the left pane horizontally for third pane
+                os.system(f"tmux split-window -t {session_name}:0.0 -h -c {root_dir}")
+                os.system(f"tmux send-keys -t {session_name}:0.2 '{start_command}' C-m")
+            elif i == 3:
+                # Split the right pane horizontally for fourth pane
+                os.system(f"tmux split-window -t {session_name}:0.1 -h -c {root_dir}")
+                os.system(f"tmux send-keys -t {session_name}:0.3 '{start_command}' C-m")
+        
+        # Attach to the tmux session
+        os.system(f"tmux attach-session -t {session_name}")
+        print_success(f"Launched all services in tmux with 2x2 grid layout")
+    elif wt_available:
+        # Use Windows Terminal with pane splits
+        wt_command = f"wt cmd /k \"{prepared_commands[0]}\""
+        
+        for i, command in enumerate(prepared_commands[1:], 1):
+            if i == 1:
+                wt_command += f" ; split-pane -V cmd /k \"{command}\""
+            else:
+                wt_command += f" ; split-pane -H cmd /k \"{command}\""
+        
+        os.system(wt_command)
+        print_success(f"Launched all services in Windows Terminal with split panes")
+    else:
+        # Fallback to opening new terminal windows
+        print_warning("Windows Terminal not found. Opening new terminal windows instead.")
+        print_info("Install Windows Terminal for pane splitting support.")
+        
+        for start_command in prepared_commands:
+            os.system(f"start cmd /k \"{start_command}\"")
+    
+    print()
+    print_success(f"All services started for {project_name}")

ntc/templates/__init__.py

@@ -0,0 +1,2 @@
+from .drf_structure import init_drf_project
+from .react_structure import init_react_project

ntc/templates/auth_app/admin.py

@@ -0,0 +1,24 @@
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from .models import User
+
+
+@admin.register(User)
+class UserAdmin(BaseUserAdmin):
+    """Custom User admin."""
+    list_display = ('email', 'username', 'first_name', 'last_name', 'is_verified', 'is_staff', 'date_joined')
+    list_filter = ('is_staff', 'is_superuser', 'is_active', 'is_verified', 'date_joined')
+    search_fields = ('email', 'username', 'first_name', 'last_name')
+    ordering = ('-date_joined',)
+    
+    fieldsets = BaseUserAdmin.fieldsets + (
+        ('Additional Info', {
+            'fields': ('phone_number', 'date_of_birth', 'profile_picture', 'is_verified')
+        }),
+    )
+    
+    add_fieldsets = BaseUserAdmin.add_fieldsets + (
+        ('Additional Info', {
+            'fields': ('email', 'first_name', 'last_name')
+        }),
+    )

ntc/templates/auth_app/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AuthenticationConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'authentication'

ntc/templates/auth_app/models.py

@@ -0,0 +1,30 @@
+from django.contrib.auth.models import AbstractUser
+from django.db import models
+
+
+class User(AbstractUser):
+    """Custom User model extending AbstractUser."""
+    email = models.EmailField(unique=True)
+    first_name = models.CharField(max_length=30, blank=True)
+    last_name = models.CharField(max_length=30, blank=True)
+    phone_number = models.CharField(max_length=15, blank=True)
+    date_of_birth = models.DateField(null=True, blank=True)
+    profile_picture = models.ImageField(upload_to='profile_pics/', null=True, blank=True)
+    is_verified = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['username']
+
+    class Meta:
+        db_table = 'auth_user'
+        verbose_name = 'User'
+        verbose_name_plural = 'Users'
+
+    def __str__(self):
+        return self.email
+
+    @property
+    def full_name(self):
+        return f"{self.first_name} {self.last_name}".strip()

ntc/templates/auth_app/serializers.py

@@ -0,0 +1,101 @@
+from rest_framework import serializers
+from django.contrib.auth import authenticate
+from django.contrib.auth.password_validation import validate_password
+from .models import User
+
+
+class UserRegistrationSerializer(serializers.ModelSerializer):
+    """Serializer for user registration."""
+    password = serializers.CharField(write_only=True, validators=[validate_password])
+    password_confirm = serializers.CharField(write_only=True)
+
+    class Meta:
+        model = User
+        fields = ('email', 'username', 'password', 'password_confirm', 'first_name', 'last_name')
+
+    def validate(self, attrs):
+        if attrs['password'] != attrs['password_confirm']:
+            raise serializers.ValidationError("Passwords don't match.")
+        return attrs
+
+    def create(self, validated_data):
+        validated_data.pop('password_confirm')
+        user = User.objects.create_user(**validated_data)
+        return user
+
+
+class UserLoginSerializer(serializers.Serializer):
+    """Serializer for user login."""
+    email = serializers.EmailField()
+    password = serializers.CharField(write_only=True)
+
+    def validate(self, attrs):
+        email = attrs.get('email')
+        password = attrs.get('password')
+
+        if email and password:
+            user = authenticate(username=email, password=password)
+            if not user:
+                raise serializers.ValidationError('Invalid credentials.')
+            if not user.is_active:
+                raise serializers.ValidationError('User account is disabled.')
+            attrs['user'] = user
+        else:
+            raise serializers.ValidationError('Must include email and password.')
+        
+        return attrs
+
+
+class UserProfileSerializer(serializers.ModelSerializer):
+    """Serializer for user profile."""
+    full_name = serializers.ReadOnlyField()
+
+    class Meta:
+        model = User
+        fields = ('id', 'email', 'username', 'first_name', 'last_name', 'full_name', 
+                 'phone_number', 'date_of_birth', 'profile_picture', 'is_verified', 
+                 'date_joined', 'created_at', 'updated_at')
+        read_only_fields = ('id', 'email', 'date_joined', 'created_at', 'updated_at', 'is_verified')
+
+
+class UpdateProfileSerializer(serializers.ModelSerializer):
+    """Serializer for updating user profile."""
+    
+    class Meta:
+        model = User
+        fields = ('first_name', 'last_name', 'phone_number', 'date_of_birth', 'profile_picture')
+
+
+class ChangePasswordSerializer(serializers.Serializer):
+    """Serializer for changing password."""
+    old_password = serializers.CharField(write_only=True)
+    new_password = serializers.CharField(write_only=True, validators=[validate_password])
+    new_password_confirm = serializers.CharField(write_only=True)
+
+    def validate(self, attrs):
+        if attrs['new_password'] != attrs['new_password_confirm']:
+            raise serializers.ValidationError("New passwords don't match.")
+        return attrs
+
+    def validate_old_password(self, value):
+        user = self.context['request'].user
+        if not user.check_password(value):
+            raise serializers.ValidationError("Old password is incorrect.")
+        return value
+
+
+class ResetPasswordSerializer(serializers.Serializer):
+    """Serializer for password reset request."""
+    email = serializers.EmailField()
+
+
+class ResetPasswordConfirmSerializer(serializers.Serializer):
+    """Serializer for password reset confirmation."""
+    token = serializers.CharField()
+    new_password = serializers.CharField(write_only=True, validators=[validate_password])
+    new_password_confirm = serializers.CharField(write_only=True)
+
+    def validate(self, attrs):
+        if attrs['new_password'] != attrs['new_password_confirm']:
+            raise serializers.ValidationError("Passwords don't match.")
+        return attrs

ntc/templates/auth_app/urls.py

@@ -0,0 +1,19 @@
+from django.urls import path
+from . import views
+
+
+app_name = 'authentication'
+
+
+urlpatterns = [
+    # Add your URL patterns here
+    path('login/', views.login, name='login'),
+    path('register/', views.register, name='register'),
+    path('logout/', views.logout, name='logout'),
+    path('refresh/', views.refresh, name='refresh'),
+    path('me/', views.me, name='me'),
+    path('update-profile/', views.update_profile, name='update_profile'),
+    path('change-password/', views.change_password, name='change_password'),
+    path('reset-password/', views.reset_password, name='reset_password'),
+    path('reset-password-confirm/', views.reset_password_confirm, name='reset_password_confirm'),
+]