starco-dj-utils 1.0.2__py3-none-any.whl

dj_utils/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

dj_utils/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class DjUtilsConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'dj_utils'
+    def ready(self):
+        from . import handlers
+        from . import tasks_config

dj_utils/handlers.py

@@ -0,0 +1,83 @@
+from asgiref.sync import async_to_sync, sync_to_async
+import os
+from django.dispatch import receiver
+from .signals import notifire, send_sms, send_mail
+import re
+from telegram import Bot
+import logging
+from dotenv import load_dotenv
+load_dotenv()
+
+def get_bot():
+    TOKEN = os.getenv('UTILS_BOT_TOKEN')
+    if not TOKEN:
+        logging.error("Telegram bot token not found in environment variables.")
+        raise ValueError("Telegram bot token is required.\nUTILS_BOT_TOKEN must be set in environment variables.")
+    return Bot(token=TOKEN)
+
+
+def clean_html_for_telegram(text: str) -> str:
+    """
+    حذف تگ‌های HTML نامجاز برای استفاده در Telegram با parse_mode='HTML'
+    و جایگزینی برخی از آن‌ها مثل <p> با newline
+    """
+    # تگ‌های مجاز HTML برای تلگرام
+    allowed_tags = ['b', 'strong', 'i', 'em', 'u', 's', 'strike', 'del',
+                    'span', 'a', 'code', 'pre']
+
+    # جایگزینی <p> و </p> با newline
+    text = re.sub(r'</?p\s*>', '\n', text)
+
+    # حذف تگ‌های غیرمجاز
+    def remove_invalid_tags(match):
+        tag = match.group(1)
+        if tag.lower() not in allowed_tags:
+            return ''
+        return match.group(0)
+
+    # حذف تگ‌های باز
+    text = re.sub(r'<(/?\s*?)(\w+)([^>]*)>',
+                  lambda m: remove_invalid_tags((m.group(2),)) if m.group(2).lower() not in allowed_tags else m.group(
+                      0), text)
+
+    return text.strip()
+
+
+@receiver(notifire)
+def handle_notifire(sender, text, chat_id=None, label=True, **kwargs):
+    chat_id = chat_id if chat_id else os.getenv('UTILS_TELEGRAM_CHAT_ID')
+    if not chat_id:
+        logging.error("Telegram chat ID not found in environment variables.")
+        raise ValueError("Telegram chat ID is required.\nUTILS_TELEGRAM_CHAT_ID must be set in environment variables.")
+    file = kwargs.get('file')
+    parse_mode = kwargs.get('parse_mode', 'HTML')
+    disable_notification = kwargs.get('disable_notification', False)
+    protect_content = kwargs.get('protect_content')
+    reply_markup = kwargs.get('reply_markup')
+    reply_to_message_id = kwargs.get('reply_to_message_id')
+    disable_web_page_preview = kwargs.get('disable_web_page_preview')
+    data = {
+        'chat_id': chat_id,
+        'parse_mode': parse_mode,
+        'disable_notification': disable_notification,
+        'protect_content': protect_content,
+        'reply_markup': reply_markup,
+        'reply_to_message_id': reply_to_message_id,
+
+    }
+    if label:
+        text = f"#{os.getenv('PROJECT_NAME_EV')}:{sender}\n{text}"
+    if kwargs.get('parse_mode') == 'HTML':
+        text = clean_html_for_telegram(text)
+    try:
+        bot = get_bot()
+        if file:
+            res = async_to_sync(bot.send_document)(document=file, caption=text, **data)
+            print(res)
+
+        else:
+            data['disable_web_page_preview'] = disable_web_page_preview
+            res = async_to_sync(bot.send_message)(text=text, **data)
+            print(res)
+    except Exception as e:
+        print(e)

dj_utils/management/commands/backup.py

