# -*- coding: utf-8 -*- from flask import Flask, request, redirect, send_from_directory, make_response, Response, send_file from werkzeug.utils import secure_filename import os import time import sys import re import shutil import py_compile import threading import html as html_lib import glob import zipfile import subprocess import ipaddress import json import urllib.request import urllib.parse import uuid app = Flask(__name__) ADMIN_PANEL_VERSION = "TripServer Admin v34.24 Netlify export builder verified" ADMIN_STARTED_AT = time.strftime("%Y-%m-%d %H:%M:%S") BASE_DIR = r"C:\TripServer" ADMIN_HOST = "0.0.0.0" ADMIN_PORT = 8000 CONTROL_PORT = 8010 CONTROL_DIR = os.path.join(BASE_DIR, "control_server") CONTROL_SCRIPT_PATH = os.path.join(CONTROL_DIR, "tripserver_control_server.py") CONTROL_PENDING_ADMIN_PATH = os.path.join(CONTROL_DIR, "pending_admin_server.py") CONTROL_REQUEST_PATH = os.path.join(CONTROL_DIR, "request.json") CONTROL_STATUS_PATH = os.path.join(CONTROL_DIR, "status.json") CONTROL_LOG_PATH = os.path.join(CONTROL_DIR, "tripserver_control_server.log") CONTROL_BOOTSTRAP_LOG_PATH = os.path.join(BASE_DIR, "tripserver_control_bootstrap.log") CONTROL_TASK_NAME = "TripServerControlServer" ADMIN_FAILSAFE_STATUS_PATH = os.path.join(BASE_DIR, "admin_failsafe_status.json") PRESENTATION_MUSIC_UPLOAD_STATUS_PATH = os.path.join(BASE_DIR, "presentation_music_upload_status.json") PENDING_MUSIC_UPLOAD_DIR = os.path.join(BASE_DIR, "tmp", "pending_music_uploads") # Local File Manager roots are discovered at runtime on the Windows server. # Access is intentionally limited to discovered Downloads folders and TripServer folders. LOCAL_FILE_ROOTS_CACHE = None LOCAL_FILE_ROOTS_CACHE_TS = 0 LOCAL_FILE_ALLOWED_ROOT_NAMES = {"downloads", "tripserver"} LOCAL_FILE_TEXT_EXTENSIONS = {".txt", ".log", ".json", ".md", ".py", ".html", ".htm", ".css", ".js", ".csv", ".bat", ".ps1", ".xml"} LOCAL_FILE_PREVIEW_MAX_BYTES = 1024 * 1024 LOCAL_FILE_ZIP_MAX_BYTES = 120 * 1024 * 1024 LOCAL_FILE_LIST_LIMIT = 700 FOLDERS = { "JAPAN": os.path.join(BASE_DIR, "JAPAN"), "USA": os.path.join(BASE_DIR, "USA"), "Moneyapp": os.path.join(BASE_DIR, "Moneyapp"), "MoneyHome": os.path.join(BASE_DIR, "MoneyHome"), "TripForm": os.path.join(BASE_DIR, "TripForm"), } APP_FOLDERS = {"JAPAN", "USA", "Moneyapp", "MoneyHome", "TripForm"} # Netlify export builder. # Uses the same current trip files that the admin panel serves from C:\TripServer\JAPAN and C:\TripServer\USA. # The generated ZIP is rewritten only for deployment paths: budget app URL and presentation launch URL. NETLIFY_BUDGET_APP_URL = "https://beautiful-kitsune-dafd66.netlify.app/" NETLIFY_EXPORT_DIR = os.path.join(BASE_DIR, "tmp", "netlify_exports") NETLIFY_BUILD_DIR = os.path.join(BASE_DIR, "tmp", "netlify_build") NETLIFY_STATIC_EXTENSIONS = { ".html", ".htm", ".css", ".js", ".json", ".txt", ".md", ".svg", ".xml", ".map", ".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".ico", ".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg", ".opus", ".wma", ".webm", ".mp4", ".woff", ".woff2", ".ttf" } NETLIFY_SKIP_DIRS = {"__pycache__", ".git", ".svn", ".hg", "backups", "backup", "tmp", "temp", "node_modules"} NETLIFY_SKIP_FILES = {"thumbs.db", ".ds_store", "desktop.ini"} NETLIFY_CONTROL_FILES = {"_redirects", "_headers"} JAPAN_PRESENTATION_FILES = { "flight_intro": "japan-flight-intro.html", "japan_experience": "japan-experience.html", } USA_PRESENTATION_FILES = { "usa_presentation": "usa2027-presentation.html", "usa_presentation_tv": "usa2027-presentation-tv.html", } USA_EXTRA_HTML_FILES = { "usa_trip_tv": "usa2027-tv.html", } USA_MUSIC_FILES = { "usa_music": os.path.join("media", "usa-presentation", "music", "usa-roadtrip-theme.mp3"), "usa_music_part2": os.path.join("media", "usa-presentation", "music", "usa-part2-theme.mp3"), } USA_IMAGE_KEYS = ({"intro", "budget", "roadtrip-map", "summary", "extra-big-sur", "extra-diner", "extra-death-valley", "extra-mono-lake"} | {f"day-{i:02d}" for i in range(1, 37)}) USA_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"} USA_IMAGE_TARGETS = { "phone": { "label": "מסך פלאפון", "description": "מצגת ארה״ב למסכי אייפון/אנדרואיד", "folder": os.path.join("media", "usa-presentation", "images"), "rel_prefix": "media/usa-presentation/images", "presentation_key": "usa_presentation", "backup_tag": "USA_images_phone", }, "tv": { "label": "מסך טלוויזיה", "description": "מצגת ארה״ב למסך TV / LG C3 77 4K", "folder": os.path.join("media", "usa-presentation", "images-tv"), "rel_prefix": "media/usa-presentation/images-tv", "presentation_key": "usa_presentation_tv", "backup_tag": "USA_images_tv", }, } JAPAN_MUSIC_TARGETS = { # The Japan experience presentation contains several fallback paths. Keep all aliases synced. "japan_experience_music": [ os.path.join("media", "japan-experience", "music", "japan-theme.mp3"), os.path.join("media", "music", "japan-theme.mp3"), "japan-theme.mp3", ], "japan_flight_music": [ os.path.join("media", "japan-flight", "music", "flight-intro.mp3"), ], } # Presentation music sync rules. # v34.14 keeps existing music upload routes as the single source of truth. # Music buttons in the UI now upload the file, measure it, and synchronize the relevant presentation section. # Japan main song syncs all japan-experience slides. USA part 1/2 sync only their own PART_*_SECONDS values. PRESENTATION_MUSIC_SYNC_RULES = { "japan_experience_music": { "label": "יפן קיץ 26 — שיר מצגת ראשית", "trip": "JAPAN", "presentation": "japan-experience.html", "music_targets": JAPAN_MUSIC_TARGETS["japan_experience_music"], "scope": "כל שקפי מצגת יפן", "future_behavior": "פעיל כעת: העלאת שיר מצגת יפן מודדת את האורך לפני הטמעה. אם ממוצע השקף יוצא מתחת ל־5 שניות או מעל ל־10 שניות, מוצג מסך אישור לפני שמירת השיר וסנכרון המצגת.", "enabled_now": True, }, "japan_flight_music": { "label": "יפן קיץ 26 — מוזיקת פתיח טיסה", "trip": "JAPAN", "presentation": "japan-flight-intro.html", "music_targets": JAPAN_MUSIC_TARGETS["japan_flight_music"], "scope": "פתיח הטיסה בלבד", "future_behavior": "העלאת שיר תישמר לפתיח הטיסה בלבד; לא מסנכרנת את מצגת יפן הראשית.", "enabled_now": False, }, "usa_music_part1": { "label": "ארצות הברית קיץ 27 — שיר חלק 1", "trip": "USA", "presentation": "usa2027-presentation.html / usa2027-presentation-tv.html", "music_targets": [USA_MUSIC_FILES["usa_music"]], "scope": "שקפים 1–23 בלבד", "future_behavior": "פעיל כעת: העלאת שיר חלק 1 מסנכרנת רק את מקטע 1 ולא משנה את מקטע 2.", "enabled_now": True, }, "usa_music_part2": { "label": "ארצות הברית קיץ 27 — שיר חלק 2", "trip": "USA", "presentation": "usa2027-presentation.html / usa2027-presentation-tv.html", "music_targets": [USA_MUSIC_FILES["usa_music_part2"]], "scope": "שקפים 24–44 בלבד", "future_behavior": "פעיל כעת: העלאת שיר חלק 2 מסנכרנת רק את מקטע 2 ולא משנה את מקטע 1.", "enabled_now": True, }, } # Japan main presentation music timing guardrails. # The uploaded file is first converted into a temporary pending MP3, measured, and only then embedded. # If the detected song length would create an average slide duration outside this range, the admin asks for confirmation. JAPAN_EXPERIENCE_MIN_AVG_SLIDE_SECONDS = 5.0 JAPAN_EXPERIENCE_MAX_AVG_SLIDE_SECONDS = 10.0 JAPAN_EXPERIENCE_LOOP_MIN_SLIDE_SECONDS = 5.0 PENDING_MUSIC_MAX_AGE_SECONDS = 60 * 60 AUDIO_UPLOAD_EXTENSIONS = {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg", ".opus", ".wma", ".webm", ".mp4"} JAPAN_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff"} JAPAN_IMAGES_ZIP_MAX_BYTES = 130 * 1024 * 1024 JAPAN_IMAGES_ZIP_MAX_FILES = 220 JAPAN_IMAGES_ZIP_MAX_UNCOMPRESSED_BYTES = 220 * 1024 * 1024 JAPAN_IMAGES_ZIP_MAX_SINGLE_FILE_BYTES = 18 * 1024 * 1024 TRIP_PACKAGE_ZIP_MAX_BYTES = 180 * 1024 * 1024 TRIP_PACKAGE_ZIP_MAX_FILES = 320 TRIP_PACKAGE_ZIP_MAX_UNCOMPRESSED_BYTES = 260 * 1024 * 1024 TRIP_PACKAGE_ZIP_MAX_SINGLE_FILE_BYTES = 35 * 1024 * 1024 TRIP_PACKAGE_EXTENSIONS = {".html", ".htm", ".jpg", ".jpeg", ".png", ".webp", ".mp3", ".css", ".js", ".json", ".txt", ".svg"} ADMIN_SERVER_PATH = os.path.abspath(__file__) ADMIN_BACKUP_DIR = os.path.join(BASE_DIR, "backups", "admin_server") ADMIN_UPLOAD_TMP_DIR = os.path.join(BASE_DIR, "tmp", "admin_server_uploads") ADMIN_MAX_UPLOAD_BYTES = 2 * 1024 * 1024 ADMIN_MAX_PACKAGE_UPLOAD_BYTES = 8 * 1024 * 1024 USA_IMAGES_ZIP_MAX_BYTES = 80 * 1024 * 1024 USA_IMAGES_ZIP_MAX_FILES = 160 USA_IMAGES_ZIP_MAX_UNCOMPRESSED_BYTES = 140 * 1024 * 1024 USA_IMAGES_ZIP_MAX_SINGLE_FILE_BYTES = 12 * 1024 * 1024 ADMIN_RESTART_CMD_PATH = os.path.join(BASE_DIR, "restart_admin_server.cmd") ADMIN_RESTART_LOG_PATH = os.path.join(BASE_DIR, "admin_restart.log") ADMIN_RESTART_HELPER_PATH = os.path.join(BASE_DIR, "restart_admin_server_helper.py") UPLOAD_BACKUP_DIR = os.path.join(BASE_DIR, "backups", "uploaded_files") # External watchdog. This is intentionally separate from the Flask process: if the admin # server is down, Windows Task Scheduler can still run this script every minute and bring # the admin back without walking to the physical computer. WATCHDOG_TASK_NAME = os.environ.get("TRIPSERVER_WATCHDOG_TASK", "TripServerAdminWatchdog") WATCHDOG_SCRIPT_PATH = os.path.join(BASE_DIR, "tripserver_admin_watchdog.py") WATCHDOG_LOG_PATH = os.path.join(BASE_DIR, "tripserver_watchdog.log") WATCHDOG_STATE_PATH = os.path.join(BASE_DIR, "tripserver_watchdog_state.txt") WATCHDOG_INTERVAL_MINUTES = int(os.environ.get("TRIPSERVER_WATCHDOG_INTERVAL_MINUTES", "5")) WATCHDOG_MIN_RESTART_INTERVAL_SECONDS = int(os.environ.get("TRIPSERVER_WATCHDOG_RESTART_COOLDOWN", "90")) # v27: self-update/restart is launched through Windows Task Scheduler, not as a # direct child of the running Flask process. This prevents the old admin process # from killing the helper that is supposed to bring the new admin back online. RESTART_TASK_NAME = os.environ.get("TRIPSERVER_RESTART_TASK", "TripServerAdminRestartOnce") def get_pythonw_executable(preferred=None): """Return a no-console Python executable for Windows scheduled tasks when available. Running the watchdog every few minutes with python.exe can flash a black console window and steal focus. pythonw.exe runs the same script without a console. On non-Windows or if pythonw.exe is not available, fall back to the normal interpreter. """ exe = preferred or sys.executable or "python" if os.name != "nt": return exe try: base = os.path.basename(exe).lower() folder = os.path.dirname(exe) if base == "pythonw.exe" and os.path.exists(exe): return exe if folder: candidate = os.path.join(folder, "pythonw.exe") if os.path.exists(candidate): return candidate # Last-resort common launcher name. Do not validate here because it may be in PATH. return "pythonw.exe" except Exception: return exe # Admin log viewer. Only these fixed paths are exposed in the UI; user-supplied paths are never accepted. LOG_FILE_REGISTRY = { "restart": {"label": "לוג אתחול פאנל", "path": ADMIN_RESTART_LOG_PATH, "note": "Restart helper, העלאת admin חדש, שחזור גיבוי ופעולות מחשב."}, "control": {"label": "לוג שרת בקרה", "path": CONTROL_LOG_PATH, "note": "שרת הבקרה החיצוני שמפעיל ומעדכן את האדמין הראשי."}, "control_bootstrap": {"label": "לוג התקנת שרת בקרה", "path": CONTROL_BOOTSTRAP_LOG_PATH, "note": "כתיבת והפעלת שרת הבקרה."}, "watchdog": {"label": "לוג legacy", "path": WATCHDOG_LOG_PATH, "note": "שאריות לוג ממנגנונים ישנים, אם קיימות. לא חלק מהפאנל הראשי."}, } LOG_TAIL_DEFAULT_LINES = 120 LOG_TAIL_MAX_LINES = 500 # Smart media optimizer settings. # Images uploaded to fixed slide slots are always stored as real .jpg files. # Audio uploaded to fixed music slots is always stored as .mp3 when FFmpeg is available. IMAGE_OPTIMIZER_MAX_LONG_EDGE = int(os.environ.get("TRIPSERVER_IMAGE_MAX_LONG_EDGE", "1920")) IMAGE_OPTIMIZER_TARGET_BYTES = int(os.environ.get("TRIPSERVER_IMAGE_TARGET_BYTES", str(1100 * 1024))) IMAGE_OPTIMIZER_QUALITIES = tuple(int(q) for q in os.environ.get("TRIPSERVER_IMAGE_QUALITIES", "88,86,84,82,80,78").split(",") if q.strip()) AUDIO_UPLOAD_MAX_BYTES = int(os.environ.get("TRIPSERVER_AUDIO_MAX_BYTES", str(80 * 1024 * 1024))) AUDIO_MP3_BITRATE = os.environ.get("TRIPSERVER_AUDIO_MP3_BITRATE", "192k") AUDIO_MP3_SAMPLE_RATE = os.environ.get("TRIPSERVER_AUDIO_MP3_SAMPLE_RATE", "44100") MEDIA_AUDIO_ACCEPT = ".mp3,.wav,.m4a,.aac,.flac,.ogg,.opus,.wma,.webm,.mp4,audio/*,video/mp4" MEDIA_IMAGE_ACCEPT = ".jpg,.jpeg,.png,.webp,.bmp,.tif,.tiff,image/*" # Power actions are intentionally guarded: POST only, LAN/local client only, typed Hebrew confirmation, and cancel support. POWER_ACTIONS_ENABLED = os.environ.get("TRIPSERVER_ENABLE_POWER_ACTIONS", "1").strip().lower() not in {"0", "false", "no", "off"} POWER_MIN_DELAY_SECONDS = 30 POWER_MAX_DELAY_SECONDS = 3600 POWER_DEFAULT_DELAY_SECONDS = 60 POWER_CONFIRM_TEXT = { "shutdown": "כיבוי", "reboot": "הפעלה מחדש", } POWER_LABELS = { "shutdown": "כיבוי מחשב", "reboot": "ריסטארט למחשב", } ADMIN_UPDATE_FAILSAFE_RESTART_SECONDS = int(os.environ.get("TRIPSERVER_ADMIN_UPDATE_FAILSAFE_RESTART_SECONDS", "180")) ADMIN_UPDATE_FAILSAFE_ENABLED = os.environ.get("TRIPSERVER_ADMIN_UPDATE_FAILSAFE", "1").strip().lower() not in {"0", "false", "no", "off"} def _json_safe_write(path, payload): try: os.makedirs(os.path.dirname(path), exist_ok=True) tmp = path + ".tmp" with open(tmp, "w", encoding="utf-8") as fh: json.dump(payload, fh, ensure_ascii=False, indent=2) os.replace(tmp, path) return True except Exception: return False def read_admin_failsafe_status(): try: if os.path.exists(ADMIN_FAILSAFE_STATUS_PATH): with open(ADMIN_FAILSAFE_STATUS_PATH, "r", encoding="utf-8") as fh: data = json.load(fh) if isinstance(data, dict): return data except Exception: pass return {"state": "unknown", "message": "עדיין אין נתוני Fail Safe שמורים."} def write_admin_failsafe_status(state, message, **extra): payload = { "state": state, "message": message, "updated_at": time.strftime("%Y-%m-%d %H:%M:%S"), "admin_version": ADMIN_PANEL_VERSION, } payload.update(extra) _json_safe_write(ADMIN_FAILSAFE_STATUS_PATH, payload) return payload def is_no_pending_shutdown_message(output): txt = (output or "").lower() return ("1116" in txt) or ("no shutdown was in progress" in txt) or ("אין" in txt and "כיבוי" in txt) def render_failsafe_status_card(): data = read_admin_failsafe_status() state = str(data.get("state") or "unknown") message = str(data.get("message") or "") updated = str(data.get("updated_at") or "") if state in {"armed"}: icon = "🟠" title = "Fail Safe חמוש" elif state in {"cancelled", "auto_cancelled", "none"}: icon = "🟢" title = "Fail Safe לא פעיל" elif state in {"arm_failed", "cancel_failed"}: icon = "🔴" title = "Fail Safe דורש בדיקה" else: icon = "⚪" title = "Fail Safe ללא סטטוס" safe_msg = html_lib.escape(message or "אין ריסטארט פעיל כרגע או שעדיין אין בדיקת סטטוס.") safe_updated = html_lib.escape(updated) return '
%s %s%s
%s
' % (icon, title, safe_msg, safe_updated) # Webcam / room camera control. The camera is never opened automatically on page load. # It starts only when the user presses the camera button, and it is guarded to LAN/Tailscale/private IPs. CAMERA_ENABLED = os.environ.get("TRIPSERVER_ENABLE_WEBCAM", "1").strip().lower() not in {"0", "false", "no", "off"} CAMERA_INDEX = int(os.environ.get("TRIPSERVER_WEBCAM_INDEX", "0")) CAMERA_WIDTH = int(os.environ.get("TRIPSERVER_WEBCAM_WIDTH", "1280")) CAMERA_HEIGHT = int(os.environ.get("TRIPSERVER_WEBCAM_HEIGHT", "720")) CAMERA_FPS = max(1, min(20, int(os.environ.get("TRIPSERVER_WEBCAM_FPS", "8")))) CAMERA_JPEG_QUALITY = max(45, min(92, int(os.environ.get("TRIPSERVER_WEBCAM_JPEG_QUALITY", "78")))) CAMERA_MAX_STREAM_SECONDS = int(os.environ.get("TRIPSERVER_WEBCAM_MAX_STREAM_SECONDS", "1800")) CAMERA_FRAME_INTERVAL_SECONDS = 1.0 / float(CAMERA_FPS) # Optional audio + recording layer. Audio and recording are manual-only and guarded by the same # LAN/Tailscale/private-IP checks as the live camera. FFmpeg is required for audio and MP4 recording. CAMERA_AUDIO_ENABLED = os.environ.get("TRIPSERVER_ENABLE_CAMERA_AUDIO", "1").strip().lower() not in {"0", "false", "no", "off"} CAMERA_RECORDING_ENABLED = os.environ.get("TRIPSERVER_ENABLE_CAMERA_RECORDING", "1").strip().lower() not in {"0", "false", "no", "off"} CAMERA_VIDEO_DEVICE = os.environ.get("TRIPSERVER_FFMPEG_VIDEO_DEVICE", "").strip() CAMERA_AUDIO_DEVICE = os.environ.get("TRIPSERVER_FFMPEG_AUDIO_DEVICE", "").strip() CAMERA_RECORDINGS_DIR = os.environ.get("TRIPSERVER_CAMERA_RECORDINGS_DIR", os.path.join(BASE_DIR, "camera_recordings")) CAMERA_RECORD_FPS = max(1, min(30, int(os.environ.get("TRIPSERVER_CAMERA_RECORD_FPS", "15")))) CAMERA_RECORD_MAX_SECONDS = max(30, min(8 * 3600, int(os.environ.get("TRIPSERVER_CAMERA_RECORD_MAX_SECONDS", "3600")))) CAMERA_AUDIO_BITRATE = os.environ.get("TRIPSERVER_CAMERA_AUDIO_BITRATE", "128k") # Camera component installer. First-run auto installer: if OpenCV is missing, the admin # starts a background pip installation automatically when the Flask process starts. # It uses the same Python executable that runs this admin server and writes a log. # The camera itself still never turns on automatically; only the dependency installer runs. CAMERA_SETUP_LOG_PATH = os.path.join(BASE_DIR, "camera_setup.log") CAMERA_AUDIO_LOG_PATH = os.path.join(BASE_DIR, "camera_audio_stream.log") CAMERA_HLS_DIR = os.path.join(BASE_DIR, "camera_live_hls") CAMERA_HLS_LOG_PATH = os.path.join(BASE_DIR, "camera_hls_stream.log") CAMERA_SETUP_CONFIRM_TEXT = "התקן" CAMERA_OPENCV_PACKAGE = os.environ.get("TRIPSERVER_OPENCV_PACKAGE", "opencv-python").strip() or "opencv-python" CAMERA_OPENCV_INSTALL_TIMEOUT_SECONDS = int(os.environ.get("TRIPSERVER_OPENCV_INSTALL_TIMEOUT_SECONDS", "900")) CAMERA_AUTO_INSTALL_OPENCV = os.environ.get("TRIPSERVER_CAMERA_AUTO_INSTALL_OPENCV", "1").strip().lower() not in {"0", "false", "no", "off"} CAMERA_AUTO_INSTALL_DELAY_SECONDS = int(os.environ.get("TRIPSERVER_CAMERA_AUTO_INSTALL_DELAY_SECONDS", "4")) CAMERA_SETUP_MARKER_PATH = os.path.join(BASE_DIR, "camera_opencv_installed.ok") CAMERA_SETUP_STATE = {"running": False, "started_at": "", "finished_at": "", "ok": False, "last_message": "", "mode": "idle", "auto_requested": False} CAMERA_SETUP_LOCK = threading.RLock() LOG_FILE_REGISTRY["camera_setup"] = {"label": "לוג התקנת רכיבי מצלמה", "path": CAMERA_SETUP_LOG_PATH, "note": "התקנת OpenCV דרך pip ובדיקת רכיבי מצלמה."} LOG_FILE_REGISTRY["camera_audio"] = {"label": "לוג אודיו מצלמה", "path": CAMERA_AUDIO_LOG_PATH, "note": "FFmpeg DirectShow, בחירת מיקרופון וניסיונות הפעלת אודיו."} LOG_FILE_REGISTRY["camera_hls"] = {"label": "לוג שידור מצלמה מאוחד HLS", "path": CAMERA_HLS_LOG_PATH, "note": "FFmpeg DirectShow וידאו+אודיו בתהליך אחד, כדי למנוע נעילת התקני USB."} def safe_zip_relpath(raw_name): raw = (raw_name or "").replace("\\", "/").strip("/") if not raw or raw.startswith("__MACOSX/"): return None parts = [p for p in raw.split("/") if p and p not in (".", "..")] if not parts or len(parts) != len(raw.split("/")): return None return "/".join(parts) def file_ext(filename): return os.path.splitext(filename or "")[1].lower() def is_likely_jpeg_file(path): try: with open(path, "rb") as fh: return fh.read(3) == b"\xff\xd8\xff" except Exception: return False def is_likely_mp3_file(path): """Fast MP3 sniffing: ID3 tag or MPEG audio frame sync near the beginning.""" try: with open(path, "rb") as fh: data = fh.read(4096) if data.startswith(b"ID3"): return True for idx in range(0, max(0, len(data) - 1)): if data[idx] == 0xFF and (data[idx + 1] & 0xE0) == 0xE0: return True return False except Exception: return False def find_ffmpeg_executable(): candidates = [ os.environ.get("FFMPEG_PATH"), "ffmpeg", r"C:\ffmpeg\bin\ffmpeg.exe", r"C:\Program Files\ffmpeg\bin\ffmpeg.exe", r"C:\Program Files (x86)\ffmpeg\bin\ffmpeg.exe", ] for candidate in candidates: if not candidate: continue found = shutil.which(candidate) if os.path.basename(candidate) == candidate else (candidate if os.path.exists(candidate) else None) if found: return found return None def find_ffprobe_executable(): candidates = [ os.environ.get("FFPROBE_PATH"), "ffprobe", r"C:\ffmpeg\bin\ffprobe.exe", r"C:\Program Files\ffmpeg\bin\ffprobe.exe", r"C:\Program Files (x86)\ffmpeg\bin\ffprobe.exe", ] for candidate in candidates: if not candidate: continue found = shutil.which(candidate) if os.path.basename(candidate) == candidate else (candidate if os.path.exists(candidate) else None) if found: return found return None def run_hidden_subprocess(cmd, timeout=20): kwargs = dict(capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=timeout, shell=False) if os.name == "nt": kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0) return subprocess.run(cmd, **kwargs) def format_seconds(value): try: total = int(round(float(value))) minutes, seconds = divmod(total, 60) hours, minutes = divmod(minutes, 60) if hours: return f"{hours}:{minutes:02d}:{seconds:02d}" return f"{minutes}:{seconds:02d}" except Exception: return str(value) def probe_audio_duration_seconds(path): ffprobe = find_ffprobe_executable() if not ffprobe: return {"ok": False, "error": r"ffprobe לא נמצא. ודא שקיים C:\ffmpeg\bin\ffprobe.exe", "ffprobe": ""} cmd = [ ffprobe, "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path, ] try: cp = run_hidden_subprocess(cmd, timeout=20) raw = ((cp.stdout or "") + "\n" + (cp.stderr or "")).strip() if cp.returncode != 0: return {"ok": False, "error": raw or f"ffprobe failed rc={cp.returncode}", "return_code": cp.returncode, "ffprobe": ffprobe} value = None for line in raw.splitlines(): line = line.strip() if not line: continue try: value = float(line) break except Exception: pass if value is None or value <= 0: return {"ok": False, "error": "ffprobe לא החזיר משך שיר תקין", "raw": raw, "ffprobe": ffprobe} return {"ok": True, "duration_seconds": value, "duration_display": format_seconds(value), "raw": raw, "ffprobe": ffprobe} except subprocess.TimeoutExpired: return {"ok": False, "error": "ffprobe חרג מזמן הבדיקה", "ffprobe": ffprobe} except Exception as exc: return {"ok": False, "error": repr(exc), "ffprobe": ffprobe} def music_key_to_rule_key(trip, music_key): trip = (trip or "").upper() if trip == "JAPAN": return music_key if music_key in PRESENTATION_MUSIC_SYNC_RULES else None if trip == "USA": if music_key == "usa_music": return "usa_music_part1" if music_key == "usa_music_part2": return "usa_music_part2" return None def read_presentation_music_upload_status(): try: if os.path.exists(PRESENTATION_MUSIC_UPLOAD_STATUS_PATH): with open(PRESENTATION_MUSIC_UPLOAD_STATUS_PATH, "r", encoding="utf-8") as f: data = json.load(f) return data if isinstance(data, dict) else {} except Exception: return {} return {} def write_presentation_music_upload_status(rule_key, status): data = read_presentation_music_upload_status() data[rule_key or "unknown"] = status history = data.get("_history") if not isinstance(history, list): history = [] history.insert(0, status) data["_history"] = history[:30] ensure_parent_dir(PRESENTATION_MUSIC_UPLOAD_STATUS_PATH) tmp = PRESENTATION_MUSIC_UPLOAD_STATUS_PATH + ".tmp" with open(tmp, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2) os.replace(tmp, PRESENTATION_MUSIC_UPLOAD_STATUS_PATH) def primary_saved_audio_path(save_result): if not isinstance(save_result, dict): return None if save_result.get("path"): return save_result.get("path") targets = save_result.get("targets") if isinstance(targets, list) and targets: first = targets[0] if isinstance(first, dict): return first.get("path") return None def all_saved_audio_paths(save_result): if not isinstance(save_result, dict): return [] if save_result.get("path"): return [save_result.get("path")] targets = save_result.get("targets") if isinstance(targets, list): return [item.get("path") for item in targets if isinstance(item, dict) and item.get("path")] return [] def read_text_file_utf8(path): with open(path, "r", encoding="utf-8", errors="ignore") as f: return f.read() def write_text_file_utf8_atomic_with_backup(path, new_text, backup_group): if not os.path.exists(path): raise FileNotFoundError(path) backup_path = backup_existing_file(path, backup_group) tmp_path = path + ".tmp" with open(tmp_path, "w", encoding="utf-8", newline="") as f: f.write(new_text) os.replace(tmp_path, path) return backup_path def calculate_scaled_slide_durations_ms(old_durations, target_total_ms): return calculate_scaled_slide_durations_ms_with_min(old_durations, target_total_ms, None) def calculate_scaled_slide_durations_ms_with_min(old_durations, target_total_ms, minimum_per_slide_ms=None): if not old_durations: raise ValueError("לא נמצאו זמני שקפים לחישוב.") target_total_ms = int(round(float(target_total_ms))) if target_total_ms <= 0: raise ValueError("משך יעד לא תקין לסנכרון שקפים.") current_total = sum(int(x) for x in old_durations) if current_total <= 0: raise ValueError("סך זמני השקפים הנוכחי אינו תקין.") count = len(old_durations) if minimum_per_slide_ms is None: minimum = 1200 if target_total_ms >= count * 1200 else max(250, target_total_ms // max(1, count)) else: minimum = int(round(float(minimum_per_slide_ms))) if minimum <= 0: raise ValueError("רצפת זמן שקף אינה תקינה.") if target_total_ms < count * minimum: raise ValueError("משך היעד קצר מדי ביחס לרצפת זמן השקפים שנבחרה.") scale = target_total_ms / float(current_total) new_durations = [max(minimum, int(round(int(x) * scale))) for x in old_durations] diff = target_total_ms - sum(new_durations) if diff > 0: new_durations[-1] += diff elif diff < 0: remaining = -diff for i in range(len(new_durations) - 1, -1, -1): room = max(0, new_durations[i] - minimum) if room <= 0: continue take = min(room, remaining) new_durations[i] -= take remaining -= take if remaining <= 0: break if remaining > 0: if minimum_per_slide_ms is None: new_durations[-1] = max(1, new_durations[-1] - remaining) else: raise ValueError("לא ניתן להגיע למשך היעד בלי לרדת מתחת לרצפת זמן השקף.") if sum(new_durations) != target_total_ms: new_durations[-1] += target_total_ms - sum(new_durations) if any(int(x) <= 0 for x in new_durations): raise ValueError("חישוב זמני השקפים יצר ערך לא תקין.") if minimum_per_slide_ms is not None and any(int(x) < int(round(float(minimum_per_slide_ms))) for x in new_durations): raise ValueError("חישוב זמני השקפים ירד מתחת לרצפת זמן השקף שנבחרה.") return new_durations def get_japan_experience_slide_durations_ms(): path = os.path.join(FOLDERS["JAPAN"], JAPAN_PRESENTATION_FILES["japan_experience"]) if not os.path.exists(path): raise FileNotFoundError(path) html = read_text_file_utf8(path) match = re.search(r"const\s+SLIDES\s*=\s*(\[.*?\]);", html, flags=re.S) if not match: raise ValueError("לא נמצא מערך SLIDES במצגת יפן. אסור לנחש זמני שקפים.") block = match.group(1) old_durations = [int(m.group(1)) for m in re.finditer(r'"duration"\s*:\s*(\d+)', block)] if not old_durations: raise ValueError("לא נמצאו ערכי duration במערך SLIDES של מצגת יפן.") return {"path": path, "html": html, "match": match, "block": block, "durations": old_durations} def sync_japan_experience_presentation_to_target_duration(duration_seconds, sync_mode="matched_music_length", source_duration_seconds=None, minimum_per_slide_seconds=None): data = get_japan_experience_slide_durations_ms() html = data["html"] match = data["match"] block = data["block"] old_durations = data["durations"] target_total_ms = int(round(float(duration_seconds) * 1000)) min_ms = None if minimum_per_slide_seconds is None else int(round(float(minimum_per_slide_seconds) * 1000)) new_durations = calculate_scaled_slide_durations_ms_with_min(old_durations, target_total_ms, min_ms) index = {"value": 0} def replace_duration(m): i = index["value"] index["value"] += 1 return '"duration":' + str(new_durations[i]) new_block = re.sub(r'"duration"\s*:\s*\d+', replace_duration, block) if index["value"] != len(new_durations): raise ValueError("מספר ערכי duration שהוחלפו אינו תואם למספר השקפים.") source_text = "" if source_duration_seconds is not None: source_text = f" source song: {float(source_duration_seconds):.6f}s;" floor_text = "" if minimum_per_slide_seconds is not None: floor_text = f" min slide: {float(minimum_per_slide_seconds):.3f}s;" stamp = ( f"// TripServer music sync v34.20 confirm: japan-experience.html; mode: {sync_mode};" f"{source_text} target total: {float(duration_seconds):.6f}s; slides: {len(new_durations)};" f" old total: {sum(old_durations)/1000:.3f}s; new total: {sum(new_durations)/1000:.3f}s;{floor_text}" ) new_html = html[:match.start(1)] + new_block + html[match.end(1):] if "// TripServer music sync v34.20 confirm: japan-experience.html" in new_html: new_html = re.sub(r"// TripServer music sync v34\.20 confirm: japan-experience\.html[^\n]*\n", stamp + "\n", new_html, count=1) elif "// TripServer music sync v34.19 safe: japan-experience.html" in new_html: new_html = re.sub(r"// TripServer music sync v34\.19 safe: japan-experience\.html[^\n]*\n", stamp + "\n", new_html, count=1) elif "// TripServer music sync v34.14: japan-experience.html" in new_html: new_html = re.sub(r"// TripServer music sync v34\.14: japan-experience\.html[^\n]*\n", stamp + "\n", new_html, count=1) elif "// TripServer music sync:" in new_html: new_html = re.sub(r"// TripServer music sync:[^\n]*\n", stamp + "\n", new_html, count=1) else: new_html = new_html[:match.start()] + stamp + "\n" + new_html[match.start():] if new_html == html: raise ValueError("לא בוצע שינוי בפועל במצגת יפן.") backup_path = write_text_file_utf8_atomic_with_backup(data["path"], new_html, "JAPAN_presentation_music_sync") verify = get_japan_experience_slide_durations_ms() verify_durations = verify.get("durations") or [] if len(verify_durations) != len(new_durations) or sum(verify_durations) != sum(new_durations): raise ValueError("אימות לאחר כתיבה נכשל: זמני השקפים בקובץ אינם תואמים לחישוב.") return { "ok": True, "path": data["path"], "backup": backup_path, "sha256": file_sha256(data["path"]), "slides": len(new_durations), "old_total_seconds": sum(old_durations) / 1000.0, "new_total_seconds": sum(new_durations) / 1000.0, "duration_seconds": float(duration_seconds), "source_duration_seconds": None if source_duration_seconds is None else float(source_duration_seconds), "min_slide_seconds": None if minimum_per_slide_seconds is None else float(minimum_per_slide_seconds), "average_slide_seconds": (sum(new_durations) / 1000.0) / max(1, len(new_durations)), "sync_mode": sync_mode, "message": f"מצגת יפן עודכנה: {len(new_durations)} שקפים, סך חדש {format_seconds(sum(new_durations)/1000.0)}.", } def sync_japan_experience_presentation_to_music_duration(duration_seconds): """Synchronize japan-experience.html exactly to the uploaded song duration. v34.20 keeps this exact-sync behavior only after the user explicitly approves it or when the measured average slide time is already inside the safe 5–10 second range. """ result = sync_japan_experience_presentation_to_target_duration( duration_seconds, sync_mode="matched_music_length", source_duration_seconds=duration_seconds, minimum_per_slide_seconds=None, ) result["message"] = f"מצגת יפן סונכרנה לפי שיר באורך {format_seconds(duration_seconds)} ({float(duration_seconds):.3f} שניות)." return result def sync_usa_presentation_part_to_music_duration(music_key, duration_seconds): """Synchronize USA presentation timing for one song part only. The USA presentation uses two constants, not per-slide duration fields: - PART_1_SECONDS controls slides 1-23. - PART_2_SECONDS controls slides 24-44. Updating one constant is the safe and intended synchronization for that song. Both regular and TV presentation variants are updated when present. No FFmpeg/ffprobe is executed here; duration must already be measured. """ key = music_key_to_rule_key("USA", music_key) or music_key if key == "usa_music_part1": const_name = "PART_1_SECONDS" label = "ארה״ב חלק 1" scope = "שקפים 1–23" elif key == "usa_music_part2": const_name = "PART_2_SECONDS" label = "ארה״ב חלק 2" scope = "שקפים 24–44" else: raise ValueError("סוג שיר ארה״ב לא מוכר לסנכרון.") seconds = float(duration_seconds) if seconds <= 0: raise ValueError("משך שיר לא תקין לסנכרון ארה״ב.") seconds_text = f"{seconds:.6f}" results = [] for presentation_key in ("usa_presentation", "usa_presentation_tv"): filename = USA_PRESENTATION_FILES.get(presentation_key) if not filename: continue path = os.path.join(FOLDERS["USA"], filename) if not os.path.exists(path): continue html = read_text_file_utf8(path) pattern = re.compile(r"(const\s+" + re.escape(const_name) + r"\s*=\s*)([0-9]+(?:\.[0-9]+)?)(\s*;)") match = pattern.search(html) if not match: raise ValueError(f"לא נמצא {const_name} בתוך {filename}. אסור לנחש זמני מצגת.") old_value = float(match.group(2)) new_html = pattern.sub(r"\g<1>" + seconds_text + r"\g<3>", html, count=1) # Keep the nearby Hebrew comment aligned when it exists. This is cosmetic but prevents future confusion. if const_name == "PART_1_SECONDS": new_html = re.sub(r"//\s*שקפים\s*1-23:[^\n]*", f"// שקפים 1-23: usa-roadtrip-theme, {seconds_text} שניות.", new_html, count=1) else: new_html = re.sub(r"//\s*שקפים\s*24-44:[^\n]*", f"// שקפים 24-44: usa-part2-theme, {seconds_text} שניות.", new_html, count=1) stamp = f"// TripServer music sync v34.14: {label} ({scope}) סונכרן לפי שיר באורך {seconds_text} שניות." if "// TripServer music sync v34.14:" in new_html: # Do not remove previous part's stamp; only replace same part if it exists. part_stamp_re = re.compile(r"// TripServer music sync v34\.14: " + re.escape(label) + r"[^\n]*\n") if part_stamp_re.search(new_html): new_html = part_stamp_re.sub(stamp + "\n", new_html, count=1) else: new_html = new_html[:match.start()] + stamp + "\n" + new_html[match.start():] elif "// TripServer music sync:" in new_html: # Legacy stamp from older experiments: add new clear stamp instead of deleting history. new_html = new_html[:match.start()] + stamp + "\n" + new_html[match.start():] else: new_html = new_html[:match.start()] + stamp + "\n" + new_html[match.start():] if new_html == html: raise ValueError(f"לא בוצע שינוי בפועל ב־{filename}.") backup_path = write_text_file_utf8_atomic_with_backup(path, new_html, "USA_presentation_music_sync") results.append({ "ok": True, "path": path, "backup": backup_path, "sha256": file_sha256(path), "presentation_key": presentation_key, "filename": filename, "part": key, "const_name": const_name, "scope": scope, "old_seconds": old_value, "new_seconds": seconds, "duration_seconds": seconds, "message": f"{filename}: {const_name} עודכן מ־{old_value:.6f} ל־{seconds_text} שניות.", }) if not results: raise FileNotFoundError("לא נמצאה מצגת ארה״ב לסנכרון: usa2027-presentation.html או usa2027-presentation-tv.html") return { "ok": True, "part": key, "label": label, "scope": scope, "duration_seconds": seconds, "results": results, "message": f"{label} סונכרן לפי שיר באורך {format_seconds(seconds)} ({seconds:.3f} שניות).", } def register_existing_music_upload_duration(trip, music_key, save_result): rule_key = music_key_to_rule_key(trip, music_key) rule = PRESENTATION_MUSIC_SYNC_RULES.get(rule_key or "", {}) path = primary_saved_audio_path(save_result) paths = all_saved_audio_paths(save_result) status = { "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), "trip": (trip or "").upper(), "music_key": music_key, "rule_key": rule_key or "", "label": rule.get("label", ""), "scope": rule.get("scope", ""), "presentation": rule.get("presentation", ""), "paths": paths, "primary_path": path or "", "duration_ok": False, "duration_seconds": None, "duration_display": "", "sync_performed": False, "sync_note": "v34.14: העלאת שיר קיימת מודדת את האורך ומסנכרנת את המצגת/המקטע הרלוונטיים כאשר כלל הסנכרון פעיל.", } if not path or not os.path.exists(path): status["error"] = "קובץ השיר נשמר אך לא נמצא נתיב קובץ למדידת אורך." if rule_key: write_presentation_music_upload_status(rule_key, status) return status probe = probe_audio_duration_seconds(path) status["ffprobe"] = probe.get("ffprobe", "") if probe.get("ok"): status["duration_ok"] = True status["duration_seconds"] = probe.get("duration_seconds") status["duration_display"] = probe.get("duration_display") try: sync_result = None if (trip or "").upper() == "JAPAN" and music_key == "japan_experience_music": sync_result = sync_japan_experience_presentation_to_music_duration(probe.get("duration_seconds")) status["sync_note"] = "בוצע סנכרון בפועל: כל שקפי מצגת יפן סונכרנו לפי אורך השיר החדש." elif (trip or "").upper() == "USA" and rule_key in {"usa_music_part1", "usa_music_part2"}: sync_result = sync_usa_presentation_part_to_music_duration(rule_key, probe.get("duration_seconds")) status["sync_note"] = "בוצע סנכרון בפועל: רק מקטע השיר הרלוונטי במצגת ארה״ב עודכן." elif (trip or "").upper() == "JAPAN" and music_key == "japan_flight_music": status["sync_note"] = "מוזיקת פתיח הטיסה נשמרה ונמדדה. לא שונה japan-experience.html כי פתיח הטיסה הוא מקטע נפרד." if sync_result: status["sync_performed"] = True if isinstance(sync_result, dict) and sync_result.get("results"): status["sync_results"] = sync_result.get("results") status["sync_summary"] = sync_result.get("message", "") else: status["sync_results"] = [sync_result] status["sync_summary"] = sync_result.get("message", "") if isinstance(sync_result, dict) else "" except Exception as sync_exc: status["sync_performed"] = False status["sync_error"] = repr(sync_exc) status["sync_note"] = "השיר נשמר ונמדד, אך סנכרון המצגת נכשל. אין אישור שהמצגת מסונכרנת." else: status["error"] = probe.get("error") or probe.get("raw") or "ffprobe לא הצליח לזהות משך שיר." if rule_key: write_presentation_music_upload_status(rule_key, status) return status def music_upload_duration_details(status): if not isinstance(status, dict): return "" lines = ["סטטוס אורך שיר:"] if status.get("label"): lines.append(f"שיר/מקטע: {status.get('label')}") if status.get("scope"): lines.append(f"תחום סנכרון עתידי: {status.get('scope')}") if status.get("duration_ok"): lines.append(f"משך שזוהה: {status.get('duration_display')} ({float(status.get('duration_seconds') or 0):.3f} שניות)") if status.get("sync_performed"): lines.append("סנכרון שקפים: בוצע בפועל למצגת יפן.") for item in status.get("sync_results") or []: if isinstance(item, dict): lines.append(f"מצגת: {item.get('path','')}") lines.append(f"שקפים: {item.get('slides','')} | סך חדש: {float(item.get('new_total_seconds') or 0):.3f} שניות") if item.get("backup"): lines.append(f"גיבוי מצגת קודם: {item.get('backup')}") elif status.get("sync_error"): lines.append("סנכרון שקפים: נכשל.") lines.append(f"שגיאת סנכרון: {status.get('sync_error')}") else: lines.append("סנכרון שקפים: לא בוצע בשלב הזה.") else: lines.append("אזהרה: השיר נשמר, אבל לא זוהה משך תקין ולכן אין אישור לסנכרון.") if status.get("error"): lines.append(f"שגיאה: {status.get('error')}") if status.get("ffprobe"): lines.append(f"ffprobe: {status.get('ffprobe')}") if status.get("primary_path"): lines.append(f"נתיב שנבדק: {status.get('primary_path')}") lines.append("קובץ סטטוס: " + PRESENTATION_MUSIC_UPLOAD_STATUS_PATH) return "\n".join(lines) def render_music_upload_status_rows(): data = read_presentation_music_upload_status() rows = [] for key, rule in PRESENTATION_MUSIC_SYNC_RULES.items(): st = data.get(key) if isinstance(data, dict) else None if isinstance(st, dict) and st.get("timestamp"): if st.get("duration_ok"): if st.get("sync_performed"): badge = f"סונכרן: {html_lib.escape(str(st.get('duration_display') or ''))}" detail = "משך זוהה ומצגת יפן סונכרנה בפועל." elif st.get("sync_error"): badge = f"נמדד, סנכרון נכשל" detail = html_lib.escape(str(st.get("sync_error") or "שגיאת סנכרון")) else: badge = f"נמדד: {html_lib.escape(str(st.get('duration_display') or ''))}" detail = "משך זוהה. עדיין לא בוצע סנכרון שקפים." else: badge = "שגיאת מדידה" detail = html_lib.escape(str(st.get("error") or "לא זוהה משך")) timestamp = html_lib.escape(str(st.get("timestamp") or "")) else: badge = "אין העלאה אחרונה" detail = "טרם נרשם סטטוס העלאה לשיר הזה." timestamp = "—" rows.append(f"{html_lib.escape(rule.get('label',''))}{badge}{timestamp}{detail}") return "".join(rows) def media_engine_status(): ffmpeg_path = find_ffmpeg_executable() or "" ffprobe_path = find_ffprobe_executable() or "" status = {"pillow": False, "ffmpeg": bool(ffmpeg_path), "ffmpeg_path": ffmpeg_path, "ffprobe": bool(ffprobe_path), "ffprobe_path": ffprobe_path} try: import PIL # noqa: F401 status["pillow"] = True except Exception: status["pillow"] = False return status def format_bytes(num): try: num = int(num) except Exception: return str(num) units = ["B", "KB", "MB", "GB"] value = float(num) for unit in units: if value < 1024 or unit == units[-1]: return f"{value:.1f} {unit}" if unit != "B" else f"{int(value)} B" value /= 1024 def convert_or_copy_image_to_jpg(source_path, target_path, original_name=""): """Create a real optimized JPG file; never writes a fake .jpg. Smart behavior: - Uses Pillow when installed. - Applies EXIF orientation. - Converts alpha/transparency to a white background. - Downscales only when the long edge is larger than IMAGE_OPTIMIZER_MAX_LONG_EDGE. - Uses progressive/optimized JPEG and a quality loop to reduce weight without aggressive damage. - If Pillow is missing, accepts only true JPEG bytes and copies them safely. """ ensure_parent_dir(target_path) original_size = os.path.getsize(source_path) if os.path.exists(source_path) else 0 try: from PIL import Image, ImageOps with Image.open(source_path) as img: img.verify() with Image.open(source_path) as img: img = ImageOps.exif_transpose(img) original_dimensions = tuple(img.size) if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info): rgba = img.convert("RGBA") background = Image.new("RGBA", rgba.size, (255, 255, 255, 255)) background.alpha_composite(rgba) img = background.convert("RGB") elif img.mode != "RGB": img = img.convert("RGB") resized = False max_edge = max(img.size) if img.size else 0 if IMAGE_OPTIMIZER_MAX_LONG_EDGE and max_edge > IMAGE_OPTIMIZER_MAX_LONG_EDGE: scale = IMAGE_OPTIMIZER_MAX_LONG_EDGE / float(max_edge) new_size = (max(1, int(round(img.size[0] * scale))), max(1, int(round(img.size[1] * scale)))) img = img.resize(new_size, Image.Resampling.LANCZOS) resized = True tmp_candidates = [] qualities = IMAGE_OPTIMIZER_QUALITIES or (88, 84, 80) for quality in qualities: tmp_candidate = f"{target_path}.q{quality}.tmp" img.save(tmp_candidate, "JPEG", quality=int(quality), optimize=True, progressive=True) tmp_candidates.append((quality, tmp_candidate, os.path.getsize(tmp_candidate))) if os.path.getsize(tmp_candidate) <= IMAGE_OPTIMIZER_TARGET_BYTES: break # Keep the highest-quality candidate that reaches target size; otherwise keep the smallest candidate. under_target = [item for item in tmp_candidates if item[2] <= IMAGE_OPTIMIZER_TARGET_BYTES] chosen = under_target[0] if under_target else min(tmp_candidates, key=lambda item: item[2]) for quality, path, _size in tmp_candidates: if path != chosen[1]: try: os.remove(path) except Exception: pass os.replace(chosen[1], target_path) final_size = os.path.getsize(target_path) return { "mode": "optimized_jpg", "quality": chosen[0], "original_size": original_size, "final_size": final_size, "original_dimensions": original_dimensions, "final_dimensions": tuple(img.size), "resized": resized, "saved_bytes": max(0, original_size - final_size), } except ImportError: if is_likely_jpeg_file(source_path): tmp_target = target_path + ".tmp" shutil.copy2(source_path, tmp_target) os.replace(tmp_target, target_path) final_size = os.path.getsize(target_path) return { "mode": "copied_real_jpeg_without_pillow", "quality": "source", "original_size": original_size, "final_size": final_size, "original_dimensions": "unknown", "final_dimensions": "unknown", "resized": False, "saved_bytes": max(0, original_size - final_size), } raise ValueError("Pillow is not installed, so non-JPG images cannot be converted. Install Pillow with: py -m pip install pillow") except ValueError: raise except Exception as exc: raise ValueError("Image conversion/compression failed: " + repr(exc)) def convert_or_copy_audio_to_mp3(source_path, target_path, original_name=""): """Store uploaded audio as a real .mp3 file. If FFmpeg exists, transcode supported audio/video containers to MP3. If FFmpeg is missing, accept only files that are already real MP3 bytes, even if their extension is wrong. """ ensure_parent_dir(target_path) original_size = os.path.getsize(source_path) if os.path.exists(source_path) else 0 if original_size <= 0: raise ValueError("קובץ האודיו ריק.") if original_size > AUDIO_UPLOAD_MAX_BYTES: raise ValueError(f"קובץ האודיו גדול מדי: {format_bytes(original_size)}. מגבלה: {format_bytes(AUDIO_UPLOAD_MAX_BYTES)}") source_is_mp3 = is_likely_mp3_file(source_path) ffmpeg = find_ffmpeg_executable() if ffmpeg: tmp_mp3 = target_path + ".ffmpeg.tmp.mp3" cmd = [ ffmpeg, "-y", "-hide_banner", "-loglevel", "error", "-i", source_path, "-vn", "-codec:a", "libmp3lame", "-b:a", AUDIO_MP3_BITRATE, "-ar", AUDIO_MP3_SAMPLE_RATE, tmp_mp3, ] run = run_hidden_subprocess(cmd, timeout=180) if run.returncode != 0 or not os.path.exists(tmp_mp3) or os.path.getsize(tmp_mp3) <= 0: try: if os.path.exists(tmp_mp3): os.remove(tmp_mp3) except Exception: pass raise ValueError("FFmpeg failed to convert audio to MP3: " + ((run.stderr or run.stdout or "unknown error")[-1200:])) converted_size = os.path.getsize(tmp_mp3) if source_is_mp3 and converted_size > int(original_size * 1.05): # Avoid bloating an already efficient MP3. Still normalize the target filename to .mp3. try: os.remove(tmp_mp3) except Exception: pass tmp_target = target_path + ".copy.tmp" shutil.copy2(source_path, tmp_target) os.replace(tmp_target, target_path) final_size = os.path.getsize(target_path) return {"mode": "copied_existing_mp3_smaller_than_reencode", "original_size": original_size, "final_size": final_size, "saved_bytes": max(0, original_size - final_size), "ffmpeg": ffmpeg} os.replace(tmp_mp3, target_path) final_size = os.path.getsize(target_path) return {"mode": "converted_to_mp3_ffmpeg", "original_size": original_size, "final_size": final_size, "saved_bytes": max(0, original_size - final_size), "ffmpeg": ffmpeg, "bitrate": AUDIO_MP3_BITRATE} if source_is_mp3: tmp_target = target_path + ".copy.tmp" shutil.copy2(source_path, tmp_target) os.replace(tmp_target, target_path) final_size = os.path.getsize(target_path) return {"mode": "copied_real_mp3_without_ffmpeg", "original_size": original_size, "final_size": final_size, "saved_bytes": max(0, original_size - final_size), "ffmpeg": "not_found"} raise ValueError("FFmpeg is not installed, so this audio file cannot be converted to MP3. Install FFmpeg or upload a real MP3 file.") def save_audio_upload_to_target(uploaded_file, target_path, backup_group="audio"): os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") safe_name = secure_filename(uploaded_file.filename or "audio_upload") or "audio_upload" tmp_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"audio_{stamp}_{os.getpid()}_{safe_name}") uploaded_file.save(tmp_path) try: backup_path = backup_existing_file(target_path, backup_group) media = convert_or_copy_audio_to_mp3(tmp_path, target_path, uploaded_file.filename or "") return {"path": target_path, "size": os.path.getsize(target_path), "sha256": file_sha256(target_path), "backup": backup_path, "media": media} finally: try: if os.path.exists(tmp_path): os.remove(tmp_path) except Exception: pass def save_audio_upload_to_multiple_targets(uploaded_file, base_folder, rel_paths, backup_group): os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") safe_name = secure_filename(uploaded_file.filename or "audio_upload") or "audio_upload" source_tmp = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"audio_multi_{stamp}_{os.getpid()}_{safe_name}") converted_tmp = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"audio_multi_{stamp}_{os.getpid()}_converted.mp3") uploaded_file.save(source_tmp) try: media = convert_or_copy_audio_to_mp3(source_tmp, converted_tmp, uploaded_file.filename or "") sha = file_sha256(converted_tmp) results = [] for rel_path in rel_paths: target_path = os.path.join(base_folder, rel_path) ensure_parent_dir(target_path) backup_path = backup_existing_file(target_path, backup_group) tmp_target = target_path + ".tmp" shutil.copy2(converted_tmp, tmp_target) os.replace(tmp_target, target_path) results.append({"rel": rel_path, "path": target_path, "size": os.path.getsize(target_path), "sha256": file_sha256(target_path), "backup": backup_path}) return {"size": os.path.getsize(converted_tmp), "sha256": sha, "targets": results, "media": media} finally: for p in (source_tmp, converted_tmp): try: if os.path.exists(p): os.remove(p) except Exception: pass def cleanup_old_pending_music_uploads(): try: os.makedirs(PENDING_MUSIC_UPLOAD_DIR, exist_ok=True) now = time.time() for name in os.listdir(PENDING_MUSIC_UPLOAD_DIR): path = os.path.join(PENDING_MUSIC_UPLOAD_DIR, name) try: if os.path.isfile(path) and now - os.path.getmtime(path) > PENDING_MUSIC_MAX_AGE_SECONDS: os.remove(path) except Exception: pass except Exception: pass def save_pending_audio_upload(uploaded_file, trip, music_key): cleanup_old_pending_music_uploads() os.makedirs(PENDING_MUSIC_UPLOAD_DIR, exist_ok=True) token = uuid.uuid4().hex stamp = time.strftime("%Y%m%d_%H%M%S") safe_name = secure_filename(uploaded_file.filename or "audio_upload") or "audio_upload" source_tmp = os.path.join(PENDING_MUSIC_UPLOAD_DIR, f"{token}_{stamp}_{safe_name}") pending_mp3 = os.path.join(PENDING_MUSIC_UPLOAD_DIR, f"{token}.mp3") meta_path = os.path.join(PENDING_MUSIC_UPLOAD_DIR, f"{token}.json") uploaded_file.save(source_tmp) try: media = convert_or_copy_audio_to_mp3(source_tmp, pending_mp3, uploaded_file.filename or "") meta = { "token": token, "created_at": time.strftime("%Y-%m-%d %H:%M:%S"), "created_epoch": time.time(), "trip": (trip or "").upper(), "music_key": music_key, "original_name": uploaded_file.filename or "", "pending_path": pending_mp3, "size": os.path.getsize(pending_mp3), "sha256": file_sha256(pending_mp3), "media": media, } with open(meta_path, "w", encoding="utf-8") as f: json.dump(meta, f, ensure_ascii=False, indent=2) return meta except Exception: for p in (pending_mp3, meta_path): try: if os.path.exists(p): os.remove(p) except Exception: pass raise finally: try: if os.path.exists(source_tmp): os.remove(source_tmp) except Exception: pass def read_pending_music_upload(token): token = (token or "").strip() if not re.fullmatch(r"[0-9a-fA-F]{32}", token): raise ValueError("אסימון העלאה זמנית לא תקין.") meta_path = os.path.join(PENDING_MUSIC_UPLOAD_DIR, f"{token}.json") if not os.path.exists(meta_path): raise FileNotFoundError("העלאת השיר הזמנית לא נמצאה. ייתכן שפג תוקפה או שהיא כבר טופלה.") with open(meta_path, "r", encoding="utf-8") as f: meta = json.load(f) if not isinstance(meta, dict) or meta.get("token") != token: raise ValueError("קובץ ההעלאה הזמנית אינו תקין.") pending_path = meta.get("pending_path") or os.path.join(PENDING_MUSIC_UPLOAD_DIR, f"{token}.mp3") if not os.path.exists(pending_path): raise FileNotFoundError("קובץ השיר הזמני לא נמצא.") if time.time() - float(meta.get("created_epoch") or 0) > PENDING_MUSIC_MAX_AGE_SECONDS: discard_pending_music_upload(token) raise FileNotFoundError("פג תוקף העלאת השיר הזמנית. העלה את השיר מחדש.") meta["pending_path"] = pending_path return meta def discard_pending_music_upload(token): token = (token or "").strip() if not re.fullmatch(r"[0-9a-fA-F]{32}", token): return for suffix in (".mp3", ".json"): path = os.path.join(PENDING_MUSIC_UPLOAD_DIR, token + suffix) try: if os.path.exists(path): os.remove(path) except Exception: pass def commit_pending_audio_to_multiple_targets(pending_meta, base_folder, rel_paths, backup_group): pending_path = pending_meta.get("pending_path") if not pending_path or not os.path.exists(pending_path): raise FileNotFoundError("קובץ השיר הזמני לא נמצא ולכן לא ניתן להטמיע אותו.") sha = file_sha256(pending_path) size = os.path.getsize(pending_path) results = [] for rel_path in rel_paths: target_path = os.path.join(base_folder, rel_path) ensure_parent_dir(target_path) backup_path = backup_existing_file(target_path, backup_group) tmp_target = target_path + ".tmp" shutil.copy2(pending_path, tmp_target) os.replace(tmp_target, target_path) results.append({"rel": rel_path, "path": target_path, "size": os.path.getsize(target_path), "sha256": file_sha256(target_path), "backup": backup_path}) return {"size": size, "sha256": sha, "targets": results, "media": pending_meta.get("media"), "pending_token": pending_meta.get("token")} def build_japan_music_duration_status(music_key, save_result, probe, sync_result=None, sync_note="", sync_error=None, approval_action=""): rule_key = music_key_to_rule_key("JAPAN", music_key) rule = PRESENTATION_MUSIC_SYNC_RULES.get(rule_key or "", {}) status = { "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"), "trip": "JAPAN", "music_key": music_key, "rule_key": rule_key or "", "label": rule.get("label", ""), "scope": rule.get("scope", ""), "presentation": rule.get("presentation", ""), "paths": all_saved_audio_paths(save_result), "primary_path": primary_saved_audio_path(save_result) or "", "duration_ok": bool(probe and probe.get("ok")), "duration_seconds": (probe or {}).get("duration_seconds"), "duration_display": (probe or {}).get("duration_display", ""), "ffprobe": (probe or {}).get("ffprobe", ""), "sync_performed": bool(sync_result), "sync_note": sync_note, "approval_action": approval_action, } if sync_result: status["sync_results"] = [sync_result] status["sync_summary"] = sync_result.get("message", "") if isinstance(sync_result, dict) else "" if sync_error: status["sync_error"] = repr(sync_error) if rule_key: write_presentation_music_upload_status(rule_key, status) return status def japan_experience_music_analysis(duration_seconds): data = get_japan_experience_slide_durations_ms() slide_count = len(data.get("durations") or []) if slide_count <= 0: raise ValueError("לא נמצאו שקפים במצגת יפן.") duration = float(duration_seconds) average = duration / float(slide_count) min_total = slide_count * JAPAN_EXPERIENCE_MIN_AVG_SLIDE_SECONDS max_total = slide_count * JAPAN_EXPERIENCE_MAX_AVG_SLIDE_SECONDS if average < JAPAN_EXPERIENCE_MIN_AVG_SLIDE_SECONDS: state = "too_short" elif average > JAPAN_EXPERIENCE_MAX_AVG_SLIDE_SECONDS: state = "too_long" else: state = "ok" return { "state": state, "slide_count": slide_count, "song_seconds": duration, "song_display": format_seconds(duration), "average_slide_seconds": average, "minimum_total_seconds": min_total, "maximum_total_seconds": max_total, "loop_total_seconds": min_total, "presentation_path": data.get("path", ""), } def render_japan_music_confirmation_page(token, analysis, probe, pending_meta): state = analysis.get("state") avg = float(analysis.get("average_slide_seconds") or 0) slide_count = int(analysis.get("slide_count") or 0) song_display = html_lib.escape(str(analysis.get("song_display") or "")) original_name = html_lib.escape(str(pending_meta.get("original_name") or "")) loop_total = html_lib.escape(format_seconds(analysis.get("loop_total_seconds") or 0)) token_safe = html_lib.escape(token) if state == "too_short": title = "נדרש אישור לפני הטמעת השיר" badge = "אזהרה: השיר קצר מדי ביחס למספר השקפים" message = ( f"השיר שזוהה באורך {song_display}. במצגת יש {slide_count} שקפים, " f"ולכן זמן ממוצע לשקף יהיה {avg:.2f} שניות — פחות מהמינימום שהוגדר: " f"{JAPAN_EXPERIENCE_MIN_AVG_SLIDE_SECONDS:.0f} שניות לשקף." ) options = f"""
""" note = f"בחירת הלופ תאריך את המצגת ל־{loop_total} לפחות. קובץ האודיו עצמו יישמר, ותגית ה־audio במצגת תמשיך לנגן אותו בלופ." elif state == "too_long": title = "נדרש אישור לפני הטמעת השיר" badge = "אזהרה: השיר ארוך מדי ביחס למספר השקפים" message = ( f"השיר שזוהה באורך {song_display}. במצגת יש {slide_count} שקפים, " f"ולכן זמן ממוצע לשקף יהיה {avg:.2f} שניות — מעל המקסימום שהוגדר: " f"{JAPAN_EXPERIENCE_MAX_AVG_SLIDE_SECONDS:.0f} שניות לשקף." ) options = f"""
""" note = "במצב הזה אין אפשרות לופ, כי הבעיה אינה שיר קצר אלא שיר ארוך מדי ביחס למצגת." else: return admin_status_page("אין צורך באישור", "משך השיר נמצא בטווח התקין. העלה שוב אם נדרש.", ok=True) return f""" {html_lib.escape(title)}
{html_lib.escape(badge)}

{html_lib.escape(title)}

{html_lib.escape(message)}

קובץ: {original_name or '—'}
משך שיר: {song_display}
שקפים: {slide_count}
ממוצע צפוי לשקף: {avg:.2f} שניות
סטטוס: השיר עדיין לא הוטמע בנתיבי המצגת. הוא נשמר זמנית בלבד עד לבחירה.

{html_lib.escape(note)}

{options}
חזרה בלי לבצע שינוי
""" def handle_japan_experience_music_upload_with_confirmation(uploaded_file): pending_meta = None try: pending_meta = save_pending_audio_upload(uploaded_file, "JAPAN", "japan_experience_music") probe = probe_audio_duration_seconds(pending_meta.get("pending_path")) if not probe.get("ok"): discard_pending_music_upload(pending_meta.get("token")) details = media_details_text(pending_meta.get("media")) details += "\n\nשגיאת ffprobe:\n" + str(probe.get("error") or probe.get("raw") or "לא ידוע") return admin_status_page("השיר לא הוטמע — בדיקת אורך נכשלה", "המערכת לא הצליחה לזהות משך תקין ולכן לא שמרה את השיר בנתיבי המצגת ולא שינתה את המצגת.", ok=False, details=details), 200 analysis = japan_experience_music_analysis(probe.get("duration_seconds")) if analysis.get("state") in {"too_short", "too_long"}: return render_japan_music_confirmation_page(pending_meta.get("token"), analysis, probe, pending_meta), 200 return commit_japan_experience_pending_music(pending_meta.get("token"), "accept_as_is") except Exception as exc: if pending_meta and pending_meta.get("token"): discard_pending_music_upload(pending_meta.get("token")) return admin_status_page("שגיאה בהכנת שיר יפן", "השיר לא הוטמע ולא בוצע שינוי במצגת.", ok=False, details=repr(exc)), 500 def commit_japan_experience_pending_music(token, action): try: action = (action or "").strip() pending_meta = read_pending_music_upload(token) if pending_meta.get("trip") != "JAPAN" or pending_meta.get("music_key") != "japan_experience_music": return admin_status_page("העלאה זמנית לא תואמת", "הקובץ הזמני אינו שייך לשיר מצגת יפן הראשית.", ok=False), 400 probe = probe_audio_duration_seconds(pending_meta.get("pending_path")) if not probe.get("ok"): discard_pending_music_upload(token) return admin_status_page("השיר לא הוטמע — בדיקת אורך נכשלה", "הקובץ הזמני קיים, אבל ffprobe לא הצליח לזהות את משך השיר בזמן האישור. לא בוצע שינוי.", ok=False, details=str(probe.get("error") or probe.get("raw") or "לא ידוע")), 200 analysis = japan_experience_music_analysis(probe.get("duration_seconds")) allowed = {"accept_as_is", "cancel"} if analysis.get("state") == "too_short": allowed.add("loop_min_5") if action not in allowed: return admin_status_page("בחירת סנכרון לא תקינה", "האפשרות שנשלחה אינה תואמת למצב השיר.", ok=False), 400 if action == "cancel": discard_pending_music_upload(token) status = build_japan_music_duration_status("japan_experience_music", {"targets": []}, probe, sync_result=None, sync_note="המשתמש ביטל את ההעלאה אחרי אזהרת זמן שקפים. השיר לא הוטמע והמצגת לא שונתה.", approval_action="cancel") return admin_status_page("העלאת השיר בוטלה", "השיר לא הוטמע בנתיבי המצגת והמצגת לא שונתה.", ok=True, details=music_upload_duration_details(status)) save_result = commit_pending_audio_to_multiple_targets(pending_meta, FOLDERS["JAPAN"], JAPAN_MUSIC_TARGETS["japan_experience_music"], "JAPAN_music") if action == "loop_min_5": target_seconds = max(float(analysis.get("loop_total_seconds") or 0), float(probe.get("duration_seconds") or 0)) sync_result = sync_japan_experience_presentation_to_target_duration( target_seconds, sync_mode="short_song_audio_loop_min_5_seconds_per_slide", source_duration_seconds=probe.get("duration_seconds"), minimum_per_slide_seconds=JAPAN_EXPERIENCE_LOOP_MIN_SLIDE_SECONDS, ) sync_note = "השיר הוטמע, אך לא דחס את המצגת. המצגת הוארכה כך שלכל שקף יש לפחות 5 שניות, והשיר יתנגן בלופ." title = "השיר הוטמע בלופ והמצגת סונכרנה בבטחה" message = "השיר נשמר בנתיבי המצגת. בגלל שהוא קצר מדי, זמני השקפים נקבעו לרצפת 5 שניות לשקף והמוזיקה תמשיך בלופ." else: sync_result = sync_japan_experience_presentation_to_music_duration(probe.get("duration_seconds")) if analysis.get("state") == "too_short": sync_note = "השיר הוטמע לאחר אישור מפורש למרות שהוא יוצר פחות מ־5 שניות בממוצע לשקף." title = "השיר הוטמע לפי האורך המקורי" message = "השיר נשמר והמצגת סונכרנה לפי אורך השיר המקורי, בהתאם לאישור שניתן במסך האזהרה." elif analysis.get("state") == "too_long": sync_note = "השיר הוטמע לאחר אישור מפורש למרות שהוא יוצר מעל 10 שניות בממוצע לשקף." title = "השיר הארוך הוטמע לפי האורך המקורי" message = "השיר נשמר והמצגת סונכרנה לפי אורך השיר הארוך, בהתאם לאישור שניתן במסך האזהרה." else: sync_note = "השיר נמצא בטווח התקין 5–10 שניות בממוצע לשקף, ולכן הוטמע וסונכרן ללא אזהרה." title = "מוזיקת יפן הועלתה והמצגת סונכרנה" message = "השיר נשמר, משך השיר זוהה, וזמני השקפים עודכנו לפי האורך החדש." status = build_japan_music_duration_status("japan_experience_music", save_result, probe, sync_result=sync_result, sync_note=sync_note, approval_action=action) discard_pending_music_upload(token) details = "נשמר אל:\n" + "\n".join([item["path"] for item in save_result["targets"]]) + f"\n\nSHA256 MP3 סופי:\n{save_result['sha256']}" details += "\n\n" + media_details_text(save_result.get("media")) details += "\n\n" + music_upload_duration_details(status) return admin_status_page(title, message, ok=True, details=details) except Exception as exc: try: discard_pending_music_upload(token) except Exception: pass return admin_status_page("שגיאה באישור הטמעת שיר", "השיר לא הוטמע או שהפעולה לא הושלמה במלואה. בדוק את הפירוט לפני ניסיון חוזר.", ok=False, details=repr(exc)), 500 def media_details_text(media): if not media: return "" lines = [] if media.get("mode"): lines.append(f"מצב עיבוד: {media.get('mode')}") if media.get("original_size") is not None and media.get("final_size") is not None: lines.append(f"גודל לפני: {format_bytes(media.get('original_size'))}") lines.append(f"גודל אחרי: {format_bytes(media.get('final_size'))}") saved = int(media.get("saved_bytes") or 0) if saved > 0: lines.append(f"חיסכון: {format_bytes(saved)}") if media.get("original_dimensions"): lines.append(f"מידות מקור: {media.get('original_dimensions')}") if media.get("final_dimensions"): lines.append(f"מידות סופיות: {media.get('final_dimensions')}") if media.get("quality"): lines.append(f"איכות JPG: {media.get('quality')}") if media.get("bitrate"): lines.append(f"ביטרייט MP3: {media.get('bitrate')}") if media.get("ffmpeg"): lines.append(f"FFmpeg: {media.get('ffmpeg')}") return "\n".join(lines) def normalize_usa_image_target(target_variant): target_variant = (target_variant or "phone").strip().lower() if target_variant in {"mobile", "iphone", "phone", "פלאפון", "טלפון"}: return "phone" if target_variant in {"tv", "television", "screen", "טלוויזיה", "טלויזיה"}: return "tv" if target_variant not in USA_IMAGE_TARGETS: raise ValueError("יעד תמונות ארה״ב לא תקין. יש לבחור פלאפון או טלוויזיה.") return target_variant def usa_image_target_info(target_variant): target_variant = normalize_usa_image_target(target_variant) return target_variant, USA_IMAGE_TARGETS[target_variant] def usa_image_dir_for_target(target_variant): target_variant, info = usa_image_target_info(target_variant) return os.path.join(FOLDERS["USA"], info["folder"]) def ensure_usa_presentation_uses_image_target(target_variant): """Make sure each USA presentation points to its own image folder.""" target_variant, info = usa_image_target_info(target_variant) presentation_key = info.get("presentation_key") filename = USA_PRESENTATION_FILES.get(presentation_key) if not filename: return {"updated": False, "reason": "presentation_key_not_found", "target": target_variant} path = os.path.join(FOLDERS["USA"], filename) if not os.path.isfile(path): return {"updated": False, "reason": "presentation_file_missing", "target": target_variant, "path": path} html = read_text_file_utf8(path) desired = info["rel_prefix"] + "/" other = USA_IMAGE_TARGETS["tv" if target_variant == "phone" else "phone"]["rel_prefix"] + "/" new_html = html.replace(other, desired) if new_html == html: return {"updated": False, "reason": "already_correct", "target": target_variant, "path": path} backup = backup_existing_file(path, f"USA_presentation_image_path_{target_variant}") write_text_file_utf8(path, new_html) return {"updated": True, "target": target_variant, "path": path, "backup": backup, "sha256": file_sha256(path)} def save_usa_presentation_image(image_key, uploaded_file, target_variant="phone"): target_variant, target_info = usa_image_target_info(target_variant) if image_key not in USA_IMAGE_KEYS: return None original_name = uploaded_file.filename or "" if file_ext(original_name) not in USA_IMAGE_EXTENSIONS: raise ValueError("סיומת תמונה לא נתמכת. העלה JPG/JPEG/PNG/WebP/BMP/TIFF.") image_dir = usa_image_dir_for_target(target_variant) os.makedirs(image_dir, exist_ok=True) os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") tmp_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"usa_image_{target_variant}_{stamp}_{os.getpid()}_{secure_filename(image_key)}") uploaded_file.save(tmp_path) try: if os.path.getsize(tmp_path) <= 0: raise ValueError("קובץ התמונה ריק.") if os.path.getsize(tmp_path) > USA_IMAGES_ZIP_MAX_SINGLE_FILE_BYTES: raise ValueError("קובץ התמונה גדול מדי.") target_path = os.path.join(image_dir, image_key + ".jpg") backup_path = backup_existing_file(target_path, target_info["backup_tag"] + "_single") media = convert_or_copy_image_to_jpg(tmp_path, target_path, original_name) for old_ext in USA_IMAGE_EXTENSIONS - {".jpg"}: old_path = os.path.join(image_dir, image_key + old_ext) if os.path.exists(old_path): try: backup_existing_file(old_path, target_info["backup_tag"] + "_single_old_ext") os.remove(old_path) except Exception: pass path_update = ensure_usa_presentation_uses_image_target(target_variant) return { "target": target_variant, "target_label": target_info["label"], "rel": os.path.join(target_info["rel_prefix"], image_key + ".jpg"), "path": target_path, "mode": media.get("mode", "optimized"), "media": media, "backup": backup_path, "presentation_path_update": path_update, "sha256": file_sha256(target_path), "size": os.path.getsize(target_path), } finally: try: if os.path.exists(tmp_path): os.remove(tmp_path) except Exception: pass def save_usa_presentation_images_zip(uploaded_file, target_variant="phone"): target_variant, target_info = usa_image_target_info(target_variant) image_dir = usa_image_dir_for_target(target_variant) os.makedirs(image_dir, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") tmp_zip = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"usa_images_{target_variant}_{stamp}.zip") tmp_extract = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"usa_images_{target_variant}_extract_{stamp}") os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) os.makedirs(tmp_extract, exist_ok=True) uploaded_file.save(tmp_zip) zip_size = os.path.getsize(tmp_zip) if zip_size > USA_IMAGES_ZIP_MAX_BYTES: try: os.remove(tmp_zip) except Exception: pass raise ValueError(f"zip_size_exceeded:{zip_size}") imported = [] skipped = [] seen = set() try: with zipfile.ZipFile(tmp_zip, "r") as zf: infos = [info for info in zf.infolist() if not info.is_dir()] if len(infos) > USA_IMAGES_ZIP_MAX_FILES: raise ValueError(f"too_many_files:{len(infos)}") total_uncompressed = sum(max(0, info.file_size) for info in infos) if total_uncompressed > USA_IMAGES_ZIP_MAX_UNCOMPRESSED_BYTES: raise ValueError(f"zip_uncompressed_size_exceeded:{total_uncompressed}") for info in infos: raw_name = (info.filename or "").replace("\\", "/") base = os.path.basename(raw_name) if not base or base.startswith(".") or raw_name.startswith("__MACOSX/"): continue if info.file_size > USA_IMAGES_ZIP_MAX_SINGLE_FILE_BYTES: skipped.append(base + " — גדול מדי") continue stem, ext = os.path.splitext(base) stem = stem.strip() ext = ext.lower() if ext not in USA_IMAGE_EXTENSIONS: skipped.append(base + " — סיומת לא נתמכת") continue if stem not in USA_IMAGE_KEYS: skipped.append(base + " — שם לא שייך למצגת") continue if stem in seen: skipped.append(base + " — כפילות ב־ZIP") continue seen.add(stem) source_tmp = os.path.join(tmp_extract, stem + ext) with zf.open(info, "r") as source, open(source_tmp, "wb") as dest: shutil.copyfileobj(source, dest) target = os.path.join(image_dir, stem + ".jpg") try: backup_existing_file(target, target_info["backup_tag"] + "_zip") media = convert_or_copy_image_to_jpg(source_tmp, target, base) for old_ext in USA_IMAGE_EXTENSIONS - {".jpg"}: old_path = os.path.join(image_dir, stem + old_ext) if os.path.exists(old_path): try: backup_existing_file(old_path, target_info["backup_tag"] + "_zip_old_ext") os.remove(old_path) except Exception: pass imported.append(stem + ".jpg" + " — " + format_bytes(media.get("original_size", 0)) + " → " + format_bytes(media.get("final_size", 0))) except Exception as exc: skipped.append(base + " — לא הומר/נדחס ל־JPG: " + str(exc)) finally: try: os.remove(tmp_zip) except Exception: pass try: shutil.rmtree(tmp_extract, ignore_errors=True) except Exception: pass imported.sort() skipped.sort() missing = sorted(key + ".jpg" for key in USA_IMAGE_KEYS if not os.path.exists(os.path.join(image_dir, key + ".jpg"))) path_update = ensure_usa_presentation_uses_image_target(target_variant) return imported, skipped, missing, {"target": target_variant, "target_label": target_info["label"], "presentation_path_update": path_update} for folder_path in FOLDERS.values(): os.makedirs(folder_path, exist_ok=True) os.makedirs(os.path.join(FOLDERS["USA"], "media", "usa-presentation", "music"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["USA"], "media", "usa-presentation", "images"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["USA"], "media", "usa-presentation", "images-tv"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["JAPAN"], "media", "images"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["JAPAN"], "media", "japan-experience", "music"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["JAPAN"], "media", "japan-flight", "music"), exist_ok=True) os.makedirs(os.path.join(FOLDERS["JAPAN"], "media", "music"), exist_ok=True) os.makedirs(ADMIN_BACKUP_DIR, exist_ok=True) os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) def no_cache_response(response): response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0, private" response.headers["Pragma"] = "no-cache" response.headers["Expires"] = "0" # Prevent old HTML/images from being reused after upload when the browser sends If-None-Match/If-Modified-Since. response.headers.pop("ETag", None) response.headers.pop("Last-Modified", None) return response @app.after_request def add_global_no_cache_headers(response): return no_cache_response(response) def serve_file_no_cache(directory, file_name): try: response = make_response(send_from_directory(directory, file_name, conditional=False, max_age=0)) except TypeError: # Compatibility fallback for older Flask/Werkzeug versions. response = make_response(send_from_directory(directory, file_name)) return no_cache_response(response) def file_sha256(path): import hashlib h = hashlib.sha256() with open(path, "rb") as fh: for chunk in iter(lambda: fh.read(1024 * 1024), b""): h.update(chunk) return h.hexdigest() def ensure_parent_dir(path): parent = os.path.dirname(path) if parent: os.makedirs(parent, exist_ok=True) def backup_existing_file(target_path, backup_group="uploads"): if not os.path.exists(target_path) or not os.path.isfile(target_path): return None stamp = time.strftime("%Y%m%d_%H%M%S") safe_group = secure_filename(str(backup_group)) or "uploads" safe_name = secure_filename(os.path.basename(target_path)) or "file" backup_dir = os.path.join(UPLOAD_BACKUP_DIR, safe_group) os.makedirs(backup_dir, exist_ok=True) backup_path = os.path.join(backup_dir, f"{stamp}_{safe_name}") shutil.copy2(target_path, backup_path) return backup_path def atomic_save_upload(uploaded_file, target_path, backup_group="uploads"): """Save uploaded file atomically: tmp -> validate size -> backup old -> os.replace.""" ensure_parent_dir(target_path) os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") safe_target = secure_filename(os.path.basename(target_path)) or "upload.bin" tmp_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"tmp_{stamp}_{os.getpid()}_{safe_target}") try: uploaded_file.save(tmp_path) size = os.path.getsize(tmp_path) if size <= 0: raise ValueError("uploaded file is empty") backup_path = backup_existing_file(target_path, backup_group) os.replace(tmp_path, target_path) final_size = os.path.getsize(target_path) if final_size != size: raise IOError(f"size mismatch after save: tmp={size}, final={final_size}") return {"path": target_path, "size": final_size, "backup": backup_path, "sha256": file_sha256(target_path)} finally: try: if os.path.exists(tmp_path): os.remove(tmp_path) except Exception: pass def find_html_file(folder_path): index_path = os.path.join(folder_path, "index.html") if os.path.exists(index_path): return "index.html" html_files = [f for f in os.listdir(folder_path) if f.lower().endswith((".html", ".htm"))] if html_files: return html_files[0] return None def clean_wrong_main_files(folder_path): wrong_names = {"html", "htm", "index", "index.htm", "download", "unknown"} for name in os.listdir(folder_path): full_path = os.path.join(folder_path, name) if not os.path.isfile(full_path): continue if name.lower().strip() in wrong_names: try: os.remove(full_path) except Exception: pass def save_uploaded_file(folder, uploaded_file): folder_path = FOLDERS[folder] os.makedirs(folder_path, exist_ok=True) original_filename = uploaded_file.filename or "" safe_name = secure_filename(original_filename) if folder in APP_FOLDERS: clean_wrong_main_files(folder_path) filename = "index.html" else: filename = safe_name or f"upload_{int(time.time())}" target_path = os.path.join(folder_path, filename) result = atomic_save_upload(uploaded_file, target_path, backup_group=f"{folder}_main") return filename, result def save_japan_presentation(presentation_key, uploaded_file): if presentation_key not in JAPAN_PRESENTATION_FILES: return None japan_folder = FOLDERS["JAPAN"] os.makedirs(japan_folder, exist_ok=True) filename = JAPAN_PRESENTATION_FILES[presentation_key] target_path = os.path.join(japan_folder, filename) result = atomic_save_upload(uploaded_file, target_path, backup_group="JAPAN_presentations") return filename, result def save_usa_presentation(presentation_key, uploaded_file): if presentation_key not in USA_PRESENTATION_FILES: return None usa_folder = FOLDERS["USA"] os.makedirs(usa_folder, exist_ok=True) filename = USA_PRESENTATION_FILES[presentation_key] target_path = os.path.join(usa_folder, filename) result = atomic_save_upload(uploaded_file, target_path, backup_group="USA_presentations") return filename, result def save_usa_music(music_key, uploaded_file): if music_key not in USA_MUSIC_FILES: return None usa_folder = FOLDERS["USA"] rel_path = USA_MUSIC_FILES[music_key] full_path = os.path.join(usa_folder, rel_path) result = save_audio_upload_to_target(uploaded_file, full_path, backup_group="USA_music") return rel_path, result def save_usa_extra_html(extra_key, uploaded_file): if extra_key not in USA_EXTRA_HTML_FILES: return None filename = USA_EXTRA_HTML_FILES[extra_key] target_path = os.path.join(FOLDERS["USA"], filename) result = atomic_save_upload(uploaded_file, target_path, backup_group="USA_extra_html") return filename, result def save_file_to_multiple_targets(uploaded_file, base_folder, rel_paths, backup_group): os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") tmp_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"multi_upload_{stamp}_{os.getpid()}") uploaded_file.save(tmp_path) try: size = os.path.getsize(tmp_path) if size <= 0: raise ValueError("uploaded file is empty") sha = file_sha256(tmp_path) results = [] for rel_path in rel_paths: target_path = os.path.join(base_folder, rel_path) ensure_parent_dir(target_path) backup_path = backup_existing_file(target_path, backup_group) tmp_target = target_path + ".tmp" shutil.copy2(tmp_path, tmp_target) os.replace(tmp_target, target_path) results.append({"rel": rel_path, "path": target_path, "size": os.path.getsize(target_path), "sha256": file_sha256(target_path), "backup": backup_path}) return {"size": size, "sha256": sha, "targets": results} finally: try: if os.path.exists(tmp_path): os.remove(tmp_path) except Exception: pass def save_japan_music(music_key, uploaded_file): if music_key not in JAPAN_MUSIC_TARGETS: return None return save_audio_upload_to_multiple_targets(uploaded_file, FOLDERS["JAPAN"], JAPAN_MUSIC_TARGETS[music_key], "JAPAN_music") def normalize_japan_image_rel(raw_name): safe = safe_zip_relpath(raw_name) if not safe: return None lower = safe.lower() marker = "/media/images/" if marker in lower: idx = lower.index(marker) + len(marker) return safe[idx:] if lower.startswith("media/images/"): return safe[len("media/images/"):] if lower.startswith("images/"): return safe[len("images/"):] marker2 = "/images/" if marker2 in lower: idx = lower.index(marker2) + len(marker2) return safe[idx:] return None def save_japan_images_zip(uploaded_file): image_root = os.path.join(FOLDERS["JAPAN"], "media", "images") os.makedirs(image_root, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") tmp_zip = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"japan_images_{stamp}.zip") os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) uploaded_file.save(tmp_zip) imported, skipped, overwritten = [], [], [] try: if os.path.getsize(tmp_zip) > JAPAN_IMAGES_ZIP_MAX_BYTES: raise ValueError(f"zip_size_exceeded:{os.path.getsize(tmp_zip)}") with zipfile.ZipFile(tmp_zip, "r") as zf: infos = [info for info in zf.infolist() if not info.is_dir()] if len(infos) > JAPAN_IMAGES_ZIP_MAX_FILES: raise ValueError(f"too_many_files:{len(infos)}") total_uncompressed = sum(max(0, info.file_size) for info in infos) if total_uncompressed > JAPAN_IMAGES_ZIP_MAX_UNCOMPRESSED_BYTES: raise ValueError(f"zip_uncompressed_size_exceeded:{total_uncompressed}") for info in infos: rel = normalize_japan_image_rel(info.filename) base = os.path.basename((info.filename or "").replace("\\", "/")) if not rel: skipped.append(base + " — לא בתיקיית images/media/images") continue if info.file_size > JAPAN_IMAGES_ZIP_MAX_SINGLE_FILE_BYTES: skipped.append(rel + " — גדול מדי") continue if file_ext(rel) not in JAPAN_IMAGE_EXTENSIONS: skipped.append(rel + " — סיומת לא נתמכת") continue # Prevent traversal after normalization. if not safe_zip_relpath(rel): skipped.append(base + " — נתיב לא בטוח") continue target = os.path.join(image_root, *rel.split("/")) ensure_parent_dir(target) if os.path.exists(target): overwritten.append(rel) backup_existing_file(target, "JAPAN_images_zip") tmp_target = target + ".tmp" with zf.open(info, "r") as source, open(tmp_target, "wb") as dest: shutil.copyfileobj(source, dest) os.replace(tmp_target, target) imported.append(rel) finally: try: os.remove(tmp_zip) except Exception: pass return sorted(imported), sorted(skipped), sorted(overwritten) def normalize_trip_package_rel(trip, raw_name): safe = safe_zip_relpath(raw_name) if not safe: return None lower = safe.lower() if trip == "USA": if lower.startswith("usa/"): return safe[4:] # Also allow a package that contains USA files at root. # Do not accept root index.html from Netlify ZIPs, because it is usually only a root redirect/landing file and would overwrite USA/index.html. if lower in {"usa2027-presentation.html", "usa2027-presentation-tv.html", "usa2027-tv.html"} or lower.startswith("media/usa-presentation/"): return safe return None if trip == "JAPAN": if lower.startswith("japan/"): return safe[6:] if lower in {"index.html", "japan-experience.html", "japan-flight-intro.html", "japan-theme.mp3"} or lower.startswith("media/"): return safe return None return None def save_trip_package_zip(trip, uploaded_file): if trip not in {"USA", "JAPAN"}: return None base_folder = FOLDERS[trip] os.makedirs(base_folder, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") tmp_zip = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"{trip.lower()}_package_{stamp}.zip") os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) uploaded_file.save(tmp_zip) imported, skipped, overwritten = [], [], [] try: if os.path.getsize(tmp_zip) > TRIP_PACKAGE_ZIP_MAX_BYTES: raise ValueError(f"zip_size_exceeded:{os.path.getsize(tmp_zip)}") with zipfile.ZipFile(tmp_zip, "r") as zf: infos = [info for info in zf.infolist() if not info.is_dir()] if len(infos) > TRIP_PACKAGE_ZIP_MAX_FILES: raise ValueError(f"too_many_files:{len(infos)}") total_uncompressed = sum(max(0, info.file_size) for info in infos) if total_uncompressed > TRIP_PACKAGE_ZIP_MAX_UNCOMPRESSED_BYTES: raise ValueError(f"zip_uncompressed_size_exceeded:{total_uncompressed}") for info in infos: rel = normalize_trip_package_rel(trip, info.filename) base = os.path.basename((info.filename or "").replace("\\", "/")) if not rel: skipped.append(base + " — לא שייך לחבילת " + trip) continue if info.file_size > TRIP_PACKAGE_ZIP_MAX_SINGLE_FILE_BYTES: skipped.append(rel + " — גדול מדי") continue ext = file_ext(rel) if ext not in TRIP_PACKAGE_EXTENSIONS: skipped.append(rel + " — סיומת לא נתמכת") continue if not safe_zip_relpath(rel): skipped.append(base + " — נתיב לא בטוח") continue target = os.path.join(base_folder, *rel.split("/")) ensure_parent_dir(target) if os.path.exists(target): overwritten.append(rel) backup_existing_file(target, f"{trip}_package_zip") tmp_target = target + ".tmp" with zf.open(info, "r") as source, open(tmp_target, "wb") as dest: shutil.copyfileobj(source, dest) os.replace(tmp_target, target) imported.append(rel) finally: try: os.remove(tmp_zip) except Exception: pass return sorted(imported), sorted(skipped), sorted(overwritten) def normalize_netlify_trip_key(trip): trip = (trip or "").strip().upper() if trip in {"USA", "US", "AMERICA"}: return "USA" if trip in {"JAPAN", "JP"}: return "JAPAN" return "" def netlify_output_filename(trip): trip = normalize_netlify_trip_key(trip) stamp = time.strftime("%Y%m%d_%H%M%S") if trip == "USA": return f"USA2027_NETLIFY_DEPLOY_FROM_ADMIN_{stamp}.zip" if trip == "JAPAN": return f"JAPAN2026_NETLIFY_DEPLOY_FROM_ADMIN_{stamp}.zip" return f"NETLIFY_DEPLOY_{stamp}.zip" def netlify_is_static_file(path): base = os.path.basename(path or "").lower() if base in NETLIFY_SKIP_FILES: return False if base in NETLIFY_CONTROL_FILES: return True return file_ext(path) in NETLIFY_STATIC_EXTENSIONS def netlify_copy_static_tree(source_root, target_root, prefix=""): copied = [] if not os.path.isdir(source_root): raise FileNotFoundError(source_root) for dirpath, dirnames, filenames in os.walk(source_root): dirnames[:] = [d for d in dirnames if d.lower() not in NETLIFY_SKIP_DIRS and not d.startswith(".")] rel_dir = os.path.relpath(dirpath, source_root) if rel_dir == ".": rel_dir = "" for name in filenames: src = os.path.join(dirpath, name) if not netlify_is_static_file(src): continue rel = os.path.join(rel_dir, name) if rel_dir else name rel = rel.replace("\\", "/") if prefix: rel = prefix.strip("/") + "/" + rel safe = safe_zip_relpath(rel) if not safe: continue dst = os.path.join(target_root, *safe.split("/")) ensure_parent_dir(dst) shutil.copy2(src, dst) copied.append(safe) return sorted(copied, key=lambda x: x.lower()) def netlify_replace_attrs(html_text, replacer): attr_re = re.compile(r"(?P\b(?:href|src|poster|data-href)\s*=\s*)(?P[\"'])(?P.*?)(?P=quote)", re.I | re.S) def repl(match): url = match.group("url") new_url = replacer(url) if new_url is None: return match.group(0) return match.group("attr") + match.group("quote") + new_url + match.group("quote") return attr_re.sub(repl, html_text or "") def netlify_is_budget_url(url): u = str(url or "").strip().lower() return ( "beautiful-kitsune-dafd66.netlify.app" in u or "moneyapp" in u or "/moneyapp" in u or "trip-budget" in u or "vacation-budget" in u ) def netlify_patch_trip_html(trip, html_text): trip = normalize_netlify_trip_key(trip) text = html_text or "" def attr_replacer(url): u = str(url or "").strip() low = u.lower() if netlify_is_budget_url(u): return NETLIFY_BUDGET_APP_URL if trip == "USA" and "usa2027-presentation" in low: return "/USA/usa2027-presentation.html" if trip == "JAPAN" and ("japan-flight-intro.html" in low or "japan-experience.html" in low): return "./japan-flight-intro.html?from=trip" return None text = netlify_replace_attrs(text, attr_replacer) # Also cover common JavaScript button patterns such as window.open('...'). if trip == "USA": text = re.sub(r"https?://[^'\"\s<>]+/USA/usa2027-presentation\.html(?:\?[^'\"\s<>]*)?", "/USA/usa2027-presentation.html", text, flags=re.I) text = re.sub(r"(?]*)?", "/USA/usa2027-presentation.html", text, flags=re.I) elif trip == "JAPAN": text = re.sub(r"https?://[^'\"\s<>]+/JAPAN/japan-flight-intro\.html(?:\?[^'\"\s<>]*)?", "./japan-flight-intro.html?from=trip", text, flags=re.I) text = re.sub(r"https?://[^'\"\s<>]+/JAPAN/japan-experience\.html(?:\?[^'\"\s<>]*)?", "./japan-flight-intro.html?from=trip", text, flags=re.I) text = re.sub(r"https?://[^'\"\s<>]+/Moneyapp/?(?:index\.html)?(?:\?[^'\"\s<>]*)?", NETLIFY_BUDGET_APP_URL, text, flags=re.I) text = re.sub(r"https?://beautiful-kitsune-dafd66\.netlify\.app(?:/index\.html)?/?", NETLIFY_BUDGET_APP_URL, text, flags=re.I) return text def netlify_patch_all_html_files(build_root, trip): patched = [] trip = normalize_netlify_trip_key(trip) for dirpath, _, filenames in os.walk(build_root): for name in filenames: if file_ext(name) not in {".html", ".htm"}: continue path = os.path.join(dirpath, name) try: with open(path, "r", encoding="utf-8", errors="replace") as fh: text = fh.read() original = text # Remove private server links from generated Netlify bundles. if trip == "USA": text = re.sub(r"https?://work-room\.tail978ec2\.ts\.net/USA/", "/USA/", text, flags=re.I) text = re.sub(r"https?://[^'\"\s<>]+/USA/", "/USA/", text, flags=re.I) elif trip == "JAPAN": text = re.sub(r"https?://work-room\.tail978ec2\.ts\.net/JAPAN/", "./", text, flags=re.I) text = re.sub(r"https?://[^'\"\s<>]+/JAPAN/", "./", text, flags=re.I) text = re.sub(r"https?://work-room\.tail978ec2\.ts\.net/Moneyapp/?(?:index\.html)?", NETLIFY_BUDGET_APP_URL, text, flags=re.I) text = re.sub(r"https?://[^'\"\s<>]+/Moneyapp/?(?:index\.html)?", NETLIFY_BUDGET_APP_URL, text, flags=re.I) if os.path.relpath(path, build_root).replace("\\", "/") in {"index.html", "USA/index.html"}: text = netlify_patch_trip_html(trip, text) if text != original: with open(path, "w", encoding="utf-8", newline="") as fh: fh.write(text) patched.append(os.path.relpath(path, build_root).replace("\\", "/")) except Exception: raise return sorted(patched, key=lambda x: x.lower()) def netlify_write_usa_root_index(build_root): path = os.path.join(build_root, "index.html") html = """ טיול ארצות הברית 2027

טיול ארצות הברית 2027

מעביר לקובץ הטיול...

פתח טיול ארה״ב

""" with open(path, "w", encoding="utf-8", newline="") as fh: fh.write(html) return "index.html" def netlify_ensure_japan_top_anchor(build_root): path = os.path.join(build_root, "index.html") if not os.path.isfile(path): return False with open(path, "r", encoding="utf-8", errors="replace") as fh: text = fh.read() if 'id="top"' in text or "id='top'" in text: return False new_text = re.sub(r"(]*>)", r"\1\n
", text, count=1, flags=re.I) if new_text == text: new_text = '
\n' + text with open(path, "w", encoding="utf-8", newline="") as fh: fh.write(new_text) return True def netlify_write_usa_redirects(build_root): """Ensure USA Netlify bundles have a root control file for the /USA entry path.""" path = os.path.join(build_root, "_redirects") if os.path.isfile(path): return False redirects = "\n".join([ "/USA /USA/ 301", "/USA/* /USA/:splat 200", "" ]) with open(path, "w", encoding="utf-8", newline="") as fh: fh.write(redirects) return True def netlify_write_japan_redirects(build_root): """Ensure Japan Netlify bundles include the same redirect compatibility file used by the manual Netlify ZIPs.""" path = os.path.join(build_root, "_redirects") if os.path.isfile(path): return False redirects = "\n".join([ "/JAPAN/japan-flight-intro.html /japan-flight-intro.html 200", "/JAPAN/japan-experience.html /japan-experience.html 200", "/JAPAN/ /index.html 200", "/JAPAN/* /index.html 200", "/japan-flight-intro.html /japan-flight-intro.html 200", "/japan-experience.html /japan-experience.html 200", "" ]) with open(path, "w", encoding="utf-8", newline="") as fh: fh.write(redirects) return True def netlify_local_ref_to_path(build_root, html_rel, raw_url): url = str(raw_url or "").strip() if not url or url.startswith("#") or url.startswith("?"): return None low = url.lower() if low.startswith(("http://", "https://", "mailto:", "tel:", "sms:", "javascript:", "data:", "blob:", "about:", "//")): return None clean = url.split("#", 1)[0].split("?", 1)[0].strip() if not clean: return None if clean.startswith("/"): rel = clean.strip("/") else: base = os.path.dirname(html_rel) rel = os.path.normpath(os.path.join(base, clean)).replace("\\", "/") rel = rel.strip("/") if not rel or rel == ".": rel = "index.html" return rel def netlify_path_exists(build_root, rel): safe = safe_zip_relpath(rel) if not safe: return False path = os.path.join(build_root, *safe.split("/")) if os.path.isfile(path): return True if os.path.isdir(path) and os.path.isfile(os.path.join(path, "index.html")): return True if safe.endswith("/") and os.path.isfile(os.path.join(build_root, *safe.split("/"), "index.html")): return True return False def netlify_validate_build(build_root, trip): trip = normalize_netlify_trip_key(trip) errors, warnings, checked_refs = [], [], [] required = ["index.html"] if trip == "USA": required += ["USA/index.html", "USA/usa2027-presentation.html", "_redirects"] elif trip == "JAPAN": required += ["japan-flight-intro.html", "japan-experience.html", "_redirects"] for rel in required: if not netlify_path_exists(build_root, rel): errors.append("חסר קובץ חובה: " + rel) attr_re = re.compile(r"\b(?:href|src|poster|data-href)\s*=\s*[\"']([^\"']+)[\"']", re.I) for dirpath, _, filenames in os.walk(build_root): for name in filenames: if file_ext(name) not in {".html", ".htm"}: continue path = os.path.join(dirpath, name) html_rel = os.path.relpath(path, build_root).replace("\\", "/") with open(path, "r", encoding="utf-8", errors="replace") as fh: text = fh.read() if "work-room.tail978ec2.ts.net" in text or "tail978ec2" in text: errors.append("נשאר קישור לשרת הפרטי בתוך: " + html_rel) for raw_url in attr_re.findall(text): rel = netlify_local_ref_to_path(build_root, html_rel, raw_url) if not rel: continue # Ignore non-file route style links that Netlify cannot validate statically, except known trip paths. if not os.path.splitext(rel)[1] and not rel.endswith("/"): candidate_dir = os.path.join(build_root, *rel.split("/")) if not os.path.isdir(candidate_dir): continue checked_refs.append(html_rel + " -> " + rel) if not netlify_path_exists(build_root, rel): errors.append("קישור פנימי חסר: " + html_rel + " -> " + raw_url + " => " + rel) return {"ok": not errors, "errors": sorted(set(errors)), "warnings": sorted(set(warnings)), "checked_refs": len(checked_refs)} def zip_directory_contents(source_dir, zip_path): ensure_parent_dir(zip_path) if os.path.exists(zip_path): os.remove(zip_path) files = [] with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf: for dirpath, _, filenames in os.walk(source_dir): for name in sorted(filenames, key=lambda x: x.lower()): full = os.path.join(dirpath, name) rel = os.path.relpath(full, source_dir).replace("\\", "/") safe = safe_zip_relpath(rel) if not safe: continue zf.write(full, safe) files.append(safe) return files def build_netlify_deploy_zip(trip): trip = normalize_netlify_trip_key(trip) if trip not in {"USA", "JAPAN"}: raise ValueError("trip_not_supported") source_root = FOLDERS[trip] if not os.path.isdir(source_root): raise FileNotFoundError(source_root) stamp = time.strftime("%Y%m%d_%H%M%S") os.makedirs(NETLIFY_BUILD_DIR, exist_ok=True) os.makedirs(NETLIFY_EXPORT_DIR, exist_ok=True) build_root = os.path.join(NETLIFY_BUILD_DIR, trip.lower() + "_" + stamp) if os.path.exists(build_root): shutil.rmtree(build_root) os.makedirs(build_root, exist_ok=True) copied = [] if trip == "USA": copied.extend(netlify_copy_static_tree(source_root, build_root, prefix="USA")) netlify_write_usa_root_index(build_root) netlify_write_usa_redirects(build_root) else: copied.extend(netlify_copy_static_tree(source_root, build_root, prefix="")) netlify_ensure_japan_top_anchor(build_root) netlify_write_japan_redirects(build_root) patched = netlify_patch_all_html_files(build_root, trip) validation = netlify_validate_build(build_root, trip) if not validation.get("ok"): raise RuntimeError("netlify_validation_failed:\n" + "\n".join(validation.get("errors") or [])) zip_path = os.path.join(NETLIFY_EXPORT_DIR, netlify_output_filename(trip)) files = zip_directory_contents(build_root, zip_path) details = { "trip": trip, "source_root": source_root, "build_root": build_root, "zip_path": zip_path, "files": len(files), "copied": len(copied), "patched_html": patched, "validation": validation, "budget_app_url": NETLIFY_BUDGET_APP_URL, "presentation_link": "/USA/usa2027-presentation.html" if trip == "USA" else "./japan-flight-intro.html?from=trip", "size_bytes": os.path.getsize(zip_path) if os.path.exists(zip_path) else 0, } return zip_path, details def describe_path(path): exists = os.path.exists(path) item = {"path": path, "exists": exists} if exists and os.path.isfile(path): try: item["size"] = os.path.getsize(path) item["mtime"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(os.path.getmtime(path))) item["sha256"] = file_sha256(path)[:16] except Exception as exc: item["error"] = repr(exc) return item def count_files(root, extensions=None): total = 0 if not os.path.isdir(root): return 0 for dirpath, _, filenames in os.walk(root): for name in filenames: if extensions is None or file_ext(name) in extensions: total += 1 return total def list_relative_files(root, extensions=None): files = [] if not os.path.isdir(root): return files for dirpath, _, filenames in os.walk(root): for name in filenames: if extensions is None or file_ext(name) in extensions: full = os.path.join(dirpath, name) rel = os.path.relpath(full, root).replace("\\", "/") files.append(rel) return sorted(files, key=lambda x: x.lower()) def normalize_web_path(path): value = str(path or "").strip().replace("\\", "/") value = value.split("?", 1)[0].split("#", 1)[0] while value.startswith("./"): value = value[2:] return value def analyze_japan_presentation_images(presentation_path=None): """Count images that Japan experience actually uses, not just files in media/images.""" presentation_path = presentation_path or os.path.join(FOLDERS["JAPAN"], "japan-experience.html") image_root = os.path.join(FOLDERS["JAPAN"], "media", "images") folder_files = list_relative_files(image_root, JAPAN_IMAGE_EXTENSIONS) result = { "presentation_path": presentation_path, "presentation_exists": os.path.isfile(presentation_path), "folder_images": len(folder_files), "image_slides": 0, "external_image_uses": 0, "embedded_image_uses": 0, "remote_image_uses": 0, "other_src_uses": 0, "unique_external_images": 0, "missing_external_images": 0, "unused_folder_images": 0, "chapter_slides": 0, "notes": [], "missing_external_list": [], "unused_folder_list": [], } if not result["presentation_exists"]: result["notes"].append("קובץ המצגת japan-experience.html לא נמצא, לכן נספרו רק קבצים בתיקיית התמונות.") return result try: with open(presentation_path, "r", encoding="utf-8", errors="ignore") as fh: html_text = fh.read() except Exception as exc: result["notes"].append("לא ניתן לקרוא את קובץ מצגת יפן: " + repr(exc)) return result refs = [m.group(2).strip() for m in re.finditer(r'["\']src["\']\s*:\s*(["\'])(.*?)\1', html_text, re.S) if m.group(2).strip()] if not refs: refs = [m.group(2).strip() for m in re.finditer(r'\bsrc\s*:\s*(["\'])(.*?)\1', html_text, re.S) if m.group(2).strip()] external = [] embedded = [] remote = [] other = [] for ref in refs: clean = normalize_web_path(ref) if clean.startswith("media/images/"): external.append(clean[len("media/images/"):]) elif clean.startswith("data:image"): embedded.append(ref) elif clean.startswith("http://") or clean.startswith("https://"): remote.append(ref) else: other.append(ref) unique_external = sorted(set(external), key=lambda x: x.lower()) folder_lower = {f.lower(): f for f in folder_files} used_lower = {f.lower() for f in unique_external} missing = [rel for rel in unique_external if rel.lower() not in folder_lower] unused = [rel for rel in folder_files if rel.lower() not in used_lower] result.update({ "image_slides": len(refs), "external_image_uses": len(external), "embedded_image_uses": len(embedded), "remote_image_uses": len(remote), "other_src_uses": len(other), "unique_external_images": len(unique_external), "missing_external_images": len(missing), "unused_folder_images": len(unused), "chapter_slides": len(re.findall(r'["\']chapter["\']\s*:\s*true', html_text)), "missing_external_list": missing[:40], "unused_folder_list": unused[:40], }) if result["image_slides"] == 0: result["notes"].append("לא נמצאו src בשקפי מצגת יפן. ייתכן שמבנה המצגת השתנה.") if result["missing_external_images"]: result["notes"].append("יש תמונות שהמצגת מבקשת אבל אינן קיימות בתיקיית media/images.") if result["unused_folder_images"]: result["notes"].append("יש תמונות בתיקייה שאינן בשימוש במצגת הפעילה.") return result def compact_japan_usage_for_health(): usage = analyze_japan_presentation_images() return { "image_slides_total": usage.get("image_slides", 0), "external_files_used": usage.get("external_image_uses", 0), "embedded_images": usage.get("embedded_image_uses", 0), "folder_images": usage.get("folder_images", 0), "missing_external_images": usage.get("missing_external_images", 0), "unused_folder_images": usage.get("unused_folder_images", 0), "chapter_slides": usage.get("chapter_slides", 0), "presentation_exists": usage.get("presentation_exists", False), } def render_admin_status(): rows = [] def add(label, path): info = describe_path(path) status = "✅ קיים" if info.get("exists") else "❌ חסר" size = f"{info.get('size', 0):,}" if info.get("exists") and "size" in info else "—" mtime = info.get("mtime", "—") sha = info.get("sha256", "—") rows.append(f"{html_lib.escape(label)}{status}{size}{html_lib.escape(mtime)}{html_lib.escape(sha)}{html_lib.escape(path)}") add("פאנל פעיל", ADMIN_SERVER_PATH) add("טיול יפן ראשי", os.path.join(FOLDERS["JAPAN"], "index.html")) add("פתיח טיסה יפן", os.path.join(FOLDERS["JAPAN"], "japan-flight-intro.html")) add("מצגת יפן", os.path.join(FOLDERS["JAPAN"], "japan-experience.html")) add("מוזיקת מצגת יפן", os.path.join(FOLDERS["JAPAN"], "media", "japan-experience", "music", "japan-theme.mp3")) add("מוזיקת פתיח יפן", os.path.join(FOLDERS["JAPAN"], "media", "japan-flight", "music", "flight-intro.mp3")) add("טיול ארה״ב ראשי", os.path.join(FOLDERS["USA"], "index.html")) add("טיול ארה״ב TV", os.path.join(FOLDERS["USA"], "usa2027-tv.html")) add("מצגת ארה״ב", os.path.join(FOLDERS["USA"], "usa2027-presentation.html")) add("מצגת ארה״ב TV", os.path.join(FOLDERS["USA"], "usa2027-presentation-tv.html")) add("שיר ארה״ב חלק 1", os.path.join(FOLDERS["USA"], "media", "usa-presentation", "music", "usa-roadtrip-theme.mp3")) add("שיר ארה״ב חלק 2", os.path.join(FOLDERS["USA"], "media", "usa-presentation", "music", "usa-part2-theme.mp3")) add("תקציב טיולים", os.path.join(FOLDERS["Moneyapp"], "index.html")) add("תקציב משפחתי", os.path.join(FOLDERS["MoneyHome"], "index.html")) add("טופס פתיחת טיול", os.path.join(FOLDERS["TripForm"], "index.html")) usa_img_count = count_files(os.path.join(FOLDERS["USA"], "media", "usa-presentation", "images"), USA_IMAGE_EXTENSIONS) japan_usage = analyze_japan_presentation_images() japan_img_count = japan_usage["folder_images"] japan_usage_ok = japan_usage["presentation_exists"] and japan_usage["missing_external_images"] == 0 japan_usage_badge = "✅ תקין" if japan_usage_ok else "⚠️ לבדיקה" japan_usage_details = ( f"{japan_usage['external_image_uses']} קבצים חיצוניים + " f"{japan_usage['embedded_image_uses']} מוטמעות · " f"בתיקייה: {japan_img_count} · " f"לא בשימוש: {japan_usage['unused_folder_images']} · " f"חסרות: {japan_usage['missing_external_images']}" ) watchdog_info = watchdog_status(include_log=False) watchdog_label = "ON" if watchdog_info.get("task_installed") else "OFF" missing_html = "" if japan_usage["missing_external_images"]: missing_items = "".join(f"
  • {html_lib.escape(x)}
    • " for x in japan_usage["missing_external_list"][:20]) missing_html = f"
    תמונות חסרות למצגת יפן
      {missing_items}
    " unused_html = "" if japan_usage["unused_folder_images"]: unused_items = "".join(f"
  • {html_lib.escape(x)}
    • " for x in japan_usage["unused_folder_list"][:20]) more = "" if japan_usage["unused_folder_images"] > 20: more = f"

    ועוד {japan_usage['unused_folder_images'] - 20} קבצים שלא מוצגים כאן.

    " unused_html = f"
    תמונות בתיקיית יפן שלא בשימוש במצגת ({japan_usage['unused_folder_images']})
      {unused_items}
    {more}
    " return f""" סטטוס TripServer
    ⬅ חזרה לפאנל

    סטטוס קבצים פעילים

    כאן רואים בפועל מה מותקן כרגע ב־C:\\TripServer, כולל גודל, תאריך שינוי ו־SHA קצר. זה נועד למנוע מצב של “העליתי אבל אני רואה גרסה ישנה”.

    תמונות מצגת ארה״ב
    {usa_img_count}
    כרטיסיות העלאה מסונכרנות לשקפי ארה״ב.
    מצגת יפן — תמונות בשימוש בפועל
    {japan_usage['image_slides']}
    {japan_usage_badge} · {japan_usage_details}
    קבצים בתיקיית תמונות יפן
    {japan_img_count}
    זה מספר קבצים בתיקייה, לא מספר התמונות שהמצגת משתמשת בהן.
    גרסת פאנל
    {html_lib.escape(ADMIN_PANEL_VERSION)}
    {missing_html}{unused_html}{''.join(rows)}
    רכיבמצבגודל bytesעודכןSHA16נתיב
    """ def validate_admin_server_upload(tmp_path): size = os.path.getsize(tmp_path) if size <= 0: return False, "הקובץ ריק." if size > ADMIN_MAX_UPLOAD_BYTES: return False, f"הקובץ גדול מדי: {size:,} bytes. המגבלה היא {ADMIN_MAX_UPLOAD_BYTES:,} bytes." try: py_compile.compile(tmp_path, doraise=True) except py_compile.PyCompileError as exc: return False, "בדיקת קומפילציה נכשלה:\n" + str(exc) except Exception as exc: return False, "שגיאה בבדיקת הקובץ:\n" + repr(exc) try: with open(tmp_path, "r", encoding="utf-8", errors="ignore") as fh: content = fh.read(400000) except Exception as exc: return False, "לא ניתן לקרוא את הקובץ:\n" + repr(exc) required_tokens = ["Flask", "@app.route", "app.run", "BASE_DIR", "ADMIN_PORT", "restart_process_later", "upload_admin_server", "run_self_test_suite", "build_watchdog_code", "watchdog_status"] missing = [token for token in required_tokens if token not in content] if missing: return False, "הקובץ עבר קומפילציה, אבל לא נראה כמו admin_server.py של TripServer. חסרים סימנים: " + ", ".join(missing) return True, "OK" def extract_admin_server_from_zip_upload(zip_path, work_dir): """Validate a controlled admin update ZIP and extract only the admin Python file. Supported package format: - root admin_server.py, or - exactly one root-level .py file that passes TripServer admin validation. For safety, this route does not execute arbitrary scripts from the ZIP. """ size = os.path.getsize(zip_path) if size <= 0: return False, "קובץ ה־ZIP ריק.", None if size > ADMIN_MAX_PACKAGE_UPLOAD_BYTES: return False, f"קובץ ה־ZIP גדול מדי: {size:,} bytes. המגבלה היא {ADMIN_MAX_PACKAGE_UPLOAD_BYTES:,} bytes.", None try: with zipfile.ZipFile(zip_path, "r") as zf: infos = zf.infolist() if not infos: return False, "קובץ ה־ZIP ריק.", None unsafe = [] py_candidates = [] for info in infos: name = (info.filename or "").replace("\\", "/") clean = name.strip("/") if not clean or info.is_dir(): continue if clean.startswith("/") or ".." in clean.split("/"): unsafe.append(name) continue # Keep package execution intentionally disabled; only extract admin Python. if clean.lower() == "admin_server.py" or ("/" not in clean and clean.lower().endswith(".py")): py_candidates.append(clean) if unsafe: return False, "קובץ ה־ZIP כולל נתיבים לא בטוחים: " + ", ".join(unsafe[:6]), None if "admin_server.py" in py_candidates: selected = "admin_server.py" elif len(py_candidates) == 1: selected = py_candidates[0] else: return False, "ZIP עדכון אדמין חייב לכלול admin_server.py בשורש, או קובץ Python יחיד בשורש החבילה.", None os.makedirs(work_dir, exist_ok=True) extracted_path = os.path.join(work_dir, "admin_server_from_zip.py") with zf.open(selected, "r") as src, open(extracted_path, "wb") as dst: shutil.copyfileobj(src, dst) valid, details = validate_admin_server_upload(extracted_path) if not valid: try: os.remove(extracted_path) except Exception: pass return False, "admin_server.py שבתוך ה־ZIP נדחה:\n" + details, None return True, f"ZIP תקין. נבחר קובץ: {selected}", extracted_path except zipfile.BadZipFile: return False, "קובץ ZIP לא תקין או פגום.", None except Exception as exc: return False, "שגיאה בבדיקת ZIP:\n" + repr(exc), None def admin_status_page(title, message, ok=True, details=""): color = "#16a34a" if ok else "#dc2626" bg = "#052e1b" if ok else "#3f1d1d" safe_title = html_lib.escape(title) safe_message = html_lib.escape(message).replace("\n", "
    ") safe_details = html_lib.escape(details).replace("\n", "
    ") details_html = f"
    {safe_details}
    " if details else "" return f""" {safe_title}
    TripServer Admin

    {safe_title}

    {safe_message}

    {details_html} חזרה לפאנל
    מיועד לבדיקה יזומה בלבד אחרי עדכון/שחזור קובץ אדמין.
    """ def backup_current_admin_server(prefix="admin_server_backup"): os.makedirs(ADMIN_BACKUP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") backup_path = os.path.join(ADMIN_BACKUP_DIR, f"{prefix}_{stamp}.py") shutil.copy2(ADMIN_SERVER_PATH, backup_path) return backup_path def latest_admin_backup(): os.makedirs(ADMIN_BACKUP_DIR, exist_ok=True) backups = glob.glob(os.path.join(ADMIN_BACKUP_DIR, "admin_server_backup_*.py")) if not backups: return None return max(backups, key=os.path.getmtime) def log_control_bootstrap(message): try: os.makedirs(BASE_DIR, exist_ok=True) with open(CONTROL_BOOTSTRAP_LOG_PATH, "a", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | control-bootstrap | " + str(message) + "\n") except Exception: pass def quiet_pythonw_path(): exe = sys.executable or "python" base = os.path.basename(exe).lower() if base == "python.exe": candidate = os.path.join(os.path.dirname(exe), "pythonw.exe") if os.path.exists(candidate): return candidate return exe def build_control_server_code(): return '# -*- coding: utf-8 -*-\nimport os, sys, time, json, shutil, subprocess, socket, threading, traceback\nfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServer\nfrom urllib.parse import urlparse\nBASE_DIR = r"C:\\TripServer"\nADMIN_PORT = 8000\nCONTROL_PORT = 8010\nADMIN_SCRIPT = os.path.join(BASE_DIR, "admin_server.py")\nCONTROL_DIR = os.path.join(BASE_DIR, "control_server")\nPENDING_ADMIN = os.path.join(CONTROL_DIR, "pending_admin_server.py")\nREQUEST_JSON = os.path.join(CONTROL_DIR, "request.json")\nSTATUS_JSON = os.path.join(CONTROL_DIR, "status.json")\nFAILSAFE_STATUS_JSON = os.path.join(BASE_DIR, "admin_failsafe_status.json")\nLOG_PATH = os.path.join(CONTROL_DIR, "tripserver_control_server.log")\nBACKUP_DIR = os.path.join(BASE_DIR, "backups", "admin_server")\nPYTHON_EXE = sys.executable\nif os.path.basename(PYTHON_EXE).lower() == "pythonw.exe":\n c = os.path.join(os.path.dirname(PYTHON_EXE), "python.exe")\n if os.path.exists(c): PYTHON_EXE = c\nos.makedirs(CONTROL_DIR, exist_ok=True); os.makedirs(BACKUP_DIR, exist_ok=True)\n\ndef log(msg):\n try:\n with open(LOG_PATH, "a", encoding="utf-8") as f:\n f.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | control-v34 | " + str(msg) + "\\n")\n except Exception: pass\n\ndef write_status(**kw):\n data={"updated_at":time.strftime("%Y-%m-%d %H:%M:%S"),"control_port":CONTROL_PORT,"admin_port":ADMIN_PORT,"python":PYTHON_EXE}\n data.update(kw)\n try:\n with open(STATUS_JSON,"w",encoding="utf-8") as f: json.dump(data,f,ensure_ascii=False,indent=2)\n except Exception as e: log("status write failed "+repr(e))\n return data\n\ndef port_open(port):\n s=socket.socket(socket.AF_INET,socket.SOCK_STREAM); s.settimeout(0.7)\n try: return s.connect_ex(("127.0.0.1",int(port)))==0\n finally:\n try: s.close()\n except Exception: pass\n\ndef admin_ping_ok():\n try:\n import urllib.request\n with urllib.request.urlopen("http://127.0.0.1:%s/ping.json"%ADMIN_PORT,timeout=1.5) as r: return r.status==200\n except Exception: return False\n\ndef pids_on_port(port):\n pids=[]\n if os.name!="nt": return pids\n try:\n cp=subprocess.run(["netstat","-ano","-p","tcp"],capture_output=True,text=True,timeout=8)\n for line in (cp.stdout or "").splitlines():\n low=line.lower()\n if (":"+str(port)) in low and "listening" in low:\n parts=line.split(); pid=parts[-1] if parts else ""\n if pid.isdigit() and int(pid) not in pids: pids.append(int(pid))\n except Exception as e: log("pids_on_port failed "+repr(e))\n return pids\n\ndef kill_admin():\n pids=pids_on_port(ADMIN_PORT); log("kill_admin pids="+repr(pids))\n for pid in pids:\n if pid==os.getpid(): continue\n try:\n cp=subprocess.run(["taskkill","/PID",str(pid),"/F"],capture_output=True,text=True,timeout=12)\n log("taskkill pid=%s rc=%s out=%s err=%s"%(pid,cp.returncode,(cp.stdout or "").strip(),(cp.stderr or "").strip()))\n except Exception as e: log("taskkill failed pid=%s %r"%(pid,e))\n deadline=time.time()+8\n while time.time()"+txt.replace("<","<")+""); return\n html="""TripServer Control

    TripServer Control Server

    שרת בקרה חיצוני לפורט 8000. לא תלוי באדמין הראשי.

    Status JSON · Log

    """\n self._send(200,html)\n def do_POST(self):\n path=urlparse(self.path).path\n if path=="/restart": ok,msg=restart_admin("http"); self._send(200 if ok else 500,json.dumps({"ok":ok,"message":msg},ensure_ascii=False),"application/json; charset=utf-8"); return\n if path=="/apply-update": ok,msg=apply_update("http"); self._send(200 if ok else 500,json.dumps({"ok":ok,"message":msg},ensure_ascii=False),"application/json; charset=utf-8"); return\n self._send(404,"not found")\n def log_message(self,fmt,*args): log("http "+(fmt%args))\nif __name__=="__main__":\n log("starting control server python="+sys.executable)\n write_status(last_action="control_start",ok=True)\n threading.Thread(target=poll_loop,daemon=True).start()\n srv=ThreadingHTTPServer(("0.0.0.0",CONTROL_PORT),Handler)\n log("listening on port "+str(CONTROL_PORT))\n srv.serve_forever()\n' def control_server_is_alive(): try: with urllib.request.urlopen(f"http://127.0.0.1:{CONTROL_PORT}/ping.json", timeout=1.0) as resp: return resp.status == 200 except Exception: return False def bootstrap_control_server(reason="startup"): try: os.makedirs(CONTROL_DIR, exist_ok=True) code = build_control_server_code() current = None if os.path.exists(CONTROL_SCRIPT_PATH): try: current = open(CONTROL_SCRIPT_PATH, "r", encoding="utf-8", errors="replace").read() except Exception: current = None if current != code: compile(code, CONTROL_SCRIPT_PATH, "exec") with open(CONTROL_SCRIPT_PATH, "w", encoding="utf-8") as fh: fh.write(code) log_control_bootstrap("control script written " + CONTROL_SCRIPT_PATH) pyw = quiet_pythonw_path() if os.name == "nt": cp = subprocess.run(["schtasks", "/Create", "/TN", CONTROL_TASK_NAME, "/SC", "ONLOGON", "/TR", f'"{pyw}" "{CONTROL_SCRIPT_PATH}"', "/F"], capture_output=True, text=True, timeout=20) log_control_bootstrap("schtasks create rc=%s out=%s err=%s" % (cp.returncode, (cp.stdout or "").strip(), (cp.stderr or "").strip())) run = subprocess.run(["schtasks", "/Run", "/TN", CONTROL_TASK_NAME], capture_output=True, text=True, timeout=20) log_control_bootstrap("schtasks run rc=%s out=%s err=%s" % (run.returncode, (run.stdout or '').strip(), (run.stderr or '').strip())) if not control_server_is_alive(): flags = 0 if os.name == "nt": flags |= getattr(subprocess, "CREATE_NO_WINDOW", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) | 0x00000008 subprocess.Popen([pyw, CONTROL_SCRIPT_PATH], cwd=BASE_DIR, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=flags) log_control_bootstrap("direct control start requested via " + pyw) return True, "OK" except Exception as exc: log_control_bootstrap("bootstrap failed " + repr(exc)) return False, repr(exc) def write_control_request(action, reason="admin", pending_path=None): os.makedirs(CONTROL_DIR, exist_ok=True) req = { "action": action, "reason": reason, "requested_at": time.strftime("%Y-%m-%d %H:%M:%S"), "not_before": time.time() + 2.5, "admin_pid": os.getpid(), "pending_admin_path": pending_path or CONTROL_PENDING_ADMIN_PATH, } with open(CONTROL_REQUEST_PATH, "w", encoding="utf-8") as fh: json.dump(req, fh, ensure_ascii=False, indent=2) return req def log_admin_restart(message): try: os.makedirs(BASE_DIR, exist_ok=True) with open(ADMIN_RESTART_LOG_PATH, "a", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | " + str(message) + "\n") except Exception: pass def build_restart_helper_code(script_path, python_exe, work_dir, current_pid=None, backup_path=None, expected_sha=None, reason=""): """Build a simple and conservative restart helper. v29 change: stop doing rollback/health gating inside the helper. The logs from the real Windows machine showed the new Flask server starts, but the helper's own health request sometimes times out and then incorrectly rolls back or leaves the port in a bad state. Since uploaded admin files already pass compile + TripServer validation before replacement, the safest behavior is: wait, release port 8000, start admin_server.py, write logs, exit. Watchdog and the browser then verify availability through /ping.json. """ return "\n".join([ "# -*- coding: utf-8 -*-", "import os", "import sys", "import subprocess", "import time", "import socket", "import hashlib", "", f"script_path = {script_path!r}", f"python_exe = {python_exe!r}", f"work_dir = {work_dir!r}", f"log_path = {ADMIN_RESTART_LOG_PATH!r}", f"admin_port = {ADMIN_PORT!r}", f"current_pid = {int(current_pid or 0)!r}", f"backup_path = {backup_path!r}", f"expected_sha = {expected_sha!r}", f"reason = {reason!r}", "", "def log(message):", " try:", " os.makedirs(os.path.dirname(log_path), exist_ok=True)", " with open(log_path, 'a', encoding='utf-8') as fh:", " fh.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | restart-v29 | ' + str(message) + '\\n')", " except Exception:", " pass", "", "def file_sha256(path):", " h = hashlib.sha256()", " with open(path, 'rb') as fh:", " for chunk in iter(lambda: fh.read(1024 * 1024), b''):", " h.update(chunk)", " return h.hexdigest()", "", "def port_open():", " try:", " with socket.create_connection(('127.0.0.1', int(admin_port)), timeout=0.7):", " return True", " except Exception:", " return False", "", "def wait_port_closed(timeout=12):", " deadline = time.time() + timeout", " while time.time() < deadline:", " if not port_open():", " return True", " time.sleep(0.4)", " return not port_open()", "", "def pids_on_port():", " pids = []", " if os.name != 'nt':", " return pids", " try:", " cp = subprocess.run(['netstat', '-ano', '-p', 'tcp'], capture_output=True, text=True, shell=False, timeout=10)", " out = (cp.stdout or '') + '\\n' + (cp.stderr or '')", " marker = ':' + str(admin_port)", " for line in out.splitlines():", " if marker not in line or 'listen' not in line.lower():", " continue", " parts = line.split()", " if parts:", " try:", " pid = int(parts[-1])", " if pid and pid not in pids:", " pids.append(pid)", " except Exception:", " pass", " except Exception as exc:", " log('netstat failed: ' + repr(exc))", " return pids", "", "def kill_pid(pid):", " try:", " pid = int(pid)", " except Exception:", " return False", " if pid <= 0 or pid == os.getpid():", " log('skip kill pid=' + str(pid) + ' self=' + str(os.getpid()))", " return False", " try:", " if os.name == 'nt':", " # No /T. Kill only the process that owns port 8000, never a tree.", " cp = subprocess.run(['taskkill', '/PID', str(pid), '/F'], capture_output=True, text=True, shell=False, timeout=12)", " log('taskkill pid=' + str(pid) + ' rc=' + str(cp.returncode) + ' out=' + ((cp.stdout or cp.stderr or "").strip()[:500]))", " return cp.returncode == 0", " os.kill(pid, 9)", " return True", " except Exception as exc:", " log('kill failed pid=' + str(pid) + ' err=' + repr(exc))", " return False", "", "def release_port():", " # Give the old request time to finish and Flask to exit if it exits naturally.", " if wait_port_closed(10):", " log('port closed naturally')", " return", " pids = pids_on_port()", " log('port still open; killing owners without rollback; current_pid=' + str(current_pid) + ' pids=' + str(pids))", " for pid in pids:", " kill_pid(pid)", " wait_port_closed(10)", " log('port open after release=' + str(port_open()) + ' pids=' + str(pids_on_port()))", "", "def start_server():", " flags = 0", " if os.name == 'nt':", " flags = getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0) | getattr(subprocess, 'DETACHED_PROCESS', 0) | getattr(subprocess, 'CREATE_BREAKAWAY_FROM_JOB', 0)", " env = os.environ.copy()", " env.setdefault('PYTHONIOENCODING', 'utf-8')", " os.makedirs(os.path.dirname(log_path), exist_ok=True)", " with open(log_path, 'a', encoding='utf-8') as log_file:", " log_file.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | restart-v29 | starting admin: ' + script_path + '\\n')", " log_file.flush()", " proc = subprocess.Popen([python_exe, script_path], cwd=work_dir, stdin=subprocess.DEVNULL, stdout=log_file, stderr=log_file, close_fds=(False if os.name == 'nt' else True), creationflags=flags, start_new_session=(os.name != 'nt'), env=env)", " log_file.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | restart-v29 | started admin pid=' + str(proc.pid) + '\\n')", " log_file.flush()", " return proc.pid", "", "def main():", " log('simple restart started reason=' + str(reason) + ' script=' + script_path + ' python=' + python_exe + ' expected_sha=' + str(expected_sha) + ' backup=' + str(backup_path))", " time.sleep(2.5)", " if expected_sha:", " try:", " actual = file_sha256(script_path)", " log('active sha=' + actual + ' expected=' + str(expected_sha))", " except Exception as exc:", " log('sha check failed: ' + repr(exc))", " release_port()", " start_server()", " # Do not call /health or /ping here and do not roll back. Previous versions", " # produced false timeout failures even though Flask was already running.", " log('simple restart helper finished; browser/watchdog will verify /ping.json')", " return 0", "", "if __name__ == '__main__':", " raise SystemExit(main())", "", ]) + "\n" def validate_restart_helper_source(helper_code): try: compile(helper_code, "", "exec") return True, "OK" except Exception as exc: return False, repr(exc) def write_restart_helper(script_path, python_exe, work_dir, backup_path=None, expected_sha=None, reason=""): helper_code = build_restart_helper_code(script_path, python_exe, work_dir, os.getpid(), backup_path, expected_sha, reason) ok, info = validate_restart_helper_source(helper_code) if not ok: raise RuntimeError("Generated restart helper is invalid: " + info) ensure_parent_dir(ADMIN_RESTART_HELPER_PATH) with open(ADMIN_RESTART_HELPER_PATH, "w", encoding="utf-8") as fh: fh.write(helper_code) py_compile.compile(ADMIN_RESTART_HELPER_PATH, doraise=True) return ADMIN_RESTART_HELPER_PATH def restart_process_later(backup_path=None, expected_sha=None, reason="manual_restart"): """Hard self-restart for Windows/iPhone admin workflow. v23: the helper can force-release a stuck port safely and roll back to the previous admin backup if the newly uploaded admin does not pass /ping.json after boot. """ time.sleep(1.2) script_path = os.path.abspath(ADMIN_SERVER_PATH) python_exe = sys.executable or "python" work_dir = os.path.dirname(script_path) or BASE_DIR try: log_admin_restart(f"hard restart requested | reason={reason} | version={ADMIN_PANEL_VERSION} | script={script_path} | python={python_exe} | pid={os.getpid()} | backup={backup_path} | expected_sha={expected_sha} | argv={sys.argv}") helper_path = write_restart_helper(script_path, python_exe, work_dir, backup_path=backup_path, expected_sha=expected_sha, reason=reason) flags = 0 if os.name == "nt": flags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) | getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(subprocess, "CREATE_BREAKAWAY_FROM_JOB", 0) subprocess.Popen( [python_exe, helper_path], cwd=work_dir, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, close_fds=(False if os.name == "nt" else True), creationflags=flags, start_new_session=(os.name != "nt"), ) log_admin_restart("hard restart helper launched: " + helper_path) os._exit(0) except Exception as exc: log_admin_restart("hard restart helper failed: " + repr(exc)) try: subprocess.Popen([python_exe, script_path], cwd=work_dir, close_fds=True, start_new_session=(os.name != "nt")) os._exit(0) except Exception as exc2: log_admin_restart("direct restart fallback failed: " + repr(exc2)) try: os.execv(python_exe, [python_exe, script_path]) except Exception as exc3: log_admin_restart("execv fallback failed: " + repr(exc3)) os._exit(1) def launch_restart_helper_via_scheduler(helper_path, python_exe, work_dir): """Launch restart helper as an independent Windows Scheduled Task. This is more reliable than subprocess.Popen from the Flask process because the helper is not a child of the admin process it is about to kill. On Windows, self-restart helpers launched as child processes can be terminated together with the old server or stuck in the same job/process group. """ if os.name != "nt": raise RuntimeError("Task Scheduler restart is supported only on Windows") quiet_python = get_pythonw_executable(python_exe) task_command = f'"{quiet_python}" "{helper_path}"' # Create a normal on-demand task. The time is deliberately far in the future; # we immediately run it with /Run, and then overwrite it on the next update. create_cmd = [ "schtasks", "/Create", "/TN", RESTART_TASK_NAME, "/TR", task_command, "/SC", "ONCE", "/ST", "23:59", "/F", ] cp_create = subprocess.run(create_cmd, capture_output=True, text=True, shell=False, timeout=20) create_out = (cp_create.stdout or cp_create.stderr or "").strip() if cp_create.returncode != 0: raise RuntimeError("Failed to create restart task: " + (create_out or str(cp_create.returncode))) cp_run = subprocess.run(["schtasks", "/Run", "/TN", RESTART_TASK_NAME], capture_output=True, text=True, shell=False, timeout=20) run_out = (cp_run.stdout or cp_run.stderr or "").strip() if cp_run.returncode != 0: raise RuntimeError("Failed to run restart task: " + (run_out or str(cp_run.returncode))) log_admin_restart("restart helper launched via Task Scheduler | task=" + RESTART_TASK_NAME + " | python=" + quiet_python + " | create=" + create_out + " | run=" + run_out) return {"task": RESTART_TASK_NAME, "python": quiet_python, "create": create_out, "run": run_out} def launch_safe_external_restart(backup_path=None, expected_sha=None, reason="safe_external_restart"): """Launch a detached restart helper through Task Scheduler. v27: this is the important architectural fix. The helper is no longer a direct child of the Flask/admin process. It is started by Windows Task Scheduler, then it can safely kill the old process on port 8000 and start the new admin without dying with its parent. """ script_path = os.path.abspath(ADMIN_SERVER_PATH) python_exe = sys.executable or "python" work_dir = os.path.dirname(script_path) or BASE_DIR log_admin_restart( f"scheduler restart requested | reason={reason} | version={ADMIN_PANEL_VERSION} | script={script_path} | python={python_exe} | pid={os.getpid()} | backup={backup_path} | expected_sha={expected_sha}" ) helper_path = write_restart_helper(script_path, python_exe, work_dir, backup_path=backup_path, expected_sha=expected_sha, reason=reason) try: task_info = launch_restart_helper_via_scheduler(helper_path, python_exe, work_dir) return helper_path + " | task=" + str(task_info.get("task")) + " | python=" + str(task_info.get("python")) except Exception as exc: # Fallback only: use direct detached Popen if Task Scheduler is unavailable. # This preserves some functionality, but the scheduled task path is the # intended reliable path on the user's Windows server. log_admin_restart("Task Scheduler restart launch failed, falling back to detached Popen: " + repr(exc)) flags = 0 if os.name == "nt": flags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) | getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(subprocess, "CREATE_BREAKAWAY_FROM_JOB", 0) quiet_python = get_pythonw_executable(python_exe) subprocess.Popen( [quiet_python, helper_path], cwd=work_dir, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, close_fds=(False if os.name == "nt" else True), creationflags=flags, start_new_session=(os.name != "nt"), ) log_admin_restart("restart helper launched through fallback detached Popen: " + helper_path) return helper_path + " | fallback=detached-popen" def build_watchdog_code(script_path, python_exe, work_dir): """Build a one-shot watchdog script for Windows Task Scheduler. v28 change: if the port is open but /ping.json fails repeatedly, the watchdog treats it as a stuck admin process, kills the process that owns port 8000, and starts admin_server.py again. This is the case that forced a physical reboot. """ return "\n".join([ "# -*- coding: utf-8 -*-", "import os", "import sys", "import time", "import socket", "import subprocess", "import urllib.request", "import json", "", f"script_path = {script_path!r}", f"python_exe = {python_exe!r}", f"work_dir = {work_dir!r}", f"admin_port = {ADMIN_PORT!r}", f"health_url = {'http://127.0.0.1:%s/ping.json' % ADMIN_PORT!r}", f"log_path = {WATCHDOG_LOG_PATH!r}", f"state_path = {WATCHDOG_STATE_PATH!r}", f"cooldown_seconds = {WATCHDOG_MIN_RESTART_INTERVAL_SECONDS!r}", "", "def log(message):", " try:", " os.makedirs(os.path.dirname(log_path), exist_ok=True)", " with open(log_path, 'a', encoding='utf-8') as fh:", " fh.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | watchdog-v28 | ' + str(message) + '\\n')", " except Exception:", " pass", "", "def load_state():", " try:", " raw = open(state_path, 'r', encoding='utf-8').read().strip()", " if not raw:", " return {}", " try:", " data = json.loads(raw)", " return data if isinstance(data, dict) else {}", " except Exception:", " return {'last_start': float(raw)}", " except Exception:", " return {}", "", "def save_state(state):", " try:", " os.makedirs(os.path.dirname(state_path), exist_ok=True)", " with open(state_path, 'w', encoding='utf-8') as fh:", " json.dump(state, fh)", " except Exception:", " pass", "", "def port_open():", " try:", " with socket.create_connection(('127.0.0.1', int(admin_port)), timeout=2.0):", " return True", " except Exception:", " return False", "", "def pids_on_port():", " pids = []", " if os.name != 'nt':", " return pids", " try:", " cp = subprocess.run(['netstat', '-ano', '-p', 'tcp'], capture_output=True, text=True, shell=False, timeout=10)", " out = (cp.stdout or '') + '\\n' + (cp.stderr or '')", " marker = ':' + str(admin_port)", " for line in out.splitlines():", " if marker not in line or 'listen' not in line.lower():", " continue", " parts = line.split()", " if parts:", " try:", " pid = int(parts[-1])", " if pid and pid not in pids:", " pids.append(pid)", " except Exception:", " pass", " except Exception as exc:", " log('netstat failed: ' + repr(exc))", " return pids", "", "def kill_port_owner(pid):", " # v23: avoid /T even in watchdog. If run-once was launched from the admin", " # panel, /T could kill the watchdog child together with the stuck admin.", " try:", " pid = int(pid)", " except Exception:", " return False", " if pid <= 0 or pid == os.getpid():", " log('skip killing pid=' + str(pid) + ' self=' + str(os.getpid()))", " return False", " try:", " if os.name == 'nt':", " cp = subprocess.run(['taskkill', '/PID', str(pid), '/F'], capture_output=True, text=True, shell=False, timeout=12)", " log('taskkill-port-owner pid=' + str(pid) + ' rc=' + str(cp.returncode) + ' out=' + ((cp.stdout or cp.stderr or "").strip()[:500]))", " return cp.returncode == 0", " os.kill(pid, 9)", " return True", " except Exception as exc:", " log('kill port owner failed pid=' + str(pid) + ' err=' + repr(exc))", " return False", "", "def wait_port_closed(timeout=12):", " deadline = time.time() + timeout", " while time.time() < deadline:", " if not port_open():", " return True", " time.sleep(0.6)", " return not port_open()", "", "def health_ok():", " try:", " req = urllib.request.Request(health_url, headers={'Accept': 'application/json'})", " with urllib.request.urlopen(req, timeout=4.0) as resp:", " raw = resp.read(8192).decode('utf-8', errors='replace')", " data = json.loads(raw)", " return bool(data.get('ok')), 'OK' if data.get('ok') else raw[:500]", " except Exception as exc:", " return False, repr(exc)", "", "def recently_started(state):", " try:", " last = float(state.get('last_start') or 0)", " return (time.time() - last) < float(cooldown_seconds)", " except Exception:", " return False", "", "def mark_started(state):", " state['last_start'] = time.time()", " state['failure_count'] = 0", " save_state(state)", "", "def script_compiles():", " try:", " import py_compile", " py_compile.compile(script_path, doraise=True)", " return True, 'OK'", " except Exception as exc:", " return False, repr(exc)", "", "def launch_admin(state):", " flags = 0", " if os.name == 'nt':", " flags = getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0) | getattr(subprocess, 'DETACHED_PROCESS', 0)", " env = os.environ.copy()", " env.setdefault('PYTHONIOENCODING', 'utf-8')", " os.makedirs(os.path.dirname(log_path), exist_ok=True)", " with open(log_path, 'a', encoding='utf-8') as log_file:", " log_file.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | watchdog-v28 | starting admin: ' + script_path + '\\n')", " log_file.flush()", " proc = subprocess.Popen(", " [python_exe, script_path],", " cwd=work_dir,", " stdin=subprocess.DEVNULL,", " stdout=log_file,", " stderr=log_file,", " close_fds=(False if os.name == 'nt' else True),", " creationflags=flags,", " start_new_session=(os.name != 'nt'),", " env=env,", " )", " log_file.write(time.strftime('%Y-%m-%d %H:%M:%S') + ' | watchdog-v28 | started pid=' + str(proc.pid) + '\\n')", " mark_started(state)", "", "def main():", " state = load_state()", " ok, info = health_ok()", " if ok:", " if state.get('failure_count'):", " state['failure_count'] = 0", " save_state(state)", " return 0", " fail_count = int(state.get('failure_count') or 0) + 1", " state['failure_count'] = fail_count", " save_state(state)", " is_port_open = port_open()", " log('health failed count=' + str(fail_count) + ' port_open=' + str(is_port_open) + ' info=' + str(info))", " if recently_started(state):", " log('restart cooldown active; skip this minute')", " return 3", " if is_port_open:", " pids = pids_on_port()", " if fail_count < 2:", " log('port is open but health failed; waiting for second failure before hard kill. pids=' + str(pids))", " return 2", " log('port open + repeated health failure; killing stuck pids=' + str(pids))", " for pid in pids:", " kill_port_owner(pid)", " wait_port_closed(14)", " if not os.path.exists(script_path):", " log('admin script not found: ' + script_path)", " return 4", " ok_compile, compile_info = script_compiles()", " if not ok_compile:", " log('admin script does not compile; not starting. info=' + str(compile_info))", " return 5", " try:", " launch_admin(state)", " return 10", " except Exception as exc:", " log('failed to launch admin: ' + repr(exc))", " return 6", "", "if __name__ == '__main__':", " raise SystemExit(main())", "", ]) + "\n" def validate_watchdog_source(watchdog_code): try: compile(watchdog_code, "", "exec") return True, "OK" except Exception as exc: return False, repr(exc) def write_watchdog_script(): script_path = os.path.abspath(ADMIN_SERVER_PATH) python_exe = sys.executable or "python" work_dir = os.path.dirname(script_path) or BASE_DIR source = build_watchdog_code(script_path, python_exe, work_dir) ok, info = validate_watchdog_source(source) if not ok: raise RuntimeError("Generated watchdog script is invalid: " + info) ensure_parent_dir(WATCHDOG_SCRIPT_PATH) with open(WATCHDOG_SCRIPT_PATH, "w", encoding="utf-8") as fh: fh.write(source) py_compile.compile(WATCHDOG_SCRIPT_PATH, doraise=True) return WATCHDOG_SCRIPT_PATH def read_log_tail(path, max_lines=18): try: with open(path, "r", encoding="utf-8", errors="replace") as fh: lines = fh.readlines() return "".join(lines[-max_lines:]).strip() except Exception: return "" def safe_int(value, default, min_value=None, max_value=None): try: parsed = int(value) except Exception: parsed = default if min_value is not None: parsed = max(min_value, parsed) if max_value is not None: parsed = min(max_value, parsed) return parsed def log_file_summary(log_key, max_lines=LOG_TAIL_DEFAULT_LINES): meta = LOG_FILE_REGISTRY.get(log_key) if not meta: return None path = meta["path"] exists = os.path.exists(path) size = os.path.getsize(path) if exists else 0 updated = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(os.path.getmtime(path))) if exists else "לא קיים עדיין" tail = read_log_tail(path, max_lines=max_lines) if exists else "אין עדיין לוג. הוא יווצר אחרי פעולה ראשונה." return { "key": log_key, "label": meta["label"], "note": meta.get("note", ""), "path": path, "exists": exists, "size": size, "size_label": format_bytes(size), "updated": updated, "tail": tail, } def build_logs_payload(max_lines=LOG_TAIL_DEFAULT_LINES): max_lines = safe_int(max_lines, LOG_TAIL_DEFAULT_LINES, 20, LOG_TAIL_MAX_LINES) items = [] for key in LOG_FILE_REGISTRY: info = log_file_summary(key, max_lines=max_lines) if info: items.append(info) return { "ok": True, "version": ADMIN_PANEL_VERSION, "checked_at": time.strftime("%Y-%m-%d %H:%M:%S"), "lines": max_lines, "logs": items, } def render_admin_logs(): payload = build_logs_payload(request.args.get("lines", LOG_TAIL_DEFAULT_LINES)) cards = [] for info in payload["logs"]: badge_cls = "ok" if info["exists"] else "warn" badge_text = "קיים" if info["exists"] else "לא נוצר עדיין" tail = html_lib.escape(info["tail"] or "אין תוכן להצגה.").replace("\n", "
    ") cards.append(f'''

    {html_lib.escape(info["label"])}

    {html_lib.escape(info["note"])}

    {badge_text}
    נתיב{html_lib.escape(info["path"])}
    גודל: {html_lib.escape(info["size_label"])}עודכן: {html_lib.escape(info["updated"])}
    {tail}
    ''') return f''' לוגים TripServer
    ⬅ חזרה לפאנל

    📜 מרכז לוגים

    צפייה נוחה בלוגי האדמין, עדכונים ופעולות מערכת בלי לפתוח קבצים ידנית במחשב. המסך לקריאה בלבד ולא מוחק או משנה שום דבר.

    רענןהצג 250 שורותהצג 500 שורותJSON טכניבדיקה עצמית
    {''.join(cards)}
    ''' def query_watchdog_task(): if os.name != "nt": return {"supported": False, "installed": False, "ok": False, "details": "Task Scheduler זמין רק על Windows."} try: completed = subprocess.run(["schtasks", "/Query", "/TN", WATCHDOG_TASK_NAME, "/FO", "LIST"], capture_output=True, text=True, shell=False, timeout=12) output = (completed.stdout or completed.stderr or "").strip() return {"supported": True, "installed": completed.returncode == 0, "ok": completed.returncode == 0, "details": output} except Exception as exc: return {"supported": True, "installed": False, "ok": False, "details": repr(exc)} def watchdog_status(include_log=True, include_task=True): generated = build_watchdog_code(os.path.abspath(ADMIN_SERVER_PATH), sys.executable or "python", os.path.dirname(os.path.abspath(ADMIN_SERVER_PATH)) or BASE_DIR) source_ok, source_info = validate_watchdog_source(generated) file_exists = os.path.exists(WATCHDOG_SCRIPT_PATH) file_compiles = False file_info = "לא נכתב עדיין" if file_exists: try: py_compile.compile(WATCHDOG_SCRIPT_PATH, doraise=True) file_compiles = True file_info = "OK" except Exception as exc: file_info = repr(exc) task = query_watchdog_task() if include_task else {"supported": None, "installed": None, "ok": None, "details": "not queried"} return { "source_ok": source_ok, "source_status": source_info, "script_path": WATCHDOG_SCRIPT_PATH, "script_exists": file_exists, "script_compiles": file_compiles, "script_status": file_info, "task_name": WATCHDOG_TASK_NAME, "task_supported": task.get("supported"), "task_installed": task.get("installed"), "task_status": task.get("details", ""), "interval_minutes": WATCHDOG_INTERVAL_MINUTES, "cooldown_seconds": WATCHDOG_MIN_RESTART_INTERVAL_SECONDS, "quiet_python": get_pythonw_executable(sys.executable or "python"), "log_path": WATCHDOG_LOG_PATH, "log_tail": read_log_tail(WATCHDOG_LOG_PATH) if include_log else "", } def install_watchdog_task(): script_path = write_watchdog_script() if os.name != "nt": return False, "קובץ ה־Watchdog נכתב, אבל התקנת Task Scheduler נתמכת רק על Windows.", f"script={script_path}" # Use pythonw.exe for the scheduled watchdog so Windows will not flash a black # console window and steal keyboard focus every run. quiet_python = get_pythonw_executable(sys.executable or "python") task_command = f'"{quiet_python}" "{script_path}"' cmd = ["schtasks", "/Create", "/TN", WATCHDOG_TASK_NAME, "/TR", task_command, "/SC", "MINUTE", "/MO", str(max(1, WATCHDOG_INTERVAL_MINUTES)), "/F"] completed = subprocess.run(cmd, capture_output=True, text=True, shell=False, timeout=20) output = (completed.stdout or completed.stderr or "").strip() if completed.returncode != 0: return False, "קובץ ה־Watchdog נכתב, אבל התקנת המשימה נכשלה.", output or f"return code: {completed.returncode}" return True, f"Watchdog שקט הותקן כמשימה מתוזמנת שרצה כל {max(1, WATCHDOG_INTERVAL_MINUTES)} דקות עם pythonw.exe, בלי חלון שחור קופץ.", output def uninstall_watchdog_task(): if os.name != "nt": return False, "הסרת Task Scheduler נתמכת רק על Windows.", "" completed = subprocess.run(["schtasks", "/Delete", "/TN", WATCHDOG_TASK_NAME, "/F"], capture_output=True, text=True, shell=False, timeout=20) output = (completed.stdout or completed.stderr or "").strip() if completed.returncode != 0: return False, "לא הצלחתי להסיר את משימת ה־Watchdog, או שהיא לא קיימת.", output or f"return code: {completed.returncode}" return True, "משימת ה־Watchdog הוסרה.", output def run_watchdog_once_now(): script_path = write_watchdog_script() completed = subprocess.run([sys.executable or "python", script_path], capture_output=True, text=True, shell=False, timeout=25) output = (completed.stdout or completed.stderr or "").strip() ok = completed.returncode in {0, 2, 3, 10} return ok, f"Watchdog רץ פעם אחת והחזיר קוד {completed.returncode}.", output or read_log_tail(WATCHDOG_LOG_PATH) def render_admin_watchdog(): status = watchdog_status(include_log=True) installed = bool(status.get("task_installed")) script_ok = bool(status.get("script_exists")) and bool(status.get("script_compiles")) source_ok = bool(status.get("source_ok")) state_badge = "מותקן ופעיל" if installed else "לא מותקן עדיין" state_cls = "ok" if installed and source_ok else "warn" task_text = html_lib.escape(status.get("task_status") or "") log_tail = html_lib.escape(status.get("log_tail") or "אין עדיין לוג.").replace("\n", "
    ") script_label = "✅ קיים ותקין" if script_ok else "⚠️ עדיין לא נכתב/לא תקין" task_label = "✅ מותקנת" if installed else "⚠️ לא מותקנת" return f""" TripServer Watchdog
    ⬅ חזרה לפאנל

    🛡️ Watchdog לשמירת פאנל האדמין

    שכבת ביטחון חיצונית: Windows מריץ סקריפט שקט כל כמה דקות. אם הפאנל לא עונה ב־localhost:{ADMIN_PORT}, הוא מפעיל מחדש את admin_server.py לבד.

    {state_badge}
    בדיקה עצמיתHealthסטטוס קבצים
    סקריפט Watchdog

    {script_label}

    {html_lib.escape(status.get('script_path',''))}
    משימה מתוזמנת

    {task_label}

    שם: {html_lib.escape(status.get('task_name',''))}

    תדירות: כל {status.get('interval_minutes')} דקות

    הרצה שקטה

    מותקן דרך pythonw.exe כדי לא לפתוח חלון CMD שחור ולא לגנוב פוקוס בזמן הקלדה.

    {html_lib.escape(status.get('quiet_python',''))}
    Cooldown

    {status.get('cooldown_seconds')} שניות בין ניסיונות הפעלה כדי למנוע לופ.

    מה זה עושה בפועל?
    ה־Watchdog לא מחליף קבצים, לא מכבה מחשב ולא עושה restart למחשב. הוא רק בודק אם פאנל האדמין חי, ואם לא — מפעיל את קובץ האדמין הפעיל מחדש. זה בדיוק הכיסוי למקרה שבו העלאת admin או restart נפלו ואתה לא רוצה ללכת פיזית למחשב.
    פעולות
    סטטוס Task Scheduler
    {task_text or 'אין מידע.'}
    לוג אחרון
    {log_tail}
    """ def get_client_ip(): # Use the direct remote address rather than trusting arbitrary X-Forwarded-For headers. return request.remote_addr or "" def is_private_or_loopback_ip(ip_text): try: ip = ipaddress.ip_address((ip_text or "").split("%", 1)[0]) tailscale_ipv4 = ip.version == 4 and ip in ipaddress.ip_network("100.64.0.0/10") tailscale_ipv6 = ip.version == 6 and ip in ipaddress.ip_network("fd7a:115c:a1e0::/48") return ip.is_loopback or ip.is_private or ip.is_link_local or tailscale_ipv4 or tailscale_ipv6 except Exception: return False def power_action_allowed(): if not POWER_ACTIONS_ENABLED: return False, "פעולות כיבוי/ריסטארט מחשב כבויות בהגדרת TRIPSERVER_ENABLE_POWER_ACTIONS." ip = get_client_ip() if not is_private_or_loopback_ip(ip): return False, f"פעולת מחשב חסומה מכתובת שאינה מקומית/רשת ביתית: {ip}" if os.name != "nt": return False, "פעולות מחשב נתמכות כאן רק על Windows." return True, "OK" def normalize_power_delay(raw_value): try: delay = int(raw_value) except Exception: delay = POWER_DEFAULT_DELAY_SECONDS return max(POWER_MIN_DELAY_SECONDS, min(POWER_MAX_DELAY_SECONDS, delay)) def run_power_command(action, delay_seconds): if action == "shutdown": mode = "/s" label = "כיבוי מחשב" elif action == "reboot": mode = "/r" label = "ריסטארט למחשב" else: raise ValueError("unknown power action") delay = normalize_power_delay(delay_seconds) comment = f"TripServer Admin scheduled {label}" cmd = ["shutdown", mode, "/t", str(delay), "/c", comment] completed = subprocess.run(cmd, capture_output=True, text=True, shell=False) if completed.returncode != 0: raise RuntimeError((completed.stderr or completed.stdout or "shutdown command failed").strip()) log_admin_restart(f"POWER {action} scheduled in {delay}s by {get_client_ip()}") return label, delay, completed.stdout.strip() or completed.stderr.strip() def cancel_power_command(): completed = subprocess.run(["shutdown", "/a"], capture_output=True, text=True, shell=False) # Windows returns non-zero when there is no pending shutdown. Treat it as useful feedback, not a server crash. log_admin_restart(f"POWER cancel requested by {get_client_ip()} | rc={completed.returncode} | out={completed.stdout.strip()} | err={completed.stderr.strip()}") return completed.returncode, (completed.stdout or completed.stderr or "").strip() def arm_admin_update_failsafe_restart(): """Schedule a Windows reboot before applying an admin update.""" if not ADMIN_UPDATE_FAILSAFE_ENABLED: msg = "Fail Safe כבוי בהגדרת TRIPSERVER_ADMIN_UPDATE_FAILSAFE." write_admin_failsafe_status("arm_failed", msg) return False, msg allowed, reason = power_action_allowed() if not allowed: write_admin_failsafe_status("arm_failed", reason) return False, reason delay = normalize_power_delay(ADMIN_UPDATE_FAILSAFE_RESTART_SECONDS) try: subprocess.run(["shutdown", "/a"], capture_output=True, text=True, shell=False) except Exception: pass try: label, final_delay, output = run_power_command("reboot", delay) msg = f"{label} Fail Safe נקבע לעוד {final_delay} שניות." write_admin_failsafe_status("armed", msg, delay_seconds=final_delay, windows_output=output or "OK") return True, f"{msg} פלט Windows: {output or 'OK'}" except Exception as exc: msg = "Fail Safe לא הצליח לקבוע ריסטארט Windows: " + repr(exc) write_admin_failsafe_status("arm_failed", msg) return False, msg def camera_access_allowed(): if not CAMERA_ENABLED: return False, "מצלמת החדר כבויה בהגדרת TRIPSERVER_ENABLE_WEBCAM." ip = get_client_ip() if not is_private_or_loopback_ip(ip): return False, f"גישה למצלמה חסומה מכתובת שאינה מקומית/רשת ביתית/Tailscale: {ip}" return True, "OK" def camera_engine_status(): status = {"enabled": CAMERA_ENABLED, "opencv": False, "opencv_version": "", "camera_index": CAMERA_INDEX} try: import cv2 # noqa: F401 status["opencv"] = True status["opencv_version"] = getattr(cv2, "__version__", "") except Exception as exc: status["opencv"] = False status["error"] = str(exc) return status class WebcamManager: def __init__(self): self.lock = threading.RLock() self.cap = None self.opened_at = 0.0 self.last_frame_at = 0.0 self.frames = 0 self.last_error = "" self.stop_requested = False def _import_cv2(self): import cv2 return cv2 def _open_locked(self): cv2 = self._import_cv2() if self.cap is not None and self.cap.isOpened(): return cv2 self.stop_requested = False backend = getattr(cv2, "CAP_DSHOW", 0) if os.name == "nt" else 0 cap = cv2.VideoCapture(CAMERA_INDEX, backend) try: cap.set(getattr(cv2, "CAP_PROP_FRAME_WIDTH", 3), CAMERA_WIDTH) cap.set(getattr(cv2, "CAP_PROP_FRAME_HEIGHT", 4), CAMERA_HEIGHT) cap.set(getattr(cv2, "CAP_PROP_FPS", 5), CAMERA_FPS) except Exception: pass if not cap or not cap.isOpened(): try: cap.release() except Exception: pass self.last_error = f"לא הצלחתי לפתוח מצלמה index={CAMERA_INDEX}. בדוק הרשאות Windows או מצלמה תפוסה באפליקציה אחרת." raise RuntimeError(self.last_error) self.cap = cap self.opened_at = time.time() self.frames = 0 self.last_error = "" return cv2 def read_jpeg(self): with self.lock: # v21 fix: stop_requested is only for the CURRENT stream. In older builds, # once /camera/stop or a browser disconnect set it to True, future starts # were blocked forever until the whole admin process rebooted. If the # capture was already released, allow a new stream to open cleanly. if self.cap is None or not getattr(self.cap, "isOpened", lambda: False)(): self.stop_requested = False elif self.stop_requested: raise RuntimeError("המצלמה כובתה ידנית") cv2 = self._open_locked() ok, frame = self.cap.read() if not ok or frame is None: time.sleep(0.15) ok, frame = self.cap.read() if not ok or frame is None: self.last_error = "לא התקבלה תמונה מהמצלמה." raise RuntimeError(self.last_error) ok, encoded = cv2.imencode(".jpg", frame, [int(getattr(cv2, "IMWRITE_JPEG_QUALITY", 1)), CAMERA_JPEG_QUALITY]) if not ok: self.last_error = "קידוד תמונת המצלמה ל־JPG נכשל." raise RuntimeError(self.last_error) self.frames += 1 self.last_frame_at = time.time() return encoded.tobytes() def stop(self): with self.lock: self.stop_requested = True if self.cap is not None: try: self.cap.release() except Exception: pass self.cap = None self.opened_at = 0.0 def prepare_new_stream(self): """Release stale webcam handles and allow the next stream to start. This is intentionally lighter than a full camera reset: it does not stop audio or recording. It is used before assigning a new MJPEG src in the UI. """ with self.lock: if self.cap is not None: try: self.cap.release() except Exception: pass self.cap = None self.opened_at = 0.0 self.stop_requested = False self.last_error = "" return True def force_reset(self): """Stop all current webcam capture state and clear sticky errors.""" self.stop() with self.lock: self.stop_requested = False self.last_error = "" self.frames = 0 self.last_frame_at = 0.0 return True def status(self): with self.lock: active = bool(self.cap is not None and self.cap.isOpened()) return { "enabled": CAMERA_ENABLED, "active": active, "camera_index": CAMERA_INDEX, "width": CAMERA_WIDTH, "height": CAMERA_HEIGHT, "fps": CAMERA_FPS, "jpeg_quality": CAMERA_JPEG_QUALITY, "opened_at": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.opened_at)) if self.opened_at else "", "last_frame_at": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.last_frame_at)) if self.last_frame_at else "", "frames": self.frames, "last_error": self.last_error, } CAMERA_MANAGER = WebcamManager() def log_camera_event(message): try: os.makedirs(BASE_DIR, exist_ok=True) with open(os.path.join(BASE_DIR, "camera_security.log"), "a", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | " + str(message) + "\n") except Exception: pass def ffmpeg_dshow_devices(): """Return DirectShow audio/video devices available to FFmpeg on Windows. v22 fix: FFmpeg on Windows usually prints devices under section headers like "DirectShow audio devices" and then plain quoted names. Older builds only looked for a non-standard `"name" (audio)` suffix, so microphones could be missed even when they existed. This parser supports both formats and also stores Alternative names, which are often more reliable than friendly names. """ devices = {"video": [], "audio": [], "video_alt": [], "audio_alt": [], "alternatives": {"video": {}, "audio": {}}, "error": "", "raw": ""} ffmpeg = find_ffmpeg_executable() if not ffmpeg: devices["error"] = "FFmpeg לא נמצא." return devices if os.name != "nt": devices["error"] = "זיהוי התקני מצלמה/מיקרופון דרך DirectShow נתמך כאן בעיקר ב־Windows." return devices try: completed = subprocess.run( [ffmpeg, "-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "dummy"], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=12, ) raw = (completed.stdout or "") + "\n" + (completed.stderr or "") devices["raw"] = raw[-9000:] section = None current_name = None current_kind = None def add_device(kind, name): if not kind or not name: return bucket = "video" if kind == "video" else "audio" if name not in devices[bucket]: devices[bucket].append(name) def add_alt(kind, name, alt): if not kind or not name or not alt: return alt_bucket = "video_alt" if kind == "video" else "audio_alt" devices["alternatives"].setdefault(kind, {})[name] = alt if alt not in devices[alt_bucket]: devices[alt_bucket].append(alt) for line in raw.splitlines(): low = line.lower() if "directshow video devices" in low: section = "video" current_name = None current_kind = None continue if "directshow audio devices" in low: section = "audio" current_name = None current_kind = None continue alt_match = re.search(r'Alternative name\s+"([^"]+)"', line, flags=re.I) if alt_match and current_name and current_kind: add_alt(current_kind, current_name, alt_match.group(1)) continue name_match = re.search(r'\]\s+"([^"]+)"', line) if name_match and section in {"video", "audio"} and "alternative name" not in low: name = name_match.group(1).strip() add_device(section, name) current_name = name current_kind = section continue for name, kind in re.findall(r'"([^"]+)"\s+\((video|audio)\)', line, flags=re.I): kind = "video" if kind.lower() == "video" else "audio" add_device(kind, name.strip()) current_name = name.strip() current_kind = kind except Exception as exc: devices["error"] = str(exc) return devices def _device_tokens(name): text = (name or "").lower() tokens = re.findall(r"[a-z0-9א-ת]+", text) stop = {"microphone", "mic", "audio", "device", "usb", "video", "camera", "webcam", "hd", "pro", "stream", "capture", "array", "מערך", "מיקרופון", "מצלמה"} return {t for t in tokens if len(t) >= 3 and t not in stop} def preferred_audio_candidates(devices=None): devices = devices or ffmpeg_dshow_devices() if CAMERA_AUDIO_DEVICE: return [{"name": CAMERA_AUDIO_DEVICE, "source": "env", "score": 999, "alt": False}] video = CAMERA_VIDEO_DEVICE or (devices.get("video") or [""])[0] video_tokens = _device_tokens(video) rows = [] alternatives = (devices.get("alternatives") or {}).get("audio", {}) for i, name in enumerate(devices.get("audio") or []): tokens = _device_tokens(name) score = 100 - i if video_tokens and tokens: score += 20 * len(video_tokens & tokens) low = name.lower() if any(w in low for w in ["webcam", "camera", "logitech", "c920", "c922", "brio", "usb"]): score += 15 rows.append({"name": name, "source": "friendly", "score": score, "alt": False}) alt = alternatives.get(name) if alt: rows.append({"name": alt, "source": f"alternative for {name}", "score": score - 1, "alt": True}) rows.sort(key=lambda r: r.get("score", 0), reverse=True) result = [] seen = set() for row in rows: if row["name"] and row["name"] not in seen: result.append(row) seen.add(row["name"]) return result def preferred_video_candidates(devices=None): devices = devices or ffmpeg_dshow_devices() if CAMERA_VIDEO_DEVICE: return [{"name": CAMERA_VIDEO_DEVICE, "source": "env", "score": 999, "alt": False}] alternatives = (devices.get("alternatives") or {}).get("video", {}) rows = [] for i, name in enumerate(devices.get("video") or []): score = 100 - i rows.append({"name": name, "source": "friendly", "score": score, "alt": False}) alt = alternatives.get(name) if alt: rows.append({"name": alt, "source": f"alternative for {name}", "score": score - 1, "alt": True}) result = [] seen = set() for row in rows: if row["name"] and row["name"] not in seen: result.append(row) seen.add(row["name"]) return result def selected_ffmpeg_devices(): devices = ffmpeg_dshow_devices() video_candidates = preferred_video_candidates(devices) audio_candidates = preferred_audio_candidates(devices) devices["video_candidates"] = video_candidates devices["audio_candidates"] = audio_candidates video = video_candidates[0]["name"] if video_candidates else "" audio = audio_candidates[0]["name"] if audio_candidates else "" return video, audio, devices def dshow_input_name(video_device="", audio_device=""): parts = [] if video_device: parts.append("video=" + video_device) if audio_device: parts.append("audio=" + audio_device) return ":".join(parts) def tail_text_file(path, max_chars=5000): try: if not path or not os.path.exists(path): return "" with open(path, "rb") as fh: fh.seek(0, os.SEEK_END) size = fh.tell() fh.seek(max(0, size - max_chars)) data = fh.read().decode("utf-8", errors="replace") return data[-max_chars:] except Exception: return "" class CameraAudioStreamManager: def __init__(self): self.lock = threading.RLock() self.proc = None self.started_at = 0.0 self.device = "" self.last_error = "" self.log_path = CAMERA_AUDIO_LOG_PATH self.log_handle = None self.candidates_tried = [] def _close_log_locked(self): try: if self.log_handle: self.log_handle.close() except Exception: pass self.log_handle = None def _append_audio_log_locked(self, message): try: os.makedirs(BASE_DIR, exist_ok=True) with open(CAMERA_AUDIO_LOG_PATH, "a", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | " + str(message) + "\n") except Exception: pass def _start_candidate_locked(self, ffmpeg, audio_name): os.makedirs(BASE_DIR, exist_ok=True) self._append_audio_log_locked("trying audio device: " + str(audio_name)) logfh = open(CAMERA_AUDIO_LOG_PATH, "ab") header = ("\n" + "=" * 70 + "\n" + time.strftime("%Y-%m-%d %H:%M:%S") + " | ffmpeg audio start | device=" + str(audio_name) + "\n").encode("utf-8", errors="replace") try: logfh.write(header) logfh.flush() except Exception: pass cmd = [ ffmpeg, "-hide_banner", "-nostdin", "-loglevel", "warning", "-f", "dshow", "-rtbufsize", "64M", "-i", "audio=" + audio_name, "-vn", "-ac", "1", "-ar", "44100", "-codec:a", "libmp3lame", "-b:a", "96k", "-f", "mp3", "pipe:1", ] creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if os.name == "nt" else 0 proc = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=logfh, creationflags=creationflags) time.sleep(0.75) if proc.poll() is not None: try: logfh.flush() logfh.close() except Exception: pass err = tail_text_file(CAMERA_AUDIO_LOG_PATH, 2500) self._append_audio_log_locked("device failed immediately: " + str(audio_name)) self.candidates_tried.append({"device": audio_name, "ok": False}) self.last_error = "FFmpeg לא הצליח לפתוח את המיקרופון: " + str(audio_name) + "\n" + err[-1200:] return None, None self.candidates_tried.append({"device": audio_name, "ok": True}) return proc, logfh def start(self, restart=False): with self.lock: if restart: self.stop_locked() return self.start_locked() def start_locked(self): if self.proc is not None and self.proc.poll() is None: return self.proc if not CAMERA_AUDIO_ENABLED: raise RuntimeError("אודיו מצלמה כבוי בהגדרת TRIPSERVER_ENABLE_CAMERA_AUDIO.") ffmpeg = find_ffmpeg_executable() if not ffmpeg: raise RuntimeError("FFmpeg לא נמצא. נדרש FFmpeg כדי להזרים אודיו חי.") _, audio, devices = selected_ffmpeg_devices() candidates = preferred_audio_candidates(devices) self.candidates_tried = [] if not candidates: raw_tail = (devices.get("raw") or "")[-2500:] self.last_error = "לא נמצא התקן מיקרופון ב־FFmpeg. בדוק הרשאות Windows או הגדר TRIPSERVER_FFMPEG_AUDIO_DEVICE.\n" + raw_tail raise RuntimeError(self.last_error) last_error = "" for row in candidates: name = row.get("name") or "" if not name: continue proc, logfh = self._start_candidate_locked(ffmpeg, name) if proc is not None: self.proc = proc self.log_handle = logfh self.started_at = time.time() self.device = name self.last_error = "" log_camera_event(f"audio stream started | device={name}") return self.proc last_error = self.last_error self.proc = None self._close_log_locked() if not last_error: last_error = "כל ניסיונות פתיחת האודיו נכשלו. בדוק לוג אודיו מצלמה." raise RuntimeError(last_error) def stream_chunks(self): try: with self.lock: proc = self.start_locked() while proc is not None and proc.poll() is None: chunk = proc.stdout.read(4096) if proc.stdout else b"" if not chunk: if proc.poll() is not None: self.last_error = "שידור האודיו נסגר על ידי FFmpeg. " + tail_text_file(CAMERA_AUDIO_LOG_PATH, 1600) break yield chunk except GeneratorExit: pass except Exception as exc: self.last_error = str(exc) self._append_audio_log_locked("stream exception: " + repr(exc)) yield b"" finally: self.stop() def stop_locked(self): proc = self.proc self.proc = None if proc is not None and proc.poll() is None: try: proc.terminate() proc.wait(timeout=3) except Exception: try: proc.kill() except Exception: pass self._close_log_locked() self.started_at = 0.0 def stop(self): with self.lock: self.stop_locked() log_camera_event("audio stream stopped") def status(self): with self.lock: active = bool(self.proc is not None and self.proc.poll() is None) return { "audio_enabled": CAMERA_AUDIO_ENABLED, "active": active, "device": self.device, "started_at": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.started_at)) if self.started_at else "", "last_error": self.last_error, "log_path": CAMERA_AUDIO_LOG_PATH, "candidates_tried": self.candidates_tried, } class CameraRecordingManager: def __init__(self): self.lock = threading.RLock() self.proc = None self.started_at = 0.0 self.file_path = "" self.log_path = "" self.last_error = "" self.with_audio = False self.video_device = "" self.audio_device = "" self.log_handle = None def _refresh_locked(self): if self.proc is not None and self.proc.poll() is not None: try: if self.log_handle: self.log_handle.close() except Exception: pass self.log_handle = None self.proc = None self.started_at = 0.0 def start(self, with_audio=True): with self.lock: self._refresh_locked() if self.proc is not None and self.proc.poll() is None: raise RuntimeError("יש כבר הקלטה פעילה. עצור אותה לפני התחלה חדשה.") if not CAMERA_RECORDING_ENABLED: raise RuntimeError("הקלטת מצלמה כבויה בהגדרת TRIPSERVER_ENABLE_CAMERA_RECORDING.") ffmpeg = find_ffmpeg_executable() if not ffmpeg: raise RuntimeError("FFmpeg לא נמצא. נדרש FFmpeg כדי להקליט וידאו/אודיו.") video, audio, devices = selected_ffmpeg_devices() if not video: raise RuntimeError("לא נמצא התקן מצלמה ב־FFmpeg. בדוק הרשאות Windows או הגדר TRIPSERVER_FFMPEG_VIDEO_DEVICE.") if with_audio and not audio: raise RuntimeError("ביקשת הקלטה עם אודיו, אבל לא נמצא התקן מיקרופון ב־FFmpeg.") os.makedirs(CAMERA_RECORDINGS_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") target = os.path.join(CAMERA_RECORDINGS_DIR, f"room_camera_{stamp}.mp4") log_path = os.path.join(CAMERA_RECORDINGS_DIR, f"room_camera_{stamp}.ffmpeg.log") input_name = dshow_input_name(video, audio if with_audio else "") cmd = [ ffmpeg, "-hide_banner", "-y", "-f", "dshow", "-rtbufsize", "512M", "-framerate", str(CAMERA_RECORD_FPS), "-video_size", f"{CAMERA_WIDTH}x{CAMERA_HEIGHT}", "-i", input_name, "-t", str(CAMERA_RECORD_MAX_SECONDS), "-c:v", "libx264", "-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p", ] if with_audio: cmd += ["-c:a", "aac", "-b:a", CAMERA_AUDIO_BITRATE] else: cmd += ["-an"] cmd += ["-movflags", "+faststart", target] logfh = open(log_path, "ab") creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if os.name == "nt" else 0 self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=logfh, creationflags=creationflags) self.log_handle = logfh self.started_at = time.time() self.file_path = target self.log_path = log_path self.last_error = "" self.with_audio = bool(with_audio) self.video_device = video self.audio_device = audio if with_audio else "" log_camera_event(f"recording started by {get_client_ip()} | file={target} | video={video} | audio={self.audio_device or 'no-audio'}") return target def stop(self): with self.lock: self._refresh_locked() proc = self.proc if proc is None: return self.file_path or "" try: if proc.stdin: proc.stdin.write(b"q") proc.stdin.flush() except Exception: try: proc.terminate() except Exception: pass try: proc.wait(timeout=10) except Exception: try: proc.kill() except Exception: pass try: if self.log_handle: self.log_handle.close() except Exception: pass self.log_handle = None self.proc = None self.started_at = 0.0 log_camera_event(f"recording stopped by {get_client_ip()} | file={self.file_path}") return self.file_path def status(self): with self.lock: self._refresh_locked() active = bool(self.proc is not None and self.proc.poll() is None) size = os.path.getsize(self.file_path) if self.file_path and os.path.exists(self.file_path) else 0 return { "recording_enabled": CAMERA_RECORDING_ENABLED, "active": active, "file_path": self.file_path, "file_name": os.path.basename(self.file_path) if self.file_path else "", "file_size": size, "started_at": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.started_at)) if self.started_at else "", "elapsed_seconds": int(time.time() - self.started_at) if active and self.started_at else 0, "with_audio": self.with_audio, "video_device": self.video_device, "audio_device": self.audio_device, "log_path": self.log_path, "last_error": self.last_error, } class CameraHlsStreamManager: """Unified video+audio live stream using one FFmpeg DirectShow process. Some USB webcams expose camera and microphone as one physical device. Opening video through OpenCV and audio through a separate FFmpeg process can fail or lock the device. HLS captures `video=...:audio=...` in one process, closer to how Zoom/Teams uses the camera+mic together. """ def __init__(self): self.lock = threading.RLock() self.proc = None self.started_at = 0.0 self.video_device = "" self.audio_device = "" self.with_audio = True self.last_error = "" self.mode = "idle" def _log(self, message): try: os.makedirs(BASE_DIR, exist_ok=True) with open(CAMERA_HLS_LOG_PATH, "a", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | hls | " + str(message) + "\n") except Exception: pass def _clean_dir_locked(self): try: os.makedirs(CAMERA_HLS_DIR, exist_ok=True) for name in os.listdir(CAMERA_HLS_DIR): if name.lower().endswith((".m3u8", ".ts", ".tmp")): try: os.remove(os.path.join(CAMERA_HLS_DIR, name)) except Exception: pass except Exception as exc: self._log("clean hls dir failed: " + repr(exc)) def _hls_input_option_candidates(self): """Return DirectShow option fallbacks for webcams. Some USB webcams, including EMEET models, work in OpenCV but reject a forced FFmpeg DirectShow combination such as -video_size 1280x720 together with -framerate 15. FFmpeg then fails with: Could not set video options. v25 tries progressively safer combinations and finally lets the driver auto-negotiate the video mode. """ preferred_size = f"{CAMERA_WIDTH}x{CAMERA_HEIGHT}" common_sizes = [] for item in (preferred_size, "1280x720", "640x480", "1920x1080"): if item not in common_sizes: common_sizes.append(item) fps_values = [] for item in (CAMERA_RECORD_FPS, 30, 15, 10): try: item = int(item) except Exception: continue if item > 0 and item not in fps_values: fps_values.append(item) candidates = [] # Try common explicit modes first, then fall back to auto negotiation. for fps in fps_values[:3]: candidates.append((f"size={preferred_size},fps={fps}", ["-video_size", preferred_size, "-framerate", str(fps)])) for size in common_sizes: candidates.append((f"size={size},auto-fps", ["-video_size", size])) for fps in fps_values: candidates.append((f"auto-size,fps={fps}", ["-framerate", str(fps)])) candidates.append(("driver-auto", [])) seen = set() unique = [] for label, opts in candidates: key = tuple(opts) if key not in seen: unique.append((label, opts)) seen.add(key) return unique def _start_ffmpeg_locked(self, video_name, audio_name=""): ffmpeg = find_ffmpeg_executable() if not ffmpeg: raise RuntimeError("FFmpeg לא נמצא. נדרש FFmpeg לשידור וידאו+אודיו מאוחד.") self._clean_dir_locked() playlist = os.path.join(CAMERA_HLS_DIR, "stream.m3u8") segment_pattern = os.path.join(CAMERA_HLS_DIR, "seg_%05d.ts") input_name = dshow_input_name(video_name, audio_name) os.makedirs(os.path.dirname(CAMERA_HLS_LOG_PATH), exist_ok=True) last_err = "" for mode_label, input_options in self._hls_input_option_candidates(): self._clean_dir_locked() cmd = [ ffmpeg, "-hide_banner", "-y", "-nostdin", "-loglevel", "warning", "-f", "dshow", "-rtbufsize", "512M", ] + list(input_options) + [ "-i", input_name, "-c:v", "libx264", "-preset", "ultrafast", "-tune", "zerolatency", "-pix_fmt", "yuv420p", "-r", str(CAMERA_RECORD_FPS), ] if audio_name: cmd += ["-c:a", "aac", "-b:a", CAMERA_AUDIO_BITRATE, "-ar", "44100", "-ac", "1"] else: cmd += ["-an"] cmd += [ "-f", "hls", "-hls_time", "1", "-hls_list_size", "5", "-hls_flags", "delete_segments+omit_endlist+program_date_time", "-hls_segment_filename", segment_pattern, playlist, ] logfh = open(CAMERA_HLS_LOG_PATH, "ab") try: header = ("\n" + "=" * 70 + "\n" + time.strftime("%Y-%m-%d %H:%M:%S") + " | unified HLS start | mode=" + mode_label + " | input=" + input_name + "\ncmd=" + " ".join(cmd) + "\n").encode("utf-8", errors="replace") logfh.write(header) logfh.flush() except Exception: pass flags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if os.name == "nt" else 0 proc = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=logfh, creationflags=flags) deadline = time.time() + 8.0 while time.time() < deadline: if proc.poll() is not None: break if os.path.exists(playlist) and os.path.getsize(playlist) > 20: self.proc = proc self.started_at = time.time() self.video_device = video_name self.audio_device = audio_name self.with_audio = bool(audio_name) self.last_error = "" self.mode = ("hls_av:" if audio_name else "hls_video_only:") + mode_label self._log("HLS started ok | mode=" + mode_label + " | video=" + str(video_name) + " | audio=" + str(audio_name or "no-audio")) return True time.sleep(0.35) try: if proc.poll() is None: proc.terminate() proc.wait(timeout=3) except Exception: try: proc.kill() except Exception: pass try: logfh.close() except Exception: pass last_err = tail_text_file(CAMERA_HLS_LOG_PATH, 4200) if "Could not set video options" in last_err or "Error opening input" in last_err: self._log("HLS candidate failed; trying next | mode=" + mode_label + " | input=" + input_name) continue # Keep trying all candidates even for other errors, because DirectShow is inconsistent. self._log("HLS candidate failed; trying next | mode=" + mode_label + " | input=" + input_name) self.last_error = "FFmpeg לא הצליח לפתוח שידור מאוחד אחרי כל מצבי DirectShow: " + input_name + "\n" + (last_err[-1800:] if last_err else "") self._log("HLS failed all candidates | input=" + input_name) return False def start(self, with_audio=True, restart=True): with self.lock: if restart: self.stop_locked() if self.proc is not None and self.proc.poll() is None: return True if not CAMERA_ENABLED: raise RuntimeError("מצלמה כבויה בהגדרת TRIPSERVER_ENABLE_WEBCAM.") video, audio, devices = selected_ffmpeg_devices() if not video: raise RuntimeError("לא נמצא התקן וידאו ב־FFmpeg. בדוק הרשאות מצלמה או הגדר TRIPSERVER_FFMPEG_VIDEO_DEVICE.") try: CAMERA_MANAGER.stop() except Exception: pass try: CAMERA_AUDIO_STREAM.stop() except Exception: pass audio_rows = preferred_audio_candidates(devices) if with_audio and CAMERA_AUDIO_ENABLED else [] if with_audio and audio_rows: last_audio_error = "" for row in audio_rows[:8]: audio_name = row.get("name") or "" if not audio_name: continue if self._start_ffmpeg_locked(video, audio_name): return True last_audio_error = self.last_error # Keep the camera available even when audio fails, but preserve the audio error. if self._start_ffmpeg_locked(video, ""): self.last_error = "האודיו נכשל ולכן הופעל וידאו בלבד. שגיאת אודיו אחרונה:\n" + last_audio_error return True raise RuntimeError(last_audio_error or self.last_error or "שידור מאוחד נכשל.") if self._start_ffmpeg_locked(video, ""): return True raise RuntimeError(self.last_error or "שידור מאוחד נכשל.") def stop_locked(self): proc = self.proc self.proc = None if proc is not None and proc.poll() is None: try: proc.terminate() proc.wait(timeout=4) except Exception: try: proc.kill() except Exception: pass self.started_at = 0.0 self.mode = "idle" def stop(self): with self.lock: self.stop_locked() self._log("HLS stopped") def status(self): with self.lock: active = bool(self.proc is not None and self.proc.poll() is None) playlist = os.path.join(CAMERA_HLS_DIR, "stream.m3u8") return { "active": active, "mode": self.mode, "with_audio": self.with_audio, "video_device": self.video_device, "audio_device": self.audio_device, "started_at": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(self.started_at)) if self.started_at else "", "playlist_exists": os.path.exists(playlist), "playlist_size": os.path.getsize(playlist) if os.path.exists(playlist) else 0, "dir": CAMERA_HLS_DIR, "log_path": CAMERA_HLS_LOG_PATH, "last_error": self.last_error, } CAMERA_HLS_STREAM = CameraHlsStreamManager() CAMERA_AUDIO_STREAM = CameraAudioStreamManager() CAMERA_RECORDER = CameraRecordingManager() def list_camera_recordings(limit=30): try: os.makedirs(CAMERA_RECORDINGS_DIR, exist_ok=True) items = [] for path in glob.glob(os.path.join(CAMERA_RECORDINGS_DIR, "*.mp4")): try: items.append({ "name": os.path.basename(path), "path": path, "size": os.path.getsize(path), "mtime": os.path.getmtime(path), }) except Exception: pass items.sort(key=lambda x: x.get("mtime", 0), reverse=True) return items[:limit] except Exception: return [] def append_camera_setup_log(message): os.makedirs(BASE_DIR, exist_ok=True) line = f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] {message}\n" try: with open(CAMERA_SETUP_LOG_PATH, "a", encoding="utf-8") as fh: fh.write(line) except Exception: pass return line def read_camera_setup_log_tail(lines=80): try: lines = max(20, min(300, int(lines))) except Exception: lines = 80 if not os.path.exists(CAMERA_SETUP_LOG_PATH): return "" try: with open(CAMERA_SETUP_LOG_PATH, "r", encoding="utf-8", errors="replace") as fh: data = fh.readlines() return "".join(data[-lines:]) except Exception as exc: return f"שגיאה בקריאת לוג התקנה: {exc}" def opencv_import_status(): try: import cv2 # noqa: F401 return True, getattr(cv2, "__version__", "") except Exception as exc: return False, str(exc) def camera_setup_status(): ok, info = opencv_import_status() ffmpeg_path = find_ffmpeg_executable() or "" with CAMERA_SETUP_LOCK: state = dict(CAMERA_SETUP_STATE) return { "opencv": ok, "opencv_info": info, "ffmpeg": bool(ffmpeg_path), "ffmpeg_path": ffmpeg_path, "python_executable": sys.executable, "pip_command": f'"{sys.executable}" -m pip install --upgrade {CAMERA_OPENCV_PACKAGE}', "opencv_package": CAMERA_OPENCV_PACKAGE, "setup_log_path": CAMERA_SETUP_LOG_PATH, "marker_path": CAMERA_SETUP_MARKER_PATH, "auto_install_enabled": CAMERA_AUTO_INSTALL_OPENCV, "auto_install_delay_seconds": CAMERA_AUTO_INSTALL_DELAY_SECONDS, "installer": state, } def ensure_pip_available(): """Make pip available in the same Python interpreter when possible.""" check = subprocess.run([sys.executable, "-m", "pip", "--version"], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=60, shell=False) if check.returncode == 0: append_camera_setup_log("pip available: " + (check.stdout or check.stderr or "").strip()) return True append_camera_setup_log("pip not available, trying ensurepip --upgrade") try: ep = subprocess.run([sys.executable, "-m", "ensurepip", "--upgrade"], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=180, shell=False) append_camera_setup_log("ensurepip return code: " + str(ep.returncode)) if ep.stdout: append_camera_setup_log("ensurepip stdout:\n" + ep.stdout[-6000:]) if ep.stderr: append_camera_setup_log("ensurepip stderr:\n" + ep.stderr[-6000:]) return ep.returncode == 0 except Exception as exc: append_camera_setup_log("ensurepip exception: " + repr(exc)) return False def write_camera_setup_marker(info): try: os.makedirs(BASE_DIR, exist_ok=True) with open(CAMERA_SETUP_MARKER_PATH, "w", encoding="utf-8") as fh: fh.write(time.strftime("%Y-%m-%d %H:%M:%S") + " | " + str(info) + "\n") except Exception: pass def run_opencv_install_worker(mode="manual"): with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE.update({"running": True, "started_at": time.strftime("%Y-%m-%d %H:%M:%S"), "finished_at": "", "ok": False, "last_message": "מתקין OpenCV...", "mode": mode}) append_camera_setup_log("OpenCV install requested | mode=" + str(mode)) append_camera_setup_log("Python executable: " + sys.executable) if not ensure_pip_available(): msg = "pip לא זמין וגם ensurepip לא הצליח. אי אפשר להתקין OpenCV אוטומטית." append_camera_setup_log("ERROR: " + msg) with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE.update({"running": False, "finished_at": time.strftime("%Y-%m-%d %H:%M:%S"), "ok": False, "last_message": msg, "mode": mode}) return cmd = [sys.executable, "-m", "pip", "install", "--upgrade", CAMERA_OPENCV_PACKAGE] append_camera_setup_log("Command: " + " ".join(cmd)) ok = False msg = "" try: completed = subprocess.run( cmd, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=CAMERA_OPENCV_INSTALL_TIMEOUT_SECONDS, shell=False, ) append_camera_setup_log("pip return code: " + str(completed.returncode)) if completed.stdout: append_camera_setup_log("pip stdout:\n" + completed.stdout[-12000:]) if completed.stderr: append_camera_setup_log("pip stderr:\n" + completed.stderr[-12000:]) ok, info = opencv_import_status() if completed.returncode == 0 and ok: msg = "OpenCV הותקן וזוהה: " + info append_camera_setup_log("SUCCESS: " + msg) write_camera_setup_marker(msg) elif completed.returncode == 0 and not ok: msg = "pip הסתיים בהצלחה אבל import cv2 עדיין נכשל: " + info append_camera_setup_log("WARNING: " + msg) else: msg = "pip נכשל. בדוק את הלוג במסך ההתקנה." append_camera_setup_log("ERROR: " + msg) ok = False except subprocess.TimeoutExpired: msg = f"התקנת OpenCV עברה את מגבלת הזמן ({CAMERA_OPENCV_INSTALL_TIMEOUT_SECONDS} שניות)." append_camera_setup_log("TIMEOUT: " + msg) except Exception as exc: msg = "שגיאה בהרצת pip: " + repr(exc) append_camera_setup_log("EXCEPTION: " + msg) with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE.update({"running": False, "finished_at": time.strftime("%Y-%m-%d %H:%M:%S"), "ok": bool(ok), "last_message": msg, "mode": mode}) def start_opencv_install_background(mode="manual"): with CAMERA_SETUP_LOCK: if CAMERA_SETUP_STATE.get("running"): return False, "התקנת OpenCV כבר רצה כרגע." CAMERA_SETUP_STATE.update({"running": True, "started_at": time.strftime("%Y-%m-%d %H:%M:%S"), "finished_at": "", "ok": False, "last_message": "מתחיל התקנה...", "mode": mode}) t = threading.Thread(target=run_opencv_install_worker, kwargs={"mode": mode}, name="tripserver-opencv-installer", daemon=True) t.start() return True, "התקנת OpenCV התחילה ברקע. אפשר לרענן את מסך המצלמה/התקנה ולבדוק לוג." def maybe_start_camera_auto_install(reason="startup"): if not CAMERA_AUTO_INSTALL_OPENCV: append_camera_setup_log("Auto install disabled by TRIPSERVER_CAMERA_AUTO_INSTALL_OPENCV") return False, "התקנה אוטומטית כבויה." ok, info = opencv_import_status() if ok: with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE.update({"ok": True, "last_message": "OpenCV כבר זמין: " + str(info), "mode": "ready"}) write_camera_setup_marker("already available: " + str(info)) return False, "OpenCV כבר מותקן." with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE["auto_requested"] = True def delayed_auto(): try: if CAMERA_AUTO_INSTALL_DELAY_SECONDS > 0: time.sleep(CAMERA_AUTO_INSTALL_DELAY_SECONDS) ok2, info2 = opencv_import_status() if ok2: write_camera_setup_marker("available before auto install: " + str(info2)) with CAMERA_SETUP_LOCK: CAMERA_SETUP_STATE.update({"ok": True, "last_message": "OpenCV כבר זמין: " + str(info2), "mode": "ready"}) return append_camera_setup_log("Auto install triggered | reason=" + str(reason) + " | cv2 import failed: " + str(info2)) start_opencv_install_background(mode="auto:" + str(reason)) except Exception as exc: append_camera_setup_log("Auto install scheduler exception: " + repr(exc)) t = threading.Thread(target=delayed_auto, name="tripserver-opencv-auto-installer", daemon=True) t.start() return True, "התקנת OpenCV אוטומטית תתחיל ברקע." def render_camera_setup_page(): allowed, reason = camera_access_allowed() status = camera_setup_status() inst = status.get("installer", {}) running = bool(inst.get("running")) opencv_badge = "ok" if status.get("opencv") else "warn" ffmpeg_badge = "ok" if status.get("ffmpeg") else "warn" run_badge = "warn" if running else ("ok" if inst.get("ok") else "idle") install_disabled = "disabled" if (not allowed or running or status.get("opencv")) else "" allowed_block = "" if allowed else f"
    גישה חסומה: {html_lib.escape(reason)}
    " log_tail = html_lib.escape(read_camera_setup_log_tail(120)) or "אין עדיין לוג התקנה." return f""" התקנת רכיבי מצלמה
    ⬅ חזרה למצלמה

    🧩 התקנת רכיבי מצלמה

    OpenCV מותקן אוטומטית חד־פעמית ברקע כאשר פאנל האדמין עולה. FFmpeg לא מותקן כאן; הוא רק מזוהה מהנתיב שכבר קיים אצלך.

    OpenCV: {'מותקן' if status.get('opencv') else 'חסר'}FFmpeg: {'זמין' if status.get('ffmpeg') else 'לא נמצא'}Installer: {'רץ עכשיו' if running else ('הצלחה אחרונה' if inst.get('ok') else 'ממתין')}
    {allowed_block}

    התקנה אוטומטית חד־פעמית

    אם OpenCV חסר, הפאנל מריץ לבד את הפקודה:

    {html_lib.escape(status.get('pip_command',''))}
    אין כפתור התקנה נוסף. ההתקנה מופעלת ברקע אחרי עליית הפאנל, כדי שתוכל לעשות את זה מרחוק בלי CMD ידני.
    {'
    OpenCV כבר מותקן וזמין. אין צורך להתקין שוב.
    ' if status.get('opencv') else ''}

    סטטוס

    Python:

    {html_lib.escape(status.get('python_executable',''))}

    OpenCV: {html_lib.escape(str(status.get('opencv_info','')))}

    FFmpeg:

    {html_lib.escape(status.get('ffmpeg_path') or 'לא נמצא')}

    הודעה אחרונה:
    {html_lib.escape(str(inst.get('last_message') or 'אין'))}

    התחיל: {html_lib.escape(str(inst.get('started_at') or ''))}
    הסתיים: {html_lib.escape(str(inst.get('finished_at') or ''))}

    רענןJSON טכני

    לוג התקנה

    נתיב לוג: {html_lib.escape(CAMERA_SETUP_LOG_PATH)}

    {log_tail}
    """ def camera_av_status(): video, audio, devices = selected_ffmpeg_devices() return { "ffmpeg": bool(find_ffmpeg_executable()), "ffmpeg_path": find_ffmpeg_executable() or "", "video_device": video, "audio_device": audio, "devices": devices, "audio_stream": CAMERA_AUDIO_STREAM.status(), "recording": CAMERA_RECORDER.status(), "recordings_dir": CAMERA_RECORDINGS_DIR, "audio_log_path": CAMERA_AUDIO_LOG_PATH, "hls_stream": CAMERA_HLS_STREAM.status(), "hls_log_path": CAMERA_HLS_LOG_PATH, } def camera_stream_generator(): started = time.time() try: while True: if CAMERA_MAX_STREAM_SECONDS > 0 and (time.time() - started) > CAMERA_MAX_STREAM_SECONDS: break frame = CAMERA_MANAGER.read_jpeg() yield b"--frame\r\nContent-Type: image/jpeg\r\nCache-Control: no-cache\r\n\r\n" + frame + b"\r\n" time.sleep(CAMERA_FRAME_INTERVAL_SECONDS) except GeneratorExit: pass except Exception as exc: CAMERA_MANAGER.last_error = str(exc) finally: # Release the webcam when the browser closes/stops the stream so the LED turns off. CAMERA_MANAGER.stop() def render_admin_camera(): allowed, reason = camera_access_allowed() engine = camera_engine_status() av = camera_av_status() cam_status = CAMERA_MANAGER.status() rec_status = av.get("recording", {}) hls_status = av.get("hls_stream", {}) devices = av.get("devices", {}) or {} allowed_block = "" if allowed else f"
    גישה חסומה: {html_lib.escape(reason)}
    " engine_block = "" if not engine.get("opencv"): engine_block = "
    OpenCV לא מותקן.
    הפאנל מנסה להתקין אותו אוטומטית. אפשר לראות את הלוג דרך: 🧩 סטטוס רכיבי מצלמה
    " if not av.get("ffmpeg"): engine_block += "
    FFmpeg לא נמצא.
    שידור מאוחד וידאו+אודיו והקלטות דורשים FFmpeg ב־PATH או ב־C:\\ffmpeg\\bin\\ffmpeg.exe.
    " hls_text = "פעיל" if hls_status.get("active") else "כבוי" hls_cls = "ok" if hls_status.get("active") else "idle" audio_text = "כלול" if hls_status.get("active") and hls_status.get("with_audio") else ("וידאו בלבד" if hls_status.get("active") else "כבוי") audio_cls = "ok" if hls_status.get("active") and hls_status.get("with_audio") else "idle" rec_text = "מקליט" if rec_status.get("active") else "לא מקליט" rec_cls = "rec" if rec_status.get("active") else "idle" disabled_hls = "disabled" if (not allowed or not av.get("ffmpeg")) else "" disabled_video = "disabled" if (not allowed or not engine.get("opencv")) else "" disabled_av = "disabled" if (not allowed or not av.get("ffmpeg")) else "" recordings = list_camera_recordings(12) rec_rows = "".join( f"
    {html_lib.escape(item['name'])}
    {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(item['mtime']))} · {format_bytes(item['size'])}
    פתח
    " for item in recordings ) or "
    אין עדיין הקלטות בתיקייה.
    " video_devices = ", ".join(devices.get("video", [])) or "לא זוהו דרך FFmpeg" audio_devices = ", ".join(devices.get("audio", [])) or "לא זוהו דרך FFmpeg" return f""" מצלמת חדר
    ⬅ חזרה לפאנל

    📷 מצלמת חדר

    v28 חוזר לברירת מחדל יציבה: וידאו דרך OpenCV/MJPEG, כי אצל EMEET SmartCam C965 הווידאו דרך FFmpeg DirectShow נכשל. האודיו מוזרם בנפרד דרך FFmpeg, וה־HLS המאוחד נשאר רק ככלי בדיקה מתקדם.

    סטטוס רכיבי מצלמה לוגים

    שידור מאוחד: {hls_text}אודיו: {audio_text}הקלטה: {rec_text}
    {allowed_block}{engine_block}

    שידור חי וידאו + אודיו

    שידור מצלמה
    השידור כבוי.
    לחץ “הפעל וידאו + אודיו”. הווידאו יעבוד דרך OpenCV, והאודיו דרך FFmpeg.
    מתקדם בלבד: אם תרצה לבדוק שוב HLS מאוחד דרך FFmpeg, השתמש בכפתור הבא. אצל המצלמה שלך הוא כנראה נכשל ולכן לא ברירת מחדל.

    ⏺️ הקלטה למחשב

    הקלטות נשמרות מקומית בתיקייה: {html_lib.escape(CAMERA_RECORDINGS_DIR)}

    משך הקלטה מקסימלי להגנה מדיסק מלא: {CAMERA_RECORD_MAX_SECONDS//60} דקות.

    🎞️ הקלטות אחרונות

    {rec_rows}

    פתח רשימת הקלטות מלאה

    סטטוס טכני

    OpenCV{'מותקן' if engine.get('opencv') else 'לא מותקן'}
    FFmpeg{'זמין' if av.get('ffmpeg') else 'לא נמצא'}
    HLS פעיל{hls_text}
    HLS מצב{html_lib.escape(hls_status.get('mode') or '')}
    וידאו HLS{html_lib.escape(hls_status.get('video_device') or av.get('video_device') or '')}
    אודיו HLS{html_lib.escape(hls_status.get('audio_device') or av.get('audio_device') or '')}
    לוג HLS{html_lib.escape(hls_status.get('log_path') or CAMERA_HLS_LOG_PATH)}
    Camera index{CAMERA_INDEX}
    רזולוציה{CAMERA_WIDTH}×{CAMERA_HEIGHT}
    Frames MJPEG{cam_status.get('frames')}
    קובץ הקלטה פעיל{html_lib.escape(rec_status.get('file_name') or 'אין')}
    גודל הקלטה{format_bytes(rec_status.get('file_size') or 0)}
    שגיאה אחרונה{html_lib.escape(hls_status.get('last_error') or cam_status.get('last_error') or rec_status.get('last_error') or 'אין')}

    התקנים שזוהו

    וידאו:
    {html_lib.escape(video_devices)}

    אודיו:
    {html_lib.escape(audio_devices)}

    אם נבחר התקן לא נכון, אפשר להגדיר במערכת: TRIPSERVER_FFMPEG_VIDEO_DEVICE / TRIPSERVER_FFMPEG_AUDIO_DEVICE.

    בדיקת אודיו טכניתJSON HLS

    הערת שימוש: זה כולל אודיו והקלטה. ודא שכל מי שנמצא בבית יודע שהמערכת קיימת ומתי היא פעילה.
    """ def serve_app(folder): file_name = find_html_file(FOLDERS[folder]) if not file_name: return f"No HTML file found in {folder} folder", 404 return serve_file_no_cache(FOLDERS[folder], file_name) @app.route("/") def home(): return """ מרכז ניהול

    מרכז ניהול

    מערכת מרכזית לניהול קבצים, תקציבים ולוחות זמנים

    📁

    ניהול קבצים

    העלאת קבצים ישירות למחשב.
    💰

    תקציב טיולים

    ניהול תקציב חופשות וסנכרון נתונים.
    🏠

    תקציב משפחתי

    ניהול תקציב חודשי, Limits, הוצאות בפועל וארכיון חודשים.
    🧾

    טופס פתיחת טיול

    טופס קליטת נתונים לטיול חדש.
    📷

    מצלמת חדר

    צפייה חיה במצלמת המחשב, אודיו והקלטות דרך הפאנל.
    🧳

    טיולים

    יפן קיץ 26, ארצות הברית קיץ 27 וכל טיול עתידי במקום אחד.
    TripServer
    """ USA_IMAGE_UI_ITEMS = [('intro', '🇺🇸 ארה״ב 2027 — אמריקה על פול ווליום', 'Road Trip • Orlando • Miami • Cruise / 36 ימים של נופים, פארקים, קניות, קרוז ורגעים שגורמים להגיד: “רגע… לשם אנחנו באמת הולכים?” / מערב ארה״ב: סן פרנסיסקו , כביש 1, LA , קניונים, וגאס ויוסמיטי'), ('roadtrip-map', '🗺️ מסלול הרוד טריפ — הסיפור הגדול, מלמעלה', 'סן פרנסיסקו • כביש 1 • LA • וגאס • יוסמיטי / מפה אחת שמסבירה את כל הרעיון: מתחילים באוקיינוס, מטפסים לקניונים, נוגעים במדבר וחוזרים לטבע. / המסלול נותן את כל המנה: חופים, כבישים יפים, פארקים לאומיים, וגאס ויוסמיטי — בלי לנסות לדחוס כאן את כל הלו״ז.'), ('day-01', 'יום 1 — ✈️ נחיתה ישירה ב סן פרנסיסקו', 'סן פרנסיסקו / נוחתים בעיר שיודעת לפתוח טיול עם סטייל. / נחיתה, התארגנות וטעימה ראשונה מהעיר'), ('day-02', 'יום 2 — 🌉 סן פרנסיסקו + Alcatraz', 'סן פרנסיסקו / Alcatraz / יום של אייקונים: מפרץ, גשרים, אלקטרז ואווירה של סרט. / אלקטרז, תצפיות והעיר הכי פוטוגנית בצפון קליפורניה'), ('day-03', 'יום 3 — 🌊 סן פרנסיסקו → מונטריי', 'מונטריי / 17-Mile Drive / עוברים למוד רוד־טריפ אמיתי: ים, כביש ונופים שמתחילים לעבוד עלינו חזק. / נסיעה דרומה, מונטריי וקטע חוף מהמם'), ('day-04', 'יום 4 — 🐋 Monterey Bay Whale Watch + Big Sur', 'מונטריי / Big Sur / היום שבו האוקיינוס נותן הופעה, ואם לוויתן קופץ — זה כבר בונוס קולנועי. / שייט לווייתנים ואז נופי Big Sur וכביש 1'), ('extra-big-sur', 'Road Trip Bonus — 🌉 Big Sur – Bixby Bridge + McWay Falls', 'כביש 1 / קליפורניה / כאן קליפורניה כבר לא רק יפה — היא מתחילה ממש להשוויץ. / גשר Bixby והחופים הדרמטיים של Big Sur הם מהשיאים המצולמים של כביש 1'), ('day-05', 'יום 5 — 🎡 סנטה מוניקה → לוס אנג׳לס', 'Santa Monica / Los Angeles / נכנסים ל־ LA דרך סנטה מוניקה : חוף, טיילת, גלגל ענק ואווירת קליפורניה קלאסית. / Santa Monica Pier, חוף, טיילת וכניסה לאווירת לוס אנג׳לס'), ('day-06', 'יום 6 — 🎥 Warner Bros + Beverly Hills + Griffith', 'לוס אנג׳לס / LA במצב קלאסי: אולפנים, בוורלי הילס ותצפית של סוף סרט. / Warner Bros , Beverly Hills ו־ Griffith'), ('day-07', 'יום 7 — 🏜️ לוס אנג׳לס → Zion', 'מעבר למדבר / Utah / עוזבים עיר ונכנסים למרחבים. זה יום מעבר, אבל עם סוף ששווה את זה. / נסיעה ארוכה אל אזור Zion'), ('extra-diner', 'Road Trip Bonus — 🍔 Peggy Sue’s 50’s Diner', 'עצירת דרך אמריקאית / מדבר / באמצע כל הנופים הגדולים, מגיע רגע קטן ומושלם של אמריקה קלאסית: ניאון, מילקשייק ואווירת רוד־טריפ אמיתית. / עצירת דיינר שנותנת לטיול את הטעם של אמריקה הישנה והכיפית של הכביש'), ('day-08', 'יום 8 — 🏞️ Zion → Bryce → Page', 'Zion / Bryce / Page / יום טבע חזק במיוחד: צוקים, צבעים ומעברים שנראים לא אמיתיים. / Zion , Bryce והגעה ל־ Page'), ('day-09', 'יום 9 — 🧡 Antelope Canyon + Horseshoe Bend', 'Page Arizona / זה היום של “וואו, לאן אתם הולכים?” — בדיוק זה. / Antelope Canyon ו־ Horseshoe Bend'), ('day-10', 'יום 10 — 🏜️ Page → Grand Canyon South Rim', 'Grand Canyon / היום שבו המילה “גדול” מקבלת קנה מידה חדש. / נסיעה אל South Rim ומפגש עם הגרנד קניון'), ('day-11', 'יום 11 — 🎰 Grand Canyon → Las Vegas', 'לאס וגאס / מהטבע הכי גדול — לעיר הכי מוגזמת. מעבר חד, אבל כיפי. / נסיעה לווגאס וכניסה לאורות של הסטריפ'), ('day-12', 'יום 12 — 🛍️ Vegas Outlets + Sphere', 'לאס וגאס / וגאס יודעת לשלב שופינג, שואו ואורות ברמה לא סבירה. / אאוטלטים, Sphere והסטריפ'), ('day-13', 'יום 13 — ✨ Vegas Extra Day + Strip', 'לאס וגאס / עוד יום בווגאס, כי כנראה יום אחד לא מספיק כדי להגזים כמו שצריך. / קניות, Strip , מלונות ותצוגות ערב'), ('day-14', 'יום 14 — 🏔️ Las Vegas → Mammoth Lakes', 'Mammoth Lakes / נפרדים מהניאון וחוזרים לאוויר הרים כמו אנשים אחראיים. בערך. / נסיעה צפונה אל Mammoth Lakes'), ('extra-death-valley', 'Road Trip Bonus — 🔥 Death Valley', 'בין וגאס ל־Mammoth / זה המעבר הכי חד במסלול: מווגאס המנצנצת אל מדבר עצום, שקט ובלתי נתפס. / עמק המוות מוסיף למסלול מרחבים אינסופיים, תצפיות דרמטיות ותחושת קצה של המערב'), ('extra-mono-lake', 'Road Trip Bonus — 🏜️ Mono Lake / Eastern Sierra', 'בדרך אל יוסמיטי / פה הרוד־טריפ משנה טון שוב: מדבר, הרים, אגם דרמטי ושמיים ענקיים — הכל בפריים אחד. / אזור Eastern Sierra מוסיף תחושת מרחב אדירה לפני הכניסה ליוסמיטי'), ('day-15', 'יום 15 — 🚗 Mammoth → Yosemite Valley', 'יוסמיטי / אחד מימי ה־וואו של הטיול. יוסמיטי נכנסת לפריים. / דרך נופית אל Yosemite Valley'), ('day-16', 'יום 16 — 🌲 Yosemite Highlights + Mariposa Grove', 'יוסמיטי / Mariposa / יום של מפלים, גרניט ועצי סקויה שגורמים לך להרגיש בגודל של סיכה. / יוסמיטי קלאסי + Mariposa Grove'), ('day-17', 'יום 17 — ✈️ Yosemite → SFO → Orlando', 'מעבר לאורלנדו / סוגרים פרק מערב ופותחים פרק פארקים. המזוודות עוד לא יודעות מה מחכה להן. / נסיעה לשדה וטיסה לאורלנדו'), ('day-18', 'יום 18 — 🛍️ התאוששות + Disney Springs', 'אורלנדו / יום רך לפני שמתחילים לצרוח בפארקים. / התאוששות, Disney Springs ואווירה קלילה'), ('day-19', 'יום 19 — 🎢 Islands of Adventure', 'Universal Orlando / כאן מתחיל פרק האדרנלין הרשמי. אקספרס ביד, חיוך בפנים. / צ׳ק־אין Premier ו־ Islands of Adventure'), ('day-20', 'יום 20 — 🎬 Universal Studios Florida + CityWalk', 'Universal Studios / יום Universal קלאסי: מתקנים, אווירה ו־ CityWalk לסיום. / Universal Studios Florida וערב CityWalk'), ('day-21', 'יום 21 — ⛳ מנוחה + Hollywood Drive-In Mini Golf', 'אורלנדו / יום רגוע יותר, כי גם למשפחה עם אנרגיה צריך טעינה. / מנוחה, בריכה/קניות קלות ומיני גולף'), ('day-22', 'יום 22 — 🌌 Epic Universe + Express', 'Epic Universe / אחד הימים הכי מסקרנים בטיול — פארק חדש, גדול ומלא הייפ. / Epic Universe עם Express'), ('day-23', 'יום 23 — 🧗 פארק חבלים + בריכה / I‑Drive', 'אורלנדו / קצת אקשן, קצת בריכה, קצת אורלנדו בלי לחץ. / פארק חבלים, בריכה או International Drive'), ('day-24', 'יום 24 — 🌊 Volcano Bay + Express', 'Volcano Bay / מים, מגלשות ויום רענון שנראה כמו פרסומת לחופשה. / Volcano Bay עם Express'), ('day-25', 'יום 25 — 🎃 רגוע + Halloween Horror Nights', 'Universal HHN / היום מתחיל רגוע ונגמר בפנים לבנות. / מנוחה ביום ו־HHN בערב'), ('day-26', 'יום 26 — 🚗 Orlando → Sawgrass Mills → Miami', 'Sawgrass / Miami / מחליפים פארקים בשופינג, ואז ממשיכים ל מיאמי . / Sawgrass Mills והמשך ל מיאמי'), ('day-27', 'יום 27 — 🌴 Miami Chill Before Cruise', 'מיאמי / מיאמי מורידה הילוך בסטייל לפני הקרוז. / חוף, אווירה, התארגנות ונשימה עמוקה'), ('day-28', 'יום 28 — 🚢 החזרת רכב ועלייה לקרוז', 'נמל מיאמי / הרכב חוזר, האונייה מתחילה. החופשה עוברת למצב צף. / עלייה לקרוז ותחילת פרק הים'), ('day-29', 'יום 29 — 🌊 קרוז – יום ים 1', 'בלב הים / יום ים ראשון: בריכה, אוכל, סיפון ונוף בלי סוף. / יום חופשי על האונייה'), ('day-30', 'יום 30 — 🌊 קרוז – יום ים 2', 'בלב הים / עוד יום ים, כי למה לעצור משהו שעובד? / מתקני האונייה, אוכל ומנוחה'), ('day-31', 'יום 31 — 🏝️ St. Maarten', 'St. Maarten / הקריביים נכנסים לתמונה בצבעים שלא נראים חוקיים. / יום עגינה ב־ St. Maarten'), ('day-32', 'יום 32 — 🐬 St. Thomas + Dolphin Splash', 'St. Thomas / יום שיכול להפוך לזיכרון משפחתי חזק במיוחד. / St. Thomas ואטרקציית דולפינים'), ('day-33', 'יום 33 — 🌅 קרוז – יום ים 3', 'בלב הים / עוד קצת ים כדי לא להיגמל מהר מדי. / יום ים, סיפון, אוכל ונוף'), ('day-34', 'יום 34 — 🏖️ Perfect Day at CocoCay', 'CocoCay / שם מחייב — ובמקרה הזה הוא לגמרי מתכוון לזה. / CocoCay , חוף, מים טורקיז ופארק מים'), ('day-35', 'יום 35 — 🏨 ירידה מהקרוז + לילה ליד השדה', 'מיאמי / החופשה מתחילה להתקפל, אבל לא שוברים בבת אחת. / ירידה מהקרוז, התארגנות ולילה ליד השדה'), ('day-36', 'יום 36 — 🛫 טיסה חזרה לישראל', 'הביתה / היום הפחות אהוב, אבל עם אלבום מטורף בזיכרון. / עלייה לטיסה חזרה לישראל'), ('budget', '💰 תקציב — המספרים, בלי דרמה', 'תמונת מצב פיננסית / זה לא טיול קטן. זה פרויקט משפחתי עם נוף, פארקים, ים, שופינג וקרוז. / עלות כללית מוערכת: $81,297 ≈ ₪243,890'), ('summary', '🥂 סיום — אז לאן אתם באמת הולכים?', 'טיול חלום משפחתי / אם מי שרואה את זה אומר “וואו” — הוא פשוט צודק. / מערב ארה״ב, אורלנדו, מיאמי וקרוז — בטיול אחד')] def local_no_window_flags(): if os.name == "nt": return getattr(subprocess, "CREATE_NO_WINDOW", 0) return 0 def local_existing_dir(path): try: return bool(path and os.path.isdir(path)) except Exception: return False def local_norm_path(path): return os.path.abspath(os.path.normpath(os.path.expandvars(os.path.expanduser(str(path or ""))))) def local_add_unique_path(items, label, path, key_hint, writable=True): if not local_existing_dir(path): return norm = local_norm_path(path) low = norm.lower() if any(item["path"].lower() == low for item in items): return items.append({"label": label, "path": norm, "key_hint": key_hint, "readonly": False, "writable": bool(writable)}) def discover_download_folders(): items = [] bases = [] for env in ("USERPROFILE", "HOME"): val = os.environ.get(env) if val: bases.append(val) hd = os.environ.get("HOMEDRIVE") hp = os.environ.get("HOMEPATH") if hd and hp: bases.append(hd + hp) for env in ("OneDrive", "OneDriveConsumer", "OneDriveCommercial"): val = os.environ.get(env) if val: bases.append(val) if os.name == "nt": # Scan Windows user profiles. This catches cases where the service runs under another user. users_root = r"C:\Users" try: for name in os.listdir(users_root): if name.lower() in {"public", "default", "default user", "all users"}: continue p = os.path.join(users_root, name) if os.path.isdir(p): bases.append(p) bases.append(os.path.join(p, "OneDrive")) bases.append(os.path.join(p, "OneDrive - Personal")) except Exception: pass checked = set() for base in bases: if not base: continue base = local_norm_path(base) if base.lower() in checked: continue checked.add(base.lower()) for sub in ("Downloads", "הורדות"): local_add_unique_path(items, "הורדות במחשב", os.path.join(base, sub), "downloads") # Some OneDrive setups store the localized display name but keep physical folder as Downloads. local_add_unique_path(items, "הורדות OneDrive", os.path.join(base, "Downloads"), "downloads") if os.name == "nt": # v34.17: also detect Downloads folders placed directly on data drives, # for example D:\הורדות as seen on the user's computer. This is shallow # and safe: it only adds existing folders named Downloads / הורדות. for letter in "CDEFGHIJKLMNOPQRSTUVWXYZ": drive = f"{letter}:\\" for sub in ("הורדות", "Downloads"): candidate = os.path.join(drive, sub) local_add_unique_path(items, f"הורדות בכונן {letter}:", candidate, "downloads") try: for name in os.listdir(drive): clean = str(name or "").strip().lower() if clean in {"downloads", "הורדות"}: local_add_unique_path(items, f"הורדות בכונן {letter}:", os.path.join(drive, name), "downloads") except Exception: pass return items def tripserver_score(path): score = 0 try: names = set(os.listdir(path)) except Exception: return 0 for name in ("admin_server.py", "control_server", "JAPAN", "USA", "Moneyapp", "MoneyHome", "TripForm"): if name in names: score += 1 return score def discover_tripserver_folders(): items = [] candidates = [] # The running admin script location is the strongest signal. try: candidates.append(os.path.dirname(os.path.abspath(__file__))) except Exception: pass candidates.append(BASE_DIR) candidates.append(os.getcwd()) # Common locations on the server computer. for env in ("USERPROFILE", "HOME", "OneDrive", "OneDriveConsumer", "OneDriveCommercial"): base = os.environ.get(env) if base: candidates.extend([ os.path.join(base, "TripServer"), os.path.join(base, "Desktop", "TripServer"), os.path.join(base, "Documents", "TripServer"), os.path.join(base, "Downloads", "TripServer"), ]) if os.name == "nt": for drive in ("C:\\", "D:\\", "E:\\"): candidates.append(os.path.join(drive, "TripServer")) try: # Shallow scan only; avoids hanging the server while still finding typical placements. for name in os.listdir(drive): if "tripserver" in name.lower() or name.lower() in {"server", "trip", "trips"}: candidates.append(os.path.join(drive, name)) except Exception: pass try: for user in os.listdir(r"C:\Users"): up = os.path.join(r"C:\Users", user) if os.path.isdir(up): candidates.extend([ os.path.join(up, "Desktop", "TripServer"), os.path.join(up, "Documents", "TripServer"), os.path.join(up, "Downloads", "TripServer"), ]) except Exception: pass # Add parent folders around the running script if they look like TripServer. try: cur = os.path.dirname(os.path.abspath(__file__)) for _ in range(3): candidates.append(cur) cur = os.path.dirname(cur) except Exception: pass seen = set() scored = [] for c in candidates: if not c: continue n = local_norm_path(c) low = n.lower() if low in seen or not local_existing_dir(n): continue seen.add(low) score = tripserver_score(n) if score >= 1 or os.path.basename(n).lower() == "tripserver": scored.append((score, n)) scored.sort(key=lambda x: (-x[0], len(x[1]))) for idx, (score, path) in enumerate(scored[:8], start=1): label = "TripServer" if idx == 1 else f"TripServer נוסף {idx}" local_add_unique_path(items, label, path, "tripserver") return items def build_local_file_roots(force=False): global LOCAL_FILE_ROOTS_CACHE, LOCAL_FILE_ROOTS_CACHE_TS now = time.time() if (not force) and LOCAL_FILE_ROOTS_CACHE and (now - LOCAL_FILE_ROOTS_CACHE_TS < 60): return LOCAL_FILE_ROOTS_CACHE roots = {} all_items = [] all_items.extend(discover_download_folders()) all_items.extend(discover_tripserver_folders()) if not all_items: # Safe fallback: expose only the folder where the admin is running. try: all_items.append({"label": "תיקיית האדמין", "path": os.path.dirname(os.path.abspath(__file__)), "key_hint": "tripserver", "readonly": False, "writable": True}) except Exception: pass counts = {"downloads": 0, "tripserver": 0, "root": 0} for item in all_items: hint = item.get("key_hint") or "root" counts[hint] = counts.get(hint, 0) + 1 key = hint if counts[hint] == 1 else f"{hint}_{counts[hint]}" roots[key] = {"label": item["label"], "path": item["path"], "readonly": False, "writable": True} LOCAL_FILE_ROOTS_CACHE = roots LOCAL_FILE_ROOTS_CACHE_TS = now return roots def normalize_local_root_key(root_key): roots = build_local_file_roots() root_key = (root_key or "").strip().lower() if root_key in roots: return root_key if "downloads" in roots: return "downloads" if "tripserver" in roots: return "tripserver" return next(iter(roots.keys())) if roots else "downloads" def local_root_path(root_key): roots = build_local_file_roots() root_key = normalize_local_root_key(root_key) if root_key not in roots: raise ValueError("לא נמצאה תיקיית בסיס מאושרת.") return os.path.abspath(os.path.normpath(roots[root_key]["path"])) def safe_local_path(root_key, rel_path=""): root = local_root_path(root_key) rel_path = (rel_path or "").replace("\\", os.sep).replace("/", os.sep).strip() if rel_path and (os.path.isabs(rel_path) or re.match(r"^[A-Za-z]:", rel_path)): raise ValueError("נתיב מוחלט נחסם. ניתן לגלוש רק בתוך התיקיות המאושרות.") target = os.path.abspath(os.path.normpath(os.path.join(root, rel_path))) try: common = os.path.commonpath([root, target]) except Exception: raise ValueError("נתיב לא תקין.") if common != root: raise ValueError("ניסיון יציאה מתיקיית הבסיס נחסם.") return target def rel_for_local(root_key, full_path): root = local_root_path(root_key) try: rel = os.path.relpath(full_path, root) return "" if rel == "." else rel.replace("\\", "/") except Exception: return "" def local_file_kind(path): if os.path.isdir(path): return "dir" ext = os.path.splitext(path)[1].lower() if ext in {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"}: return "image" if ext in LOCAL_FILE_TEXT_EXTENSIONS: return "text" return "file" def local_file_icon(kind): return {"dir": "📁", "image": "🖼️", "text": "📄", "file": "📦"}.get(kind, "📦") def local_safe_name(name): name = os.path.basename((name or "").replace("\\", "/")).strip() name = re.sub(r"[\x00-\x1f<>:\"/\\|?*]", "_", name) name = name.strip(" .") if name in {"", ".", ".."}: raise ValueError("שם קובץ/תיקייה לא תקין.") return name def local_unique_destination(path): if not os.path.exists(path): return path folder = os.path.dirname(path) base, ext = os.path.splitext(os.path.basename(path)) for i in range(1, 1000): candidate = os.path.join(folder, f"{base}_copy{i}{ext}") if not os.path.exists(candidate): return candidate raise ValueError("לא ניתן ליצור שם יעד ייחודי.") def local_copy_item(src, dest_dir): target = local_unique_destination(os.path.join(dest_dir, os.path.basename(src))) if os.path.isdir(src): shutil.copytree(src, target) else: shutil.copy2(src, target) return target def local_move_item(src, dest_dir): target = local_unique_destination(os.path.join(dest_dir, os.path.basename(src))) shutil.move(src, target) return target def add_path_to_zip(zf, root_key, full_path, base_arc=""): if os.path.isfile(full_path): arc = base_arc or rel_for_local(root_key, full_path) zf.write(full_path, arc) return os.path.getsize(full_path), 1 total = 0 count = 0 for dirpath, dirnames, filenames in os.walk(full_path): dirnames[:] = [d for d in dirnames if d not in {"$RECYCLE.BIN", "System Volume Information", "__pycache__"}] for filename in filenames: p = os.path.join(dirpath, filename) try: size = os.path.getsize(p) rel = rel_for_local(root_key, p) zf.write(p, rel) total += size count += 1 except Exception: continue return total, count def local_file_href(endpoint="/admin/local-files", root_key=None, rel_path=None, **extra): """Build HTML-safe admin local-file URLs with proper percent-encoding. This is required for Hebrew names, spaces and characters like & in filenames. """ params = {} if root_key is not None: params["root"] = str(root_key) if rel_path is not None and str(rel_path) != "": params["path"] = str(rel_path).replace("\\", "/") for k, v in extra.items(): if v is not None: params[k] = str(v) url = endpoint if params: url += "?" + urllib.parse.urlencode(params, doseq=True) return html_lib.escape(url, quote=True) def render_admin_file_manager(root_key="downloads", rel_path=""): root_key = normalize_local_root_key(root_key) roots = build_local_file_roots() root_info = roots[root_key] try: current = safe_local_path(root_key, rel_path) except Exception as exc: return admin_status_page("נתיב נחסם", "מנהל הקבצים לא פתח את הנתיב המבוקש.", ok=False, details=str(exc)), 400 if not os.path.exists(current): return admin_status_page("תיקייה לא קיימת", "התיקייה המבוקשת לא קיימת במחשב השרת.", ok=False, details=current), 404 if not os.path.isdir(current): return redirect(html_lib.unescape(local_file_href("/admin/local-files/preview", root_key, rel_for_local(root_key, current)))) rel_path = rel_for_local(root_key, current) breadcrumbs = [] if rel_path and rel_path != ".": parts = [p for p in rel_path.split("/") if p and p != "."] acc = [] breadcrumbs.append(f'שורש') for part in parts: acc.append(part) breadcrumbs.append(f'{html_lib.escape(part)}') else: breadcrumbs.append("שורש") rows = [] parent_link = "" if rel_path and rel_path not in (".", ""): parent = os.path.dirname(rel_path.replace("/", os.sep)).replace("\\", "/") parent_link = f'⬆️ תיקייה למעלהתיקייה' try: entries = [] for name in os.listdir(current): if name in {"$RECYCLE.BIN", "System Volume Information"}: continue path = os.path.join(current, name) try: is_dir = os.path.isdir(path) st = os.stat(path) entries.append((not is_dir, name.lower(), name, path, st)) except Exception: continue entries.sort() limited = entries[:LOCAL_FILE_LIST_LIMIT] for _not_dir, _sort, name, path, st in limited: rel = rel_for_local(root_key, path) kind = local_file_kind(path) icon = local_file_icon(kind) safe_name = html_lib.escape(name) safe_rel = html_lib.escape(rel, quote=True) modified = time.strftime("%Y-%m-%d %H:%M", time.localtime(st.st_mtime)) size = "—" if os.path.isdir(path) else format_bytes(st.st_size) checkbox = f'' if os.path.isdir(path): main = f'{icon} {safe_name}' actions = 'פתח' else: main = f'{icon} {safe_name}' actions = f'הורד ' if kind == "text" and st.st_size <= LOCAL_FILE_PREVIEW_MAX_BYTES: actions += f' · תצוגה · עריכה' rows.append(f'{checkbox}{main}{html_lib.escape(kind)}{size}{modified}{actions}') if len(entries) > LOCAL_FILE_LIST_LIMIT: rows.append(f'מוצגים {LOCAL_FILE_LIST_LIMIT} פריטים ראשונים מתוך {len(entries)}. השתמש בתיקיות משנה כדי לצמצם.') except Exception as exc: rows.append(f'שגיאה בקריאת תיקייה: {html_lib.escape(repr(exc))}') root_buttons = [] for key, info in roots.items(): cls = "active-root" if key == root_key else "" root_buttons.append(f'{html_lib.escape(info["label"])}') dest_options = [] for key, info in roots.items(): selected = " selected" if key == root_key else "" dest_options.append(f'') body_rows = parent_link + "\n".join(rows) safe_current = html_lib.escape(current) root_key_safe = html_lib.escape(root_key, quote=True) rel_path_safe = html_lib.escape(rel_path if rel_path != "." else "", quote=True) crumbs = " / ".join(breadcrumbs) return f""" קבצי מחשב
    ⬅ חזרה לפאנל

    📁 קבצי מחשב — גישה מלאה לתיקיות מאושרות

    הפאנל סורק את מחשב השרת ומציג תיקיות הורדות ו־TripServer שנמצאו בפועל. בתוך התיקיות האלה אפשר לקרוא, להוריד, להעלות, למחוק, ליצור תיקייה, לערוך טקסט, להעתיק ולהעביר קבצים.

    {''.join(root_buttons)}🔄 סרוק מחדש
    {safe_current}

    {crumbs}

    חשוב: זה עדיין לא נותן ל־ChatGPT גישה ישירה למחשב שלך. אבל זה כן נותן לך דרך לנהל קבצים במחשב השרת מתוך הפאנל, ליצור ZIP ולהעלות אליי לצ׳אט כשצריך ניתוח.

    פעולות בתיקייה הנוכחית

    {body_rows}
    שםסוגגודלעודכןפעולות
    """ def render_usa_image_upload_cards(target_variant="phone"): target_variant, target_info = usa_image_target_info(target_variant) safe_target = html_lib.escape(target_variant, quote=True) target_label = html_lib.escape(target_info["label"], quote=True) cards = [] for image_key, title, desc in USA_IMAGE_UI_ITEMS: safe_key = html_lib.escape(image_key, quote=True) safe_title = html_lib.escape(title, quote=True) safe_desc = html_lib.escape(desc, quote=True) search_text = html_lib.escape((image_key + " " + title + " " + desc).lower(), quote=True) input_id = html_lib.escape("image-file-" + target_variant + "-" + image_key, quote=True) cards.append("""
    """ % (search_text, safe_target, safe_key, input_id, target_label, input_id, safe_key, safe_title, safe_desc, target_label)) return "\n".join(cards) @app.route("/admin") @app.route("/admin/") def admin(): return """ TripServer Admin

    TripServer Admin

    מסך ניהול לפי היגיון עבודה: בוחרים תחום, נכנסים לתת־קטגוריה, ואז מעלים רק את מה שצריך. בלי גלילה אינסופית ובלי לחפש ידיים ורגליים.

    📊 סטטוס קבצים 🩺 בדיקת מערכת 🧪 בדיקה עצמית מלאה 📜 לוגים 🏠 ראשי
    📁 העלאה בטוחהשמירה זמנית, גיבוי, החלפה אטומית, גודל ו־SHA אחרי שמירה.
    """ + render_failsafe_status_card() + """
    🧭 מבנה היררכימסך ראשי → תחום → תת־תחום → פעולה.
    🖥️ מחשבכיבוי/ריסטארט עם טיימר, אישור כתוב וביטול.
    📜 לוגיםצפייה בלוגי האדמין, עדכונים ופעולות מערכת מתוך הפאנל.
    📷

    מצלמת חדר

    הפעלת מצלמת החדר, אודיו והקלטות — רק בלחיצה ידנית.
    📜

    לוגים

    צפייה בלוגי האדמין, עדכונים ופעולות מערכת מתוך הדפדפן.
    📁

    קבצי מחשב

    גישה מלאה לתיקיות הורדות ו־TripServer שהתגלו במחשב: קריאה, העלאה, מחיקה, העתקה, העברה ו־ZIP.

    🌐 Netlify

    בחר טיול, והפאנל יבנה ZIP מוכן להעלאה ל־Netlify מתוך הקבצים העדכניים שנמצאים כעת בתיקיות הטיול בשרת.

    🇺🇸 טיול ארצות הברית 27

    יוצר ZIP עם USA/index.html, מצגת, תמונות, מוזיקה וכל הנתיבים הנדרשים ל־Netlify.

    🇯🇵 טיול יפן 26

    יוצר ZIP עם index.html, פתיח טיסה, מצגת יפן, מדיה וכל הנתיבים הנדרשים ל־Netlify.

    בזמן הבנייה מתבצעת סימולציית נתיבים: קבצי HTML נבדקים מול הקבצים שנכנסו ל־ZIP, וקישורים לשרת הפרטי מוחלפים לנתיבי Netlify.

    🧳 טיולים

    כאן נמצאים כל הטיולים הפעילים. טיול חדש יתווסף למסך הזה, בלי להעמיס על המסך הראשי.

    🇯🇵 יפן קיץ 26

    קובץ טיול, מצגות, תמונות ומוזיקה של טיול יפן 2026.

    🇺🇸 ארצות הברית קיץ 27

    קובץ טיול, מצגת, TV, תמונות שקפים ומוזיקה של טיול ארצות הברית 2027.

    פורמט עבודה להמשך: כל טיול עתידי יופיע כאן ככרטיס חדש עם שם יעד + עונה/שנה, ואז יוביל למסך משנה באותו מבנה של קובץ טיול, מצגות, מדיה ובדיקות.

    🇯🇵 יפן

    בחר קודם מה אתה מעדכן: קובץ הטיול, המצגות או המדיה.

    פתח יפן

    📄 קובץ טיול יפן

    העלאת index.html או חבילת ZIP מלאה.

    🎬 מצגות יפן

    פתיח טיסה ומצגת יפן.

    🖼️🎵 מדיה יפן

    ZIP תמונות ושירי MP3.

    🔎 בדיקה מהירה

    פתיחת מצגת יפן בחלון חדש.

    📄 קובץ טיול יפן

    קובץ יחיד נשמר כ־JAPAN/index.html. ZIP מלא מעדכן גם מצגות ומדיה אם הן קיימות בחבילה.

    קובץ HTML ראשי

    יישמר כ־C:\\TripServer\\JAPAN\\index.html

    ZIP מלא יפן

    מתאים לחבילה עם index.html, japan-experience.html, japan-flight-intro.html ותיקיית media.

    🎬 מצגות יפן

    שמות היעד קבועים כדי שהקישורים מתוך קובץ הטיול לא יישברו.

    ✈️ פתיח טיסה

    יישמר כ־japan-flight-intro.html

    🎌 מצגת יפן

    יישמר כ־japan-experience.html

    בדיקת פתיחבדיקת מצגת

    🖼️🎵 מדיה יפן

    תמונות ושירים נשמרים לנתיבים שהמצגת מחפשת בפועל. ספירה מדויקת של תמונות בשימוש נמצאת במסך סטטוס קבצים.

    ZIP תמונות מצגת יפן

    הפאנל מסנן קובצי תמונה נתמכים. הספירה החשובה היא לא כמה קבצים יש בתיקייה, אלא כמה src מופיעים בפועל בתוך japan-experience.html. בחבילות/ZIP מלאים הוא לא משנה שמות קבצים כדי לא לשבור קישורים פנימיים במצגת.

    🎵 שיר מצגת יפן — בדיקה לפני הטמעה

    פעולה בטוחה: השיר נשמר זמנית, ffprobe מזהה את האורך, ורק אם ממוצע השקף בטווח 5–10 שניות הוא מוטמע ומסונכרן אוטומטית. אם הוא קצר מדי או ארוך מדי, יוצג מסך אישור לפני שמירת השיר בנתיבי המצגת ולפני שינוי japan-experience.html.

    סטטוס סנכרון מוזיקהפתח מצגת יפן

    ✈️ מוזיקת פתיח טיסה — העלאה

    פתיח הטיסה הוא מקטע נפרד. השיר נשמר ונמדד, אבל לא משנה את japan-experience.html.

    🇺🇸 ארצות הברית

    אזור ארה״ב מחולק לקובץ טיול, מצגות, תמונות שקפים ומוזיקה/TV.

    פתח ארה״ב

    📄 קובץ טיול

    HTML ראשי, ZIP מלא וגרסת טלוויזיה.

    🎬 מצגת

    מצגת עם סכומים וגרסת TV.

    🖼️ תמונות שקפים

    ZIP מלא או העלאה לפי שקף/יום.

    🎵 מוזיקה

    שיר חלק 1 ושיר חלק 2 של המצגת.

    📄 קובץ טיול ארה״ב

    קובץ הטיול הראשי נשמר כ־USA/index.html. גרסת TV נשמרת בנפרד.

    HTML ראשי

    יישמר כ־C:\\TripServer\\USA\\index.html

    ZIP מלא ארה״ב

    מתאים לחבילת Netlify/שרת עם index.html, מצגת, media ותמונות.

    גרסת טלוויזיה

    יישמר כ־usa2027-tv.html.

    🎬 מצגת ארה״ב

    המצגת הרגילה והמצגת המותאמת למסך טלוויזיה נשמרות בשמות קבועים.

    מצגת ארה״ב עם סכומים

    יישמר כ־usa2027-presentation.html

    מצגת ארה״ב TV

    יישמר כ־usa2027-presentation-tv.html

    בדיקת מצגתבדיקת מצגת TV

    🖼️ תמונות מצגת ארה״ב

    בחר קודם לאיזו מצגת התמונות מיועדות. לכל יעד יש תיקייה נפרדת, כדי שתמונות אייפון לא ידרסו תמונות TV ולהפך.

    הפרדה חדשה: מסך פלאפון נשמר ב־media/usa-presentation/images. מסך טלוויזיה נשמר ב־media/usa-presentation/images-tv. שמות הקבצים נשארים זהים, אבל היעד נפרד.

    📱 מסך פלאפון

    תמונות מותאמות למצגת אייפון/אנדרואיד. יעד: usa2027-presentation.html.

    📺 מסך טלוויזיה

    תמונות מותאמות למצגת TV / LG C3. יעד: usa2027-presentation-tv.html.

    📱 תמונות שקפים — מסך פלאפון

    העלה ZIP מלא או תמונה בודדת. הקבצים יישמרו רק בתיקיית הפלאפון.

    ZIP תמונות מלא — פלאפון

    שמות נתמכים: intro, roadtrip-map, day-01 עד day-36, budget, summary ותמונות bonus.

    בדיקת מצגת פלאפון

    אחרי העלאה פתח את המצגת הרגילה ובדוק שאין cache ישן.

    פתח מצגת פלאפוןסטטוס תמונות
    """ + render_usa_image_upload_cards("phone") + """

    📺 תמונות שקפים — מסך טלוויזיה

    העלה ZIP מלא או תמונה בודדת. הקבצים יישמרו רק בתיקיית הטלוויזיה.

    ZIP תמונות מלא — טלוויזיה

    שמות נתמכים זהים לפלאפון, אבל השמירה מתבצעת לתיקיית TV נפרדת.

    בדיקת מצגת TV

    אחרי העלאה פתח את מצגת הטלוויזיה ובדוק שאין cache ישן.

    פתח מצגת TVסטטוס תמונות
    """ + render_usa_image_upload_cards("tv") + """

    🎵 מוזיקת מצגת ארה״ב

    העלאת שיר קיימת + מדידת אורך + סנכרון המקטע הרלוונטי במצגת הרגילה ובמצגת TV.

    כלל עבודה פעיל: למצגת ארה״ב יש שני שירים. שיר חלק 1 מסנכרן רק שקפים 1–23. שיר חלק 2 מסנכרן רק שקפים 24–44. לא משנים את המקטע השני כשמעלים את הראשון, ולהפך.

    שיר חלק 1 — Road Trip

    הקובץ נשמר כ־media/usa-presentation/music/usa-roadtrip-theme.mp3, ואז PART_1_SECONDS מתעדכן במצגת הרגילה ובמצגת TV.

    שיר חלק 2 — Orlando / Miami / Cruise

    הקובץ נשמר כ־media/usa-presentation/music/usa-part2-theme.mp3, ואז PART_2_SECONDS מתעדכן במצגת הרגילה ובמצגת TV.

    סטטוס סנכרון מוזיקהפתח מצגת ארה״בפתח מצגת TV

    💰 תקציבים

    שתי אפליקציות נפרדות: תקציב חופשה ותקציב חודשי/משפחתי.

    💼 אפליקציית ניהול תקציב חופשה

    יישמר כ־Moneyapp/index.html.

    פתח תקציב חופשה

    🏠 אפליקציית תקציב חודשי / משפחתי

    יישמר כ־MoneyHome/index.html.

    פתח תקציב חודשי

    🧾 טופס פתיחת טיול

    טופס הקליטה ליצירת טיול חדש.

    פתח טופס

    העלאת טופס HTML

    יישמר כ־TripForm/index.html.

    🖥️ פעולות מחשב

    פעולות Windows אמיתיות. הן מוגנות באישור כתוב, טיימר וחסימת גישה מחוץ לרשת מקומית.

    זהירות: כיבוי או ריסטארט מנתקים את השרת עד שהמחשב עולה מחדש. השתמש בטיימר ולא ב־0 שניות.

    ⏻ כיבוי מחשב

    🔄 ריסטארט למחשב

    פעולות נרשמות ללוג C:\\TripServer\\admin_restart.log.

    ⚙️ ניהול אפליקציית האדמין

    כאן מעדכנים את הקובץ שמפעיל את הפאנל עצמו. נתמך קובץ Python ישיר, ומגרסה זו גם ZIP עדכון מבוקר.

    סטטוסבדיקת מערכתבדיקה עצמית מלאהלוגים
    פעולה רגישה: עדכון admin_server.py מחליף את המנוע שמריץ את הפאנל. לפני שליחת העדכון מופעל Fail Safe: ריסטארט Windows מתוכנן לעוד 3 דקות, כדי שגם אם הפאנל ייתקע המחשב יחזור לבד.
    הזרימה: העלאה → בדיקת Python → בדיקת סימני TripServer → גיבוי → חימוש Fail Safe → שליחה לשרת הבקרה → החלפה ואתחול. אם הכול חזר תקין — אפשר ללחוץ על ביטול ריסטארט Fail Safe. אם הוא כבר בוטל אוטומטית, תופיע הודעה רגועה שאין ריסטארט פעיל.

    העלאת admin חדש

    ניתן להעלות קובץ Python ישיר. החל מגרסה זו נתמך גם ZIP מבוקר הכולל admin_server.py בשורש החבילה. ZIP אינו מריץ סקריפטים חופשיים — בכוונה, כדי לא לסכן את השליטה מרחוק.

    פעולות תחזוקה

    🧪 הרץ בדיקה עצמית מלאה📜 צפה בלוגים🛰️ שרת בקרה

    הערה: בדיקת אתחול מיועדת רק לבדיקה יזומה או אחרי עדכון/שחזור אדמין.
    גיבויים: C:\\TripServer\\backups\\admin_server

    """ def render_probe_form(rule_key): return f"""
    בדיקה זמנית בלבד: הקובץ נמחק בסיום, אין שמירה ואין שינוי למצגת. """ def render_presentation_music_panel(): rows = [] for key, rule in PRESENTATION_MUSIC_SYNC_RULES.items(): targets = "
    ".join(html_lib.escape(str(x)) for x in (rule.get("music_targets") or [])) rows.append(f""" {html_lib.escape(rule.get('label',''))}
    {html_lib.escape(key)} {html_lib.escape(rule.get('scope',''))} {html_lib.escape(rule.get('presentation',''))} {targets} {html_lib.escape(rule.get('future_behavior',''))} העלאה פעילה דרך מסך הטיול
    בדיקת אורך זמנית נשארה ככלי עזר בלבד:
    {render_probe_form(key)} """) ffprobe = find_ffprobe_executable() or "לא נמצא" ffprobe_badge = "safe" if find_ffprobe_executable() else "warn" return f""" סנכרון מוזיקה למצגות
    ⬅ חזרה לפאנל

    🎵 סנכרון מוזיקה למצגות — העלאה קיימת + סנכרון פעיל

    גרסה זו מתחברת להעלאות השירים הקיימות: יפן מצגת ראשית מודדת את השיר לפני הטמעה ומבקשת אישור אם קצב השקפים יוצא מטווח 5–10 שניות. ארה״ב חלק 1 מסנכרן רק שקפים 1–23, וחלק 2 מסנכרן רק שקפים 24–44. פתיח הטיסה נשמר ונמדד ללא שינוי למצגת הראשית.

    ffprobe: {html_lib.escape(ffprobe)}
    סדר הפיתוח: v34.14 לא מוסיף מנגנון העלאה חדש. הוא משתמש בהעלאות הקיימות ומוסיף עליהן מדידה, מסך אישור לפני הטמעה כשצריך, וסנכרון בפועל רק לאחר בחירת המשתמש. טפסי בדיקת אורך זמניים נשארו כלי עזר בלבד ואינם מחליפים את כפתורי ההעלאה.

    סטטוס העלאות אחרונות

    {render_music_upload_status_rows()}
    שירסטטוסזמן עדכוןפירוט

    כללי סנכרון פעילים ובדיקת אורך זמנית

    {''.join(rows)}
    שיר / יעדתחום סנכרוןמצגתנתיבי מוזיקההתנהגות עתידיתבדיקה זמנית
    """ @app.route("/admin/presentation-music") def admin_presentation_music(): return render_presentation_music_panel() @app.route("/probe_presentation_music/", methods=["POST"]) def probe_presentation_music(rule_key): if rule_key not in PRESENTATION_MUSIC_SYNC_RULES: return admin_status_page("סוג שיר לא מוכר", "לא נמצא כלל סנכרון מתאים לשיר שנבחר.", ok=False), 404 file = request.files.get("file") if not file or file.filename == "": return admin_status_page("לא נבחר קובץ", "בחר קובץ אודיו לבדיקה זמנית.", ok=False), 400 if request.content_length and request.content_length > AUDIO_UPLOAD_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ מוזיקה גדול מדי", f"קובץ האודיו גדול מהמגבלה: {format_bytes(AUDIO_UPLOAD_MAX_BYTES)}.", ok=False), 413 probe_dir = os.path.join(BASE_DIR, "tmp", "music_probe") os.makedirs(probe_dir, exist_ok=True) safe_name = secure_filename(file.filename or "audio") or "audio" target = os.path.join(probe_dir, time.strftime("probe_%Y%m%d_%H%M%S_") + safe_name) try: file.save(target) result = probe_audio_duration_seconds(target) rule = PRESENTATION_MUSIC_SYNC_RULES.get(rule_key, {}) if result.get("ok"): details = ( f"שיר/מקטע: {rule.get('label','')}\n" f"תחום סנכרון עתידי: {rule.get('scope','')}\n" f"משך שזוהה: {result.get('duration_display')} ({result.get('duration_seconds'):.3f} שניות)\n" f"ffprobe: {result.get('ffprobe')}\n\n" "בדיקה זמנית בלבד: הקובץ לא נשמר קבוע, ולא בוצע שינוי במצגת." ) return admin_status_page("בדיקת אורך שיר הצליחה", "ffprobe זיהה את משך השיר. לא בוצע סנכרון ולא נשמר שיר קבוע.", ok=True, details=details) details = ( f"שיר/מקטע: {rule.get('label','')}\n" f"ffprobe: {result.get('ffprobe') or 'לא נמצא'}\n" f"שגיאה: {result.get('error') or result.get('raw') or 'לא ידוע'}\n\n" "לא בוצע סנכרון ולא נשמר שיר קבוע." ) return admin_status_page("בדיקת אורך שיר נכשלה", "לא ניתן לזהות את משך השיר עם ffprobe.", ok=False, details=details), 400 finally: try: if os.path.exists(target): os.remove(target) except Exception: pass def add_self_test_result(results, category, name, ok, details="", severity="critical"): if ok: status = "pass" elif severity == "warning": status = "warn" else: status = "fail" results.append({ "category": category, "name": name, "status": status, "severity": severity, "details": str(details or ""), }) def route_rule_matches_action(rule, action): # Support both exact rules and Flask dynamic rules such as /upload/. if rule == action: return True rule_parts = [part for part in (rule or "").strip("/").split("/") if part] action_parts = [part for part in (action or "").strip("/").split("/") if part] if len(rule_parts) != len(action_parts): return False for rule_part, action_part in zip(rule_parts, action_parts): if rule_part.startswith("<") and rule_part.endswith(">"): if not action_part: return False continue if rule_part != action_part: return False return True def collect_admin_form_actions(html_text): return sorted(set(re.findall(r"]+action=[\"\']([^\"\']+)[\"\']", html_text or ""))) def collect_duplicate_ids(html_text): ids = re.findall(r"\bid=[\"\']([^\"\']+)[\"\']", html_text or "") seen, duplicates = set(), [] for item in ids: if item in seen and item not in duplicates: duplicates.append(item) seen.add(item) return duplicates def check_temp_write_permission(): os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) test_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"self_test_{os.getpid()}_{int(time.time())}.tmp") try: with open(test_path, "w", encoding="utf-8") as fh: fh.write("TripServer self test") with open(test_path, "r", encoding="utf-8") as fh: data = fh.read() return data == "TripServer self test", test_path finally: try: if os.path.exists(test_path): os.remove(test_path) except Exception: pass def run_self_test_suite(include_media_conversion=False): """Non-destructive self-test for the admin panel. It checks code validity, routes/forms, folders, media engine availability, presentation image mappings, power guards, Control Server and Fail Safe status. It intentionally does not upload real files, restart the server, shut down Windows, or modify active trip files. """ started = time.time() results = [] # 1) Python/code validity. try: py_compile.compile(ADMIN_SERVER_PATH, doraise=True) add_self_test_result(results, "קוד", "קומפילציית Python לקובץ האדמין הפעיל", True, ADMIN_SERVER_PATH) except Exception as exc: add_self_test_result(results, "קוד", "קומפילציית Python לקובץ האדמין הפעיל", False, repr(exc)) try: proc = subprocess.run([sys.executable, "-Werror", "-m", "py_compile", ADMIN_SERVER_PATH], capture_output=True, text=True, timeout=40) add_self_test_result(results, "קוד", "קומפילציה עם Werror", proc.returncode == 0, (proc.stderr or proc.stdout or "OK")[-1200:]) except Exception as exc: add_self_test_result(results, "קוד", "קומפילציה עם Werror", False, repr(exc), severity="warning") try: valid, info = validate_admin_server_upload(ADMIN_SERVER_PATH) add_self_test_result(results, "קוד", "בדיקת קובץ אדמין מול מנגנון upload_admin_server", bool(valid), info) except Exception as exc: add_self_test_result(results, "קוד", "בדיקת קובץ אדמין מול מנגנון upload_admin_server", False, repr(exc)) try: bootstrap_ok, bootstrap_info = bootstrap_control_server("self-test") alive = control_server_is_alive() add_self_test_result(results, "עדכון אדמין", "שרת בקרה חיצוני Control Server פעיל", bool(alive), bootstrap_info if not alive else "פורט 8010 עונה") except Exception as exc: add_self_test_result(results, "עדכון אדמין", "בדיקת Control Server", False, repr(exc)) try: fs = read_admin_failsafe_status() state = str(fs.get("state", "unknown")) bad_states = {"arm_failed", "cancel_failed"} ok = state not in bad_states msg = fs.get("message", "") or "OK" add_self_test_result(results, "עדכון אדמין", "סטטוס Fail Safe ניתן לקריאה", ok, f"state={state} | {msg}") except Exception as exc: add_self_test_result(results, "עדכון אדמין", "סטטוס Fail Safe ניתן לקריאה", False, repr(exc)) add_self_test_result(results, "עדכון אדמין", "קבצי Watchdog / restart helper ישנים אינם דרישת תקינות", True, "בדיקת התקינות נשענת על Control Server + Fail Safe. רכיבי Watchdog/helper ישנים מוגדרים כ־legacy ולא נספרים ככשל.") # 2) Paths and write access. for key, folder_path in sorted(FOLDERS.items()): add_self_test_result(results, "נתיבים", f"תיקיית {key} קיימת", os.path.isdir(folder_path), folder_path) try: ok, path = check_temp_write_permission() add_self_test_result(results, "נתיבים", "כתיבה/מחיקה בתיקיית tmp של האדמין", ok, path) except Exception as exc: add_self_test_result(results, "נתיבים", "כתיבה/מחיקה בתיקיית tmp של האדמין", False, repr(exc)) for label, path in [ ("תיקיית גיבויי אדמין", ADMIN_BACKUP_DIR), ("תיקיית גיבויי העלאות", UPLOAD_BACKUP_DIR), ]: try: os.makedirs(path, exist_ok=True) add_self_test_result(results, "נתיבים", label, os.path.isdir(path), path) except Exception as exc: add_self_test_result(results, "נתיבים", label, False, repr(exc)) # 3) Flask routes and HTML forms. try: rules = sorted(str(rule.rule) for rule in app.url_map.iter_rules()) expected_routes = [ "/", "/admin", "/admin/status", "/admin/health", "/admin/self-test", "/admin/self-test.json", "/admin/watchdog", "/admin/presentation-music", "/admin/logs", "/admin/logs.json", "/probe_presentation_music/", "/confirm_japan_experience_music_upload/", "/admin/camera", "/camera/stream", "/camera/snapshot.jpg", "/camera/prepare-video", "/camera/reset", "/camera/stop", "/camera/status.json", "/camera/audio-stream", "/camera/audio-test.json", "/camera/audio-stop", "/camera/record/start", "/camera/record/stop", "/camera/recordings", "/health", "/ping.json", "/upload_admin_server", "/restart_admin_server", "/restore_admin_server_backup", "/watchdog/install", "/watchdog/uninstall", "/watchdog/run-once", "/upload/", "/upload_presentation/", "/upload_usa_presentation/", "/upload_usa_image", "/upload_usa_images_zip", "/upload_usa_extra_html/", "/upload_japan_music/", "/upload_japan_images_zip", "/upload_trip_package/", "/admin/netlify/download/", "/upload_usa_music/", "/power/", "/power/cancel", ] missing_routes = [route for route in expected_routes if route not in rules] add_self_test_result(results, "ממשק", "כל routes המרכזיים קיימים", not missing_routes, ", ".join(missing_routes) if missing_routes else f"{len(rules)} routes") except Exception as exc: rules = [] add_self_test_result(results, "ממשק", "קריאת routes מהאפליקציה", False, repr(exc)) try: admin_html = admin() actions = collect_admin_form_actions(admin_html) missing_actions = [] for action in actions: if not any(route_rule_matches_action(rule, action) for rule in rules): missing_actions.append(action) add_self_test_result(results, "ממשק", "כל טפסי הפאנל מחוברים ל־route קיים", not missing_actions, ", ".join(missing_actions) if missing_actions else f"{len(actions)} טפסים") dup_ids = collect_duplicate_ids(admin_html) add_self_test_result(results, "ממשק", "אין IDs כפולים במסך האדמין", not dup_ids, ", ".join(dup_ids) if dup_ids else "OK") add_self_test_result(results, "ממשק", "כפתור בדיקה עצמית קיים בפאנל", "/admin/self-test" in admin_html, "נבדק href=/admin/self-test") add_self_test_result(results, "ממשק", "כפתור טיולים מרכזי קיים בפאנל", "showScreen('trips')" in admin_html and "יפן קיץ 26" in admin_html and "ארצות הברית קיץ 27" in admin_html, "המסך הראשי מוביל למסך טיולים ולא מציג יעדים כקטגוריות ראשיות") add_self_test_result(results, "ממשק", "מסך Netlify קיים ומחובר להורדת ZIP", "showScreen('netlify')" in admin_html and "/admin/netlify/download/USA" in admin_html and "/admin/netlify/download/JAPAN" in admin_html, "נבדקו כרטיס Netlify ושתי פעולות הורדה") add_self_test_result(results, "ממשק", "Watchdog הוסר מהפאנל הראשי", "screen-watchdog" not in admin_html and "showScreen('watchdog')" not in admin_html, "ה־route הטכני יכול להישאר מוסתר, אך אין כרטיס/מסך Watchdog בפאנל") add_self_test_result(results, "ממשק", "כפתור לוגים קיים בפאנל", "/admin/logs" in admin_html, "נבדק href=/admin/logs") add_self_test_result(results, "ממשק", "כפתור מצלמת חדר קיים בפאנל", "/admin/camera" in admin_html and "מצלמת חדר" in admin_html, "נבדק href=/admin/camera") add_self_test_result(results, "ממשק", "מסך מוזיקה מציג העלאה קיימת, בדיקה ואישור לפני הטמעה", "/upload_japan_music/japan_experience_music" in admin_html and "/upload_usa_music/usa_music" in admin_html and "/upload_usa_music/usa_music_part2" in admin_html and ("בדוק שיר והמשך להטמעה" in admin_html or "העלה שיר וסנכרן" in admin_html), "כפתורי ההעלאה הם הפעולה הראשית; מצגת יפן כוללת בדיקת טווח 5–10 שניות לפני הטמעה; probe נשאר כלי עזר בלבד") add_self_test_result(results, "ממשק", "כפתור אתחול מתקדם מוצג ככלי בדיקה בלבד", "בדיקת אתחול פאנל — מתקדם" in admin_html and (("מיועד לבדיקה יזומה בלבד" in admin_html) or ("מיועדת רק לבדיקה יזומה" in admin_html) or ("בדיקה יזומה" in admin_html)), "נבדק ניסוח UX") except Exception as exc: add_self_test_result(results, "ממשק", "ניתוח HTML של הפאנל", False, repr(exc)) try: status_html = render_admin_status() add_self_test_result(results, "ממשק", "מסך סטטוס נבנה ללא שגיאה", "סטטוס קבצים פעילים" in status_html, "OK") except Exception as exc: add_self_test_result(results, "ממשק", "מסך סטטוס נבנה ללא שגיאה", False, repr(exc)) try: health_html = render_admin_health() add_self_test_result(results, "ממשק", "מסך Health נבנה ללא שגיאה", "בדיקת מערכת" in health_html, "OK") except Exception as exc: add_self_test_result(results, "ממשק", "מסך Health נבנה ללא שגיאה", False, repr(exc)) try: logs_html = render_admin_logs() add_self_test_result(results, "ממשק", "מסך לוגים נבנה ללא שגיאה", "מרכז לוגים" in logs_html, "OK") except Exception as exc: add_self_test_result(results, "ממשק", "מסך לוגים נבנה ללא שגיאה", False, repr(exc)) try: camera_html = render_admin_camera() add_self_test_result(results, "מצלמה", "מסך מצלמת חדר נבנה ללא שגיאה", "מצלמת חדר" in camera_html and "/camera/stream" in camera_html and "/camera/reset" in camera_html, "OK") cam_engine = camera_engine_status() add_self_test_result(results, "מצלמה", "OpenCV זמין להפעלת מצלמה", bool(cam_engine.get("opencv")), "התקנה אוטומטית ברקע פעילה; בדוק /camera/setup" if not cam_engine.get("opencv") else f"OpenCV {cam_engine.get('opencv_version','')}", severity="warning") setup_html = render_camera_setup_page() add_self_test_result(results, "מצלמה", "מסך סטטוס רכיבי מצלמה נבנה תקין", "התקנה אוטומטית" in setup_html and "pip install" in setup_html, "OK") add_self_test_result(results, "מצלמה", "מצלמה מוגנת לרשת פרטית/Tailscale בלבד", is_private_or_loopback_ip("100.64.1.2") and not is_private_or_loopback_ip("8.8.8.8"), "Tailscale מותר, ציבורי חסום") except Exception as exc: add_self_test_result(results, "מצלמה", "בדיקת מסך/מנוע מצלמה", False, repr(exc)) # 4) Media engine. try: media_status = media_engine_status() add_self_test_result(results, "מדיה", "Pillow זמין להמרת/דחיסת תמונות", bool(media_status.get("pillow")), "py -m pip install --upgrade Pillow" if not media_status.get("pillow") else "OK") add_self_test_result(results, "מדיה", "FFmpeg זמין להמרת אודיו ל־MP3", bool(media_status.get("ffmpeg")), media_status.get("ffmpeg_path") or r"שים FFmpeg ב־C:\ffmpeg\bin\ffmpeg.exe") add_self_test_result(results, "מדיה", "ffprobe זמין לבדיקת אורך שירים", bool(media_status.get("ffprobe")), media_status.get("ffprobe_path") or r"שים ffprobe ב־C:\ffmpeg\bin\ffprobe.exe") add_self_test_result(results, "מדיה", "קובץ סטטוס העלאות מוזיקה מוגדר", PRESENTATION_MUSIC_UPLOAD_STATUS_PATH.endswith("presentation_music_upload_status.json"), PRESENTATION_MUSIC_UPLOAD_STATUS_PATH) rules_ok = isinstance(PRESENTATION_MUSIC_SYNC_RULES, dict) and {"japan_experience_music", "japan_flight_music", "usa_music_part1", "usa_music_part2"}.issubset(set(PRESENTATION_MUSIC_SYNC_RULES.keys())) add_self_test_result(results, "מדיה", "כללי סנכרון מוזיקה למצגות קיימים עם סטטוס אורך לאחר העלאה", rules_ok, "v34.12 מודד משך אחרי העלאת שיר קיימת, ואינו משנה מצגות") except Exception as exc: add_self_test_result(results, "מדיה", "בדיקת מנוע מדיה", False, repr(exc)) # Optional conversion mini-test: only in temp folder, never touches active media. if include_media_conversion: try: from PIL import Image source = os.path.join(ADMIN_UPLOAD_TMP_DIR, "self_test_image.png") target = os.path.join(ADMIN_UPLOAD_TMP_DIR, "self_test_image.jpg") Image.new("RGBA", (1600, 900), (30, 80, 150, 255)).save(source, "PNG") media = convert_or_copy_image_to_jpg(source, target, "self_test.png") ok = os.path.exists(target) and is_likely_jpeg_file(target) add_self_test_result(results, "מדיה", "סימולציית PNG → JPG בתיקיית tmp", ok, media_details_text(media)) except Exception as exc: add_self_test_result(results, "מדיה", "סימולציית PNG → JPG בתיקיית tmp", False, repr(exc), severity="warning") finally: for p in (os.path.join(ADMIN_UPLOAD_TMP_DIR, "self_test_image.png"), os.path.join(ADMIN_UPLOAD_TMP_DIR, "self_test_image.jpg")): try: if os.path.exists(p): os.remove(p) except Exception: pass # 5) Presentation-specific checks. try: usa_count = len(USA_IMAGE_UI_ITEMS) usa_keys = {item[0] for item in USA_IMAGE_UI_ITEMS} add_self_test_result(results, "ארה״ב", "44 כרטיסיות תמונות ארה״ב קיימות", usa_count == 44, str(usa_count)) add_self_test_result(results, "ארה״ב", "כרטיסיות ארה״ב תואמות למפת שמות התמונות", usa_keys == set(USA_IMAGE_KEYS), f"ui={len(usa_keys)} keys={len(USA_IMAGE_KEYS)}") ui_blob = "\n".join(" ".join(item) for item in USA_IMAGE_UI_ITEMS) forbidden = [word for word in ["Nassau", "נסאו", "פארק דיסני"] if word in ui_blob] add_self_test_result(results, "ארה״ב", "אין תיאורים שגויים ידועים בתמונות ארה״ב", not forbidden, ", ".join(forbidden) if forbidden else "OK") required = ["Disney Springs", "קרוז – יום ים 1", "קרוז – יום ים 2", "קרוז – יום ים 3", "St. Maarten", "St. Thomas", "CocoCay"] missing_words = [word for word in required if word not in ui_blob] add_self_test_result(results, "ארה״ב", "תיאורי קרוז/אורלנדו מסונכרנים", not missing_words, ", ".join(missing_words) if missing_words else "OK") except Exception as exc: add_self_test_result(results, "ארה״ב", "בדיקת כרטיסיות ארה״ב", False, repr(exc)) try: japan_usage = analyze_japan_presentation_images() if not japan_usage.get("presentation_exists"): add_self_test_result(results, "יפן", "מצגת יפן קיימת לניתוח", False, japan_usage.get("presentation_path", ""), severity="warning") else: add_self_test_result(results, "יפן", "מצגת יפן קיימת לניתוח", True, japan_usage.get("presentation_path", "")) add_self_test_result(results, "יפן", "מצגת יפן משתמשת בתמונות בפועל", japan_usage.get("image_slides", 0) > 0, f"{japan_usage.get('image_slides', 0)} תמונות") add_self_test_result(results, "יפן", "אין תמונות חיצוניות חסרות למצגת יפן", japan_usage.get("missing_external_images", 0) == 0, f"חסרות: {japan_usage.get('missing_external_images', 0)}") add_self_test_result(results, "יפן", "ספירת תמונות יפן מוצגת כספירת שימוש ולא כספירת תיקייה", "תמונות בשימוש בפועל" in render_admin_status(), "OK") except Exception as exc: add_self_test_result(results, "יפן", "ניתוח מצגת יפן", False, repr(exc)) # 6) Upload target mapping and safety guards. try: main_targets = {key: os.path.join(path, "index.html") for key, path in FOLDERS.items()} bad_targets = [f"{key}:{target}" for key, target in main_targets.items() if not target.lower().endswith("index.html")] add_self_test_result(results, "העלאות", "קבצים ראשיים נשמרים תמיד כ־index.html", not bad_targets, ", ".join(bad_targets) if bad_targets else "OK") except Exception as exc: add_self_test_result(results, "העלאות", "מפת יעדי העלאה ראשיים", False, repr(exc)) try: safe_examples = ["index.html", "media/images/a.jpg", "USA/index.html"] unsafe_examples = ["../x.html", "a/../../x.html", "__MACOSX/a.jpg"] ok_safe = all(safe_zip_relpath(x) is not None for x in safe_examples) ok_unsafe = all(safe_zip_relpath(x) is None for x in unsafe_examples) add_self_test_result(results, "העלאות", "הגנת ZIP Slip / נתיבים מסוכנים", ok_safe and ok_unsafe, "OK" if ok_safe and ok_unsafe else f"safe={ok_safe} unsafe={ok_unsafe}") except Exception as exc: add_self_test_result(results, "העלאות", "הגנת ZIP Slip / נתיבים מסוכנים", False, repr(exc)) try: add_self_test_result(results, "אבטחה", "זיהוי IP מקומי/בית/Tailscale", is_private_or_loopback_ip("127.0.0.1") and is_private_or_loopback_ip("192.168.1.10") and is_private_or_loopback_ip("100.64.1.2") and is_private_or_loopback_ip("fd7a:115c:a1e0::1"), "OK") add_self_test_result(results, "אבטחה", "כתובת ציבורית נחסמת לפעולות מחשב", not is_private_or_loopback_ip("8.8.8.8"), "OK") add_self_test_result(results, "אבטחה", "טווח טיימר כיבוי/ריסטארט מוגבל", normalize_power_delay("0") == POWER_MIN_DELAY_SECONDS and normalize_power_delay("999999") == POWER_MAX_DELAY_SECONDS, f"{POWER_MIN_DELAY_SECONDS}-{POWER_MAX_DELAY_SECONDS} שניות") except Exception as exc: add_self_test_result(results, "אבטחה", "בדיקות אבטחת פעולות מחשב", False, repr(exc)) elapsed = round(time.time() - started, 3) passed = sum(1 for item in results if item["status"] == "pass") warned = sum(1 for item in results if item["status"] == "warn") failed = sum(1 for item in results if item["status"] == "fail") return { "ok": failed == 0, "passed": passed, "warnings": warned, "failed": failed, "total": len(results), "elapsed_seconds": elapsed, "version": ADMIN_PANEL_VERSION, "started_at": ADMIN_STARTED_AT, "checked_at": time.strftime("%Y-%m-%d %H:%M:%S"), "results": results, } def render_admin_self_test(): include_conversion = (request.args.get("conversion") == "1") payload = run_self_test_suite(include_media_conversion=include_conversion) badge_class = "ok" if payload["ok"] else "bad" badge_text = "הבדיקה עברה" if payload["ok"] else "נמצאו כשלים" grouped = {} for item in payload["results"]: grouped.setdefault(item["category"], []).append(item) def row_html(item): status = item.get("status") if status == "pass": mark = "✅" cls = "pass" label = "תקין" elif status == "warn": mark = "⚠️" cls = "warn" label = "אזהרה" else: mark = "❌" cls = "fail" label = "כשל" details = html_lib.escape(item.get("details") or "").replace("\n", "
    ") return f"{mark} {label}{html_lib.escape(item.get('name',''))}{details}" groups_html = [] for category, items in grouped.items(): rows = "".join(row_html(item) for item in items) groups_html.append(f"

    {html_lib.escape(category)}

    {rows}
    מצבבדיקהפירוט
    ") return f""" בדיקה עצמית TripServer
    ⬅ חזרה לפאנל

    🧪 בדיקה עצמית מלאה

    בדיקה לא־הרסנית של קוד, routes, טפסים, נתיבים, מדיה, מצגות, אבטחה, Control Server ו־Fail Safe. היא לא מבצעת העלאות אמיתיות, לא מאתחלת את השרת ולא מכבה את המחשב.

    {badge_text}
    הרץ שובבדיקה כולל סימולציית המרת תמונהJSON טכניסטטוס קבציםHealth
    סה״כ בדיקות
    {payload['total']}
    עברו
    {payload['passed']}
    אזהרות
    {payload['warnings']}
    כשלים
    {payload['failed']}
    משך
    {payload['elapsed_seconds']}s
    גרסה: {html_lib.escape(payload['version'])}
    נבדק: {html_lib.escape(payload['checked_at'])}
    {''.join(groups_html)}
    """ def health_payload(): # v34.9: Restart helper is a legacy component. The active stable update path is # Control Server + Fail Safe, so Health must not mark the panel as faulty just # because the old helper was removed from the live workflow. control_alive = False control_info = "not checked" try: control_alive = bool(control_server_is_alive()) control_info = "פורט 8010 עונה" if control_alive else "פורט 8010 לא עונה" except Exception as exc: control_info = repr(exc) try: failsafe_info = read_admin_failsafe_status() except Exception as exc: failsafe_info = {"state": "unknown", "message": repr(exc)} return { "ok": True, "service": "TripServer Admin", "version": ADMIN_PANEL_VERSION, "started_at": ADMIN_STARTED_AT, "script": ADMIN_SERVER_PATH, "host": ADMIN_HOST, "port": ADMIN_PORT, "usa_image_keys": len(USA_IMAGE_KEYS), "japan_presentation_images": compact_japan_usage_for_health(), "power_actions_enabled": POWER_ACTIONS_ENABLED, "control_server_ok": control_alive, "control_server_status": control_info, "failsafe_status": failsafe_info, "restart_helper_legacy": True, "restart_helper_status": "legacy hidden from Health; active path is Control Server + Fail Safe", "watchdog": {"legacy": True, "visible_in_panel": False}, "logs": {key: {"path": meta["path"], "exists": os.path.exists(meta["path"])} for key, meta in LOG_FILE_REGISTRY.items()}, "media_engine": media_engine_status(), } def render_admin_health(): payload = health_payload() media = payload.get("media_engine", {}) pillow_ok = bool(media.get("pillow")) ffmpeg_ok = bool(media.get("ffmpeg")) ffmpeg_path = media.get("ffmpeg_path") or "לא נמצא" ffprobe_ok = bool(media.get("ffprobe")) ffprobe_path = media.get("ffprobe_path") or "לא נמצא" power_ok = bool(payload.get("power_actions_enabled")) japan_usage = payload.get("japan_presentation_images", {}) def badge(ok, text_ok="תקין", text_bad="חסר"): cls = "ok" if ok else "bad" txt = text_ok if ok else text_bad return f'{txt}' json_text = html_lib.escape(str(payload)).replace(", '", ",\n '").replace("{", "{\n ").replace("}", "\n}") return f""" בדיקת מערכת TripServer

    🩺 בדיקת מערכת

    זה מסך קריא לבני אדם. נקודת הקצה הטכנית עדיין קיימת ב־/health?json=1 למקרה שצריך בדיקה אוטומטית.

    ⬅ חזרה לפאנל📊 סטטוס קבציםJSON טכני🧪 בדיקה עצמית מלאה📜 לוגים

    מצב שרת

    {badge(True)}
    גרסה{html_lib.escape(ADMIN_PANEL_VERSION)}
    עלה בתאריך{html_lib.escape(ADMIN_STARTED_AT)}
    פורט{ADMIN_PORT}
    Host{html_lib.escape(ADMIN_HOST)}
    Control Server{badge(payload.get("control_server_ok", False), "פעיל", "לא פעיל")}
    Fail Safe{html_lib.escape(str(payload.get("failsafe_status", {}).get("state", "unknown")))}

    מנוע מדיה

    {badge(pillow_ok, "Pillow תקין", "Pillow חסר")} {badge(ffmpeg_ok, "FFmpeg תקין", "FFmpeg חסר")}
    תמונותהמרה ודחיסה ל־JPG
    אודיוהמרה ל־MP3
    FFmpeg{html_lib.escape(ffmpeg_path)}
    ffprobe{html_lib.escape(ffprobe_path)}

    פעולות מחשב

    {badge(power_ok, "פעיל", "כבוי")}
    כיבוי / ריסטארט{"מופעל בפאנל" if power_ok else "מנוטרל בהגדרות"}
    הגנותPOST, רשת מקומית, אישור כתוב, טיימר וביטול

    כיסוי מצגת ארה״ב

    {badge(len(USA_IMAGE_KEYS) == 44, "44 שקפים", str(len(USA_IMAGE_KEYS)) + " שקפים")}
    תמונות שקפים{len(USA_IMAGE_KEYS)}
    העלאהJPG/PNG/WebP וכו׳ → JPG דחוס

    כיסוי מצגת יפן

    {badge(japan_usage.get('presentation_exists') and japan_usage.get('missing_external_images', 0) == 0, "תקין", "לבדיקה")}
    תמונות בשימוש בפועל{japan_usage.get('image_slides_total', 0)}
    קבצים חיצוניים{japan_usage.get('external_files_used', 0)}
    תמונות מוטמעות{japan_usage.get('embedded_images', 0)}
    קבצים בתיקייה{japan_usage.get('folder_images', 0)}
    לא בשימוש / חסרות{japan_usage.get('unused_folder_images', 0)} / {japan_usage.get('missing_external_images', 0)}
    מה קרה קודם?
    מסך Health מציג רק רכיבים פעילים ורלוונטיים. Restart helper ו־Watchdog הישנים הם רכיבי Legacy ולכן אינם מוצגים יותר ככשל. מסלול העדכון התקין הוא Control Server + Fail Safe.

    מידע טכני מלא

    {json_text}
    """ @app.route("/admin/local-files") def admin_local_files(): if request.args.get("refresh") == "1": build_local_file_roots(force=True) return render_admin_file_manager(request.args.get("root"), request.args.get("path") or "") @app.route("/admin/local-files/download") def admin_local_files_download(): root_key = normalize_local_root_key(request.args.get("root")) try: path = safe_local_path(root_key, request.args.get("path") or "") except Exception as exc: return admin_status_page("נתיב נחסם", "הקובץ המבוקש לא נמצא בתוך התיקיות המאושרות.", ok=False, details=str(exc)), 400 if not os.path.isfile(path): return admin_status_page("קובץ לא נמצא", "לא ניתן להוריד תיקייה או קובץ שאינו קיים.", ok=False, details=path), 404 return send_file(path, as_attachment=True, download_name=os.path.basename(path)) @app.route("/admin/local-files/preview") def admin_local_files_preview(): root_key = normalize_local_root_key(request.args.get("root")) try: path = safe_local_path(root_key, request.args.get("path") or "") except Exception as exc: return admin_status_page("נתיב נחסם", "הקובץ המבוקש לא נמצא בתוך התיקיות המאושרות.", ok=False, details=str(exc)), 400 if not os.path.isfile(path): return admin_status_page("קובץ לא נמצא", "לא ניתן להציג תיקייה או קובץ שאינו קיים.", ok=False, details=path), 404 size = os.path.getsize(path) ext = os.path.splitext(path)[1].lower() if ext not in LOCAL_FILE_TEXT_EXTENSIONS or size > LOCAL_FILE_PREVIEW_MAX_BYTES: return admin_status_page("אין תצוגה מקדימה", "ניתן להציג רק קבצי טקסט קטנים. אפשר להוריד את הקובץ במקום זאת.", ok=False, details=f"{path}\n{format_bytes(size)}"), 400 try: raw = open(path, "rb").read() try: content = raw.decode("utf-8") except UnicodeDecodeError: content = raw.decode("cp1255", errors="replace") except Exception as exc: return admin_status_page("שגיאה בקריאת קובץ", "לא ניתן היה לקרוא את הקובץ.", ok=False, details=repr(exc)), 500 safe_content = html_lib.escape(content[:250000]) root = html_lib.escape(root_key, quote=True) rel_raw = rel_for_local(root_key, path) rel = html_lib.escape(rel_raw, quote=True) back_raw = os.path.dirname(rel_raw).replace('\\','/') back_url = local_file_href("/admin/local-files", root_key, back_raw) download_url = local_file_href("/admin/local-files/download", root_key, rel_raw) edit_url = local_file_href("/admin/local-files/edit", root_key, rel_raw) return f"""תצוגת קובץ
    ⬅ חזרה לתיקייה · הורד קובץ · ערוך

    📄 {html_lib.escape(os.path.basename(path))}

    {html_lib.escape(path)}

    {safe_content}
    """ @app.route("/admin/local-files/edit", methods=["GET", "POST"]) def admin_local_files_edit(): root_key = normalize_local_root_key(request.values.get("root")) try: path = safe_local_path(root_key, request.values.get("path") or "") except Exception as exc: return admin_status_page("נתיב נחסם", "הקובץ אינו בתוך תיקייה מאושרת.", ok=False, details=str(exc)), 400 if not os.path.isfile(path): return admin_status_page("קובץ לא נמצא", "לא ניתן לערוך תיקייה או קובץ שאינו קיים.", ok=False, details=path), 404 ext = os.path.splitext(path)[1].lower() if ext not in LOCAL_FILE_TEXT_EXTENSIONS: return admin_status_page("עריכה חסומה", "עריכה דרך הדפדפן מותרת רק לקבצי טקסט מוכרים.", ok=False, details=path), 400 if request.method == "POST": text = request.form.get("content", "") try: backup_existing_file(path, "local_file_edit") with open(path, "w", encoding="utf-8", newline="") as f: f.write(text) return admin_status_page("הקובץ נשמר", "קובץ הטקסט עודכן ונוצר גיבוי לפני השינוי.", ok=True, details=path) except Exception as exc: return admin_status_page("שגיאה בשמירה", "לא ניתן היה לשמור את הקובץ.", ok=False, details=repr(exc)), 500 try: raw = open(path, "rb").read() try: content = raw.decode("utf-8") except UnicodeDecodeError: content = raw.decode("cp1255", errors="replace") except Exception as exc: return admin_status_page("שגיאה בקריאה", "לא ניתן היה לקרוא את הקובץ לעריכה.", ok=False, details=repr(exc)), 500 root = html_lib.escape(root_key, quote=True) rel_raw = rel_for_local(root_key, path) rel = html_lib.escape(rel_raw, quote=True) back_raw = os.path.dirname(rel_raw).replace('\\','/') back_url = local_file_href("/admin/local-files", root_key, back_raw) return f"""עריכת קובץ
    ⬅ חזרה לתיקייה

    ✏️ עריכת {html_lib.escape(os.path.basename(path))}

    {html_lib.escape(path)}

    """ @app.route("/admin/local-files/upload", methods=["POST"]) def admin_local_files_upload(): root_key = normalize_local_root_key(request.form.get("root")) try: folder = safe_local_path(root_key, request.form.get("path") or "") except Exception as exc: return admin_status_page("נתיב נחסם", "התיקייה אינה מאושרת.", ok=False, details=str(exc)), 400 if not os.path.isdir(folder): return admin_status_page("תיקייה לא קיימת", "לא ניתן להעלות לקובץ או לתיקייה שאינה קיימת.", ok=False, details=folder), 400 files = request.files.getlist("files") saved = [] try: for f in files: if not f or not (f.filename or "").strip(): continue try: name = local_safe_name(f.filename) except Exception: name = "upload_" + str(int(time.time())) target = local_unique_destination(os.path.join(folder, name)) f.save(target) saved.append(os.path.basename(target)) if not saved: return admin_status_page("לא נבחר קובץ", "בחר קובץ אחד לפחות להעלאה.", ok=False), 400 return admin_status_page("העלאה הושלמה", f"נשמרו {len(saved)} קבצים בתיקייה הנוכחית.", ok=True, details="\n".join(saved)) except Exception as exc: return admin_status_page("שגיאה בהעלאה", "לא ניתן היה לשמור את הקבצים.", ok=False, details=repr(exc)), 500 @app.route("/admin/local-files/mkdir", methods=["POST"]) def admin_local_files_mkdir(): root_key = normalize_local_root_key(request.form.get("root")) try: folder = safe_local_path(root_key, request.form.get("path") or "") except Exception as exc: return admin_status_page("נתיב נחסם", "התיקייה אינה מאושרת.", ok=False, details=str(exc)), 400 try: name = local_safe_name(request.form.get("folder_name") or "") except Exception as exc: return admin_status_page("שם תיקייה חסר", "כתוב שם תיקייה תקין.", ok=False, details=str(exc)), 400 try: target = safe_local_path(root_key, os.path.join(rel_for_local(root_key, folder), name)) os.makedirs(target, exist_ok=False) return admin_status_page("תיקייה נוצרה", "התיקייה החדשה נוצרה בהצלחה.", ok=True, details=target) except Exception as exc: return admin_status_page("שגיאה ביצירת תיקייה", "לא ניתן היה ליצור את התיקייה.", ok=False, details=repr(exc)), 500 @app.route("/admin/local-files/bulk", methods=["POST"]) def admin_local_files_bulk(): root_key = normalize_local_root_key(request.form.get("root")) action = (request.form.get("action") or "zip").strip().lower() selected = request.form.getlist("path") if not selected: return admin_status_page("לא נבחרו פריטים", "סמן קובץ או תיקייה לפני פעולה.", ok=False), 400 try: paths = [safe_local_path(root_key, rel) for rel in selected[:300]] except Exception as exc: return admin_status_page("נתיב נחסם", "אחד הנתיבים אינו מאושר.", ok=False, details=str(exc)), 400 if action == "zip": stamp = time.strftime("%Y%m%d_%H%M%S") out_dir = os.path.join(BASE_DIR, "tmp") os.makedirs(out_dir, exist_ok=True) zip_path = os.path.join(out_dir, f"local_files_export_{root_key}_{stamp}.zip") total = 0 count = 0 try: with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf: for p in paths: if not os.path.exists(p): continue added_bytes, added_count = add_path_to_zip(zf, root_key, p) total += added_bytes count += added_count if total > LOCAL_FILE_ZIP_MAX_BYTES: raise ValueError(f"ZIP גדול מדי. מגבלה: {format_bytes(LOCAL_FILE_ZIP_MAX_BYTES)}") if count <= 0: return admin_status_page("לא נוספו קבצים", "לא נמצאו קבצים תקינים לבניית ZIP.", ok=False), 400 return send_file(zip_path, as_attachment=True, download_name=os.path.basename(zip_path)) except Exception as exc: try: if os.path.exists(zip_path): os.remove(zip_path) except Exception: pass return admin_status_page("שגיאה ביצירת ZIP", "לא ניתן היה ליצור חבילת קבצים להורדה.", ok=False, details=repr(exc)), 500 if action == "delete": deleted = [] errors = [] for p in paths: try: if os.path.abspath(p) == local_root_path(root_key): raise ValueError("אסור למחוק את שורש התיקייה.") if os.path.isdir(p): shutil.rmtree(p) elif os.path.exists(p): os.remove(p) deleted.append(rel_for_local(root_key, p)) except Exception as exc: errors.append(f"{rel_for_local(root_key, p)}: {repr(exc)}") return admin_status_page("מחיקה הסתיימה", f"נמחקו {len(deleted)} פריטים. שגיאות: {len(errors)}", ok=(len(errors)==0), details="\n".join(deleted + errors)) if action == "rename": if len(paths) != 1: return admin_status_page("שינוי שם", "בחר פריט אחד בלבד לשינוי שם.", ok=False), 400 try: new_name = local_safe_name(request.form.get("new_name") or "") src = paths[0] dest = os.path.join(os.path.dirname(src), new_name) dest = safe_local_path(root_key, rel_for_local(root_key, dest)) if os.path.exists(dest): raise ValueError("כבר קיים קובץ/תיקייה בשם הזה.") os.rename(src, dest) return admin_status_page("שם שונה", "הפריט שונה שם בהצלחה.", ok=True, details=f"{src}\n→ {dest}") except Exception as exc: return admin_status_page("שגיאה בשינוי שם", "לא ניתן היה לשנות את שם הפריט.", ok=False, details=repr(exc)), 500 if action in {"copy", "move"}: dest_root = normalize_local_root_key(request.form.get("dest_root")) dest_rel = request.form.get("dest_path") or "" try: dest_dir = safe_local_path(dest_root, dest_rel) if not os.path.isdir(dest_dir): raise ValueError("יעד אינו תיקייה קיימת.") except Exception as exc: return admin_status_page("יעד לא תקין", "בחר תיקיית יעד קיימת בתוך אחת התיקיות המאושרות.", ok=False, details=str(exc)), 400 done = [] errors = [] for p in paths: try: if action == "copy": target = local_copy_item(p, dest_dir) else: target = local_move_item(p, dest_dir) done.append(target) except Exception as exc: errors.append(f"{p}: {repr(exc)}") return admin_status_page("הפעולה הסתיימה", f"בוצעו {len(done)} פעולות. שגיאות: {len(errors)}", ok=(len(errors)==0), details="\n".join(done + errors)) return admin_status_page("פעולה לא מוכרת", "הפעולה המבוקשת אינה נתמכת.", ok=False, details=action), 400 @app.route("/admin/local-files/zip", methods=["POST"]) def admin_local_files_zip(): # Backward compatible endpoint: use the new bulk action. return admin_local_files_bulk() @app.route("/admin/self-test") def admin_self_test(): return render_admin_self_test() @app.route("/admin/self-test.json") def admin_self_test_json(): include_conversion = (request.args.get("conversion") == "1") return run_self_test_suite(include_media_conversion=include_conversion) @app.route("/ping") def ping(): return "OK", 200, {"Cache-Control": "no-store"} @app.route("/ping.json") def ping_json(): # Ultra-light endpoint for restart helper and Watchdog. # It must never parse presentations, inspect files, call schtasks, enumerate cameras, or run FFmpeg. return {"ok": True, "service": "TripServer Admin", "version": ADMIN_PANEL_VERSION, "started_at": ADMIN_STARTED_AT, "port": ADMIN_PORT} @app.route("/health") def health(): accept = request.headers.get("Accept", "") if request.args.get("json") != "1" and "text/html" in accept: return redirect("/admin/health") return health_payload() @app.route("/health.json") def health_json(): return health_payload() @app.route("/admin/health") def admin_health(): return render_admin_health() @app.route("/admin/status") def admin_status(): return render_admin_status() @app.route("/admin/control") def admin_control_page(): bootstrap_ok, bootstrap_info = bootstrap_control_server("control-page") alive = control_server_is_alive() status_text = "" try: if os.path.exists(CONTROL_STATUS_PATH): status_text = open(CONTROL_STATUS_PATH, "r", encoding="utf-8", errors="replace").read() except Exception as exc: status_text = repr(exc) log_tail = "" try: if os.path.exists(CONTROL_LOG_PATH): log_tail = open(CONTROL_LOG_PATH, "r", encoding="utf-8", errors="replace").read()[-16000:] except Exception as exc: log_tail = repr(exc) html = f"""TripServer Control
    ⬅ חזרה

    שרת בקרה חיצוני

    {'פעיל' if alive else 'לא פעיל'}

    Bootstrap: {html_lib.escape(str(bootstrap_ok))} | {html_lib.escape(str(bootstrap_info))}

    Status מקומילוג מקומי

    Status

    {html_lib.escape(status_text or 'אין')}

    Log

    {html_lib.escape(log_tail or 'אין')}
    """ return make_response(html) @app.route("/admin/logs") def admin_logs(): return render_admin_logs() @app.route("/admin/logs.json") def admin_logs_json(): return build_logs_payload(request.args.get("lines", LOG_TAIL_DEFAULT_LINES)) @app.route("/camera/hls/start", methods=["POST"]) def camera_hls_start(): allowed, reason = camera_access_allowed() if not allowed: return {"ok": False, "error": reason}, 403 if not find_ffmpeg_executable(): return {"ok": False, "error": "FFmpeg לא נמצא. נדרש FFmpeg לשידור מאוחד."}, 503 with_audio = request.args.get("audio", "1") != "0" try: ok = CAMERA_HLS_STREAM.start(with_audio=with_audio, restart=True) status = CAMERA_HLS_STREAM.status() return {"ok": bool(ok), "playlist": "/camera/hls/stream.m3u8", "with_audio": bool(status.get("with_audio")), "status": status} except Exception as exc: return {"ok": False, "error": str(exc), "status": CAMERA_HLS_STREAM.status()}, 500 @app.route("/camera/hls/stop", methods=["POST"]) def camera_hls_stop(): allowed, reason = camera_access_allowed() if not allowed: return {"ok": False, "error": reason}, 403 CAMERA_HLS_STREAM.stop() return {"ok": True, "status": CAMERA_HLS_STREAM.status()} @app.route("/camera/hls/status.json") def camera_hls_status_json(): allowed, reason = camera_access_allowed() if not allowed: return {"ok": False, "error": reason}, 403 return {"ok": True, "status": CAMERA_HLS_STREAM.status(), "devices": ffmpeg_dshow_devices()} @app.route("/camera/hls/") def camera_hls_file(filename): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 safe = safe_zip_relpath(filename) if not safe or "/" in safe or not safe.lower().endswith((".m3u8", ".ts")): return "invalid hls file", 400 resp = send_from_directory(CAMERA_HLS_DIR, safe, conditional=False) resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0" resp.headers["Pragma"] = "no-cache" if safe.lower().endswith(".m3u8"): resp.headers["Content-Type"] = "application/vnd.apple.mpegurl; charset=utf-8" elif safe.lower().endswith(".ts"): resp.headers["Content-Type"] = "video/mp2t" return resp @app.route("/camera/setup") def camera_setup_page(): allowed, reason = camera_access_allowed() if not allowed: return admin_status_page("גישה נחסמה", reason, ok=False, back_url="/admin/camera"), 403 return render_camera_setup_page() @app.route("/camera/setup/status.json") def camera_setup_status_json(): allowed, reason = camera_access_allowed() payload = camera_setup_status() payload["access_allowed"] = allowed payload["access_reason"] = reason return payload @app.route("/camera/setup/opencv", methods=["POST"]) def camera_setup_opencv(): allowed, reason = camera_access_allowed() if not allowed: return admin_status_page("התקנת OpenCV נחסמה", reason, ok=False, back_url="/camera/setup"), 403 confirm = (request.form.get("confirm") or "").strip() if confirm != CAMERA_SETUP_CONFIRM_TEXT: return admin_status_page("אישור חסר", f"כדי להתקין OpenCV צריך לכתוב בדיוק: {CAMERA_SETUP_CONFIRM_TEXT}", ok=False, back_url="/camera/setup"), 400 if camera_engine_status().get("opencv"): return admin_status_page("OpenCV כבר מותקן", "אין צורך להריץ התקנה נוספת. אפשר לחזור למסך המצלמה.", ok=True, back_url="/admin/camera") started, message = start_opencv_install_background(mode="manual") return admin_status_page("התקנת OpenCV התחילה" if started else "התקנת OpenCV כבר רצה", message + "\n\nפתח את מסך סטטוס רכיבי מצלמה כדי לעקוב אחרי הלוג.", ok=started, back_url="/camera/setup", details=str(camera_setup_status())) @app.route("/admin/camera") def admin_camera(): return render_admin_camera() @app.route("/camera/status.json") def camera_status_json(): allowed, reason = camera_access_allowed() payload = CAMERA_MANAGER.status() payload.update(camera_engine_status()) payload["access_allowed"] = allowed payload["access_reason"] = reason return payload @app.route("/camera/snapshot.jpg") def camera_snapshot(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 if not camera_engine_status().get("opencv"): return "OpenCV לא מותקן. הרץ: py -m pip install opencv-python", 503 try: frame = CAMERA_MANAGER.read_jpeg() response = make_response(frame) response.headers["Content-Type"] = "image/jpeg" response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0" return response except Exception as exc: return f"שגיאת מצלמה: {exc}", 500 @app.route("/camera/prepare-video", methods=["POST"]) def camera_prepare_video(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 CAMERA_MANAGER.prepare_new_stream() log_camera_event(f"video prepare requested by {get_client_ip()}") return {"ok": True, "message": "camera video handle released and ready"} @app.route("/camera/reset", methods=["POST"]) def camera_reset(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 # Recovery button: release everything that may hold the webcam/microphone. try: CAMERA_AUDIO_STREAM.stop() except Exception: pass try: CAMERA_RECORDER.stop() except Exception: pass CAMERA_MANAGER.force_reset() log_camera_event(f"full camera reset requested by {get_client_ip()}") return {"ok": True, "message": "camera/audio/recording handles released"} @app.route("/camera/stream") def camera_stream(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 if not camera_engine_status().get("opencv"): return "OpenCV לא מותקן. הרץ: py -m pip install opencv-python", 503 return Response(camera_stream_generator(), mimetype="multipart/x-mixed-replace; boundary=frame", headers={"Cache-Control": "no-store, no-cache, must-revalidate, max-age=0", "X-Accel-Buffering": "no"}) @app.route("/camera/stop", methods=["POST"]) def camera_stop(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 CAMERA_MANAGER.stop() return action_page("מצלמה כובתה", "המצלמה שוחררה והזרם הופסק. אם נורית המצלמה עדיין דולקת, סגור גם את דף השידור בדפדפן ורענן.", "/admin/camera") @app.route("/camera/audio-stream") def camera_audio_stream(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 if not find_ffmpeg_executable(): return "FFmpeg לא נמצא. נדרש FFmpeg כדי להזרים אודיו.", 503 try: restart = request.args.get("restart") == "1" CAMERA_AUDIO_STREAM.start(restart=restart) except Exception as exc: return "שגיאת אודיו: " + str(exc), 500 return Response(CAMERA_AUDIO_STREAM.stream_chunks(), mimetype="audio/mpeg", headers={"Cache-Control": "no-store, no-cache, must-revalidate, max-age=0", "X-Accel-Buffering": "no"}) @app.route("/camera/audio-test.json") def camera_audio_test_json(): allowed, reason = camera_access_allowed() if not allowed: return {"ok": False, "error": reason}, 403 ffmpeg = find_ffmpeg_executable() if not ffmpeg: return {"ok": False, "error": "FFmpeg לא נמצא"}, 503 devices = ffmpeg_dshow_devices() candidates = preferred_audio_candidates(devices) results = [] for row in candidates[:6]: name = row.get("name") or "" started = time.time() cmd = [ffmpeg, "-hide_banner", "-nostdin", "-loglevel", "warning", "-f", "dshow", "-rtbufsize", "64M", "-i", "audio=" + name, "-t", "1", "-vn", "-f", "null", "-"] try: completed = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=5) results.append({"device": name, "source": row.get("source"), "ok": completed.returncode == 0, "returncode": completed.returncode, "seconds": round(time.time() - started, 2), "stderr_tail": (completed.stderr or "")[-1200:]}) except Exception as exc: results.append({"device": name, "source": row.get("source"), "ok": False, "error": repr(exc)}) return {"ok": any(r.get("ok") for r in results), "ffmpeg": ffmpeg, "selected": selected_ffmpeg_devices()[:2], "devices": devices, "results": results, "audio_log": CAMERA_AUDIO_LOG_PATH} @app.route("/camera/audio-stop", methods=["POST"]) def camera_audio_stop(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 CAMERA_AUDIO_STREAM.stop() return action_page("אודיו כובה", "שידור האודיו הופסק והמיקרופון שוחרר.", "/admin/camera") @app.route("/camera/record/start", methods=["POST"]) def camera_record_start(): allowed, reason = camera_access_allowed() if not allowed: return admin_status_page("הקלטה נחסמה", reason, ok=False), 403 try: with_audio = request.form.get("with_audio") == "1" target = CAMERA_RECORDER.start(with_audio=with_audio) return admin_status_page("הקלטה התחילה", f"ההקלטה נשמרת אל:\n{target}", ok=True, details=str(CAMERA_RECORDER.status())) except Exception as exc: CAMERA_RECORDER.last_error = str(exc) return admin_status_page("הקלטה לא התחילה", str(exc), ok=False, details=str(camera_av_status())), 500 @app.route("/camera/record/stop", methods=["POST"]) def camera_record_stop(): allowed, reason = camera_access_allowed() if not allowed: return admin_status_page("עצירת הקלטה נחסמה", reason, ok=False), 403 try: target = CAMERA_RECORDER.stop() return admin_status_page("הקלטה נעצרה", f"קובץ ההקלטה:\n{target or 'לא היה קובץ פעיל'}", ok=True, details=str(CAMERA_RECORDER.status()), back_url="/admin/camera") except Exception as exc: return admin_status_page("שגיאה בעצירת הקלטה", str(exc), ok=False, back_url="/admin/camera"), 500 @app.route("/camera/recordings") def camera_recordings_page(): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 rows = "".join( f"
    {html_lib.escape(item['name'])}
    {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(item['mtime']))} · {format_bytes(item['size'])}
    פתח/נגן
    " for item in list_camera_recordings(100) ) or "

    אין הקלטות.

    " return f"""הקלטות מצלמה
    ⬅ חזרה למצלמה

    🎞️ הקלטות מצלמה

    תיקייה: {html_lib.escape(CAMERA_RECORDINGS_DIR)}

    {rows}
    """ @app.route("/camera/recordings/") def camera_recording_file(filename): allowed, reason = camera_access_allowed() if not allowed: return reason, 403 base = os.path.basename(filename or "") if not base.lower().endswith(".mp4"): return "קובץ לא מורשה", 403 return send_from_directory(CAMERA_RECORDINGS_DIR, base, as_attachment=False) @app.route("/admin/watchdog") def admin_watchdog(): return render_admin_watchdog() @app.route("/watchdog/install", methods=["POST"]) def watchdog_install_route(): if not is_private_or_loopback_ip(get_client_ip()): return admin_status_page("התקנת Watchdog נחסמה", f"הבקשה הגיעה מכתובת לא מקומית/לא Tailscale: {get_client_ip()}", ok=False), 403 try: ok, message, details = install_watchdog_task() return admin_status_page("Watchdog הותקן" if ok else "Watchdog לא הותקן", message, ok=ok, details=details + "\n\n" + str(watchdog_status(include_log=False))) except Exception as exc: return admin_status_page("שגיאה בהתקנת Watchdog", "לא הצלחתי להתקין את שכבת ה־Watchdog.", ok=False, details=repr(exc)), 500 @app.route("/watchdog/uninstall", methods=["POST"]) def watchdog_uninstall_route(): if not is_private_or_loopback_ip(get_client_ip()): return admin_status_page("הסרת Watchdog נחסמה", f"הבקשה הגיעה מכתובת לא מקומית/לא Tailscale: {get_client_ip()}", ok=False), 403 try: ok, message, details = uninstall_watchdog_task() return admin_status_page("Watchdog הוסר" if ok else "Watchdog לא הוסר", message, ok=ok, details=details) except Exception as exc: return admin_status_page("שגיאה בהסרת Watchdog", "לא הצלחתי להסיר את משימת ה־Watchdog.", ok=False, details=repr(exc)), 500 @app.route("/watchdog/run-once", methods=["POST"]) def watchdog_run_once_route(): if not is_private_or_loopback_ip(get_client_ip()): return admin_status_page("הרצת Watchdog נחסמה", f"הבקשה הגיעה מכתובת לא מקומית/לא Tailscale: {get_client_ip()}", ok=False), 403 try: ok, message, details = run_watchdog_once_now() return admin_status_page("Watchdog הורץ" if ok else "Watchdog נכשל", message, ok=ok, details=details) except Exception as exc: return admin_status_page("שגיאה בהרצת Watchdog", "לא הצלחתי להריץ את ה־Watchdog.", ok=False, details=repr(exc)), 500 @app.route("/upload_admin_server", methods=["POST"]) def upload_admin_server(): file = request.files.get("file") if not file or file.filename == "": return admin_status_page("לא נבחר קובץ", "בחר קובץ admin_server.py או ZIP עדכון אדמין להעלאה.", ok=False), 400 original_name = file.filename or "" lower_name = original_name.lower() is_py = lower_name.endswith(".py") is_zip = lower_name.endswith(".zip") if not (is_py or is_zip): return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן קובץ Python עם סיומת .py או ZIP עדכון אדמין מבוקר.", ok=False), 400 limit = ADMIN_MAX_PACKAGE_UPLOAD_BYTES if is_zip else ADMIN_MAX_UPLOAD_BYTES if request.content_length and request.content_length > limit + 250000: return admin_status_page("קובץ גדול מדי", f"הקובץ גדול מהמותר. המגבלה היא בערך {limit:,} bytes.", ok=False), 413 os.makedirs(CONTROL_DIR, exist_ok=True) os.makedirs(ADMIN_UPLOAD_TMP_DIR, exist_ok=True) stamp = time.strftime("%Y%m%d_%H%M%S") suffix = ".zip" if is_zip else ".py" tmp_path = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"admin_server_upload_{stamp}{suffix}") extracted_admin_path = None try: file.save(tmp_path) if is_zip: work_dir = os.path.join(ADMIN_UPLOAD_TMP_DIR, f"admin_zip_extract_{stamp}_{os.getpid()}") valid, details, extracted_admin_path = extract_admin_server_from_zip_upload(tmp_path, work_dir) if not valid: try: os.remove(tmp_path) except Exception: pass try: if work_dir and os.path.isdir(work_dir): shutil.rmtree(work_dir, ignore_errors=True) except Exception: pass return admin_status_page("העלאת ZIP אדמין נדחתה", "הקובץ הפעיל לא הוחלף. נמצאה בעיה בחבילת העדכון.", ok=False, details=details), 400 admin_candidate_path = extracted_admin_path source_note = details else: valid, details = validate_admin_server_upload(tmp_path) if not valid: try: os.remove(tmp_path) except Exception: pass return admin_status_page("העלאת admin_server.py נדחתה", "הקובץ הפעיל לא הוחלף. נמצאה בעיה בקובץ שהעלית.", ok=False, details=details), 400 admin_candidate_path = tmp_path source_note = "קובץ Python ישיר תקין." shutil.copy2(admin_candidate_path, CONTROL_PENDING_ADMIN_PATH) new_sha = file_sha256(CONTROL_PENDING_ADMIN_PATH) try: os.remove(tmp_path) except Exception: pass if extracted_admin_path: try: shutil.rmtree(os.path.dirname(extracted_admin_path), ignore_errors=True) except Exception: pass failsafe_ok, failsafe_info = arm_admin_update_failsafe_restart() if not failsafe_ok: return admin_status_page("Fail Safe לא הופעל", "הקובץ עבר בדיקה, אבל עדכון האדמין לא נשלח כי ריסטארט החירום לא הופעל. הקובץ הפעיל לא הוחלף.", ok=False, details=failsafe_info), 500 bootstrap_ok, bootstrap_info = bootstrap_control_server("admin-upload") req = write_control_request("apply_update", reason="admin_upload_v34_3_control_server_failsafe", pending_path=CONTROL_PENDING_ADMIN_PATH) details = ( f"מקור העלאה:\n{html_lib.escape(original_name)}\n\n" f"בדיקת מקור:\n{source_note}\n\n" f"קובץ ממתין:\n{CONTROL_PENDING_ADMIN_PATH}\n\n" f"SHA256 חדש:\n{new_sha}\n\n" f"Fail Safe:\n{failsafe_info}\n\n" f"Control Server:\nhttp://127.0.0.1:{CONTROL_PORT}/\n\n" f"Bootstrap:\n{bootstrap_ok} | {bootstrap_info}\n\n" f"Request:\n{json.dumps(req, ensure_ascii=False, indent=2)}\n\n" f"לוג בקרה:\n{CONTROL_LOG_PATH}\n" f"לוג התקנה:\n{CONTROL_BOOTSTRAP_LOG_PATH}\n\n" "אם הפאנל חזר לעבוד אחרי העדכון — אפשר ללחוץ על ביטול ריסטארט Fail Safe. אם הוא כבר בוטל אוטומטית, זה יוצג כמצב תקין." ) return admin_status_page("עדכון נשלח לשרת הבקרה", "הקובץ החדש עבר בדיקה, ריסטארט חירום נקבע, והעדכון נשלח לשרת הבקרה החיצוני.", ok=True, details=details) except Exception as exc: try: if os.path.exists(tmp_path): os.remove(tmp_path) except Exception: pass try: if extracted_admin_path and os.path.exists(os.path.dirname(extracted_admin_path)): shutil.rmtree(os.path.dirname(extracted_admin_path), ignore_errors=True) except Exception: pass return admin_status_page("שגיאה בעדכון אדמין", "הקובץ הפעיל לא הוחלף.", ok=False, details=repr(exc)), 500 @app.route("/restart_admin_server", methods=["POST"]) def restart_admin_server(): bootstrap_ok, bootstrap_info = bootstrap_control_server("manual-restart") req = write_control_request("restart_admin", reason="manual_panel_restart_v34_control") return admin_status_page("אתחול נשלח לשרת הבקרה", "שרת הבקרה החיצוני יאתחל את פאנל האדמין הראשי. המתן כמה שניות ורענן.", ok=True, details=f"Control bootstrap: {bootstrap_ok} | {bootstrap_info}\n\nRequest:\n{json.dumps(req, ensure_ascii=False, indent=2)}\n\nControl log:\n{CONTROL_LOG_PATH}") @app.route("/restore_admin_server_backup", methods=["POST"]) def restore_admin_server_backup(): backup_path = latest_admin_backup() if not backup_path: return admin_status_page("אין גיבוי לשחזור", "לא נמצא קובץ גיבוי בתיקיית הגיבויים.", ok=False), 404 try: valid, details = validate_admin_server_upload(backup_path) if not valid: return admin_status_page("הגיבוי האחרון לא תקין", "הגיבוי לא שוחזר כי הוא לא עבר בדיקת תקינות.", ok=False, details=details), 400 safety_backup = backup_current_admin_server("admin_server_before_restore") shutil.copy2(backup_path, ADMIN_SERVER_PATH) msg = "הגיבוי האחרון שוחזר אל admin_server.py. לחץ בדיקת אתחול פאנל — מתקדם כדי להפעיל אותו." det = f"שוחזר מתוך:\n{backup_path}\n\nגיבוי בטיחות לגרסה שהייתה פעילה לפני השחזור:\n{safety_backup}" return admin_status_page("שחזור גיבוי הסתיים", msg, ok=True, details=det) except Exception as exc: return admin_status_page("שגיאה בשחזור גיבוי", "השחזור לא הושלם.", ok=False, details=repr(exc)), 500 @app.route("/upload/", methods=["POST"]) def upload(folder): if folder not in FOLDERS: return "Folder not found", 404 file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if folder in APP_FOLDERS and file_ext(file.filename) not in {".html", ".htm"}: return admin_status_page("קובץ לא תקין", "לאזור הזה ניתן להעלות רק קובץ HTML.", ok=False), 400 try: filename, result = save_uploaded_file(folder, file) details = f"יעד:\n{result['path']}\n\nגודל:\n{result['size']:,} bytes\n\nSHA256:\n{result['sha256']}" if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" return admin_status_page("העלאה הושלמה", f"הקובץ נשמר בהצלחה כ־{filename}. אם אתה רואה גרסה ישנה, פתח מחדש עם רענון מלא.", ok=True, details=details) except Exception as exc: return admin_status_page("שגיאה בהעלאה", "הקובץ לא נשמר. הקובץ הקודם נשאר במקומו אם היה קיים.", ok=False, details=repr(exc)), 500 @app.route("/upload_presentation/", methods=["POST"]) def upload_presentation(presentation_key): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if file_ext(file.filename) not in {".html", ".htm"}: return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק קובץ HTML של מצגת יפן.", ok=False), 400 saved = save_japan_presentation(presentation_key, file) if not saved: return "Presentation type not found", 404 filename, result = saved details = f"יעד:\n{result['path']}\n\nגודל:\n{result['size']:,} bytes\n\nSHA256:\n{result['sha256']}" if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" return admin_status_page("מצגת יפן הועלתה", f"הקובץ נשמר בשם הקבוע: {filename}", ok=True, details=details) @app.route("/upload_usa_presentation/", methods=["POST"]) def upload_usa_presentation(presentation_key): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if file_ext(file.filename) not in {".html", ".htm"}: return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק קובץ HTML של מצגת ארה״ב.", ok=False), 400 saved = save_usa_presentation(presentation_key, file) if not saved: return "USA presentation type not found", 404 filename, result = saved details = f"יעד:\n{result['path']}\n\nגודל:\n{result['size']:,} bytes\n\nSHA256:\n{result['sha256']}" if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" return admin_status_page("מצגת ארה״ב הועלתה", f"הקובץ נשמר בשם הקבוע: {filename}", ok=True, details=details) @app.route("/upload_usa_image", methods=["POST"]) def upload_usa_image(): image_key = request.form.get("image_key", "").strip() target_variant = request.form.get("target", "phone").strip() file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 try: result = save_usa_presentation_image(image_key, file, target_variant) if not result: return "USA image key not found", 404 details = ( f"יעד תצוגה: {result.get('target_label', '')}\n" f"יעד קובץ:\n{result['path']}\n\n" f"גודל:\n{result['size']:,} bytes\n\n" f"SHA256:\n{result['sha256']}\n\n" f"מצב שמירה:\n{result['mode']}" ) if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" details += "\n\n" + media_details_text(result.get("media")) details += "\n\nבדיקת נתיב מצגת:\n" + str(result.get("presentation_path_update") or {}) return admin_status_page("תמונת מצגת ארה״ב הועלתה", f"התמונה נשמרה ל־{result.get('target_label', 'יעד')}: {result['rel']}", ok=True, details=details) except Exception as exc: return admin_status_page("שגיאה בהעלאת תמונה", "התמונה לא נשמרה. להמרה ודחיסה של PNG/WebP/BMP/TIFF צריך Pillow בשרת. JPG אמיתי יתקבל גם בלי Pillow.", ok=False, details=repr(exc)), 400 @app.route("/upload_usa_images_zip", methods=["POST"]) def upload_usa_images_zip(): target_variant = request.form.get("target", "phone").strip() file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 original_name = file.filename or "" if not original_name.lower().endswith(".zip"): return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק קובץ ZIP של תמונות מצגת.", ok=False), 400 if request.content_length and request.content_length > USA_IMAGES_ZIP_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ גדול מדי", f"קובץ התמונות גדול מהמגבלה: {USA_IMAGES_ZIP_MAX_BYTES:,} bytes.", ok=False), 413 try: imported, skipped, missing, target_result = save_usa_presentation_images_zip(file, target_variant) details = "יעד תצוגה: " + target_result.get("target_label", "") + "\n" details += "נשמרו בתיקיית התמונות:\n" + ("\n".join(imported) if imported else "לא נשמרו תמונות.") details += "\n\nבדיקת נתיב מצגת:\n" + str(target_result.get("presentation_path_update") or {}) if skipped: details += "\n\nדולגו:\n" + "\n".join(skipped[:120]) if missing: details += "\n\nלא נמצאו בתיקיית היעד אחרי ההעלאה, ולכן עדיין חסרים שם:\n" + "\n".join(missing[:120]) return admin_status_page( "ZIP תמונות ארה״ב נטען", f"נשמרו {len(imported)} תמונות ל־{target_result.get('target_label', 'יעד נבחר')}. קבצים קיימים באותו שם הוחלפו רק בתיקיית היעד הזו.", ok=True, details=details, ) except zipfile.BadZipFile: return admin_status_page("ZIP לא תקין", "הקובץ שהועלה אינו ZIP תקין או שלא ניתן לפתוח אותו.", ok=False), 400 except ValueError as exc: return admin_status_page("ZIP לא תקין", "הקובץ לא עומד במגבלות העלאה של הפאנל.", ok=False, details=str(exc)), 400 except Exception as exc: return admin_status_page("שגיאה בהעלאת ZIP", "לא ניתן היה לעבד את קובץ התמונות.", ok=False, details=repr(exc)), 500 @app.route("/upload_usa_extra_html/", methods=["POST"]) def upload_usa_extra_html(extra_key): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if file_ext(file.filename) not in {".html", ".htm"}: return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק קובץ HTML.", ok=False), 400 saved = save_usa_extra_html(extra_key, file) if not saved: return "USA extra HTML type not found", 404 filename, result = saved details = f"יעד:\n{result['path']}\n\nגודל:\n{result['size']:,} bytes\n\nSHA256:\n{result['sha256']}" if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" return admin_status_page("קובץ ארה״ב נוסף הועלה", f"הקובץ נשמר בשם הקבוע: {filename}", ok=True, details=details) @app.route("/confirm_japan_experience_music_upload/", methods=["POST"]) def confirm_japan_experience_music_upload(token): action = request.form.get("action", "") return commit_japan_experience_pending_music(token, action) @app.route("/upload_japan_music/", methods=["POST"]) def upload_japan_music(music_key): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if request.content_length and request.content_length > AUDIO_UPLOAD_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ מוזיקה גדול מדי", f"קובץ האודיו גדול מהמגבלה: {format_bytes(AUDIO_UPLOAD_MAX_BYTES)}.", ok=False), 413 if music_key == "japan_experience_music": return handle_japan_experience_music_upload_with_confirmation(file) result = save_japan_music(music_key, file) if not result: return "Japan music type not found", 404 duration_status = register_existing_music_upload_duration("JAPAN", music_key, result) details = "נשמר אל:\n" + "\n".join([item["path"] for item in result["targets"]]) + f"\n\nSHA256 MP3 סופי:\n{result['sha256']}" details += "\n\n" + media_details_text(result.get("media")) details += "\n\n" + music_upload_duration_details(duration_status) if duration_status.get("duration_ok"): if music_key == "japan_experience_music": if duration_status.get("sync_performed"): return admin_status_page("מוזיקת יפן הועלתה והמצגת סונכרנה", "השיר נשמר, משך השיר זוהה, וכל שקפי מצגת יפן סונכרנו לפי האורך החדש.", ok=True, details=details) return admin_status_page("מוזיקת יפן נשמרה — סנכרון מצגת נכשל", "השיר נשמר ומשך השיר זוהה, אך סנכרון שקפי מצגת יפן נכשל. אין אישור שהמצגת מסונכרנת.", ok=False, details=details), 200 return admin_status_page("מוזיקת פתיח טיסה הועלתה", "הקובץ נשמר ומשך השיר זוהה. פתיח הטיסה הוא מקטע נפרד ולכן japan-experience.html לא שונה.", ok=True, details=details) return admin_status_page("מוזיקת יפן נשמרה — בדיקת אורך נכשלה", "השיר נשמר, אבל ffprobe לא הצליח לזהות משך תקין. אין אישור לסנכרון.", ok=False, details=details), 200 @app.route("/upload_japan_images_zip", methods=["POST"]) def upload_japan_images_zip(): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if not (file.filename or "").lower().endswith(".zip"): return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק ZIP תמונות יפן.", ok=False), 400 if request.content_length and request.content_length > JAPAN_IMAGES_ZIP_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ גדול מדי", f"קובץ התמונות גדול מהמגבלה: {JAPAN_IMAGES_ZIP_MAX_BYTES:,} bytes.", ok=False), 413 try: imported, skipped, overwritten = save_japan_images_zip(file) details = "יובאו:\n" + ("\n".join(imported[:180]) if imported else "לא יובאו תמונות.") if overwritten: details += "\n\nהוחלפו קבצים קיימים:\n" + "\n".join(overwritten[:120]) if skipped: details += "\n\nדולגו:\n" + "\n".join(skipped[:120]) return admin_status_page("ZIP תמונות יפן נטען", f"נשמרו {len(imported)} תמונות תחת JAPAN/media/images.", ok=True, details=details) except zipfile.BadZipFile: return admin_status_page("ZIP לא תקין", "הקובץ שהועלה אינו ZIP תקין או שלא ניתן לפתוח אותו.", ok=False), 400 except Exception as exc: return admin_status_page("שגיאה בהעלאת ZIP יפן", "לא ניתן היה לעבד את קובץ התמונות.", ok=False, details=repr(exc)), 500 @app.route("/admin/netlify/download/") def admin_netlify_download(trip): trip_key = normalize_netlify_trip_key(trip) if trip_key not in {"USA", "JAPAN"}: return admin_status_page("טיול לא מוכר", "ניתן ליצור ZIP ל־Netlify רק עבור USA או JAPAN.", ok=False), 404 try: zip_path, details = build_netlify_deploy_zip(trip_key) response = send_file( zip_path, as_attachment=True, download_name=os.path.basename(zip_path), mimetype="application/zip", conditional=False, max_age=0, ) response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0" response.headers["X-TripServer-Netlify-Trip"] = trip_key response.headers["X-TripServer-Netlify-Files"] = str(details.get("files", "")) return response except Exception as exc: return admin_status_page( "יצירת ZIP ל־Netlify נכשלה", "לא הצלחתי להכין את חבילת Netlify. הקבצים המקוריים לא שונו.", ok=False, details=repr(exc), ), 500 @app.route("/upload_trip_package/", methods=["POST"]) def upload_trip_package(trip): trip = (trip or "").upper() file = request.files.get("file") if trip not in {"USA", "JAPAN"}: return "Trip package type not found", 404 if not file or file.filename == "": return "No file selected", 400 if not (file.filename or "").lower().endswith(".zip"): return admin_status_page("קובץ לא תקין", "ניתן להעלות כאן רק ZIP מלא של הטיול.", ok=False), 400 if request.content_length and request.content_length > TRIP_PACKAGE_ZIP_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ גדול מדי", f"ה־ZIP גדול מהמגבלה: {TRIP_PACKAGE_ZIP_MAX_BYTES:,} bytes.", ok=False), 413 try: imported, skipped, overwritten = save_trip_package_zip(trip, file) details = "יובאו:\n" + ("\n".join(imported[:200]) if imported else "לא יובאו קבצים.") if overwritten: details += "\n\nהוחלפו קבצים קיימים:\n" + "\n".join(overwritten[:140]) if skipped: details += "\n\nדולגו:\n" + "\n".join(skipped[:140]) return admin_status_page(f"ZIP מלא של {trip} נטען", f"נשמרו {len(imported)} קבצים בתיקיית {trip}.", ok=True, details=details) except zipfile.BadZipFile: return admin_status_page("ZIP לא תקין", "הקובץ שהועלה אינו ZIP תקין או שלא ניתן לפתוח אותו.", ok=False), 400 except Exception as exc: return admin_status_page("שגיאה בהעלאת ZIP מלא", "לא ניתן היה לעבד את חבילת הטיול.", ok=False, details=repr(exc)), 500 @app.route("/upload_usa_music/", methods=["POST"]) def upload_usa_music(music_key): file = request.files.get("file") if not file or file.filename == "": return "No file selected", 400 if request.content_length and request.content_length > AUDIO_UPLOAD_MAX_BYTES + 1024 * 1024: return admin_status_page("קובץ מוזיקה גדול מדי", f"קובץ האודיו גדול מהמגבלה: {format_bytes(AUDIO_UPLOAD_MAX_BYTES)}.", ok=False), 413 saved = save_usa_music(music_key, file) if not saved: return "USA music type not found", 404 filename, result = saved duration_status = register_existing_music_upload_duration("USA", music_key, result) details = f"יעד:\n{result['path']}\n\nגודל:\n{result['size']:,} bytes\n\nSHA256:\n{result['sha256']}" if result.get("backup"): details += f"\n\nגיבוי קודם:\n{result['backup']}" details += "\n\n" + media_details_text(result.get("media")) details += "\n\n" + music_upload_duration_details(duration_status) if duration_status.get("duration_ok"): return admin_status_page("מוזיקת ארה״ב הועלתה והמצגת סונכרנה", f"הקובץ נשמר בנתיב הקבוע: {filename}, משך השיר זוהה, ומקטע המצגת הרלוונטי סונכרן.", ok=True, details=details) if duration_status.get("sync_performed") else admin_status_page("מוזיקת ארה״ב נשמרה — סנכרון נכשל", "השיר נשמר ומשך השיר זוהה, אך סנכרון מקטע מצגת ארה״ב נכשל. אין אישור שהמצגת מסונכרנת.", ok=False, details=details) return admin_status_page("מוזיקת ארה״ב נשמרה — בדיקת אורך נכשלה", "השיר נשמר, אבל ffprobe לא הצליח לזהות משך תקין. אין אישור לסנכרון.", ok=False, details=details), 200 @app.route("/power/", methods=["POST"]) def power_action(action): action = (action or "").strip().lower() if action not in POWER_CONFIRM_TEXT: return admin_status_page("פעולת מחשב לא מוכרת", "הפעולה המבוקשת אינה קיימת.", ok=False), 404 allowed, reason = power_action_allowed() if not allowed: return admin_status_page("פעולת מחשב נחסמה", reason, ok=False), 403 if request.form.get("ack") != "1": return admin_status_page("חסר אישור פעולה", "כדי למנוע לחיצה בטעות, צריך לסמן שאתה מבין את המשמעות של הפעולה.", ok=False), 400 expected = POWER_CONFIRM_TEXT[action] confirm_text = (request.form.get("confirm_text") or "").strip() if confirm_text != expected: return admin_status_page("מילת האישור לא נכונה", f"כדי לבצע את הפעולה צריך להקליד בדיוק: {expected}", ok=False), 400 delay = normalize_power_delay(request.form.get("delay")) try: label, final_delay, output = run_power_command(action, delay) details = f"פעולה:\n{label}\n\nתבוצע בעוד:\n{final_delay} שניות\n\nכתובת מבקשת:\n{get_client_ip()}\n\nפלט Windows:\n{output or 'OK'}" return admin_status_page("פעולת מחשב נקבעה", f"{label} נקבע בהצלחה. אפשר לבטל לפני סוף הטיימר דרך כפתור הביטול בפאנל.", ok=True, details=details) except Exception as exc: return admin_status_page("שגיאה בהפעלת פקודת מחשב", "Windows לא קיבל את פקודת הכיבוי/ריסטארט.", ok=False, details=repr(exc)), 500 @app.route("/power/cancel", methods=["POST"]) def power_cancel(): allowed, reason = power_action_allowed() if not allowed: return admin_status_page("ביטול פעולת מחשב נחסם", reason, ok=False), 403 rc, output = cancel_power_command() details = output or f"return code: {rc}" if rc == 0: write_admin_failsafe_status("cancelled", "ריסטארט/כיבוי מתוזמן בוטל ידנית מהפאנל.", windows_output=details) return admin_status_page("פעולה מתוזמנת בוטלה", "אם היה כיבוי/ריסטארט בהמתנה — הוא בוטל.", ok=True, details=details) if is_no_pending_shutdown_message(details): write_admin_failsafe_status("none", "אין כרגע ריסטארט Fail Safe פעיל. כנראה שהוא כבר בוטל אוטומטית או שלא היה ריסטארט בהמתנה.", windows_output=details) return admin_status_page("אין ריסטארט פעיל כרגע", "אין כרגע כיבוי/ריסטארט בהמתנה. זה תקין אם העדכון הצליח וה־Fail Safe כבר בוטל אוטומטית.", ok=True, details=details) write_admin_failsafe_status("cancel_failed", "ניסיון ביטול ריסטארט החזיר שגיאה שדורשת בדיקה.", windows_output=details, return_code=rc) return admin_status_page("ביטול פעולה מתוזמנת נכשל", "Windows החזיר שגיאה בביטול כיבוי/ריסטארט מתוזמן.", ok=False, details=details) @app.route("/JAPAN") @app.route("/JAPAN/") def japan(): return serve_app("JAPAN") @app.route("/USA") @app.route("/USA/") def usa(): return serve_app("USA") @app.route("/Moneyapp") @app.route("/Moneyapp/") def moneyapp(): return serve_app("Moneyapp") @app.route("/MoneyHome") @app.route("/MoneyHome/") def moneyhome(): return serve_app("MoneyHome") @app.route("/JAPAN/") def japan_static(path): return serve_file_no_cache(FOLDERS["JAPAN"], path) @app.route("/USA/") def usa_static(path): return serve_file_no_cache(FOLDERS["USA"], path) @app.route("/Moneyapp/") def money_static(path): return serve_file_no_cache(FOLDERS["Moneyapp"], path) @app.route("/TripForm") @app.route("/TripForm/") def tripform(): return serve_app("TripForm") @app.route("/MoneyHome/") def moneyhome_static(path): return serve_file_no_cache(FOLDERS["MoneyHome"], path) @app.route("/TripForm/") def tripform_static(path): return serve_file_no_cache(FOLDERS["TripForm"], path) if __name__ == "__main__": bootstrap_control_server("admin-startup") maybe_start_camera_auto_install("admin-startup") app.run(host=ADMIN_HOST, port=ADMIN_PORT, threaded=True, use_reloader=False)