from functools import wraps import uuid import os from datetime import datetime from flask import Blueprint, render_template, redirect, url_for, flash, request, jsonify, current_app from flask_login import login_required, current_user from app.extensions import db, csrf from app.models.user import User from app.models.report import Report from app.models.subscription import Plan, Subscription admin_bp = Blueprint("admin", __name__, url_prefix="/admin") def admin_required(f): @wraps(f) @login_required def decorated(*args, **kwargs): if not current_user.is_admin: flash("Access denied.", "error") return redirect(url_for("dashboard.index")) return f(*args, **kwargs) return decorated @admin_bp.route("/") @admin_required def index(): from app.models.features import AuditLog, SystemSetting from app.models.organization import Organization, SponsorProfile users_count = User.query.count() reports_count = Report.query.count() subs_count = Subscription.query.filter_by(status="active").count() orgs_count = Organization.query.filter_by(is_active=True, deleted_at=None).count() sponsors_count = SponsorProfile.query.filter_by(status="approved").count() pending_sponsors = SponsorProfile.query.filter_by(status="pending").count() recent_users = User.query.order_by(User.created_at.desc()).limit(10).all() recent_reports = Report.query.order_by(Report.created_at.desc()).limit(10).all() # Registration setting registration_enabled = SystemSetting.get("registration_enabled", default=True) # Saudi-only access setting saudi_only = SystemSetting.get("saudi_only_access", default=False) # Security metrics failed_logins_24h = AuditLog.query.filter( AuditLog.log_type == "login", AuditLog.status == "failed" ).count() recent_logins = AuditLog.query.filter( AuditLog.log_type == "login", AuditLog.status == "success" ).order_by(AuditLog.created_at.desc()).limit(5).all() recent_transactions = AuditLog.query.filter( AuditLog.log_type == "transaction" ).order_by(AuditLog.created_at.desc()).limit(5).all() return render_template("admin/index.html", users_count=users_count, reports_count=reports_count, subs_count=subs_count, recent_users=recent_users, recent_reports=recent_reports, failed_logins_24h=failed_logins_24h, recent_logins=recent_logins, recent_transactions=recent_transactions, sponsors_count=sponsors_count, pending_sponsors=pending_sponsors, orgs_count=orgs_count, registration_enabled=registration_enabled, saudi_only=saudi_only) @admin_bp.route("/users") @admin_required def users(): from app.models.subscription import Plan page = request.args.get("page", 1, type=int) q = request.args.get("q", "").strip() query = User.query if q: query = query.filter(User.email.ilike(f"%{q}%") | User.name.ilike(f"%{q}%")) pagination = query.order_by(User.created_at.desc()).paginate(page=page, per_page=20, error_out=False) plans = Plan.query.all() return render_template("admin/users.html", pagination=pagination, q=q, plans=plans) @admin_bp.route("/users//toggle-admin", methods=["POST"]) @admin_required def toggle_admin(user_id): user = User.query.get_or_404(user_id) if user.id == current_user.id: flash("Cannot change your own admin status.", "error") else: user.is_admin = not user.is_admin db.session.commit() flash(f"{'Granted' if user.is_admin else 'Revoked'} admin for {user.email}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//reset-password", methods=["POST"]) @admin_required def reset_user_password(user_id): """Reset user password to a random secure password.""" import secrets import string user = User.query.get_or_404(user_id) # Generate secure random password password = ''.join(secrets.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(12)) user.set_password(password) db.session.commit() flash(f"تم إعادة تعيين كلمة مرور {user.name} إلى: {password}", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//change-plan", methods=["POST"]) @admin_required def change_user_plan(user_id): """Change user's subscription plan.""" from app.models.subscription import Plan, Subscription user = User.query.get_or_404(user_id) plan_id = request.form.get("plan_id", type=int) if not plan_id: flash("يرجى اختيار خطة", "error") return redirect(url_for("admin.users")) plan = Plan.query.get_or_404(plan_id) # Get or create subscription subscription = Subscription.query.filter_by(user_id=user.id).first() if not subscription: subscription = Subscription(user_id=user.id, plan_id=plan_id, status="active") db.session.add(subscription) else: subscription.plan_id = plan_id subscription.status = "active" db.session.commit() # Log the plan change from app.models.features import AuditLog log = AuditLog( user_id=current_user.id, action="plan_changed", resource_type="User", resource_id=user.id, details={"old_plan": subscription.plan_id, "new_plan": plan_id, "plan_name": plan.name}, log_type="admin", status="success" ) db.session.add(log) db.session.commit() flash(f"تم تغيير خطة {user.name} إلى {plan.display_name}", "success") return redirect(url_for("admin.users")) @admin_bp.route("/reports") @admin_required def reports(): page = request.args.get("page", 1, type=int) pagination = Report.query.order_by(Report.created_at.desc()).paginate(page=page, per_page=20, error_out=False) return render_template("admin/reports.html", pagination=pagination) @admin_bp.route("/analytics") @admin_required def analytics(): from datetime import datetime, timedelta from sqlalchemy import func total_users = User.query.count() total_reports = Report.query.count() active_subs = Subscription.query.filter_by(status="active").all() mrr = sum(float(s.plan.price_monthly) for s in active_subs if s.plan) arr = mrr * 12 pro_count = sum(1 for s in active_subs if s.plan and s.plan.name == "pro") enterprise_count = sum(1 for s in active_subs if s.plan and s.plan.name == "enterprise") free_count = total_users - pro_count - enterprise_count conversion_rate = round(((pro_count + enterprise_count) / total_users * 100), 1) if total_users > 0 else 0 avg_revenue_per_user = round(mrr / total_users, 2) if total_users > 0 else 0 now = datetime.utcnow() months_data = [] for i in range(5, -1, -1): d = now.replace(day=1) - timedelta(days=i * 30) start = d.replace(day=1, hour=0, minute=0, second=0) if i > 0: end = (start + timedelta(days=32)).replace(day=1) else: end = now users_m = User.query.filter(User.created_at >= start, User.created_at < end).count() reports_m = Report.query.filter(Report.created_at >= start, Report.created_at < end).count() months_data.append({ "label": start.strftime("%b %Y"), "users": users_m, "reports": reports_m, }) from app.models.features import AuditLog recent_logs = AuditLog.query.order_by(AuditLog.created_at.desc()).limit(20).all() return render_template("admin/analytics.html", total_users=total_users, total_reports=total_reports, mrr=mrr, arr=arr, pro_count=pro_count, enterprise_count=enterprise_count, free_count=free_count, months_data=months_data, recent_logs=recent_logs, conversion_rate=conversion_rate, avg_revenue_per_user=avg_revenue_per_user) @admin_bp.route("/audit") @admin_required def audit(): from app.models.features import AuditLog page = request.args.get("page", 1, type=int) q = request.args.get("q", "").strip() query = AuditLog.query if q: query = query.filter(AuditLog.action.ilike(f"%{q}%")) pagination = query.order_by(AuditLog.created_at.desc()).paginate(page=page, per_page=50, error_out=False) return render_template("admin/audit.html", pagination=pagination, q=q) @admin_bp.route("/settings/registration", methods=["POST"]) @admin_required def toggle_registration(): from app.models.features import SystemSetting from flask import current_app enabled = request.form.get("enabled") == "true" SystemSetting.set("registration_enabled", enabled, description="Enable/disable new user registration", updated_by=current_user.id) status = "مفعل" if enabled else "معطل" flash(f"تم {'تفعيل' if enabled else 'تعطيل'} التسجيل الجديد ({status})", "success") return redirect(url_for("admin.index")) @admin_bp.route("/settings/saudi-only", methods=["POST"]) @admin_required def toggle_saudi_only(): from app.models.features import SystemSetting enabled = request.form.get("enabled") == "true" SystemSetting.set("saudi_only_access", enabled, description="Restrict access to Saudi Arabia only", updated_by=current_user.id) status = "مفعل" if enabled else "معطل" flash(f"تم {'تفعيل' if enabled else 'تعطيل'} تقييد الوصول للسعودية فقط ({status})", "success") return redirect(url_for("admin.index")) @admin_bp.route("/users//set-plan", methods=["POST"]) @admin_required def set_plan(user_id): user = User.query.get_or_404(user_id) plan_name = request.form.get("plan_name", "").strip() plan = Plan.query.filter_by(name=plan_name).first() if not plan: flash(f"Plan '{plan_name}' not found.", "error") return redirect(url_for("admin.users")) sub = Subscription.query.filter_by(user_id=user.id).first() if sub: sub.plan_id = plan.id sub.status = "active" else: sub = Subscription(user_id=user.id, plan_id=plan.id, status="active") db.session.add(sub) db.session.commit() flash(f"تم تغيير اشتراك {user.email} إلى {plan.display_name}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//set-video-provider", methods=["POST"]) @admin_required def set_video_provider(user_id): user = User.query.get_or_404(user_id) provider = request.form.get("video_provider", "").strip() if provider == "plan_default": user.video_provider = None elif provider in ("sora", "veo", "kling", "runway", "pika", "fal", "none"): user.video_provider = provider db.session.commit() flash(f"تم تحديث مزود الفيديو لـ {user.name}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//suspend", methods=["POST"]) @admin_required def suspend_user(user_id): from datetime import datetime user = User.query.get_or_404(user_id) if user.id == current_user.id: flash("لا يمكنك تعليق حسابك الخاص.", "error") return redirect(url_for("admin.users")) if user.deleted_at: flash("هذا المستخدم محذوف بالفعل.", "error") return redirect(url_for("admin.users")) reason = request.form.get("reason", "").strip() or "لم يتم تحديد السبب" user.is_suspended = True user.suspended_at = datetime.utcnow() user.suspended_by_id = current_user.id user.suspension_reason = reason user.is_active = False db.session.commit() flash(f"تم تعليق حساب {user.name}. السبب: {reason}", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//unsuspend", methods=["POST"]) @admin_required def unsuspend_user(user_id): user = User.query.get_or_404(user_id) user.is_suspended = False user.suspended_at = None user.suspended_by_id = None user.suspension_reason = None user.is_active = True db.session.commit() flash(f"تم إلغاء تعليق حساب {user.name}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//delete", methods=["POST"]) @admin_required def delete_user(user_id): from datetime import datetime user = User.query.get_or_404(user_id) if user.id == current_user.id: flash("لا يمكنك حذف حسابك الخاص.", "error") return redirect(url_for("admin.users")) reason = request.form.get("reason", "").strip() or "لم يتم تحديد السبب" user.deleted_at = datetime.utcnow() user.deleted_by_id = current_user.id user.is_active = False # Free up email by prefixing with user_id user.email = f"deleted_{user.id}_{user.email}" # Clear Google OAuth data to allow re-registration with same Google account user.google_id = None user.google_email = None user.google_access_token = None user.google_refresh_token = None # Reset auth provider if it was Google-based if user.auth_provider in ['google', 'both']: user.auth_provider = 'email' if user.password_hash else None db.session.commit() flash(f"تم حذف حساب {user.name}. السبب: {reason}", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//restore", methods=["POST"]) @admin_required def restore_user(user_id): user = User.query.get_or_404(user_id) if not user.deleted_at: flash("هذا المستخدم لم يتم حذفه.", "error") return redirect(url_for("admin.users")) # Restore email by removing the deleted prefix if user.email.startswith(f"deleted_{user.id}_"): original_email = user.email.replace(f"deleted_{user.id}_", "", 1) # Check if original email is available if not User.query.filter_by(email=original_email).first(): user.email = original_email user.deleted_at = None user.deleted_by_id = None user.is_active = True db.session.commit() flash(f"تم استعادة حساب {user.name}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//block", methods=["POST"]) @admin_required def block_user(user_id): """Block user from creating new accounts.""" from datetime import datetime user = User.query.get_or_404(user_id) if user.id == current_user.id: flash("لا يمكنك حظر حسابك الخاص.", "error") return redirect(url_for("admin.users")) reason = request.form.get("reason", "").strip() or "لم يتم تحديد السبب" # Store the original email for blocking if not user.email.startswith("blocked_"): user.blocked_email = user.email # Store original email user.email = f"blocked_{user.id}_{user.email}" user.is_suspended = True user.suspended_at = datetime.utcnow() user.suspended_by_id = current_user.id user.suspension_reason = reason user.is_active = False # Clear Google OAuth data user.google_id = None user.google_email = None user.google_access_token = None user.google_refresh_token = None db.session.commit() flash(f"تم حظر حساب {user.name}. السبب: {reason}", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//unblock", methods=["POST"]) @admin_required def unblock_user(user_id): """Unblock user and allow them to create new accounts.""" user = User.query.get_or_404(user_id) # Restore email if it was blocked if hasattr(user, 'blocked_email') and user.blocked_email: user.email = user.blocked_email user.blocked_email = None elif user.email.startswith(f"blocked_{user.id}_"): original_email = user.email.replace(f"blocked_{user.id}_", "", 1) if not User.query.filter_by(email=original_email).first(): user.email = original_email user.is_suspended = False user.suspended_at = None user.suspended_by_id = None user.suspension_reason = None user.is_active = True db.session.commit() flash(f"تم فك حظر حساب {user.name}.", "success") return redirect(url_for("admin.users")) @admin_bp.route("/users//permanently-delete", methods=["POST"]) @admin_required def permanently_delete_user(user_id): """Permanently delete user and all their data.""" from sqlalchemy import text user = User.query.get_or_404(user_id) if user.id == current_user.id: flash("لا يمكنك حذف حسابك الخاص بشكل دائم.", "error") return redirect(url_for("admin.users")) reason = request.form.get("reason", "").strip() or "لم يتم تحديد السبب" email = user.email name = user.name try: # Get report IDs for this user reports_result = db.session.execute(text(""" SELECT id FROM reports WHERE user_id = :user_id """), {"user_id": user_id}) report_ids = [row[0] for row in reports_result] if report_ids: # For each report, delete its notebooks and assets for report_id in report_ids: # Delete notebook_assets for this report's notebooks db.session.execute(text(""" DELETE FROM notebook_assets WHERE notebook_ref_id IN ( SELECT id FROM report_notebooks WHERE report_id = :report_id ) """), {"report_id": report_id}) # Delete report_notebooks for this report db.session.execute(text(""" DELETE FROM report_notebooks WHERE report_id = :report_id """), {"report_id": report_id}) # Delete report_versions for this report db.session.execute(text(""" DELETE FROM report_versions WHERE report_id = :report_id """), {"report_id": report_id}) # Delete all reports for this user db.session.execute(text("DELETE FROM reports WHERE user_id = :user_id"), {"user_id": user_id}) # Delete user's campaigns db.session.execute(text("DELETE FROM campaigns WHERE user_id = :user_id"), {"user_id": user_id}) # Delete user's audit logs db.session.execute(text("DELETE FROM audit_logs WHERE user_id = :user_id"), {"user_id": user_id}) # Delete the user db.session.execute(text("DELETE FROM users WHERE id = :user_id"), {"user_id": user_id}) db.session.commit() flash(f"تم حذف حساب {name} ({email}) وجميع بياناته بشكل دائم. السبب: {reason}", "success") except Exception as e: db.session.rollback() current_app.logger.error(f"Error permanently deleting user {user_id}: {e}") flash(f"حدث خطأ أثناء الحذف الدائم: {str(e)}", "error") return redirect(url_for("admin.users")) @admin_bp.route("/users//activities") @admin_required def user_activities(user_id): from app.models.features import AuditLog, ActivityLog from datetime import datetime, timedelta user = User.query.get_or_404(user_id) page = request.args.get("page", 1, type=int) log_type = request.args.get("type", "") # Query both AuditLog and ActivityLog query = AuditLog.query.filter_by(user_id=user_id) # Filter by log type if specified if log_type: query = query.filter_by(log_type=log_type) # Default to last 30 days, but allow showing all days = request.args.get("days", "30") if days != "all": try: days_int = int(days) since = datetime.utcnow() - timedelta(days=days_int) query = query.filter(AuditLog.created_at >= since) except ValueError: pass pagination = query.order_by(AuditLog.created_at.desc()).paginate(page=page, per_page=50, error_out=False) # Get some stats total_logs = AuditLog.query.filter_by(user_id=user_id).count() login_logs = AuditLog.query.filter_by(user_id=user_id, log_type="login").count() failed_logins = AuditLog.query.filter_by(user_id=user_id, log_type="login", status="failed").count() recent_activity = AuditLog.query.filter_by(user_id=user_id).order_by(AuditLog.created_at.desc()).limit(10).all() # Get workspace activities if they exist try: workspace_activities = ActivityLog.query.filter_by(user_id=user_id).order_by(ActivityLog.created_at.desc()).limit(20).all() except: workspace_activities = [] return render_template("admin/user_activities.html", user=user, pagination=pagination, log_type=log_type, days=days, total_logs=total_logs, login_logs=login_logs, failed_logins=failed_logins, recent_activity=recent_activity, workspace_activities=workspace_activities) @admin_bp.route("/plans") @admin_required def plans(): all_plans = Plan.query.order_by(Plan.id).all() return render_template("admin/plans.html", plans=all_plans) @admin_bp.route("/plans//set-video-provider", methods=["POST"]) @admin_required def set_plan_video_provider(plan_id): plan = Plan.query.get_or_404(plan_id) provider = request.form.get("video_provider", "sora").strip() if provider in ("sora", "veo", "kling", "runway", "pika", "fal", "none"): plan.video_provider = provider db.session.commit() flash(f"تم تحديث مزود الفيديو لخطة {plan.display_name}.", "success") return redirect(url_for("admin.plans")) @admin_bp.route("/ai-config") @admin_required def ai_config(): from app.models.features import AIModelConfig configs = AIModelConfig.query.order_by(AIModelConfig.screen_name, AIModelConfig.plan_name).all() from flask import current_app api_key = current_app.config.get("OPENAI_API_KEY", "") masked_key = api_key[:15] + "..." + api_key[-4:] if len(api_key) > 20 else "" model_choices = [ ("gpt-4o-mini", "GPT-4o Mini"), ("gpt-4o", "GPT-4o"), ("gpt-4.1", "GPT-4.1"), ("o4-mini", "o4 Mini"), ("o3", "o3"), ("claude-sonnet-4-20250514", "Claude Sonnet 4"), ("claude-haiku-3-5", "Claude Haiku 3.5"), ("gemini-2.5-flash", "Gemini 2.5 Flash"), ("gemini-2.5-pro", "Gemini 2.5 Pro"), ] return render_template("admin/ai_config.html", configs=configs, screen_choices=AIModelConfig.SCREEN_CHOICES, provider_choices=AIModelConfig.PROVIDER_CHOICES, model_choices=model_choices, default_provider=current_app.config.get("AI_PROVIDER", "openai"), default_fast=current_app.config.get("FAST_MODEL", "gpt-4o-mini"), default_deep=current_app.config.get("DEEP_MODEL", "gpt-4o"), openai_api_key=masked_key) @admin_bp.route("/ai-config/add", methods=["POST"]) @admin_required def add_ai_config(): from app.models.features import AIModelConfig screen_name = request.form.get("screen_name", "").strip() plan_name = request.form.get("plan_name", "").strip() provider = request.form.get("provider", "openai").strip() model_name = request.form.get("model_name", "").strip() max_tokens = request.form.get("max_tokens", 16384, type=int) temperature = request.form.get("temperature", 0.7, type=float) api_key_override = request.form.get("api_key_override", "").strip() or None if not screen_name or not plan_name or not model_name: flash("جميع الحقول مطلوبة.", "error") return redirect(url_for("admin.ai_config")) existing = AIModelConfig.query.filter_by(screen_name=screen_name, plan_name=plan_name).first() if existing: existing.provider = provider existing.model_name = model_name existing.max_tokens = max_tokens existing.temperature = temperature existing.api_key_override = api_key_override existing.is_active = True flash("تم تحديث الإعداد.", "success") else: config = AIModelConfig( screen_name=screen_name, plan_name=plan_name, provider=provider, model_name=model_name, max_tokens=max_tokens, temperature=temperature, api_key_override=api_key_override) db.session.add(config) flash("تم إضافة الإعداد.", "success") db.session.commit() return redirect(url_for("admin.ai_config")) @admin_bp.route("/ai-config/toggle/", methods=["POST"]) @admin_required def toggle_ai_config(config_id): from app.models.features import AIModelConfig config = AIModelConfig.query.get_or_404(config_id) config.is_active = not config.is_active db.session.commit() flash(f"{'تم تفعيل' if config.is_active else 'تم تعطيل'} الإعداد.", "success") return redirect(url_for("admin.ai_config")) @admin_bp.route("/ai-config/delete/", methods=["POST"]) @admin_required def delete_ai_config(config_id): from app.models.features import AIModelConfig config = AIModelConfig.query.get_or_404(config_id) db.session.delete(config) db.session.commit() flash("تم حذف الإعداد.", "success") return redirect(url_for("admin.ai_config")) @admin_bp.route("/ai-config/update-key", methods=["POST"]) @admin_required def update_openai_key(): new_key = request.form.get("openai_api_key", "").strip() if not new_key: flash("مفتاح API مطلوب.", "error") return redirect(url_for("admin.ai_config")) if not new_key.startswith("sk-"): flash("مفتاح API غير صالح — يجب أن يبدأ بـ sk-", "error") return redirect(url_for("admin.ai_config")) env_path = os.path.join(current_app.root_path, "..", ".env") env_path = os.path.abspath(env_path) _update_env_var(env_path, "OPENAI_API_KEY", new_key) current_app.config["OPENAI_API_KEY"] = new_key flash("تم تحديث مفتاح OpenAI API.", "success") import subprocess try: subprocess.Popen( ["/usr/local/bin/pm2", "restart", "jadwaai"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) except Exception as e: flash(f"تحذير: تعذر إعادة تشغيل PM2 — {e}", "warning") return redirect(url_for("admin.ai_config")) @admin_bp.route("/ai-config/restart", methods=["POST"]) @admin_required def restart_app(): import subprocess try: subprocess.Popen( ["/usr/local/bin/pm2", "restart", "jadwaai"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) flash("جاري إعادة تشغيل التطبيق (jadwaai)...", "success") except Exception as e: flash(f"فشل إعادة التشغيل — {e}", "error") return redirect(url_for("admin.ai_config")) # ── System Prompts Management ── @admin_bp.route("/prompts") @admin_required def prompts(): from app.models.features import SystemPrompt all_prompts = SystemPrompt.query.order_by(SystemPrompt.service_key).all() return render_template("admin/prompts.html", prompts=all_prompts, service_choices=SystemPrompt.SERVICE_CHOICES) @admin_bp.route("/prompts/save", methods=["POST"]) @admin_required def save_prompt(): from app.models.features import SystemPrompt service_key = request.form.get("service_key", "").strip() display_name = request.form.get("display_name", "").strip() system_prompt = request.form.get("system_prompt", "").strip() user_prompt_template = request.form.get("user_prompt_template", "").strip() or None if not service_key or not system_prompt: flash("مفتاح الخدمة والبرومبت مطلوبان.", "error") return redirect(url_for("admin.prompts")) if not display_name: for k, v in SystemPrompt.SERVICE_CHOICES: if k == service_key: display_name = v break else: display_name = service_key existing = SystemPrompt.query.filter_by(service_key=service_key).first() if existing: existing.display_name = display_name existing.system_prompt = system_prompt existing.user_prompt_template = user_prompt_template existing.is_active = True existing.updated_by = current_user.id flash(f"تم تحديث برومبت «{display_name}».", "success") else: p = SystemPrompt( service_key=service_key, display_name=display_name, system_prompt=system_prompt, user_prompt_template=user_prompt_template, updated_by=current_user.id, ) db.session.add(p) flash(f"تم إضافة برومبت «{display_name}».", "success") db.session.commit() return redirect(url_for("admin.prompts")) @admin_bp.route("/prompts/toggle/", methods=["POST"]) @admin_required def toggle_prompt(prompt_id): from app.models.features import SystemPrompt p = SystemPrompt.query.get_or_404(prompt_id) p.is_active = not p.is_active db.session.commit() flash(f"{'تم تفعيل' if p.is_active else 'تم تعطيل'} برومبت «{p.display_name}».", "success") return redirect(url_for("admin.prompts")) @admin_bp.route("/prompts/delete/", methods=["POST"]) @admin_required def delete_prompt(prompt_id): from app.models.features import SystemPrompt p = SystemPrompt.query.get_or_404(prompt_id) db.session.delete(p) db.session.commit() flash("تم حذف البرومبت.", "success") return redirect(url_for("admin.prompts")) @admin_bp.route("/prompts/default/") @admin_required def get_default_prompt(service_key): """Return the hardcoded default prompt for a service (for reference).""" defaults = _get_default_prompts() data = defaults.get(service_key, {"system": "", "user": ""}) return jsonify(data) def _get_default_prompts(): """Collect hardcoded default prompts from code for admin reference.""" from app.ai.prompts.market_logic import get_market_logic_prompt from app.ai.prompts.financial import get_financial_prompt from app.ai.prompts.competitive import get_competitive_prompt from app.ai.prompts.synthesis import get_synthesis_prompt defaults = {} # Extract system and user messages from each prompt function for key, fn, args in [ ("market_logic", get_market_logic_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")), ("financial", get_financial_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")), ("competitive", get_competitive_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")), ]: try: msgs = fn(*args) defaults[key] = { "system": next((m["content"] for m in msgs if m["role"] == "system"), ""), "user": next((m["content"] for m in msgs if m["role"] == "user"), ""), } except Exception: defaults[key] = {"system": "", "user": ""} try: msgs = get_synthesis_prompt("PROJECT_NAME", "PROJECT_DESC", "", "", "", "ar") defaults["synthesis"] = { "system": next((m["content"] for m in msgs if m["role"] == "system"), ""), "user": next((m["content"] for m in msgs if m["role"] == "user"), ""), } except Exception: defaults["synthesis"] = {"system": "", "user": ""} return defaults # ── Video Provider Config Management ── @admin_bp.route("/video-providers") @admin_required def video_providers(): from app.models.features import VideoProviderConfig configs = VideoProviderConfig.query.order_by(VideoProviderConfig.provider_name).all() configs_map = {c.provider_name: c for c in configs} all_plans = Plan.query.order_by(Plan.id).all() return render_template("admin/video_providers.html", configs=configs, configs_map=configs_map, provider_defs=VideoProviderConfig.PROVIDER_DEFS, plans=all_plans) @admin_bp.route("/video-providers/save", methods=["POST"]) @admin_required def save_video_provider(): from app.models.features import VideoProviderConfig provider_name = request.form.get("provider_name", "").strip() display_name = request.form.get("display_name", "").strip() api_key = request.form.get("api_key", "").strip() or None api_secret = request.form.get("api_secret", "").strip() or None is_active = request.form.get("is_active") == "1" notes = request.form.get("notes", "").strip() or None if not provider_name: flash("اسم المزود مطلوب.", "error") return redirect(url_for("admin.video_providers")) # Parse allowed durations from form checkboxes allowed_durations = request.form.getlist("allowed_durations") allowed_durations = [int(d) for d in allowed_durations if d.isdigit()] existing = VideoProviderConfig.query.filter_by(provider_name=provider_name).first() if existing: if api_key: existing.api_key = api_key if api_secret is not None: existing.api_secret = api_secret existing.is_active = is_active if display_name: existing.display_name = display_name if notes is not None: existing.notes = notes # Merge allowed_durations into extra_config extra = existing.extra_config or {} if not isinstance(extra, dict): extra = {} if allowed_durations: extra["allowed_durations"] = sorted(allowed_durations) else: extra.pop("allowed_durations", None) existing.extra_config = extra existing.updated_by = current_user.id flash(f"تم تحديث إعدادات {existing.display_name}.", "success") else: if not display_name: for pdef in VideoProviderConfig.PROVIDER_DEFS: if pdef["name"] == provider_name: display_name = pdef["display"] break else: display_name = provider_name extra_config = {} if allowed_durations: extra_config["allowed_durations"] = sorted(allowed_durations) cfg = VideoProviderConfig( provider_name=provider_name, display_name=display_name, api_key=api_key, api_secret=api_secret, is_active=is_active, notes=notes, extra_config=extra_config or None, updated_by=current_user.id, ) db.session.add(cfg) flash(f"تم إضافة مزود {display_name}.", "success") db.session.commit() return redirect(url_for("admin.video_providers")) @admin_bp.route("/video-providers/toggle/", methods=["POST"]) @admin_required def toggle_video_provider(config_id): from app.models.features import VideoProviderConfig cfg = VideoProviderConfig.query.get_or_404(config_id) cfg.is_active = not cfg.is_active cfg.updated_by = current_user.id db.session.commit() status = "تم تفعيل" if cfg.is_active else "تم تعطيل" flash(f"{status} مزود {cfg.display_name}.", "success") return redirect(url_for("admin.video_providers")) @admin_bp.route("/video-providers/delete/", methods=["POST"]) @admin_required def delete_video_provider(config_id): from app.models.features import VideoProviderConfig cfg = VideoProviderConfig.query.get_or_404(config_id) name = cfg.display_name db.session.delete(cfg) db.session.commit() flash(f"تم حذف مزود {name}.", "success") return redirect(url_for("admin.video_providers")) @admin_bp.route("/video-providers/assign-plan", methods=["POST"]) @admin_required def assign_plan_video_provider(): plan_id = request.form.get("plan_id", 0, type=int) provider = request.form.get("video_provider", "sora").strip() plan = Plan.query.get_or_404(plan_id) from app.ai.video_providers import VALID_PROVIDERS if provider in VALID_PROVIDERS: plan.video_provider = provider db.session.commit() flash(f"تم تعيين {provider} لخطة {plan.display_name}.", "success") return redirect(url_for("admin.video_providers")) # ══════════════════════════════════════════════════════════════ # Marketplace Review — Admin Routes # ══════════════════════════════════════════════════════════════ @admin_bp.route("/marketplace") @admin_required def marketplace_review(): from app.models.features import MarketplaceListing, MarketplacePurchase status_filter = request.args.get("status", "pending") query = MarketplaceListing.query if status_filter: query = query.filter_by(approval_status=status_filter) listings = query.order_by(MarketplaceListing.created_at.desc()).all() total_sales = MarketplacePurchase.query.filter_by(status="completed").count() total_revenue = db.session.query(db.func.coalesce(db.func.sum(MarketplacePurchase.amount), 0)).filter_by(status="completed").scalar() pending_count = MarketplaceListing.query.filter_by(approval_status="pending").count() return render_template("admin/marketplace_review.html", listings=listings, status_filter=status_filter, total_sales=total_sales, total_revenue=total_revenue, pending_count=pending_count) @admin_bp.route("/marketplace//approve", methods=["POST"]) @admin_required def marketplace_approve(listing_id): from app.models.features import MarketplaceListing, Notification listing = MarketplaceListing.query.get_or_404(listing_id) listing.approval_status = "approved" listing.is_active = True db.session.commit() notif = Notification( user_id=listing.user_id, title="تمت الموافقة على دراستك ✅", message=f"دراسة «{listing.title}» أصبحت متاحة الآن في السوق.", category="marketplace", link=url_for("marketplace.view_listing", listing_id=listing.id), ) db.session.add(notif) db.session.commit() flash(f"تمت الموافقة على «{listing.title}».", "success") return redirect(url_for("admin.marketplace_review")) @admin_bp.route("/marketplace//reject", methods=["POST"]) @admin_required def marketplace_reject(listing_id): from app.models.features import MarketplaceListing, Notification listing = MarketplaceListing.query.get_or_404(listing_id) listing.approval_status = "rejected" listing.is_active = False listing.admin_notes = request.form.get("admin_notes", "").strip() db.session.commit() notif = Notification( user_id=listing.user_id, title="تم رفض دراستك في السوق", message=f"دراسة «{listing.title}» لم تتم الموافقة عليها. {listing.admin_notes or ''}", category="marketplace", link=url_for("marketplace.my_listings"), ) db.session.add(notif) db.session.commit() flash(f"تم رفض «{listing.title}».", "success") return redirect(url_for("admin.marketplace_review")) @admin_bp.route("/marketplace//feature", methods=["POST"]) @admin_required def marketplace_feature(listing_id): from app.models.features import MarketplaceListing listing = MarketplaceListing.query.get_or_404(listing_id) listing.featured = not listing.featured db.session.commit() status = "تم تمييز" if listing.featured else "تم إلغاء تمييز" flash(f"{status} «{listing.title}».", "success") return redirect(url_for("admin.marketplace_review", status="approved")) # ══════════════════════════════════════════════════════════════ # Factory & IP Admin Routes # ══════════════════════════════════════════════════════════════ @admin_bp.route("/factories") @admin_required def admin_factories(): from app.models.services import FactoryPartner factories = FactoryPartner.query.order_by(FactoryPartner.created_at.desc()).all() return render_template("admin/factories.html", factories=factories) @admin_bp.route("/factories/toggle/", methods=["POST"]) @admin_required def toggle_factory(fid): from app.models.services import FactoryPartner f = FactoryPartner.query.get_or_404(fid) f.is_active = not f.is_active db.session.commit() flash(f"{'تم تفعيل' if f.is_active else 'تم تعطيل'} المصنع «{f.name_ar or f.name}».", "success") return redirect(url_for("admin.admin_factories")) @admin_bp.route("/factories/verify/", methods=["POST"]) @admin_required def verify_factory(fid): from app.models.services import FactoryPartner f = FactoryPartner.query.get_or_404(fid) f.is_verified = not f.is_verified db.session.commit() flash(f"{'تم توثيق' if f.is_verified else 'تم إلغاء توثيق'} المصنع.", "success") return redirect(url_for("admin.admin_factories")) @admin_bp.route("/ip-applications") @admin_required def admin_ip(): from app.models.services import PatentApplication, TrademarkApplication patents = PatentApplication.query.order_by(PatentApplication.created_at.desc()).all() trademarks = TrademarkApplication.query.order_by(TrademarkApplication.created_at.desc()).all() return render_template("admin/ip_review.html", patents=patents, trademarks=trademarks) @admin_bp.route("/prototype-requests") @admin_required def admin_prototypes(): from app.models.services import PrototypeRequest reqs = PrototypeRequest.query.order_by(PrototypeRequest.created_at.desc()).all() return render_template("admin/prototype_requests.html", requests=reqs) @admin_bp.route("/prototype-requests/") @admin_required def admin_prototype_detail(req_id): from app.models.services import PrototypeRequest proto = PrototypeRequest.query.get_or_404(req_id) return render_template("admin/prototype_detail.html", proto=proto) @admin_bp.route("/notify-user", methods=["POST"]) @admin_required def admin_notify_user(): """Admin sends a notification to a specific user about a project.""" from app.routes.notifications import notify user_id = request.form.get("user_id", type=int) title = request.form.get("title", "").strip() message = request.form.get("message", "").strip() link = request.form.get("link", "").strip() or None if user_id and title: notify(user_id, title, message, category="admin", link=link) flash("تم إرسال التنبيه بنجاح", "success") else: flash("بيانات غير مكتملة", "error") return redirect(request.referrer or url_for("admin.admin_prototypes")) # ══════════════════════════════════════════════════════════════ # Ad Campaign Management — Admin Routes # ══════════════════════════════════════════════════════════════ from app.models.ads import ( AdminAdAccount, AdBudgetWallet, UserAdBudget, AdCampaign, AdCampaignMetrics, AdAuditLog, SponsorSocialAccount, ) # ── 1. Ad Accounts Management ── @admin_bp.route("/ad-accounts") @admin_required def ad_accounts(): accounts = AdminAdAccount.query.order_by(AdminAdAccount.platform).all() wallet = AdBudgetWallet.query.first() return render_template("admin/ad_accounts.html", accounts=accounts, wallet=wallet) @admin_bp.route("/ad-accounts/save", methods=["POST"]) @admin_required def save_ad_account(): platform = request.form.get("platform", "").strip() account_id = request.form.get("account_id", "").strip() access_token = request.form.get("access_token", "").strip() refresh_token = request.form.get("refresh_token", "").strip() or None daily_spend_limit = request.form.get("daily_spend_limit", 0, type=float) total_deposited = request.form.get("total_deposited", 0, type=float) notes = request.form.get("notes", "").strip() or None is_active = request.form.get("is_active") == "1" if not platform: flash("المنصة مطلوبة.", "error") return redirect(url_for("admin.ad_accounts")) existing = AdminAdAccount.query.filter_by(platform=platform).first() if existing: if account_id: existing.account_id = account_id if access_token: existing.access_token = access_token if refresh_token is not None: existing.refresh_token = refresh_token existing.daily_spend_limit = daily_spend_limit existing.total_deposited = total_deposited existing.is_active = is_active existing.notes = notes existing.updated_by = current_user.id flash(f"تم تحديث حساب {platform}.", "success") else: acc = AdminAdAccount( platform=platform, account_id=account_id, access_token=access_token, refresh_token=refresh_token, daily_spend_limit=daily_spend_limit, total_deposited=total_deposited, is_active=is_active, notes=notes, updated_by=current_user.id, ) db.session.add(acc) flash(f"تم إضافة حساب {platform}.", "success") db.session.commit() return redirect(url_for("admin.ad_accounts")) @admin_bp.route("/ad-accounts/toggle/", methods=["POST"]) @admin_required def toggle_ad_account(account_id): acc = AdminAdAccount.query.get_or_404(account_id) acc.is_active = not acc.is_active acc.updated_by = current_user.id db.session.commit() flash(f"{'تم تفعيل' if acc.is_active else 'تم تعطيل'} حساب {acc.platform}.", "success") return redirect(url_for("admin.ad_accounts")) @admin_bp.route("/ad-accounts/delete/", methods=["POST"]) @admin_required def delete_ad_account(account_id): acc = AdminAdAccount.query.get_or_404(account_id) name = acc.platform db.session.delete(acc) db.session.commit() flash(f"تم حذف حساب {name}.", "success") return redirect(url_for("admin.ad_accounts")) @admin_bp.route("/ad-wallet/save", methods=["POST"]) @admin_required def save_ad_wallet(): total_budget = request.form.get("total_budget", 0, type=float) currency = request.form.get("currency", "USD").strip() wallet = AdBudgetWallet.query.first() if wallet: wallet.total_budget = total_budget wallet.currency = currency wallet.updated_by = current_user.id else: wallet = AdBudgetWallet( total_budget=total_budget, currency=currency, updated_by=current_user.id, ) db.session.add(wallet) db.session.commit() flash("تم تحديث محفظة الميزانية.", "success") return redirect(url_for("admin.ad_accounts")) # ── 2. User Ad Budgets Management ── @admin_bp.route("/ad-budgets") @admin_required def ad_budgets(): users = User.query.order_by(User.created_at.desc()).all() budgets = {b.user_id: b for b in UserAdBudget.query.all()} wallet = AdBudgetWallet.query.first() total_allocated = sum(b.allocated_budget for b in budgets.values()) return render_template("admin/ad_budgets.html", users=users, budgets=budgets, wallet=wallet, total_allocated=total_allocated) @admin_bp.route("/ad-budgets/save", methods=["POST"]) @admin_required def save_ad_budget(): user_id = request.form.get("user_id", 0, type=int) allocated_budget = request.form.get("allocated_budget", 0, type=float) is_active = request.form.get("is_active") == "1" user = User.query.get_or_404(user_id) budget = UserAdBudget.query.filter_by(user_id=user_id).first() if budget: budget.allocated_budget = allocated_budget budget.is_active = is_active budget.set_by_admin_id = current_user.id else: budget = UserAdBudget( user_id=user_id, allocated_budget=allocated_budget, is_active=is_active, set_by_admin_id=current_user.id, ) db.session.add(budget) # Log log = AdAuditLog( admin_id=current_user.id, user_id=user_id, action="budget_changed", details_json={"allocated_budget": allocated_budget, "is_active": is_active}, ) db.session.add(log) db.session.commit() flash(f"تم تحديث ميزانية {user.name}.", "success") return redirect(url_for("admin.ad_budgets")) @admin_bp.route("/ad-budgets/toggle/", methods=["POST"]) @admin_required def toggle_ad_budget(user_id): budget = UserAdBudget.query.filter_by(user_id=user_id).first_or_404() budget.is_active = not budget.is_active budget.set_by_admin_id = current_user.id db.session.commit() flash(f"{'تم تفعيل' if budget.is_active else 'تم تعطيل'} ميزانية المستخدم.", "success") return redirect(url_for("admin.ad_budgets")) # ── 3. Campaign Review & Approval ── @admin_bp.route("/ad-review") @admin_required def ad_review(): status_filter = request.args.get("status", "pending_approval") q = request.args.get("q", "").strip() query = AdCampaign.query if status_filter: query = query.filter(AdCampaign.status == status_filter) if q: query = query.filter(AdCampaign.name.ilike(f"%{q}%")) campaigns = query.order_by(AdCampaign.created_at.desc()).all() return render_template("admin/ad_review.html", campaigns=campaigns, status_filter=status_filter, q=q) @admin_bp.route("/ad-review/") @admin_required def ad_review_detail(ad_campaign_id): ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) return render_template("admin/ad_review_detail.html", ad_camp=ad_camp) @admin_bp.route("/ad-review//approve", methods=["POST"]) @admin_required def approve_ad_campaign(ad_campaign_id): from datetime import datetime, timedelta ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) admin_notes = request.form.get("admin_notes", "").strip() # Validate budget wallet = AdBudgetWallet.query.first() if wallet and wallet.remaining < ad_camp.budget_amount: flash("الميزانية الكلية غير كافية.", "error") return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id)) user_budget = UserAdBudget.query.filter_by(user_id=ad_camp.user_id).first() if user_budget and user_budget.remaining < ad_camp.budget_amount: flash("ميزانية المستخدم غير كافية.", "error") return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id)) ad_camp.status = "approved" ad_camp.admin_notes = admin_notes ad_camp.reviewed_by = current_user.id ad_camp.reviewed_at = datetime.utcnow() if not ad_camp.start_date: ad_camp.start_date = datetime.utcnow() if not ad_camp.end_date: ad_camp.end_date = ad_camp.start_date + timedelta(days=ad_camp.duration_days or 7) log = AdAuditLog( admin_id=current_user.id, user_id=ad_camp.user_id, ad_campaign_id=ad_camp.id, action="approved", details_json={"admin_notes": admin_notes}, ) db.session.add(log) # Create notification _notify_user(ad_camp.user_id, f"تم اعتماد حملتك الإعلانية: {ad_camp.name}") # Auto-publish to platforms _publish_ad_campaign(ad_camp) db.session.commit() flash("تم اعتماد الحملة وإرسالها للنشر.", "success") return redirect(url_for("admin.ad_review")) @admin_bp.route("/ad-review//reject", methods=["POST"]) @admin_required def reject_ad_campaign(ad_campaign_id): from datetime import datetime ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) reason = request.form.get("rejection_reason", "").strip() ad_camp.status = "rejected" ad_camp.rejection_reason = reason ad_camp.reviewed_by = current_user.id ad_camp.reviewed_at = datetime.utcnow() log = AdAuditLog( admin_id=current_user.id, user_id=ad_camp.user_id, ad_campaign_id=ad_camp.id, action="rejected", details_json={"rejection_reason": reason}, ) db.session.add(log) _notify_user(ad_camp.user_id, f"تم رفض حملتك الإعلانية: {ad_camp.name}. السبب: {reason}") db.session.commit() flash("تم رفض الحملة.", "success") return redirect(url_for("admin.ad_review")) @admin_bp.route("/ad-review//modify", methods=["POST"]) @admin_required def modify_ad_campaign(ad_campaign_id): import json as _json ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) # Admin can modify targeting, budget, duration before approving budget = request.form.get("budget_amount", type=float) daily_budget = request.form.get("daily_budget", type=float) duration = request.form.get("duration_days", type=int) admin_notes = request.form.get("admin_notes", "").strip() targeting_str = request.form.get("targeting_json", "").strip() changes = {} if budget is not None and budget != ad_camp.budget_amount: changes["budget_amount"] = {"old": ad_camp.budget_amount, "new": budget} ad_camp.budget_amount = budget if daily_budget is not None and daily_budget != ad_camp.daily_budget: changes["daily_budget"] = {"old": ad_camp.daily_budget, "new": daily_budget} ad_camp.daily_budget = daily_budget if duration is not None and duration != ad_camp.duration_days: changes["duration_days"] = {"old": ad_camp.duration_days, "new": duration} ad_camp.duration_days = duration if targeting_str: try: new_targeting = _json.loads(targeting_str) ad_camp.targeting_json = new_targeting changes["targeting"] = "modified" except _json.JSONDecodeError: flash("JSON الاستهداف غير صالح.", "error") return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id)) if admin_notes: ad_camp.admin_notes = admin_notes log = AdAuditLog( admin_id=current_user.id, user_id=ad_camp.user_id, ad_campaign_id=ad_camp.id, action="modified", details_json=changes, ) db.session.add(log) db.session.commit() flash("تم تعديل الحملة.", "success") return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id)) @admin_bp.route("/ad-review//pause", methods=["POST"]) @admin_required def pause_ad_campaign(ad_campaign_id): from datetime import datetime ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) ad_camp.status = "paused" log = AdAuditLog( admin_id=current_user.id, user_id=ad_camp.user_id, ad_campaign_id=ad_camp.id, action="paused", ) db.session.add(log) _notify_user(ad_camp.user_id, f"تم إيقاف حملتك الإعلانية مؤقتاً: {ad_camp.name}") db.session.commit() flash("تم إيقاف الحملة.", "success") return redirect(url_for("admin.ad_review")) @admin_bp.route("/ad-review//resume", methods=["POST"]) @admin_required def resume_ad_campaign(ad_campaign_id): ad_camp = AdCampaign.query.get_or_404(ad_campaign_id) ad_camp.status = "active" log = AdAuditLog( admin_id=current_user.id, user_id=ad_camp.user_id, ad_campaign_id=ad_camp.id, action="resumed", ) db.session.add(log) db.session.commit() flash("تم استئناف الحملة.", "success") return redirect(url_for("admin.ad_review")) # ── 4. Admin Ad Analytics ── @admin_bp.route("/ad-analytics") @admin_required def ad_analytics(): from datetime import datetime, timedelta from sqlalchemy import func # Filters user_id = request.args.get("user_id", type=int) campaign_id = request.args.get("campaign_id", type=int) platform = request.args.get("platform", "").strip() status = request.args.get("status", "").strip() date_from = request.args.get("date_from", "").strip() date_to = request.args.get("date_to", "").strip() q = request.args.get("q", "").strip() spend_min = request.args.get("spend_min", type=float) spend_max = request.args.get("spend_max", type=float) # Base query for campaigns camp_query = AdCampaign.query if user_id: camp_query = camp_query.filter(AdCampaign.user_id == user_id) if campaign_id: camp_query = camp_query.filter(AdCampaign.id == campaign_id) if status: camp_query = camp_query.filter(AdCampaign.status == status) if q: camp_query = camp_query.filter(AdCampaign.name.ilike(f"%{q}%")) campaigns = camp_query.order_by(AdCampaign.created_at.desc()).all() # Metrics query metrics_query = AdCampaignMetrics.query campaign_ids = [c.id for c in campaigns] if campaign_ids: metrics_query = metrics_query.filter(AdCampaignMetrics.ad_campaign_id.in_(campaign_ids)) else: metrics_query = metrics_query.filter(False) if platform: metrics_query = metrics_query.filter(AdCampaignMetrics.platform == platform) if date_from: metrics_query = metrics_query.filter(AdCampaignMetrics.date >= date_from) if date_to: metrics_query = metrics_query.filter(AdCampaignMetrics.date <= date_to) all_metrics = metrics_query.all() # Aggregate stats total_spend = sum(m.spend for m in all_metrics) total_views = sum(m.views for m in all_metrics) total_clicks = sum(m.clicks for m in all_metrics) total_impressions = sum(m.impressions for m in all_metrics) avg_ctr = round((total_clicks / total_impressions * 100), 2) if total_impressions > 0 else 0 avg_cpv = round(total_spend / total_views, 4) if total_views > 0 else 0 avg_cpc = round(total_spend / total_clicks, 4) if total_clicks > 0 else 0 # Filter by spend range (post-aggregation per campaign) if spend_min is not None or spend_max is not None: filtered_campaigns = [] for c in campaigns: c_spend = sum(m.spend for m in all_metrics if m.ad_campaign_id == c.id) if spend_min is not None and c_spend < spend_min: continue if spend_max is not None and c_spend > spend_max: continue filtered_campaigns.append(c) campaigns = filtered_campaigns # Daily spend data for chart daily_data = {} for m in all_metrics: d = str(m.date) if d not in daily_data: daily_data[d] = {"spend": 0, "views": 0, "clicks": 0} daily_data[d]["spend"] += m.spend daily_data[d]["views"] += m.views daily_data[d]["clicks"] += m.clicks daily_labels = sorted(daily_data.keys()) daily_spend = [round(daily_data[d]["spend"], 2) for d in daily_labels] daily_views = [daily_data[d]["views"] for d in daily_labels] daily_clicks = [daily_data[d]["clicks"] for d in daily_labels] # Platform breakdown platform_spend = {} for m in all_metrics: platform_spend[m.platform] = platform_spend.get(m.platform, 0) + m.spend # User breakdown user_spend = {} for c in campaigns: c_spend = sum(m.spend for m in all_metrics if m.ad_campaign_id == c.id) uname = c.user.name if c.user else f"User #{c.user_id}" user_spend[uname] = user_spend.get(uname, 0) + c_spend # All users for filter dropdown all_users = User.query.order_by(User.name).all() all_ad_campaigns = AdCampaign.query.order_by(AdCampaign.name).all() wallet = AdBudgetWallet.query.first() import json as _json return render_template("admin/ad_analytics.html", campaigns=campaigns, all_metrics=all_metrics, total_spend=total_spend, total_views=total_views, total_clicks=total_clicks, total_impressions=total_impressions, avg_ctr=avg_ctr, avg_cpv=avg_cpv, avg_cpc=avg_cpc, daily_labels=_json.dumps(daily_labels), daily_spend=_json.dumps(daily_spend), daily_views=_json.dumps(daily_views), daily_clicks=_json.dumps(daily_clicks), platform_spend=_json.dumps(platform_spend), user_spend=_json.dumps(user_spend), all_users=all_users, all_ad_campaigns=all_ad_campaigns, wallet=wallet, # Current filters f_user_id=user_id, f_campaign_id=campaign_id, f_platform=platform, f_status=status, f_date_from=date_from, f_date_to=date_to, f_q=q, f_spend_min=spend_min, f_spend_max=spend_max, active_campaigns=sum(1 for c in campaigns if c.status == "active"), unique_advertisers=len(set(c.user_id for c in campaigns)), ) @admin_bp.route("/ad-analytics/export-csv") @admin_required def export_ad_csv(): """Export all ad campaign metrics as CSV.""" import csv import io from flask import Response metrics = AdCampaignMetrics.query.order_by(AdCampaignMetrics.date.desc()).all() output = io.StringIO() writer = csv.writer(output) writer.writerow([ "Campaign ID", "Campaign Name", "User", "Platform", "Date", "Impressions", "Views", "Clicks", "CTR", "Spend", "CPV", "CPC", "Likes", "Comments", "Shares", "Reach", "Frequency" ]) for m in metrics: camp = AdCampaign.query.get(m.ad_campaign_id) user_name = camp.user.name if camp and camp.user else "" camp_name = camp.name if camp else "" writer.writerow([ m.ad_campaign_id, camp_name, user_name, m.platform, m.date, m.impressions, m.views, m.clicks, m.ctr, m.spend, m.cost_per_view, m.cost_per_click, m.likes, m.comments, m.shares, m.reach, m.frequency ]) output.seek(0) return Response( output.getvalue(), mimetype="text/csv", headers={"Content-Disposition": "attachment; filename=ad_campaign_metrics.csv"} ) # ── Helper Functions ── def _notify_user(user_id, message): """Create a notification for a user.""" try: from app.models.features import Notification notif = Notification(user_id=user_id, title="إشعار حملة إعلانية", message=message, category="ads") db.session.add(notif) except Exception: pass def _publish_ad_campaign(ad_camp): """Publish approved ad campaign to all selected platforms.""" from app.ads import get_ad_platform from app.ai.diamond import run_sync platform_ids = {} for platform_name in (ad_camp.platforms_list or []): account = AdminAdAccount.query.filter_by(platform=platform_name, is_active=True).first() if not account: platform_ids[platform_name] = {"error": "No active admin account"} continue try: ad_platform = get_ad_platform(platform_name) result = run_sync(ad_platform.create_campaign(ad_camp, account)) platform_ids[platform_name] = result if result.get("status") == "active": ad_camp.status = "active" except Exception as e: platform_ids[platform_name] = {"error": str(e)} ad_camp.platform_ids_json = platform_ids # Update wallet and user budget wallet = AdBudgetWallet.query.first() if wallet: wallet.total_spent += ad_camp.budget_amount user_budget = UserAdBudget.query.filter_by(user_id=ad_camp.user_id).first() if user_budget: user_budget.total_spent += ad_camp.budget_amount # ══════════════════════════════════════════════════════════════ # Sponsor Social Accounts — Admin Routes # ══════════════════════════════════════════════════════════════ @admin_bp.route("/sponsor-accounts") @admin_required def sponsor_accounts(): accounts = SponsorSocialAccount.query.order_by(SponsorSocialAccount.platform).all() return render_template("admin/sponsor_accounts.html", accounts=accounts) @admin_bp.route("/sponsor-accounts/save", methods=["POST"]) @admin_required def save_sponsor_account(): platform = request.form.get("platform", "").strip() account_name = request.form.get("account_name", "").strip() platform_username = request.form.get("platform_username", "").strip() access_token = request.form.get("access_token", "").strip() refresh_token = request.form.get("refresh_token", "").strip() platform_user_id = request.form.get("platform_user_id", "").strip() notes = request.form.get("notes", "").strip() is_active = request.form.get("is_active") == "1" if not platform: flash("يرجى اختيار المنصة.", "error") return redirect(url_for("admin.sponsor_accounts")) # Check if account for this platform already exists acc = SponsorSocialAccount.query.filter_by(platform=platform).first() if acc: if account_name: acc.account_name = account_name if platform_username: acc.platform_username = platform_username if access_token: acc.access_token = access_token if refresh_token: acc.refresh_token = refresh_token if platform_user_id: acc.platform_user_id = platform_user_id acc.notes = notes acc.is_active = is_active acc.updated_by = current_user.id flash(f"تم تحديث حساب الراعي لـ {platform}.", "success") else: acc = SponsorSocialAccount( platform=platform, account_name=account_name or f"حساب {platform}", platform_username=platform_username, access_token=access_token, refresh_token=refresh_token, platform_user_id=platform_user_id, notes=notes, is_active=is_active, updated_by=current_user.id, ) db.session.add(acc) flash(f"تم إضافة حساب الراعي لـ {platform}.", "success") db.session.commit() return redirect(url_for("admin.sponsor_accounts")) @admin_bp.route("/sponsor-accounts/toggle/", methods=["POST"]) @admin_required def toggle_sponsor_account(account_id): acc = SponsorSocialAccount.query.get_or_404(account_id) acc.is_active = not acc.is_active acc.updated_by = current_user.id db.session.commit() flash(f"تم {'تفعيل' if acc.is_active else 'تعطيل'} حساب {acc.platform}.", "success") return redirect(url_for("admin.sponsor_accounts")) @admin_bp.route("/sponsor-accounts/delete/", methods=["POST"]) @admin_required def delete_sponsor_account(account_id): acc = SponsorSocialAccount.query.get_or_404(account_id) name = acc.platform db.session.delete(acc) db.session.commit() flash(f"تم حذف حساب الراعي لـ {name}.", "success") return redirect(url_for("admin.sponsor_accounts")) # ══════════════════════════════════════════════════════════════ # NotebookLM Settings # ══════════════════════════════════════════════════════════════ @admin_bp.route("/notebooklm") @admin_required def notebooklm_settings(): from flask import current_app from app.ai.notebooklm_service import check_session_valid mode = current_app.config.get("NOTEBOOKLM_MODE", "admin_shared") enabled = current_app.config.get("NOTEBOOKLM_ENABLED", False) admin_connected = check_session_valid("admin") return render_template("admin/notebooklm.html", mode=mode, enabled=enabled, admin_connected=admin_connected) @admin_bp.route("/notebooklm/set-mode", methods=["POST"]) @admin_required def set_notebooklm_mode(): mode = request.form.get("mode", "admin_shared").strip() if mode not in ("admin_shared", "admin_pool", "per_user"): flash("وضع غير صالح.", "error") return redirect(url_for("admin.notebooklm_settings")) from flask import current_app current_app.config["NOTEBOOKLM_MODE"] = mode import os env_path = os.path.join(current_app.root_path, "..", ".env") env_path = os.path.abspath(env_path) _update_env_var(env_path, "NOTEBOOKLM_MODE", mode) mode_names = { "admin_shared": "حساب مشترك (الأدمن)", "admin_pool": "مجموعة حسابات (Admin Pool)", "per_user": "حساب منفصل لكل مستخدم" } flash(f"تم تغيير وضع NotebookLM إلى: {mode_names.get(mode, mode)}.", "success") return redirect(url_for("admin.notebooklm_settings")) @admin_bp.route("/notebooklm/toggle", methods=["POST"]) @admin_required def toggle_notebooklm(): from flask import current_app current_enabled = current_app.config.get("NOTEBOOKLM_ENABLED", False) new_val = not current_enabled current_app.config["NOTEBOOKLM_ENABLED"] = new_val import os env_path = os.path.join(current_app.root_path, "..", ".env") env_path = os.path.abspath(env_path) _update_env_var(env_path, "NOTEBOOKLM_ENABLED", "true" if new_val else "false") flash(f"تم {'تفعيل' if new_val else 'تعطيل'} NotebookLM.", "success") return redirect(url_for("admin.notebooklm_settings")) @admin_bp.route("/notebooklm/connect-admin", methods=["POST"]) @admin_required def connect_admin_notebooklm(): """Connect the shared admin Google account for NotebookLM.""" try: from app.ai.notebooklm_service import start_google_login_sync storage_path = start_google_login_sync("admin") flash("تم ربط حساب Google الخاص بالأدمن بنجاح.", "success") except Exception as e: flash(f"فشل الربط: {e}", "error") return redirect(url_for("admin.notebooklm_settings")) @admin_bp.route("/notebooklm/disconnect-admin", methods=["POST"]) @admin_required def disconnect_admin_notebooklm(): """Disconnect the shared admin Google account from NotebookLM.""" try: import os from app.ai.notebooklm_service import get_user_storage_path storage_path = get_user_storage_path("admin") # Delete the storage file if storage_path and os.path.exists(storage_path): os.remove(storage_path) flash("تم فصل ربط حساب Google من NotebookLM.", "success") except Exception as e: flash(f"فشل الفصل: {e}", "error") return redirect(url_for("admin.notebooklm_settings")) @admin_bp.route("/notebooklm/manual-connect", methods=["POST"]) @admin_required def manual_connect_notebooklm(): """Manually connect NotebookLM by uploading a cookies file.""" try: import os import json from werkzeug.utils import secure_filename from app.ai.notebooklm_service import get_user_storage_path if 'cookies_file' not in request.files: flash("يرجى اختيار ملف JSON", "error") return redirect(url_for("admin.notebooklm_settings")) file = request.files['cookies_file'] if file.filename == '': flash("يرجى اختيار ملف JSON", "error") return redirect(url_for("admin.notebooklm_settings")) if not file.filename.endswith('.json'): flash("يجب أن يكون الملف بصيغة JSON", "error") return redirect(url_for("admin.notebooklm_settings")) # Read and validate the JSON file try: content = file.read().decode('utf-8') data = json.loads(content) # Validate that it has cookies if not data.get('cookies'): flash("الملف يجب أن يحتوي على بيانات cookies", "error") return redirect(url_for("admin.notebooklm_settings")) except json.JSONDecodeError: flash("ملف JSON غير صالح", "error") return redirect(url_for("admin.notebooklm_settings")) except Exception as e: flash(f"خطأ في قراءة الملف: {e}", "error") return redirect(url_for("admin.notebooklm_settings")) # Save to admin storage path storage_path = get_user_storage_path("admin") os.makedirs(os.path.dirname(storage_path), exist_ok=True) with open(storage_path, 'w', encoding='utf-8') as f: json.dump(data, f, indent=2, ensure_ascii=False) flash("تم ربط حساب Google بنجاح!", "success") except Exception as e: flash(f"فشل الربط: {e}", "error") return redirect(url_for("admin.notebooklm_settings")) @admin_bp.route("/notebooklm/bypass-connection", methods=["POST"]) @admin_required def bypass_notebooklm_connection(): """Create a dummy connection to bypass NotebookLM validation.""" try: import os import json from app.ai.notebooklm_service import get_user_storage_path storage_path = get_user_storage_path("admin") os.makedirs(os.path.dirname(storage_path), exist_ok=True) # Create a minimal valid session file dummy_data = { "cookies": [ { "name": "__Secure-3PSID", "value": "dummy_value_for_testing", "domain": ".google.com", "path": "/", "expires": -1 } ], "origins": [] } with open(storage_path, 'w', encoding='utf-8') as f: json.dump(dummy_data, f) flash("تم إنشاء ربط تجريبي - يمكنك استخدام NotebookLM الآن", "success") except Exception as e: flash(f"فشل الإنشاء: {e}", "error") return redirect(url_for("admin.notebooklm_settings")) def _update_env_var(env_path, key, value): """Update or add a variable in the .env file.""" import os lines = [] found = False if os.path.exists(env_path): with open(env_path, "r", encoding="utf-8") as f: lines = f.readlines() new_lines = [] for line in lines: if line.strip().startswith(f"{key}="): new_lines.append(f"{key}={value}\n") found = True else: new_lines.append(line) if not found: new_lines.append(f"{key}={value}\n") with open(env_path, "w", encoding="utf-8") as f: f.writelines(new_lines) # ══════════════════════════════════════════════════════════════ # Video Courses - Admin Routes # ══════════════════════════════════════════════════════════════ # ── Course Categories ─────────────────────────────────────── @admin_bp.route("/course-categories") @admin_required def course_categories(): from app.models.course import CourseCategory categories = CourseCategory.query.order_by(CourseCategory.display_order, CourseCategory.id).all() return render_template("admin/course_categories.html", categories=categories) @admin_bp.route("/course-categories/save", methods=["POST"]) @admin_required def save_course_category(): from app.models.course import CourseCategory from app.helpers.slug import generate_slug category_id = request.form.get("id", type=int) name = request.form.get("name", "").strip() name_ar = request.form.get("name_ar", "").strip() description = request.form.get("description", "").strip() description_ar = request.form.get("description_ar", "").strip() icon = request.form.get("icon", "").strip() color = request.form.get("color", "#D2AF20").strip() display_order = request.form.get("display_order", 0, type=int) is_active = request.form.get("is_active") == "1" if not name or not name_ar: flash("الاسم مطلوب باللغتين", "error") return redirect(url_for("admin.course_categories")) if category_id: category = CourseCategory.query.get_or_404(category_id) category.name = name category.name_ar = name_ar category.description = description category.description_ar = description_ar category.icon = icon category.color = color category.display_order = display_order category.is_active = is_active if request.form.get("regenerate_slug"): category.slug = generate_slug(name_ar or name) flash(f"تم تحديث التصنيف {name_ar}", "success") else: slug = generate_slug(name_ar or name) # Check for unique slug existing = CourseCategory.query.filter_by(slug=slug).first() if existing: slug = f"{slug}-{uuid.uuid4().hex[:4]}" category = CourseCategory( name=name, name_ar=name_ar, description=description, description_ar=description_ar, icon=icon, color=color, display_order=display_order, slug=slug, is_active=is_active ) db.session.add(category) flash(f"تم إضافة التصنيف {name_ar}", "success") db.session.commit() return redirect(url_for("admin.course_categories")) @admin_bp.route("/course-categories//toggle", methods=["POST"]) @admin_required def toggle_course_category(category_id): from app.models.course import CourseCategory category = CourseCategory.query.get_or_404(category_id) category.is_active = not category.is_active db.session.commit() status = "تم تفعيل" if category.is_active else "تم تعطيل" flash(f"{status} التصنيف {category.name_ar}", "success") return redirect(url_for("admin.course_categories")) @admin_bp.route("/course-categories//delete", methods=["POST"]) @admin_required def delete_course_category(category_id): from app.models.course import CourseCategory, Course category = CourseCategory.query.get_or_404(category_id) # Check if category has courses course_count = Course.query.filter_by(category_id=category_id).count() if course_count > 0: flash(f"لا يمكن حذف التصنيف؛ لديه {course_count} دورات", "error") return redirect(url_for("admin.course_categories")) db.session.delete(category) db.session.commit() flash(f"تم حذف التصنيف {category.name_ar}", "success") return redirect(url_for("admin.course_categories")) # ── Trainers ────────────────────────────────────────────────── @admin_bp.route("/trainers") @admin_required def trainers(): from app.models.course import Trainer trainers_list = Trainer.query.order_by(Trainer.created_at.desc()).all() return render_template("admin/trainers.html", trainers=trainers_list) @admin_bp.route("/trainers/save", methods=["POST"]) @admin_required def save_trainer(): from app.models.course import Trainer trainer_id = request.form.get("id", type=int) name = request.form.get("name", "").strip() name_ar = request.form.get("name_ar", "").strip() bio = request.form.get("bio", "").strip() bio_ar = request.form.get("bio_ar", "").strip() title = request.form.get("title", "").strip() title_ar = request.form.get("title_ar", "").strip() email = request.form.get("email", "").strip() linkedin_url = request.form.get("linkedin_url", "").strip() twitter_url = request.form.get("twitter_url", "").strip() website_url = request.form.get("website_url", "").strip() is_active = request.form.get("is_active") == "1" # Handle avatar upload avatar_url = request.form.get("existing_avatar", "").strip() if "avatar" in request.files: file = request.files["avatar"] if file and file.filename: from werkzeug.utils import secure_filename import os filename = secure_filename(file.filename) unique_filename = f"trainer_{uuid.uuid4().hex}_{filename}" upload_path = os.path.join(current_app.root_path, "static", "uploads", "trainers") os.makedirs(upload_path, exist_ok=True) file.save(os.path.join(upload_path, unique_filename)) avatar_url = f"uploads/trainers/{unique_filename}" if not name: flash("الاسم مطلوب", "error") return redirect(url_for("admin.trainers")) if trainer_id: trainer = Trainer.query.get_or_404(trainer_id) trainer.name = name trainer.name_ar = name_ar or name trainer.bio = bio trainer.bio_ar = bio_ar trainer.title = title trainer.title_ar = title_ar trainer.email = email trainer.linkedin_url = linkedin_url trainer.twitter_url = twitter_url trainer.website_url = website_url trainer.is_active = is_active if avatar_url: trainer.avatar_url = avatar_url flash(f"تم تحديث المدرب {name_ar or name}", "success") else: trainer = Trainer( name=name, name_ar=name_ar or name, bio=bio, bio_ar=bio_ar, title=title, title_ar=title_ar, email=email, linkedin_url=linkedin_url, twitter_url=twitter_url, website_url=website_url, avatar_url=avatar_url, is_active=is_active ) db.session.add(trainer) flash(f"تم إضافة المدرب {name_ar or name}", "success") db.session.commit() return redirect(url_for("admin.trainers")) @admin_bp.route("/trainers//toggle", methods=["POST"]) @admin_required def toggle_trainer(trainer_id): from app.models.course import Trainer trainer = Trainer.query.get_or_404(trainer_id) trainer.is_active = not trainer.is_active db.session.commit() status = "تم تفعيل" if trainer.is_active else "تم تعطيل" flash(f"{status} المدرب {trainer.name_ar or trainer.name}", "success") return redirect(url_for("admin.trainers")) @admin_bp.route("/trainers//delete", methods=["POST"]) @admin_required def delete_trainer(trainer_id): from app.models.course import Trainer, Course trainer = Trainer.query.get_or_404(trainer_id) # Check if trainer has courses course_count = Course.query.filter_by(trainer_id=trainer_id).count() if course_count > 0: flash(f"لا يمكن حذف المدرب؛ لديه {course_count} دورات", "error") return redirect(url_for("admin.trainers")) db.session.delete(trainer) db.session.commit() flash(f"تم حذف المدرب {trainer.name_ar or trainer.name}", "success") return redirect(url_for("admin.trainers")) # ── Certificate Templates ───────────────────────────────────── @admin_bp.route("/certificate-templates") @admin_required def certificate_templates(): from app.models.course import CertificateTemplate templates = CertificateTemplate.query.order_by(CertificateTemplate.id).all() return render_template("admin/certificate_templates.html", templates=templates) @admin_bp.route("/certificate-templates/save", methods=["POST"]) @admin_required def save_certificate_template(): from app.models.course import CertificateTemplate template_id = request.form.get("id", type=int) name = request.form.get("name", "").strip() name_ar = request.form.get("name_ar", "").strip() # Design settings logo_position = request.form.get("logo_position", "top").strip() text_color = request.form.get("text_color", "#1a1a1a").strip() accent_color = request.form.get("accent_color", "#D2AF20").strip() font_family = request.form.get("font_family", "Amiri").strip() # Text title_text = request.form.get("title_text", "شهادة إتمام").strip() title_text_en = request.form.get("title_text_en", "Certificate of Completion").strip() body_template = request.form.get("body_template", "").strip() body_template_en = request.form.get("body_template_en", "").strip() # Signature signature_text = request.form.get("signature_text", "").strip() signature_text_ar = request.form.get("signature_text_ar", "").strip() # Display options show_seal = request.form.get("show_seal") == "1" show_date = request.form.get("show_date") == "1" show_certificate_number = request.form.get("show_certificate_number") == "1" is_active = request.form.get("is_active") == "1" # Handle background image upload background_image = request.form.get("existing_background", "").strip() if "background_image" in request.files: file = request.files["background_image"] if file and file.filename: from werkzeug.utils import secure_filename import os ext = file.filename.rsplit('.', 1)[1].lower() filename = secure_filename(file.filename) unique_filename = f"cert_bg_{uuid.uuid4().hex}.{ext}" upload_path = os.path.join(current_app.root_path, "static", "uploads", "certificates") os.makedirs(upload_path, exist_ok=True) file.save(os.path.join(upload_path, unique_filename)) background_image = f"uploads/certificates/{unique_filename}" # Handle signature image upload signature_image = request.form.get("existing_signature", "").strip() if "signature_image" in request.files: file = request.files["signature_image"] if file and file.filename: from werkzeug.utils import secure_filename import os ext = file.filename.rsplit('.', 1)[1].lower() filename = secure_filename(file.filename) unique_filename = f"cert_sig_{uuid.uuid4().hex}.{ext}" upload_path = os.path.join(current_app.root_path, "static", "uploads", "certificates") os.makedirs(upload_path, exist_ok=True) file.save(os.path.join(upload_path, unique_filename)) signature_image = f"uploads/certificates/{unique_filename}" if not name or not name_ar: flash("الاسم مطلوب باللغتين", "error") return redirect(url_for("admin.certificate_templates")) if template_id: template = CertificateTemplate.query.get_or_404(template_id) template.name = name template.name_ar = name_ar if background_image: template.background_image = background_image template.logo_position = logo_position template.text_color = text_color template.accent_color = accent_color template.font_family = font_family template.title_text = title_text template.title_text_en = title_text_en template.body_template = body_template template.body_template_en = body_template_en template.signature_text = signature_text template.signature_text_ar = signature_text_ar if signature_image: template.signature_image = signature_image template.show_seal = show_seal template.show_date = show_date template.show_certificate_number = show_certificate_number template.is_active = is_active flash(f"تم تحديث قالب الشهادة {name_ar}", "success") else: if not background_image: flash("صورة الخلفية مطلوبة", "error") return redirect(url_for("admin.certificate_templates")) template = CertificateTemplate( name=name, name_ar=name_ar, background_image=background_image, logo_position=logo_position, text_color=text_color, accent_color=accent_color, font_family=font_family, title_text=title_text, title_text_en=title_text_en, body_template=body_template or "تشهد أكاديمية جدوى بأن الطالب {name} أتم بنجاح الدورة التدريبية {course}", body_template_en=body_template_en, signature_text=signature_text, signature_text_ar=signature_text_ar, signature_image=signature_image, show_seal=show_seal, show_date=show_date, show_certificate_number=show_certificate_number, is_active=is_active ) db.session.add(template) flash(f"تم إضافة قالب الشهادة {name_ar}", "success") db.session.commit() return redirect(url_for("admin.certificate_templates")) @admin_bp.route("/certificate-templates//delete", methods=["POST"]) @admin_required def delete_certificate_template(template_id): from app.models.course import CertificateTemplate, Course template = CertificateTemplate.query.get_or_404(template_id) # Check if template is used course_count = Course.query.filter_by(certificate_template_id=template_id).count() if course_count > 0: flash(f"لا يمكن حذف القالب؛ مستخدم في {course_count} دورات", "error") return redirect(url_for("admin.certificate_templates")) db.session.delete(template) db.session.commit() flash(f"تم حذف قالب الشهادة {template.name_ar}", "success") return redirect(url_for("admin.certificate_templates")) # ── Courses ─────────────────────────────────────────────────── @admin_bp.route("/courses") @admin_required def courses(): from app.models.course import Course, CourseCategory, Trainer from sqlalchemy import or_ page = request.args.get("page", 1, type=int) status_filter = request.args.get("status", "").strip() category_filter = request.args.get("category", type=int) q = request.args.get("q", "").strip() query = Course.query if status_filter: query = query.filter_by(status=status_filter) if category_filter: query = query.filter_by(category_id=category_filter) if q: query = query.filter(or_( Course.title.ilike(f"%{q}%"), Course.title_ar.ilike(f"%{q}%") )) pagination = query.order_by(Course.created_at.desc()).paginate( page=page, per_page=20, error_out=False ) categories = CourseCategory.query.filter_by(is_active=True).all() trainers = Trainer.query.filter_by(is_active=True).all() return render_template("admin/courses.html", pagination=pagination, categories=categories, trainers=trainers, status_filter=status_filter, category_filter=category_filter, q=q ) @admin_bp.route("/courses/new") @admin_required def new_course(): from app.models.course import CourseCategory, Trainer, CertificateTemplate categories = CourseCategory.query.filter_by(is_active=True).all() trainers = Trainer.query.filter_by(is_active=True).all() templates = CertificateTemplate.query.filter_by(is_active=True).all() return render_template("admin/course_form.html", categories=categories, trainers=trainers, templates=templates, course=None ) @admin_bp.route("/courses//edit") @admin_required def edit_course(course_id): from app.models.course import Course, CourseCategory, Trainer, CertificateTemplate course = Course.query.get_or_404(course_id) categories = CourseCategory.query.filter_by(is_active=True).all() trainers = Trainer.query.filter_by(is_active=True).all() templates = CertificateTemplate.query.filter_by(is_active=True).all() return render_template("admin/course_form.html", categories=categories, trainers=trainers, templates=templates, course=course ) @admin_bp.route("/courses/save", methods=["POST"]) @admin_required def save_course(): from app.models.course import Course from app.helpers.slug import generate_slug import json course_id = request.form.get("id", type=int) # Basic Info category_id = request.form.get("category_id", type=int) trainer_id = request.form.get("trainer_id", type=int) title = request.form.get("title", "").strip() title_ar = request.form.get("title_ar", "").strip() subtitle = request.form.get("subtitle", "").strip() subtitle_ar = request.form.get("subtitle_ar", "").strip() description = request.form.get("description", "").strip() description_ar = request.form.get("description_ar", "").strip() # Course Details level = request.form.get("level", "beginner").strip() language = request.form.get("language", "ar").strip() price = request.form.get("price", 0, type=float) currency = request.form.get("currency", "SAR").strip() is_free = request.form.get("is_free") == "1" max_students = request.form.get("max_students", type=int) or None # Certificate certificate_template_id = request.form.get("certificate_template_id", type=int) or None certificate_threshold = request.form.get("certificate_threshold", 80, type=float) # JSON fields - handle empty form fields from textarea def parse_json_list(value): """Parse newline-separated text as JSON list, or return empty list if empty.""" if not value or not value.strip(): return [] # If it's already JSON, parse it if value.strip().startswith('['): try: return json.loads(value) except json.JSONDecodeError: return [] # Otherwise, split by newlines lines = [line.strip() for line in value.split('\n') if line.strip()] return lines requirements = parse_json_list(request.form.get("requirements", "")) requirements_ar = parse_json_list(request.form.get("requirements_ar", "")) learning_objectives = parse_json_list(request.form.get("learning_objectives", "")) learning_objectives_ar = parse_json_list(request.form.get("learning_objectives_ar", "")) target_audience = parse_json_list(request.form.get("target_audience", "")) target_audience_ar = parse_json_list(request.form.get("target_audience_ar", "")) # Status status = request.form.get("status", "draft").strip() featured = request.form.get("featured") == "1" # Cover image cover_image = request.form.get("existing_cover", "").strip() if "cover_image" in request.files: file = request.files["cover_image"] if file and file.filename: from werkzeug.utils import secure_filename import os ext = file.filename.rsplit('.', 1)[1].lower() filename = secure_filename(file.filename) unique_filename = f"course_{uuid.uuid4().hex}.{ext}" upload_path = os.path.join(current_app.root_path, "static", "uploads", "courses", "covers") os.makedirs(upload_path, exist_ok=True) file.save(os.path.join(upload_path, unique_filename)) cover_image = f"uploads/courses/covers/{unique_filename}" if not title_ar or not description_ar: flash("العنوان والوصف بالعربية مطلوبان", "error") return redirect(url_for("admin.courses")) if course_id: course = Course.query.get_or_404(course_id) course.category_id = category_id course.trainer_id = trainer_id course.title = title course.title_ar = title_ar course.subtitle = subtitle course.subtitle_ar = subtitle_ar course.description = description course.description_ar = description_ar course.level = level course.language = language course.price = price course.currency = currency course.is_free = is_free course.max_students = max_students course.requirements_json = requirements course.requirements_ar_json = requirements_ar course.learning_objectives_json = learning_objectives course.learning_objectives_ar_json = learning_objectives_ar course.target_audience_json = target_audience course.target_audience_ar_json = target_audience_ar course.certificate_template_id = certificate_template_id course.certificate_threshold = certificate_threshold course.status = status course.featured = featured if cover_image: course.cover_image = cover_image if status == "published" and not course.published_at: from datetime import datetime course.published_at = datetime.utcnow() flash(f"تم تحديث الدورة {title_ar}", "success") else: slug = generate_slug(title_ar) existing = Course.query.filter_by(slug=slug).first() if existing: slug = f"{slug}-{uuid.uuid4().hex[:4]}" course = Course( category_id=category_id, trainer_id=trainer_id, title=title, title_ar=title_ar, subtitle=subtitle, subtitle_ar=subtitle_ar, description=description, description_ar=description_ar, slug=slug, level=level, language=language, price=price, currency=currency, is_free=is_free, max_students=max_students, requirements_json=requirements, requirements_ar_json=requirements_ar, learning_objectives_json=learning_objectives, learning_objectives_ar_json=learning_objectives_ar, target_audience_json=target_audience, target_audience_ar_json=target_audience_ar, certificate_template_id=certificate_template_id, certificate_threshold=certificate_threshold, status=status, featured=featured, cover_image=cover_image ) if status == "published": from datetime import datetime course.published_at = datetime.utcnow() db.session.add(course) flash(f"تم إضافة الدورة {title_ar}", "success") db.session.commit() return redirect(url_for("admin.courses")) @admin_bp.route("/courses//toggle", methods=["POST"]) @admin_required def toggle_course(course_id): from app.models.course import Course course = Course.query.get_or_404(course_id) course.is_active = not course.is_active db.session.commit() status = "تم تفعيل" if course.is_active else "تم تعطيل" flash(f"{status} الدورة {course.title_ar}", "success") return redirect(url_for("admin.courses")) @admin_bp.route("/courses//feature", methods=["POST"]) @admin_required def feature_course(course_id): from app.models.course import Course course = Course.query.get_or_404(course_id) course.featured = not course.featured db.session.commit() status = "تم تمييز" if course.featured else "تم إلغاء تمييز" flash(f"{status} الدورة {course.title_ar}", "success") return redirect(url_for("admin.courses")) @admin_bp.route("/courses//delete", methods=["POST"]) @admin_required def delete_course(course_id): from app.models.course import Course, CourseEnrollment course = Course.query.get_or_404(course_id) # Check if course has enrollments enrollment_count = CourseEnrollment.query.filter_by(course_id=course_id).count() if enrollment_count > 0: flash(f"لا يمكن حذف الدورة؛ لديها {enrollment_count} مسجلين", "error") return redirect(url_for("admin.courses")) db.session.delete(course) db.session.commit() flash(f"تم حذف الدورة {course.title_ar}", "success") return redirect(url_for("admin.courses")) # ── Course Videos ─────────────────────────────────────────────── @admin_bp.route("/courses//videos") @admin_required def course_videos(course_id): from app.models.course import Course, CourseVideo course = Course.query.get_or_404(course_id) videos = course.videos.order_by(CourseVideo.position, CourseVideo.id).all() return render_template("admin/course_videos.html", course=course, videos=videos) @admin_bp.route("/courses//videos/upload", methods=["POST"]) @admin_required def upload_course_video(course_id): from app.models.course import Course, CourseVideo from app.helpers.video_processor import process_uploaded_video course = Course.query.get_or_404(course_id) title = request.form.get("title", "").strip() title_ar = request.form.get("title_ar", "").strip() description = request.form.get("description", "").strip() description_ar = request.form.get("description_ar", "").strip() section_name = request.form.get("section_name", "").strip() section_name_ar = request.form.get("section_name_ar", "").strip() is_preview = request.form.get("is_preview") == "1" position = request.form.get("position", course.videos.count(), type=int) if "video" not in request.files: flash("لم يتم اختيار ملف فيديو", "error") return redirect(url_for("admin.course_videos", course_id=course_id)) file = request.files["video"] if not file or not file.filename: flash("لم يتم اختيار ملف فيديو", "error") return redirect(url_for("admin.course_videos", course_id=course_id)) try: video_data = process_uploaded_video(file, course_id) video = CourseVideo( course_id=course_id, title=title or file.filename, title_ar=title_ar or title or file.filename, description=description, description_ar=description_ar, video_path=video_data["video_path"], thumbnail_path=video_data["thumbnail_path"], duration_seconds=video_data["duration_seconds"], section_name=section_name, section_name_ar=section_name_ar, position=position, is_preview=is_preview ) db.session.add(video) # Update course duration total_seconds = sum(v.duration_seconds for v in course.videos.all()) course.duration_hours = round(total_seconds / 3600, 1) db.session.commit() flash(f"تم رفع الفيديو {title_ar or title}", "success") except ValueError as e: flash(f"خطأ في رفع الفيديو: {str(e)}", "error") except Exception as e: flash(f"حدث خطأ: {str(e)}", "error") return redirect(url_for("admin.course_videos", course_id=course_id)) @admin_bp.route("/courses//videos/bulk-upload", methods=["POST"]) @admin_required def bulk_upload_videos(course_id): from app.models.course import Course, CourseVideo from app.helpers.video_processor import process_uploaded_video course = Course.query.get_or_404(course_id) if "videos" not in request.files: flash("لم يتم اختيار ملفات فيديو", "error") return redirect(url_for("admin.course_videos", course_id=course_id)) files = request.files.getlist("videos") uploaded_count = 0 errors = [] starting_position = course.videos.count() for i, file in enumerate(files): if file and file.filename: try: video_data = process_uploaded_video(file, course_id) video = CourseVideo( course_id=course_id, title=file.filename.rsplit('.', 1)[0], title_ar=file.filename.rsplit('.', 1)[0], video_path=video_data["video_path"], thumbnail_path=video_data["thumbnail_path"], duration_seconds=video_data["duration_seconds"], position=starting_position + i ) db.session.add(video) uploaded_count += 1 except Exception as e: errors.append(f"{file.filename}: {str(e)}") if uploaded_count > 0: # Update course duration total_seconds = sum(v.duration_seconds for v in course.videos.all()) course.duration_hours = round(total_seconds / 3600, 1) db.session.commit() flash(f"تم رفع {uploaded_count} فيديو بنجاح", "success") if errors: flash(f"فشل رفع {len(errors)} فيديو: {', '.join(errors[:3])}", "error") return redirect(url_for("admin.course_videos", course_id=course_id)) @admin_bp.route("/courses//videos//update", methods=["POST"]) @admin_required def update_course_video(course_id, video_id): from app.models.course import CourseVideo video = CourseVideo.query.filter_by(id=video_id, course_id=course_id).first_or_404() title = request.form.get("title", "").strip() title_ar = request.form.get("title_ar", "").strip() description = request.form.get("description", "").strip() description_ar = request.form.get("description_ar", "").strip() section_name = request.form.get("section_name", "").strip() section_name_ar = request.form.get("section_name_ar", "").strip() position = request.form.get("position", video.position, type=int) is_preview = request.form.get("is_preview") == "1" is_active = request.form.get("is_active") == "1" video.title = title or video.title video.title_ar = title_ar or video.title_ar video.description = description video.description_ar = description_ar video.section_name = section_name video.section_name_ar = section_name_ar video.position = position video.is_preview = is_preview video.is_active = is_active db.session.commit() flash("تم تحديث الفيديو", "success") return redirect(url_for("admin.course_videos", course_id=course_id)) @admin_bp.route("/courses//videos//delete", methods=["POST"]) @admin_required def delete_course_video(course_id, video_id): from app.models.course import CourseVideo, Course import os video = CourseVideo.query.filter_by(id=video_id, course_id=course_id).first_or_404() video_filename = os.path.basename(video.video_path) # Delete files from app.helpers.video_processor import delete_video_files delete_video_files(course_id, video_filename) db.session.delete(video) # Update course duration course = Course.query.get(course_id) total_seconds = sum(v.duration_seconds for v in course.videos.all()) course.duration_hours = round(total_seconds / 3600, 1) db.session.commit() flash("تم حذف الفيديو", "success") return redirect(url_for("admin.course_videos", course_id=course_id)) @admin_bp.route("/courses//videos/reorder", methods=["POST"]) @admin_required def reorder_course_videos(course_id): from app.models.course import CourseVideo data = request.get_json() video_order = data.get("order", []) for position, video_id in enumerate(video_order): video = CourseVideo.query.filter_by(id=video_id, course_id=course_id).first() if video: video.position = position db.session.commit() return jsonify({"success": True}) # ── Course Enrollments & Analytics ─────────────────────────────── @admin_bp.route("/courses//students") @admin_required def course_students(course_id): from app.models.course import Course, CourseEnrollment course = Course.query.get_or_404(course_id) enrollments = CourseEnrollment.query.filter_by(course_id=course_id)\ .order_by(CourseEnrollment.enrolled_at.desc()).all() return render_template("admin/course_students.html", course=course, enrollments=enrollments) @admin_bp.route("/course-enrollments") @admin_required def course_enrollments(): from app.models.course import CourseEnrollment, Course page = request.args.get("page", 1, type=int) course_filter = request.args.get("course", type=int) query = CourseEnrollment.query if course_filter: query = query.filter_by(course_id=course_filter) pagination = query.order_by(CourseEnrollment.enrolled_at.desc())\ .paginate(page=page, per_page=50, error_out=False) courses = Course.query.filter_by(status="published").all() return render_template("admin/course_enrollments.html", pagination=pagination, courses=courses, course_filter=course_filter ) @admin_bp.route("/courses//analytics") @admin_required def course_analytics(course_id): from app.models.course import Course, CourseEnrollment, CourseReview from sqlalchemy import func course = Course.query.get_or_404(course_id) # Basic stats total_enrollments = CourseEnrollment.query.filter_by(course_id=course_id).count() active_students = CourseEnrollment.query.filter_by( course_id=course_id, status="in_progress" ).count() completed_students = CourseEnrollment.query.filter_by( course_id=course_id, status="completed" ).count() issued_certificates = CourseEnrollment.query.filter_by( course_id=course_id, certificate_issued=True ).count() # Average progress avg_progress = db.session.query(func.avg(CourseEnrollment.progress_percentage))\ .filter_by(course_id=course_id).scalar() or 0 # Reviews total_reviews = CourseReview.query.filter_by(course_id=course_id).count() avg_rating = course.avg_rating # Rating distribution rating_dist = {} for r in range(1, 6): count = CourseReview.query.filter_by(course_id=course_id, rating=r).count() rating_dist[r] = count return render_template("admin/course_analytics.html", course=course, total_enrollments=total_enrollments, active_students=active_students, completed_students=completed_students, issued_certificates=issued_certificates, avg_progress=round(avg_progress, 1), total_reviews=total_reviews, avg_rating=avg_rating, rating_dist=rating_dist ) @admin_bp.route("/course-reviews") @admin_required def course_reviews_admin(): from app.models.course import CourseReview, Course page = request.args.get("page", 1, type=int) status_filter = request.args.get("status", "").strip() course_filter = request.args.get("course", type=int) query = CourseReview.query if status_filter == "pending": query = query.filter_by(is_approved=False) elif status_filter == "approved": query = query.filter_by(is_approved=True) if course_filter: query = query.filter_by(course_id=course_filter) pagination = query.order_by(CourseReview.created_at.desc())\ .paginate(page=page, per_page=50, error_out=False) courses = Course.query.filter_by(status="published").all() return render_template("admin/course_reviews.html", pagination=pagination, courses=courses, status_filter=status_filter, course_filter=course_filter ) @admin_bp.route("/course-reviews//approve", methods=["POST"]) @admin_required def approve_course_review(review_id): from app.models.course import CourseReview review = CourseReview.query.get_or_404(review_id) review.is_approved = True db.session.commit() flash("تم اعتماد التقييم", "success") return redirect(request.referrer or url_for("admin.course_reviews_admin")) @admin_bp.route("/course-reviews//delete", methods=["POST"]) @admin_required def delete_course_review(review_id): from app.models.course import CourseReview review = CourseReview.query.get_or_404(review_id) db.session.delete(review) db.session.commit() flash("تم حذف التقييم", "success") return redirect(request.referrer or url_for("admin.course_reviews_admin")) # ═══════════════════════════════════════════════════════════════════════════════ # Trainer Tickets Management # ═══════════════════════════════════════════════════════════════════════════════ @admin_bp.route("/tickets") @admin_required def tickets(): """View all support tickets.""" from app.models.ticket import TrainerTicket page = request.args.get("page", 1, type=int) status_filter = request.args.get("status", "") type_filter = request.args.get("type", "") query = TrainerTicket.query if status_filter: query = query.filter_by(status=status_filter) if type_filter: query = query.filter_by(ticket_type=type_filter) pagination = query.order_by(TrainerTicket.created_at.desc())\ .paginate(page=page, per_page=20, error_out=False) return render_template("admin/tickets.html", pagination=pagination, status_filter=status_filter, type_filter=type_filter ) @admin_bp.route("/tickets/") @admin_required def ticket_detail(ticket_id): """View ticket details as admin.""" from app.models.ticket import TrainerTicket ticket = TrainerTicket.query.get_or_404(ticket_id) # Mark messages as read for admin view for msg in ticket.messages.filter_by(is_read=False): msg.is_read = True db.session.commit() return render_template("admin/ticket_detail.html", ticket=ticket) @admin_bp.route("/tickets//assign", methods=["POST"]) @admin_required def assign_ticket(ticket_id): """Assign or reassign ticket to a trainer.""" from app.models.ticket import TrainerTicket ticket = TrainerTicket.query.get_or_404(ticket_id) trainer_id = request.form.get("trainer_id") if trainer_id: trainer = User.query.get_or_404(trainer_id) ticket.trainer_id = trainer.id ticket.status = "in_progress" db.session.commit() flash(f"تم تعيين التذكرة للمدرب {trainer.name}", "success") else: flash("يجب اختيار مدرب", "error") return redirect(request.referrer or url_for("admin.ticket_detail", ticket_id=ticket_id)) @admin_bp.route("/users//set-role", methods=["POST"]) @admin_required def set_user_role(user_id): """Set user role (student, trainer, admin).""" user = User.query.get_or_404(user_id) new_role = request.form.get("role") if new_role in ["student", "trainer", "admin"]: user.role = new_role db.session.commit() flash(f"تم تغيير دور المستخدم إلى {new_role}", "success") else: flash("دور غير صحيح", "error") return redirect(request.referrer or url_for("admin.users")) # ═══════════════════════════════════════════════════════════════════════════════ # Activity Logs Routes # ═══════════════════════════════════════════════════════════════════════════════ @admin_bp.route("/activity-logs") @admin_required def activity_logs(): """View and filter activity logs.""" from app.models.features import AuditLog page = request.args.get("page", 1, type=int) q = request.args.get("q", "").strip() log_type = request.args.get("log_type", "").strip() status = request.args.get("status", "").strip() user_email = request.args.get("user_email", "").strip() query = AuditLog.query # Apply filters if q: query = query.filter(AuditLog.action.ilike(f"%{q}%")) if log_type: query = query.filter(AuditLog.log_type == log_type) if status: query = query.filter(AuditLog.status == status) if user_email: query = query.join(AuditLog.user).filter(User.email.ilike(f"%{user_email}%")) pagination = query.order_by(AuditLog.created_at.desc()).paginate( page=page, per_page=50, error_out=False ) # Get counts for stats total_count = query.count() login_count = AuditLog.query.filter(AuditLog.log_type == "login").count() transaction_count = AuditLog.query.filter(AuditLog.log_type == "transaction").count() failed_count = AuditLog.query.filter(AuditLog.status == "failed").count() return render_template("admin/activity_logs.html", pagination=pagination, q=q, log_type=log_type, status=status, user_email=user_email, total_count=total_count, login_count=login_count, transaction_count=transaction_count, failed_count=failed_count) @admin_bp.route("/activity-logs/export") @admin_required def export_activity_logs(): """Export activity logs to CSV.""" from app.models.features import AuditLog import csv from io import StringIO from flask import Response q = request.args.get("q", "").strip() log_type = request.args.get("log_type", "").strip() status = request.args.get("status", "").strip() user_email = request.args.get("user_email", "").strip() query = AuditLog.query if q: query = query.filter(AuditLog.action.ilike(f"%{q}%")) if log_type: query = query.filter(AuditLog.log_type == log_type) if status: query = query.filter(AuditLog.status == status) if user_email: query = query.join(AuditLog.user).filter(User.email.ilike(f"%{user_email}%")) logs = query.order_by(AuditLog.created_at.desc()).limit(10000).all() # Create CSV output = StringIO() writer = csv.writer(output) writer.writerow(["Time", "User", "Email", "Action", "Type", "Status", "IP", "User Agent", "Details"]) for log in logs: writer.writerow([ log.created_at.strftime("%Y-%m-%d %H:%M:%S"), log.user.name if log.user else "", log.user.email if log.user else "", log.action, log.log_type, log.status, log.ip_address or "", log.user_agent or "", str(log.details) if log.details else "" ]) output.seek(0) return Response( output.getvalue(), mimetype="text/csv", headers={"Content-Disposition": "attachment;filename=activity_logs.csv"} ) # ═══════════════════════════════════════════════════════════════════════════════ # Society Projects Admin Routes # ═══════════════════════════════════════════════════════════════════════════════ @admin_bp.route("/society-projects") @admin_required def society_projects(): """Manage society projects - view and approve submissions.""" from app.models.society import SocietyProject page = request.args.get("page", 1, type=int) status_filter = request.args.get("status", "") query = SocietyProject.query if status_filter: query = query.filter_by(status=status_filter) else: # Show pending first by default query = query.order_by( db.case(value=SocietyProject.status, whens={"pending": 1, "approved": 2, "published": 3, "rejected": 4}) ) pagination = query.order_by(SocietyProject.created_at.desc()).paginate( page=page, per_page=20, error_out=False ) # Get counts pending_count = SocietyProject.query.filter_by(status="pending").count() published_count = SocietyProject.query.filter_by(status="published").count() total_sponsors = SocietyProjectSponsor.query.filter_by(status="approved").count() return render_template("admin/society_projects.html", pagination=pagination, status_filter=status_filter, pending_count=pending_count, published_count=published_count, total_sponsors=total_sponsors) @admin_bp.route("/society-projects//review") @admin_required def review_society_project(project_id): """Review a society project submission.""" from app.models.society import SocietyProject project = SocietyProject.query.get_or_404(project_id) return render_template("admin/society_review.html", project=project) @admin_bp.route("/society-projects//approve", methods=["POST"]) @admin_required def approve_society_project(project_id): """Approve and publish a society project.""" from app.models.society import SocietyProject from datetime import datetime project = SocietyProject.query.get_or_404(project_id) project.status = "published" project.published_at = datetime.utcnow() db.session.commit() # Notify user from app.models.features import Notification notification = Notification( user_id=project.user_id, title="تم نشر مشروعك! 🎉", message=f"تمت الموافقة على مشروعك \"{project.title}\" وتم نشره في المجتمع.", category="society", link=url_for("society.detail", slug=project.slug) ) db.session.add(notification) db.session.commit() flash("تم نشر المشروع بنجاح", "success") return redirect(url_for("admin.society_projects")) @admin_bp.route("/society-projects//reject", methods=["POST"]) @admin_required def reject_society_project(project_id): """Reject a society project submission.""" from app.models.society import SocietyProject project = SocietyProject.query.get_or_404(project_id) reason = request.form.get("reason", "").strip() project.status = "rejected" db.session.commit() # Notify user from app.models.features import Notification notification = Notification( user_id=project.user_id, title="تم رفض مشروعك", message=f"عذراً، تم رفض مشروعك \"{project.title}\". {reason}", category="society" ) db.session.add(notification) db.session.commit() flash("تم رفض المشروع", "success") return redirect(url_for("admin.society_projects")) @admin_bp.route("/society-projects//edit", methods=["GET", "POST"]) @admin_required def edit_society_project(project_id): """Edit a society project.""" from app.models.society import SocietyProject project = SocietyProject.query.get_or_404(project_id) if request.method == "POST": project.title = request.form.get("title", project.title) project.title_ar = request.form.get("title_ar", project.title_ar) project.description = request.form.get("description", project.description) project.description_ar = request.form.get("description_ar", project.description_ar) project.content = request.form.get("content", project.content) project.video_url = request.form.get("video_url", project.video_url) project.cover_image = request.form.get("cover_image", project.cover_image) project.is_featured = "is_featured" in request.form # Update sponsorship tiers tiers = {} for tier_name in ["platinum", "gold", "silver", "bronze"]: min_amount = request.form.get(f"tier_{tier_name}_min", type=int) logo_size = request.form.get(f"tier_{tier_name}_logo", type=int) placement = request.form.get(f"tier_{tier_name}_placement", "") if min_amount and logo_size and placement: tiers[tier_name] = { "min": min_amount, "logo_size": logo_size, "placement": placement } if tiers: project.sponsorship_tiers = tiers db.session.commit() flash("تم تحديث المشروع بنجاح", "success") return redirect(url_for("admin.review_society_project", project_id=project_id)) return render_template("admin/society_project_edit.html", project=project) @admin_bp.route("/society-projects//sponsors") @admin_required def project_sponsors(project_id): """Manage sponsors for a society project.""" from app.models.society import SocietyProject, SocietyProjectSponsor project = SocietyProject.query.get_or_404(project_id) pending_sponsors = SocietyProjectSponsor.query.filter_by( project_id=project_id, status="pending" ).all() approved_sponsors = SocietyProjectSponsor.query.filter_by( project_id=project_id, status="approved" ).all() return render_template("admin/society_sponsors.html", project=project, pending_sponsors=pending_sponsors, approved_sponsors=approved_sponsors) @admin_bp.route("/society-sponsors//approve", methods=["POST"]) @admin_required def approve_sponsor(sponsor_id): """Approve a sponsorship request.""" from app.models.society import SocietyProjectSponsor from datetime import datetime sponsor = SocietyProjectSponsor.query.get_or_404(sponsor_id) sponsor.status = "approved" sponsor.approved_at = datetime.utcnow() db.session.commit() # Notify sponsor from app.models.features import Notification notification = Notification( user_id=sponsor.sponsor_id, title="تم قبول طلب الرعاية! 🎉", message=f"تم قبول طلب رعايتك لمشروع \"{sponsor.project.title}\".", category="society", link=url_for("society.detail", slug=sponsor.project.slug) ) db.session.add(notification) db.session.commit() flash("تم قبول الرعاية بنجاح", "success") return redirect(request.referrer or url_for("admin.project_sponsors", project_id=sponsor.project_id)) @admin_bp.route("/society-sponsors//reject", methods=["POST"]) @admin_required def reject_sponsor(sponsor_id): """Reject a sponsorship request.""" from app.models.society import SocietyProjectSponsor sponsor = SocietyProjectSponsor.query.get_or_404(sponsor_id) sponsor.status = "rejected" db.session.commit() # Notify sponsor from app.models.features import Notification notification = Notification( user_id=sponsor.sponsor_id, title="تم رفض طلب الرعاية", message=f"عذراً، تم رفض طلب رعايتك لمشروع \"{sponsor.project.title}\".", category="society" ) db.session.add(notification) db.session.commit() flash("تم رفض الرعاية", "success") return redirect(request.referrer or url_for("admin.project_sponsors", project_id=sponsor.project_id)) @admin_bp.route("/society-projects//feature", methods=["POST"]) @admin_required def toggle_feature_project(project_id): """Toggle featured status of a project.""" from app.models.society import SocietyProject project = SocietyProject.query.get_or_404(project_id) project.is_featured = not project.is_featured db.session.commit() return jsonify({"featured": project.is_featured}) # ═══════════════════════════════════════════════════════════════════════════════ # Organization Management Routes # ═══════════════════════════════════════════════════════════════════════════════ @admin_bp.route("/organizations") @admin_required def organizations(): """List all organizations with search and pagination.""" from app.models.organization import Organization page = request.args.get("page", 1, type=int) q = request.args.get("q", "").strip() status_filter = request.args.get("status", "all") # active, inactive, all query = Organization.query.filter(Organization.deleted_at == None) if q: query = query.filter( Organization.name.ilike(f"%{q}%") | Organization.name_ar.ilike(f"%{q}%") | Organization.email.ilike(f"%{q}%") ) if status_filter == "active": query = query.filter(Organization.is_active == True) elif status_filter == "inactive": query = query.filter(Organization.is_active == False) pagination = query.order_by(Organization.created_at.desc()).paginate( page=page, per_page=20, error_out=False ) return render_template("admin/organizations.html", pagination=pagination, q=q, status_filter=status_filter) @admin_bp.route("/organizations/create", methods=["GET", "POST"]) @admin_required def create_organization(): """Create a new organization.""" from app.models.organization import Organization from app.utils.uploads import upload_logo if request.method == "POST": name = request.form.get("name", "").strip() name_ar = request.form.get("name_ar", "").strip() or None description = request.form.get("description", "").strip() or None description_ar = request.form.get("description_ar", "").strip() or None org_type = request.form.get("org_type", "company") website_url = request.form.get("website_url", "").strip() or None email = request.form.get("email", "").strip() or None phone = request.form.get("phone", "").strip() or None address = request.form.get("address", "").strip() or None city = request.form.get("city", "").strip() or None country = request.form.get("country", "").strip() or None sponsor_tier = request.form.get("sponsor_tier", "").strip() or None is_active = request.form.get("is_active") == "1" is_verified = request.form.get("is_verified") == "1" if not name: flash("الاسم مطلوب", "error") return redirect(url_for("admin.create_organization")) org = Organization( name=name, name_ar=name_ar, description=description, description_ar=description_ar, org_type=org_type, website_url=website_url, email=email, phone=phone, address=address, city=city, country=country, sponsor_tier=sponsor_tier, is_active=is_active, is_verified=is_verified, ) # Generate slug org.slug = org.generate_slug() # Handle logo upload if 'logo' in request.files: logo = request.files['logo'] if logo and logo.filename: logo_url = upload_logo(logo) if logo_url: org.logo_url = logo_url db.session.add(org) db.session.commit() flash("تم إنشاء المنظمة بنجاح", "success") return redirect(url_for("admin.organizations")) return render_template("admin/organization_form.html", org=None) @admin_bp.route("/organizations//edit", methods=["GET", "POST"]) @admin_required def edit_organization(org_id): """Edit an existing organization.""" from app.models.organization import Organization from app.utils.uploads import upload_logo, delete_file org = Organization.query.get_or_404(org_id) if request.method == "POST": old_logo = org.logo_url org.name = request.form.get("name", "").strip() org.name_ar = request.form.get("name_ar", "").strip() or None org.description = request.form.get("description", "").strip() or None org.description_ar = request.form.get("description_ar", "").strip() or None org.org_type = request.form.get("org_type", "company") org.website_url = request.form.get("website_url", "").strip() or None org.email = request.form.get("email", "").strip() or None org.phone = request.form.get("phone", "").strip() or None org.address = request.form.get("address", "").strip() or None org.city = request.form.get("city", "").strip() or None org.country = request.form.get("country", "").strip() or None org.sponsor_tier = request.form.get("sponsor_tier", "").strip() or None org.is_active = request.form.get("is_active") == "1" org.is_verified = request.form.get("is_verified") == "1" # Regenerate slug if name changed new_slug = org.generate_slug() if new_slug != org.slug: org.slug = new_slug # Handle logo upload if 'logo' in request.files: logo = request.files['logo'] if logo and logo.filename: logo_url = upload_logo(logo) if logo_url: org.logo_url = logo_url # Delete old logo if exists if old_logo: delete_file(old_logo) # Handle logo deletion if request.form.get("delete_logo") == "1": if org.logo_url: delete_file(org.logo_url) org.logo_url = None db.session.commit() flash("تم تحديث المنظمة بنجاح", "success") return redirect(url_for("admin.organizations")) return render_template("admin/organization_form.html", org=org) @admin_bp.route("/organizations//delete", methods=["POST"]) @admin_required def delete_organization(org_id): """Soft delete an organization.""" from datetime import datetime from app.models.organization import Organization org = Organization.query.get_or_404(org_id) # Check if organization has users if len(org.users) > 0: flash(f"لا يمكن حذف المنظمة {org.name} لأنها تحتوي على {len(org.users)} مستخدم", "error") return redirect(url_for("admin.organizations")) # Soft delete org.deleted_at = datetime.utcnow() org.is_active = False db.session.commit() flash("تم حذف المنظمة بنجاح", "success") return redirect(url_for("admin.organizations")) @admin_bp.route("/organizations//toggle-status", methods=["POST"]) @admin_required def toggle_organization_status(org_id): """Toggle organization active status.""" from app.models.organization import Organization org = Organization.query.get_or_404(org_id) org.is_active = not org.is_active db.session.commit() status = "مفعّل" if org.is_active else "معطّل" flash(f"تم {status} المنظمة {org.name}", "success") return redirect(request.referrer or url_for("admin.organizations")) # ═══════════════════════════════════════════════════════════════════════════════ # Sponsor Management Routes # ═══════════════════════════════════════════════════════════════════════════════ @admin_bp.route("/sponsors") @admin_required def sponsors(): """List all sponsor profiles with filtering.""" from app.models.organization import SponsorProfile, Organization page = request.args.get("page", 1, type=int) q = request.args.get("q", "").strip() status_filter = request.args.get("status", "all") query = db.session.query(SponsorProfile, Organization).join( Organization, SponsorProfile.organization_id == Organization.id ) if q: query = query.filter(Organization.name.ilike(f"%{q}%") | Organization.name_ar.ilike(f"%{q}%")) if status_filter == "pending": query = query.filter(SponsorProfile.status == "pending") elif status_filter == "approved": query = query.filter(SponsorProfile.status == "approved") elif status_filter == "rejected": query = query.filter(SponsorProfile.status == "rejected") elif status_filter == "inactive": query = query.filter(SponsorProfile.status == "inactive") pagination = query.order_by(SponsorProfile.created_at.desc()).paginate( page=page, per_page=20, error_out=False ) return render_template("admin/sponsors.html", pagination=pagination, q=q, status_filter=status_filter) @admin_bp.route("/sponsors/create", methods=["GET", "POST"]) @admin_required def create_sponsor(): """Create a new sponsor profile.""" from app.models.organization import SponsorProfile, Organization from app.utils.uploads import upload_logo organizations = Organization.query.filter( Organization.deleted_at == None, Organization.is_active == True ).order_by(Organization.name).all() if request.method == "POST": organization_id = request.form.get("organization_id", type=int) user_id = request.form.get("user_id", type=int) or None logo_url = request.form.get("logo_url", "").strip() or None website_url = request.form.get("website_url", "").strip() or None tagline = request.form.get("tagline", "").strip() or None tagline_ar = request.form.get("tagline_ar", "").strip() or None tier = request.form.get("tier", "bronze") monthly_contribution = request.form.get("monthly_contribution") or None display_on_landing = request.form.get("display_on_landing") == "1" display_order = request.form.get("display_order", 0, type=int) notes = request.form.get("notes", "").strip() or None if not organization_id: flash("يجب اختيار منظمة", "error") return redirect(url_for("admin.create_sponsor")) org = Organization.query.get_or_404(organization_id) sponsor = SponsorProfile( organization_id=organization_id, user_id=user_id, logo_url=logo_url, website_url=website_url, tagline=tagline, tagline_ar=tagline_ar, tier=tier, monthly_contribution=monthly_contribution, display_on_landing=display_on_landing, display_order=display_order, notes=notes, ) # Handle logo upload if 'logo' in request.files: logo = request.files['logo'] if logo and logo.filename: uploaded_url = upload_logo(logo) if uploaded_url: sponsor.logo_url = uploaded_url db.session.add(sponsor) db.session.commit() flash("تم إنشاء ملف الراعي بنجاح", "success") return redirect(url_for("admin.sponsors")) return render_template("admin/sponsor_form.html", organizations=organizations, sponsor=None) @admin_bp.route("/sponsors//edit", methods=["GET", "POST"]) @admin_required def edit_sponsor(sponsor_id): """Edit an existing sponsor profile.""" from app.models.organization import SponsorProfile, Organization from app.utils.uploads import upload_logo, delete_file sponsor = SponsorProfile.query.get_or_404(sponsor_id) organizations = Organization.query.filter( Organization.deleted_at == None, Organization.is_active == True ).order_by(Organization.name).all() if request.method == "POST": old_logo = sponsor.logo_url sponsor.organization_id = request.form.get("organization_id", type=int) sponsor.user_id = request.form.get("user_id", type=int) or None sponsor.website_url = request.form.get("website_url", "").strip() or None sponsor.tagline = request.form.get("tagline", "").strip() or None sponsor.tagline_ar = request.form.get("tagline_ar", "").strip() or None sponsor.tier = request.form.get("tier", "bronze") sponsor.monthly_contribution = request.form.get("monthly_contribution") or None sponsor.display_on_landing = request.form.get("display_on_landing") == "1" sponsor.display_order = request.form.get("display_order", 0, type=int) sponsor.notes = request.form.get("notes", "").strip() or None # Handle logo upload if 'logo' in request.files: logo = request.files['logo'] if logo and logo.filename: uploaded_url = upload_logo(logo) if uploaded_url: sponsor.logo_url = uploaded_url # Delete old logo if exists if old_logo: delete_file(old_logo) # Handle logo deletion if request.form.get("delete_logo") == "1": if sponsor.logo_url: delete_file(sponsor.logo_url) sponsor.logo_url = None db.session.commit() flash("تم تحديث ملف الراعي بنجاح", "success") return redirect(url_for("admin.sponsors")) return render_template("admin/sponsor_form.html", organizations=organizations, sponsor=sponsor) @admin_bp.route("/sponsors//approve", methods=["POST"]) @admin_required def approve_org_sponsor(sponsor_id): """Approve a sponsor profile.""" from datetime import datetime from app.models.organization import SponsorProfile sponsor = SponsorProfile.query.get_or_404(sponsor_id) sponsor.status = "approved" sponsor.approved_at = datetime.utcnow() sponsor.rejected_at = None db.session.commit() # Notify sponsor user if exists if sponsor.user: from app.models.features import Notification notification = Notification( user_id=sponsor.user_id, title="تم قبول طلب الرعاية! 🎉", message=f"تم قبول طلب رعايتك لمنظمة {sponsor.organization.name}.", category="sponsor", link=url_for("auth.profile") ) db.session.add(notification) db.session.commit() flash(f"تم قبول راعي {sponsor.organization.name}", "success") return redirect(request.referrer or url_for("admin.sponsors")) @admin_bp.route("/sponsors//reject", methods=["POST"]) @admin_required def reject_org_sponsor(sponsor_id): """Reject a sponsor profile.""" from datetime import datetime from app.models.organization import SponsorProfile sponsor = SponsorProfile.query.get_or_404(sponsor_id) sponsor.status = "rejected" sponsor.rejected_at = datetime.utcnow() sponsor.display_on_landing = False db.session.commit() # Notify sponsor user if exists if sponsor.user: from app.models.features import Notification notification = Notification( user_id=sponsor.user_id, title="تم رفض طلب الرعاية", message=f"عذراً، تم رفض طلب رعايتك لمنظمة {sponsor.organization.name}.", category="sponsor", link=url_for("auth.profile") ) db.session.add(notification) db.session.commit() flash(f"تم رفض راعي {sponsor.organization.name}", "success") return redirect(request.referrer or url_for("admin.sponsors")) @admin_bp.route("/sponsors//delete", methods=["POST"]) @admin_required def delete_sponsor(sponsor_id): """Delete a sponsor profile.""" from app.models.organization import SponsorProfile sponsor = SponsorProfile.query.get_or_404(sponsor_id) org_name = sponsor.organization.name # Delete logo if exists if sponsor.logo_url: from app.utils.uploads import delete_file delete_file(sponsor.logo_url) db.session.delete(sponsor) db.session.commit() flash(f"تم حذف راعي {org_name}", "success") return redirect(url_for("admin.sponsors")) @admin_bp.route("/sponsors//toggle-display", methods=["POST"]) @admin_required def toggle_sponsor_display(sponsor_id): """Toggle sponsor display on landing page.""" from app.models.organization import SponsorProfile sponsor = SponsorProfile.query.get_or_404(sponsor_id) if sponsor.status != "approved": flash("يمكن فقط إظهار الرعاة المقبولين", "error") return redirect(request.referrer or url_for("admin.sponsors")) sponsor.display_on_landing = not sponsor.display_on_landing db.session.commit() status = "مفعّل" if sponsor.display_on_landing else "معطّل" flash(f"تم {status} عرض الراعي على الصفحة الرئيسية", "success") return redirect(request.referrer or url_for("admin.sponsors")) # ============================================================================ # NotebookLM Admin Account Management Routes # ============================================================================ @admin_bp.route("/nlm-accounts", methods=["GET"]) @login_required def nlm_accounts(): """Manage NotebookLM admin accounts.""" if not current_user.is_admin: flash("غير مصرح لك بالوصول إلى هذه الصفحة", "error") return redirect(url_for("main.index")) from app.ai.nlm_admin_service import get_account_usage_stats stats = get_account_usage_stats() return render_template("admin/nlm_accounts.html", **stats) @admin_bp.route("/nlm-accounts/add", methods=["POST"]) @csrf.exempt @login_required def nlm_account_add(): """Add a new NotebookLM admin account.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import add_admin_account import json from werkzeug.utils import secure_filename # Check if this is a file upload or JSON data if 'session_file' in request.files: # Handle file upload file = request.files['session_file'] name = request.form.get('name', '').strip() google_email = request.form.get('google_email', '').strip() if not name or not google_email: return jsonify({"error": "Name and email are required"}), 400 if file and file.filename: filename = secure_filename(file.filename) if not filename.endswith('.json'): return jsonify({"error": "Session file must be a JSON file"}), 400 # Save the file to a secure location upload_dir = os.path.join(current_app.root_path, '../nlm_sessions') os.makedirs(upload_dir, exist_ok=True) # Create a unique filename import uuid unique_filename = f"{uuid.uuid4().hex}_{filename}" session_path = os.path.join(upload_dir, unique_filename) file.save(session_path) account = add_admin_account( name=name, google_email=google_email, session_path=session_path, created_by_id=current_user.id ) if account: return jsonify({ "status": "success", "account": account.to_dict() }) else: return jsonify({"error": "Failed to create account"}), 500 else: return jsonify({"error": "Invalid file"}), 400 else: # Handle JSON data data = request.get_json(silent=True) if not data: return jsonify({"error": "Invalid JSON data"}), 400 name = (data.get("name") or "").strip() google_email = (data.get("google_email") or "").strip() session_path = (data.get("session_path") or "").strip() or None if not name or not google_email: return jsonify({"error": "Name and email are required"}), 400 account = add_admin_account( name=name, google_email=google_email, session_path=session_path, created_by_id=current_user.id ) if account: return jsonify({ "status": "success", "account": account.to_dict() }) else: return jsonify({"error": "Failed to create account"}), 500 except Exception as e: current_app.logger.error(f"Error adding NLM account: {e}") import traceback current_app.logger.error(traceback.format_exc()) return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts//edit", methods=["POST"]) @csrf.exempt @login_required def nlm_account_edit(account_id): """Edit a NotebookLM admin account.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import update_admin_account data = request.get_json() updates = {} if "name" in data: updates["name"] = data["name"].strip() if "google_email" in data: updates["google_email"] = data["google_email"].strip() if "priority" in data: updates["priority"] = int(data["priority"]) if "is_active" in data: updates["is_active"] = bool(data["is_active"]) account = update_admin_account(account_id, **updates) if account: return jsonify({ "status": "success", "account": account.to_dict() }) else: return jsonify({"error": "Account not found"}), 404 except Exception as e: current_app.logger.error(f"Error updating NLM account: {e}") return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts//delete", methods=["POST"]) @csrf.exempt @login_required def nlm_account_delete(account_id): """Delete a NotebookLM admin account.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import delete_admin_account success = delete_admin_account(account_id) if success: return jsonify({"status": "success"}) else: return jsonify({"error": "Account not found"}), 404 except Exception as e: current_app.logger.error(f"Error deleting NLM account: {e}") return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts//upload-session", methods=["POST"]) @csrf.exempt @login_required def nlm_account_upload_session(account_id): """Upload a new session file for an existing NotebookLM admin account.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import get_admin_account, update_admin_account from werkzeug.utils import secure_filename if 'session_file' not in request.files: return jsonify({"error": "No file uploaded"}), 400 file = request.files['session_file'] if file.filename == '': return jsonify({"error": "No file selected"}), 400 if not file.filename.endswith('.json'): return jsonify({"error": "Session file must be a JSON file"}), 400 # Get the account account = get_admin_account(account_id) if not account: return jsonify({"error": "Account not found"}), 404 # Create account-specific directory account_dir = os.path.join(current_app.root_path, f'../nlm_sessions/account_{account_id}') os.makedirs(account_dir, exist_ok=True) # Save as storage_state.json (notebooklm library expects exactly this name) session_path = os.path.join(account_dir, "storage_state.json") file.save(session_path) # Delete old session file if exists if account.session_path and os.path.exists(account.session_path): try: os.remove(account.session_path) except: pass # Update the account with new session path update_admin_account(account_id, session_path=session_path, is_healthy=True, error_message=None) return jsonify({ "status": "success", "message": "تم رفع ملف الجلسة بنجاح", "session_path": session_path, "notebooklm_home": account_dir }) except Exception as e: current_app.logger.error(f"Error uploading session file: {e}") import traceback current_app.logger.error(traceback.format_exc()) return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts//health-check", methods=["POST"]) @csrf.exempt @login_required def nlm_account_health_check(account_id): """Check health of a specific NotebookLM admin account.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import check_account_health, get_admin_account is_healthy = check_account_health(account_id) account = get_admin_account(account_id) return jsonify({ "status": "success", "is_healthy": is_healthy, "account": account.to_dict() if account else None }) except Exception as e: current_app.logger.error(f"Error checking NLM account health: {e}") return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts/health-check-all", methods=["POST"]) @csrf.exempt @login_required def nlm_accounts_health_check_all(): """Check health of all NotebookLM admin accounts.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import check_all_accounts_health, get_account_usage_stats results = check_all_accounts_health() stats = get_account_usage_stats() return jsonify({ "status": "success", "results": results, "stats": stats }) except Exception as e: current_app.logger.error(f"Error checking all NLM accounts: {e}") return jsonify({"error": str(e)}), 500 @admin_bp.route("/nlm-accounts//authenticate", methods=["POST"]) @csrf.exempt @login_required def nlm_account_authenticate(account_id): """Trigger browser authentication for an admin account using notebooklm CLI.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 import subprocess import os try: from app.ai.nlm_admin_service import get_admin_account, get_admin_storage_path, update_admin_account account = get_admin_account(account_id) if not account: return jsonify({"error": "Account not found"}), 404 # Set custom NOTEBOOKLM_HOME for this account account_dir = f"/data/nlm_admin_{account_id}" os.makedirs(account_dir, exist_ok=True) env = os.environ.copy() env["NOTEBOOKLM_HOME"] = account_dir # Check if DISPLAY is set, if not start Xvfb display = env.get("DISPLAY", ":99") if not os.path.exists(f"/tmp/.X11-unix/X{display.split(':')[-1]}"): try: subprocess.Popen( ["Xvfb", display, "-screen", "0", "1280x720x24", "-ac"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) import time time.sleep(1) except: pass env["DISPLAY"] = display # Run notebooklm login try: result = subprocess.run( ["notebooklm", "login"], env=env, timeout=300, capture_output=True, text=True ) # Update account with new session path storage_path = os.path.join(account_dir, "storage_state.json") if os.path.exists(storage_path): update_admin_account( account_id, session_path=storage_path, is_healthy=True, error_message=None ) return jsonify({ "status": "success", "message": "تمت المصادقة بنجاح" }) else: return jsonify({ "error": "authentication_failed", "message": "لم يتم إنشاء ملف الجلسة. يرجى رفع ملف storage_state.json يدوياً." }), 500 except subprocess.TimeoutExpired: return jsonify({ "error": "timeout", "message": "انتهت مهلة المصادقة (5 دقائق). يرجى المحاولة مرة أخرى أو رفع ملف الجلسة يدوياً." }), 500 except Exception as e: current_app.logger.error(f"Error authenticating NLM account: {e}") import traceback current_app.logger.error(traceback.format_exc()) return jsonify({"error": str(e)}), 500 @admin_bp.route("/api/nlm-accounts", methods=["GET"]) @login_required def api_nlm_accounts(): """Get all NotebookLM admin accounts as JSON.""" if not current_user.is_admin: return jsonify({"error": "Unauthorized"}), 403 try: from app.ai.nlm_admin_service import get_account_usage_stats stats = get_account_usage_stats() return jsonify(stats) except Exception as e: current_app.logger.error(f"Error getting NLM accounts: {e}") return jsonify({"error": str(e)}), 500