@@ -0,0 +1,156 @@
+import os
+import subprocess
+import datetime
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+
+
+class Command(BaseCommand):
+    help = 'Backup database to a file'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--path', type=str, help='Path to save the backup file (optional)')
+        parser.add_argument('--format', type=str, choices=['sql', 'dump', 'custom'], default='sql',
+                            help='Backup format (sql, dump, or custom for PostgreSQL)')
+
+    def handle(self, *args, **options):
+        db_settings = settings.DATABASES['default']
+        db_type = db_settings['ENGINE'].split('.')[-1]
+
+        # Generate default backup path if not provided
+        backup_path = options.get('path')
+        if not backup_path:
+            timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+            backup_dir = os.path.join(settings.BASE_DIR, 'backups')
+            os.makedirs(backup_dir, exist_ok=True)
+
+            if db_type == 'postgresql':
+                ext = '.sql' if options['format'] == 'sql' else '.dump'
+                backup_path = os.path.join(backup_dir, f'backup_pg_{timestamp}{ext}')
+            elif db_type == 'sqlite3':
+                backup_path = os.path.join(backup_dir, f'backup_sqlite_{timestamp}.sqlite3')
+            elif db_type == 'mysql':
+                backup_path = os.path.join(backup_dir, f'backup_mysql_{timestamp}.sql')
+            else:
+                raise CommandError(f'Unsupported database type: {db_type}')
+
+        try:
+            if db_type == 'postgresql':
+                self._backup_postgresql(db_settings, backup_path, options['format'])
+            elif db_type == 'sqlite3':
+                self._backup_sqlite3(db_settings, backup_path)
+            elif db_type == 'mysql':
+                self._backup_mysql(db_settings, backup_path)
+            else:
+                raise CommandError(f'Unsupported database type: {db_type}')
+
+            self.stdout.write(self.style.SUCCESS(f'Database backup created successfully at: {backup_path}'))
+        except Exception as e:
+            raise CommandError(f'Failed to backup database: {str(e)}')
+
+    def _backup_postgresql(self, db_settings, backup_path, format_type):
+        """Backup PostgreSQL database to a file"""
+        db_name = db_settings['NAME']
+        db_user = db_settings['USER']
+        db_password = db_settings['PASSWORD']
+        db_host = db_settings['HOST']
+        db_port = db_settings['PORT']
+
+        env = os.environ.copy()
+        env['PGPASSWORD'] = db_password
+
+        if format_type == 'sql':
+            # Plain SQL dump
+            command = [
+                'pg_dump',
+                f'-h{db_host}',
+                f'-p{db_port}',
+                f'-U{db_user}',
+                '-d', db_name,
+                '-f', backup_path
+            ]
+        else:
+            # Custom format dump
+            format_flag = '-Fc' if format_type == 'dump' else '-Fc'  # Default to custom format
+            command = [
+                'pg_dump',
+                f'-h{db_host}',
+                f'-p{db_port}',
+                f'-U{db_user}',
+                format_flag,
+                '-d', db_name,
+                '-f', backup_path
+            ]
+
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=env
+        )
+        stdout, stderr = process.communicate()
+
+        if process.returncode != 0:
+            raise CommandError(f'pg_dump command failed: {stderr.decode()}')
+
+    def _backup_sqlite3(self, db_settings, backup_path):
+        """Backup SQLite database to a file"""
+        db_path = db_settings['NAME']
+
+        if not os.path.exists(db_path):
+            raise CommandError(f'SQLite database file does not exist: {db_path}')
+
+        # For SQLite, we can simply copy the database file
+        import shutil
+        shutil.copy2(db_path, backup_path)
+
+        # Alternatively, we can use the .dump command for a SQL dump
+        if backup_path.endswith('.sql'):
+            command = [
+                'sqlite3',
+                db_path,
+                '.dump'
+            ]
+
+            with open(backup_path, 'w') as f:
+                process = subprocess.Popen(
+                    command,
+                    stdout=f,
+                    stderr=subprocess.PIPE
+                )
+                _, stderr = process.communicate()
+
+                if process.returncode != 0:
+                    raise CommandError(f'sqlite3 dump command failed: {stderr.decode()}')
+
+    def _backup_mysql(self, db_settings, backup_path):
+        """Backup MySQL database to a file"""
+        db_name = db_settings['NAME']
+        db_user = db_settings['USER']
+        db_password = db_settings['PASSWORD']
+        db_host = db_settings['HOST']
+        db_port = db_settings['PORT']
+
+        command = [
+            'mysqldump',
+            f'-h{db_host}',
+            f'-P{db_port}',
+            f'-u{db_user}',
+            f'-p{db_password}',
+            '--single-transaction',
+            '--routines',
+            '--triggers',
+            '--events',
+            db_name
+        ]
+
+        with open(backup_path, 'w') as f:
+            process = subprocess.Popen(
+                command,
+                stdout=f,
+                stderr=subprocess.PIPE
+            )
+            _, stderr = process.communicate()
+
+            if process.returncode != 0:
+                raise CommandError(f'mysqldump command failed: {stderr.decode()}')

dj_utils/management/commands/restore.py

