diff --git a/media/canva-blue-night-sky-cute-whale-desktop-wallpaper-Z3o7FZeI-Ms.webp b/media/canva-blue-night-sky-cute-whale-desktop-wallpaper-Z3o7FZeI-Ms.webp new file mode 100644 index 0000000..5aa0c49 Binary files /dev/null and b/media/canva-blue-night-sky-cute-whale-desktop-wallpaper-Z3o7FZeI-Ms.webp differ diff --git a/media/edited_media/AGC_20250704_204105932_e_v1.jpg b/media/edited_media/AGC_20250704_204105932_e_v1.jpg deleted file mode 100644 index ee6ba33..0000000 Binary files a/media/edited_media/AGC_20250704_204105932_e_v1.jpg and /dev/null differ diff --git a/media/edited_media/AGC_20250704_204105932_e_v1_metadata.json b/media/edited_media/AGC_20250704_204105932_e_v1_metadata.json deleted file mode 100644 index 7273734..0000000 --- a/media/edited_media/AGC_20250704_204105932_e_v1_metadata.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "time_of_modification": "2025-12-05T00:20:29.292050", - "original_name": "AGC_20250704_204105932.jpg", - "new_name": "AGC_20250704_204105932_e_v1.jpg", - "original_path": "/home/pi/Desktop/Kiwy-Signage/media/AGC_20250704_204105932.jpg", - "version": 1 -} \ No newline at end of file diff --git a/media/edited_media/Cindrel_1_e_v1.jpg b/media/edited_media/Cindrel_1_e_v1.jpg deleted file mode 100644 index 58b7d53..0000000 Binary files a/media/edited_media/Cindrel_1_e_v1.jpg and /dev/null differ diff --git a/media/edited_media/Cindrel_1_e_v1_metadata.json b/media/edited_media/Cindrel_1_e_v1_metadata.json deleted file mode 100644 index 3719c6e..0000000 --- a/media/edited_media/Cindrel_1_e_v1_metadata.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "time_of_modification": "2025-12-05T00:23:14.473276", - "original_name": "Cindrel_1.jpg", - "new_name": "Cindrel_1_e_v1.jpg", - "original_path": "/home/pi/Desktop/Kiwy-Signage/media/Cindrel_1.jpg", - "version": 1 -} \ No newline at end of file diff --git a/media/wp1993621.webp b/media/wp1993621.webp new file mode 100644 index 0000000..52a2177 Binary files /dev/null and b/media/wp1993621.webp differ diff --git a/src/main.py b/src/main.py index a1ccb5e..95e5ac9 100644 --- a/src/main.py +++ b/src/main.py @@ -544,6 +544,21 @@ class EditPopup(Popup): if response.status_code == 200: response_data = response.json() Logger.info(f"EditPopup: ✅ Successfully uploaded edited media to server: {response_data}") + + # Delete local files after successful upload + try: + if os.path.exists(image_path): + os.remove(image_path) + Logger.info(f"EditPopup: Deleted local image file: {os.path.basename(image_path)}") + + if os.path.exists(metadata_path): + os.remove(metadata_path) + Logger.info(f"EditPopup: Deleted local metadata file: {os.path.basename(metadata_path)}") + + Logger.info("EditPopup: ✅ Local edited files cleaned up after successful upload") + except Exception as e: + Logger.warning(f"EditPopup: Could not delete local files: {e}") + return True elif response.status_code == 404: Logger.warning("EditPopup: ⚠️ Upload endpoint not available on server (404) - edited media saved locally only") diff --git a/src/player_auth.json b/src/player_auth.json index 8e2420e..7342223 100644 --- a/src/player_auth.json +++ b/src/player_auth.json @@ -1,10 +1,10 @@ { "hostname": "tv-terasa", - "auth_code": "iiSyZDLWGyqNIxeRt54XYREgvAio11RwwU1_oJev6WI", + "auth_code": "vkrxEO6eOTxkzXJBtoN4OuXc8eaX2mC3AB9ZePrnick", "player_id": 1, - "player_name": "TV-acasa 1", + "player_name": "TV-acasa", "playlist_id": 1, "orientation": "Landscape", "authenticated": true, - "server_url": "https://digi-signage.moto-adv.com:443" + "server_url": "http://digi-signage.moto-adv.com" } \ No newline at end of file diff --git a/working_files/get_playlists.py b/working_files/get_playlists.py new file mode 100644 index 0000000..34e453c --- /dev/null +++ b/working_files/get_playlists.py @@ -0,0 +1,346 @@ +import os +import json +import requests +import bcrypt +import re +import datetime +import logging + +# Set up logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +def send_player_feedback(config, message, status="active", playlist_version=None, error_details=None): + """ + Send feedback to the server about player status. + + Args: + config (dict): Configuration containing server details + message (str): Main feedback message + status (str): Player status - "active", "playing", "error", "restarting" + playlist_version (int, optional): Current playlist version being played + error_details (str, optional): Error details if status is "error" + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + try: + server = config.get("server_ip", "") + host = config.get("screen_name", "") + quick = config.get("quickconnect_key", "") + port = config.get("port", "") + + # Construct server URL + # Remove protocol if already present + server_clean = server.replace('http://', '').replace('https://', '') + ip_pattern = r'^\d+\.\d+\.\d+\.\d+$' + if re.match(ip_pattern, server_clean): + feedback_url = f'http://{server_clean}:{port}/api/player-feedback' + else: + # Use original server if it has protocol, otherwise add http:// + if server.startswith(('http://', 'https://')): + feedback_url = f'{server}/api/player-feedback' + else: + feedback_url = f'http://{server}/api/player-feedback' + + # Prepare feedback data + feedback_data = { + 'hostname': host, + 'quickconnect_code': quick, + 'message': message, + 'status': status, + 'timestamp': datetime.datetime.now().isoformat(), + 'playlist_version': playlist_version, + 'error_details': error_details + } + + logger.info(f"Sending feedback to {feedback_url}: {feedback_data}") + + # Send POST request + response = requests.post(feedback_url, json=feedback_data, timeout=10) + + if response.status_code == 200: + logger.info(f"Feedback sent successfully: {message}") + return True + else: + logger.warning(f"Feedback failed with status {response.status_code}: {response.text}") + return False + + except requests.exceptions.RequestException as e: + logger.error(f"Failed to send feedback: {e}") + return False + except Exception as e: + logger.error(f"Unexpected error sending feedback: {e}") + return False + +def send_playlist_check_feedback(config, playlist_version=None): + """ + Send feedback when playlist is checked for updates. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + message = f"player {player_name}, is active, Playing {version_info}" + + return send_player_feedback( + config=config, + message=message, + status="active", + playlist_version=playlist_version + ) + +def send_playlist_restart_feedback(config, playlist_version=None): + """ + Send feedback when playlist loop ends and restarts. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + message = f"player {player_name}, playlist loop completed, restarting {version_info}" + + return send_player_feedback( + config=config, + message=message, + status="restarting", + playlist_version=playlist_version + ) + +def send_player_error_feedback(config, error_message, playlist_version=None): + """ + Send feedback when an error occurs in the player. + + Args: + config (dict): Configuration containing server details + error_message (str): Description of the error + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + message = f"player {player_name}, error occurred" + + return send_player_feedback( + config=config, + message=message, + status="error", + playlist_version=playlist_version, + error_details=error_message + ) + +def send_playing_status_feedback(config, playlist_version=None, current_media=None): + """ + Send feedback about current playing status. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + current_media (str, optional): Currently playing media file + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + media_info = f" - {current_media}" if current_media else "" + message = f"player {player_name}, is active, Playing {version_info}{media_info}" + + return send_player_feedback( + config=config, + message=message, + status="playing", + playlist_version=playlist_version + ) + +def fetch_server_playlist(config): + """Fetch the updated playlist from the server using a config dict.""" + server = config.get("server_ip", "") + host = config.get("screen_name", "") + quick = config.get("quickconnect_key", "") + port = config.get("port", "") + try: + # Remove protocol if already present + server_clean = server.replace('http://', '').replace('https://', '') + ip_pattern = r'^\d+\.\d+\.\d+\.\d+$' + if re.match(ip_pattern, server_clean): + server_url = f'http://{server_clean}:{port}/api/playlists' + else: + # Use original server if it has protocol, otherwise add http:// + if server.startswith(('http://', 'https://')): + server_url = f'{server}/api/playlists' + else: + server_url = f'http://{server}/api/playlists' + params = { + 'hostname': host, + 'quickconnect_code': quick + } + logger.info(f"Fetching playlist from URL: {server_url} with params: {params}") + response = requests.get(server_url, params=params) + if response.status_code == 200: + response_data = response.json() + logger.info(f"Server response: {response_data}") + playlist = response_data.get('playlist', []) + version = response_data.get('playlist_version', None) + hashed_quickconnect = response_data.get('hashed_quickconnect', None) + if version is not None and hashed_quickconnect is not None: + if bcrypt.checkpw(quick.encode('utf-8'), hashed_quickconnect.encode('utf-8')): + logger.info("Fetched updated playlist from server.") + return {'playlist': playlist, 'version': version} + else: + logger.error("Quickconnect code validation failed.") + else: + logger.error("Failed to retrieve playlist or hashed quickconnect from the response.") + else: + logger.error(f"Failed to fetch playlist. Status Code: {response.status_code}") + except requests.exceptions.RequestException as e: + logger.error(f"Failed to fetch playlist: {e}") + return {'playlist': [], 'version': 0} + +def save_playlist_with_version(playlist_data, playlist_dir): + version = playlist_data.get('version', 0) + playlist_file = os.path.join(playlist_dir, f'server_playlist_v{version}.json') + with open(playlist_file, 'w') as f: + json.dump(playlist_data, f, indent=2) + logger.info(f"Playlist saved to {playlist_file}") + return playlist_file + +def download_media_files(playlist, media_dir): + """Download media files from the server and save them to media_dir.""" + if not os.path.exists(media_dir): + os.makedirs(media_dir) + logger.info(f"Created directory {media_dir} for media files.") + + updated_playlist = [] + for media in playlist: + file_name = media.get('file_name', '') + file_url = media.get('url', '') + duration = media.get('duration', 10) + local_path = os.path.join(media_dir, file_name) + logger.info(f"Preparing to download {file_name} from {file_url}...") + if os.path.exists(local_path): + logger.info(f"File {file_name} already exists. Skipping download.") + else: + try: + response = requests.get(file_url, timeout=10) + if response.status_code == 200: + with open(local_path, 'wb') as file: + file.write(response.content) + logger.info(f"Successfully downloaded {file_name} to {local_path}") + else: + logger.error(f"Failed to download {file_name}. Status Code: {response.status_code}") + continue + except requests.exceptions.RequestException as e: + logger.error(f"Error downloading {file_name}: {e}") + continue + updated_media = { + 'file_name': file_name, + 'url': os.path.relpath(local_path, os.path.dirname(media_dir)), + 'duration': duration + } + updated_playlist.append(updated_media) + return updated_playlist + +def delete_old_playlists_and_media(current_version, playlist_dir, media_dir, keep_versions=1): + """ + Delete old playlist files and media files not referenced by the latest playlist version. + keep_versions: number of latest versions to keep (default 1) + """ + # Find all playlist files + playlist_files = [f for f in os.listdir(playlist_dir) if f.startswith('server_playlist_v') and f.endswith('.json')] + # Keep only the latest N versions + versions = sorted([int(f.split('_v')[-1].split('.json')[0]) for f in playlist_files], reverse=True) + keep = set(versions[:keep_versions]) + # Delete old playlist files + for f in playlist_files: + v = int(f.split('_v')[-1].split('.json')[0]) + if v not in keep: + os.remove(os.path.join(playlist_dir, f)) + # Collect all media files referenced by the kept playlists + referenced = set() + for v in keep: + path = os.path.join(playlist_dir, f'server_playlist_v{v}.json') + if os.path.exists(path): + with open(path, 'r') as f: + data = json.load(f) + for item in data.get('playlist', []): + referenced.add(item.get('file_name')) + # Delete media files not referenced + for f in os.listdir(media_dir): + if f not in referenced: + try: + os.remove(os.path.join(media_dir, f)) + except Exception as e: + logger.warning(f"Failed to delete media file {f}: {e}") + +def update_playlist_if_needed(local_playlist_path, config, media_dir, playlist_dir): + """ + Fetch the server playlist once, compare versions, and update if needed. + Returns True if updated, False if already up to date. + Also sends feedback to server about playlist check. + """ + server_data = fetch_server_playlist(config) + server_version = server_data.get('version', 0) + if not os.path.exists(local_playlist_path): + local_version = 0 + else: + with open(local_playlist_path, 'r') as f: + local_data = json.load(f) + local_version = local_data.get('version', 0) + + logger.info(f"Local playlist version: {local_version}, Server playlist version: {server_version}") + + # Send feedback about playlist check + send_playlist_check_feedback(config, server_version if server_version > 0 else local_version) + + if local_version != server_version: + if server_data and server_data.get('playlist'): + updated_playlist = download_media_files(server_data['playlist'], media_dir) + server_data['playlist'] = updated_playlist + save_playlist_with_version(server_data, playlist_dir) + # Delete old playlists and unreferenced media + delete_old_playlists_and_media(server_version, playlist_dir, media_dir) + + # Send feedback about playlist update + player_name = config.get("screen_name", "unknown") + update_message = f"player {player_name}, playlist updated to v{server_version}" + send_player_feedback(config, update_message, "active", server_version) + + return True + else: + logger.warning("No playlist data fetched from server or playlist is empty.") + + # Send error feedback + send_player_error_feedback(config, "No playlist data fetched from server or playlist is empty", local_version) + + return False + else: + logger.info("Local playlist is already up to date.") + return False + +def is_playlist_up_to_date(local_playlist_path, config): + """ + Compare the version of the local playlist with the server playlist. + Returns True if up-to-date, False otherwise. + """ + if not os.path.exists(local_playlist_path): + logger.info(f"Local playlist file not found: {local_playlist_path}") + return False + with open(local_playlist_path, 'r') as f: + local_data = json.load(f) + local_version = local_data.get('version', 0) + server_data = fetch_server_playlist(config) + server_version = server_data.get('version', 0) + logger.info(f"Local playlist version: {local_version}, Server playlist version: {server_version}") + return local_version == server_version \ No newline at end of file