139 lines
5.8 KiB
Python
139 lines
5.8 KiB
Python
import os
|
|
import json
|
|
import requests
|
|
import bcrypt
|
|
import re
|
|
from logging_config import Logger
|
|
|
|
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.
|
|
"""
|
|
import json
|
|
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
|
|
|
|
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:
|
|
ip_pattern = r'^\d+\.\d+\.\d+\.\d+$'
|
|
if re.match(ip_pattern, server):
|
|
server_url = f'http://{server}:{port}/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)
|
|
print(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 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.
|
|
"""
|
|
import json
|
|
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}")
|
|
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)
|
|
return True
|
|
else:
|
|
Logger.warning("No playlist data fetched from server or playlist is empty.")
|
|
return False
|
|
else:
|
|
Logger.info("Local playlist is already up to date.")
|
|
return False
|
|
|
|
|
|
|
|
|