@@ -0,0 +1,167 @@
+import os
+import subprocess
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+
+
+class Command(BaseCommand):
+    help = 'Restore database from a backup file'
+
+    def add_arguments(self, parser):
+        parser.add_argument('--path', type=str, required=True, help='Path to the backup file')
+
+    def handle(self, *args, **options):
+        backup_path = options['path']
+
+        if not os.path.exists(backup_path):
+            raise CommandError(f'Backup file does not exist: {backup_path}')
+
+        db_settings = settings.DATABASES['default']
+        db_type = db_settings['ENGINE'].split('.')[-1]
+
+        self.stdout.write(self.style.WARNING(f'Restoring database from {backup_path}'))
+        self.stdout.write(self.style.WARNING('This will overwrite the current database. Are you sure? (y/n)'))
+
+        # confirm = input()
+        # if confirm.lower() != 'y':
+        #     self.stdout.write(self.style.ERROR('Restore cancelled.'))
+        #     return
+
+        try:
+            if db_type == 'postgresql':
+                self._restore_postgresql(db_settings, backup_path)
+            elif db_type == 'sqlite3':
+                self._restore_sqlite3(db_settings, backup_path)
+            elif db_type == 'mysql':
+                self._restore_mysql(db_settings, backup_path)
+            else:
+                raise CommandError(f'Unsupported database type: {db_type}')
+
+            self.stdout.write(self.style.SUCCESS('Database restored successfully!'))
+        except Exception as e:
+            raise CommandError(f'Failed to restore database: {str(e)}')
+
+    def _restore_postgresql(self, db_settings, backup_path):
+        """Restore PostgreSQL database from backup file"""
+        db_name = db_settings['NAME']
+        db_user = db_settings['USER']
+        db_password = db_settings['PASSWORD']
+        db_host = db_settings['HOST']
+        db_port = db_settings['PORT']
+
+        # Check file extension to determine restore method
+        if backup_path.endswith('.sql'):
+            # SQL dump file
+            env = os.environ.copy()
+            env['PGPASSWORD'] = db_password
+
+            command = [
+                'psql',
+                f'-h{db_host}',
+                f'-p{db_port}',
+                f'-U{db_user}',
+                f'-d{db_name}',
+                '-f', backup_path
+            ]
+
+            process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env
+            )
+            stdout, stderr = process.communicate()
+
+            if process.returncode != 0:
+                raise CommandError(f'psql command failed: {stderr.decode()}')
+
+        elif backup_path.endswith('.dump'):
+            # pg_dump custom format
+            env = os.environ.copy()
+            env['PGPASSWORD'] = db_password
+
+            command = [
+                'pg_restore',
+                '--clean',
+                '--if-exists',
+                f'-h{db_host}',
+                f'-p{db_port}',
+                f'-U{db_user}',
+                f'-d{db_name}',
+                backup_path
+            ]
+
+            process = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env
+            )
+            stdout, stderr = process.communicate()
+
+            if process.returncode != 0:
+                raise CommandError(f'pg_restore command failed: {stderr.decode()}')
+        else:
+            raise CommandError(f'Unsupported file format for PostgreSQL: {backup_path}')
+
+    def _restore_sqlite3(self, db_settings, backup_path):
+        """Restore SQLite database from backup file"""
+        db_path = db_settings['NAME']
+
+        if os.path.exists(db_path):
+            # Create a backup of the current database
+            backup_name = f"{db_path}.bak"
+            os.rename(db_path, backup_name)
+            self.stdout.write(self.style.WARNING(f'Current database backed up to {backup_name}'))
+
+        # For SQLite, we can simply copy the backup file to the database location
+        if backup_path.endswith('.sql'):
+            # SQL dump file - need to execute the SQL commands
+            try:
+                import sqlite3
+                conn = sqlite3.connect(db_path)
+                cursor = conn.cursor()
+
+                with open(backup_path, 'r') as f:
+                    sql_script = f.read()
+                    cursor.executescript(sql_script)
+
+                conn.commit()
+                conn.close()
+            except Exception as e:
+                raise CommandError(f'Failed to restore SQLite database: {str(e)}')
+        else:
+            # Binary backup - just copy the file
+            import shutil
+            shutil.copy2(backup_path, db_path)
+
+    def _restore_mysql(self, db_settings, backup_path):
+        """Restore MySQL database from backup file"""
+        db_name = db_settings['NAME']
+        db_user = db_settings['USER']
+        db_password = db_settings['PASSWORD']
+        db_host = db_settings['HOST']
+        db_port = db_settings['PORT']
+
+        command = [
+            'mysql',
+            f'-h{db_host}',
+            f'-P{db_port}',
+            f'-u{db_user}',
+            f'-p{db_password}',
+            db_name,
+            '<', backup_path
+        ]
+
+        # For MySQL, we need to use shell=True to handle the redirect operator
+        command_str = ' '.join(command)
+        process = subprocess.Popen(
+            command_str,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True
+        )
+        stdout, stderr = process.communicate()
+
+        if process.returncode != 0:
+            raise CommandError(f'mysql command failed: {stderr.decode()}')

dj_utils/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

dj_utils/signals.py

@@ -0,0 +1,7 @@
+from django.dispatch import Signal
+
+
+
+notifire = Signal()
+send_sms = Signal()
+send_mail = Signal()

dj_utils/tasks.py

@@ -0,0 +1,29 @@
+from celery import shared_task
+import zipfile
+import os
+from datetime import datetime
+from django.core.management import call_command
+from .handlers import notifire
+@shared_task
+def backup_database():
+    path= '/app/backup.sql'
+    call_command('backup',path= path)
+    # Create ZIP archive
+    zip_file = f"{path}.zip"
+    with zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        zipf.write(path, os.path.basename(path))
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    try:
+        with open(zip_file, 'rb') as backup:
+            notifire.send(
+                'backup_database',
+                chat_id=os.getenv('BACKUP_TELEGRAM_CHAT_ID_EV'),  # Send to admin group
+                file=backup,
+                text=f"📂 Database Backup \n📅 {timestamp}\n💾 {os.path.getsize(zip_file) / (1024 * 1024):.2f} MB"
+            )
+    except Exception as e:
+        print(e)
+        notifire.send(sender='backup_database', text=f"❌ Error sending backup: {str(e)}")
+    os.remove(zip_file)
+    os.remove(path)
+

dj_utils/tasks_config.py

@@ -0,0 +1,11 @@
+try:
+    from core.celery_config import app
+    import os
+    app.conf.beat_schedule = {
+        'run-backup-task': {
+            'task': 'utils.tasks.backup_database',
+            'schedule': int(os.getenv('BACKUP_EVERY_SECOND_EV')),  # seconds
+        },
+
+    }
+except:pass

dj_utils/templates/dj_utils/database_management.html

@@ -0,0 +1,261 @@
+{% load static %}
+<!DOCTYPE html>
+<html lang="fa" dir="rtl">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ title }}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @keyframes slideIn {
+            from {
+                opacity: 0;
+                transform: translateY(-20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .animate-slide-in {
+            animation: slideIn 0.3s ease;
+        }
+
+        .spinner {
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            width: 40px;
+            height: 40px;
+            animation: spin 1s linear infinite;
+            margin: 0 auto;
+        }
+    </style>
+</head>
+<body class="bg-gradient-to-br from-purple-600 to-purple-800 min-h-screen p-4 md:p-8">
+    <div class="max-w-4xl mx-auto">
+        <!-- Header -->
+        <div class="bg-white rounded-t-2xl shadow-2xl overflow-hidden">
+            <div class="bg-gradient-to-r from-purple-600 to-purple-800 text-white p-8">
+                <h1 class="text-3xl md:text-4xl font-bold text-center mb-4">
+                    🗄️ {{ title }}
+                </h1>
+                <div class="bg-white/10 backdrop-blur-sm rounded-xl p-4 space-y-2">
+                    <p class="text-sm md:text-base">
+                        <span class="font-semibold">موتور دیتابیس:</span>
+                        <span class="font-mono">{{ db_engine }}</span>
+                    </p>
+                    <p class="text-sm md:text-base">
+                        <span class="font-semibold">نام دیتابیس:</span>
+                        <span class="font-mono">{{ db_name }}</span>
+                    </p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Content -->
+        <div class="bg-white rounded-b-2xl shadow-2xl p-6 md:p-10">
+            <!-- Messages -->
+            {% if messages %}
+            <div class="mb-6 space-y-3">
+                {% for message in messages %}
+                <div class="animate-slide-in rounded-lg p-4 {% if message.tags == 'success' %}bg-green-50 text-green-800 border border-green-200{% elif message.tags == 'error' %}bg-red-50 text-red-800 border border-red-200{% else %}bg-blue-50 text-blue-800 border border-blue-200{% endif %}">
+                    <p class="text-sm md:text-base">{{ message }}</p>
+                </div>
+                {% endfor %}
+            </div>
+            {% endif %}
+
+            <!-- Backup Section -->
+            <div class="bg-gradient-to-br from-green-50 to-emerald-50 rounded-xl p-6 md:p-8 mb-6 border border-green-100">
+                <h2 class="text-2xl font-bold text-green-700 mb-4 flex items-center gap-2">
+                    <span>📦</span>
+                    <span>ایجاد بک‌آپ</span>
+                </h2>
+                <p class="text-gray-700 mb-6 leading-relaxed">
+                    با استفاده از این بخش می‌توانید از دیتابیس خود بک‌آپ تهیه کنید. فایل بک‌آپ به صورت فشرده (ZIP) دانلود خواهد شد.
+                </p>
+
+                <form method="post" action="{% url 'database_backup' %}" id="backupForm">
+                    {% csrf_token %}
+                    <button type="submit" class="bg-gradient-to-r from-green-500 to-emerald-600 hover:from-green-600 hover:to-emerald-700 text-white font-bold py-3 px-8 rounded-lg shadow-lg hover:shadow-xl transform hover:-translate-y-1 transition-all duration-200 flex items-center gap-2">
+                        <span>💾</span>
+                        <span>دانلود بک‌آپ</span>
+                    </button>
+                </form>
+
+                <div class="hidden mt-6 text-center" id="backupLoading">
+                    <div class="spinner mb-3"></div>
+                    <p class="text-gray-600 font-medium">در حال ایجاد بک‌آپ...</p>
+                </div>
+            </div>
+
+            <!-- Restore Section -->
+            <div class="bg-gradient-to-br from-purple-50 to-indigo-50 rounded-xl p-6 md:p-8 border border-purple-100">
+                <h2 class="text-2xl font-bold text-purple-700 mb-4 flex items-center gap-2">
+                    <span>♻️</span>
+                    <span>بازیابی دیتابیس</span>
+                </h2>
+                <p class="text-gray-700 mb-4 leading-relaxed">
+                    برای بازیابی دیتابیس، فایل بک‌آپ (.sql، .dump یا .zip) خود را انتخاب کنید.
+                </p>
+
+                <!-- Warning -->
+                <div class="bg-yellow-50 border-r-4 border-yellow-400 p-4 mb-6 rounded-lg">
+                    <div class="flex items-start gap-3">
+                        <span class="text-2xl">⚠️</span>
+                        <div>
+                            <p class="font-bold text-yellow-800 mb-2">هشدار مهم:</p>
+                            <p class="text-yellow-700 text-sm leading-relaxed">
+                                بازیابی دیتابیس تمام اطلاعات فعلی را جایگزین می‌کند. قبل از ادامه، مطمئن شوید که از دیتابیس فعلی بک‌آپ تهیه کرده‌اید.
+                            </p>
+                        </div>
+                    </div>
+                </div>
+
+                <form method="post" action="{% url 'database_restore' %}" enctype="multipart/form-data" id="restoreForm">
+                    {% csrf_token %}
+
+                    <div class="mb-6">
+                        <label class="block text-gray-700 font-semibold mb-3">
+                            انتخاب فایل بک‌آپ:
+                        </label>
+
+                        <div class="flex flex-col md:flex-row items-start md:items-center gap-4">
+                            <label class="cursor-pointer bg-white hover:bg-gray-50 text-purple-600 font-semibold py-3 px-6 rounded-lg border-2 border-purple-300 hover:border-purple-400 transition-all duration-200 flex items-center gap-2">
+                                <span>📁</span>
+                                <span>انتخاب فایل</span>
+                                <input type="file" name="backup_file" id="backupFile" accept=".sql,.dump,.zip" class="hidden" required>
+                            </label>
+
+                            <div class="flex-1 w-full md:w-auto">
+                                <div id="fileName" class="bg-white border-2 border-dashed border-purple-300 rounded-lg p-3 text-gray-500 text-sm min-w-[200px]">
+                                    هیچ فایلی انتخاب نشده
+                                </div>
+                            </div>
+                        </div>
+
+                        <p class="text-xs text-gray-500 mt-2">
+                            فرمت‌های مجاز: .sql، .dump، .zip
+                        </p>
+                    </div>
+
+                    <div class="flex flex-col sm:flex-row gap-3">
+                        <button type="submit" id="restoreBtn" class="bg-gradient-to-r from-purple-600 to-indigo-600 hover:from-purple-700 hover:to-indigo-700 text-white font-bold py-3 px-8 rounded-lg shadow-lg hover:shadow-xl transform hover:-translate-y-1 transition-all duration-200 disabled:opacity-50 disabled:cursor-not-allowed disabled:transform-none flex items-center justify-center gap-2" disabled>
+                            <span>♻️</span>
+                            <span>بازیابی دیتابیس</span>
+                        </button>
+
+                        <button type="button" onclick="window.location.href='{% url 'database_management' %}'" class="bg-gray-200 hover:bg-gray-300 text-gray-700 font-semibold py-3 px-8 rounded-lg transition-all duration-200 flex items-center justify-center gap-2">
+                            <span>↩️</span>
+                            <span>بازگشت</span>
+                        </button>
+                    </div>
+                </form>
+
+                <div class="hidden mt-6 text-center" id="restoreLoading">
+                    <div class="spinner mb-3"></div>
+                    <p class="text-gray-600 font-medium">در حال بازیابی دیتابیس...</p>
+                    <p class="text-sm text-gray-500 mt-2">این عملیات ممکن است چند دقیقه طول بکشد...</p>
+                </div>
+            </div>
+
+            <!-- Info Section -->
+            <div class="mt-6 bg-blue-50 border border-blue-200 rounded-xl p-6">
+                <h3 class="text-lg font-bold text-blue-800 mb-3 flex items-center gap-2">
+                    <span>ℹ️</span>
+                    <span>راهنما</span>
+                </h3>
+                <ul class="space-y-2 text-sm text-blue-700">
+                    <li class="flex items-start gap-2">
+                        <span class="mt-1">•</span>
+                        <span>برای ایجاد بک‌آپ، روی دکمه "دانلود بک‌آپ" کلیک کنید</span>
+                    </li>
+                    <li class="flex items-start gap-2">
+                        <span class="mt-1">•</span>
+                        <span>فایل بک‌آپ به صورت خودکار فشرده و دانلود می‌شود</span>
+                    </li>
+                    <li class="flex items-start gap-2">
+                        <span class="mt-1">•</span>
+                        <span>برای بازیابی، فایل بک‌آپ را انتخاب کرده و روی "بازیابی دیتابیس" کلیک کنید</span>
+                    </li>
+                    <li class="flex items-start gap-2">
+                        <span class="mt-1">•</span>
+                        <span>حتماً قبل از بازیابی، از دیتابیس فعلی بک‌آپ تهیه کنید</span>
+                    </li>
+                </ul>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        // File input handler
+        const fileInput = document.getElementById('backupFile');
+        const fileName = document.getElementById('fileName');
+        const restoreBtn = document.getElementById('restoreBtn');
+
+        fileInput.addEventListener('change', function(e) {
+            if (this.files && this.files[0]) {
+                const file = this.files[0];
+                const fileSize = (file.size / (1024 * 1024)).toFixed(2);
+                fileName.innerHTML = `
+                    <div class="flex items-center justify-between">
+                        <span class="text-gray-700 font-medium truncate">${file.name}</span>
+                        <span class="text-gray-500 text-xs mr-2">${fileSize} MB</span>
+                    </div>
+                `;
+                fileName.classList.remove('border-dashed', 'text-gray-500');
+                fileName.classList.add('border-solid', 'border-green-400', 'bg-green-50');
+                restoreBtn.disabled = false;
+            } else {
+                fileName.textContent = 'هیچ فایلی انتخاب نشده';
+                fileName.classList.add('border-dashed', 'text-gray-500');
+                fileName.classList.remove('border-solid', 'border-green-400', 'bg-green-50');
+                restoreBtn.disabled = true;
+            }
+        });
+
+        // Backup form handler
+        const backupForm = document.getElementById('backupForm');
+        const backupLoading = document.getElementById('backupLoading');
+
+        backupForm.addEventListener('submit', function() {
+            backupLoading.classList.remove('hidden');
+            this.querySelector('button').disabled = true;
+        });
+
+        // Restore form handler
+        const restoreForm = document.getElementById('restoreForm');
+        const restoreLoading = document.getElementById('restoreLoading');
+
+        restoreForm.addEventListener('submit', function(e) {
+            if (!confirm('⚠️ آیا مطمئن هستید که می‌خواهید دیتابیس را بازیابی کنید؟\n\nتمام اطلاعات فعلی جایگزین خواهند شد!')) {
+                e.preventDefault();
+                return false;
+            }
+
+            restoreLoading.classList.remove('hidden');
+            restoreBtn.disabled = true;
+            restoreBtn.innerHTML = '<span class="spinner-small"></span> در حال بازیابی...';
+        });
+
+        // Auto-hide messages after 5 seconds
+        setTimeout(function() {
+            const messages = document.querySelectorAll('.animate-slide-in');
+            messages.forEach(function(msg) {
+                msg.style.transition = 'opacity 0.5s ease';
+                msg.style.opacity = '0';
+                setTimeout(function() {
+                    msg.remove();
+                }, 500);
+            });
+        }, 5000);
+    </script>
+</body>
+</html>

dj_utils/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

dj_utils/urls.py

@@ -0,0 +1,11 @@
+
+from django.urls import path
+from . import views
+
+urlpatterns = [
+    # Database Management URLs
+    path('database/', views.database_management_view, name='database_management'),
+    path('database/backup/', views.database_backup_view, name='database_backup'),
+    path('database/restore/', views.database_restore_view, name='database_restore'),
+    path('database/backup/ajax/', views.database_backup_ajax, name='database_backup_ajax'),
+]

dj_utils/views.py

@@ -0,0 +1,174 @@
+
+from django.shortcuts import render, redirect
+from django.contrib.admin.views.decorators import staff_member_required
+from django.contrib.auth.decorators import user_passes_test
+from django.http import JsonResponse, HttpResponse, FileResponse
+from django.core.management import call_command
+from django.views.decorators.http import require_http_methods
+from django.contrib import messages
+from django.conf import settings
+import os
+import zipfile
+from datetime import datetime
+import tempfile
+from io import BytesIO
+
+def is_superuser(user):
+    """Check if user is superuser"""
+    return user.is_superuser
+
+@user_passes_test(is_superuser)
+@require_http_methods(["GET", "POST"])
+def database_backup_view(request):
+    """
+    View for creating database backup
+    Only accessible by superusers
+    """
+    if request.method == "POST":
+        try:
+            # Create temporary backup file
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            backup_filename = f'backup_{timestamp}.sql'
+            backup_path = os.path.join(tempfile.gettempdir(), backup_filename)
+            
+            # Call backup command
+            call_command('backup', path=backup_path)
+            
+            # Create ZIP archive
+            zip_buffer = BytesIO()
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                zipf.write(backup_path, os.path.basename(backup_path))
+            
+            # Clean up temporary file
+            if os.path.exists(backup_path):
+                os.remove(backup_path)
+            
+            # Prepare response
+            zip_buffer.seek(0)
+            response = HttpResponse(zip_buffer.getvalue(), content_type='application/zip')
+            response['Content-Disposition'] = f'attachment; filename="backup_{timestamp}.zip"'
+            
+            messages.success(request, f'✅ بک‌آپ با موفقیت ایجاد شد: {backup_filename}')
+            return response
+            
+        except Exception as e:
+            messages.error(request, f'❌ خطا در ایجاد بک‌آپ: {str(e)}')
+            return redirect('database_management')
+    
+    return redirect('database_management')
+
+@user_passes_test(is_superuser)
+@require_http_methods(["GET", "POST"])
+def database_restore_view(request):
+    """
+    View for restoring database from backup
+    Only accessible by superusers
+    """
+    if request.method == "POST":
+        backup_file = request.FILES.get('backup_file')
+        
+        if not backup_file:
+            messages.error(request, '❌ لطفاً فایل بک‌آپ را انتخاب کنید')
+            return redirect('database_management')
+        
+        try:
+            # Save uploaded file temporarily
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            temp_dir = tempfile.gettempdir()
+            
+            # Check if file is ZIP
+            if backup_file.name.endswith('.zip'):
+                zip_path = os.path.join(temp_dir, f'restore_{timestamp}.zip')
+                with open(zip_path, 'wb+') as destination:
+                    for chunk in backup_file.chunks():
+                        destination.write(chunk)
+                
+                # Extract ZIP file
+                with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                    zip_ref.extractall(temp_dir)
+                    extracted_files = zip_ref.namelist()
+                    
+                    if not extracted_files:
+                        raise Exception('فایل ZIP خالی است')
+                    
+                    backup_path = os.path.join(temp_dir, extracted_files[0])
+                
+                # Clean up ZIP file
+                os.remove(zip_path)
+            else:
+                # Direct SQL or dump file
+                backup_path = os.path.join(temp_dir, f'restore_{timestamp}{os.path.splitext(backup_file.name)[1]}')
+                with open(backup_path, 'wb+') as destination:
+                    for chunk in backup_file.chunks():
+                        destination.write(chunk)
+            
+            # Validate file extension
+            if not (backup_path.endswith('.sql') or backup_path.endswith('.dump')):
+                os.remove(backup_path)
+                raise Exception('فرمت فایل پشتیبانی نشده است. فقط .sql یا .dump مجاز است')
+            
+            # Call restore command
+            call_command('restore', path=backup_path)
+            
+            # Clean up temporary file
+            if os.path.exists(backup_path):
+                os.remove(backup_path)
+            
+            messages.success(request, '✅ دیتابیس با موفقیت بازیابی شد')
+            
+        except Exception as e:
+            messages.error(request, f'❌ خطا در بازیابی دیتابیس: {str(e)}')
+            
+            # Clean up on error
+            if 'backup_path' in locals() and os.path.exists(backup_path):
+                os.remove(backup_path)
+    
+    return redirect('database_management')
+
+@user_passes_test(is_superuser)
+def database_management_view(request):
+    """
+    Main view for database management
+    Shows backup and restore options
+    """
+    context = {
+        'title': 'مدیریت دیتابیس',
+        'db_engine': settings.DATABASES['default']['ENGINE'],
+        'db_name': settings.DATABASES['default']['NAME'],
+    }
+    
+    return render(request, 'dj_utils/database_management.html', context)
+
+@user_passes_test(is_superuser)
+@require_http_methods(["POST"])
+def database_backup_ajax(request):
+    """
+    AJAX endpoint for database backup
+    Returns JSON response
+    """
+    try:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_filename = f'backup_{timestamp}.sql'
+        backup_path = os.path.join(tempfile.gettempdir(), backup_filename)
+        
+        call_command('backup', path=backup_path)
+        
+        file_size = os.path.getsize(backup_path) / (1024 * 1024)  # Size in MB
+        
+        # Clean up
+        if os.path.exists(backup_path):
+            os.remove(backup_path)
+        
+        return JsonResponse({
+            'success': True,
+            'message': f'بک‌آپ با موفقیت ایجاد شد',
+            'filename': backup_filename,
+            'size': f'{file_size:.2f} MB',
+            'timestamp': timestamp
+        })
+        
+    except Exception as e:
+        return JsonResponse({
+            'success': False,
+            'message': f'خطا در ایجاد بک‌آپ: {str(e)}'
+        }, status=500)

starco_dj_utils-1.0.2.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: starco-dj-utils
+Version: 1.0.2
+Summary: A Django pluggable app for utilities and database management
+Author: Mojtaba
+Author-email: m.tahmasbi0111@yahoo.com
+License: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: Django>=4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

starco_dj_utils-1.0.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+dj_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dj_utils/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
+dj_utils/apps.py,sha256=4Hj6VLtqAhiItX4Ifztaj5DnP7csfHKk_kCtTmPAC8w,234
+dj_utils/handlers.py,sha256=4BAmPAV1gByCrZHpUyXc9qxpqIJeT2cLCV8p_F-cJCc,3102
+dj_utils/models.py,sha256=Vjc0p2XbAPgE6HyTF6vll98A4eDhA5AvaQqsc4kQ9AQ,57
+dj_utils/signals.py,sha256=1UsFrBjhrJPL7mExvD6SExgYAl1oqU8SDdZVmr65NF8,99
+dj_utils/tasks.py,sha256=vBCfY_cE_tbS6I-0NyUm4fwf5_QfvUvyAjm0GYoJSiY,1047
+dj_utils/tasks_config.py,sha256=aRjQ4xcbFWRY3XwCyAeBAqxS1ZfIPYBZBXNs4LnONGo,276
+dj_utils/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
+dj_utils/urls.py,sha256=sKZ0c7IxR6Z-reGRhDilLq4ZOldD4ZC_t5uN_SPIP3Y,442
+dj_utils/views.py,sha256=6HQBbaDiYIpYoRlYrTs3pKNTfzj9U4xXaFxkg9PBXWc,6599
+dj_utils/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dj_utils/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dj_utils/management/commands/backup.py,sha256=2LVTUyeKpyvrjEzliGbyehYNk-umXFasSDr1qHZkhj0,5573
+dj_utils/management/commands/restore.py,sha256=hg_S-Rvd83pyyG9-nML99Fh6htZHkaQgmTkMUc4we3k,5809
+dj_utils/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dj_utils/templates/dj_utils/database_management.html,sha256=KMOseSxu_RGujuEwSpeXrp2kYm61FISRhKyk9L5Khbo,13248
+starco_dj_utils-1.0.2.dist-info/METADATA,sha256=Qza2AyGxRVAbmlmUV7I7QPFMw5xxlO29kNR9otso_T8,419
+starco_dj_utils-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+starco_dj_utils-1.0.2.dist-info/top_level.txt,sha256=rsoZCEk78JSKSSx0ac_lRbFiZBJpicuobSbw2l0cxvk,9
+starco_dj_utils-1.0.2.dist-info/RECORD,,

starco_dj_utils-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

starco_dj_utils-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+dj_utils