From 03b982e7c27bbe085f452a0b13399be48fb24edd Mon Sep 17 00:00:00 2001 From: Christian Krakau-Louis Date: Tue, 13 May 2025 08:59:02 +0000 Subject: [PATCH] Initial clean commit --- .env.demo | 63 + .github/workflows/docker-publish.yml | 98 + .gitignore | 171 ++ Dockerfile | 33 + LICENSE | 21 + README.md | 157 ++ TODO.md | 166 ++ docker-compose.yml | 59 + docker-entrypoint.sh | 27 + docs/brand_identity.md | 72 + docs/oauth_callback_urls.md | 106 + favicon.ico | Bin 0 -> 4158 bytes migrations/add_dropbox_export_path.py | 78 + migrations/add_dropbox_oauth.py | 185 ++ migrations/add_oauth_providers.py | 158 ++ migrations/add_preview_urls.py | 126 ++ migrations/add_song_fields.py | 124 ++ migrations/add_spotify_audio_features.py | 116 ++ migrations/add_tag_system.py | 146 ++ musicround/__init__.py | 367 ++++ musicround/config.py | 75 + musicround/deezer_client.py | 252 +++ musicround/errors.py | 222 +++ musicround/helpers/__init__.py | 1 + musicround/helpers/auth_helpers.py | 280 +++ musicround/helpers/backup_helper.py | 724 +++++++ musicround/helpers/dropbox_helper.py | 495 +++++ musicround/helpers/email_helper.py | 103 + musicround/helpers/import_helper.py | 611 ++++++ musicround/helpers/metadata.py | 839 ++++++++ musicround/helpers/spotify_direct.py | 304 +++ musicround/helpers/utils.py | 303 +++ musicround/models.py | 331 ++++ musicround/mp3/1.mp3 | Bin 0 -> 6381 bytes musicround/mp3/2.mp3 | Bin 0 -> 6381 bytes musicround/mp3/3.mp3 | Bin 0 -> 6669 bytes musicround/mp3/4.mp3 | Bin 0 -> 6381 bytes musicround/mp3/5.mp3 | Bin 0 -> 6957 bytes musicround/mp3/6.mp3 | Bin 0 -> 6669 bytes musicround/mp3/7.mp3 | Bin 0 -> 6813 bytes musicround/mp3/8.mp3 | Bin 0 -> 6093 bytes musicround/mp3/intro.mp3 | Bin 0 -> 16317 bytes musicround/mp3/outro.mp3 | Bin 0 -> 16461 bytes musicround/mp3/replay.mp3 | Bin 0 -> 13293 bytes musicround/routes/api.py | 1073 ++++++++++ musicround/routes/auth.py | 179 ++ musicround/routes/core.py | 323 +++ musicround/routes/db_admin.py | 190 ++ musicround/routes/deezer_routes.py | 223 +++ musicround/routes/generate.py | 579 ++++++ musicround/routes/import.py | 241 +++ musicround/routes/import_routes.py | 745 +++++++ musicround/routes/import_songs.py | 111 ++ musicround/routes/process.py | 21 + musicround/routes/rounds.py | 1112 +++++++++++ musicround/routes/users.py | 1743 +++++++++++++++++ musicround/static/audio/1.mp3 | Bin 0 -> 6381 bytes musicround/static/audio/2.mp3 | Bin 0 -> 6381 bytes musicround/static/audio/3.mp3 | Bin 0 -> 6669 bytes musicround/static/audio/4.mp3 | Bin 0 -> 6381 bytes musicround/static/audio/5.mp3 | Bin 0 -> 6957 bytes musicround/static/audio/6.mp3 | Bin 0 -> 6669 bytes musicround/static/audio/7.mp3 | Bin 0 -> 6813 bytes musicround/static/audio/8.mp3 | Bin 0 -> 6093 bytes musicround/static/audio/intro.mp3 | Bin 0 -> 16317 bytes musicround/static/audio/outro.mp3 | Bin 0 -> 16461 bytes musicround/static/audio/replay.mp3 | Bin 0 -> 13293 bytes musicround/static/css/style.css | 32 + musicround/static/favicon.ico | Bin 0 -> 1252505 bytes musicround/static/img/dark/logo.png | Bin 0 -> 86407 bytes .../static/img/dark/logo_whitespace.png | Bin 0 -> 592633 bytes musicround/static/img/dark/logotype.png | Bin 0 -> 538450 bytes musicround/static/img/dark/monogram.png | Bin 0 -> 311312 bytes musicround/static/img/light/logo.png | Bin 0 -> 155090 bytes .../static/img/light/logo_whitespace.png | Bin 0 -> 201199 bytes musicround/static/img/light/logotype.png | Bin 0 -> 218074 bytes musicround/static/img/light/monogram.png | Bin 0 -> 214601 bytes .../templates/admin/backup_manager.html | 528 +++++ .../templates/admin/spotify_token_wizard.html | 95 + musicround/templates/admin/system_health.html | 219 +++ .../templates/admin/system_settings.html | 257 +++ musicround/templates/base.html | 229 +++ .../templates/browse_deezer_playlists.html | 278 +++ musicround/templates/build_music_round.html | 112 ++ musicround/templates/error.html | 226 +++ musicround/templates/homepage.html | 56 + .../templates/import_official_playlists.html | 430 ++++ musicround/templates/import_playlist.html | 132 ++ musicround/templates/raw_playlists.html | 260 +++ musicround/templates/round.html | 86 + musicround/templates/round_detail.html | 1173 +++++++++++ musicround/templates/rounds.html | 89 + musicround/templates/service_import.html | 70 + musicround/templates/service_search.html | 169 ++ .../templates/service_search_results.html | 516 +++++ musicround/templates/spotify_client_test.html | 172 ++ musicround/templates/spotify_direct_auth.html | 141 ++ .../templates/users/audio_settings.html | 461 +++++ .../templates/users/change_password.html | 56 + musicround/templates/users/edit_profile.html | 566 ++++++ .../templates/users/forgot_password.html | 56 + musicround/templates/users/login.html | 92 + musicround/templates/users/profile.html | 832 ++++++++ musicround/templates/users/register.html | 71 + .../templates/users/reset_password.html | 67 + musicround/templates/users/spotify_link.html | 143 ++ musicround/templates/view_songs.html | 1478 ++++++++++++++ musicround/version.py | 27 + requirements.txt | 21 + run.py | 80 + run_migration.py | 44 + tests/__init__.py | 1 + tests/test_metadata.py | 355 ++++ 113 files changed, 22973 insertions(+) create mode 100644 .env.demo create mode 100644 .github/workflows/docker-publish.yml create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 LICENSE create mode 100644 README.md create mode 100644 TODO.md create mode 100644 docker-compose.yml create mode 100644 docker-entrypoint.sh create mode 100644 docs/brand_identity.md create mode 100644 docs/oauth_callback_urls.md create mode 100644 favicon.ico create mode 100644 migrations/add_dropbox_export_path.py create mode 100644 migrations/add_dropbox_oauth.py create mode 100644 migrations/add_oauth_providers.py create mode 100644 migrations/add_preview_urls.py create mode 100644 migrations/add_song_fields.py create mode 100644 migrations/add_spotify_audio_features.py create mode 100644 migrations/add_tag_system.py create mode 100644 musicround/__init__.py create mode 100644 musicround/config.py create mode 100644 musicround/deezer_client.py create mode 100644 musicround/errors.py create mode 100644 musicround/helpers/__init__.py create mode 100644 musicround/helpers/auth_helpers.py create mode 100644 musicround/helpers/backup_helper.py create mode 100644 musicround/helpers/dropbox_helper.py create mode 100644 musicround/helpers/email_helper.py create mode 100644 musicround/helpers/import_helper.py create mode 100644 musicround/helpers/metadata.py create mode 100644 musicround/helpers/spotify_direct.py create mode 100644 musicround/helpers/utils.py create mode 100644 musicround/models.py create mode 100644 musicround/mp3/1.mp3 create mode 100644 musicround/mp3/2.mp3 create mode 100644 musicround/mp3/3.mp3 create mode 100644 musicround/mp3/4.mp3 create mode 100644 musicround/mp3/5.mp3 create mode 100644 musicround/mp3/6.mp3 create mode 100644 musicround/mp3/7.mp3 create mode 100644 musicround/mp3/8.mp3 create mode 100644 musicround/mp3/intro.mp3 create mode 100644 musicround/mp3/outro.mp3 create mode 100644 musicround/mp3/replay.mp3 create mode 100644 musicround/routes/api.py create mode 100644 musicround/routes/auth.py create mode 100644 musicround/routes/core.py create mode 100644 musicround/routes/db_admin.py create mode 100644 musicround/routes/deezer_routes.py create mode 100644 musicround/routes/generate.py create mode 100644 musicround/routes/import.py create mode 100644 musicround/routes/import_routes.py create mode 100644 musicround/routes/import_songs.py create mode 100644 musicround/routes/process.py create mode 100644 musicround/routes/rounds.py create mode 100644 musicround/routes/users.py create mode 100644 musicround/static/audio/1.mp3 create mode 100644 musicround/static/audio/2.mp3 create mode 100644 musicround/static/audio/3.mp3 create mode 100644 musicround/static/audio/4.mp3 create mode 100644 musicround/static/audio/5.mp3 create mode 100644 musicround/static/audio/6.mp3 create mode 100644 musicround/static/audio/7.mp3 create mode 100644 musicround/static/audio/8.mp3 create mode 100644 musicround/static/audio/intro.mp3 create mode 100644 musicround/static/audio/outro.mp3 create mode 100644 musicround/static/audio/replay.mp3 create mode 100644 musicround/static/css/style.css create mode 100644 musicround/static/favicon.ico create mode 100644 musicround/static/img/dark/logo.png create mode 100644 musicround/static/img/dark/logo_whitespace.png create mode 100644 musicround/static/img/dark/logotype.png create mode 100644 musicround/static/img/dark/monogram.png create mode 100644 musicround/static/img/light/logo.png create mode 100644 musicround/static/img/light/logo_whitespace.png create mode 100644 musicround/static/img/light/logotype.png create mode 100644 musicround/static/img/light/monogram.png create mode 100644 musicround/templates/admin/backup_manager.html create mode 100644 musicround/templates/admin/spotify_token_wizard.html create mode 100644 musicround/templates/admin/system_health.html create mode 100644 musicround/templates/admin/system_settings.html create mode 100644 musicround/templates/base.html create mode 100644 musicround/templates/browse_deezer_playlists.html create mode 100644 musicround/templates/build_music_round.html create mode 100644 musicround/templates/error.html create mode 100644 musicround/templates/homepage.html create mode 100644 musicround/templates/import_official_playlists.html create mode 100644 musicround/templates/import_playlist.html create mode 100644 musicround/templates/raw_playlists.html create mode 100644 musicround/templates/round.html create mode 100644 musicround/templates/round_detail.html create mode 100644 musicround/templates/rounds.html create mode 100644 musicround/templates/service_import.html create mode 100644 musicround/templates/service_search.html create mode 100644 musicround/templates/service_search_results.html create mode 100644 musicround/templates/spotify_client_test.html create mode 100644 musicround/templates/spotify_direct_auth.html create mode 100644 musicround/templates/users/audio_settings.html create mode 100644 musicround/templates/users/change_password.html create mode 100644 musicround/templates/users/edit_profile.html create mode 100644 musicround/templates/users/forgot_password.html create mode 100644 musicround/templates/users/login.html create mode 100644 musicround/templates/users/profile.html create mode 100644 musicround/templates/users/register.html create mode 100644 musicround/templates/users/reset_password.html create mode 100644 musicround/templates/users/spotify_link.html create mode 100644 musicround/templates/view_songs.html create mode 100644 musicround/version.py create mode 100644 requirements.txt create mode 100644 run.py create mode 100644 run_migration.py create mode 100644 tests/__init__.py create mode 100644 tests/test_metadata.py diff --git a/.env.demo b/.env.demo new file mode 100644 index 0000000..e5d4518 --- /dev/null +++ b/.env.demo @@ -0,0 +1,63 @@ +# Quizzical Beats - Environment Variables Demo File +# Copy this file to .env and replace with your actual values + +# Debug settings +DEBUG=True +DEBUG2=False +SECRET_KEY=your-secret-key-here-make-it-long-and-random + +# API Keys +OPENAI_API_KEY=your-openai-api-key +OPENAI_URL=https://api.openai.com/v1 +OPENAI_MODEL=gpt-4o-mini +OPENAI_SEARCH_MODEL=gpt-4o-mini-search-preview + +# Translation and language services +DEEPL_API_KEY=your-deepl-api-key +MEANINGCLOUD_API_KEY=your-meaningcloud-api-key + +# Audio services +ELEVENLABS_API_KEY=your-elevenlabs-api-key +ACRCLOUD_TOKEN=your-acrcloud-token + +# Music APIs +LASTFM_API_KEY=your-lastfm-api-key + +# Database configuration +SQLALCHEMY_DATABASE_URI=sqlite:///data/song_data.db +SQLALCHEMY_TRACK_MODIFICATIONS=False + +# Spotify API configuration +SPOTIFY_CLIENT_ID=your-spotify-client-id +SPOTIFY_CLIENT_SECRET=your-spotify-client-secret +SPOTIFY_REDIRECT_URI=http://localhost:5000/auth/spotify/callback + +# Deezer API configuration +DEEZER_APP_ID=your-deezer-app-id +DEEZER_APP_SECRET=your-deezer-app-secret +DEEZER_REDIRECT_URI=http://localhost:5000/deezer-callback + +# OAuth providers +# Google OAuth configuration +GOOGLE_CLIENT_ID=your-google-client-id +GOOGLE_CLIENT_SECRET=your-google-client-secret + +# Authentik OAuth configuration +AUTHENTIK_CLIENT_ID=your-authentik-client-id +AUTHENTIK_CLIENT_SECRET=your-authentik-client-secret +AUTHENTIK_METADATA_URL=https://authentik.example.com/.well-known/openid-configuration + +# Dropbox OAuth configuration +DROPBOX_APP_KEY=your-dropbox-app-key +DROPBOX_APP_SECRET=your-dropbox-app-secret +DROPBOX_REDIRECT_URI=http://localhost:5000/users/dropbox/callback + +# Email configuration +MAIL_HOST=smtp.example.com +MAIL_PORT=587 +MAIL_USE_TLS=True +MAIL_USE_SSL=False +MAIL_USERNAME=your-email-username +MAIL_PASSWORD=your-email-password +MAIL_SENDER=quizzical-beats@example.com +MAIL_RECIPIENT=admin@example.com \ No newline at end of file diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml new file mode 100644 index 0000000..048bb9d --- /dev/null +++ b/.github/workflows/docker-publish.yml @@ -0,0 +1,98 @@ +name: Docker + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +on: + schedule: + - cron: '30 21 * * *' + push: + branches: [ "main" ] + # Publish semver tags as releases. + tags: [ 'v*.*.*' ] + pull_request: + branches: [ "main" ] + +env: + # Use docker.io for Docker Hub if empty + REGISTRY: ghcr.io + # github.repository as / + IMAGE_NAME: ${{ github.repository }} + + +jobs: + build: + + runs-on: ubuntu-latest + permissions: + contents: read + packages: write + # This is used to complete the identity challenge + # with sigstore/fulcio when running outside of PRs. + id-token: write + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + # Install the cosign tool except on PR + # https://github.com/sigstore/cosign-installer + - name: Install cosign + if: github.event_name != 'pull_request' + uses: sigstore/cosign-installer@59acb6260d9c0ba8f4a2f9d9b48431a222b68e20 #v3.5.0 + with: + cosign-release: 'v2.2.4' + + # Set up BuildKit Docker container builder to be able to build + # multi-platform images and export cache + # https://github.com/docker/setup-buildx-action + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@f95db51fddba0c2d1ec667646a06c2ce06100226 # v3.0.0 + + # Login against a Docker registry except on PR + # https://github.com/docker/login-action + - name: Log into registry ${{ env.REGISTRY }} + if: github.event_name != 'pull_request' + uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0 + with: + registry: ${{ env.REGISTRY }} + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + # Extract metadata (tags, labels) for Docker + # https://github.com/docker/metadata-action + - name: Extract Docker metadata + id: meta + uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 # v5.0.0 + with: + images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }} + + # Build and push Docker image with Buildx (don't push on PR) + # https://github.com/docker/build-push-action + - name: Build and push Docker image + id: build-and-push + uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0 + with: + context: . + push: ${{ github.event_name != 'pull_request' }} + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + cache-from: type=gha + cache-to: type=gha,mode=max + + # Sign the resulting Docker image digest except on PRs. + # This will only write to the public Rekor transparency log when the Docker + # repository is public to avoid leaking data. If you would like to publish + # transparency data even for private images, pass --force to cosign below. + # https://github.com/sigstore/cosign + - name: Sign the published Docker image + if: ${{ github.event_name != 'pull_request' }} + env: + # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable + TAGS: ${{ steps.meta.outputs.tags }} + DIGEST: ${{ steps.build-and-push.outputs.digest }} + # This step uses the identity token to provision an ephemeral certificate + # against the sigstore community Fulcio instance. + run: echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..15201ac --- /dev/null +++ b/.gitignore @@ -0,0 +1,171 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# PyPI configuration file +.pypirc diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..d86b87b --- /dev/null +++ b/Dockerfile @@ -0,0 +1,33 @@ +# Use an official Python runtime as a parent image +FROM python:3.11-slim + +# Set the working directory to /app +WORKDIR /app + +# Install system dependencies and Node.js +RUN apt-get update && apt-get install -y \ + libavcodec-extra \ + ffmpeg \ + curl \ + gnupg \ + && rm -rf /var/lib/apt/lists/* + +# Copy requirements first for better caching +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copy application code +COPY . . + +# Make the entrypoint script executable +RUN chmod +x docker-entrypoint.sh + +# Create necessary directories and ensure proper permissions +RUN mkdir -p /data && chmod 777 /data + +# Set environment variables +ENV PYTHONPATH=/app +ENV FLASK_APP=run.py + +# Use the entrypoint script +ENTRYPOINT ["./docker-entrypoint.sh"] \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..3e5e7d2 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Christian Krakau-Louis + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..4aaa07d --- /dev/null +++ b/README.md @@ -0,0 +1,157 @@ +# MusicRound + +**MusicRound** is a Flask-based web application for building engaging music rounds for pub quizzes. Leveraging the Spotify API, it allows you to generate rounds based on the least-used genres, decades, or completely random criteria, making your quizzes dynamic and entertaining. + +--- + +## Features + +- **Spotify Integration**: Import songs and playlists directly from Spotify using their API. +- **Dynamic Round Creation**: + - Randomly generated songs. + - Based on least-used genres or decades. + - Unique and diverse song selections. +- **Preview and Export**: + - Include Spotify preview links in rounds. + - Export rounds as printable **PDFs** and playable **MP3s**. +- **Last.fm Integration**: Automatically enrich tracks with genre metadata. +- **Email Delivery**: Email generated quiz rounds to the designated recipient. + +--- + +## Getting Started + +### Prerequisites + +- **Python**: Version 3.6 or higher. +- **Spotify Developer Account**: [Create a Spotify Developer App](https://developer.spotify.com/dashboard/applications) to retrieve your client ID and secret. +- **Last.fm API Key**: Sign up at [Last.fm](https://www.last.fm/api) to obtain an API key. + +### Installation + +1. Clone the repository: + ```bash + git clone https://github.com/christianlouis/musicround.git + cd musicround + ``` + +2. Create a virtual environment: + ```bash + python3 -m venv venv + source venv/bin/activate + ``` + +3. Install dependencies: + ```bash + pip install -r requirements.txt + ``` + +4. Set up environment variables in a `.env` file: + ```env + SPOTIFY_CLIENT_ID=your_spotify_client_id + SPOTIFY_CLIENT_SECRET=your_spotify_client_secret + SPOTIFY_REDIRECT_URI=http://localhost:5000/callback + LASTFM_API_KEY=your_lastfm_api_key + ``` + +5. Initialize the SQLite database: + ```bash + python + >>> from app import db + >>> db.create_all() + >>> exit() + ``` + +6. Start the application: + ```bash + python app.py + ``` + +7. Open your browser and navigate to `http://localhost:5000`. + +--- + +## APIs Used + +- **Spotify API**: + - Used to import songs, playlists, and retrieve song metadata. + - [API Documentation](https://developer.spotify.com/documentation/web-api/) + +- **Last.fm API**: + - Enriches tracks with genre information. + - [API Documentation](https://www.last.fm/api) + +### Provided APIs + +**MusicRound** also provides APIs to fetch data from the application. For example: + +- `GET /rounds`: Fetch all rounds created. +- `POST /rounds`: Create a new round using specified criteria. +- `GET /songs`: Retrieve all songs in the database. + +For detailed API usage, refer to the in-app documentation or inspect the routes in `app.py`. + +--- + +## Changelog + +### Version 1.0 +- Initial release. +- Features: + - Spotify and Last.fm integration. + - Random, genre-based, and decade-based round generation. + - PDF and MP3 export functionality. + - Email delivery of rounds. + +--- + +## Project Structure + +``` +musicround/ +├── app.py # Main application logic +├── config.py # Configuration settings +├── templates/ # HTML templates for rendering views +├── static/ # Static files (CSS, JS) +├── requirements.txt # Python dependencies +├── instance/ # SQLite database folder +├── mp3/ # Audio files for MP3 generation +├── pdf_reports/ # Generated PDF reports +├── README.md # Project documentation +└── rounds/ # MP3 cache for quiz rounds +``` + +--- + +## License + +This project is licensed under the **MIT License**. See `LICENSE` for details. + +--- + +## Contributing + +We welcome contributions! To contribute: + +1. Fork the repository. +2. Create a feature branch: + ```bash + git checkout -b feature/your-feature-name + ``` +3. Commit your changes: + ```bash + git commit -m "Add your feature description" + ``` +4. Push the branch: + ```bash + git push origin feature/your-feature-name + ``` +5. Open a pull request. + +--- + +## Contact + +- **Developer**: Christian Krakau-Louis +- **Email**: [christian@kaufdeinquiz.com](mailto:christian@kaufdeinquiz.com) +- **GitHub**: [christianlouis](https://github.com/christianlouis) diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..3b767b5 --- /dev/null +++ b/TODO.md @@ -0,0 +1,166 @@ +# Quizzical Beats TODO List + +## ✅ Completed Milestones + +### Milestone 1: Spotify Integration Fix (Immediate Priority) + +* [x] Fix Spotify playlist import functionality + + * [x] Implement proper pagination for playlist retrieval + * [x] Add better error handling for API rate limits + * [x] Refactor Spotify client code for maintainability + * [x] Add logging to track API requests and responses for debugging + +### Milestone 2: Authentication Foundation + +* [x] Design database schema for users and roles +* [x] Implement basic authentication system with local username/password +* [x] Create user management interfaces (register, login, profile) +* [x] Set up admin role functionality +* [x] Implement secure password handling and session management + +### Milestone 3: Spotify Integration with User Accounts + +* [x] Migrate Spotify token storage to user-specific model +* [x] Add Spotify OAuth login option +* [x] Create fallback mechanism for service account +* [x] Link user playlists with their Spotify accounts + +### Milestone 4: Enhanced User Experience + +* [x] Enable user-specific intro/outro/replay MP3s +* [x] Update email system to use logged-in user's email +* [x] Implement user preferences and settings + +### Milestone 5: Additional OAuth Providers + +* [x] Add Google OAuth integration +* [x] Add Authentik OAuth integration +* [x] Ensure consistent user experience across auth methods + +### Milestone 6: Advanced Features & Optimizations + +* [x] Create comprehensive logging and monitoring + +### Milestone 7: **"Bulletproof Backups" Release** – System Backup & Restore + +* [x] Implement full system-wide backup and restore + + * [x] Backup all critical data: DB, rounds, MP3s, user settings + * [x] Support both manual and scheduled backups + * [x] Admin UI to download, manage, and restore backups + * [x] Store backups to local filesystem or optional cloud locations + * [x] Include versioning to support future schema migration compatibility + * [x] Add internal backup verification/checksum logic + * [x] Integrate with Ofelia scheduler for automatic backups + * [x] Add command-line backup functionality for scripting + * [x] Implement retention policy for automatic cleanup of old backups +* [x] Add system health check and status dashboard + +### Milestone 8: **"Dropbox Dispatch" Release** – Round Export via Dropbox + +* [x] Add Dropbox OAuth login per user +* [x] Let users link/unlink and view Dropbox account info +* [x] Export full rounds (metadata + MP3s) as ZIP or PDF +* [x] Push selected rounds to user's Dropbox via UI +* [x] Add fallback handling and Dropbox access token refresh +* [x] Log export actions and errors for transparency + +--- + +## 🆕 Upcoming Milestones + +### 🎯 Milestone 9: **"Storage Sanctuary" Release** – Multi-Provider Storage + +* [ ] Implement cloud storage backend abstraction +* [ ] Add support for AWS S3 storage + * [ ] Configure S3 credentials and bucket management + * [ ] Support for optional encryption and lifecycle policies +* [ ] Add support for S3-compatible storage (MinIO, Wasabi, etc.) +* [ ] Integrate Dropbox as a storage backend +* [ ] Create unified storage management UI +* [ ] Export backups to cloud storage +* [ ] Store and retrieve music rounds from cloud storage +* [ ] Add background synchronization and status tracking +* [ ] Implement bandwidth-efficient differential uploads + +### 🎯 Milestone 10: **"Rhythm Roundsmith" Release** – AI-Generated Quiz Rounds + +* [ ] Develop AI module to generate full quiz rounds + + * [ ] Use existing song metadata (genre, year, tempo, artist) + * [ ] Support different quiz formats: multiple-choice, guess-the-clip, open-ended + * [ ] Create quiz rounds from a playlist + * [ ] Let users prompt AI with a theme or vibe (e.g., "Chill 80s", "Dancefloor Divas") + * [ ] Include fallback logic when metadata is sparse +* [ ] Let users review/edit AI-generated questions before saving +* [ ] Log prompt/response pairs for model improvement +* [ ] Add backend abstraction to swap AI providers (OpenAI, Mistral, etc.) +* [ ] Build tuning pipeline for prompt quality testing + +### 🎯 Milestone 11: **"Collaboration Core" Release** – Multi-User Round Sharing + +* [ ] Allow shared editing of rounds +* [ ] Add collaboration roles (view, comment, edit) +* [ ] Invite others to rounds via username/email +* [ ] Show who is currently editing (presence indicator) +* [ ] Track revision history and changes +* [ ] Allow public view-only sharing links with optional expiration +* [ ] Display access audit log (who opened/edited and when) + +### 🎯 Milestone 12: **"Profile Personalizer" Release** – User Preferences & Tagging + +* [x] User-specific intro/outro/replay MP3 fallback system +* [x] Persistent custom user settings +* [ ] Let users define default round format +* [ ] Implement personal tags for rounds (e.g., "pub night", "2020s", "pop") +* [ ] Add filtering and sorting by tag +* [ ] Dark mode toggle + +### 🎯 Milestone 13: **"Scraper Symphony" Release** – External Music Data + +* [ ] Identify 2–3 public music chart sources (Billboard, Official Charts, etc.) +* [ ] Build scraper with user-agent rotation and proxy support +* [ ] Normalize results into song data model +* [ ] Link scraped data to existing Spotify records +* [ ] Review interface for admins to validate scraped data +* [ ] Store scraper runs and log errors transparently +* [ ] Add cron-based scheduler for scraper refresh + +### 🎯 Milestone 14: **"Alert Amplifier" Release** – Notifications & Emails + +* [ ] Email verification for new accounts +* [ ] Notify users when round generation completes +* [ ] Notify users of expiring OAuth tokens (Spotify, Dropbox) +* [ ] Optional weekly usage summary for admins +* [ ] Push notification support via browser or Telegram + +### 🎯 Milestone 15: **"Performance Pulse" Release** – Scaling & Speed + +* [ ] Index high-traffic database fields (tags, dates, users) +* [ ] Paginate round/song lists +* [ ] Lazy load MP3 previews and large content +* [ ] Add Redis/memory cache layer for read-heavy endpoints +* [ ] Load test with simulated users and large playlists + +### 🎯 Milestone 16: **"Deployment Dynamo" Release** – CI/CD and Maintenance + +* [ ] GitHub Actions or GitLab CI/CD pipeline for builds and tests +* [ ] Nightly backup job with status alert +* [ ] Add Sentry or similar for exception tracking +* [ ] Updater script for pulling latest Git commits safely +* [ ] Add status endpoint (`/healthz`) for uptime monitors + +--- + +## Other Features / Ideas in Progress + +* [ ] "Blind Test" toggle per round (hide title/artist metadata) +* [ ] Team scoreboard (live projection mode) +* [ ] Public round library with clone/save features +* [ ] REST API for third-party integration (e.g., with trivia bots) +* [ ] Audio fingerprint validation for user-uploaded MP3s +* [ ] Round analytics: usage frequency, popularity, ratings + +*Last updated: May 8, 2025* + diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..d1d2753 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,59 @@ +services: + web: + build: . + ports: + - "5000:5000" + volumes: + - ./musicround:/app/musicround + - ./templates:/app/templates + - ./static:/app/static + - ./migrations:/app/migrations + - ./.env:/app/.env + - musicround_data:/data + labels: + ofelia.enabled: "true" + ofelia.job-exec.backup.schedule: "@hourly" + ofelia.job-exec.backup.command: "python /app/run.py backup create --auto" + ofelia.job-exec.backup.no-overlap: "true" + ofelia.job-exec.retention.schedule: "@weekly" + ofelia.job-exec.retention.command: "python /app/run.py backup retention --days 13" + ofelia.job-exec.retention.no-overlap: "true" + env_file: + - .env + environment: + - FLASK_APP=run.py + - FLASK_ENV=development # Using the older style for compatibility + - FLASK_DEBUG=1 + - SQLALCHEMY_DATABASE_URI=sqlite:///data/song_data.db + - PYTHONUNBUFFERED=1 + # Hot reloading specific settings + - FLASK_RUN_EXTRA_FILES=./templates:/app/templates,./static:/app/static + - FLASK_RUN_HOST=0.0.0.0 + - FLASK_RUN_PORT=5000 + - PYTHONDONTWRITEBYTECODE=1 + # Email configuration variables + - MAIL_HOST=${MAIL_HOST} + - MAIL_PORT=${MAIL_PORT} + - MAIL_USERNAME=${MAIL_USERNAME} + - MAIL_PASSWORD=${MAIL_PASSWORD} + - MAIL_SENDER=${MAIL_SENDER} + - MAIL_RECIPIENT=${MAIL_RECIPIENT} + restart: unless-stopped + # Updated command with explicit extra-files and reload arguments + command: python -m flask run --host=0.0.0.0 --port=5000 --reload --extra-files ./templates:/app/templates,./static:/app/static + + scheduler: + image: mcuadros/ofelia:latest + depends_on: + - web + volumes: + - /var/run/docker.sock:/var/run/docker.sock:ro + restart: unless-stopped + command: daemon --docker + labels: + ofelia.job-local.my-test-job.schedule: "@hourly" + ofelia.job-local.my-test-job.command: "date" + +volumes: + musicround_data: + driver: local \ No newline at end of file diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh new file mode 100644 index 0000000..3d7b430 --- /dev/null +++ b/docker-entrypoint.sh @@ -0,0 +1,27 @@ +#!/bin/bash +set -e + +# Run the OAuth migration script first +echo "Running database migration for OAuth providers..." +python run_migration.py + +# Start the Flask application with better error reporting +echo "Starting Flask application..." +export PYTHONUNBUFFERED=1 +export FLASK_DEBUG=1 +echo "Flask environment: $FLASK_ENV" +echo "Database URI: $SQLALCHEMY_DATABASE_URI" +echo "Database path: $DATABASE_PATH" +echo "Available environment variables:" +env | grep -v PASSWORD | grep -v SECRET + +# Use flask run with explicit reload for better hot reloading +export PYTHONFAULTHANDLER=1 +export PYTHONDONTWRITEBYTECODE=1 + +echo "Starting Flask development server with hot reload..." +exec python -m flask run --host=0.0.0.0 --port=5000 --reload --debug || { + echo "Flask application failed to start. Error details:" + python -c "import traceback; traceback.print_exc()" + exit 1 +} \ No newline at end of file diff --git a/docs/brand_identity.md b/docs/brand_identity.md new file mode 100644 index 0000000..067dc2f --- /dev/null +++ b/docs/brand_identity.md @@ -0,0 +1,72 @@ +# 🎧 Quizzical Beats – Brand Identity + +## 🧠 Tagline + +**Primary:** +> *"Where trivia meets the rhythm."* + +**Alternate options:** +- "The soundtrack to your smartest guesses." +- "Play the quiz. Feel the beat." + +--- + +## 🎯 Mission Statement + +*Quizzical Beats empowers quiz hosts to create unforgettable music rounds that blend knowledge and rhythm. We make music-based trivia engaging, easy to set up, and endlessly fun for players of all ages.* + +--- + +## 🌍 Purpose Statement + +*We aim to make pub quizzes more interactive and exciting by elevating the music round. Whether you're a professional quizmaster or a casual host, Quizzical Beats provides the tools to bring sound, style, and smarts together.* + +--- + +## 🎨 Color Scheme + +| Color | Usage | Hex Code | Description | +|------------------|----------------------------|-----------|-----------------------------| +| Deep Navy Blue | Primary text/logo | `#1A237E` | Bold, trustworthy, smart | +| Vibrant Teal | Accents/highlights | `#00ACC1` | Energetic, fresh, modern | +| Bright Orange | Call-to-actions/buttons | `#FF7043` | Playful, attention-grabbing | +| Light Gray | Background/secondary UI | `#F5F5F5` | Clean, soft, minimalist | +| Dark Gray | Text/subtle UI elements | `#212121` | Contrast, structure | + +--- + +## 🖋️ Typography + +**Primary Font:** Montserrat +> Modern, geometric sans-serif font with excellent readability. + +**Secondary Font:** Open Sans +> Humanist sans-serif for body copy and UI elements. + +--- + +## 🖼️ Visual Assets + +- ✅ **Logo:** Stylized note and magnifying glass, symbolizing *music + discovery* +- ✅ **Textlogo:** “Quizzical Beats” in bold *Montserrat* +- ✅ **Monogram:** Clean *"QB"* + musical-symbol monogram + +--- + +## 🔧 Optional Brand Assets + +Would you like any of the following? + +- [ ] Favicon pack (.ico, .png, .svg) +- [ ] Social media banners (e.g., Twitter/X, YouTube, Instagram) +- [ ] Brand style guide (PDF) +- [ ] Pitch deck slide template or Keynote theme + +--- + +## 🔊 Voice & Tone + +- Friendly and playful +- Confident but not arrogant +- Fun, musical, and clever +- Inclusive for all trivia lovers diff --git a/docs/oauth_callback_urls.md b/docs/oauth_callback_urls.md new file mode 100644 index 0000000..4cb5440 --- /dev/null +++ b/docs/oauth_callback_urls.md @@ -0,0 +1,106 @@ +# OAuth Integration Callback URLs + +This document provides information about the OAuth callback URLs used in Quizzical Beats for various authentication providers. + +## Overview + +When configuring OAuth providers (Google, Authentik, Spotify, Dropbox), you need to set up redirect/callback URLs in each provider's developer console. These URLs tell the provider where to send users after they authenticate. + +## Callback URLs by Provider + +### Google OAuth + +**Callback URL:** `https://your-domain.com/users/login/google/callback` +**Local Development:** `http://localhost:5000/users/login/google/callback` + +When configuring Google OAuth in the Google Cloud Console: +1. Go to "APIs & Services" > "Credentials" +2. Create or edit an OAuth 2.0 Client ID +3. Add the above URLs to the "Authorized redirect URIs" section + +### Authentik OAuth + +**Callback URL:** `https://your-domain.com/users/login/authentik/callback` +**Local Development:** `http://localhost:5000/users/login/authentik/callback` + +When configuring Authentik: +1. Create an OAuth2/OIDC Provider +2. Add the above URLs to the "Redirect URIs" field +3. Ensure the scopes include "openid", "profile", and "email" + +### Spotify API + +**Callback URL:** `https://your-domain.com/users/spotify-callback` +**Local Development:** `http://localhost:5000/users/spotify-callback` + +When configuring Spotify in the Spotify Developer Dashboard: +1. Go to your app's settings +2. Add the above URLs to the "Redirect URIs" section +3. Save the changes + +### Dropbox API + +**Callback URL:** `https://your-domain.com/users/dropbox-callback` +**Local Development:** `http://localhost:5000/users/dropbox-callback` + +When configuring Dropbox in the Dropbox Developer Console: +1. Go to your app's settings in the [Dropbox App Console](https://www.dropbox.com/developers/apps) +2. Under "OAuth 2", add the above URLs to the "Redirect URIs" section +3. Make sure you've selected the correct permission scopes: + - `files.content.read` + - `files.content.write` + - `sharing.write` + - `offline_access` (for refresh tokens) +4. Set the app status to "Production" if it's still in development mode +5. In the "Permissions" tab, ensure all required scopes are selected + +## Environment Variables + +Make sure to update the following environment variables in your `.env` file to match your configured callback URLs: + +``` +# For Google OAuth +GOOGLE_REDIRECT_URI=http://localhost:5000/users/login/google/callback + +# For Authentik OAuth +AUTHENTIK_REDIRECT_URI=http://localhost:5000/users/login/authentik/callback + +# For Spotify API +SPOTIFY_REDIRECT_URI=http://localhost:5000/users/spotify-callback + +# For Dropbox API +# DROPBOX_REDIRECT_URI=http://localhost:5000/users/dropbox-callback +# Note: The Dropbox URL is automatically generated using Flask's url_for function +``` + +In production, update these URLs to use your actual domain. + +## Additional Notes + +1. Make sure your application is properly configured to handle these callback routes. +2. For security, always use HTTPS URLs in production environments. +3. When testing locally with HTTP, some providers may require you to explicitly allow HTTP redirects for development. +4. If you're using Docker or other containerization, ensure your application is accessible at the configured URLs. +5. Dropbox requires the app to be in "Production" mode for non-developers to use it. + +## Troubleshooting + +If you encounter OAuth errors such as "invalid_redirect_uri" or "redirect_uri_mismatch": + +1. Verify that the callback URL is exactly the same in both your OAuth provider configuration and your application code. +2. Check that the protocol (http vs https) matches what's configured. +3. Ensure there are no trailing slashes unless specifically required. +4. For development behind NAT/firewalls, you may need to use a service like ngrok to create a public URL. +5. Check that the response data format matches what your code expects. For Google OAuth, ensure your code is accessing fields correctly (Google uses 'sub' for user IDs rather than 'id'). +6. Enable debug logging to inspect the full OAuth response payload to identify missing or incorrectly named fields. +7. Verify that your OAuth scopes in the provider configuration match the scopes requested in your application code. +8. Test with a minimal set of scopes first, then add more as needed once the basic flow works. + +### Dropbox-Specific Troubleshooting + +If you see "This app is not valid" error from Dropbox: +1. Make sure your app is configured in the [Dropbox App Console](https://www.dropbox.com/developers/apps) +2. Verify that your app key and app secret in your config match what's in the Dropbox console +3. Ensure your redirect URI is correctly registered in the Dropbox console +4. Check if your app needs to be in "Production" mode (it may be in development mode) +5. Verify that you've selected all required permission scopes in the Dropbox console \ No newline at end of file diff --git a/favicon.ico b/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..460e978b68064762f9b444cb63f95d2c56db6e97 GIT binary patch literal 4158 zcmc&%StxZ~7(Qm16ThMGnMGWXLc$FaMG=u)xS%Lxh%4bnLXPx*8Ep-}$+Q25y>6#pp{3P0uL zro3X57yBtS)(VAZ(Ay5UZ*LFdEUa+Iqz5H;o$+p!^4P5r3&f|RId`FItk5N!iAlC8`$7ky`+31cHIE$xr2^*tSlFBgLi4Gl0bF!-z7#3zrsEH5v^)z$Tn@G`z) zVq)Ow=_!jx9`aFMUtdvLS}Hs4JMm^?V}r!RM2w7#;PLSh{r&w~bwKh(Sy`Fj-Q3(1 zH9_i^+K7kVOxKtKRIJUrm;?hZdcKZJ*eBQrA-O-)T$SXjXQ{k>Sv z;o%{2a&lzXLwwdC@^*H1!pO)-Yg|c5iNKL;L)`Q8bCIh@M@Kk2JHy@GozS0SSaVlb zS5aSI4}X9E4|9}!t3kySje!f<%A@66gM&DalScuqSUNXm- zL-Y${k9AD51~Im|cXV}i2|a1J!NEZ=Hl%fvS2M?0bCZ&igiqt+<3$~zj&il0oIEGk z+1Ux5Qc_YxzRk|g;_B+^CtvYQWol}w;wGJ-O{Jf|dd~Q1VQLSoal5;_=T!E}i 0: + logger.info(f"Successfully added {columns_added} new columns to the database.") + else: + logger.info("No new columns needed to be added.") + + logger.info("Migration add_spotify_audio_features completed successfully") + return True + + except Exception as e: + logger.error(f"Migration add_spotify_audio_features failed: {str(e)}") + import traceback + logger.error(traceback.format_exc()) + return False + +if __name__ == "__main__": + # Set up logging when run directly + logging.basicConfig(level=logging.INFO) + run_migration() \ No newline at end of file diff --git a/migrations/add_tag_system.py b/migrations/add_tag_system.py new file mode 100644 index 0000000..223772a --- /dev/null +++ b/migrations/add_tag_system.py @@ -0,0 +1,146 @@ +"""Add tag system for songs + +Revision ID: e7c912b4d835 +Revises: d82c9a4f1e56 +Create Date: 2025-04-22 10:34:56.789012 + +""" +from alembic import op +import sqlalchemy as sa + +# revision identifiers, used by Alembic. +revision = 'e7c912b4d835' +down_revision = 'd82c9a4f1e56' # previous migration was add_preview_urls +branch_labels = None +depends_on = None + +def upgrade(): + # Create tag table + op.create_table('tag', + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('name', sa.String(length=50), nullable=False), + sa.Column('created_at', sa.DateTime(), nullable=True), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('name') + ) + + # Create song_tag mapping table + op.create_table('song_tag', + sa.Column('song_id', sa.Integer(), nullable=False), + sa.Column('tag_id', sa.Integer(), nullable=False), + sa.Column('created_at', sa.DateTime(), nullable=True), + sa.ForeignKeyConstraint(['song_id'], ['song.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['tag_id'], ['tag.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('song_id', 'tag_id') + ) + + # Create indexes for faster lookups + op.create_index(op.f('ix_song_tag_song_id'), 'song_tag', ['song_id'], unique=False) + op.create_index(op.f('ix_song_tag_tag_id'), 'song_tag', ['tag_id'], unique=False) + +def downgrade(): + # Drop the indexes first + op.drop_index(op.f('ix_song_tag_tag_id'), table_name='song_tag') + op.drop_index(op.f('ix_song_tag_song_id'), table_name='song_tag') + + # Drop the tables + op.drop_table('song_tag') + op.drop_table('tag') + +def run_migration(): + """ + Add tag and song_tag tables for the tag system if they don't exist. + """ + import sqlite3 + import os + import logging + + logger = logging.getLogger(__name__) + logger.info("Running migration: add_tag_system") + + # Try to get the database path from Flask config first + try: + from flask import current_app + if current_app and current_app.config.get('SQLALCHEMY_DATABASE_URI'): + # Extract path from URI + db_uri = current_app.config['SQLALCHEMY_DATABASE_URI'] + if db_uri.startswith('sqlite:///'): + db_path = db_uri[10:] # Remove 'sqlite:///' + logger.info(f"Got database path from Flask config: {db_path}") + else: + # Use DATABASE_PATH if available + db_path = current_app.config.get('DATABASE_PATH', '/data/song_data.db') + logger.info(f"Using DATABASE_PATH: {db_path}") + else: + # If Flask isn't running, try Docker standard path + db_path = '/data/song_data.db' + logger.info(f"Flask not available, using default path: {db_path}") + except Exception as e: + # Fallbacks in case Flask isn't available + logger.warning(f"Could not get path from Flask: {str(e)}") + + # Try environment variable + db_path = os.environ.get('DATABASE_PATH', '/data/song_data.db') + logger.info(f"Using DATABASE_PATH from environment: {db_path}") + + if not os.path.exists(db_path): + logger.warning(f"Database not found at {db_path}") + return False + + try: + # Connect to the database + logger.info(f"Connecting to database at: {db_path}") + conn = sqlite3.connect(db_path) + cursor = conn.cursor() + + # Check if tables exist + cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='tag'") + tag_table_exists = cursor.fetchone() is not None + + cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='song_tag'") + song_tag_table_exists = cursor.fetchone() is not None + + # Create tag table if it doesn't exist + if not tag_table_exists: + cursor.execute(''' + CREATE TABLE tag ( + id INTEGER PRIMARY KEY, + name VARCHAR(50) NOT NULL UNIQUE, + created_at DATETIME DEFAULT CURRENT_TIMESTAMP + ) + ''') + logger.info("Created table: tag") + else: + logger.info("Table already exists: tag") + + # Create song_tag table if it doesn't exist + if not song_tag_table_exists: + cursor.execute(''' + CREATE TABLE song_tag ( + song_id INTEGER NOT NULL, + tag_id INTEGER NOT NULL, + created_at DATETIME DEFAULT CURRENT_TIMESTAMP, + PRIMARY KEY (song_id, tag_id), + FOREIGN KEY (song_id) REFERENCES song (id) ON DELETE CASCADE, + FOREIGN KEY (tag_id) REFERENCES tag (id) ON DELETE CASCADE + ) + ''') + logger.info("Created table: song_tag") + else: + logger.info("Table already exists: song_tag") + + # Commit changes and close connection + conn.commit() + conn.close() + logger.info("Migration add_tag_system completed successfully") + return True + + except Exception as e: + logger.error(f"Migration add_tag_system failed: {str(e)}") + return False + +if __name__ == "__main__": + # Set up logging when run directly + import logging + logging.basicConfig(level=logging.INFO) + run_migration() \ No newline at end of file diff --git a/musicround/__init__.py b/musicround/__init__.py new file mode 100644 index 0000000..c35843c --- /dev/null +++ b/musicround/__init__.py @@ -0,0 +1,367 @@ +import os +import logging +import importlib.util +from flask import Flask, session, redirect, url_for, request +from flask_login import LoginManager, current_user +from flask_sqlalchemy import SQLAlchemy +from flask_wtf.csrf import CSRFProtect +from dotenv import load_dotenv +from werkzeug.middleware.proxy_fix import ProxyFix +from importlib import import_module +import spotipy +from spotipy.oauth2 import SpotifyOAuth +from musicround.config import Config +from musicround.version import VERSION_INFO, get_version_str + +# Initialize SQLAlchemy +db = SQLAlchemy() +login_manager = LoginManager() +csrf = CSRFProtect() + +# Set up logging +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') +logger = logging.getLogger(__name__) + +def run_migrations(): + """ + Run all migration scripts in the migrations directory + """ + logger.info("Running database migrations...") + + # Path to migrations directory + migrations_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'migrations') + if not os.path.isdir(migrations_dir): + logger.warning(f"Migrations directory not found at {migrations_dir}") + return + + # Get all Python files in the migrations directory + migration_files = [f for f in os.listdir(migrations_dir) + if f.endswith('.py') and not f.startswith('__')] + + if not migration_files: + logger.info("No migration scripts found") + return + + # Run each migration script + migration_errors = False + + for migration_file in sorted(migration_files): + try: + logger.info(f"Loading migration: {migration_file}") + file_path = os.path.join(migrations_dir, migration_file) + + # Load the module dynamically + spec = importlib.util.spec_from_file_location( + f"migrations.{migration_file[:-3]}", file_path) + if spec and spec.loader: + migration_module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(migration_module) + + # Check if the module has a run_migration function + if hasattr(migration_module, "run_migration"): + logger.info(f"Executing migration: {migration_file}") + result = migration_module.run_migration() + + # Handle the three possible return values: + # True: changes were made successfully + # None: no changes needed (already up to date) + # False: errors occurred + if result is True: + logger.info(f"Migration {migration_file} completed successfully") + elif result is None: + logger.info(f"Migration {migration_file} reported no changes needed") + else: + logger.warning(f"Migration {migration_file} reported errors") + migration_errors = True + else: + logger.warning(f"Migration {migration_file} doesn't have run_migration() function") + else: + logger.warning(f"Could not load migration module: {migration_file}") + except Exception as e: + logger.error(f"Error running migration {migration_file}: {str(e)}") + migration_errors = True + + if migration_errors: + logger.warning("Some migrations encountered errors, but the application will continue to start") + else: + logger.info("All migrations completed") + +def create_app(config=None): + """ + Factory pattern for creating the Flask app + """ + # Load environment variables + load_dotenv() + + # Create Flask app + app = Flask(__name__, instance_relative_config=True) + + # Configure ProxyFix for reverse proxy (e.g., Nginx) + app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1) + + # Create data directory if it doesn't exist + data_dir = '/data' + if not os.path.exists(data_dir): + os.makedirs(data_dir, exist_ok=True) + + # Set the database file path in the data directory + db_path = os.path.join(data_dir, 'song_data.db') + + # Configure the app + app.config.from_object(Config) + + # Explicitly set the database URI to ensure correct path + app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{db_path}' + + # Initialize extensions with app + db.init_app(app) + csrf.init_app(app) + + # Register custom Jinja filters + @app.template_filter('timestamp_to_datetime') + def timestamp_to_datetime(timestamp): + """Convert a Unix timestamp or ISO datetime string to a datetime object""" + from datetime import datetime + + if isinstance(timestamp, str): + try: + # Try to parse as ISO format string + return datetime.fromisoformat(timestamp) + except (ValueError, TypeError): + try: + # Try to convert to float first then use as timestamp + return datetime.fromtimestamp(float(timestamp)) + except (ValueError, TypeError): + return None + elif timestamp is None: + return None + else: + # Assume it's a numeric timestamp + try: + return datetime.fromtimestamp(timestamp) + except (ValueError, TypeError): + return None + + @app.template_filter('format_datetime') + def format_datetime(dt, format='%Y-%m-%d %H:%M:%S'): + """Format a datetime object to a string""" + if not dt: + return "Unknown" + return dt.strftime(format) + + # Set up the Flask-Login extension + login_manager.login_view = 'users.login' + login_manager.login_message_category = 'info' + login_manager.login_message = 'Please log in to access this page.' + login_manager.init_app(app) + + # Add version info to template context + @app.context_processor + def inject_version(): + from musicround.version import get_version_str, VERSION_INFO + return { + 'get_version_str': get_version_str, + 'version_info': VERSION_INFO + } + + # Import User model here to avoid circular imports + from musicround.models import User + + @login_manager.user_loader + def load_user(user_id): + return User.query.get(int(user_id)) + + # Ensure instance folder exists + try: + os.makedirs(app.instance_path, exist_ok=True) + except OSError: + pass + + # Initialize OAuth providers (Google, Authentik) + from musicround.helpers.auth_helpers import init_oauth + init_oauth(app) + + # Initialize Spotify client for common API access + # This will be available for any authenticated route + if app.config['SPOTIFY_CLIENT_ID'] and app.config['SPOTIFY_CLIENT_SECRET']: + app.config['sp_oauth'] = SpotifyOAuth( + client_id=app.config['SPOTIFY_CLIENT_ID'], + client_secret=app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=app.config['SPOTIFY_REDIRECT_URI'], + scope=app.config['SPOTIFY_SCOPE'] + ) + # Create a Spotify client that will be used throughout the app + app.config['sp'] = spotipy.Spotify(auth_manager=app.config['sp_oauth']) + +# Initialize Deezer client - import inside the function to avoid circular dependency + from musicround.deezer_client import DeezerClient + app.config['deezer'] = DeezerClient() + + # Add before_request handler to ensure Spotify token is available + @app.before_request + def ensure_spotify_token(): + """ + Ensure a valid Spotify token is available in the session. + Priority: + 1. Use existing manual bearer token if present in session + 2. Try to refresh user's token if they have a refresh token + 3. Use client credentials flow as fallback (no user login required) + """ + # Skip for static files and certain paths + if request.path.startswith('/static') or request.path.startswith('/favicon.ico'): + return + + # If we already have a manual token in session, don't do anything + # Manual tokens take priority over everything else + if 'access_token' in session and session.get('token_source') != 'user' and session.get('token_source') != 'client_credentials': + app.logger.debug("Using existing manual bearer token") + return + + from datetime import datetime + from spotipy.oauth2 import SpotifyOAuth + from .models import SystemSetting + import base64 + import requests + + try: + # Only check user token if user is logged in + if current_user.is_authenticated: + # Step 1: Try to use user's refresh token + if current_user.spotify_refresh_token: + app.logger.debug(f"Attempting to refresh token for user {current_user.username}") + + # Create OAuth manager for token refresh + sp_oauth = SpotifyOAuth( + client_id=app.config['SPOTIFY_CLIENT_ID'], + client_secret=app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=url_for('users.spotify_callback', _external=True), + scope=app.config['SPOTIFY_SCOPE'] + ) + + try: + # Refresh user's token + token_info = sp_oauth.refresh_access_token(current_user.spotify_refresh_token) + + if token_info and 'access_token' in token_info: + # Update user's tokens in database + current_user.spotify_token = token_info['access_token'] + current_user.spotify_token_expiry = datetime.fromtimestamp(token_info['expires_at']) + + # If we got a new refresh token (rare but possible), update it + if 'refresh_token' in token_info: + current_user.spotify_refresh_token = token_info['refresh_token'] + + # Save to database + db.session.commit() + + # Store token in session + session['access_token'] = token_info['access_token'] + session['token_source'] = 'user' + + app.logger.debug(f"Generated new token for user {current_user.username}") + return + except Exception as e: + app.logger.warning(f"Failed to refresh user token: {str(e)}") + + # Step 2: If no user token or user not logged in, use client credentials flow + # Check if we already have a valid client credentials token + client_token_expiry = session.get('client_token_expiry', 0) + + if 'access_token' in session and session.get('token_source') == 'client_credentials' and client_token_expiry > datetime.now().timestamp(): + app.logger.debug("Using existing client credentials token") + return + + # Get client credentials from config + client_id = app.config['SPOTIFY_CLIENT_ID'] + client_secret = app.config['SPOTIFY_CLIENT_SECRET'] + + if client_id and client_secret: + app.logger.debug("Getting new token via client credentials flow") + + # Encode client credentials + auth_header = base64.b64encode(f"{client_id}:{client_secret}".encode()).decode() + + # Prepare headers and payload + headers = { + 'Authorization': f'Basic {auth_header}', + 'Content-Type': 'application/x-www-form-urlencoded' + } + data = { + 'grant_type': 'client_credentials' + } + + try: + # Make the POST request + response = requests.post('https://accounts.spotify.com/api/token', headers=headers, data=data) + response.raise_for_status() + + token_data = response.json() + + if 'access_token' in token_data: + # Store the token in session + session['access_token'] = token_data['access_token'] + session['token_source'] = 'client_credentials' + + # Calculate and store expiry time (typically 1 hour from now) + expires_in = token_data.get('expires_in', 3600) # Default to 1 hour + expiry_timestamp = datetime.now().timestamp() + expires_in + session['client_token_expiry'] = expiry_timestamp + + app.logger.debug("Successfully obtained client credentials token") + return + else: + app.logger.warning("No access token in client credentials response") + + except Exception as e: + app.logger.error(f"Error getting client credentials token: {str(e)}") + + except Exception as e: + app.logger.error(f"Error in ensure_spotify_token: {str(e)}") + pass # Continue without a token if all methods fail + + # Register blueprints + from musicround.routes.core import core_bp + from musicround.routes.users import users_bp + from musicround.routes.import_songs import import_songs_bp + from musicround.routes.rounds import rounds_bp + from musicround.routes.generate import generate_bp + from musicround.routes.api import api_bp + from musicround.routes.import_routes import import_bp + from musicround.routes.process import process_bp + from musicround.routes.deezer_routes import deezer_bp + from musicround.routes.db_admin import db_admin_bp, init_admin + from musicround.routes.auth import auth_bp + + app.register_blueprint(core_bp) + app.register_blueprint(users_bp) + app.register_blueprint(import_songs_bp) + app.register_blueprint(rounds_bp) + app.register_blueprint(generate_bp) + app.register_blueprint(api_bp) + app.register_blueprint(import_bp) + app.register_blueprint(process_bp) + app.register_blueprint(deezer_bp) + app.register_blueprint(db_admin_bp) + app.register_blueprint(auth_bp) + + # Initialize the admin interface + init_admin(app) + + # Register error handlers + from musicround.errors import register_error_handlers + register_error_handlers(app) + + # Try to create database tables if they don't exist + with app.app_context(): + try: + db.create_all() + logger.info("Database tables created successfully during app initialization") + + # Run migrations after tables are created + run_migrations() + except Exception as e: + logger.error(f"Error creating database tables during app initialization: {e}") + + # Return the app + return app + diff --git a/musicround/config.py b/musicround/config.py new file mode 100644 index 0000000..58ce92f --- /dev/null +++ b/musicround/config.py @@ -0,0 +1,75 @@ +import os +import openai +from dotenv import load_dotenv +import tempfile +from datetime import timedelta + +# Load environment variables from .env file +load_dotenv() + +# Set up OpenAI API key +openai.api_key = os.getenv("OPENAI_API_KEY") + +# Get the base directory of the application +basedir = os.path.abspath(os.path.dirname(__file__)) + +class Config: + # Debug settings + DEBUG = os.getenv("DEBUG", "True") == "True" + DEBUG2 = os.getenv("DEBUG2", "False") == "True" + SECRET_KEY = os.getenv('SECRET_KEY', 'dev-key-please-change') + + # API Keys + OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") + DEEPL_API_KEY = os.getenv("DEEPL_API_KEY") + MEANINGCLOUD_API_KEY = os.getenv("MEANINGCLOUD_API_KEY") + LASTFM_API_KEY = os.getenv("LASTFM_API_KEY") + ACRCLOUD_TOKEN = os.getenv("ACRCLOUD_TOKEN") + ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY") + OPENAI_URL = os.getenv("OPENAI_URL", "https://api.openai.com/v1") + OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini") + OPENAI_SEARCH_MODEL = os.getenv("OPENAI_SEARCH_MODEL", "gpt-4o-mini-search") + + SQLALCHEMY_DATABASE_URI = os.environ.get('SQLALCHEMY_DATABASE_URI') + SQLALCHEMY_TRACK_MODIFICATIONS = False + + + # Spotify API credentials + SPOTIFY_CLIENT_ID = os.getenv("SPOTIFY_CLIENT_ID") + SPOTIFY_CLIENT_SECRET = os.getenv("SPOTIFY_CLIENT_SECRET") + SPOTIFY_REDIRECT_URI = os.getenv("SPOTIFY_REDIRECT_URI") + SPOTIFY_SCOPE = "playlist-read-private playlist-read-collaborative user-library-read user-top-read" + + # Deezer API credentials + DEEZER_APP_ID = os.getenv("DEEZER_APP_ID", "") + DEEZER_APP_SECRET = os.getenv("DEEZER_APP_SECRET", "") + DEEZER_REDIRECT_URI = os.getenv("DEEZER_REDIRECT_URI", "http://localhost:5000/deezer-callback") + + # Google OAuth credentials + GOOGLE_CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID", "") + GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET", "") + + # Authentik OAuth credentials + AUTHENTIK_CLIENT_ID = os.getenv("AUTHENTIK_CLIENT_ID", "") + AUTHENTIK_CLIENT_SECRET = os.getenv("AUTHENTIK_CLIENT_SECRET", "") + AUTHENTIK_METADATA_URL = os.getenv("AUTHENTIK_METADATA_URL", "") + + # Dropbox OAuth credentials + DROPBOX_APP_KEY = os.getenv("DROPBOX_APP_KEY", "") + DROPBOX_APP_SECRET = os.getenv("DROPBOX_APP_SECRET", "") + DROPBOX_REDIRECT_URI = os.getenv("DROPBOX_REDIRECT_URI", "http://localhost:5000/users/dropbox/callback") + + MAIL_HOST = os.getenv("MAIL_HOST", "localhost") + MAIL_PORT = os.getenv("MAIL_PORT", 25) + MAIL_USE_TLS = os.getenv("MAIL_USE_TLS", "False") == "True" + MAIL_USE_SSL = os.getenv("MAIL_USE_SSL", "False") == "True" + MAIL_USERNAME = os.getenv("MAIL_USERNAME", "") + MAIL_PASSWORD = os.getenv("MAIL_PASSWORD", "") + MAIL_SENDER = os.getenv("MAIL_SENDER", "quizzical-beats@example.com") + MAIL_RECIPIENT = os.getenv("MAIL_RECIPIENT", "admin@example.com") + + # Automation settings + AUTOMATION_TOKEN = os.getenv("AUTOMATION_TOKEN", "change-this-token-in-production") + + + diff --git a/musicround/deezer_client.py b/musicround/deezer_client.py new file mode 100644 index 0000000..45748d8 --- /dev/null +++ b/musicround/deezer_client.py @@ -0,0 +1,252 @@ +import os +import requests +import logging +import random +import time +from flask import current_app +from musicround.models import Song, db + +logger = logging.getLogger(__name__) + +class DeezerClient: + """ + Client for interacting with the Deezer API + Handles searching and importing songs, albums, and playlists + """ + + def __init__(self): + self.base_url = "https://api.deezer.com" + self.logger = logging.getLogger(__name__) + + def _make_request(self, endpoint, params=None): + """Make a GET request to the Deezer API""" + url = f"{self.base_url}/{endpoint}" + try: + response = requests.get(url, params=params) + response.raise_for_status() + return response.json() + except requests.RequestException as e: + self.logger.error(f"Deezer API request error: {e}") + return None + + def search_tracks(self, query, limit=50): + """Search for tracks on Deezer""" + params = { + 'q': query, + 'limit': limit + } + result = self._make_request('search/track', params=params) + if result and 'data' in result: + return result['data'] + return [] + + def search_albums(self, query, limit=25): + """Search for albums on Deezer""" + params = { + 'q': query, + 'limit': limit + } + result = self._make_request('search/album', params=params) + if result and 'data' in result: + return result['data'] + return [] + + def search_playlists(self, query, limit=25): + """Search for playlists on Deezer""" + params = { + 'q': query, + 'limit': limit + } + result = self._make_request('search/playlist', params=params) + if result and 'data' in result: + return result['data'] + return [] + + def get_track(self, track_id): + """Get details for a specific track""" + return self._make_request(f'track/{track_id}') + + def get_album(self, album_id): + """Get details for a specific album""" + return self._make_request(f'album/{album_id}') + + def get_album_tracks(self, album_id): + """Get tracks from a specific album""" + result = self._make_request(f'album/{album_id}/tracks') + if result and 'data' in result: + return result['data'] + return [] + + def get_playlist(self, playlist_id): + """Get details for a specific playlist""" + return self._make_request(f'playlist/{playlist_id}') + + def get_playlist_tracks(self, playlist_id): + """Get tracks from a specific playlist""" + result = self._make_request(f'playlist/{playlist_id}/tracks') + if result and 'data' in result: + return result['data'] + return [] + + def get_popular_playlists(self, limit=30): + """ + Get popular playlists from Deezer + This uses a set of predetermined searches to find popular playlists + """ + playlists = [] + search_terms = ['hits', 'top', 'chart', 'popular', 'best', 'essential'] + + # Search for each term and combine results + for term in search_terms: + results = self.search_playlists(term, limit=10) + playlists.extend(results) + + # Avoid rate limiting + time.sleep(0.1) + + # Filter for playlists with reasonable track counts (avoid tiny playlists) + playlists = [p for p in playlists if p.get('nb_tracks', 0) >= 10] + + # Sort by popularity or track count + playlists.sort(key=lambda x: x.get('nb_tracks', 0), reverse=True) + + # Shuffle and limit results + random.shuffle(playlists) + return playlists[:limit] + + def get_genre_from_lastfm(self, artist_name, track_name, lastfm_api_key): + """ + Fetch genre from Last.fm API + Returns the genre string, or empty string if not found + """ + if not lastfm_api_key: + return "" + + url = 'http://ws.audioscrobbler.com/2.0/' + params = { + 'method': 'track.getInfo', + 'api_key': lastfm_api_key, + 'artist': artist_name, + 'track': track_name, + 'format': 'json' + } + + try: + response = requests.get(url=url, params=params).json() + + # If present, use the first top-level tag as "genre" + if ('track' in response and + 'toptags' in response['track'] and + 'tag' in response['track']['toptags'] and + response['track']['toptags']['tag']): + return response['track']['toptags']['tag'][0]['name'] + return "" + except Exception as e: + self.logger.error(f"Last.fm API error: {e}") + return "" + + def import_track(self, track_id, lastfm_api_key=None): + """ + Import a track from Deezer into the database + Returns the Song object if successful, None otherwise + """ + track_info = self.get_track(track_id) + + if not track_info: + self.logger.error(f"Could not fetch track with ID {track_id}") + return None + + # Check if the track has a preview URL (required for our application) + preview_url = track_info.get('preview') + if not preview_url: + self.logger.warning(f"Track {track_info.get('title')} has no preview URL") + return None + + # Check if this track is already in our database + existing_song = Song.query.filter_by(deezer_id=str(track_info['id'])).first() + if existing_song: + self.logger.info(f"Track {track_info.get('title')} already exists in database") + return existing_song + + # Get additional artist details if needed + artist_name = track_info.get('artist', {}).get('name', '') + + # Get album release year + album_id = track_info.get('album', {}).get('id') + release_year = '' + cover_url = '' + + if album_id: + album_info = self.get_album(album_id) + if album_info: + release_date = album_info.get('release_date', '') + release_year = release_date[:4] if release_date else '' + # Get highest quality cover image + cover_url = album_info.get('cover_xl') or album_info.get('cover_big') or album_info.get('cover_medium', '') + + # Get genre from Last.fm + genre = self.get_genre_from_lastfm(artist_name, track_info.get('title', ''), lastfm_api_key) + + # Create new Song object + new_song = Song( + deezer_id=str(track_info['id']), + spotify_id=None, # We don't have Spotify ID for Deezer tracks + title=track_info.get('title', ''), + artist=artist_name, + genre=genre, + year=release_year, + preview_url=preview_url, + cover_url=cover_url, + popularity=track_info.get('rank', 0), + used_count=0 + ) + + try: + db.session.add(new_song) + db.session.commit() + self.logger.info(f"Imported track '{new_song.title}' by {new_song.artist}") + return new_song + except Exception as e: + db.session.rollback() + self.logger.error(f"Error saving track to database: {e}") + return None + + def import_album(self, album_id, lastfm_api_key=None): + """ + Import all tracks from an album + Returns a list of successfully imported Song objects + """ + tracks = self.get_album_tracks(album_id) + imported_songs = [] + + for track in tracks: + track_id = track.get('id') + if track_id: + song = self.import_track(track_id, lastfm_api_key) + if song: + imported_songs.append(song) + + # Add a small delay to avoid overwhelming the API + time.sleep(0.2) + + return imported_songs + + def import_playlist(self, playlist_id, lastfm_api_key=None): + """ + Import all tracks from a playlist + Returns a list of successfully imported Song objects + """ + tracks = self.get_playlist_tracks(playlist_id) + imported_songs = [] + + for track in tracks: + track_id = track.get('id') + if track_id: + song = self.import_track(track_id, lastfm_api_key) + if song: + imported_songs.append(song) + + # Add a small delay to avoid overwhelming the API + time.sleep(0.2) + + return imported_songs \ No newline at end of file diff --git a/musicround/errors.py b/musicround/errors.py new file mode 100644 index 0000000..2c2770b --- /dev/null +++ b/musicround/errors.py @@ -0,0 +1,222 @@ +import traceback +from flask import render_template, session, request, current_app, jsonify +from flask_wtf.csrf import CSRFError +from flask_login import current_user +import json +import openai + +# Import the csrf instance from the package +from musicround import csrf + +def generate_friendly_error_message(error_info, app=None): + """ + Generate a user-friendly error message using OpenAI + + Args: + error_info (dict): Information about the error + app: Flask application instance + + Returns: + str: User-friendly error message or None if generation fails + """ + if not app: + app = current_app + + try: + # Get OpenAI API details + openai_api_key = app.config.get('OPENAI_API_KEY') + openai_url = app.config.get('OPENAI_URL') + openai_model = app.config.get('OPENAI_MODEL') + + if not openai_api_key or not openai_model: + app.logger.warning("OpenAI credentials not configured for error messages") + return None + + # Configure OpenAI API + openai.api_key = openai_api_key + if openai_url: + if hasattr(openai, 'base_url'): # New OpenAI API client (>= 1.0.0) + openai.base_url = openai_url + else: # Old OpenAI API client (< 1.0.0) + openai.api_base = openai_url + + # Create a meaningful prompt with the error information + prompt = f""" + Generate a user-friendly, helpful explanation for this technical error: + Error Type: {error_info.get('error_type', 'Unknown Error')} + Error Message: {error_info.get('error_message', 'No specific message available')} + Error Code: {error_info.get('code', 'Unknown')} + + The explanation should: + 1. Be written in simple, non-technical language + 2. Explain what might have happened + 3. Suggest possible solutions or next steps + 4. Be concise (max 2-3 sentences) + 5. Be friendly and reassuring + + Return just the friendly explanation without any additional text. + """ + + app.logger.info(f"Requesting friendly error message from OpenAI") + content = None + + # Call OpenAI based on library version + if hasattr(openai, 'chat') and hasattr(openai.chat, 'completions'): + # New OpenAI API client (>= 1.0.0) + try: + response = openai.chat.completions.create( + model=openai_model, + messages=[{"role": "user", "content": prompt}], + max_tokens=150, + temperature=0.7 + ) + + if response and hasattr(response, 'choices') and response.choices: + content = response.choices[0].message.content + app.logger.info(f"Received friendly error message from OpenAI") + except Exception as e: + app.logger.error(f"OpenAI chat completions error: {e}") + else: + # Old OpenAI API client (< 1.0.0) + try: + response = openai.Completion.create( + engine=openai_model, + prompt=prompt, + max_tokens=150, + temperature=0.7 + ) + + if response and hasattr(response, 'choices') and len(response.choices) > 0: + content = response.choices[0].text.strip() + app.logger.info(f"Received friendly error message from OpenAI") + except Exception as e: + app.logger.error(f"OpenAI completion error: {e}") + + # Return the friendly message if available + if content: + return content.strip() + + except Exception as e: + app.logger.error(f"Error generating friendly error message: {e}") + + return None + +def register_error_handlers(app): + """Register error handlers with the Flask application.""" + + # Add endpoint to get friendly error message asynchronously + @app.route('/api/friendly-error', methods=['POST']) + @csrf.exempt # Exempt this endpoint from CSRF protection + def get_friendly_error_message(): + try: + data = request.get_json() + error_info = { + 'error_type': data.get('error_type', 'Unknown Error'), + 'error_message': data.get('error_message', 'No specific message available'), + 'code': data.get('code', 'Unknown') + } + + friendly_message = generate_friendly_error_message(error_info, app) + + if friendly_message: + return jsonify({'success': True, 'message': friendly_message}) + else: + return jsonify({'success': False, 'message': 'Could not generate a friendly message'}), 500 + except Exception as e: + app.logger.error(f"Error in friendly error API: {e}") + return jsonify({'success': False, 'message': str(e)}), 500 + + @app.errorhandler(400) + def bad_request_error(error): + return handle_error(error, 400, "Bad Request") + + @app.errorhandler(401) + def unauthorized_error(error): + return handle_error(error, 401, "Unauthorized") + + @app.errorhandler(403) + def forbidden_error(error): + return handle_error(error, 403, "Forbidden") + + @app.errorhandler(404) + def not_found_error(error): + return handle_error(error, 404, "Page Not Found") + + @app.errorhandler(405) + def method_not_allowed_error(error): + return handle_error(error, 405, "Method Not Allowed") + + @app.errorhandler(429) + def too_many_requests_error(error): + return handle_error(error, 429, "Too Many Requests") + + @app.errorhandler(500) + def internal_server_error(error): + return handle_error(error, 500, "Internal Server Error") + + @app.errorhandler(CSRFError) + def handle_csrf_error(error): + return handle_error(error, 400, "CSRF Error") + + # Add this to ensure other errors are also captured + @app.errorhandler(Exception) + def unhandled_exception(error): + app.logger.error(f"Unhandled Exception: {error}") + return handle_error(error, 500, "Internal Server Error") + + +def handle_error(error, code, default_message): + """ + Common error handler that renders the error.html template with appropriate context + """ + # Get the error message + message = getattr(error, 'description', str(error)) or default_message + + # Prepare debug info for logged-in users + debug_info = None + tb = None + + # Use Flask-Login instead of checking for access_token in session + if current_user.is_authenticated: + # Include request details in debug info + debug_info = { + 'error_type': error.__class__.__name__, + 'request_path': request.path, + 'request_method': request.method, + 'request_headers': {k: v for k, v in request.headers.items() if k.lower() not in ('cookie', 'authorization')}, + 'request_args': request.args.to_dict(), + } + + # Include POST data if it's form data (not for file uploads) + if request.form and 'multipart/form-data' not in request.content_type: + debug_info['request_form'] = request.form.to_dict() + + # Include JSON data if applicable + if request.is_json: + try: + debug_info['request_json'] = request.get_json() + except: + debug_info['request_json'] = 'Invalid JSON' + + # Get traceback for more detailed debugging + tb = traceback.format_exc() if code == 500 else None + + # Convert debug_info to formatted string for template + debug_info_str = json.dumps(debug_info, indent=2) + + # We'll pass the error info to the template so JavaScript can request a friendly message + error_info_for_js = json.dumps({ + 'error_type': error.__class__.__name__, + 'error_message': str(error), + 'code': code + }) + + # Render the template with all necessary information + return render_template( + 'error.html', + message=message, # Original technical message + code=code, + debug_info=debug_info_str if 'debug_info_str' in locals() else None, + traceback=tb, + error_info_for_js=error_info_for_js # Error info for JavaScript to use + ), code \ No newline at end of file diff --git a/musicround/helpers/__init__.py b/musicround/helpers/__init__.py new file mode 100644 index 0000000..b8ca501 --- /dev/null +++ b/musicround/helpers/__init__.py @@ -0,0 +1 @@ +# This file makes the helpers directory a proper Python package diff --git a/musicround/helpers/auth_helpers.py b/musicround/helpers/auth_helpers.py new file mode 100644 index 0000000..8d59c44 --- /dev/null +++ b/musicround/helpers/auth_helpers.py @@ -0,0 +1,280 @@ +""" +Authentication helper functions for OAuth providers +""" +import os +from flask import current_app, url_for, session, flash, redirect, request +from authlib.integrations.flask_client import OAuth +from flask_login import login_user, current_user +from functools import wraps +from datetime import datetime, timedelta +import requests + +from musicround.models import db, User + +# Initialize OAuth object +oauth = OAuth() + +def init_oauth(app): + """ + Initialize OAuth with the Flask app and register providers + """ + oauth.init_app(app) + + # Register Google OAuth client + if app.config.get('GOOGLE_CLIENT_ID') and app.config.get('GOOGLE_CLIENT_SECRET'): + oauth.register( + name='google', + client_id=app.config.get('GOOGLE_CLIENT_ID'), + client_secret=app.config.get('GOOGLE_CLIENT_SECRET'), + server_metadata_url='https://accounts.google.com/.well-known/openid-configuration', + client_kwargs={ + 'scope': 'openid email profile' + } + ) + app.logger.info("Google OAuth client registered") + else: + app.logger.warning("Google OAuth client not registered - missing client ID or secret") + + # Register Authentik OAuth client + if app.config.get('AUTHENTIK_CLIENT_ID') and app.config.get('AUTHENTIK_CLIENT_SECRET'): + oauth.register( + name='authentik', + client_id=app.config.get('AUTHENTIK_CLIENT_ID'), + client_secret=app.config.get('AUTHENTIK_CLIENT_SECRET'), + server_metadata_url=app.config.get('AUTHENTIK_METADATA_URL'), + client_kwargs={ + 'scope': 'openid email profile' + } + ) + app.logger.info("Authentik OAuth client registered") + else: + app.logger.warning("Authentik OAuth client not registered - missing client ID or secret") + + # Register Dropbox OAuth client + if app.config.get('DROPBOX_APP_KEY') and app.config.get('DROPBOX_APP_SECRET'): + oauth.register( + name='dropbox', + client_id=app.config.get('DROPBOX_APP_KEY'), + client_secret=app.config.get('DROPBOX_APP_SECRET'), + authorize_url='https://www.dropbox.com/oauth2/authorize', + authorize_params=None, + access_token_url='https://api.dropboxapi.com/oauth2/token', + access_token_params=None, + refresh_token_url='https://api.dropboxapi.com/oauth2/token', + client_kwargs={ + 'scope': 'files.content.write account_info.read' + } + ) + app.logger.info("Dropbox OAuth client registered") + else: + app.logger.warning("Dropbox OAuth client not registered - missing app key or secret") + + return oauth + +def get_google_user_info(token): + """ + Get Google user info from the token + """ + try: + resp = oauth.google.get('https://www.googleapis.com/oauth2/v3/userinfo') + profile = resp.json() + + # Create a standardized user info dictionary + user_info = { + 'id': profile.get('sub'), # Google uses 'sub' as the unique identifier + 'email': profile.get('email'), + 'name': profile.get('name'), + 'given_name': profile.get('given_name'), + 'family_name': profile.get('family_name'), + 'picture': profile.get('picture') + } + + # Add 'sub' field explicitly for backwards compatibility + if profile.get('sub'): + user_info['sub'] = profile.get('sub') + + return user_info + except Exception as e: + current_app.logger.error(f"Error getting Google user info: {str(e)}") + return None + +def get_authentik_user_info(token): + """ + Get Authentik user info from the token + """ + try: + resp = oauth.authentik.get('userinfo') + profile = resp.json() + return { + 'id': profile.get('sub'), + 'email': profile.get('email'), + 'name': profile.get('name'), + 'given_name': profile.get('given_name', ''), + 'family_name': profile.get('family_name', ''), + 'picture': profile.get('picture', '') + } + except Exception as e: + current_app.logger.error(f"Error getting Authentik user info: {str(e)}") + return None + +def get_dropbox_user_info(token): + """ + Get Dropbox user info from the token + """ + try: + # Add debug logging for token + current_app.logger.debug(f"Retrieving Dropbox user info with token: {token}") + + # Make sure we have an access token + access_token = token.get("access_token") + if not access_token: + # Try direct token string if token is not a dict + if isinstance(token, str): + access_token = token + else: + current_app.logger.error("No access token found in token object") + return None + + # Set proper headers for Dropbox API - no Content-Type for null body + headers = { + 'Authorization': f'Bearer {access_token}' + } + + # The Dropbox API for get_current_account actually expects a null body with no Content-Type header + response = requests.post( + 'https://api.dropboxapi.com/2/users/get_current_account', + headers=headers, + data=None # Send null body + ) + + # Check for successful response + if response.status_code != 200: + current_app.logger.error(f"Dropbox API error: {response.status_code} - {response.text}") + return None + + # Parse response + profile = response.json() + current_app.logger.debug(f"Dropbox user info response: {profile}") + + # Create a standardized user info dictionary + user_info = { + 'id': profile.get('account_id', ''), + 'email': profile.get('email', ''), + 'name': profile.get('name', {}).get('display_name', ''), + 'given_name': profile.get('name', {}).get('given_name', ''), + 'family_name': profile.get('name', {}).get('surname', ''), + 'picture': profile.get('profile_photo_url', '') + } + + return user_info + except Exception as e: + current_app.logger.error(f"Error getting Dropbox user info: {str(e)}") + return None + +def find_or_create_user(user_info, auth_provider): + """ + Find existing user or create a new one based on OAuth user info + """ + if not user_info: + return None + + # First try to find user by provider-specific ID + if auth_provider == 'google': + user = User.query.filter_by(google_id=user_info['id']).first() + elif auth_provider == 'authentik': + user = User.query.filter_by(authentik_id=user_info['id']).first() + elif auth_provider == 'dropbox': + user = User.query.filter_by(dropbox_id=user_info['id']).first() + else: + return None + + # If not found by provider ID, try email + if user is None and user_info.get('email'): + user = User.query.filter_by(email=user_info['email']).first() + + # If user exists but doesn't have provider ID, update it + if user: + if auth_provider == 'google': + user.google_id = user_info['id'] + elif auth_provider == 'authentik': + user.authentik_id = user_info['id'] + elif auth_provider == 'dropbox': + user.dropbox_id = user_info['id'] + + db.session.commit() + current_app.logger.info(f"Updated existing user {user.username} with {auth_provider} ID") + + # If user still not found, check if new signups are allowed before creating + if user is None: + # Check system setting if new signups are allowed + from musicround.models import SystemSetting + allow_signups = SystemSetting.get('allow_signups', 'true') == 'true' + + if not allow_signups: + current_app.logger.warning(f"OAuth signup attempted for {auth_provider} but new signups are disabled") + return None + + # Generate a username from email + email = user_info.get('email', '') + base_username = email.split('@')[0] if email else f"{auth_provider}_{user_info['id']}" + + # Ensure username is unique + username = base_username + counter = 1 + while User.query.filter_by(username=username).first(): + username = f"{base_username}_{counter}" + counter += 1 + + # Create new user + user = User( + username=username, + email=user_info.get('email', ''), + first_name=user_info.get('given_name', ''), + last_name=user_info.get('family_name', ''), + auth_provider=auth_provider, + created_at=datetime.now(), + last_login=datetime.now() + ) + + # Set provider-specific fields + if auth_provider == 'google': + user.google_id = user_info['id'] + elif auth_provider == 'authentik': + user.authentik_id = user_info['id'] + elif auth_provider == 'dropbox': + user.dropbox_id = user_info['id'] + + db.session.add(user) + try: + db.session.commit() + current_app.logger.info(f"Created new user {username} with {auth_provider} auth") + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error creating user: {str(e)}") + return None + + return user + +def update_oauth_tokens(user, tokens, auth_provider): + """ + Update user's OAuth tokens + """ + if auth_provider == 'google': + user.google_token = tokens.get('access_token') + user.google_refresh_token = tokens.get('refresh_token') + elif auth_provider == 'authentik': + user.authentik_token = tokens.get('access_token') + user.authentik_refresh_token = tokens.get('refresh_token') + elif auth_provider == 'dropbox': + user.dropbox_token = tokens.get('access_token') + user.dropbox_refresh_token = tokens.get('refresh_token') + if tokens.get('expires_in'): + user.dropbox_token_expiry = datetime.now() + timedelta(seconds=int(tokens.get('expires_in'))) + user.last_login = datetime.now() + try: + db.session.commit() + return True + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error updating {auth_provider} tokens: {str(e)}") + return False \ No newline at end of file diff --git a/musicround/helpers/backup_helper.py b/musicround/helpers/backup_helper.py new file mode 100644 index 0000000..b8b5b09 --- /dev/null +++ b/musicround/helpers/backup_helper.py @@ -0,0 +1,724 @@ +""" +Backup helper functions for creating, managing, and restoring backups. +""" +import os +import shutil +import json +import logging +import sqlite3 +import zipfile +from datetime import datetime +import tempfile +from flask import current_app + +# Set up logging +logger = logging.getLogger(__name__) + +def create_backup(backup_name=None, include_mp3s=True, include_config=True): + """ + Create a full system backup including database, MP3s, and configuration. + + Args: + backup_name: Optional name for the backup (defaults to timestamp) + include_mp3s: Whether to include MP3 files in the backup + include_config: Whether to include configuration files + + Returns: + dict: Backup information including path and status + """ + try: + # Generate backup name if not provided + if not backup_name: + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + backup_name = f"backup_{timestamp}" + + # Ensure backup directory exists + backup_dir = os.path.join('/data', 'backups') + os.makedirs(backup_dir, exist_ok=True) + + # Create backup zip file path + backup_path = os.path.join(backup_dir, f"{backup_name}.zip") + + # Create a temporary directory for collecting files + with tempfile.TemporaryDirectory() as temp_dir: + # Step 1: Backup the database + db_path = current_app.config['SQLALCHEMY_DATABASE_URI'].replace('sqlite:///', '') + + if os.path.exists(db_path): + # Create a copy of the database (to avoid locking issues) + temp_db = os.path.join(temp_dir, 'song_data.db') + + # Connect to source database and back it up + conn = sqlite3.connect(db_path) + backup_conn = sqlite3.connect(temp_db) + conn.backup(backup_conn) + conn.close() + backup_conn.close() + + logger.info(f"Database backed up to {temp_db}") + else: + logger.error(f"Database not found at {db_path}") + return { + "status": "error", + "message": f"Database not found at {db_path}", + "path": None + } + + # Step 2: Copy MP3 files if requested + if include_mp3s: + mp3_dir = os.path.join(os.path.dirname(current_app.root_path), 'mp3') + if os.path.exists(mp3_dir): + mp3_backup_dir = os.path.join(temp_dir, 'mp3') + os.makedirs(mp3_backup_dir, exist_ok=True) + + # Copy all MP3 files + for mp3_file in os.listdir(mp3_dir): + if mp3_file.endswith('.mp3'): + source_path = os.path.join(mp3_dir, mp3_file) + dest_path = os.path.join(mp3_backup_dir, mp3_file) + shutil.copy2(source_path, dest_path) + + logger.info(f"MP3 files backed up to {mp3_backup_dir}") + else: + logger.warning(f"MP3 directory not found at {mp3_dir}") + + # Step 3: Add configuration files if requested + if include_config: + config_dir = os.path.join(temp_dir, 'config') + os.makedirs(config_dir, exist_ok=True) + + # Copy .env file if it exists + env_path = os.path.join(os.path.dirname(current_app.root_path), '.env') + if os.path.exists(env_path): + shutil.copy2(env_path, os.path.join(config_dir, '.env')) + logger.info(f".env file backed up") + + # Extract system settings from database and save as JSON + try: + from musicround.models import SystemSetting + settings = SystemSetting.all_settings() + + # Save settings to JSON file + settings_path = os.path.join(config_dir, 'system_settings.json') + with open(settings_path, 'w') as f: + json.dump(settings, f, indent=2) + + logger.info(f"System settings backed up to {settings_path}") + except Exception as e: + logger.error(f"Error backing up system settings: {str(e)}") + + # Step 4: Add backup metadata file with version info and timestamp + from musicround.version import VERSION_INFO + + metadata = { + "backup_name": backup_name, + "timestamp": datetime.now().isoformat(), + "version": VERSION_INFO['version'], + "release_name": VERSION_INFO['release_name'], + "includes_mp3s": include_mp3s, + "includes_config": include_config + } + + metadata_path = os.path.join(temp_dir, 'backup_metadata.json') + with open(metadata_path, 'w') as f: + json.dump(metadata, f, indent=2) + + # Step 5: Create a ZIP archive of all backed up content + with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf: + # Add all files from temp directory to ZIP + for root, _, files in os.walk(temp_dir): + for file in files: + file_path = os.path.join(root, file) + # Add file to ZIP with a relative path + arcname = os.path.relpath(file_path, temp_dir) + zipf.write(file_path, arcname) + + # Get backup file size + backup_size = os.path.getsize(backup_path) + + return { + "status": "success", + "message": "Backup created successfully", + "path": backup_path, + "name": backup_name, + "size": backup_size, + "timestamp": datetime.now().isoformat() + } + + except Exception as e: + logger.error(f"Error during backup creation: {str(e)}") + return { + "status": "error", + "message": f"Backup failed: {str(e)}", + "path": None + } + +def list_backups(): + """ + List all available backups with their metadata. + + Returns: + list: List of backup information dictionaries + """ + backup_dir = os.path.join('/data', 'backups') + + if not os.path.exists(backup_dir): + os.makedirs(backup_dir, exist_ok=True) + return [] + + backups = [] + + for filename in os.listdir(backup_dir): + if filename.endswith('.zip'): + backup_path = os.path.join(backup_dir, filename) + try: + # Extract metadata from ZIP file + with zipfile.ZipFile(backup_path, 'r') as zipf: + if 'backup_metadata.json' in zipf.namelist(): + with zipf.open('backup_metadata.json') as f: + metadata = json.load(f) + + # Add file information to metadata + file_info = os.stat(backup_path) + metadata['file_size'] = file_info.st_size + metadata['file_name'] = filename + metadata['file_path'] = backup_path + metadata['file_date'] = datetime.fromtimestamp(file_info.st_mtime).isoformat() + + backups.append(metadata) + else: + # No metadata file, create basic info + file_info = os.stat(backup_path) + backups.append({ + 'backup_name': os.path.splitext(filename)[0], + 'file_name': filename, + 'file_path': backup_path, + 'file_size': file_info.st_size, + 'file_date': datetime.fromtimestamp(file_info.st_mtime).isoformat(), + 'timestamp': datetime.fromtimestamp(file_info.st_mtime).isoformat(), + 'version': 'Unknown', + 'release_name': 'Unknown' + }) + except Exception as e: + logger.error(f"Error reading backup metadata from {filename}: {str(e)}") + + # Sort backups by timestamp (newest first) + backups.sort(key=lambda x: x.get('timestamp', ''), reverse=True) + + return backups + +def delete_backup(backup_filename): + """ + Delete a backup file. + + Args: + backup_filename: Name of the backup file to delete + + Returns: + dict: Operation status information + """ + backup_dir = os.path.join('/data', 'backups') + backup_path = os.path.join(backup_dir, backup_filename) + + if not os.path.exists(backup_path): + return { + "status": "error", + "message": f"Backup file {backup_filename} not found" + } + + try: + os.remove(backup_path) + return { + "status": "success", + "message": f"Backup {backup_filename} deleted successfully" + } + except Exception as e: + logger.error(f"Error deleting backup {backup_filename}: {str(e)}") + return { + "status": "error", + "message": f"Error deleting backup: {str(e)}" + } + +def restore_backup(backup_filename): + """ + Restore system from a backup file. + + Args: + backup_filename: Name of the backup file to restore + + Returns: + dict: Operation status information + """ + backup_dir = os.path.join('/data', 'backups') + backup_path = os.path.join(backup_dir, backup_filename) + + if not os.path.exists(backup_path): + return { + "status": "error", + "message": f"Backup file {backup_filename} not found" + } + + try: + # Create a temporary directory for extracting backup + with tempfile.TemporaryDirectory() as temp_dir: + # Extract the backup ZIP + with zipfile.ZipFile(backup_path, 'r') as zipf: + zipf.extractall(temp_dir) + + # Get backup metadata + metadata_path = os.path.join(temp_dir, 'backup_metadata.json') + if os.path.exists(metadata_path): + with open(metadata_path, 'r') as f: + metadata = json.load(f) + else: + metadata = { + "includes_mp3s": True, + "includes_config": True + } + + # Restore database + db_backup_path = os.path.join(temp_dir, 'song_data.db') + db_path = current_app.config['SQLALCHEMY_DATABASE_URI'].replace('sqlite:///', '') + + if os.path.exists(db_backup_path): + # Create a backup of the current database before overwriting + timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') + db_current_backup = f"{db_path}.{timestamp}.bak" + + if os.path.exists(db_path): + shutil.copy2(db_path, db_current_backup) + logger.info(f"Created backup of current database at {db_current_backup}") + + # Restore the database from backup + shutil.copy2(db_backup_path, db_path) + logger.info(f"Restored database from backup") + else: + logger.error("Database file not found in backup") + return { + "status": "error", + "message": "Database file not found in backup" + } + + # Restore MP3 files if included in backup + if metadata.get("includes_mp3s", True): + mp3_backup_dir = os.path.join(temp_dir, 'mp3') + if os.path.exists(mp3_backup_dir): + mp3_dir = os.path.join(os.path.dirname(current_app.root_path), 'mp3') + + # Create backup of current MP3 files + if os.path.exists(mp3_dir): + mp3_backup = f"{mp3_dir}.{timestamp}.bak" + shutil.copytree(mp3_dir, mp3_backup) + logger.info(f"Created backup of current MP3 files at {mp3_backup}") + + # Remove current MP3 directory and replace with backup + if os.path.exists(mp3_dir): + shutil.rmtree(mp3_dir) + + # Create MP3 directory if it doesn't exist + os.makedirs(mp3_dir, exist_ok=True) + + # Copy MP3 files from backup + for mp3_file in os.listdir(mp3_backup_dir): + if mp3_file.endswith('.mp3'): + source_path = os.path.join(mp3_backup_dir, mp3_file) + dest_path = os.path.join(mp3_dir, mp3_file) + shutil.copy2(source_path, dest_path) + + logger.info(f"Restored MP3 files from backup") + + # Restore config files if included in backup + if metadata.get("includes_config", True): + config_backup_dir = os.path.join(temp_dir, 'config') + if os.path.exists(config_backup_dir): + # Restore .env file if present in backup + env_backup_path = os.path.join(config_backup_dir, '.env') + if os.path.exists(env_backup_path): + env_path = os.path.join(os.path.dirname(current_app.root_path), '.env') + + # Backup current .env + if os.path.exists(env_path): + env_backup = f"{env_path}.{timestamp}.bak" + shutil.copy2(env_path, env_backup) + logger.info(f"Created backup of current .env file at {env_backup}") + + # Restore .env from backup + shutil.copy2(env_backup_path, env_path) + logger.info(f"Restored .env file from backup") + + # Restore system settings from JSON if present + settings_backup_path = os.path.join(config_backup_dir, 'system_settings.json') + if os.path.exists(settings_backup_path): + try: + with open(settings_backup_path, 'r') as f: + settings = json.load(f) + + # Import within function to avoid circular imports + from musicround.models import SystemSetting, db + + # Restore each setting + for key, value in settings.items(): + SystemSetting.set(key, value) + + logger.info("Restored system settings from backup") + except Exception as e: + logger.error(f"Error restoring system settings: {str(e)}") + + return { + "status": "success", + "message": "Backup restored successfully", + "backup_name": backup_filename + } + + except Exception as e: + logger.error(f"Error restoring backup {backup_filename}: {str(e)}") + return { + "status": "error", + "message": f"Error restoring backup: {str(e)}" + } + +def verify_backup(backup_filename): + """ + Verify the integrity of a backup file. + + Args: + backup_filename: Name of the backup file to verify + + Returns: + dict: Verification result + """ + backup_dir = os.path.join('/data', 'backups') + backup_path = os.path.join(backup_dir, backup_filename) + + if not os.path.exists(backup_path): + return { + "status": "error", + "message": f"Backup file {backup_filename} not found", + "is_valid": False + } + + try: + # Check if the file is a valid ZIP + if not zipfile.is_zipfile(backup_path): + return { + "status": "error", + "message": f"Backup file is not a valid ZIP archive", + "is_valid": False + } + + # Try to open the ZIP and extract metadata + with zipfile.ZipFile(backup_path, 'r') as zipf: + # Test the integrity of all files in the ZIP + test_result = zipf.testzip() + if test_result is not None: + return { + "status": "error", + "message": f"Backup file contains corrupted files, first bad file: {test_result}", + "is_valid": False + } + + # Check for essential files + if 'song_data.db' not in zipf.namelist(): + return { + "status": "error", + "message": "Backup file does not contain a database", + "is_valid": False + } + + # Extract metadata if available + if 'backup_metadata.json' in zipf.namelist(): + with zipf.open('backup_metadata.json') as f: + metadata = json.load(f) + else: + metadata = {"version": "Unknown"} + + # If we got here, the backup is valid + return { + "status": "success", + "message": "Backup file is valid", + "is_valid": True, + "version": metadata.get("version", "Unknown"), + "timestamp": metadata.get("timestamp", "Unknown") + } + + except Exception as e: + logger.error(f"Error verifying backup {backup_filename}: {str(e)}") + return { + "status": "error", + "message": f"Error verifying backup: {str(e)}", + "is_valid": False + } + +def schedule_backup(schedule_time=None, frequency='daily', retention_days=30): + """ + Schedule automatic backups. + + Args: + schedule_time: Time to run the backup (HH:MM format) + frequency: Frequency of backups ('hourly', 'daily', 'weekly') + retention_days: Number of days of backups to keep (0 = keep all) + + Returns: + dict: Operation status information + """ + # This would typically integrate with a scheduler like cron + # For now, we'll just store the settings in SystemSetting + try: + from musicround.models import SystemSetting + + # Get current time if not provided + if schedule_time is None: + schedule_time = datetime.now().strftime('%H:%M') + + # Store backup schedule settings + SystemSetting.set('backup_schedule_time', schedule_time) + SystemSetting.set('backup_schedule_frequency', frequency) + SystemSetting.set('backup_schedule_enabled', 'true') + SystemSetting.set('backup_retention_days', str(retention_days)) + + # If retention policy is set, apply it immediately + if retention_days > 0: + apply_retention_policy(retention_days) + + return { + "status": "success", + "message": f"Backup scheduled for {schedule_time} ({frequency}), keeping {retention_days} days of backups", + "schedule_time": schedule_time, + "frequency": frequency, + "retention_days": retention_days + } + except Exception as e: + logger.error(f"Error scheduling backup: {str(e)}") + return { + "status": "error", + "message": f"Error scheduling backup: {str(e)}" + } + +def get_backup_summary(): + """ + Get a summary of backup system status. + + Returns: + dict: Summary information including counts, schedule info, etc. + """ + from musicround.models import SystemSetting + + # Get all backups + backups = list_backups() + + # Extract info from settings + schedule_enabled = SystemSetting.get('backup_schedule_enabled', 'false') == 'true' + schedule_time = SystemSetting.get('backup_schedule_time', '03:00') + schedule_frequency = SystemSetting.get('backup_schedule_frequency', 'daily') + retention_days = int(SystemSetting.get('backup_retention_days', '30')) + + # Calculate next backup time based on schedule + from datetime import datetime, time, timedelta + now = datetime.now() + + next_backup = None + if schedule_enabled: + try: + # Parse schedule time + hour, minute = map(int, schedule_time.split(':')) + schedule_time_obj = time(hour, minute) + + # Calculate next occurrence + next_backup_date = now.date() + next_backup_datetime = datetime.combine(next_backup_date, schedule_time_obj) + + # If today's scheduled time has passed, move to next occurrence based on frequency + if next_backup_datetime < now: + if schedule_frequency == 'hourly': + next_backup_datetime = now + timedelta(hours=1) + elif schedule_frequency == 'daily': + next_backup_datetime = datetime.combine(next_backup_date + timedelta(days=1), schedule_time_obj) + elif schedule_frequency == 'weekly': + next_backup_datetime = datetime.combine(next_backup_date + timedelta(days=7), schedule_time_obj) + + next_backup = next_backup_datetime.strftime('%Y-%m-%d %H:%M') + except: + next_backup = "Error calculating next backup time" + + # Get latest backup info + latest_backup = backups[0] if backups else None + + return { + "backup_count": len(backups), + "latest_backup": latest_backup, + "schedule_enabled": schedule_enabled, + "schedule_time": schedule_time, + "schedule_frequency": schedule_frequency, + "next_backup": next_backup, + "backup_location": "/data/backups", + "retention_days": retention_days + } + +def generate_backup_config_suggestion(retention_days=30): + """ + Generate a configuration suggestion for setting up automated backups. + This does NOT modify any files, it only returns a suggestion. + + Args: + retention_days: Number of days to keep backups + + Returns: + dict: Configuration suggestion and instructions + """ + # Generate the backup schedule configuration suggestion + from musicround.models import SystemSetting + + # Get backup schedule information + schedule_time = SystemSetting.get('backup_schedule_time', '03:00') + schedule_frequency = SystemSetting.get('backup_schedule_frequency', 'daily') + + # Map schedule frequency to cron expressions for documentation + frequency_map = { + 'hourly': '@hourly', + 'daily': '@daily', + 'weekly': '@weekly' + } + + schedule_cron = frequency_map.get(schedule_frequency, '@daily') + + # Generate docker-compose config example + docker_compose_suggestion = f"""labels: + ofelia.enabled: "true" + ofelia.job-exec.backup.schedule: "{schedule_cron}" + ofelia.job-exec.backup.command: "python /app/run.py backup create --auto" + ofelia.job-exec.backup.no-overlap: "true" + # Retention policy - automatically delete backups older than {retention_days} days + ofelia.job-exec.retention.schedule: "@weekly" + ofelia.job-exec.retention.command: "python /app/run.py backup retention --days {retention_days}" + ofelia.job-exec.retention.no-overlap: "true" +""" + + # Generate ofelia.ini config example (for standalone setups) + ofelia_ini_suggestion = f"""[global] +save-folder = /var/log/ofelia + +[job-exec "backup"] +schedule = {schedule_cron} +command = python /app/run.py backup create --auto +user = root +no-overlap = true + +[job-exec "retention"] +schedule = @weekly +command = python /app/run.py backup retention --days {retention_days} +user = root +no-overlap = true +""" + + # Generate instructions for manual setup + instructions = f"""To set up automated backups, add the configuration to your Docker Compose file OR use the ofelia.ini file. + +Option 1: Add these labels to your main service in docker-compose.yml: +{docker_compose_suggestion} + +Option 2: Add these sections to ofelia.ini: +{ofelia_ini_suggestion} + +After making changes, restart your containers to apply the configuration: +docker-compose down +docker-compose up -d +""" + + return { + "status": "success", + "schedule": { + "frequency": schedule_frequency, + "time": schedule_time, + "retention_days": retention_days + }, + "docker_compose_suggestion": docker_compose_suggestion, + "ofelia_ini_suggestion": ofelia_ini_suggestion, + "instructions": instructions, + "message": "Generated backup configuration suggestion" + } + +def apply_retention_policy(retention_days=30): + """ + Apply the backup retention policy by deleting old backups. + + Args: + retention_days: Number of days of backups to keep (0 = keep all) + + Returns: + dict: Operation status information + """ + if retention_days <= 0: + return { + "status": "success", + "message": "Retention policy disabled, all backups kept", + "deleted_count": 0, + "deleted_backups": [] + } + + try: + from datetime import datetime, timedelta + import os + + # Get the cutoff date + cutoff_date = datetime.now() - timedelta(days=retention_days) + + # Get list of all backups + backups = list_backups() + + # Filter to find backups older than the cutoff date + deleted_backups = [] + + for backup in backups: + # Get backup timestamp + backup_time = None + + if 'timestamp' in backup: + try: + backup_time = datetime.fromisoformat(backup['timestamp']) + except (ValueError, TypeError): + # Try the file date as fallback + if 'file_date' in backup: + try: + backup_time = datetime.fromisoformat(backup['file_date']) + except (ValueError, TypeError): + # Can't determine date, skip this backup + continue + elif 'file_date' in backup: + try: + backup_time = datetime.fromisoformat(backup['file_date']) + except (ValueError, TypeError): + # Can't determine date, skip this backup + continue + + # If we couldn't determine when this backup was created, skip it + if not backup_time: + continue + + # Check if this backup is older than the cutoff date + if backup_time < cutoff_date: + backup_path = backup.get('file_path') + if backup_path and os.path.exists(backup_path): + try: + os.remove(backup_path) + deleted_backups.append({ + 'name': backup.get('backup_name') or os.path.basename(backup_path), + 'date': backup_time.isoformat() + }) + except Exception as e: + logger.error(f"Error deleting old backup {backup_path}: {str(e)}") + + return { + "status": "success", + "message": f"Retention policy applied: deleted {len(deleted_backups)} backups older than {retention_days} days", + "deleted_count": len(deleted_backups), + "deleted_backups": deleted_backups + } + + except Exception as e: + logger.error(f"Error applying retention policy: {str(e)}") + return { + "status": "error", + "message": f"Error applying retention policy: {str(e)}", + "deleted_count": 0, + "deleted_backups": [] + } \ No newline at end of file diff --git a/musicround/helpers/dropbox_helper.py b/musicround/helpers/dropbox_helper.py new file mode 100644 index 0000000..1bf7a5c --- /dev/null +++ b/musicround/helpers/dropbox_helper.py @@ -0,0 +1,495 @@ +""" +Helpers for Dropbox API integration +""" +from flask import current_app, url_for, redirect, session +import requests +import json +import os +from datetime import datetime, timedelta +from flask_login import current_user + +def get_dropbox_auth_url(): + """Get the authorization URL for Dropbox OAuth flow""" + app_key = current_app.config.get('DROPBOX_APP_KEY') + redirect_uri = url_for('users.dropbox_callback', _external=True) + + # Add the required scopes for our application + scopes = ["files.content.read", "files.content.write", "sharing.write","account_info.read"] + + auth_url = f'https://www.dropbox.com/oauth2/authorize?client_id={app_key}&response_type=code&redirect_uri={redirect_uri}&scope={" ".join(scopes)}&token_access_type=offline' + return auth_url + +def exchange_code_for_token(code): + """Exchange the authorization code for an access token""" + app_key = current_app.config.get('DROPBOX_APP_KEY') + app_secret = current_app.config.get('DROPBOX_APP_SECRET') + redirect_uri = url_for('users.dropbox_callback', _external=True) + + data = { + 'code': code, + 'grant_type': 'authorization_code', + 'client_id': app_key, + 'client_secret': app_secret, + 'redirect_uri': redirect_uri + } + + response = requests.post('https://api.dropboxapi.com/oauth2/token', data=data) + + if response.status_code == 200: + return response.json() + else: + current_app.logger.error(f"Error exchanging code for token: {response.text}") + return None + +def refresh_dropbox_token(refresh_token): + """Refresh an expired Dropbox access token""" + app_key = current_app.config.get('DROPBOX_APP_KEY') + app_secret = current_app.config.get('DROPBOX_APP_SECRET') + + data = { + 'refresh_token': refresh_token, + 'grant_type': 'refresh_token', + 'client_id': app_key, + 'client_secret': app_secret + } + + response = requests.post('https://api.dropboxapi.com/oauth2/token', data=data) + + if response.status_code == 200: + return response.json() + else: + current_app.logger.error(f"Error refreshing token: {response.text}") + return None + +def get_dropbox_user_info(access_token): + """Get user info from Dropbox API""" + headers = { + 'Authorization': f'Bearer {access_token}', + 'Content-Type': 'application/json' + } + + response = requests.post('https://api.dropboxapi.com/2/users/get_current_account', headers=headers) + + if response.status_code == 200: + return response.json() + else: + current_app.logger.error(f"Error getting user info: {response.text}") + return None + +def get_current_user_dropbox_token(): + """Get a valid Dropbox access token for the current user, refreshing if needed""" + if not current_user or not current_user.is_authenticated: + current_app.logger.error("No authenticated user") + return None + + # Check if token exists and is valid + if (current_user.dropbox_token and + current_user.dropbox_token_expiry and + current_user.dropbox_token_expiry > datetime.now() + timedelta(minutes=5)): + # Token is valid and not about to expire + return current_user.dropbox_token + + # Token is missing or about to expire - try to refresh + if current_user.dropbox_refresh_token: + from musicround.models import db + + # Try to refresh the token + token_info = refresh_dropbox_token(current_user.dropbox_refresh_token) + + if token_info and 'access_token' in token_info: + # Update token in database + current_user.dropbox_token = token_info['access_token'] + expires_in = token_info.get('expires_in', 14400) # Default to 4 hours if not specified + current_user.dropbox_token_expiry = datetime.now() + timedelta(seconds=expires_in) + + db.session.commit() + + return current_user.dropbox_token + + # If we get here, we couldn't refresh the token + current_app.logger.error("Failed to get valid Dropbox token") + return None + +def upload_and_share(file_path, dropbox_path): + """ + Upload a file to Dropbox and create a shared link + + Args: + file_path: Local path to the file to upload + dropbox_path: Destination path in Dropbox (including filename) + + Returns: + Shared link URL or None if upload failed + """ + token = get_current_user_dropbox_token() + if not token: + current_app.logger.error("No valid Dropbox token available") + return None + + # Make sure dropbox_path starts with / + if not dropbox_path.startswith('/'): + dropbox_path = '/' + dropbox_path + + # First, upload the file + try: + # Check if file exists + if not os.path.exists(file_path): + current_app.logger.error(f"File not found: {file_path}") + return None + + # Get file size + file_size = os.path.getsize(file_path) + + # For small files (< 150 MB), use simple upload + if file_size < 150 * 1024 * 1024: + with open(file_path, 'rb') as f: + file_data = f.read() + + headers = { + 'Authorization': f'Bearer {token}', + 'Dropbox-API-Arg': json.dumps({ + 'path': dropbox_path, + 'mode': 'overwrite', + 'autorename': True, + 'mute': False + }), + 'Content-Type': 'application/octet-stream' + } + + response = requests.post( + 'https://content.dropboxapi.com/2/files/upload', + headers=headers, + data=file_data + ) + + if response.status_code != 200: + current_app.logger.error(f"Error uploading file: {response.text}") + return None + + file_metadata = response.json() + current_app.logger.info(f"File uploaded successfully: {file_metadata.get('path_display')}") + else: + # For larger files, we'd implement chunked upload here + current_app.logger.error(f"File too large for simple upload: {file_size} bytes") + return None + + # Now create a shared link + headers = { + 'Authorization': f'Bearer {token}', + 'Content-Type': 'application/json' + } + + data = { + 'path': file_metadata.get('path_lower', dropbox_path), + 'settings': { + 'requested_visibility': 'public' # Make link publicly accessible + } + } + + response = requests.post( + 'https://api.dropboxapi.com/2/sharing/create_shared_link_with_settings', + headers=headers, + json=data + ) + + # If the link already exists, we'll get a 409 error with "shared_link_already_exists" + if response.status_code == 409 and "shared_link_already_exists" in response.text: + # Get existing links + list_data = { + 'path': file_metadata.get('path_lower', dropbox_path) + } + + list_response = requests.post( + 'https://api.dropboxapi.com/2/sharing/list_shared_links', + headers=headers, + json=list_data + ) + + if list_response.status_code == 200: + links_data = list_response.json() + if links_data.get('links') and len(links_data['links']) > 0: + # Return the first link's URL + return links_data['links'][0].get('url') + + elif response.status_code == 200: + share_data = response.json() + current_app.logger.info(f"Created shared link: {share_data.get('url')}") + return share_data.get('url') + + current_app.logger.error(f"Error creating shared link: {response.text}") + return None + + except Exception as e: + current_app.logger.error(f"Exception in upload_and_share: {str(e)}") + return None + +def refresh_dropbox_token_if_needed(user): + """ + Check if user's Dropbox token needs refreshing and refresh it if needed + + Args: + user: The User object with Dropbox token information + + Returns: + dict: {'success': True/False, 'message': 'success or error message'} + """ + if not user.dropbox_token or not user.dropbox_refresh_token: + return {'success': False, 'message': 'No Dropbox token available'} + + # If token is still valid, return success + if user.dropbox_token_expiry and user.dropbox_token_expiry > datetime.now() + timedelta(minutes=5): + return {'success': True, 'message': 'Token is still valid'} + + # Token needs refreshing + from musicround.models import db + + try: + token_info = refresh_dropbox_token(user.dropbox_refresh_token) + + if token_info and 'access_token' in token_info: + # Update token in database + user.dropbox_token = token_info['access_token'] + expires_in = token_info.get('expires_in', 14400) # Default to 4 hours if not specified + user.dropbox_token_expiry = datetime.now() + timedelta(seconds=expires_in) + + # If we got a new refresh token, update that too + if token_info.get('refresh_token'): + user.dropbox_refresh_token = token_info['refresh_token'] + + db.session.commit() + + return {'success': True, 'message': 'Token refreshed successfully'} + else: + return {'success': False, 'message': 'Failed to refresh token'} + + except Exception as e: + current_app.logger.error(f"Error refreshing Dropbox token: {str(e)}") + return {'success': False, 'message': f'Error refreshing token: {str(e)}'} + +def upload_to_dropbox(access_token, dropbox_path, data, mode='binary'): + """ + Upload data to Dropbox + + Args: + access_token: Dropbox access token + dropbox_path: Destination path in Dropbox (including filename) + data: The data to upload (bytes for binary mode, string for text mode) + mode: 'binary' or 'text' + + Returns: + dict: {'success': True/False, 'message': 'success or error message', 'metadata': file metadata if successful} + """ + # Make sure dropbox_path starts with / + if not dropbox_path.startswith('/'): + dropbox_path = '/' + dropbox_path + + try: + # Convert string data to bytes if text mode + if mode == 'text' and isinstance(data, str): + data = data.encode('utf-8') + + # Debug token information + token_preview = access_token[:10] + '...' if access_token else 'None' + current_app.logger.debug(f"Upload to Dropbox - Path: {dropbox_path}, Token preview: {token_preview}, Data size: {len(data) if data else 0} bytes") + + headers = { + 'Authorization': f'Bearer {access_token}', + 'Dropbox-API-Arg': json.dumps({ + 'path': dropbox_path, + 'mode': 'overwrite', + 'autorename': True, + 'mute': False + }), + 'Content-Type': 'application/octet-stream' + } + + current_app.logger.debug(f"Dropbox API headers: {headers}") + + response = requests.post( + 'https://content.dropboxapi.com/2/files/upload', + headers=headers, + data=data + ) + + current_app.logger.debug(f"Dropbox upload response code: {response.status_code}") + + if response.status_code != 200: + current_app.logger.error(f"Error uploading to Dropbox: Status code {response.status_code}") + current_app.logger.error(f"Response headers: {response.headers}") + + # Try to parse response body + try: + error_json = response.json() + current_app.logger.error(f"Error details: {json.dumps(error_json, indent=2)}") + error_message = error_json.get('error_summary', 'Unknown error') + except: + error_message = response.text[:500] # Limit to first 500 chars + current_app.logger.error(f"Raw error response: {error_message}") + + return { + 'success': False, + 'message': f"Error uploading file: {response.status_code} - {error_message}", + 'status_code': response.status_code + } + + file_metadata = response.json() + current_app.logger.info(f"File uploaded successfully: {file_metadata.get('path_display')}") + current_app.logger.debug(f"Upload metadata: {json.dumps(file_metadata, indent=2)}") + + return { + 'success': True, + 'message': 'File uploaded successfully', + 'metadata': file_metadata + } + + except Exception as e: + import traceback + current_app.logger.error(f"Exception in upload_to_dropbox: {str(e)}") + current_app.logger.error(traceback.format_exc()) + return { + 'success': False, + 'message': f"Error uploading file: {str(e)}" + } + +def create_shared_link(access_token, dropbox_path): + """ + Create a shared link for a file in Dropbox + + Args: + access_token: Dropbox access token + dropbox_path: Path to the file in Dropbox + + Returns: + dict: {'success': True/False, 'message': 'success or error message', 'url': shared link URL if successful} + """ + # Make sure dropbox_path starts with / + if not dropbox_path.startswith('/'): + dropbox_path = '/' + dropbox_path + + try: + # Debug token information + token_preview = access_token[:10] + '...' if access_token else 'None' + current_app.logger.debug(f"Creating shared link - Path: {dropbox_path}, Token preview: {token_preview}") + + headers = { + 'Authorization': f'Bearer {access_token}', + 'Content-Type': 'application/json' + } + + data = { + 'path': dropbox_path, + 'settings': { + 'requested_visibility': 'public' # Make link publicly accessible + } + } + + current_app.logger.debug(f"Sharing API request data: {json.dumps(data, indent=2)}") + + response = requests.post( + 'https://api.dropboxapi.com/2/sharing/create_shared_link_with_settings', + headers=headers, + json=data + ) + + current_app.logger.debug(f"Sharing API response code: {response.status_code}") + + # If the link already exists, we'll get a 409 error with "shared_link_already_exists" + if response.status_code == 409 and "shared_link_already_exists" in response.text: + current_app.logger.debug("Shared link already exists, retrieving existing link") + + # Get existing links + list_data = { + 'path': dropbox_path + } + + list_response = requests.post( + 'https://api.dropboxapi.com/2/sharing/list_shared_links', + headers=headers, + json=list_data + ) + + current_app.logger.debug(f"List shared links response code: {list_response.status_code}") + + if list_response.status_code == 200: + links_data = list_response.json() + current_app.logger.debug(f"Existing links data: {json.dumps(links_data, indent=2)}") + + if links_data.get('links') and len(links_data['links']) > 0: + # Return the first link's URL + url = links_data['links'][0].get('url') + current_app.logger.info(f"Retrieved existing shared link: {url}") + return { + 'success': True, + 'message': 'Existing shared link retrieved', + 'url': url + } + else: + current_app.logger.error("No links found despite 'shared_link_already_exists' error") + else: + current_app.logger.error(f"Error listing shared links: {list_response.text}") + + elif response.status_code == 200: + share_data = response.json() + current_app.logger.info(f"Created shared link: {share_data.get('url')}") + current_app.logger.debug(f"Shared link data: {json.dumps(share_data, indent=2)}") + return { + 'success': True, + 'message': 'Shared link created successfully', + 'url': share_data.get('url') + } + + # Try to parse error response + try: + error_json = response.json() + current_app.logger.error(f"Sharing API error details: {json.dumps(error_json, indent=2)}") + error_message = error_json.get('error_summary', 'Unknown error') + except: + error_message = response.text[:500] # Limit to first 500 chars + current_app.logger.error(f"Raw sharing API error response: {error_message}") + + current_app.logger.error(f"Error creating shared link: {response.status_code} - {error_message}") + return { + 'success': False, + 'message': f"Error creating shared link: {response.status_code} - {error_message}", + 'status_code': response.status_code + } + + except Exception as e: + import traceback + current_app.logger.error(f"Exception in create_shared_link: {str(e)}") + current_app.logger.error(traceback.format_exc()) + return { + 'success': False, + 'message': f"Error creating shared link: {str(e)}" + } + +def get_dropbox_account_info(access_token): + """ + Get account information for a Dropbox user + + Args: + access_token: Dropbox access token + + Returns: + dict: Account information or None if failed + """ + headers = { + 'Authorization': f'Bearer {access_token}' + } + + try: + # According to the API documentation, this endpoint requires no request body + response = requests.post( + 'https://api.dropboxapi.com/2/users/get_current_account', + headers=headers + ) + + if response.status_code == 200: + return response.json() + else: + current_app.logger.error(f"Error getting Dropbox account info: {response.text}") + return None + + except Exception as e: + current_app.logger.error(f"Exception in get_dropbox_account_info: {str(e)}") + return None \ No newline at end of file diff --git a/musicround/helpers/email_helper.py b/musicround/helpers/email_helper.py new file mode 100644 index 0000000..e739f70 --- /dev/null +++ b/musicround/helpers/email_helper.py @@ -0,0 +1,103 @@ +""" +Email helper functions for Quizzical Beats +""" +import smtplib +from email.mime.multipart import MIMEMultipart +from email.mime.text import MIMEText +from email.mime.base import MIMEBase +from email import encoders +from flask import current_app + +def send_email(recipient, subject, body_text, attachments=None): + """ + Sends an email with optional attachments. + + Args: + recipient (str): Email address of the recipient + subject (str): Email subject + body_text (str): Plain text email body + attachments (list): Optional list of attachment dictionaries with keys: + - 'data': The binary data of the attachment + - 'filename': Filename for the attachment + - 'mimetype': Mimetype string like 'application/pdf' + + Returns: + tuple: (success, message) where success is a boolean and message contains + details about the result + """ + # Get mail configuration from environment variables + mail_host = current_app.config.get('MAIL_HOST') + mail_port = current_app.config.get('MAIL_PORT') + mail_username = current_app.config.get('MAIL_USERNAME') + mail_password = current_app.config.get('MAIL_PASSWORD') + mail_sender = current_app.config.get('MAIL_SENDER') + + # Check if all email configuration parameters are available + missing_config = [] + if not mail_host: + missing_config.append("MAIL_HOST") + if not mail_port: + missing_config.append("MAIL_PORT") + if not mail_username: + missing_config.append("MAIL_USERNAME") + if not mail_password: + missing_config.append("MAIL_PASSWORD") + if not mail_sender: + missing_config.append("MAIL_SENDER") + + if missing_config: + missing_params = ", ".join(missing_config) + error_msg = f"Email server configuration is incomplete. Missing parameters: {missing_params}." + current_app.logger.error(f"Email configuration error: {error_msg}") + current_app.logger.error(f"Current config values - MAIL_HOST: {'set' if mail_host else 'missing'}, " + f"MAIL_PORT: {'set' if mail_port else 'missing'}, " + f"MAIL_USERNAME: {'set' if mail_username else 'missing'}, " + f"MAIL_PASSWORD: {'set' if mail_password else 'missing'}, " + f"MAIL_SENDER: {'set' if mail_sender else 'missing'}") + return False, error_msg + + # Create message object + msg = MIMEMultipart() + msg['From'] = mail_sender + msg['To'] = recipient + msg['Subject'] = subject + + # Attach text body + msg.attach(MIMEText(body_text, 'plain')) + + # Attach files if provided + if attachments: + for attachment in attachments: + part = MIMEBase( + attachment.get('mimetype', 'application/octet-stream').split('/')[0], + attachment.get('mimetype', 'application/octet-stream').split('/')[1] + ) + part.set_payload(attachment['data']) + encoders.encode_base64(part) + part.add_header( + 'Content-Disposition', + f'attachment; filename={attachment["filename"]}' + ) + msg.attach(part) + + try: + current_app.logger.info(f"Attempting to send email to {recipient} via {mail_host}:{mail_port}") + with smtplib.SMTP(mail_host, mail_port) as server: + server.starttls() + current_app.logger.debug("STARTTLS established") + server.login(mail_username, mail_password) + current_app.logger.debug(f"Login successful for {mail_username}") + server.sendmail(mail_sender, recipient, msg.as_string()) + current_app.logger.info(f"Email sent successfully from {mail_sender} to {recipient}") + + return True, f'Email sent successfully to {recipient}!' + + except smtplib.SMTPException as e: + error_msg = str(e) + current_app.logger.error(f"SMTP Error: {error_msg}") + current_app.logger.error(f"Failed to send email from {mail_sender} to {recipient} via {mail_host}:{mail_port}") + return False, error_msg + except Exception as e: + error_msg = f"Unexpected error: {str(e)}" + current_app.logger.error(error_msg) + return False, error_msg \ No newline at end of file diff --git a/musicround/helpers/import_helper.py b/musicround/helpers/import_helper.py new file mode 100644 index 0000000..17a0f16 --- /dev/null +++ b/musicround/helpers/import_helper.py @@ -0,0 +1,611 @@ +""" +Unified import helper for importing music content across different services. +This module provides consistent import functionality for tracks, albums, and playlists +from various music streaming services like Spotify and Deezer. +""" +import json +import logging +import secrets +import string +from flask import current_app, flash +from musicround.models import Song, Tag, db +from musicround.helpers.metadata import get_song_metadata_by_isrc + +def generate_token(length=32): + """ + Generate a secure random token for authentication or validation purposes. + + Args: + length (int): The length of the token to generate (default: 32) + + Returns: + str: A secure random token string + """ + # Use secrets module for cryptographically strong random numbers + alphabet = string.ascii_letters + string.digits + token = ''.join(secrets.choice(alphabet) for _ in range(length)) + return token + +class ImportHelper: + """Unified helper for importing music content from different services.""" + + # Helper method to create tags from genres + @staticmethod + def create_tags_from_genre(song, genre_data): + """ + Create tags from genre data and associate them with a song + + Args: + song (Song): Song object to associate tags with + genre_data (str or list): Genre data that could be string, list, or comma-separated values + """ + if not genre_data: + return + + genres = [] + + # Handle different types of genre data + if isinstance(genre_data, str): + # Handle comma-separated genre string + genres = [g.strip() for g in genre_data.split(',')] + elif isinstance(genre_data, list): + # Handle genre list + genres = [g.strip() if isinstance(g, str) else str(g).strip() for g in genre_data] + + # Add each genre as a tag + for genre_name in genres: + if not genre_name: + continue + + # Convert to lowercase for consistency + genre_name = genre_name.lower() + + # Find existing tag or create new one + tag = Tag.query.filter(Tag.name.ilike(genre_name)).first() + if not tag: + tag = Tag(name=genre_name) + db.session.add(tag) + try: + db.session.flush() # Flush to get ID but don't commit yet + except Exception as e: + current_app.logger.error(f"Error creating tag '{genre_name}': {e}") + continue + + # Add tag to song if not already present + if tag not in song.tags: + song.tags.append(tag) + current_app.logger.info(f"Added tag '{tag.name}' to song '{song.title}'") + + @staticmethod + def import_item(service_name, item_type, item_id): + """ + Import a track, album, or playlist from a specific service. + + Args: + service_name (str): Name of the service (e.g., 'spotify', 'deezer') + item_type (str): Type of item ('track', 'album', 'playlist') + item_id (str): ID of the item to import + + Returns: + dict: Summary of import operation with counts of imported items + """ + current_app.logger.info(f"Importing {item_type} {item_id} from {service_name}") + + result = { + 'success': False, + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [], + 'service': service_name, + 'item_type': item_type, + 'item_id': item_id + } + + try: + if service_name.lower() == 'spotify': + # Get Spotify client + sp = current_app.config.get('sp') + if not sp: + result['errors'].append("Spotify client not configured") + return result + + # Handle based on item type + if item_type.lower() == 'track': + track_result = ImportHelper.import_spotify_track(sp, item_id) + result.update(track_result) + elif item_type.lower() == 'album': + album_result = ImportHelper.import_spotify_album(sp, item_id) + result.update(album_result) + elif item_type.lower() == 'playlist': + playlist_result = ImportHelper.import_spotify_playlist(sp, item_id) + result.update(playlist_result) + else: + result['errors'].append(f"Unknown item type: {item_type}") + return result + + elif service_name.lower() == 'deezer': + # Get Deezer client + deezer_client = current_app.config.get('deezer') + if not deezer_client: + result['errors'].append("Deezer client not configured") + return result + + # Handle based on item type + if item_type.lower() == 'track': + track_result = ImportHelper.import_deezer_track(deezer_client, item_id) + result.update(track_result) + elif item_type.lower() == 'album': + album_result = ImportHelper.import_deezer_album(deezer_client, item_id) + result.update(album_result) + elif item_type.lower() == 'playlist': + playlist_result = ImportHelper.import_deezer_playlist(deezer_client, item_id) + result.update(playlist_result) + else: + result['errors'].append(f"Unknown item type: {item_type}") + return result + else: + result['errors'].append(f"Unsupported service: {service_name}") + return result + + result['success'] = len(result['errors']) == 0 + return result + + except Exception as e: + current_app.logger.error(f"Error importing {item_type} {item_id} from {service_name}: {str(e)}") + result['errors'].append(str(e)) + result['success'] = False + return result + + # ------------- SPOTIFY IMPORT METHODS ------------- + + @staticmethod + def import_spotify_track(sp, track_id): + """Import a single track from Spotify""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # First check if this Spotify track is already in our database + existing_song = Song.query.filter_by(spotify_id=track_id).first() + if existing_song: + current_app.logger.info(f'Song already exists: {existing_song.title} by {existing_song.artist}') + result['skipped_count'] += 1 + return result + + # Get track info from Spotify + track_info = sp.track(track_id) + if not track_info: + result['errors'].append(f"Track with ID {track_id} not found on Spotify") + result['error_count'] += 1 + return result + + # Try to get ISRC if available + isrc = track_info.get('external_ids', {}).get('isrc') + song = None + + # If we have an ISRC, check if a song with this ISRC already exists + if isrc: + existing_by_isrc = Song.query.filter(Song.isrc == isrc).first() + if existing_by_isrc: + current_app.logger.info(f'Song already exists by ISRC: {existing_by_isrc.title} by {existing_by_isrc.artist}') + result['skipped_count'] += 1 + return result + + # Get comprehensive metadata using ISRC + current_app.logger.info(f"Looking up metadata for ISRC: {isrc}") + metadata = get_song_metadata_by_isrc(isrc, current_app) + + if metadata and metadata.get("title"): + # Create song with enriched metadata + song = Song( + spotify_id=track_id, + deezer_id=metadata.get("deezer_id"), + title=metadata.get("title", track_info['name']), + artist=metadata.get("artist_name", ", ".join([artist['name'] for artist in track_info['artists']])), + genre=metadata.get("genre"), + year=metadata.get("year"), + preview_url=metadata.get("preview_url", track_info.get('preview_url')), + cover_url=metadata.get("cover_url") or (track_info['album']['images'][0]['url'] if track_info.get('album', {}).get('images') else None), + popularity=metadata.get("popularity", track_info.get('popularity')), + isrc=isrc, + album_name=track_info.get('album', {}).get('name'), + metadata_sources=','.join(metadata.get("sources", [])), + source='spotify', + spotify_preview_url=metadata.get("spotify_preview_url"), + deezer_preview_url=metadata.get("deezer_preview_url"), + apple_preview_url=metadata.get("apple_preview_url"), + youtube_preview_url=metadata.get("youtube_preview_url"), + spotify_cover_url=metadata.get("spotify_cover_url"), + deezer_cover_url=metadata.get("deezer_cover_url"), + apple_cover_url=metadata.get("apple_cover_url"), + additional_data=json.dumps({ + k: v for k, v in metadata.items() + if k not in ['artist_name', 'title', 'year', 'genre', 'popularity', + 'preview_url', 'sources', 'isrc', 'spotify_id', + 'deezer_id', 'cover_url', 'spotify_preview_url', + 'deezer_preview_url', 'apple_preview_url', + 'youtube_preview_url', 'spotify_cover_url', + 'deezer_cover_url', 'apple_cover_url'] + }) if metadata else None + ) + current_app.logger.info(f"Metadata found from sources: {metadata.get('sources', [])}") + else: + # Fallback to just Spotify data with the ISRC + song = ImportHelper._create_song_from_spotify(track_info, isrc) + else: + # No ISRC available, just use Spotify data + song = ImportHelper._create_song_from_spotify(track_info) + + # We already checked for duplicates above, so we can add the song directly + if song: + db.session.add(song) + + # Create tags from genre information + if song.genre: + ImportHelper.create_tags_from_genre(song, song.genre) + + # Also check additional data for genres + if song.additional_data: + try: + additional_data = json.loads(song.additional_data) + if 'genres' in additional_data: + ImportHelper.create_tags_from_genre(song, additional_data['genres']) + except Exception as e: + current_app.logger.error(f"Error parsing additional data for genres: {e}") + + # Get audio features if this is a Spotify track - NEW ADDITION + ImportHelper._fetch_audio_features_for_song(sp, song) + + db.session.commit() + current_app.logger.info(f'Imported Spotify track {song.title} by {song.artist}') + result['imported_count'] += 1 + else: + current_app.logger.warning(f'Could not create song from Spotify track {track_id}') + result['skipped_count'] += 1 + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Spotify track {track_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result + + @staticmethod + def import_spotify_album(sp, album_id): + """Import all tracks from a Spotify album""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # Get album tracks from Spotify + album_tracks = sp.album_tracks(album_id) + if not album_tracks or 'items' not in album_tracks: + result['errors'].append(f"Album with ID {album_id} not found on Spotify") + result['error_count'] += 1 + return result + + # Import each track in the album + for track in album_tracks['items']: + if track and 'id' in track: + track_result = ImportHelper.import_spotify_track(sp, track['id']) + result['imported_count'] += track_result['imported_count'] + result['skipped_count'] += track_result['skipped_count'] + result['error_count'] += track_result['error_count'] + result['errors'].extend(track_result['errors']) + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Spotify album {album_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result + + @staticmethod + def import_spotify_playlist(sp, playlist_id): + """Import all tracks from a Spotify playlist""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # Get playlist tracks from Spotify + tracks_info = sp.playlist_tracks(playlist_id) + if not tracks_info or 'items' not in tracks_info: + result['errors'].append(f"Playlist with ID {playlist_id} not found on Spotify") + result['error_count'] += 1 + return result + + # Import each track in the playlist + items = tracks_info.get('items', []) + for item in items: + # 'track' can be None if it's a local or unavailable track + track_obj = item.get('track') + if track_obj and 'id' in track_obj: + track_result = ImportHelper.import_spotify_track(sp, track_obj['id']) + result['imported_count'] += track_result['imported_count'] + result['skipped_count'] += track_result['skipped_count'] + result['error_count'] += track_result['error_count'] + result['errors'].extend(track_result['errors']) + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Spotify playlist {playlist_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result + + @staticmethod + def _create_song_from_spotify(track_info, isrc=None): + """Create a song object from Spotify track data""" + # Basic song with just Spotify data + preview_url = track_info.get('preview_url') + cover_url = track_info['album']['images'][0]['url'] if track_info.get('album', {}).get('images') else None + + # Extract year from album if available + year = None + if track_info.get('album') and track_info['album'].get('release_date'): + year = track_info['album']['release_date'][:4] + + # Try to get genre from album + genre = None + + # Create song object + return Song( + spotify_id=track_info['id'], + title=track_info['name'], + artist=", ".join([artist['name'] for artist in track_info['artists']]), + genre=genre, + year=year, + preview_url=preview_url, + cover_url=cover_url, + popularity=track_info.get('popularity'), + isrc=isrc, + album_name=track_info.get('album', {}).get('name'), + metadata_sources='spotify', + source='spotify' + ) + + @staticmethod + def _fetch_audio_features_for_song(sp, song): + """Fetch audio features for a Spotify song and update the song object""" + try: + audio_features = sp.audio_features(song.spotify_id) + if audio_features and len(audio_features) > 0: + features = audio_features[0] + song.danceability = features.get('danceability') + song.energy = features.get('energy') + song.key = features.get('key') + song.loudness = features.get('loudness') + song.mode = features.get('mode') + song.speechiness = features.get('speechiness') + song.acousticness = features.get('acousticness') + song.instrumentalness = features.get('instrumentalness') + song.liveness = features.get('liveness') + song.valence = features.get('valence') + song.tempo = features.get('tempo') + current_app.logger.info(f"Audio features fetched for song '{song.title}'") + except Exception as e: + current_app.logger.error(f"Error fetching audio features for song '{song.title}': {str(e)}") + + # ------------- DEEZER IMPORT METHODS ------------- + + @staticmethod + def import_deezer_track(deezer_client, track_id): + """Import a single track from Deezer""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # First check if this Deezer track is already in our database + existing_song = Song.query.filter_by(deezer_id=track_id).first() + if existing_song: + current_app.logger.info(f'Song already exists: {existing_song.title} by {existing_song.artist}') + result['skipped_count'] += 1 + return result + + # Get track info from Deezer + track = deezer_client.get_track(track_id) + if not track: + result['errors'].append(f"Track with ID {track_id} not found on Deezer") + result['error_count'] += 1 + return result + + # Check if ISRC is available + isrc = track.get('isrc') + song = None + + # If we have an ISRC, check if a song with this ISRC already exists + if isrc: + existing_by_isrc = Song.query.filter(Song.isrc == isrc).first() + if existing_by_isrc: + current_app.logger.info(f'Song already exists by ISRC: {existing_by_isrc.title} by {existing_by_isrc.artist}') + result['skipped_count'] += 1 + return result + + # Use metadata helper function to get comprehensive metadata + current_app.logger.info(f"Looking up metadata for ISRC: {isrc}") + metadata = get_song_metadata_by_isrc(isrc, current_app) + + # Use metadata if found, otherwise fall back to Deezer data only + if metadata and metadata.get("title"): + song = Song( + deezer_id=track.get('id'), + spotify_id=metadata.get("spotify_id"), + title=metadata.get("title", track.get('title')), + artist=metadata.get("artist_name", track.get('artist', {}).get('name') if track.get('artist') else 'Unknown Artist'), + preview_url=metadata.get("preview_url", track.get('preview')), + cover_url=metadata.get("cover_url") or track.get('album', {}).get('cover'), + genre=metadata.get("genre"), + year=metadata.get("year"), + popularity=metadata.get("popularity"), + isrc=isrc, + album_name=track.get('album', {}).get('title'), + metadata_sources=','.join(metadata.get("sources", [])), + source='deezer', + spotify_preview_url=metadata.get("spotify_preview_url"), + deezer_preview_url=metadata.get("deezer_preview_url"), + apple_preview_url=metadata.get("apple_preview_url"), + youtube_preview_url=metadata.get("youtube_preview_url"), + spotify_cover_url=metadata.get("spotify_cover_url"), + deezer_cover_url=metadata.get("deezer_cover_url"), + apple_cover_url=metadata.get("apple_cover_url"), + additional_data=json.dumps( + {k: v for k, v in metadata.items() if k not in ['artist_name', 'title', 'year', 'genre', + 'popularity', 'preview_url', 'sources', + 'isrc', 'spotify_id', 'deezer_id', 'cover_url', + 'spotify_preview_url', 'deezer_preview_url', + 'apple_preview_url', 'youtube_preview_url', + 'spotify_cover_url', 'deezer_cover_url', + 'apple_cover_url']} + ) if metadata else None + ) + current_app.logger.info(f"Metadata found from sources: {metadata.get('sources', [])}") + else: + # Fallback to just Deezer data + song = Song( + deezer_id=track.get('id'), + title=track.get('title'), + artist=track.get('artist', {}).get('name') if track.get('artist') else 'Unknown Artist', + preview_url=track.get('preview'), + cover_url=track.get('album', {}).get('cover'), + album_name=track.get('album', {}).get('title'), + metadata_sources='deezer', + source='deezer' + ) + else: + # No ISRC available, just use Deezer data + song = Song( + deezer_id=track.get('id'), + title=track.get('title'), + artist=track.get('artist', {}).get('name') if track.get('artist') else 'Unknown Artist', + preview_url=track.get('preview'), + cover_url=track.get('album', {}).get('cover'), + album_name=track.get('album', {}).get('title'), + metadata_sources='deezer', + source='deezer' + ) + + # We already checked for duplicates above, so we can add the song directly + if song: + db.session.add(song) + + # Create tags from genre information + if song.genre: + ImportHelper.create_tags_from_genre(song, song.genre) + + # Also check additional data for genres + if song.additional_data: + try: + additional_data = json.loads(song.additional_data) + if 'genres' in additional_data: + ImportHelper.create_tags_from_genre(song, additional_data['genres']) + except Exception as e: + current_app.logger.error(f"Error parsing additional data for genres: {e}") + + db.session.commit() + current_app.logger.info(f'Imported Deezer track {song.title} by {song.artist}') + result['imported_count'] += 1 + else: + current_app.logger.warning(f'Could not create song from Deezer track {track_id}') + result['skipped_count'] += 1 + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Deezer track {track_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result + + @staticmethod + def import_deezer_album(deezer_client, album_id): + """Import all tracks from a Deezer album""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # Get album info from Deezer + album = deezer_client.get_album(album_id) + if not album or not album.get('tracks') or not album['tracks'].get('data'): + result['errors'].append(f"Album with ID {album_id} not found on Deezer") + result['error_count'] += 1 + return result + + # Import each track in the album + tracks = album['tracks']['data'] + for track in tracks: + track_id = track.get('id') + if track_id: + track_result = ImportHelper.import_deezer_track(deezer_client, track_id) + result['imported_count'] += track_result['imported_count'] + result['skipped_count'] += track_result['skipped_count'] + result['error_count'] += track_result['error_count'] + result['errors'].extend(track_result['errors']) + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Deezer album {album_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result + + @staticmethod + def import_deezer_playlist(deezer_client, playlist_id): + """Import all tracks from a Deezer playlist""" + result = { + 'imported_count': 0, + 'skipped_count': 0, + 'error_count': 0, + 'errors': [] + } + + try: + # Get playlist info from Deezer + playlist = deezer_client.get_playlist(playlist_id) + if not playlist or not playlist.get('tracks') or not playlist['tracks'].get('data'): + result['errors'].append(f"Playlist with ID {playlist_id} not found on Deezer") + result['error_count'] += 1 + return result + + # Import each track in the playlist + tracks = playlist['tracks']['data'] + for track in tracks: + track_id = track.get('id') + if track_id: + track_result = ImportHelper.import_deezer_track(deezer_client, track_id) + result['imported_count'] += track_result['imported_count'] + result['skipped_count'] += track_result['skipped_count'] + result['error_count'] += track_result['error_count'] + result['errors'].extend(track_result['errors']) + + return result + + except Exception as e: + current_app.logger.error(f"Error importing Deezer playlist {playlist_id}: {str(e)}") + result['errors'].append(str(e)) + result['error_count'] += 1 + return result \ No newline at end of file diff --git a/musicround/helpers/metadata.py b/musicround/helpers/metadata.py new file mode 100644 index 0000000..b29a1c5 --- /dev/null +++ b/musicround/helpers/metadata.py @@ -0,0 +1,839 @@ +import requests +import json +import statistics +import musicbrainzngs +import openai +from flask import current_app +from collections import Counter +import traceback # Added for detailed error tracking + +def get_song_metadata_by_isrc(isrc, app=None): + """ + Get comprehensive song metadata by ISRC code from multiple sources. + + Args: + isrc (str): The ISRC code to look up + app: Flask application context (optional) + + Returns: + dict: Standardized metadata with the following keys: + - artist_name: Artist name(s) + - title: Title of the song + - year: Year the song was first released + - genre: Primary genre + - genres: All genres as an array + - popularity: Popularity rating (0-100) + - preview_url: Main preview URL (prioritized from sources) + - sources: List of sources that provided data + - spotify_id: Spotify track ID if available + - deezer_id: Deezer track ID if available + - And more provider-specific data + """ + # Initialize result dictionary + metadata = { + "artist_name": None, + "title": None, + "year": None, + "genre": None, + "genres": [], # New array to store all genres + "popularity": None, + "preview_url": None, + "sources": [], + "isrc": isrc, + "spotify_id": None, + "deezer_id": None, + # Cover URLs from different sources + "cover_url": None, + "spotify_cover_url": None, + "deezer_cover_url": None, + "apple_cover_url": None, + # Preview URLs from different sources + "spotify_preview_url": None, + "deezer_preview_url": None, + "apple_preview_url": None, + "youtube_preview_url": None + } + + # Store results from different sources to compare + artist_names = [] + titles = [] + years = [] + genres = [] # This will collect all genres for final processing + preview_urls = [] + + # Initialize logger if app context provided + logger = app.logger if app else None + if logger: + logger.info(f"=== DEBUG: Starting metadata refresh for ISRC: {isrc} ===") + + try: + # 0. Query ACRCloud first (provides info from multiple platforms) + if logger: + logger.info(f"DEBUG: Querying ACRCloud for ISRC: {isrc}") + acrcloud_data = get_acrcloud_data(isrc, app) + if acrcloud_data: + metadata["sources"].append("acrcloud") + if logger: + logger.info(f"DEBUG: ACRCloud data received: {json.dumps(acrcloud_data, default=str)}") + + if acrcloud_data.get("artist_name"): + artist_names.append(acrcloud_data["artist_name"]) + if acrcloud_data.get("title"): + titles.append(acrcloud_data["title"]) + if acrcloud_data.get("year"): + years.append(acrcloud_data["year"]) + if acrcloud_data.get("genre"): + # Debug the genre value + if logger: + logger.info(f"DEBUG: ACRCloud genre type: {type(acrcloud_data['genre']).__name__}") + logger.info(f"DEBUG: ACRCloud genre value: {acrcloud_data['genre']}") + + # Handle genre properly whether it's a string, list, or dict + if isinstance(acrcloud_data["genre"], list): + if logger: + logger.info(f"DEBUG: Processing genre as list: {acrcloud_data['genre']}") + genres.extend(acrcloud_data["genre"]) # ACRCloud might return multiple genres + elif isinstance(acrcloud_data["genre"], str): + if logger: + logger.info(f"DEBUG: Processing genre as string: {acrcloud_data['genre']}") + genres.append(acrcloud_data["genre"]) + elif isinstance(acrcloud_data["genre"], dict): + # Debug the dict structure + if logger: + logger.info(f"DEBUG: Processing genre as dict: {acrcloud_data['genre']}") + + # Extract genre name from dict if available + for genre_key, genre_value in acrcloud_data["genre"].items(): + if logger: + logger.info(f"DEBUG: Genre key: {genre_key}, value type: {type(genre_value).__name__}") + + if isinstance(genre_value, str): + if logger: + logger.info(f"DEBUG: Adding genre string: {genre_value}") + genres.append(genre_value) + elif isinstance(genre_value, list) and genre_value: + if logger: + logger.info(f"DEBUG: Adding genres from list: {genre_value}") + genres.extend([g for g in genre_value if isinstance(g, str)]) + else: + if logger: + logger.info(f"DEBUG: Skipping genre value of type: {type(genre_value).__name__}") + else: + if logger: + logger.info(f"DEBUG: Unknown genre type: {type(acrcloud_data['genre']).__name__}") + + # Store platform IDs + if acrcloud_data.get("spotify_id"): + metadata["spotify_id"] = acrcloud_data["spotify_id"] + if acrcloud_data.get("deezer_id"): + metadata["deezer_id"] = acrcloud_data["deezer_id"] + + # Store preview URLs from different sources + if acrcloud_data.get("spotify_preview_url"): + metadata["spotify_preview_url"] = acrcloud_data["spotify_preview_url"] + if acrcloud_data.get("deezer_preview_url"): + metadata["deezer_preview_url"] = acrcloud_data["deezer_preview_url"] + if acrcloud_data.get("apple_preview_url"): + metadata["apple_preview_url"] = acrcloud_data["apple_preview_url"] + if acrcloud_data.get("youtube_preview_url"): + metadata["youtube_preview_url"] = acrcloud_data["youtube_preview_url"] + + # Store cover URLs from different sources + if acrcloud_data.get("spotify_cover_url"): + metadata["spotify_cover_url"] = acrcloud_data["spotify_cover_url"] + if acrcloud_data.get("deezer_cover_url"): + metadata["deezer_cover_url"] = acrcloud_data["deezer_cover_url"] + if acrcloud_data.get("apple_cover_url"): + metadata["apple_cover_url"] = acrcloud_data["apple_cover_url"] + + # Store album cover as main cover if available + if acrcloud_data.get("album_cover"): + metadata["cover_url"] = acrcloud_data["album_cover"] + except Exception as e: + if logger: + logger.error(f"ACRCloud error for ISRC {isrc}: {e}") + logger.error(f"Traceback: {traceback.format_exc()}") + + try: + # 1. Query MusicBrainz (direct ISRC support) + mb_data = get_musicbrainz_data(isrc, logger) + if mb_data: + metadata["sources"].append("musicbrainz") + if mb_data.get("artist_name"): + artist_names.append(mb_data["artist_name"]) + if mb_data.get("title"): + titles.append(mb_data["title"]) + if mb_data.get("year"): + years.append(mb_data["year"]) + if mb_data.get("genre"): + genres.append(mb_data["genre"]) + except Exception as e: + if logger: + logger.error(f"MusicBrainz error for ISRC {isrc}: {e}") + + try: + # 2. Query Spotify (direct ISRC support) + spotify_data = get_spotify_data(isrc, app) + if spotify_data: + metadata["sources"].append("spotify") + if spotify_data.get("artist_name"): + artist_names.append(spotify_data["artist_name"]) + if spotify_data.get("title"): + titles.append(spotify_data["title"]) + if spotify_data.get("year"): + years.append(spotify_data["year"]) + if spotify_data.get("genre"): + genres.append(spotify_data["genre"]) + if spotify_data.get("popularity") is not None: + metadata["popularity"] = spotify_data["popularity"] + if spotify_data.get("spotify_preview_url"): + metadata["spotify_preview_url"] = spotify_data["spotify_preview_url"] + if spotify_data.get("id"): + metadata["spotify_id"] = spotify_data["id"] + if spotify_data.get("spotify_cover_url"): + metadata["spotify_cover_url"] = spotify_data["spotify_cover_url"] + except Exception as e: + if logger: + logger.error(f"Spotify error for ISRC {isrc}: {e}") + + try: + # 3. Query Deezer (direct ISRC support in newer API) + deezer_data = get_deezer_data(isrc, app) + if deezer_data: + metadata["sources"].append("deezer") + if deezer_data.get("artist_name"): + artist_names.append(deezer_data["artist_name"]) + if deezer_data.get("title"): + titles.append(deezer_data["title"]) + if deezer_data.get("year"): + years.append(deezer_data["year"]) + if deezer_data.get("genre"): + genres.append(deezer_data["genre"]) + if deezer_data.get("deezer_preview_url"): + metadata["deezer_preview_url"] = deezer_data["deezer_preview_url"] + if deezer_data.get("id"): + metadata["deezer_id"] = deezer_data["id"] + if deezer_data.get("deezer_cover_url"): + metadata["deezer_cover_url"] = deezer_data["deezer_cover_url"] + except Exception as e: + if logger: + logger.error(f"Deezer error for ISRC {isrc}: {e}") + + # Debug the collected data before processing + if logger: + logger.info(f"DEBUG: All collected artist names: {artist_names}") + logger.info(f"DEBUG: All collected titles: {titles}") + logger.info(f"DEBUG: All collected years: {years}") + logger.info(f"DEBUG: All collected genres: {genres}") + + # Determine most common values so far + if artist_names and titles: + try: + # Use the most frequent values from collected data + if logger: + logger.info(f"DEBUG: Computing most common artist from: {artist_names}") + metadata["artist_name"] = Counter(artist_names).most_common(1)[0][0] + + if logger: + logger.info(f"DEBUG: Computing most common title from: {titles}") + metadata["title"] = Counter(titles).most_common(1)[0][0] + + # With artist and title, we can query services that don't support ISRC + try: + # 4. Query Last.fm + lastfm_data = get_lastfm_data(metadata["artist_name"], metadata["title"], app) + if lastfm_data: + metadata["sources"].append("lastfm") + if lastfm_data.get("genre"): + genres.append(lastfm_data["genre"]) + except Exception as e: + if logger: + logger.error(f"Last.fm error for {metadata['artist_name']} - {metadata['title']}: {e}") + logger.error(f"Traceback: {traceback.format_exc()}") + + try: + # 5. Query OpenAI for additional verification + openai_data = get_openai_data(metadata["artist_name"], metadata["title"], app) + if openai_data: + metadata["sources"].append("openai") + if openai_data.get("year"): + years.append(openai_data["year"]) + if openai_data.get("genre"): + genres.append(openai_data["genre"]) + except Exception as e: + if logger: + logger.error(f"OpenAI error for {metadata['artist_name']} - {metadata['title']}: {e}") + logger.error(f"Traceback: {traceback.format_exc()}") + except Exception as e: + if logger: + logger.error(f"Error determining most common values: {e}") + logger.error(f"Artist names: {artist_names}") + logger.error(f"Titles: {titles}") + logger.error(f"Traceback: {traceback.format_exc()}") + + # Process collected data + if years: + try: + # For year, take the earliest one as "first released" + if logger: + logger.info(f"DEBUG: Processing years: {years}") + + numeric_years = [int(y) for y in years if y and y.isdigit()] + if numeric_years: + metadata["year"] = str(min(numeric_years)) + if logger: + logger.info(f"DEBUG: Selected earliest year: {metadata['year']}") + except Exception as e: + # Fallback to most common if conversion fails + if logger: + logger.error(f"Year processing error: {e}") + logger.error(f"Traceback: {traceback.format_exc()}") + + try: + metadata["year"] = Counter(years).most_common(1)[0][0] + if logger: + logger.info(f"DEBUG: Fallback to most common year: {metadata['year']}") + except Exception as e2: + if logger: + logger.error(f"Year fallback error: {e2}") + + # Process all genres and create a clean list for tagging + if genres: + try: + # First, clean up genres for storage + clean_genres = [] + for g in genres: + if isinstance(g, str) and g.strip(): + # Translate specific genre names to English + if g.strip().lower() == "vaihtoehtoinen": + clean_genres.append("Alternative") + if logger: + logger.info(f"DEBUG: Translated genre 'Vaihtoehtoinen' to 'Alternative'") + else: + clean_genres.append(g.strip()) + elif isinstance(g, list): + # Flatten any nested lists and translate if needed + for item in g: + if isinstance(item, str) and item.strip(): + if item.strip().lower() == "vaihtoehtoinen": + clean_genres.append("Alternative") + if logger: + logger.info(f"DEBUG: Translated genre 'Vaihtoehtoinen' to 'Alternative'") + else: + clean_genres.append(item.strip()) + + # Store all unique genres in the metadata + unique_genres = [] + for g in clean_genres: + if g.lower() not in [existing.lower() for existing in unique_genres]: + unique_genres.append(g) + + metadata["genres"] = unique_genres + + if logger: + logger.info(f"DEBUG: All cleaned genres: {unique_genres}") + + # For the main genre field, take the most common one + if clean_genres: + # Get a case-insensitive count by converting all to lowercase + lowercase_genres = [g.lower() for g in clean_genres] + genre_counter = Counter(lowercase_genres) + most_common_genre_lower = genre_counter.most_common(1)[0][0] + + # Find the original case version from our clean genres + for g in clean_genres: + if g.lower() == most_common_genre_lower: + metadata["genre"] = g + break + + if logger: + logger.info(f"DEBUG: Selected most common genre as main: {metadata['genre']}") + except Exception as e: + if logger: + logger.error(f"Genre processing error: {e}") + logger.error(f"Traceback: {traceback.format_exc()}") + + # Process preview URLs with priority for Spotify, then Apple Music, then Deezer + preview_sources = [ + metadata.get("spotify_preview_url"), + metadata.get("apple_preview_url"), + metadata.get("deezer_preview_url"), + metadata.get("youtube_preview_url") + ] + + # Select the first available preview URL as the main one + for url in preview_sources: + if url: + metadata["preview_url"] = url + if logger: + logger.info(f"DEBUG: Selected preview URL: {url}") + break + + # Process cover URLs with priority + cover_sources = [ + metadata.get("spotify_cover_url"), + metadata.get("apple_cover_url"), + metadata.get("deezer_cover_url") + ] + + # Select the first available cover URL as the main one if not already set + if not metadata["cover_url"]: + for url in cover_sources: + if url: + metadata["cover_url"] = url + if logger: + logger.info(f"DEBUG: Selected cover URL: {url}") + break + + if logger: + logger.info(f"=== DEBUG: Completed metadata refresh for ISRC: {isrc} ===") + logger.info(f"=== Final metadata: {json.dumps(metadata, default=str)} ===") + + return metadata + +def get_musicbrainz_data(isrc, logger=None): + """Query MusicBrainz API using ISRC""" + result = {} + + # Set user agent for MusicBrainz API + musicbrainzngs.set_useragent("MusicRound", "0.1", "fret@fret.de") + + try: + # Search MusicBrainz by ISRC + mb_results = musicbrainzngs.search_recordings(isrc=isrc, limit=1) + if mb_results and mb_results.get('recording-list') and len(mb_results['recording-list']) > 0: + recording = mb_results['recording-list'][0] + + # Extract title + result["title"] = recording.get('title') + + # Extract artist name + if recording.get('artist-credit'): + artist_names = [] + for artist_credit in recording['artist-credit']: + if isinstance(artist_credit, dict) and 'artist' in artist_credit: + artist_names.append(artist_credit['artist']['name']) + if artist_names: + result["artist_name"] = ", ".join(artist_names) + + # Extract genre tags + if 'tag-list' in recording: + tags = [tag['name'] for tag in recording['tag-list']] + if tags: + result["genre"] = tags[0] + + # Get release year + if 'release-list' in recording and recording['release-list']: + release = recording['release-list'][0] + if 'date' in release: + result["year"] = release['date'][:4] # Extract year from date + except Exception as e: + if logger: + logger.error(f"MusicBrainz API error: {e}") + + return result + +def get_spotify_data(isrc, app=None): + """Query Spotify API using ISRC""" + result = {} + + try: + # Get Spotify client from app context + sp = app.config.get('sp') if app else None + if not sp: + return result + + # Search Spotify by ISRC + query = f"isrc:{isrc}" + spotify_result = sp.search(q=query, type='track') + + if spotify_result and spotify_result.get('tracks') and spotify_result['tracks'].get('items'): + track = spotify_result['tracks']['items'][0] + + # Extract track title + result["title"] = track.get('name') + + # Extract artist names + if track.get('artists'): + result["artist_name"] = ", ".join([artist['name'] for artist in track['artists']]) + + # Extract popularity + result["popularity"] = track.get('popularity') + + # Extract preview URL + result["spotify_preview_url"] = track.get('preview_url') + + # Store main track ID + result["id"] = track.get('id') + + # Get album details to extract more info + if track.get('album') and track['album'].get('id'): + album = sp.album(track['album']['id']) + + # Extract genre + if album.get('genres') and len(album['genres']) > 0: + result["genre"] = album['genres'][0] + + # Extract release year + if album.get('release_date'): + result["year"] = album['release_date'][:4] + + # Extract cover images + if track['album'].get('images') and len(track['album']['images']) > 0: + for img in track['album']['images']: + if img.get('height') and img.get('width') and img.get('url'): + if img['height'] > 600: # Consider this a large image + result["spotify_cover_url"] = img['url'] + break + # If we didn't find a large image, use the first one + if not result.get("spotify_cover_url") and track['album']['images'][0].get('url'): + result["spotify_cover_url"] = track['album']['images'][0]['url'] + except Exception as e: + if app: + app.logger.error(f"Spotify API error: {e}") + + return result + +def get_deezer_data(isrc, app=None): + """Query Deezer API using ISRC""" + result = {} + + try: + # Get Deezer client from app context or create a basic one + deezer_client = app.config.get('deezer') if app else None + + if not deezer_client: + # If no client in app context, make direct API call + response = requests.get(f"https://api.deezer.com/track/isrc:{isrc}") + if response.status_code == 200: + track = response.json() + else: + return result + else: + # Try to use the ISRC search if available, or search by track if not + try: + track = deezer_client._make_request(f"track/isrc:{isrc}") + except: + # Deezer client might not have direct ISRC support, so try a workaround + # (This would require having title and artist from another source) + track = None + + if track and not track.get('error'): + # Extract title + result["title"] = track.get('title') + + # Extract artist name + if track.get('artist'): + result["artist_name"] = track['artist'].get('name') + + # Extract preview URL + result["deezer_preview_url"] = track.get('preview') + + # Extract Deezer ID + result["id"] = track.get('id') + + # Get album details to extract more info + if track.get('album') and track['album'].get('id'): + album_id = track['album']['id'] + + if deezer_client: + album = deezer_client.get_album(album_id) + else: + album_response = requests.get(f"https://api.deezer.com/album/{album_id}") + album = album_response.json() if album_response.status_code == 200 else None + + if album and not album.get('error'): + # Extract genre + if album.get('genres') and album['genres'].get('data') and len(album['genres']['data']) > 0: + result["genre"] = album['genres']['data'][0].get('name') + + # Extract release year + if album.get('release_date'): + result["year"] = album['release_date'][:4] + + # Extract cover image + if track['album'].get('cover'): + result["deezer_cover_url"] = track['album']['cover'] + # Try the bigger version + if track['album'].get('cover_xl'): + result["deezer_cover_url"] = track['album']['cover_xl'] + elif track['album'].get('cover_big'): + result["deezer_cover_url"] = track['album']['cover_big'] + except Exception as e: + if app: + app.logger.error(f"Deezer API error: {e}") + + return result + +def get_lastfm_data(artist_name, track_title, app=None): + """Query Last.fm API using artist name and track title""" + result = {} + + if not artist_name or not track_title: + return result + + try: + # Get Last.fm API key from app context or environment + lastfm_api_key = None + if app: + lastfm_api_key = app.config.get('LASTFM_API_KEY') + + if not lastfm_api_key: + return result + + # Query Last.fm API + url = 'http://ws.audioscrobbler.com/2.0/' + params = { + 'method': 'track.getInfo', + 'api_key': lastfm_api_key, + 'artist': artist_name, + 'track': track_title, + 'format': 'json' + } + + response = requests.get(url=url, params=params) + if response.status_code == 200: + data = response.json() + + # Extract genre from top tags + if (data.get('track') and + data['track'].get('toptags') and + data['track']['toptags'].get('tag')): + tags = data['track']['toptags']['tag'] + if tags and len(tags) > 0: + result["genre"] = tags[0]['name'] + except Exception as e: + if app: + app.logger.error(f"Last.fm API error: {e}") + + return result + +def get_openai_data(artist_name, track_title, app=None): + """Query OpenAI API for additional metadata verification""" + result = {} + + if not artist_name or not track_title: + return result + + try: + # Get OpenAI API details from app context + if not app: + return result + + openai_api_key = app.config.get('OPENAI_API_KEY') + openai_url = app.config.get('OPENAI_URL') + openai_model = app.config.get('OPENAI_MODEL') + + if not openai_api_key or not openai_model: + return result + + # Configure OpenAI API key + openai.api_key = openai_api_key + + # Create prompt + prompt = f"Provide the genre and release year for the song '{track_title}' by {artist_name}. Return the data as a JSON object with keys 'genre' and 'year'. If the information is not available, return null for the corresponding key." + + # Log the query + app.logger.info(f"ChatGPT Query: {prompt}") + + content = None + + # Check which version of the OpenAI library is being used + if hasattr(openai, 'chat') and hasattr(openai.chat, 'completions'): + # New OpenAI API client (>= 1.0.0) + if openai_url: + openai.base_url = openai_url + + # Call OpenAI API with new client + try: + response = openai.chat.completions.create( + model=openai_model, + messages=[{"role": "user", "content": prompt}], + response_format={"type": "json_object"} + ) + + if response and hasattr(response, 'choices') and response.choices: + content = response.choices[0].message.content + app.logger.info(f"ChatGPT Response: {content}") + except Exception as e: + app.logger.error(f"OpenAI chat completions error: {e}") + # Try falling back to completion API if available + try: + if hasattr(openai, 'Completion'): + response = openai.Completion.create( + engine=openai_model, + prompt=prompt, + max_tokens=200, + temperature=0.2, + top_p=1.0 + ) + if response and hasattr(response, 'choices') and len(response.choices) > 0: + content = response.choices[0].text.strip() + app.logger.info(f"OpenAI Completion Response: {content}") + except Exception as inner_e: + app.logger.error(f"OpenAI completion fallback error: {inner_e}") + else: + # Old OpenAI API client (< 1.0.0) + if openai_url: + openai.api_base = openai_url # Different attribute in old client + + # Call OpenAI API with old client + try: + response = openai.Completion.create( + engine=openai_model, # In old API, it's 'engine' instead of 'model' + prompt=prompt, + max_tokens=200, + temperature=0.2, + top_p=1.0 + ) + + if response and hasattr(response, 'choices') and len(response.choices) > 0: + content = response.choices[0].text.strip() + app.logger.info(f"ChatGPT Response: {content}") + except Exception as e: + app.logger.error(f"OpenAI completion error: {e}") + + # Process the response content + if content: + try: + # Try to extract JSON from the content (handle cases where there might be extra text) + import re + json_match = re.search(r'(\{.*\})', content, re.DOTALL) + if json_match: + json_str = json_match.group(1) + data = json.loads(json_str) + else: + data = json.loads(content) + + if data.get("genre"): + result["genre"] = data["genre"] + if data.get("year"): + # Always convert year to string + result["year"] = str(data["year"]) + + # If we got valid data, return it + if "genre" in result or "year" in result: + return result + + except Exception as e: + app.logger.error(f"Error parsing OpenAI response: {e}") + app.logger.error(f"Raw response content: {content}") + except AttributeError as e: + app.logger.error(f"OpenAI module error: {e}") + except Exception as e: + if app: + app.logger.error(f"OpenAI API error: {e}") + + return result + +def get_acrcloud_data(isrc, app=None): + """Query ACRCloud API using ISRC""" + result = {} + + if not app: + return result + + try: + # Get ACRCloud API key from app config + acrcloud_token = app.config.get('ACRCLOUD_TOKEN') + if not acrcloud_token: + logger = app.logger if app else None + if logger: + logger.warning("ACRCloud token not found in app config.") + return result + + # Query ACRCloud API for track metadata + url = "https://eu-api-v2.acrcloud.com/api/external-metadata/tracks" + headers = { + 'Authorization': f'Bearer {acrcloud_token}' + } + params = { + 'isrc': isrc, + 'platforms': 'spotify,deezer,youtube,applemusic', + 'include_works': 1 # Include additional work metadata + } + + response = requests.get(url, headers=headers, params=params) + if response.status_code != 200: + app.logger.warning(f"ACRCloud API error: {response.status_code} - {response.text}") + return result + + data = response.json() + if not data or not data.get('data') or not len(data['data']) > 0: + return result + + track_data = data['data'][0] + logger = app.logger if app else None + if logger: + logger.info(f"ACRCloud API response: {json.dumps(data, default=str)}") + # Extract basic metadata + if track_data.get('name'): + result['title'] = track_data['name'] + + if track_data.get('artists') and len(track_data['artists']) > 0: + artist_names = [artist['name'] for artist in track_data['artists'] if 'name' in artist] + result['artist_name'] = ', '.join(artist_names) + + if track_data.get('release_date'): + result['year'] = track_data['release_date'][:4] # Extract year + + if track_data.get('genres'): + result['genre'] = track_data['genres'] + + # Extract album cover if available + if track_data.get('album') and track_data['album'].get('cover'): + result['album_cover'] = track_data['album']['cover'] + + # Also get covers from specific sizes if available + if track_data['album'].get('covers'): + covers = track_data['album']['covers'] + if covers.get('large'): + result['album_cover_large'] = covers['large'] + if covers.get('medium'): + result['album_cover_medium'] = covers['medium'] + + # Get external metadata from platforms + ext_meta = track_data.get('external_metadata', {}) + + # Get Spotify metadata + if 'spotify' in ext_meta and ext_meta['spotify'] and len(ext_meta['spotify']) > 0: + spotify_data = ext_meta['spotify'][0] + if spotify_data.get('id'): + result['spotify_id'] = spotify_data['id'] + if spotify_data.get('preview'): + result['spotify_preview_url'] = spotify_data['preview'] + if spotify_data.get('album') and spotify_data['album'].get('cover'): + result['spotify_cover_url'] = spotify_data['album']['cover'] + + # Get Deezer metadata + if 'deezer' in ext_meta and ext_meta['deezer'] and len(ext_meta['deezer']) > 0: + deezer_data = ext_meta['deezer'][0] + if deezer_data.get('id'): + result['deezer_id'] = deezer_data['id'] + # Deezer preview URL might come from additional API call + if deezer_data.get('album') and deezer_data['album'].get('cover'): + result['deezer_cover_url'] = deezer_data['album']['cover'] + + # Get Apple Music metadata + if 'applemusic' in ext_meta and ext_meta['applemusic'] and len(ext_meta['applemusic']) > 0: + apple_data = ext_meta['applemusic'][0] + if apple_data.get('preview'): + result['apple_preview_url'] = apple_data['preview'] + if apple_data.get('album') and apple_data['album'].get('cover'): + result['apple_cover_url'] = apple_data['album']['cover'] + + # Get YouTube metadata + if 'youtube' in ext_meta and ext_meta['youtube'] and len(ext_meta['youtube']) > 0: + youtube_data = ext_meta['youtube'][0] + if youtube_data.get('id'): + youtube_id = youtube_data['id'] + result['youtube_id'] = youtube_id + # Construct a YouTube Music playback URL + result['youtube_preview_url'] = f"https://music.youtube.com/watch?v={youtube_id}" + + return result + except Exception as e: + if app: + app.logger.error(f"ACRCloud API error: {e}") + + return result diff --git a/musicround/helpers/spotify_direct.py b/musicround/helpers/spotify_direct.py new file mode 100644 index 0000000..2c12771 --- /dev/null +++ b/musicround/helpers/spotify_direct.py @@ -0,0 +1,304 @@ +""" +Direct Spotify Web API client implementation. +This is an alternative to spotipy for testing and comparison purposes. +""" +import json +import os +import time +import requests +import logging +from flask import current_app + +class SpotifyDirectClient: + """ + A client for the Spotify Web API that directly uses the HTTP endpoints + rather than using the spotipy library. + """ + def __init__(self, client_id=None, client_secret=None, cache_path=None, bearer_token=None): + self.client_id = client_id or current_app.config['SPOTIFY_CLIENT_ID'] + self.client_secret = client_secret or current_app.config['SPOTIFY_CLIENT_SECRET'] + self.cache_path = cache_path or os.path.join('/data', '.spotifycache') + self.base_url = 'https://api.spotify.com/v1' + self.token_url = 'https://accounts.spotify.com/api/token' + self.access_token = bearer_token # Use provided bearer token if available + self.token_expiry = 0 + self.refresh_token = None + self.logger = logging.getLogger(__name__) + + # Configure session with retry logic + self.session = requests.Session() + from requests.adapters import HTTPAdapter + from urllib3.util import Retry + retries = Retry( + total=5, + backoff_factor=0.5, + status_forcelist=[429, 500, 502, 503, 504] + ) + self.session.mount('https://', HTTPAdapter(max_retries=retries)) + + # Only load tokens from cache if bearer token was not provided + if not bearer_token: + self._load_token_from_cache() + + def _load_token_from_cache(self): + """Load access and refresh tokens from cache file""" + if not os.path.exists(self.cache_path): + self.logger.warning(f"Cache file not found at {self.cache_path}") + return + + try: + with open(self.cache_path, 'r') as f: + token_info = json.load(f) + self.access_token = token_info.get('access_token') + self.refresh_token = token_info.get('refresh_token') + self.token_expiry = token_info.get('expires_at', 0) + self.logger.info("Loaded tokens from cache file") + except Exception as e: + self.logger.error(f"Error loading tokens from cache: {e}") + + def _save_token_to_cache(self, token_info): + """Save token information to cache file""" + try: + with open(self.cache_path, 'w') as f: + json.dump(token_info, f) + self.logger.info("Saved tokens to cache file") + except Exception as e: + self.logger.error(f"Error saving tokens to cache: {e}") + + def _refresh_access_token(self): + """Refresh the access token using the refresh token""" + if not self.refresh_token: + self.logger.error("No refresh token available. User must log in again.") + return False + + self.logger.info("Refreshing access token...") + + data = { + 'grant_type': 'refresh_token', + 'refresh_token': self.refresh_token, + 'client_id': self.client_id, + 'client_secret': self.client_secret + } + + try: + response = self.session.post(self.token_url, data=data) + response.raise_for_status() + + token_info = response.json() + self.access_token = token_info['access_token'] + self.token_expiry = int(time.time()) + token_info['expires_in'] + + # If new refresh token provided, update it + if 'refresh_token' in token_info: + self.refresh_token = token_info['refresh_token'] + + # Update cache + token_info['expires_at'] = self.token_expiry + if 'refresh_token' not in token_info and self.refresh_token: + token_info['refresh_token'] = self.refresh_token + + self._save_token_to_cache(token_info) + return True + + except Exception as e: + self.logger.error(f"Error refreshing access token: {e}") + return False + + def _ensure_token_valid(self): + """Check if token is valid and refresh if needed""" + # If we're using a manually provided bearer token, assume it's valid + if self.access_token and not self.refresh_token: + return True + + # Otherwise use the normal refresh logic + if not self.access_token or time.time() > self.token_expiry - 60: + return self._refresh_access_token() + return True + + def _make_api_request(self, endpoint, method='GET', params=None, data=None, retry_on_auth_error=True): + """Make a request to the Spotify API with automatic token refresh""" + if not self._ensure_token_valid(): + return None + + url = f"{self.base_url}/{endpoint}" + headers = { + 'Authorization': f'Bearer {self.access_token}', + 'Content-Type': 'application/json' + } + + try: + if method == 'GET': + response = self.session.get(url, headers=headers, params=params) + elif method == 'POST': + response = self.session.post(url, headers=headers, json=data, params=params) + elif method == 'PUT': + response = self.session.put(url, headers=headers, json=data, params=params) + elif method == 'DELETE': + response = self.session.delete(url, headers=headers, params=params) + else: + self.logger.error(f"Unsupported HTTP method: {method}") + return None + + # Handle 401 by refreshing token and retrying once + if response.status_code == 401 and retry_on_auth_error: + self.logger.info("Got 401, refreshing token and retrying...") + if self._refresh_access_token(): + return self._make_api_request(endpoint, method, params, data, retry_on_auth_error=False) + + response.raise_for_status() + return response.json() + + except requests.exceptions.HTTPError as e: + self.logger.error(f"HTTP error: {e}") + # Log the response content for debugging + if hasattr(e, 'response') and e.response: + self.logger.error(f"Response status: {e.response.status_code}") + self.logger.error(f"Response content: {e.response.text}") + return None + + except Exception as e: + self.logger.error(f"Error making API request: {e}") + return None + + def user_playlists(self, user_id, limit=50, offset=0): + """ + Get a user's playlists. Mirrors the spotipy interface. + + Args: + user_id: The Spotify user ID + limit: Maximum number of playlists to return (max 50) + offset: The index of the first playlist to return + + Returns: + A dictionary containing the user's playlists or None if an error occurred + """ + endpoint = f"users/{user_id}/playlists" + params = { + 'limit': min(limit, 50), # Spotify API has a max limit of 50 + 'offset': offset + } + + self.logger.info(f"Fetching {limit} playlists at offset {offset} for user {user_id}") + result = self._make_api_request(endpoint, params=params) + + if result: + self.logger.info(f"Got {len(result.get('items', []))} playlists, total {result.get('total', 0)}") + else: + self.logger.error("Failed to fetch playlists") + + return result + + def fetch_all_user_playlists(self, user_id, limit=50): + """ + Fetch all playlists for a user with proper pagination. + + Args: + user_id: The Spotify user ID + limit: Maximum number of playlists per request (max 50) + + Returns: + List of all playlists from the user + """ + all_playlists = [] + offset = 0 + total = None + max_loops = 50 # Safety limit + loop_count = 0 + + self.logger.info(f"Starting to fetch all playlists for user {user_id}") + start_time = time.time() + + while loop_count < max_loops: + loop_count += 1 + + result = self.user_playlists(user_id, limit=limit, offset=offset) + if not result: + self.logger.error(f"Failed to fetch playlists for user {user_id} at offset {offset}") + break + + # Get total on first request + if total is None: + total = result.get('total', 0) + self.logger.info(f"User has {total} total playlists according to API") + + # Process items from this batch + items = result.get('items', []) + item_count = len(items) + all_playlists.extend(items) + + self.logger.info(f"Fetched {item_count} playlists for user {user_id}, progress: {len(all_playlists)}/{total}") + + # Break if we got fewer items than requested (last page) + if item_count < limit: + self.logger.info(f"Received fewer items than requested, assuming end of list") + break + + # Update offset for next batch + offset += item_count + + # Break if we've fetched all playlists + if offset >= total: + self.logger.info(f"Reached total {total} playlists") + break + + # Break if next URL is None (no more pages) + if not result.get('next'): + self.logger.info(f"No 'next' URL in response, end of pagination") + # Check for inconsistency + if offset < total: + self.logger.warning(f"API inconsistency: no more pages but only fetched {len(all_playlists)}/{total}") + break + + duration_ms = int((time.time() - start_time) * 1000) + self.logger.info(f"Completed fetching {len(all_playlists)}/{total} playlists in {duration_ms}ms") + + return all_playlists + + def get_track_audio_features(self, track_id): + """ + Get audio features for a specific track + + Args: + track_id: Spotify ID of the track + + Returns: + dict: Audio features for the track or None if not found + """ + self.logger.info(f"Getting audio features for track {track_id}") + if not self._ensure_token_valid(): + return None + + endpoint = f"audio-features/{track_id}" + return self._make_api_request(endpoint) + + def get_tracks_audio_features(self, track_ids): + """ + Get audio features for multiple tracks in a single request + + Args: + track_ids: List of Spotify track IDs (max 100) + + Returns: + list: List of audio features for tracks + """ + if not track_ids: + return [] + + self.logger.info(f"Getting audio features for {len(track_ids)} tracks") + if not self._ensure_token_valid(): + return None + + # Spotify API only accepts up to 100 IDs per request + if len(track_ids) > 100: + self.logger.warning("More than 100 track IDs provided, only fetching the first 100") + track_ids = track_ids[:100] + + # Convert list to comma-separated string + ids_param = ",".join(track_ids) + + endpoint = "audio-features" + result = self._make_api_request(endpoint, params={"ids": ids_param}) + + if result and "audio_features" in result: + return result["audio_features"] + return [] \ No newline at end of file diff --git a/musicround/helpers/utils.py b/musicround/helpers/utils.py new file mode 100644 index 0000000..eba7131 --- /dev/null +++ b/musicround/helpers/utils.py @@ -0,0 +1,303 @@ +""" +General utility functions used throughout the application. +""" +import secrets +import string +import os +import shutil +from flask import current_app +from werkzeug.utils import secure_filename +import uuid +import requests +import json + +def generate_token(length=32): + """ + Generate a secure random token for authentication or validation purposes. + + Args: + length (int): The length of the token to generate (default: 32) + + Returns: + str: A secure random token string + """ + # Use secrets module for cryptographically strong random numbers + alphabet = string.ascii_letters + string.digits + token = ''.join(secrets.choice(alphabet) for _ in range(length)) + return token + +def get_user_mp3_directory(username): + """ + Get the directory path for a user's custom MP3 files + Creates the directory if it doesn't exist + + Args: + username (str): Username + + Returns: + str: Path to the user's MP3 directory + """ + base_dir = os.path.join('/data', 'custommp3') + user_dir = os.path.join(base_dir, secure_filename(username)) + + # Create directories if they don't exist + if not os.path.exists(base_dir): + os.makedirs(base_dir) + if not os.path.exists(user_dir): + os.makedirs(user_dir) + + return user_dir + +def save_user_mp3(file, username, mp3_type): + """ + Save a user's uploaded MP3 file + + Args: + file: FileStorage object from Flask request.files + username (str): Username + mp3_type (str): Type of MP3 (intro, outro, or replay) + + Returns: + str: Path to the saved file relative to data directory + """ + if not file or not allowed_file(file.filename): + return None + + # Get user directory and create if needed + user_dir = get_user_mp3_directory(username) + + # Generate a unique filename to avoid overwriting + original_filename = secure_filename(file.filename) + file_extension = os.path.splitext(original_filename)[1] # Should be .mp3 + unique_filename = f"{mp3_type}{file_extension}" + + # Full path to save the file + filepath = os.path.join(user_dir, unique_filename) + + # Save the file + file.save(filepath) + + # Return the relative path for database storage + return os.path.join('custommp3', secure_filename(username), unique_filename) + +def allowed_file(filename): + """ + Check if the file has an allowed extension + + Args: + filename (str): Name of the file + + Returns: + bool: True if extension is allowed, False otherwise + """ + allowed_extensions = {'mp3'} + return '.' in filename and filename.rsplit('.', 1)[1].lower() in allowed_extensions + +def get_mp3_path(user, mp3_type): + """ + Get the path to a user's custom MP3 file or the default if not set + + Args: + user: User object from database + mp3_type (str): Type of MP3 (intro, outro, or replay) + + Returns: + str: Path to the MP3 file + """ + user_setting_attr = f"{mp3_type}_mp3" + user_mp3_path = getattr(user, user_setting_attr) + + if user_mp3_path and os.path.exists(os.path.join('/data', user_mp3_path)): + return os.path.join('/data', user_mp3_path) + + # Fall back to the default MP3 + return os.path.join(current_app.root_path, 'static', 'audio', f'{mp3_type}.mp3') + +def get_available_voices(service='polly'): + """ + Get a list of available voices for the specified TTS service + + Args: + service (str): TTS service ('polly', 'openai', or 'elevenlabs') + + Returns: + list: List of available voice options + """ + if service == 'polly': + # Standard AWS Polly voices - subset of most natural ones + return [ + {'id': 'Joanna', 'name': 'Joanna (Female, US)', 'gender': 'Female', 'language': 'en-US'}, + {'id': 'Matthew', 'name': 'Matthew (Male, US)', 'gender': 'Male', 'language': 'en-US'}, + {'id': 'Amy', 'name': 'Amy (Female, UK)', 'gender': 'Female', 'language': 'en-GB'}, + {'id': 'Brian', 'name': 'Brian (Male, UK)', 'gender': 'Male', 'language': 'en-GB'}, + {'id': 'Kendra', 'name': 'Kendra (Female, US)', 'gender': 'Female', 'language': 'en-US'}, + {'id': 'Kimberly', 'name': 'Kimberly (Female, US)', 'gender': 'Female', 'language': 'en-US'}, + {'id': 'Salli', 'name': 'Salli (Female, US)', 'gender': 'Female', 'language': 'en-US'}, + {'id': 'Joey', 'name': 'Joey (Male, US)', 'gender': 'Male', 'language': 'en-US'}, + ] + elif service == 'openai': + return [ + {'id': 'alloy', 'name': 'Alloy (Neutral)', 'gender': 'Neutral', 'language': 'en'}, + {'id': 'echo', 'name': 'Echo (Male)', 'gender': 'Male', 'language': 'en'}, + {'id': 'fable', 'name': 'Fable (Male)', 'gender': 'Male', 'language': 'en'}, + {'id': 'onyx', 'name': 'Onyx (Male)', 'gender': 'Male', 'language': 'en'}, + {'id': 'nova', 'name': 'Nova (Female)', 'gender': 'Female', 'language': 'en'}, + {'id': 'shimmer', 'name': 'Shimmer (Female)', 'gender': 'Female', 'language': 'en'}, + ] + elif service == 'elevenlabs': + # Check if we have a valid API key + api_key = current_app.config.get('ELEVENLABS_API_KEY') + if not api_key: + return [] + + try: + # Call the ElevenLabs API to get available voices + headers = { + "xi-api-key": api_key, + "Content-Type": "application/json" + } + response = requests.get("https://api.elevenlabs.io/v1/voices", headers=headers) + + if response.status_code == 200: + voices_data = response.json() + voices = [] + for voice in voices_data.get('voices', []): + voice_info = { + 'id': voice.get('voice_id'), + 'name': voice.get('name', 'Unknown'), + 'gender': voice.get('labels', {}).get('gender', 'Unknown'), + 'language': 'en' # Default to English + } + voices.append(voice_info) + return voices + else: + current_app.logger.error(f"Error fetching ElevenLabs voices: {response.status_code} - {response.text}") + return [] + except Exception as e: + current_app.logger.error(f"Exception fetching ElevenLabs voices: {str(e)}") + return [] + + # Default fallback + return [] + +def generate_tts_mp3(text, username, mp3_type, service='polly', voice=None, model=None, stability=None, similarity=None): + """ + Generate a text-to-speech MP3 file + + Args: + text (str): The text to convert to speech + username (str): Username + mp3_type (str): Type of MP3 (intro, outro, or replay) + service (str): TTS service to use ('polly', 'openai', or 'elevenlabs') + voice (str): Voice ID to use (defaults to service-specific default if None) + model (str): Model to use for OpenAI or ElevenLabs (defaults to service-specific default if None) + stability (float): Voice stability parameter for ElevenLabs (0.0-1.0) + similarity (float): Voice similarity parameter for ElevenLabs (0.0-1.0) + + Returns: + str: Path to the generated file relative to data directory + """ + try: + user_dir = get_user_mp3_directory(username) + output_filename = f"{mp3_type}.mp3" + output_path = os.path.join(user_dir, output_filename) + + if service == 'polly': + # AWS Polly implementation + import boto3 + + polly_client = boto3.client('polly', + region_name=current_app.config.get('AWS_REGION', 'us-east-1'), + aws_access_key_id=current_app.config.get('AWS_ACCESS_KEY_ID'), + aws_secret_access_key=current_app.config.get('AWS_SECRET_ACCESS_KEY') + ) + + # Use provided voice or default + voice_id = voice or current_app.config.get('AWS_POLLY_VOICE', 'Joanna') + + # Use neural engine if available + engine = 'neural' if voice_id in ['Joanna', 'Matthew', 'Amy', 'Emma', 'Brian', 'Kendra'] else 'standard' + + response = polly_client.synthesize_speech( + Text=text, + OutputFormat='mp3', + VoiceId=voice_id, + Engine=engine + ) + + # Write the audio stream to a file + if "AudioStream" in response: + with open(output_path, 'wb') as file: + file.write(response["AudioStream"].read()) + + current_app.logger.info(f"Generated AWS Polly TTS with voice {voice_id} for {username}/{mp3_type}") + + elif service == 'openai': + # OpenAI TTS implementation + import openai + + openai.api_key = current_app.config.get('OPENAI_API_KEY') + openai.base_url = current_app.config.get('OPENAI_URL', 'https://api.openai.com/v1') + + # Use provided voice or default + voice_id = voice or 'alloy' + # Use provided model or default + tts_model = model or 'tts-1' # Options: tts-1, tts-1-hd + + response = openai.audio.speech.create( + model=tts_model, + voice=voice_id, + input=text + ) + + response.stream_to_file(output_path) + current_app.logger.info(f"Generated OpenAI TTS with voice {voice_id} for {username}/{mp3_type}") + + elif service == 'elevenlabs': + # ElevenLabs implementation + api_key = current_app.config.get('ELEVENLABS_API_KEY') + if not api_key: + current_app.logger.error("ElevenLabs API key not configured") + return None + + # Use provided voice or default + voice_id = voice or "21m00Tcm4TlvDq8ikWAM" # Default to "Rachel" voice + + # Set default values for stability and similarity if not provided + stability_value = stability if stability is not None else 0.5 + similarity_value = similarity if similarity is not None else 0.75 + + headers = { + "xi-api-key": api_key, + "Content-Type": "application/json" + } + + payload = { + "text": text, + "model_id": model or "eleven_monolingual_v1", + "voice_settings": { + "stability": stability_value, + "similarity_boost": similarity_value + } + } + + response = requests.post( + f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}", + headers=headers, + data=json.dumps(payload) + ) + + if response.status_code == 200: + with open(output_path, 'wb') as file: + file.write(response.content) + current_app.logger.info(f"Generated ElevenLabs TTS with voice {voice_id} for {username}/{mp3_type}") + else: + current_app.logger.error(f"ElevenLabs API error: {response.status_code} - {response.text}") + return None + + # Return the relative path for database storage + return os.path.join('custommp3', secure_filename(username), output_filename) + + except Exception as e: + current_app.logger.error(f"Error generating TTS MP3: {str(e)}") + return None diff --git a/musicround/models.py b/musicround/models.py new file mode 100644 index 0000000..fc94dbc --- /dev/null +++ b/musicround/models.py @@ -0,0 +1,331 @@ +from datetime import datetime +from musicround import db +from flask_login import UserMixin +from werkzeug.security import generate_password_hash, check_password_hash +import uuid + +# User-Role association table for many-to-many relationship +user_roles = db.Table('user_roles', + db.Column('user_id', db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'), primary_key=True), + db.Column('role_id', db.Integer, db.ForeignKey('role.id', ondelete='CASCADE'), primary_key=True) +) + +class Role(db.Model): + """ + Role model for user permissions + """ + id = db.Column(db.Integer, primary_key=True) + name = db.Column(db.String(50), unique=True, nullable=False) + description = db.Column(db.String(255)) + + def __repr__(self): + return f"Role(id={self.id}, name='{self.name}')" + + +class UserPreferences(db.Model): + """ + User preferences model for storing user-specific settings + """ + id = db.Column(db.Integer, primary_key=True) + user_id = db.Column(db.Integer, db.ForeignKey('user.id'), unique=True) + default_tts_service = db.Column(db.String(32), default='polly') + enable_intro = db.Column(db.Boolean, default=True) + theme = db.Column(db.String(16), default='light') + user = db.relationship('User', back_populates='preferences') + + +class User(db.Model, UserMixin): + """ + User model for authentication and user management + """ + id = db.Column(db.Integer, primary_key=True) + username = db.Column(db.String(80), index=True, unique=True, nullable=False) + email = db.Column(db.String(120), index=True, unique=True, nullable=False) + password_hash = db.Column(db.String(255), nullable=True) # Now nullable for OAuth-only users + first_name = db.Column(db.String(50)) + last_name = db.Column(db.String(50)) + active = db.Column(db.Boolean, default=True) + is_admin = db.Column(db.Boolean, default=False) + created_at = db.Column(db.DateTime, default=datetime.utcnow) + last_login = db.Column(db.DateTime) + + # Token for password reset, email verification, etc. + reset_token = db.Column(db.String(100), index=True, unique=True) + reset_token_expiry = db.Column(db.DateTime) + + # Authentication provider info + auth_provider = db.Column(db.String(20), default='local') # 'local', 'google', 'authentik' + + # OAuth provider info - Spotify + oauth_id = db.Column(db.String(100)) # Spotify user ID + spotify_token = db.Column(db.Text) # Store Spotify access token + spotify_refresh_token = db.Column(db.Text) # Store Spotify refresh token + spotify_token_expiry = db.Column(db.DateTime) + + # OAuth provider info - Google + google_id = db.Column(db.String(100)) # Google user ID + google_token = db.Column(db.Text) # Store Google access token + google_refresh_token = db.Column(db.Text) # Store Google refresh token + + # OAuth provider info - Authentik + authentik_id = db.Column(db.String(100)) # Authentik user ID + authentik_token = db.Column(db.Text) # Store Authentik access token + authentik_refresh_token = db.Column(db.Text) # Store Authentik refresh token + + # OAuth provider info - Dropbox + dropbox_id = db.Column(db.String(100)) # Dropbox user ID + dropbox_token = db.Column(db.Text) # Store Dropbox access token + dropbox_refresh_token = db.Column(db.Text) # Store Dropbox refresh token + dropbox_token_expiry = db.Column(db.DateTime) # Dropbox token expiration + dropbox_export_path = db.Column(db.String(255), default='/QuizzicalBeats') # User's preferred Dropbox export folder + + # User preferences + intro_mp3 = db.Column(db.String(255)) # Custom intro MP3 path + outro_mp3 = db.Column(db.String(255)) # Custom outro MP3 path + replay_mp3 = db.Column(db.String(255)) # Custom replay MP3 path + + # Relationships + roles = db.relationship('Role', secondary=user_roles, backref=db.backref('users', lazy='dynamic')) + preferences = db.relationship('UserPreferences', uselist=False, back_populates='user') + + @property + def password(self): + """Password getter should raise an error""" + raise AttributeError('password is not a readable attribute') + + @password.setter + def password(self, password): + """Hash and store the password""" + self.password_hash = generate_password_hash(password) + + def check_password(self, password): + """Check if provided password matches the hash""" + return check_password_hash(self.password_hash, password) + + def set_token(self): + """Generate a unique token for the user""" + self.reset_token = str(uuid.uuid4()) + return self.reset_token + + def has_role(self, role_name): + """Check if user has a specific role""" + return any(role.name == role_name for role in self.roles) + + def is_admin(self): + """Check if user is an admin""" + return self.has_role('admin') + + def __repr__(self): + return f"User(id={self.id}, username='{self.username}', email='{self.email}')" + + +class Tag(db.Model): + """ + Tag model for storing song tags + """ + id = db.Column(db.Integer, primary_key=True) + name = db.Column(db.String(50), unique=True, nullable=False) + created_at = db.Column(db.DateTime, default=datetime.utcnow) + + # Define relationship to songs via SongTag + songs = db.relationship('Song', secondary='song_tag', back_populates='tags') + + def __repr__(self): + return f"Tag(id={self.id}, name='{self.name}')" + + +class SongTag(db.Model): + """ + Association table for Song-Tag many-to-many relationship + """ + __tablename__ = 'song_tag' + + song_id = db.Column(db.Integer, db.ForeignKey('song.id', ondelete='CASCADE'), primary_key=True) + tag_id = db.Column(db.Integer, db.ForeignKey('tag.id', ondelete='CASCADE'), primary_key=True) + created_at = db.Column(db.DateTime, default=datetime.utcnow) + + def __repr__(self): + return f"SongTag(song_id={self.song_id}, tag_id={self.tag_id})" + + +class Song(db.Model): + """ + Song model for storing song details from Spotify and Deezer + """ + id = db.Column(db.Integer, primary_key=True) + spotify_id = db.Column(db.String(100), unique=True, nullable=True) + deezer_id = db.Column(db.Integer, unique=True, nullable=True) + isrc = db.Column(db.String(20), index=True, nullable=True) # Add ISRC code + title = db.Column(db.String(200), nullable=False) + artist = db.Column(db.String(200), nullable=False) + album_name = db.Column(db.String(200), nullable=True) # Album name + genre = db.Column(db.String(100)) + year = db.Column(db.Integer) + preview_url = db.Column(db.String(500)) # Increased length for longer URLs - primary preview URL + cover_url = db.Column(db.String(500)) # Increased length - primary cover URL + spotify_preview_url = db.Column(db.String(500), nullable=True) # Spotify-specific preview + deezer_preview_url = db.Column(db.String(500), nullable=True) # Deezer-specific preview + apple_preview_url = db.Column(db.String(500), nullable=True) # Apple Music preview + youtube_preview_url = db.Column(db.String(500), nullable=True) # YouTube preview + spotify_cover_url = db.Column(db.String(500), nullable=True) # Spotify cover + deezer_cover_url = db.Column(db.String(500), nullable=True) # Deezer cover + apple_cover_url = db.Column(db.String(500), nullable=True) # Apple Music cover + popularity = db.Column(db.Integer) + used_count = db.Column(db.Integer, default=0) + source = db.Column(db.String(20), default='spotify') # 'spotify', 'deezer', or 'acrcloud' + import_date = db.Column(db.DateTime, default=datetime.utcnow) # Add import date + added_at = db.Column(db.DateTime, default=datetime.utcnow) + last_used = db.Column(db.DateTime) + metadata_sources = db.Column(db.String(500), nullable=True) # Comma-separated list of metadata sources + + # Spotify Audio Features + acousticness = db.Column(db.Float, nullable=True) # Confidence of track being acoustic (0.0 to 1.0) + danceability = db.Column(db.Float, nullable=True) # How suitable for dancing (0.0 to 1.0) + energy = db.Column(db.Float, nullable=True) # Intensity and activity measure (0.0 to 1.0) + instrumentalness = db.Column(db.Float, nullable=True) # Predicts if track has no vocals (0.0 to 1.0) + key = db.Column(db.Integer, nullable=True) # Key of the track (standard Pitch Class notation, -1 = no key) + liveness = db.Column(db.Float, nullable=True) # Presence of audience in recording (0.0 to 1.0) + loudness = db.Column(db.Float, nullable=True) # Overall loudness in dB (-60 to 0 typically) + mode = db.Column(db.Integer, nullable=True) # Modality - major (1) or minor (0) + speechiness = db.Column(db.Float, nullable=True) # Presence of spoken words (0.0 to 1.0) + tempo = db.Column(db.Float, nullable=True) # Estimated tempo in BPM + time_signature = db.Column(db.Integer, nullable=True) # Estimated time signature (3 to 7 representing 3/4 to 7/4) + valence = db.Column(db.Float, nullable=True) # Musical positiveness (0.0 to 1.0) + duration_ms = db.Column(db.Integer, nullable=True) # Duration of track in milliseconds + analysis_url = db.Column(db.String(500), nullable=True) # URL to access full audio analysis + + # Additional properties as JSON strings + additional_data = db.Column(db.Text, nullable=True) # Store additional data as JSON + + # Relationship with tags + tags = db.relationship('Tag', secondary='song_tag', back_populates='songs') + + def __repr__(self): + return ( + f"Song('{self.id}', '{self.title}', '{self.artist}', " + f"'{self.genre}', '{self.year}', source='{self.source}', " + f"isrc='{self.isrc}', spotify_id='{self.spotify_id}', deezer_id='{self.deezer_id}')" + ) + + def to_dict(self): + return { + 'id': self.id, + 'title': self.title, + 'artist': self.artist, + 'album_name': self.album_name, + 'cover_url': self.cover_url, + 'preview_url': self.preview_url, + 'spotify_id': self.spotify_id, + 'deezer_id': self.deezer_id, + 'isrc': self.isrc, + 'year': self.year, + 'genre': self.genre, + 'popularity': self.popularity, + 'used_count': self.used_count, + 'last_used': self.last_used.strftime('%Y-%m-%d %H:%M:%S') if self.last_used else None, + 'metadata_sources': self.metadata_sources, + 'tags': [{'id': tag.id, 'name': tag.name} for tag in self.tags], + # Include audio features in the dictionary + 'acousticness': self.acousticness, + 'danceability': self.danceability, + 'energy': self.energy, + 'instrumentalness': self.instrumentalness, + 'key': self.key, + 'liveness': self.liveness, + 'loudness': self.loudness, + 'mode': self.mode, + 'speechiness': self.speechiness, + 'tempo': self.tempo, + 'time_signature': self.time_signature, + 'valence': self.valence, + 'duration_ms': self.duration_ms + } + + +class Round(db.Model): + """ + Round model for storing quiz rounds and their associated songs + """ + id = db.Column(db.Integer, primary_key=True) + name = db.Column(db.String(200), nullable=True) # Optional name for the round + round_type = db.Column(db.String(50), nullable=False) + round_criteria_used = db.Column(db.String(500), nullable=False) + songs = db.Column(db.Text, nullable=False) # JSON string of song IDs in order + genre = db.Column(db.String(100)) + decade = db.Column(db.String(10)) + tag = db.Column(db.String(50)) + created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow) + mp3_generated = db.Column(db.Boolean, default=False) # Track if MP3 has been generated + pdf_generated = db.Column(db.Boolean, default=False) # Track if PDF has been generated + last_generated_at = db.Column(db.DateTime, nullable=True) # When files were last generated + + def __repr__(self): + return ( + f"Round('{self.name or self.id}', '{self.round_type}', '{self.round_criteria_used}', " + f"'{self.songs}', '{self.created_at}')" + ) + + @property + def song_list(self): + """ + Returns a list of Song objects associated with this round + """ + song_ids = self.songs.split(',') + return Song.query.filter(Song.id.in_(song_ids)).all() + + def reset_generated_status(self): + """ + Reset the MP3 and PDF generated flags when a round is modified + """ + self.mp3_generated = False + self.pdf_generated = False + + +class RoundExport(db.Model): + """ + Model to track round exports to various destinations (Dropbox, email, etc.) + """ + id = db.Column(db.Integer, primary_key=True) + round_id = db.Column(db.Integer, db.ForeignKey('round.id', ondelete='CASCADE'), nullable=False) + user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='SET NULL'), nullable=True) + export_type = db.Column(db.String(20), nullable=False) # 'dropbox', 'email', etc. + timestamp = db.Column(db.DateTime, default=datetime.utcnow, nullable=False) + destination = db.Column(db.String(500), nullable=True) # Path, email address, etc. + include_mp3s = db.Column(db.Boolean, default=False) # Whether MP3s were included + status = db.Column(db.String(20), default='success') # 'success', 'failed' + error_message = db.Column(db.Text, nullable=True) # Error details if failed + + # Relationships + round = db.relationship('Round', backref=db.backref('exports', lazy='dynamic')) + user = db.relationship('User', backref=db.backref('exports', lazy='dynamic')) + + def __repr__(self): + return f"RoundExport(id={self.id}, round_id={self.round_id}, type='{self.export_type}', timestamp='{self.timestamp}')" + + +class SystemSetting(db.Model): + __tablename__ = 'system_settings' + id = db.Column(db.Integer, primary_key=True) + key = db.Column(db.String(64), unique=True, nullable=False) + value = db.Column(db.Text, nullable=True) + + @staticmethod + def get(key, default=None): + setting = SystemSetting.query.filter_by(key=key).first() + return setting.value if setting else default + + @staticmethod + def set(key, value): + setting = SystemSetting.query.filter_by(key=key).first() + if not setting: + setting = SystemSetting(key=key, value=value) + db.session.add(setting) + else: + setting.value = value + db.session.commit() + + @staticmethod + def all_settings(): + return {s.key: s.value for s in SystemSetting.query.all()} + diff --git a/musicround/mp3/1.mp3 b/musicround/mp3/1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..db0b7445d216192ab0dea4b1d7ff110eb7a8faa6 GIT binary patch literal 6381 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 Hzgztu7zX+$ literal 0 HcmV?d00001 diff --git a/musicround/mp3/3.mp3 b/musicround/mp3/3.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..ae461ec3935899cee9fd92a62ca775c7ff858560 GIT binary patch literal 6669 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 X0-v8$CVgtgk^yYN|JC{bL;L>#JS~ac literal 0 HcmV?d00001 diff --git a/musicround/mp3/7.mp3 b/musicround/mp3/7.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..0ee88f0db5b03dddc33d7d8fbda0f079742fd2b8 GIT binary patch literal 6813 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 Z{{I)k^GLU?I0g6){QUpF-2b`4{{W;XBW3^q literal 0 HcmV?d00001 diff --git a/musicround/mp3/8.mp3 b/musicround/mp3/8.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..c943a7548799cf4f8aecd66560bc61fdbdd245f5 GIT binary patch literal 6093 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 I{{JuZKm3mxP5=M^ literal 0 HcmV?d00001 diff --git a/musicround/mp3/outro.mp3 b/musicround/mp3/outro.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..600fbaf6d247bff3f3ebbd8f74fa532ceccd22aa GIT binary patch literal 16461 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 literal 0 HcmV?d00001 diff --git a/musicround/routes/api.py b/musicround/routes/api.py new file mode 100644 index 0000000..ce07f1a --- /dev/null +++ b/musicround/routes/api.py @@ -0,0 +1,1073 @@ +""" +API routes for song operations in the Music Round application +""" +from flask import Blueprint, jsonify, request, current_app, session, redirect, url_for +from musicround.models import Song, Tag, SongTag, db, Round +from musicround.helpers.metadata import get_song_metadata_by_isrc +from flask_wtf.csrf import CSRFProtect +import traceback # Add import at the top +import spotipy as spotify # Changed import from spotify to spotipy as spotify +import logging +from sqlalchemy import or_ +from flask_login import login_required # Add import for login_required + +api_bp = Blueprint('api', __name__, url_prefix='/api') + +@api_bp.route('/songs/', methods=['GET', 'PUT', 'DELETE']) +def song_detail(song_id): + """API endpoint for getting, updating, and deleting song details""" + song = Song.query.get_or_404(song_id) + + if request.method == 'GET': + # Return song details as JSON + tag_list = [{'id': tag.id, 'name': tag.name} for tag in song.tags] + + return jsonify({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist, + 'genre': song.genre, + 'year': song.year, + 'isrc': song.isrc, + 'popularity': song.popularity, + 'used_count': song.used_count, + 'spotify_id': song.spotify_id, + 'deezer_id': song.deezer_id, + 'preview_url': song.preview_url, + 'cover_url': song.cover_url, + 'spotify_preview_url': song.spotify_preview_url, + 'deezer_preview_url': song.deezer_preview_url, + 'apple_preview_url': song.apple_preview_url, + 'youtube_preview_url': song.youtube_preview_url, + 'spotify_cover_url': song.spotify_cover_url, + 'deezer_cover_url': song.deezer_cover_url, + 'apple_cover_url': song.apple_cover_url, + 'metadata_sources': song.metadata_sources, + 'album_name': song.album_name, + 'source': song.source, + 'import_date': song.import_date.isoformat() if song.import_date else None, + 'tags': tag_list, + # Add all Spotify audio features + 'acousticness': song.acousticness, + 'danceability': song.danceability, + 'energy': song.energy, + 'instrumentalness': song.instrumentalness, + 'key': song.key, + 'liveness': song.liveness, + 'loudness': song.loudness, + 'mode': song.mode, + 'speechiness': song.speechiness, + 'tempo': song.tempo, + 'time_signature': song.time_signature, + 'valence': song.valence, + 'duration_ms': song.duration_ms + }) + + elif request.method == 'PUT': + # Update song details + data = request.get_json() + current_app.logger.info(f"Updating song {song_id} with data: {data}") + + # Update basic fields + if data.get('title'): + song.title = data['title'] + if data.get('artist'): + song.artist = data['artist'] + if data.get('genre'): + song.genre = data['genre'] + if data.get('year'): + song.year = data['year'] + if data.get('isrc'): + song.isrc = data['isrc'] + if 'popularity' in data and data['popularity'] is not None: + try: + song.popularity = int(data['popularity']) + except (ValueError, TypeError): + current_app.logger.warning(f"Invalid popularity value: {data['popularity']}") + + # Update IDs + if data.get('spotify_id'): + song.spotify_id = data['spotify_id'] + if data.get('deezer_id'): + song.deezer_id = data['deezer_id'] + + # Update URLs + if data.get('preview_url'): + song.preview_url = data['preview_url'] + if data.get('cover_url'): + song.cover_url = data['cover_url'] + + # Save changes + db.session.commit() + current_app.logger.info(f"Song {song_id} updated successfully") + + # Return updated song details including tags + tag_list = [{'id': tag.id, 'name': tag.name} for tag in song.tags] + + return jsonify({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist, + 'genre': song.genre, + 'year': song.year, + 'isrc': song.isrc, + 'popularity': song.popularity, + 'preview_url': song.preview_url, + 'cover_url': song.cover_url, + 'tags': tag_list + }) + + elif request.method == 'DELETE': + # Check if the song is used in any rounds before deleting + rounds_with_song = [] + + for round_obj in Round.query.all(): + song_ids = round_obj.songs.split(',') + if str(song_id) in song_ids: + rounds_with_song.append(round_obj.id) + + if rounds_with_song: + # The song is used in rounds, return error + return jsonify({ + 'error': 'Cannot delete song as it is used in rounds', + 'rounds': rounds_with_song + }), 400 + + # Delete the song + title = song.title + artist = song.artist + db.session.delete(song) + db.session.commit() + current_app.logger.info(f"Song {song_id} ({title} by {artist}) deleted successfully") + + return jsonify({ + 'message': f"Song '{title}' by {artist} deleted successfully", + 'id': song_id + }) + +@api_bp.route('/songs//refresh-metadata', methods=['POST']) +def refresh_song_metadata(song_id): + """API endpoint for refreshing song metadata""" + song = Song.query.get_or_404(song_id) + + # Check if we have an ISRC code to use for refreshing metadata + if not song.isrc: + current_app.logger.warning(f"Cannot refresh metadata for song {song_id} - no ISRC code") + return jsonify({'error': 'Song has no ISRC code to refresh metadata'}), 400 + + try: + # Get fresh metadata using the existing ISRC + current_app.logger.info(f"=== DEBUG: Starting metadata refresh for song {song_id} with ISRC {song.isrc} ===") + metadata = get_song_metadata_by_isrc(song.isrc, current_app) + + if not metadata: + current_app.logger.warning(f"No metadata found for ISRC {song.isrc}") + return jsonify({'error': 'No metadata found for this ISRC'}), 404 + + # Debug the metadata received + current_app.logger.info(f"DEBUG: Received metadata structure: {type(metadata).__name__}") + for key, value in metadata.items(): + value_type = type(value).__name__ + value_str = str(value) + if len(value_str) > 100: + value_str = value_str[:100] + "..." + current_app.logger.info(f"DEBUG: Metadata key '{key}' = {value_str} (type: {value_type})") + + # Update song with new metadata + if metadata.get('title'): + current_app.logger.info(f"DEBUG: Updating title to '{metadata['title']}'") + song.title = metadata['title'] + if metadata.get('artist_name'): + current_app.logger.info(f"DEBUG: Updating artist to '{metadata['artist_name']}'") + song.artist = metadata['artist_name'] + if metadata.get('genre'): + current_app.logger.info(f"DEBUG: Updating genre to '{metadata['genre']}' (type: {type(metadata['genre']).__name__})") + song.genre = metadata['genre'] + + # Import helper for creating tags from genre + from musicround.helpers.import_helper import ImportHelper + ImportHelper.create_tags_from_genre(song, metadata['genre']) + + if metadata.get('year'): + current_app.logger.info(f"DEBUG: Updating year to '{metadata['year']}'") + song.year = metadata['year'] + + # Check additional metadata for genres and add tags from there too + if 'genres' in metadata: + current_app.logger.info(f"DEBUG: Creating tags from additional genres") + from musicround.helpers.import_helper import ImportHelper + ImportHelper.create_tags_from_genre(song, metadata['genres']) + + # Update URLs if available + if metadata.get('preview_url'): + current_app.logger.info(f"DEBUG: Updating preview_url") + song.preview_url = metadata['preview_url'] + if metadata.get('cover_url'): + current_app.logger.info(f"DEBUG: Updating cover_url") + song.cover_url = metadata['cover_url'] + + # Update platform-specific IDs if available + if metadata.get('spotify_id'): + song.spotify_id = metadata['spotify_id'] + if metadata.get('deezer_id'): + song.deezer_id = metadata['deezer_id'] + + # Update platform-specific preview URLs + if metadata.get('spotify_preview_url'): + song.spotify_preview_url = metadata['spotify_preview_url'] + if metadata.get('deezer_preview_url'): + song.deezer_preview_url = metadata['deezer_preview_url'] + if metadata.get('apple_preview_url'): + song.apple_preview_url = metadata['apple_preview_url'] + if metadata.get('youtube_preview_url'): + song.youtube_preview_url = metadata['youtube_preview_url'] + + # Update platform-specific cover URLs + if metadata.get('spotify_cover_url'): + song.spotify_cover_url = metadata['spotify_cover_url'] + if metadata.get('deezer_cover_url'): + song.deezer_cover_url = metadata['deezer_cover_url'] + if metadata.get('apple_cover_url'): + song.apple_cover_url = metadata['apple_cover_url'] + + # Update popularity if available + if metadata.get('popularity') is not None: + song.popularity = metadata['popularity'] + + # Store metadata sources + if metadata.get('sources'): + try: + sources_str = ','.join(metadata['sources']) + current_app.logger.info(f"DEBUG: Setting metadata_sources to '{sources_str}'") + song.metadata_sources = sources_str + except Exception as source_error: + current_app.logger.error(f"DEBUG: Error joining sources: {source_error}") + current_app.logger.error(f"DEBUG: Sources value: {metadata['sources']} (type: {type(metadata['sources']).__name__})") + + # Save changes to the database + try: + current_app.logger.info("DEBUG: Committing changes to database") + db.session.commit() + current_app.logger.info(f"Metadata for song {song_id} updated successfully with sources: {metadata.get('sources')}") + except Exception as db_error: + db.session.rollback() + current_app.logger.error(f"DEBUG: Database commit error: {db_error}") + current_app.logger.error(f"DEBUG: Traceback: {traceback.format_exc()}") + return jsonify({'error': f"Database error: {str(db_error)}"}), 500 + + # Return updated song details including tags + tag_list = [{'id': tag.id, 'name': tag.name} for tag in song.tags] + + return jsonify({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist, + 'genre': song.genre, + 'year': song.year, + 'isrc': song.isrc, + 'popularity': song.popularity, + 'preview_url': song.preview_url, + 'cover_url': song.cover_url, + 'spotify_id': song.spotify_id, + 'deezer_id': song.deezer_id, + 'spotify_preview_url': song.spotify_preview_url, + 'deezer_preview_url': song.deezer_preview_url, + 'apple_preview_url': song.apple_preview_url, + 'youtube_preview_url': song.youtube_preview_url, + 'metadata_sources': song.metadata_sources, + 'tags': tag_list + }) + + except Exception as e: + current_app.logger.error(f"Error refreshing metadata for song {song_id}: {str(e)}") + current_app.logger.error(f"Full traceback: {traceback.format_exc()}") + return jsonify({'error': str(e)}), 500 + +# New API routes for tag operations + +@api_bp.route('/tags', methods=['GET']) +def list_tags(): + """Get all available tags""" + tags = Tag.query.order_by(Tag.name).all() + return jsonify({ + 'tags': [{'id': tag.id, 'name': tag.name} for tag in tags] + }) + +@api_bp.route('/tags', methods=['POST']) +def create_tag(): + """Create a new tag""" + data = request.get_json() + + if not data or not data.get('name'): + return jsonify({'error': 'Tag name is required'}), 400 + + tag_name = data['name'].strip() + + # Check if tag already exists + existing_tag = Tag.query.filter(Tag.name.ilike(tag_name)).first() + if existing_tag: + return jsonify({ + 'message': 'Tag already exists', + 'tag': {'id': existing_tag.id, 'name': existing_tag.name} + }) + + # Create new tag + new_tag = Tag(name=tag_name) + db.session.add(new_tag) + db.session.commit() + + return jsonify({ + 'message': 'Tag created successfully', + 'tag': {'id': new_tag.id, 'name': new_tag.name} + }), 201 + +@api_bp.route('/songs//tags', methods=['GET']) +def get_song_tags(song_id): + """Get all tags for a specific song""" + song = Song.query.get_or_404(song_id) + + return jsonify({ + 'song_id': song_id, + 'tags': [{'id': tag.id, 'name': tag.name} for tag in song.tags] + }) + +@api_bp.route('/songs//tags', methods=['POST']) +def add_tag_to_song(song_id): + """Add a tag to a song""" + song = Song.query.get_or_404(song_id) + data = request.get_json() + + if not data: + return jsonify({'error': 'No data provided'}), 400 + + # Check if we're adding an existing tag or creating a new one + if data.get('tag_id'): + # Add existing tag + tag = Tag.query.get_or_404(data['tag_id']) + elif data.get('tag_name'): + # Find or create tag + tag_name = data['tag_name'].strip() + tag = Tag.query.filter(Tag.name.ilike(tag_name)).first() + + if not tag: + tag = Tag(name=tag_name) + db.session.add(tag) + db.session.commit() + else: + return jsonify({'error': 'Either tag_id or tag_name must be provided'}), 400 + + # Check if the song already has this tag + if tag in song.tags: + return jsonify({ + 'message': f"Song '{song.title}' already has tag '{tag.name}'", + 'song_id': song_id, + 'tag': {'id': tag.id, 'name': tag.name} + }) + + # Add tag to song + song.tags.append(tag) + db.session.commit() + + return jsonify({ + 'message': f"Tag '{tag.name}' added to song '{song.title}'", + 'song_id': song_id, + 'tag': {'id': tag.id, 'name': tag.name} + }) + +@api_bp.route('/songs//tags/', methods=['DELETE']) +def remove_tag_from_song(song_id, tag_id): + """Remove a tag from a song""" + song = Song.query.get_or_404(song_id) + tag = Tag.query.get_or_404(tag_id) + + # Check if the song has this tag + if tag not in song.tags: + return jsonify({ + 'message': f"Song '{song.title}' doesn't have tag '{tag.name}'", + 'song_id': song_id, + 'tag_id': tag_id + }) + + # Remove tag from song + song.tags.remove(tag) + db.session.commit() + + return jsonify({ + 'message': f"Tag '{tag.name}' removed from song '{song.title}'", + 'song_id': song_id, + 'tag_id': tag_id + }) + +@api_bp.route('/tags/', methods=['GET']) +def get_songs_by_tag(tag_id): + """Get all songs with a specific tag""" + tag = Tag.query.get_or_404(tag_id) + + songs = [] + for song in tag.songs: + songs.append({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist + }) + + return jsonify({ + 'tag': {'id': tag.id, 'name': tag.name}, + 'song_count': len(songs), + 'songs': songs + }) + +@api_bp.route('/spotify/album/', methods=['GET']) +def get_spotify_album(album_id): + try: + # Check for Spotify access token + if 'access_token' not in session: + return jsonify({'error': 'You must be logged in to access this feature'}), 401 + + # Initialize Spotify client with access token + sp = spotify.Spotify(auth=session.get('access_token')) + + # Get album details + album = sp.album(album_id) + album_tracks = sp.album_tracks(album_id, limit=50) + + # Format tracks + tracks = [] + for track in album_tracks['items']: + artist_names = [artist['name'] for artist in track['artists']] + tracks.append({ + 'name': track['name'], + 'artist': ', '.join(artist_names), + 'duration': track['duration_ms'], + 'track_number': track['track_number'] + }) + + # Format album response + album_data = { + 'id': album['id'], + 'name': album['name'], + 'artist': ', '.join([artist['name'] for artist in album['artists']]), + 'release_date': album['release_date'], + 'image_url': album['images'][0]['url'] if album['images'] else None, + 'total_tracks': album['total_tracks'], + 'tracks': tracks + } + + return jsonify(album_data) + except Exception as e: + current_app.logger.error(f"Error fetching Spotify album: {str(e)}") + return jsonify({'error': 'Unable to fetch album details'}), 500 + +@api_bp.route('/spotify/playlist/', methods=['GET']) +def get_spotify_playlist(playlist_id): + try: + # Check for Spotify access token + if 'access_token' not in session: + return jsonify({'error': 'You must be logged in to access this feature'}), 401 + + # Initialize Spotify client with access token + sp = spotify.Spotify(auth=session.get('access_token')) + + # Get playlist details + playlist = sp.playlist(playlist_id) + + # Format tracks + tracks = [] + for item in playlist['tracks']['items']: + if not item['track']: + continue + + track = item['track'] + artist_names = [artist['name'] for artist in track['artists']] + tracks.append({ + 'name': track['name'], + 'artist': ', '.join(artist_names), + 'duration': track['duration_ms'], + 'album': track['album']['name'] if track.get('album') else '' + }) + + # Format playlist response + playlist_data = { + 'id': playlist['id'], + 'name': playlist['name'], + 'description': playlist['description'], + 'owner': playlist['owner']['display_name'] or playlist['owner']['id'], + 'image_url': playlist['images'][0]['url'] if playlist['images'] else None, + 'followers': playlist['followers']['total'] if playlist.get('followers') else 0, + 'tracks': tracks + } + + return jsonify(playlist_data) + except Exception as e: + current_app.logger.error(f"Error fetching Spotify playlist: {str(e)}") + return jsonify({'error': 'Unable to fetch playlist details'}), 500 + +@api_bp.route('/deezer/album/', methods=['GET']) +def get_deezer_album(album_id): + try: + # Get album details from Deezer using the DeezerClient instance from Flask app config + deezer_client = current_app.config.get('deezer') # Using correct config key 'deezer' + album = deezer_client.get_album(album_id) + tracks = deezer_client.get_album_tracks(album_id) + + # Format tracks + formatted_tracks = [] + for track in tracks: + formatted_tracks.append({ + 'name': track['title'], + 'artist': track['artist']['name'], + 'duration': track['duration'] * 1000, # Convert to ms for consistency + 'track_number': track.get('track_position', 0) + }) + + # Format album response + album_data = { + 'id': album['id'], + 'name': album['title'], + 'artist': album['artist']['name'], + 'release_date': album.get('release_date', ''), + 'image_url': album.get('cover_xl') or album.get('cover_big') or album.get('cover'), + 'total_tracks': album.get('nb_tracks', len(formatted_tracks)), + 'tracks': formatted_tracks + } + + return jsonify(album_data) + except Exception as e: + current_app.logger.error(f"Error fetching Deezer album: {str(e)}") + return jsonify({'error': 'Unable to fetch album details'}), 500 + +@api_bp.route('/deezer/playlist/', methods=['GET']) +def get_deezer_playlist(playlist_id): + try: + # Get playlist details from Deezer using the DeezerClient instance from Flask app config + deezer_client = current_app.config.get('deezer') # Using correct config key 'deezer' + playlist = deezer_client.get_playlist(playlist_id) + tracks = deezer_client.get_playlist_tracks(playlist_id) + + # Format tracks + formatted_tracks = [] + for track in tracks: + formatted_tracks.append({ + 'name': track['title'], + 'artist': track['artist']['name'], + 'duration': track['duration'] * 1000, # Convert to ms for consistency + 'album': track['album']['title'] if 'album' in track else '' + }) + + # Format playlist response + playlist_data = { + 'id': playlist['id'], + 'name': playlist['title'], + 'description': playlist.get('description', ''), + 'owner': playlist.get('creator', {}).get('name', 'Unknown'), + 'image_url': playlist.get('picture_xl') or playlist.get('picture_big') or playlist.get('picture'), + 'followers': playlist.get('fans', 0), + 'tracks': formatted_tracks + } + + return jsonify(playlist_data) + except Exception as e: + current_app.logger.error(f"Error fetching Deezer playlist: {str(e)}") + return jsonify({'error': 'Unable to fetch playlist details'}), 500 + +@api_bp.route('/songs/search') +def search_songs(): + """Search for songs by title or artist""" + if 'access_token' not in session: + return jsonify({'error': 'Authentication required'}), 401 + + query = request.args.get('q', '') + if not query or len(query) < 2: + return jsonify([]) + + # Search for songs by title or artist + songs = Song.query.filter( + or_( + Song.title.ilike(f'%{query}%'), + Song.artist.ilike(f'%{query}%') + ) + ).limit(20).all() + + # Convert songs to JSON + results = [] + for song in songs: + results.append({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist, + 'year': song.year, + 'genre': song.genre, + 'cover_url': song.cover_url, + 'preview_url': song.preview_url + }) + + return jsonify(results) + +@api_bp.route('/songs/update-audio-features', methods=['POST']) +@login_required +def update_audio_features(): + """Update audio features for Spotify songs in the database""" + # Get parameters from the request + batch_size = request.json.get('batch_size', 50) # Process in batches to avoid timeouts + process_all = request.json.get('process_all', False) + process_specific = request.json.get('process_specific', False) + song_ids = request.json.get('song_ids', []) + + # If specific song IDs are provided, query those songs + if process_specific and song_ids: + query = Song.query.filter( + Song.id.in_(song_ids), + Song.spotify_id.isnot(None) # Only process songs with Spotify IDs + ) + else: + # Query songs that have Spotify IDs but no audio features + query = Song.query.filter( + Song.spotify_id.isnot(None) # Only process songs with Spotify IDs + ) + + # If not processing all, only select songs without audio features + if not process_all: + query = query.filter(Song.acousticness.is_(None)) + + # Count total songs to process + total_songs = query.count() + + if total_songs == 0: + return jsonify({ + 'success': True, + 'message': 'No songs found that need audio features.', + 'processed': 0, + 'total': 0 + }) + + # Get bearer token from session + bearer_token = session.get('direct_bearer_token') + + # If no direct bearer token found, try to use the standard access token as fallback + if not bearer_token: + bearer_token = session.get('access_token') + if not bearer_token: + return jsonify({ + 'success': False, + 'message': 'No Spotify authentication token found in session.', + 'error': 'SPOTIFY_TOKEN_NOT_FOUND' + }), 401 + + # Create an instance of the SpotifyDirectClient for this request + try: + # Initialize our custom Spotify client with the bearer token + from musicround.helpers.spotify_direct import SpotifyDirectClient + direct_sp = SpotifyDirectClient(bearer_token=bearer_token) + except Exception as e: + current_app.logger.error(f"Error initializing SpotifyDirectClient: {str(e)}") + return jsonify({ + 'success': False, + 'message': 'Failed to initialize Spotify client', + 'error': str(e) + }), 500 + + # Process songs in batches + processed_count = 0 + error_count = 0 + + # Get all matching songs (limit to reasonable number to prevent timeouts) + songs = query.limit(1000).all() + + # Process in batches of batch_size + for i in range(0, len(songs), batch_size): + batch = songs[i:i+batch_size] + track_ids = [song.spotify_id for song in batch] + + # Get audio features for this batch + try: + # Use our custom SpotifyDirectClient for batch audio features + features = direct_sp.get_tracks_audio_features(track_ids) + + if not features: + current_app.logger.warning(f"No audio features returned for batch {i//batch_size + 1}") + error_count += len(batch) + continue + + # Map features to songs by Spotify ID + features_dict = {feature['id']: feature for feature in features if feature} + + # Update each song with its audio features + for song in batch: + if song.spotify_id in features_dict: + feature = features_dict[song.spotify_id] + + # Update song with audio features + song.acousticness = feature.get('acousticness') + song.danceability = feature.get('danceability') + song.energy = feature.get('energy') + song.instrumentalness = feature.get('instrumentalness') + song.key = feature.get('key') + song.liveness = feature.get('liveness') + song.loudness = feature.get('loudness') + song.mode = feature.get('mode') + song.speechiness = feature.get('speechiness') + song.tempo = feature.get('tempo') + song.time_signature = feature.get('time_signature') + song.valence = feature.get('valence') + song.duration_ms = feature.get('duration_ms') + song.analysis_url = feature.get('analysis_url') + + # Add audio features to metadata sources if not already present + if song.metadata_sources: + sources = song.metadata_sources.split(',') + if 'audio_features' not in sources: + sources.append('audio_features') + song.metadata_sources = ','.join(sources) + else: + song.metadata_sources = 'audio_features' + + processed_count += 1 + else: + current_app.logger.warning(f"No audio features found for song {song.id} ({song.spotify_id})") + error_count += 1 + + # Save all changes to database + db.session.commit() + + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error processing audio features batch: {str(e)}") + error_count += len(batch) + + return jsonify({ + 'success': True, + 'message': f'Successfully updated audio features for {processed_count} songs. {error_count} errors.', + 'processed': processed_count, + 'errors': error_count, + 'total': total_songs + }) + +@api_bp.route('/dropbox/folders', methods=['GET']) +@login_required +def list_dropbox_folders(): + """List folders from user's Dropbox account for the folder browser""" + from flask_login import current_user + from musicround.helpers.dropbox_helper import get_current_user_dropbox_token + import requests + import json + import traceback + + # Check if user has Dropbox connected + if not current_user.dropbox_token: + current_app.logger.error("Dropbox folder listing failed: User has no Dropbox token") + return jsonify({'error': 'Dropbox account not connected'}), 401 + + # Get Dropbox token + token = get_current_user_dropbox_token() + if not token: + current_app.logger.error("Dropbox folder listing failed: Failed to get valid token") + return jsonify({'error': 'Failed to get valid Dropbox token'}), 401 + + # Get the path from query params, default to empty string (root) + path = request.args.get('path', '') + + # Fix path format for Dropbox API + # Dropbox API requires empty string for root, not "/" + if path == '/' or not path: + path = "" + display_path = "/" + else: + display_path = path + + current_app.logger.info(f"Listing Dropbox folders for path: {display_path}") + + try: + # Call Dropbox API to list folders + headers = { + 'Authorization': f'Bearer {token}', + 'Content-Type': 'application/json' + } + + # Use the list_folder API with recursive=False to get only immediate children + data = { + 'path': path, + 'recursive': False, + 'include_deleted': False, + 'include_has_explicit_shared_members': False, + 'include_mounted_folders': True, + 'include_non_downloadable_files': False + } + + current_app.logger.debug(f"Sending request to Dropbox API: {json.dumps(data)}") + current_app.logger.debug(f"Using token: {token[:5]}...{token[-5:] if len(token) > 10 else ''}") + + response = requests.post( + 'https://api.dropboxapi.com/2/files/list_folder', + headers=headers, + json=data + ) + + current_app.logger.debug(f"Dropbox API response status: {response.status_code}") + + if response.status_code != 200: + current_app.logger.error(f"Dropbox API error: {response.status_code}, Response: {response.text}") + + # Check for specific error types to provide better messages + try: + error_data = response.json() + error_message = f"Dropbox API error: {response.status_code}" + + # Handle "not_found" error by trying to create the folder if it's not root + if (response.status_code == 409 and + "not_found" in response.text and + path != ""): + current_app.logger.info(f"Folder {display_path} doesn't exist, showing root folder instead") + # Return root folder with a note about the folder not existing + return list_root_folders(token, display_path) + + if 'error_summary' in error_data: + error_message += f": {error_data['error_summary']}" + + # Handle common errors + if response.status_code == 401: + # Try to refresh the token and retry once + current_app.logger.info("Attempting to refresh Dropbox token and retry") + from musicround.helpers.dropbox_helper import refresh_dropbox_token + + if current_user.dropbox_refresh_token: + new_token_info = refresh_dropbox_token(current_user.dropbox_refresh_token) + if new_token_info and 'access_token' in new_token_info: + # Try again with the new token + headers['Authorization'] = f"Bearer {new_token_info['access_token']}" + response = requests.post( + 'https://api.dropboxapi.com/2/files/list_folder', + headers=headers, + json=data + ) + + if response.status_code == 200: + # Success! Continue with processing + current_app.logger.info("Successfully refreshed token and retrieved folders") + else: + current_app.logger.error(f"Still failed after token refresh: {response.status_code}, {response.text}") + return jsonify({'error': error_message, 'details': error_data}), response.status_code + else: + current_app.logger.error("Token refresh failed") + + if response.status_code != 200: # If we're still having an error + return jsonify({'error': error_message, 'details': error_data}), response.status_code + + except Exception as json_error: + current_app.logger.error(f"Error parsing Dropbox error response: {str(json_error)}") + return jsonify({'error': f'Dropbox API error: {response.status_code}', 'raw_response': response.text}), 500 + + # Process the successful response + result = response.json() + current_app.logger.debug(f"Received Dropbox response: {json.dumps(result)[:1000] if len(json.dumps(result)) > 1000 else json.dumps(result)}") + + # Filter to only include folders + folders = [] + for entry in result.get('entries', []): + if entry.get('.tag') == 'folder': + folders.append({ + 'name': entry.get('name', ''), + 'path_display': entry.get('path_display', ''), + 'id': entry.get('id', '') + }) + + current_app.logger.info(f"Successfully listed {len(folders)} folders in path '{display_path}'") + + return jsonify({ + 'path': display_path, + 'folders': folders + }) + + except Exception as e: + error_traceback = traceback.format_exc() + current_app.logger.error(f"Error listing Dropbox folders: {str(e)}") + current_app.logger.error(f"Traceback: {error_traceback}") + return jsonify({ + 'error': str(e), + 'traceback': error_traceback, + 'message': 'An unexpected error occurred while listing Dropbox folders' + }), 500 + +@api_bp.route('/dropbox/create-folder', methods=['POST']) +@login_required +def create_dropbox_folder(): + """Create a new folder in the user's Dropbox account""" + from flask_login import current_user + from musicround.helpers.dropbox_helper import get_current_user_dropbox_token + import requests + import json + import traceback + + # Check if user has Dropbox connected + if not current_user.dropbox_token: + current_app.logger.error("Dropbox folder creation failed: User has no Dropbox token") + return jsonify({'error': 'Dropbox account not connected'}), 401 + + # Get Dropbox token + token = get_current_user_dropbox_token() + if not token: + current_app.logger.error("Dropbox folder creation failed: Failed to get valid token") + return jsonify({'error': 'Failed to get valid Dropbox token'}), 401 + + # Get path and new folder name from request + data = request.get_json() + if not data or 'parent_path' not in data or 'folder_name' not in data: + return jsonify({'error': 'Missing required parameters: parent_path and folder_name'}), 400 + + parent_path = data['parent_path'] + folder_name = data['folder_name'].strip() + + # Validate folder name - basic validation + if not folder_name: + return jsonify({'error': 'Folder name cannot be empty'}), 400 + + if any(char in folder_name for char in ['/', '\\', ':', '*', '?', '"', '<', '>', '|']): + return jsonify({'error': 'Folder name contains invalid characters'}), 400 + + # Construct full path + # If parent is root, we need special handling + if parent_path == '/' or parent_path == '': + full_path = '/' + folder_name + else: + full_path = parent_path + '/' + folder_name + + current_app.logger.info(f"Creating Dropbox folder: {full_path}") + + try: + # Call Dropbox API to create folder + headers = { + 'Authorization': f'Bearer {token}', + 'Content-Type': 'application/json' + } + + data = { + 'path': full_path, + 'autorename': False + } + + current_app.logger.debug(f"Sending request to Dropbox API: {json.dumps(data)}") + + response = requests.post( + 'https://api.dropboxapi.com/2/files/create_folder_v2', + headers=headers, + json=data + ) + + current_app.logger.debug(f"Dropbox API response status: {response.status_code}") + + if response.status_code != 200: + current_app.logger.error(f"Dropbox API error: {response.status_code}, Response: {response.text}") + + try: + error_data = response.json() + error_message = f"Dropbox API error: {response.status_code}" + + if 'error_summary' in error_data: + error_message += f": {error_data['error_summary']}" + + # Special handling for conflict (folder already exists) + if response.status_code == 409 and 'conflict' in response.text: + return jsonify({ + 'error': 'A folder with this name already exists', + 'details': error_data + }), 409 + + return jsonify({'error': error_message, 'details': error_data}), response.status_code + + except Exception as json_error: + current_app.logger.error(f"Error parsing Dropbox error response: {str(json_error)}") + return jsonify({ + 'error': f'Dropbox API error: {response.status_code}', + 'raw_response': response.text + }), 500 + + # Process the successful response + result = response.json() + current_app.logger.debug(f"Received Dropbox response: {json.dumps(result)}") + + # Extract metadata from result + metadata = result.get('metadata', {}) + + current_app.logger.info(f"Successfully created folder: {full_path}") + + return jsonify({ + 'success': True, + 'path': metadata.get('path_display', full_path), + 'name': metadata.get('name', folder_name), + 'id': metadata.get('id', '') + }) + + except Exception as e: + error_traceback = traceback.format_exc() + current_app.logger.error(f"Error creating Dropbox folder: {str(e)}") + current_app.logger.error(f"Traceback: {error_traceback}") + return jsonify({ + 'error': str(e), + 'traceback': error_traceback, + 'message': 'An unexpected error occurred while creating Dropbox folder' + }), 500 + +def list_root_folders(token, attempted_path=None): + """Get root folders as a fallback when requested path doesn't exist""" + import requests + import json + + try: + # Call Dropbox API to list root folders + headers = { + 'Authorization': f'Bearer {token}', + 'Content-Type': 'application/json' + } + + data = { + 'path': "", # Empty string for root + 'recursive': False, + 'include_deleted': False, + 'include_has_explicit_shared_members': False, + 'include_mounted_folders': True, + 'include_non_downloadable_files': False + } + + current_app.logger.debug("Listing root folders as fallback") + + response = requests.post( + 'https://api.dropboxapi.com/2/files/list_folder', + headers=headers, + json=data + ) + + if response.status_code != 200: + current_app.logger.error(f"Root folder listing failed: {response.status_code}, {response.text}") + return jsonify({ + 'error': f'Could not list root folders: {response.status_code}', + 'attempted_path': attempted_path + }), response.status_code + + # Process the successful response + result = response.json() + + # Filter to only include folders + folders = [] + for entry in result.get('entries', []): + if entry.get('.tag') == 'folder': + folders.append({ + 'name': entry.get('name', ''), + 'path_display': entry.get('path_display', ''), + 'id': entry.get('id', '') + }) + + message = None + if attempted_path: + message = f"Folder '{attempted_path}' doesn't exist. Showing root folder instead." + + return jsonify({ + 'path': '/', + 'folders': folders, + 'warning': message + }) + + except Exception as e: + current_app.logger.error(f"Error listing root folders: {str(e)}") + return jsonify({ + 'error': f'Error listing root folders: {str(e)}', + 'attempted_path': attempted_path + }), 500 \ No newline at end of file diff --git a/musicround/routes/auth.py b/musicround/routes/auth.py new file mode 100644 index 0000000..f1c550e --- /dev/null +++ b/musicround/routes/auth.py @@ -0,0 +1,179 @@ +""" +Authentication routes for the Music Round application +""" +import os +from flask import Blueprint, render_template, redirect, url_for, request, flash, current_app, session +from flask_login import login_user, current_user, logout_user, login_required +from werkzeug.security import check_password_hash +from musicround.models import User, db +from datetime import datetime +import spotipy + +# Create blueprint +auth_bp = Blueprint('auth', __name__) + +@auth_bp.route('/') +def index(): + """Landing page""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + return render_template('auth/index.html') + +@auth_bp.route('/login') +def login(): + """Redirect to user login page""" + return redirect(url_for('users.login')) + +@auth_bp.route('/login-with-spotify') +def login_with_spotify(): + """Start Spotify OAuth flow for login""" + # If user is already logged in, redirect to home + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Create a new OAuth object + sp_oauth = current_app.config['sp_oauth'] + + # Get the authorization URL + auth_url = sp_oauth.get_authorize_url() + + # Store state in session for validation + session['oauth_state'] = sp_oauth.state + + # Set flag that we're using OAuth for login, not just connection + session['spotify_login_flow'] = True + + return redirect(auth_url) + +@auth_bp.route('/callback') +def callback(): + """Handle Spotify OAuth callback for login""" + try: + # Verify the state parameter + if request.args.get('state') != session.get('oauth_state'): + flash("Authentication state mismatch. Please try logging in again.", "danger") + return redirect(url_for('auth.index')) + + # Get the authorization code + code = request.args.get('code') + if not code: + flash("No authorization code received from Spotify.", "danger") + return redirect(url_for('auth.index')) + + # Exchange the code for an access token + sp_oauth = current_app.config['sp_oauth'] + token_info = sp_oauth.get_access_token(code) + + if not token_info or 'access_token' not in token_info: + flash("Failed to obtain access token from Spotify.", "danger") + return redirect(url_for('auth.index')) + + # Store the token in the session + session['access_token'] = token_info['access_token'] + session['refresh_token'] = token_info.get('refresh_token') + session['token_expiration'] = token_info.get('expires_at') + session['token_source'] = 'user' + + # Get user info from Spotify to find or create the user account + sp = spotipy.Spotify(auth=token_info['access_token']) + spotify_user_info = sp.current_user() + + if not spotify_user_info or 'id' not in spotify_user_info: + flash("Could not fetch user information from Spotify.", "danger") + return redirect(url_for('auth.index')) + + spotify_id = spotify_user_info['id'] + email = spotify_user_info.get('email') + display_name = spotify_user_info.get('display_name', spotify_id) + + # Log the Spotify login attempt + current_app.logger.info(f"Spotify login attempt: ID={spotify_id}, Email={email}, Name={display_name}") + + # Look for an existing user with this Spotify ID + user = User.query.filter_by(oauth_id=spotify_id).first() + + # If no user found with this Spotify ID but we have an email, try to find by email + if not user and email: + user = User.query.filter_by(email=email).first() + if user: + # Update the user's Spotify ID if they have an account with the same email + user.oauth_id = spotify_id + current_app.logger.info(f"Linked Spotify ID {spotify_id} to existing account: {user.username}") + + # If we still don't have a user, create a new one + if not user: + if not email: + # If Spotify didn't provide an email, we can't create a new user automatically + flash("Your Spotify account does not have an email address. Please register manually.", "danger") + return redirect(url_for('users.register')) + + # Generate a unique username based on Spotify display name + base_username = ''.join(c for c in display_name if c.isalnum()).lower() + if not base_username: + base_username = "spotify_user" + + username = base_username + count = 1 + while User.query.filter_by(username=username).first(): + username = f"{base_username}{count}" + count += 1 + + # Create a new user + from werkzeug.security import generate_password_hash + import secrets + + # Generate a random password - user can reset it later + random_password = secrets.token_urlsafe(12) + + user = User( + username=username, + email=email, + password_hash=generate_password_hash(random_password), + first_name=display_name.split()[0] if ' ' in display_name else display_name, + last_name=' '.join(display_name.split()[1:]) if ' ' in display_name else '', + oauth_id=spotify_id, + created_at=datetime.now(), + last_login=datetime.now() + ) + + try: + db.session.add(user) + db.session.commit() + current_app.logger.info(f"Created new user from Spotify: {username} (ID: {user.id})") + flash(f"Welcome! A new account has been created for you as '{username}'.", "success") + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error creating user from Spotify: {e}") + flash("Error creating account. Please try again or register manually.", "danger") + return redirect(url_for('users.register')) + + # Store the Spotify tokens in the user's account + user.spotify_token = token_info['access_token'] + user.spotify_refresh_token = token_info.get('refresh_token') + if 'expires_at' in token_info: + user.spotify_token_expiry = datetime.fromtimestamp(token_info['expires_at']) + + # Update last login time + user.last_login = datetime.now() + + try: + db.session.commit() + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error updating user with Spotify tokens: {e}") + flash("Error updating your account with Spotify information.", "danger") + return redirect(url_for('users.login')) + + # Log the user in + login_user(user) + + # Update the Spotify client with the new token + current_app.config['sp'].set_auth(token_info['access_token']) + + flash("Successfully logged in with Spotify!", "success") + return redirect(url_for('core.index')) + + except Exception as e: + current_app.logger.error(f"Error during Spotify callback: {e}") + flash("Error during Spotify authentication. Please try again.", "danger") + return redirect(url_for('auth.index')) \ No newline at end of file diff --git a/musicround/routes/core.py b/musicround/routes/core.py new file mode 100644 index 0000000..6a39af4 --- /dev/null +++ b/musicround/routes/core.py @@ -0,0 +1,323 @@ +""" +Core routes that form the basic navigation structure of the app. +""" +from flask import Blueprint, render_template, redirect, url_for, current_app, request, send_from_directory, abort, session +from flask_login import current_user, login_required +from musicround import db + +core_bp = Blueprint('core', __name__) + +@core_bp.route('/') +def index(): + """ + If user is not logged in, show login. + Otherwise, show homepage with user info. + """ + if not current_user.is_authenticated: + return redirect(url_for('users.login')) + + return render_template('homepage.html', user_info={'display_name': current_user.username}) + +@core_bp.route('/search', methods=['GET']) +@login_required +def search(): + """ + Show search page for Spotify + """ + return render_template('service_search.html', + service_name='Spotify', + search_results_url=url_for('core.search_results'), + track_import_url=url_for('import_songs.import_song'), + album_import_url=url_for('import_songs.import_album'), + playlist_import_url=url_for('import_songs.import_playlist'), + url_placeholder="https://open.spotify.com/track/...") + +@core_bp.route('/search-results', methods=['POST']) +@login_required +def search_results(): + """Process Spotify search and display results""" + if 'access_token' not in session: + # Redirect to Spotify login if not authenticated + return redirect(url_for('auth.spotify_login')) + + search_term = request.form.get('search_term', '') + if not search_term: + return redirect(url_for('core.search')) + + try: + # Initialize Spotify client with access token + import spotipy + from spotipy.exceptions import SpotifyException + + current_app.logger.info(f"Searching Spotify for: {search_term}") + + # Try to check if token is valid before using it + try: + sp = spotipy.Spotify(auth=session.get('access_token')) + # Make a simple API call to verify token + sp.current_user() + except SpotifyException as e: + # If token is expired, try refreshing it + if e.http_status == 401: + current_app.logger.info("Spotify token expired, attempting refresh") + # Check if we have a refresh token + if current_user.spotify_refresh_token: + try: + # Create OAuth object to refresh token + from spotipy.oauth2 import SpotifyOAuth + from musicround.config import Config + + sp_oauth = SpotifyOAuth( + client_id=Config.SPOTIFY_CLIENT_ID, + client_secret=Config.SPOTIFY_CLIENT_SECRET, + redirect_uri=Config.SPOTIFY_REDIRECT_URI, + scope=Config.SPOTIFY_SCOPE + ) + + # Get new token + token_info = sp_oauth.refresh_access_token(current_user.spotify_refresh_token) + + # Update session and user + session['access_token'] = token_info['access_token'] + current_user.spotify_token = token_info['access_token'] + if 'refresh_token' in token_info: + current_user.spotify_refresh_token = token_info['refresh_token'] + + # Update token expiry + import datetime + current_user.spotify_token_expiry = datetime.datetime.now() + datetime.timedelta(seconds=token_info['expires_in']) + + # Save changes + db.session.commit() + + # Create new Spotify client with updated token + sp = spotipy.Spotify(auth=token_info['access_token']) + + except Exception as refresh_error: + current_app.logger.error(f"Error refreshing Spotify token: {str(refresh_error)}") + # Redirect to login if we can't refresh + return redirect(url_for('auth.spotify_login')) + else: + # No refresh token, redirect to login + return redirect(url_for('auth.spotify_login')) + else: + # Some other Spotify error + raise + + # Prepare more specific search parameters for better results + # Try different search strategies for artists vs tracks + search_strategies = [ + # Regular search for all types + {'q': search_term, 'type': 'track,album,playlist', 'limit': 10}, + + # Search specifically for artist + {'q': f'artist:{search_term}', 'type': 'track', 'limit': 10}, + + # Search specifically for track + {'q': f'track:{search_term}', 'type': 'track', 'limit': 10} + ] + + tracks = [] + albums = [] + playlists = [] + + # Try different search strategies until we get results + for strategy in search_strategies: + current_app.logger.info(f"Trying search strategy: {strategy}") + + # Perform search with current strategy + results = sp.search(**strategy) + + # Extract track results if available + if 'tracks' in results and results['tracks']['items']: + for item in results['tracks']['items']: + # Skip None items or items without required fields + if item is None or 'id' not in item or 'artists' not in item or 'album' not in item: + continue + + artist_names = [artist['name'] for artist in item['artists']] + + # Get album image safely + image_url = None + if 'album' in item and item['album'] and 'images' in item['album'] and item['album']['images']: + image_url = item['album']['images'][0]['url'] if item['album']['images'] else None + + # Get album name safely + album_name = item['album']['name'] if 'album' in item and item['album'] and 'name' in item['album'] else 'Unknown Album' + + tracks.append({ + 'id': item['id'], + 'name': item['name'], + 'artist': ', '.join(artist_names), + 'album': album_name, + 'image_url': image_url, + 'preview_url': item.get('preview_url'), + 'duration_ms': item.get('duration_ms', 0) + }) + + # Extract album results if available + if 'albums' in results and results['albums']['items']: + for item in results['albums']['items']: + # Skip None items or items without required fields + if item is None or 'id' not in item or 'artists' not in item: + continue + + artist_names = [artist['name'] for artist in item['artists']] + + # Get album image safely + image_url = None + if 'images' in item and item['images']: + image_url = item['images'][0]['url'] if item['images'] else None + + albums.append({ + 'id': item['id'], + 'name': item['name'], + 'artist': ', '.join(artist_names), + 'image_url': image_url, + 'total_tracks': item.get('total_tracks', 0) + }) + + # Extract playlist results if available + if 'playlists' in results and results['playlists']['items']: + for item in results['playlists']['items']: + # Skip None items or items without required fields + if item is None or 'id' not in item or 'owner' not in item: + continue + + # Get playlist image safely + image_url = None + if 'images' in item and item['images']: + image_url = item['images'][0]['url'] if item['images'] else None + + # Get track count safely + track_count = 0 + if 'tracks' in item and item['tracks'] is not None and 'total' in item['tracks']: + track_count = item['tracks']['total'] + + # Get owner name safely + owner_name = item['owner'].get('display_name') or item['owner'].get('id', 'Unknown') + + playlists.append({ + 'id': item['id'], + 'name': item['name'], + 'owner': owner_name, + 'image_url': image_url, + 'tracks': track_count + }) + + # If we got any results, break the loop + if tracks or albums or playlists: + break + + # If still no results after all strategies, try one more approach + if not tracks and not albums and not playlists: + current_app.logger.info("No results from standard searches, trying market-specific search") + # Try a more generic search with market specification + results = sp.search(q=search_term, type='track,album,playlist', limit=10, market='US') + + # Extract track results + if 'tracks' in results and results['tracks']['items']: + for item in results['tracks']['items']: + artist_names = [artist['name'] for artist in item['artists']] + tracks.append({ + 'id': item['id'], + 'name': item['name'], + 'artist': ', '.join(artist_names), + 'album': item['album']['name'], + 'image_url': item['album']['images'][0]['url'] if item['album']['images'] else None, + 'preview_url': item['preview_url'], + 'duration_ms': item['duration_ms'] + }) + + # Remove duplicates (in case our strategies found the same items) + unique_tracks = [] + track_ids_seen = set() + for track in tracks: + if track['id'] not in track_ids_seen: + track_ids_seen.add(track['id']) + unique_tracks.append(track) + + unique_albums = [] + album_ids_seen = set() + for album in albums: + if album['id'] not in album_ids_seen: + album_ids_seen.add(album['id']) + unique_albums.append(album) + + unique_playlists = [] + playlist_ids_seen = set() + for playlist in playlists: + if playlist['id'] not in playlist_ids_seen: + playlist_ids_seen.add(playlist['id']) + unique_playlists.append(playlist) + + # Log the number of results found + current_app.logger.info(f"Search results: {len(unique_tracks)} tracks, {len(unique_albums)} albums, {len(unique_playlists)} playlists") + + # Render search results template + return render_template('service_search_results.html', + service_name='Spotify', + search_term=search_term, + tracks=unique_tracks, + albums=unique_albums, + playlists=unique_playlists, + track_import_url=url_for('import_songs.import_song'), + album_import_url=url_for('import_songs.import_album'), + playlist_import_url=url_for('import_songs.import_playlist'), + track_id_field='song_id', + album_id_field='album_id', + playlist_id_field='playlist_id', + tracks_label='Tracks', + has_preview=True, + search_url=url_for('core.search')) + + except Exception as e: + # Log the detailed error + import traceback + current_app.logger.error(f"Spotify search error: {str(e)}") + current_app.logger.error(traceback.format_exc()) + + # Render error template + return render_template('error.html', + error_message="An error occurred while searching Spotify.", + error_details=str(e), + back_url=url_for('core.search')) + +@core_bp.route('/view-songs') +@login_required +def view_songs(): + """ + Show all songs in database + """ + from musicround.models import Song, Tag + + # Get all songs + songs = Song.query.all() + + # Get all tags + tags = Tag.query.all() + + return render_template('view_songs.html', songs=songs, tags=tags) + +@core_bp.route('/data/') +@login_required +def serve_user_audio(filepath): + """ + Serve user custom audio files from the data directory + """ + # For security, ensure the filepath doesn't try to access parent directories + if '..' in filepath: + abort(404) + + # Only allow access to the current user's custom MP3 files or to admins + if 'custommp3/' in filepath: + # Extract username from the filepath + parts = filepath.split('/') + if len(parts) >= 2 and parts[0] == 'custommp3': + username = parts[1] + + # Check if current user is the owner of the file or an admin + if username != current_user.username and not current_user.is_admin: + abort(403) # Unauthorized + + return send_from_directory('/data', filepath) \ No newline at end of file diff --git a/musicround/routes/db_admin.py b/musicround/routes/db_admin.py new file mode 100644 index 0000000..e6ebfbf --- /dev/null +++ b/musicround/routes/db_admin.py @@ -0,0 +1,190 @@ +from flask import Blueprint, redirect, url_for, flash, jsonify +from flask_admin import Admin, BaseView, expose +from flask_admin.contrib.sqla import ModelView +from flask_admin.contrib.fileadmin import FileAdmin +from flask_admin.menu import MenuLink +from flask_admin.actions import action +from flask_login import current_user, login_required +from musicround.models import Song, Tag, SongTag, Round, User, Role, UserPreferences, SystemSetting, db +from functools import wraps +import os +import json + +# Create a basic authentication wrapper +def admin_required(view_func): + @wraps(view_func) + def wrapper(*args, **kwargs): + # Check if user is logged in and is an admin + if not current_user.is_authenticated: + return redirect(url_for('users.login')) + + if not current_user.is_admin(): + flash('Admin access required.', 'danger') + return redirect(url_for('core.index')) + + return view_func(*args, **kwargs) + return wrapper + +# Create the blueprint +db_admin_bp = Blueprint('db_admin', __name__, url_prefix='/admin') + +# Define routes on the blueprint before it gets registered +@db_admin_bp.route('/raw') +@admin_required +def raw_db_access(): + return redirect(url_for('admin.index')) + +# Base model view with authentication +class AuthModelView(ModelView): + def is_accessible(self): + return current_user.is_authenticated and current_user.is_admin() + + def inaccessible_callback(self, name, **kwargs): + if not current_user.is_authenticated: + return redirect(url_for('users.login')) + return redirect(url_for('core.index')) + + # Add basic search functionality to all models + column_searchable_list = [] + column_filters = [] + + # Enable export to CSV + can_export = True + export_types = ['csv', 'json'] + +# Enhanced Song ModelView +class SongModelView(AuthModelView): + column_searchable_list = ['title', 'artist', 'spotify_id'] + column_filters = ['title', 'artist', 'year', 'genre', 'used_count'] + column_default_sort = ('id', False) + + @action('reset_used_count', 'Reset Used Count', 'Are you sure you want to reset used count to 0?') + def action_reset_used_count(self, ids): + try: + query = Song.query.filter(Song.id.in_(ids)) + + # Update all songs + for song in query.all(): + song.used_count = 0 + + db.session.commit() + flash(f'Used count reset for {len(ids)} songs.', 'success') + except Exception as ex: + db.session.rollback() + flash(f'Error resetting used count: {str(ex)}', 'danger') + +# Enhanced Round ModelView +class RoundModelView(AuthModelView): + column_searchable_list = ['name', 'round_type', 'round_criteria_used'] + column_filters = ['name', 'round_type', 'round_criteria_used'] + column_list = ['id', 'name', 'round_type', 'round_criteria_used', 'created_at', 'mp3_generated', 'pdf_generated'] + column_default_sort = ('id', False) + +# Enhanced Tag ModelView +class TagModelView(AuthModelView): + column_searchable_list = ['name'] + column_filters = ['name'] + +# Enhanced SongTag ModelView +class SongTagModelView(AuthModelView): + column_filters = ['song_id', 'tag_id'] + +# Enhanced User ModelView +class UserModelView(AuthModelView): + column_searchable_list = ['username', 'email', 'first_name', 'last_name'] + column_filters = ['username', 'email', 'active', 'created_at', 'last_login'] + column_default_sort = ('id', False) + + # Protect password field in forms + form_excluded_columns = ['password_hash', 'reset_token', 'reset_token_expiry'] + + @action('activate_users', 'Activate Users', 'Are you sure you want to activate selected users?') + def action_activate_users(self, ids): + try: + query = User.query.filter(User.id.in_(ids)) + + # Update all selected users + for user in query.all(): + user.active = True + + db.session.commit() + flash(f'Successfully activated {len(ids)} users.', 'success') + except Exception as ex: + db.session.rollback() + flash(f'Error activating users: {str(ex)}', 'danger') + + @action('deactivate_users', 'Deactivate Users', 'Are you sure you want to deactivate selected users?') + def action_deactivate_users(self, ids): + try: + query = User.query.filter(User.id.in_(ids)) + + # Update all selected users + for user in query.all(): + user.active = False + + db.session.commit() + flash(f'Successfully deactivated {len(ids)} users.', 'success') + except Exception as ex: + db.session.rollback() + flash(f'Error deactivating users: {str(ex)}', 'danger') + +# Enhanced Role ModelView +class RoleModelView(AuthModelView): + column_searchable_list = ['name', 'description'] + column_filters = ['name'] + +# Enhanced UserPreferences ModelView +class UserPreferencesModelView(AuthModelView): + column_filters = ['user_id', 'theme', 'enable_intro'] + +# Enhanced SystemSetting ModelView +class SystemSettingModelView(AuthModelView): + column_searchable_list = ['key'] + column_filters = ['key'] + column_exclude_list = [] # Ensure any sensitive values are not excluded if needed + +# Initialize the admin interface +admin = None + +def init_admin(app): + """Initialize the admin interface with the Flask app.""" + global admin + + # Set Flask-Admin configuration + app.config['FLASK_ADMIN_SWATCH'] = 'cerulean' # Use a Bootstrap swatch theme + + # Create admin interface + admin = Admin( + app, + name='MusicRound Admin', + template_mode='bootstrap3', + url='/admin' + ) + + # Add model views + # Data models + admin.add_view(SongModelView(Song, db.session, category="Music Data")) + admin.add_view(TagModelView(Tag, db.session, category="Music Data")) + admin.add_view(SongTagModelView(SongTag, db.session, category="Music Data")) + admin.add_view(RoundModelView(Round, db.session, category="Music Data")) + + # User management + admin.add_view(UserModelView(User, db.session, category="User Management")) + admin.add_view(RoleModelView(Role, db.session, category="User Management")) + admin.add_view(UserPreferencesModelView(UserPreferences, db.session, category="User Management")) + + # System + admin.add_view(SystemSettingModelView(SystemSetting, db.session, category="System")) + + # Add file admin for audio files + path = os.path.join(os.path.dirname(__file__), '../static/audio') + admin.add_view(FileAdmin(path, '/static/audio/', name='Audio Files', category="System", endpoint='static_audio_files')) + + # User MP3 files + user_mp3_path = os.path.join(os.path.dirname(__file__), '../mp3') + admin.add_view(FileAdmin(user_mp3_path, '/mp3/', name='User MP3 Files', category="System", endpoint='user_mp3_files')) + + # Add links + admin.add_link(MenuLink(name='Back to App', url='/')) + + return admin \ No newline at end of file diff --git a/musicround/routes/deezer_routes.py b/musicround/routes/deezer_routes.py new file mode 100644 index 0000000..6b88830 --- /dev/null +++ b/musicround/routes/deezer_routes.py @@ -0,0 +1,223 @@ +from flask import Blueprint, render_template, redirect, url_for, request, current_app, flash, session, jsonify +from musicround.models import Song, db +import deezer +import musicbrainzngs +import requests +import openai +import os +import json +from musicround.helpers.metadata import get_song_metadata_by_isrc +from musicround.helpers.import_helper import ImportHelper + +deezer_bp = Blueprint('deezer', __name__) + +@deezer_bp.route('/deezer-search', methods=['GET']) +def deezer_search(): + """Display Deezer search form""" + return render_template('service_search.html', + service_name='Deezer', + search_results_url=url_for('deezer.deezer_search_results'), + browse_playlists_url=url_for('deezer.browse_deezer_playlists'), + track_import_url=url_for('deezer.import_deezer_track_result'), + album_import_url=url_for('deezer.import_deezer_album_result'), + playlist_import_url=url_for('deezer.import_deezer_playlist_result'), + url_placeholder='https://www.deezer.com/...') + +@deezer_bp.route('/deezer-search-results', methods=['POST']) +def deezer_search_results(): + """Search for tracks, albums, and playlists on Deezer""" + search_term = request.form['search_term'] + deezer_client = current_app.config['deezer'] + + try: + tracks = deezer_client.search_tracks(search_term) + albums = deezer_client.search_albums(search_term) + playlists = deezer_client.search_playlists(search_term) + + # Format tracks for the template + formatted_tracks = [] + for track in tracks: + if track: + formatted_tracks.append({ + 'id': track.get('id'), + 'name': track.get('title'), + 'artist': track.get('artist', {}).get('name', 'Unknown Artist') if track.get('artist') else 'Unknown Artist', + 'album': track.get('album', {}).get('title', '') if track.get('album') else '', + 'image_url': track.get('album', {}).get('cover_medium') if track.get('album') else None, + 'preview_url': track.get('preview') + }) + + # Format albums for the template + formatted_albums = [] + for album in albums: + if album: + formatted_albums.append({ + 'id': album.get('id'), + 'name': album.get('title'), + 'artist': album.get('artist', {}).get('name', 'Unknown Artist') if album.get('artist') else 'Unknown Artist', + 'image_url': album.get('cover_medium'), + 'track_count': album.get('nb_tracks') + }) + + # Format playlists for the template + formatted_playlists = [] + for playlist in playlists: + if playlist: + formatted_playlists.append({ + 'id': playlist.get('id'), + 'name': playlist.get('title'), + 'owner': playlist.get('user', {}).get('name', 'Unknown') if playlist.get('user') else 'Unknown', + 'image_url': playlist.get('picture_medium'), + 'track_count': playlist.get('nb_tracks') + }) + + # Use the standardized template for search results + return render_template('service_search_results.html', + service_name='Deezer', + search_term=search_term, + tracks=formatted_tracks, + albums=formatted_albums, + playlists=formatted_playlists, + tracks_label='Tracks', + search_url=url_for('deezer.deezer_search'), + has_preview=True, + track_import_url=url_for('deezer.import_deezer_track_result'), + track_id_field='track_id', + album_import_url=url_for('deezer.import_deezer_album_result'), + album_id_field='album_id', + playlist_import_url=url_for('deezer.import_deezer_playlist_result'), + playlist_id_field='playlist_id') + + except Exception as e: + current_app.logger.error(f"Deezer search error: {e}") + flash("Error searching Deezer. Please try again.", "danger") + return redirect(url_for('deezer.deezer_search')) + +@deezer_bp.route('/import-deezer-track', methods=['GET']) +def import_deezer_track(): + """Display form to import a single track from Deezer""" + return render_template('service_import.html', + service_name='Deezer', + item_type='Track', + url_example_prefix='https://www.deezer.com/track/', + url_example_id='12345678', + id_field='track_id', + form_action=url_for('deezer.import_deezer_track_result'), + back_url=url_for('deezer.deezer_search')) + +@deezer_bp.route('/import-deezer-track-result', methods=['POST']) +def import_deezer_track_result(): + """Process the import of a single track from Deezer using the unified ImportHelper""" + track_id = request.form['track_id'] + + # Use the unified ImportHelper to handle track import + result = ImportHelper.import_item('deezer', 'track', track_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} song from Deezer!', 'success') + elif result['skipped_count'] > 0: + flash('Song was already in the database.', 'info') + else: + flash(f'Error importing song: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + +# Legacy function kept for backward compatibility +def import_deezer_track_result_helper(track_id): + """Helper function to import a single track from Deezer""" + result = ImportHelper.import_item('deezer', 'track', track_id) + return result['imported_count'] > 0 + +@deezer_bp.route('/import-deezer-playlist', methods=['GET', 'POST']) +def import_deezer_playlist(): + """Display form to import all tracks from a Deezer playlist""" + if request.method == 'POST': + playlist_id = request.form.get('playlist_id') + if playlist_id: + # Use the unified ImportHelper to handle playlist import + result = ImportHelper.import_item('deezer', 'playlist', playlist_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from Deezer playlist!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing playlist: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + else: + flash("Playlist ID is required.", 'error') + + return render_template('service_import.html', + service_name='Deezer', + item_type='Playlist', + url_example_prefix='https://www.deezer.com/playlist/', + url_example_id='9876543', + id_field='playlist_id', + form_action=url_for('deezer.import_deezer_playlist_result'), + back_url=url_for('deezer.deezer_search')) + +@deezer_bp.route('/import-deezer-playlist-result', methods=['POST']) +def import_deezer_playlist_result(): + """Process the import of all tracks from a Deezer playlist using the unified ImportHelper""" + playlist_id = request.form['playlist_id'] + + # Use the unified ImportHelper to handle playlist import + result = ImportHelper.import_item('deezer', 'playlist', playlist_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from Deezer playlist!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing playlist: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + +@deezer_bp.route('/import-deezer-album', methods=['GET']) +def import_deezer_album(): + """Display form to import all tracks from a Deezer album""" + return render_template('service_import.html', + service_name='Deezer', + item_type='Album', + url_example_prefix='https://www.deezer.com/album/', + url_example_id='1234567', + id_field='album_id', + form_action=url_for('deezer.import_deezer_album_result'), + back_url=url_for('deezer.deezer_search')) + +@deezer_bp.route('/import-deezer-album-result', methods=['POST']) +def import_deezer_album_result(): + """Process the import of all tracks from a Deezer album using the unified ImportHelper""" + album_id = request.form['album_id'] + + # Use the unified ImportHelper to handle album import + result = ImportHelper.import_item('deezer', 'album', album_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from Deezer album!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing album: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + +@deezer_bp.route('/browse-deezer-playlists') +def browse_deezer_playlists(): + """Browse popular playlists on Deezer""" + deezer_client = current_app.config['deezer'] + + try: + playlists = deezer_client.get_popular_playlists() + return render_template('browse_deezer_playlists.html', playlists=playlists) + except Exception as e: + current_app.logger.error(f"Error browsing Deezer playlists: {e}") + flash("Error loading Deezer playlists. Please try again.", "danger") + return render_template('browse_deezer_playlists.html', playlists=[]) \ No newline at end of file diff --git a/musicround/routes/generate.py b/musicround/routes/generate.py new file mode 100644 index 0000000..6180d2d --- /dev/null +++ b/musicround/routes/generate.py @@ -0,0 +1,579 @@ +import random +from datetime import datetime +from flask import Blueprint, render_template, request, redirect, url_for, flash, current_app +from flask_login import current_user, login_required +from musicround.models import Song, Round, Tag, db + +generate_bp = Blueprint('generate', __name__) + +# Constants +songs_per_round = 8 + +# Helper functions +def get_all_decades(): + """ + Return a list of 'decade' strings (e.g. '1970', '1980') + based on the first 3 digits of the year + '0'. + """ + all_decades = [] + for song in Song.query.all(): + if song.year: + decade = str(song.year)[:3] + '0' + if decade not in all_decades: + all_decades.append(decade) + return all_decades + +def get_all_genres(): + """ + Return a list of all genres in the Song table. + """ + all_genres = [] + for song in Song.query.all(): + if song.genre and song.genre not in all_genres: + all_genres.append(song.genre) + return all_genres + +def get_all_tags(): + """ + Return a list of all tag names in the Tag table. + """ + return [tag.name for tag in Tag.query.all()] + +def get_songs_by_tag(tag_name, limit=8): + """ + Return songs that have the specified tag. + """ + tag = Tag.query.filter_by(name=tag_name).first() + if tag: + return tag.songs[:limit] + return [] + +def get_least_used_genres(): + """ + Returns a list of genre(s) whose usage count is minimal among all genres. + Usage is measured by how many Rounds of type 'genre' reference that genre. + """ + all_genres_list = get_all_genres() + # Start every genre with usage=0 + genre_usage = {g: 0 for g in all_genres_list} + + # Count how many times each genre appears in Rounds of type 'genre' + used_genre_rounds = Round.query.filter_by(round_type='genre').all() + for rnd in used_genre_rounds: + # Ensure we only increment if it exists in genre_usage + if rnd.round_criteria_used in genre_usage: + genre_usage[rnd.round_criteria_used] += 1 + + # If we have no genres at all, return an empty list + if not genre_usage: + return [] + + # Find the minimal usage count + min_usage = min(genre_usage.values()) + + # Return all genres that match min_usage + return [g for g, usage in genre_usage.items() if usage == min_usage] + + +def get_least_used_decades(): + """ + Returns a list of decade(s) whose usage count is minimal among all decades. + Usage is measured by how many Rounds of type 'decade' reference that decade. + """ + all_decades_list = get_all_decades() + # Start each decade with usage=0 + decade_usage = {d: 0 for d in all_decades_list} + + # Count how many times each decade appears in Rounds of type 'decade' + used_decade_rounds = Round.query.filter_by(round_type='decade').all() + for rnd in used_decade_rounds: + if rnd.round_criteria_used in decade_usage: + decade_usage[rnd.round_criteria_used] += 1 + + # If we have no decades at all, return empty + if not decade_usage: + return [] + + # Minimal usage + min_usage = min(decade_usage.values()) + + # Return all decades that match min_usage + return [d for d, usage in decade_usage.items() if usage == min_usage] + +def get_least_used_songs(genre=None, decade=None): + """ + Returns songs that have never been used in a round. + Can filter by genre or decade. + """ + least_used_songs = [] + all_songs = Song.query.all() + + # gather round_criteria_used for rounds of type 'song' + used_song_ids = [] + for rnd in Round.query.all(): + if rnd.round_type == 'song': + used_song_ids.append(rnd.round_criteria_used) + + # If a song's spotify_id never appears in used_song_ids => "least used" + for song in all_songs: + if song.spotify_id not in used_song_ids: + least_used_songs.append(song) + + # Filter by genre or decade if passed + if genre: + least_used_songs = [s for s in least_used_songs if s.genre == genre] + if decade: + least_used_songs = [s for s in least_used_songs if s.year and str(s.year)[:3] + '0' == decade] + return least_used_songs + +def get_non_overused_songs(genre=None, decade=None): + """ + Returns a list of songs whose used_count is <= the average usage among all songs. + Optional filtering by genre or decade. + """ + all_songs = Song.query.all() + total_times_used = sum(song.used_count for song in all_songs) or 1 + average_times_used = total_times_used / len(all_songs) if len(all_songs) else 1 + + # pick songs that are used <= average usage + non_overused_songs = [s for s in all_songs if s.used_count <= average_times_used] + + if genre: + non_overused_songs = [s for s in non_overused_songs if s.genre == genre] + + if decade: + non_overused_songs = [s for s in non_overused_songs if s.year and str(s.year)[:3] + '0' == decade] + + return non_overused_songs + +def get_random_songs_from_genre(genre, x=5): + """ + Returns x random songs from the given genre, + filling from non-overused songs in that genre. + If not enough, fallback to any non-overused songs. + """ + non_overused = get_non_overused_songs(genre=genre) + while len(non_overused) < x: + more = get_non_overused_songs() + if not more: # in case the DB is empty or something else + break + non_overused.extend(more) + + return random.sample(non_overused, x) if len(non_overused) >= x else non_overused + +def get_random_songs_from_decade(decade, x=5): + """ + Returns x random songs from the given decade, + filling from non-overused songs in that decade. + If not enough, fallback to any non-overused songs. + """ + non_overused = get_non_overused_songs(decade=decade) + while len(non_overused) < x: + more = get_non_overused_songs() + if not more: + break + non_overused.extend(more) + + return random.sample(non_overused, x) if len(non_overused) >= x else non_overused + +def get_random_songs(x): + """ + Returns x random songs from the pool of non-overused songs, + ensuring some naive diversity constraints: + - no artist used more than once + - no decade used more than x/3 times + - number of unique artists must match number of chosen songs + """ + non_overused_songs = get_non_overused_songs() + if len(non_overused_songs) < x: + return non_overused_songs + + random_songs = random.sample(non_overused_songs, x) + + artist_count = {} + decade_count = {} + + for song in random_songs: + artist_count[song.artist] = artist_count.get(song.artist, 0) + 1 + if song.year: + dec = str(song.year)[:3] + '0' + decade_count[dec] = decade_count.get(dec, 0) + 1 + + while ( + max(artist_count.values()) > 1 + or (decade_count and max(decade_count.values()) > len(random_songs) / 3) + or len(artist_count) != len(random_songs) + ): + # 1. If any artist is used more than once, replace that song + if max(artist_count.values()) > 1: + repeated_artist = None + for artist, count in artist_count.items(): + if count > 1: + repeated_artist = artist + break + if repeated_artist: + # remove one of that artist from random_songs + to_remove = next(s for s in random_songs if s.artist == repeated_artist) + random_songs.remove(to_remove) + artist_count[repeated_artist] -= 1 + + # pick a new random non-overused + refill = [s for s in non_overused_songs if s not in random_songs] + if refill: + new_song = random.choice(refill) + random_songs.append(new_song) + artist_count[new_song.artist] = artist_count.get(new_song.artist, 0) + 1 + + # update decade_count + if to_remove.year: + dec_to_remove = str(to_remove.year)[:3] + '0' + decade_count[dec_to_remove] = decade_count.get(dec_to_remove, 0) - 1 + if new_song.year: + dec_new = str(new_song.year)[:3] + '0' + decade_count[dec_new] = decade_count.get(dec_new, 0) + 1 + else: + # If no new songs available, just return what we have + return random_songs + + elif decade_count and max(decade_count.values()) > len(random_songs) / 3: + # 2. If any decade is used more than x/3, remove a song from that decade + repeated_decade = None + for dec, count in decade_count.items(): + if count > len(random_songs) / 3: + repeated_decade = dec + break + if repeated_decade: + to_remove = next((s for s in random_songs if s.year and str(s.year)[:3] + '0' == repeated_decade), None) + if to_remove: + random_songs.remove(to_remove) + decade_count[repeated_decade] -= 1 + + # pick a new random + refill = [s for s in non_overused_songs if s not in random_songs] + if refill: + new_song = random.choice(refill) + random_songs.append(new_song) + if new_song.year: + dec_new = str(new_song.year)[:3] + '0' + decade_count[dec_new] = decade_count.get(dec_new, 0) + 1 + + # update artist_count + artist_count[to_remove.artist] -= 1 + artist_count[new_song.artist] = artist_count.get(new_song.artist, 0) + 1 + else: + # If no new songs available, just return what we have + return random_songs + + elif len(artist_count) != len(random_songs): + # 3. if there's mismatch in how many unique artists vs. songs, fix that + # i.e. if we have a repeated artist but haven't caught it above + refill = [s for s in non_overused_songs if s not in random_songs] + repeated_song = None + # find a repeated artist + for s in random_songs: + if artist_count[s.artist] > 1: + repeated_song = s + break + if repeated_song is None or not refill: + break # fallback + + random_songs.remove(repeated_song) + artist_count[repeated_song.artist] -= 1 + + new_song = random.choice(refill) + random_songs.append(new_song) + artist_count[new_song.artist] = artist_count.get(new_song.artist, 0) + 1 + + if repeated_song.year: + dec_removed = str(repeated_song.year)[:3] + '0' + decade_count[dec_removed] = decade_count.get(dec_removed, 0) - 1 + if new_song.year: + dec_new = str(new_song.year)[:3] + '0' + decade_count[dec_new] = decade_count.get(dec_new, 0) + 1 + + return random_songs + +def get_random_songs_from_least_used_decade(x): + """ + Returns up to x songs from *one* of the least used decade(s), chosen at random. + Returns (songs, chosen_decade). + """ + candidates = get_least_used_decades() + if not candidates: + return [], None + + chosen_decade = random.choice(candidates) + random_songs = get_random_songs_from_decade(chosen_decade, x=x) + + return random_songs, chosen_decade + + +def get_random_songs_from_least_used_genre(x): + """ + Returns up to x songs from *one* of the least used genre(s), chosen at random. + Returns (songs, chosen_genre). + """ + candidates = get_least_used_genres() + if not candidates: + return [], None + + chosen_genre = random.choice(candidates) + random_songs = get_random_songs_from_genre(chosen_genre, x=x) + + return random_songs, chosen_genre + +def get_songs_from_deezer_playlist(playlist_id): + """ + Fetch songs from a Deezer playlist, properly import them with metadata, and return them + """ + try: + deezer_client = current_app.config['deezer'] + songs_per_round = current_app.config.get('SONGS_PER_ROUND', 10) + + playlist = deezer_client.get_playlist(playlist_id) + if not playlist: + return [] + + # Use the ImportHelper static methods directly without creating an instance + from musicround.helpers.import_helper import ImportHelper + + songs = [] + tracks = playlist.get('tracks', {}).get('data', []) + + for track in tracks: + deezer_id = str(track.get('id')) + if not deezer_id: + continue + + # Check if song already exists in our database + existing_song = Song.query.filter_by(deezer_id=deezer_id).first() + if existing_song: + songs.append(existing_song) + continue + + # Use the proper ImportHelper static method for importing + track_result = ImportHelper.import_deezer_track(deezer_client, deezer_id) + + # If the track was successfully imported, retrieve it from the database + if track_result.get('imported_count', 0) > 0: + imported_song = Song.query.filter_by(deezer_id=deezer_id).first() + if imported_song: + songs.append(imported_song) + + return songs[:songs_per_round] # Limit to songs_per_round + except Exception as e: + current_app.logger.error(f"Error fetching Deezer playlist: {e}") + import traceback + current_app.logger.error(traceback.format_exc()) + return [] + +def get_songs_from_spotify_playlist(playlist_id): + """ + Fetch songs from a Spotify playlist, properly import them with metadata, and return them + """ + try: + sp = current_app.config['sp'] + songs_per_round = current_app.config.get('SONGS_PER_ROUND', 10) + + playlist = sp.playlist_tracks(playlist_id) + if not playlist: + return [] + + # Use the ImportHelper static methods directly without creating an instance + from musicround.helpers.import_helper import ImportHelper + + songs = [] + for item in playlist.get('items', []): + track = item.get('track') + if not track or not track.get('id'): + continue + + spotify_id = track.get('id') + + # Check if the song already exists in our database + existing_song = Song.query.filter_by(spotify_id=spotify_id).first() + if existing_song: + songs.append(existing_song) + continue + + # Use the proper ImportHelper static methods for importing + track_result = ImportHelper.import_spotify_track(sp, spotify_id) + + # If the track was successfully imported, retrieve it from the database + if track_result.get('imported_count', 0) > 0: + imported_song = Song.query.filter_by(spotify_id=spotify_id).first() + if imported_song: + songs.append(imported_song) + + return songs[:songs_per_round] # Limit to songs_per_round + except Exception as e: + current_app.logger.error(f"Error fetching Spotify playlist: {e}") + import traceback + current_app.logger.error(traceback.format_exc()) + return [] + +@generate_bp.route('/build-music-round', methods=['GET', 'POST']) +@login_required +def build_music_round(): + """Build a music round based on the selected criteria""" + if request.method == 'POST': + round_type = request.form['round_type'] + if round_type == 'Random': + round_criteria = 'Random' + songs = get_random_songs(songs_per_round) + return render_template('round.html', songs=songs, round_criteria=round_criteria) + + elif round_type == 'Decade': + round_criteria = 'Least Used Decade' + songs, decade_used = get_random_songs_from_least_used_decade(songs_per_round) + return render_template( + 'round.html', + songs=songs, + round_criteria=round_criteria, + decade=decade_used + ) + + elif round_type == 'Genre': + round_criteria = 'Least Used Genre' + songs, genre_used = get_random_songs_from_least_used_genre(songs_per_round) + return render_template( + 'round.html', + songs=songs, + round_criteria=round_criteria, + genre=genre_used + ) + + elif round_type == 'Tag': + tag_name = request.form.get('tag_name') + if tag_name: + round_criteria = f'Tag: {tag_name}' + songs = get_songs_by_tag(tag_name, songs_per_round) + return render_template( + 'round.html', + songs=songs, + round_criteria=round_criteria, + tag=tag_name + ) + + # Pass tag choices to the template for selection + tags = get_all_tags() + return render_template('build_music_round.html', tags=tags) + +@generate_bp.route('/import-playlist', methods=['GET', 'POST']) +@login_required +def import_playlist(): + """Import a playlist from Deezer or Spotify""" + if request.method == 'POST': + playlist_url = request.form.get('playlist_url', '') + platform = request.form.get('platform', '').lower() + round_name = request.form.get('round_name', '') + + if not playlist_url: + flash('Please enter a playlist URL or ID', 'error') + return redirect(url_for('generate.import_playlist')) + + # Extract playlist ID from URL or use as is + playlist_id = playlist_url + + if platform == 'deezer': + # Extract Deezer playlist ID from URL if needed + if 'deezer.com' in playlist_url: + try: + playlist_id = playlist_url.split('playlist/')[1].split('?')[0] + except (IndexError, ValueError): + flash('Invalid Deezer playlist URL', 'error') + return redirect(url_for('generate.import_playlist')) + + songs = get_songs_from_deezer_playlist(playlist_id) + if not songs: + flash('No songs found or error fetching playlist from Deezer', 'error') + return redirect(url_for('generate.import_playlist')) + + round_criteria = f'Deezer Playlist: {playlist_id}' + + elif platform == 'spotify': + # Extract Spotify playlist ID from URL if needed + if 'spotify.com' in playlist_url: + try: + playlist_id = playlist_url.split('playlist/')[1].split('?')[0] + except (IndexError, ValueError): + flash('Invalid Spotify playlist URL', 'error') + return redirect(url_for('generate.import_playlist')) + + songs = get_songs_from_spotify_playlist(playlist_id) + if not songs: + flash('No songs found or error fetching playlist from Spotify', 'error') + return redirect(url_for('generate.import_playlist')) + + round_criteria = f'Spotify Playlist: {playlist_id}' + + else: + flash('Please select a valid platform', 'error') + return redirect(url_for('generate.import_playlist')) + + return render_template('round.html', + songs=songs, + round_criteria=round_criteria, + round_name=round_name, + playlist_import=True) + + return render_template('import_playlist.html') + +@generate_bp.route('/save_round', methods=['POST']) +@login_required +def save_round(): + """ + Persists a new Round to the DB (with chosen songs). + Increments used_count on all chosen songs. + """ + # get round criteria and name from form + round_criteria = request.form.get('round_criteria') + round_name = request.form.get('round_name') + + # get optional genre and decade from form + genre = request.form.get('genre') + decade = request.form.get('decade') + tag = request.form.get('tag') + + # get list of song IDs from form + song_ids = request.form.getlist('song_id') + + # get list of song objects from database + songs = Song.query.filter(Song.id.in_(song_ids)).all() + + # create string representation of song IDs + song_ids_str = ','.join(song_id for song_id in song_ids) + + # determine round type + if genre: + round_type = 'Genre' + round_criteria_used = genre + elif decade: + round_type = 'Decade' + round_criteria_used = decade + elif tag: + round_type = 'Tag' + round_criteria_used = tag + else: + round_type = 'Random' + round_criteria_used = 'Random Selection' + + # create new Round object and add to database + new_round = Round( + name=round_name, + round_type=round_type, + round_criteria_used=round_criteria_used, + songs=song_ids_str, + created_at=datetime.utcnow() + ) + db.session.add(new_round) + + # update usage count for each song + for song in songs: + song.used_count += 1 + db.session.add(song) + + db.session.commit() + + # redirect back to the rounds page + return redirect(url_for('rounds.rounds_list')) \ No newline at end of file diff --git a/musicround/routes/import.py b/musicround/routes/import.py new file mode 100644 index 0000000..504f7ff --- /dev/null +++ b/musicround/routes/import.py @@ -0,0 +1,241 @@ +""" +Import routes for the Music Round application +""" +import json +import time +import random +from flask import Blueprint, render_template, redirect, url_for, request, current_app, flash, session, jsonify +from musicround.models import Song, db +from musicround.routes.import_songs import import_pl, import_track + +import_bp = Blueprint('import', __name__, url_prefix='/import') + +def fetch_all_user_playlists(sp, user_id, limit=50): + """ + Fetch all playlists from a specific Spotify user account with pagination + + Args: + sp: Spotify API client + user_id: Spotify user ID to fetch playlists from + limit: Number of playlists to fetch per request (max 50) + + Returns: + List of all playlists from the specified user + """ + all_playlists = [] + offset = 0 + total = None + + start_time = time.time() + current_app.logger.info(f"Started fetching playlists for user '{user_id}'") + + while total is None or offset < total: + try: + # Use Spotify API to get playlists with pagination + results = sp.user_playlists(user_id, limit=limit, offset=offset) + + # If first request, get the total + if total is None: + total = results['total'] + current_app.logger.info(f"User '{user_id}' has {total} playlists in total") + + # Add the current batch of playlists to our collection + playlists_batch = results.get('items', []) + all_playlists.extend(playlists_batch) + + # Update offset for next batch + offset += limit + + # Log progress + current_app.logger.info(f"Fetched {len(playlists_batch)} playlists for '{user_id}', progress: {len(all_playlists)}/{total}") + + # Break if we've reached the end + if not results.get('next'): + break + + except Exception as e: + current_app.logger.error(f"Error fetching playlists for user '{user_id}' at offset {offset}: {e}") + break + + end_time = time.time() + duration = int((end_time - start_time) * 1000) + current_app.logger.info(f"Completed fetching {len(all_playlists)}/{total} playlists for user '{user_id}' in {duration}ms") + + return all_playlists + +def filter_playlists_by_keywords(playlists, keywords, debug_info=None): + """ + Filter playlists by checking if any of the keywords are in the playlist name + + Args: + playlists: List of playlist objects + keywords: List of keywords to filter by + debug_info: Optional debug info dictionary to update with filtering stats + + Returns: + Filtered list of playlists + """ + filtered = [] + keywords_lower = [k.lower() for k in keywords] + + for playlist in playlists: + name = playlist.get('name', '').lower() + + # Check if any keyword is in the playlist name + if any(keyword in name for keyword in keywords_lower): + filtered.append(playlist) + + # Add to debug info if provided + if debug_info is not None and 'matched_keywords' in debug_info: + matched = [k for k in keywords_lower if k in name] + for keyword in matched: + if keyword not in debug_info['matched_keywords']: + debug_info['matched_keywords'][keyword] = 0 + debug_info['matched_keywords'][keyword] += 1 + + return filtered + +@import_bp.route('/official-playlists', methods=['GET', 'POST']) +def import_official_playlists(): + """Display and import official Spotify playlists from multiple regional accounts""" + if 'access_token' not in session: + return redirect(url_for('auth.login')) + + sp = current_app.config['sp'] + + # Handle POST request for importing a playlist + if request.method == 'POST': + playlist_id = request.form['playlist_id'] + import_pl(playlist_id) + flash('Spotify playlist imported successfully!', 'success') + return redirect(url_for('core.view_songs')) + + # Get filter keywords from the query string (default to empty list) + filter_keywords = request.args.get('filter', '').split(',') + filter_keywords = [k.strip() for k in filter_keywords if k.strip()] + + # List of official Spotify user accounts to fetch playlists from + spotify_accounts = [ + 'spotify', + 'spotifycharts', + 'spotifymaps', + 'spotifyuk', + 'spotifyusa', + 'spotify_germany' + ] + + # Get selected account from query string or default to all + selected_account = request.args.get('account', 'all') + + # Get debug mode parameter + debug_mode = request.args.get('debug', 'false').lower() == 'true' + + # Prepare debug info + debug_info = { + 'accounts': {}, + 'total_fetched': 0, + 'total_filtered': 0, + 'filtered_out': 0, + 'matched_keywords': {}, + 'query_time_ms': 0, + 'duplicates_removed': 0 + } + + # Initialize playlists list + all_playlists = [] + + try: + start_time = time.time() + + # Process each Spotify account or just the selected one + accounts_to_process = [selected_account] if selected_account != 'all' else spotify_accounts + + for account in accounts_to_process: + if account not in spotify_accounts and account != 'all': + continue + + account_debug = { + 'total': 0, + 'fetched': 0, + 'filtered': 0, + 'time_ms': 0 + } + + account_start = time.time() + + # Fetch all playlists for this account + account_playlists = fetch_all_user_playlists(sp, account) + + account_end = time.time() + account_debug['time_ms'] = int((account_end - account_start) * 1000) + + account_debug['total'] = len(account_playlists) + account_debug['fetched'] = len(account_playlists) + debug_info['total_fetched'] += len(account_playlists) + + # Apply keyword filtering if keywords provided + if filter_keywords: + filtered_playlists = filter_playlists_by_keywords( + account_playlists, + filter_keywords, + debug_info + ) + account_debug['filtered'] = len(filtered_playlists) + debug_info['filtered_out'] += (len(account_playlists) - len(filtered_playlists)) + all_playlists.extend(filtered_playlists) + else: + # No filtering, use all playlists + all_playlists.extend(account_playlists) + account_debug['filtered'] = len(account_playlists) + + debug_info['accounts'][account] = account_debug + + # Remove duplicates based on playlist ID + unique_playlists = [] + seen_ids = set() + for playlist in all_playlists: + if playlist['id'] not in seen_ids: + seen_ids.add(playlist['id']) + unique_playlists.append(playlist) + else: + debug_info['duplicates_removed'] += 1 + + all_playlists = unique_playlists + debug_info['total_filtered'] = len(all_playlists) + + end_time = time.time() + debug_info['query_time_ms'] = int((end_time - start_time) * 1000) + + # Log summary + current_app.logger.info( + f"Search summary: Fetched {debug_info['total_fetched']} playlists, " + f"filtered to {debug_info['total_filtered']} playlists " + f"({debug_info['filtered_out']} filtered out, {debug_info['duplicates_removed']} duplicates removed) " + f"in {debug_info['query_time_ms']}ms" + ) + + # Sort playlists by follower count or name if available + all_playlists.sort(key=lambda x: x.get('name', '').lower()) + + # Randomize order if no specific sorting + if not filter_keywords: + random.shuffle(all_playlists) + + except Exception as e: + current_app.logger.error(f"Error fetching official playlists: {e}") + flash('Error retrieving playlists from Spotify', 'danger') + all_playlists = [] + + # Handle empty result + if not all_playlists: + flash('No Spotify playlists found matching your criteria', 'warning') + + return render_template( + 'import_official_playlists.html', + playlists=all_playlists, + filter_keywords=filter_keywords, + selected_account=selected_account, + spotify_accounts=spotify_accounts, + debug_info=debug_info, + debug_mode=debug_mode + ) \ No newline at end of file diff --git a/musicround/routes/import_routes.py b/musicround/routes/import_routes.py new file mode 100644 index 0000000..b9937fa --- /dev/null +++ b/musicround/routes/import_routes.py @@ -0,0 +1,745 @@ +""" +Import routes for the Music Round application +""" +import json +import time +import random +from flask import Blueprint, render_template, redirect, url_for, request, current_app, flash, session, jsonify +from musicround.models import Song, db +from musicround.routes.import_songs import import_pl +from musicround.helpers.import_helper import ImportHelper + +import_bp = Blueprint('import', __name__, url_prefix='/import') + +def fetch_all_user_playlists(sp, user_id, limit=50): + """ + Fetch all playlists from a specific Spotify user account with pagination + + Args: + sp: Spotify API client + user_id: Spotify user ID to fetch playlists from + limit: Number of playlists to fetch per request (max 50) + + Returns: + List of all playlists from the specified user + """ + all_playlists = [] + offset = 0 + total = None + + start_time = time.time() + current_app.logger.info(f"Started fetching playlists for user '{user_id}'") + + # Hard limit to prevent infinite loops (should never be needed if API works correctly) + max_loops = 100 + loop_count = 0 + + while loop_count < max_loops: + loop_count += 1 + try: + # Use Spotify API to get playlists with pagination + current_app.logger.info(f"Fetching playlists for {user_id} with offset={offset}, limit={limit}, loop={loop_count}") + results = sp.user_playlists(user_id, limit=limit, offset=offset) + + # Log raw API response for debugging (only first few characters to avoid flooding logs) + response_sample = str(results)[:500] + '...' if len(str(results)) > 500 else str(results) + current_app.logger.debug(f"API response sample: {response_sample}") + + # If first request, get and validate the total + if total is None: + total = results.get('total', 0) + current_app.logger.info(f"User '{user_id}' has {total} playlists in total according to API") + if total == 0: + current_app.logger.warning(f"API reported 0 total playlists for {user_id} - possible API error") + + # Add the current batch of playlists to our collection + playlists_batch = results.get('items', []) + batch_count = len(playlists_batch) + all_playlists.extend(playlists_batch) + + current_app.logger.info(f"Batch for {user_id}: offset={offset}, received={batch_count} playlists") + + # If we didn't get any playlists in this batch, something is wrong + if batch_count == 0: + current_app.logger.warning(f"Received 0 playlists for {user_id} at offset {offset} - possible API error") + if 'items' not in results: + current_app.logger.warning(f"Missing 'items' key in API response for {user_id}") + break + + # Break if we received fewer items than requested (last page) + if batch_count < limit: + current_app.logger.info(f"Reached end of results for {user_id} (received {batch_count} < limit {limit})") + break + + # Update offset for next batch + offset += batch_count + + # Log progress + current_app.logger.info(f"Fetched {len(playlists_batch)} playlists for '{user_id}', progress: {len(all_playlists)}/{total}") + + # Break if we've reached or exceeded the total number of playlists + if offset >= total: + current_app.logger.info(f"Reached total {total} playlists for {user_id} at offset {offset}") + break + + # Break if we've exhausted all playlists (next URL is None) + if not results.get('next'): + current_app.logger.info(f"No more 'next' URL for {user_id} at offset {offset}") + # Check if we should have more results based on 'total' + if offset < total: + current_app.logger.warning( + f"API inconsistency: 'next' is None but we've only fetched {offset} out of {total} playlists" + ) + break + + except Exception as e: + current_app.logger.error(f"Error fetching playlists for user '{user_id}' at offset {offset}: {str(e)}") + # Try to get more specific error information + import traceback + current_app.logger.error(f"Traceback: {traceback.format_exc()}") + break + + # Check if we hit the max loops limit + if loop_count >= max_loops: + current_app.logger.warning(f"Reached maximum loop count ({max_loops}) for user {user_id}") + + end_time = time.time() + duration = int((end_time - start_time) * 1000) + current_app.logger.info(f"Completed fetching {len(all_playlists)}/{total} playlists for user '{user_id}' in {duration}ms") + + return all_playlists + +def filter_playlists_by_keywords(playlists, keywords, debug_info=None): + """ + Filter playlists by checking if any of the keywords are in the playlist name + + Args: + playlists: List of playlist objects + keywords: List of keywords to filter by + debug_info: Optional debug info dictionary to update with filtering stats + + Returns: + Filtered list of playlists + """ + filtered = [] + keywords_lower = [k.lower() for k in keywords] + + for playlist in playlists: + name = playlist.get('name', '').lower() + + # Check if any keyword is in the playlist name + if any(keyword in name for keyword in keywords_lower): + filtered.append(playlist) + + # Add to debug info if provided + if debug_info is not None and 'matched_keywords' in debug_info: + matched = [k for k in keywords_lower if k in name] + for keyword in matched: + if keyword not in debug_info['matched_keywords']: + debug_info['matched_keywords'][keyword] = 0 + debug_info['matched_keywords'][keyword] += 1 + + return filtered + +@import_bp.route('/official-playlists', methods=['GET', 'POST']) +def import_official_playlists(): + """Display and import official Spotify playlists from multiple regional accounts""" + if 'access_token' not in session: + return redirect(url_for('users.login')) + + sp = current_app.config['sp'] + + # Handle POST request for importing a playlist + if request.method == 'POST': + playlist_id = request.form['playlist_id'] + # Use the new unified ImportHelper + result = ImportHelper.import_item('spotify', 'playlist', playlist_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from official Spotify playlist!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing playlist: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + + # Get filter keywords from the query string (default to empty list) + filter_keywords = request.args.get('filter', '').split(',') + filter_keywords = [k.strip() for k in filter_keywords if k.strip()] + + # List of official Spotify user accounts to fetch playlists from + spotify_accounts = [ + 'spotify', + 'spotifycharts', + 'spotifymaps', + 'spotifyuk', + 'spotifyusa', + 'spotify_germany' + ] + + # Get selected account from query string or default to all + selected_account = request.args.get('account', 'all') + + # Get debug mode parameter + debug_mode = request.args.get('debug', 'false').lower() == 'true' + + # Prepare debug info + debug_info = { + 'accounts': {}, + 'total_fetched': 0, + 'total_filtered': 0, + 'filtered_out': 0, + 'matched_keywords': {}, + 'query_time_ms': 0, + 'duplicates_removed': 0 + } + + # Initialize playlists list + all_playlists = [] + + try: + start_time = time.time() + + # Process each Spotify account or just the selected one + accounts_to_process = [selected_account] if selected_account != 'all' else spotify_accounts + + for account in accounts_to_process: + if account not in spotify_accounts and account != 'all': + continue + + account_debug = { + 'total': 0, + 'fetched': 0, + 'filtered': 0, + 'time_ms': 0 + } + + account_start = time.time() + + # Fetch all playlists for this account + account_playlists = fetch_all_user_playlists(sp, account) + + account_end = time.time() + account_debug['time_ms'] = int((account_end - account_start) * 1000) + + account_debug['total'] = len(account_playlists) + account_debug['fetched'] = len(account_playlists) + debug_info['total_fetched'] += len(account_playlists) + + # Apply keyword filtering if keywords provided + if filter_keywords: + filtered_playlists = filter_playlists_by_keywords( + account_playlists, + filter_keywords, + debug_info + ) + account_debug['filtered'] = len(filtered_playlists) + debug_info['filtered_out'] += (len(account_playlists) - len(filtered_playlists)) + all_playlists.extend(filtered_playlists) + else: + # No filtering, use all playlists + all_playlists.extend(account_playlists) + account_debug['filtered'] = len(account_playlists) + + debug_info['accounts'][account] = account_debug + + # Remove duplicates based on playlist ID + unique_playlists = [] + seen_ids = set() + for playlist in all_playlists: + if playlist['id'] not in seen_ids: + seen_ids.add(playlist['id']) + unique_playlists.append(playlist) + else: + debug_info['duplicates_removed'] += 1 + + all_playlists = unique_playlists + debug_info['total_filtered'] = len(all_playlists) + + end_time = time.time() + debug_info['query_time_ms'] = int((end_time - start_time) * 1000) + + # Log summary + current_app.logger.info( + f"Search summary: Fetched {debug_info['total_fetched']} playlists, " + f"filtered to {debug_info['total_filtered']} playlists " + f"({debug_info['filtered_out']} filtered out, {debug_info['duplicates_removed']} duplicates removed) " + f"in {debug_info['query_time_ms']}ms" + ) + + # Sort playlists by follower count or name if available + all_playlists.sort(key=lambda x: x.get('name', '').lower()) + + # Randomize order if no specific sorting + if not filter_keywords: + random.shuffle(all_playlists) + + except Exception as e: + current_app.logger.error(f"Error fetching official playlists: {e}") + flash('Error retrieving playlists from Spotify', 'danger') + all_playlists = [] + + # Handle empty result + if not all_playlists: + flash('No Spotify playlists found matching your criteria', 'warning') + + # Get the bearer token from the session to display in the form + session_bearer_token = session.get('direct_bearer_token', '') + spotify_username = session.get('direct_spotify_username') + + return render_template( + 'import_official_playlists.html', + playlists=all_playlists, + filter_keywords=filter_keywords, + selected_account=selected_account, + spotify_accounts=spotify_accounts, + debug_info=debug_info, + debug_mode=debug_mode, + session_bearer_token=session_bearer_token, + spotify_username=spotify_username, + direct_mode=False + ) + +@import_bp.route('/direct-official-playlists', methods=['GET', 'POST']) +def direct_official_playlists(): + """Display and import official Spotify playlists using the direct client with bearer token""" + # Check if user has provided a bearer token + bearer_token = session.get('direct_bearer_token') + if not bearer_token: + flash('Please provide a bearer token first', 'warning') + return redirect(url_for('import.direct_spotify_auth')) + + # Initialize direct Spotify client with bearer token + from musicround.helpers.spotify_direct import SpotifyDirectClient + direct_client = SpotifyDirectClient(bearer_token=bearer_token) + + # Handle POST request for importing a playlist + if request.method == 'POST': + playlist_id = request.form['playlist_id'] + # Use the new unified ImportHelper + result = ImportHelper.import_item('spotify', 'playlist', playlist_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from official Spotify playlist!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing playlist: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + + # Get filter keywords from the query string (default to empty list) + filter_keywords = request.args.get('filter', '').split(',') + filter_keywords = [k.strip() for k in filter_keywords if k.strip()] + + # List of official Spotify user accounts to fetch playlists from + spotify_accounts = [ + 'spotify', + 'spotifycharts', + 'spotifymaps', + 'spotifyuk', + 'spotifyusa', + 'spotify_germany' + ] + + # Get selected account from query string or default to all + selected_account = request.args.get('account', 'all') + + # Get debug mode parameter + debug_mode = request.args.get('debug', 'false').lower() == 'true' + + # Prepare debug info + debug_info = { + 'accounts': {}, + 'total_fetched': 0, + 'total_filtered': 0, + 'filtered_out': 0, + 'matched_keywords': {}, + 'query_time_ms': 0, + 'duplicates_removed': 0 + } + + # Initialize playlists list + all_playlists = [] + + try: + start_time = time.time() + + # Process each Spotify account or just the selected one + accounts_to_process = [selected_account] if selected_account != 'all' else spotify_accounts + + for account in accounts_to_process: + if account not in spotify_accounts and account != 'all': + continue + + account_debug = { + 'total': 0, + 'fetched': 0, + 'filtered': 0, + 'time_ms': 0 + } + + account_start = time.time() + + # Fetch all playlists for this account using direct client + account_playlists = direct_client.fetch_all_user_playlists(account) + + account_end = time.time() + account_debug['time_ms'] = int((account_end - account_start) * 1000) + + account_debug['total'] = len(account_playlists) + account_debug['fetched'] = len(account_playlists) + debug_info['total_fetched'] += len(account_playlists) + + # Apply keyword filtering if keywords provided + if filter_keywords: + filtered_playlists = filter_playlists_by_keywords( + account_playlists, + filter_keywords, + debug_info + ) + account_debug['filtered'] = len(filtered_playlists) + debug_info['filtered_out'] += (len(account_playlists) - len(filtered_playlists)) + all_playlists.extend(filtered_playlists) + else: + # No filtering, use all playlists + all_playlists.extend(account_playlists) + account_debug['filtered'] = len(account_playlists) + + debug_info['accounts'][account] = account_debug + + # Remove duplicates based on playlist ID + unique_playlists = [] + seen_ids = set() + for playlist in all_playlists: + if playlist['id'] not in seen_ids: + seen_ids.add(playlist['id']) + unique_playlists.append(playlist) + else: + debug_info['duplicates_removed'] += 1 + + all_playlists = unique_playlists + debug_info['total_filtered'] = len(all_playlists) + + end_time = time.time() + debug_info['query_time_ms'] = int((end_time - start_time) * 1000) + + # Log summary + current_app.logger.info( + f"Direct search summary: Fetched {debug_info['total_fetched']} playlists, " + f"filtered to {debug_info['total_filtered']} playlists " + f"({debug_info['filtered_out']} filtered out, {debug_info['duplicates_removed']} duplicates removed) " + f"in {debug_info['query_time_ms']}ms" + ) + + # Sort playlists by follower count or name if available + all_playlists.sort(key=lambda x: x.get('name', '').lower()) + + # Randomize order if no specific sorting + if not filter_keywords: + random.shuffle(all_playlists) + + except Exception as e: + current_app.logger.error(f"Error fetching official playlists with direct client: {e}") + import traceback + current_app.logger.error(traceback.format_exc()) + flash(f'Error retrieving playlists from Spotify: {str(e)}', 'danger') + all_playlists = [] + + # Handle empty result + if not all_playlists: + flash('No Spotify playlists found matching your criteria', 'warning') + + return render_template( + 'import_official_playlists.html', + playlists=all_playlists, + filter_keywords=filter_keywords, + selected_account=selected_account, + spotify_accounts=spotify_accounts, + debug_info=debug_info, + debug_mode=debug_mode, + direct_mode=True, + spotify_username=session.get('direct_spotify_username') + ) + +@import_bp.route('/test-spotify-client', methods=['GET']) +def test_spotify_client(): + """Test route to compare different Spotify client implementations""" + if 'access_token' not in session: + return redirect(url_for('users.login')) + + # Get Spotify account to check from query parameters + account = request.args.get('account', 'spotify') + + # Results container + results = { + 'spotipy': { + 'playlists': [], + 'count': 0, + 'total': 0, + 'time_ms': 0, + 'error': None + }, + 'direct': { + 'playlists': [], + 'count': 0, + 'total': 0, + 'time_ms': 0, + 'error': None + } + } + + # Test spotipy implementation + try: + sp = current_app.config['sp'] + start_time = time.time() + + current_app.logger.info(f"Testing spotipy implementation for account {account}") + spotipy_playlists = fetch_all_user_playlists(sp, account) + + end_time = time.time() + duration_ms = int((end_time - start_time) * 1000) + + results['spotipy']['playlists'] = spotipy_playlists + results['spotipy']['count'] = len(spotipy_playlists) + results['spotipy']['time_ms'] = duration_ms + + # Get total from first API call if available + if spotipy_playlists: + first_result = sp.user_playlists(account, limit=1) + results['spotipy']['total'] = first_result.get('total', 'unknown') + + except Exception as e: + import traceback + current_app.logger.error(f"Error testing spotipy: {e}") + current_app.logger.error(traceback.format_exc()) + results['spotipy']['error'] = str(e) + + # Test direct implementation + try: + from musicround.helpers.spotify_direct import SpotifyDirectClient + + # Get bearer token from session if available + bearer_token = session.get('direct_bearer_token') + if not bearer_token: + current_app.logger.warning("No bearer token in session for direct client") + results['direct']['error'] = "No bearer token available. Please set a token in Direct Auth page first." + else: + direct_client = SpotifyDirectClient(bearer_token=bearer_token) + + start_time = time.time() + current_app.logger.info(f"Testing direct implementation for account {account}") + direct_playlists = direct_client.fetch_all_user_playlists(account) + + end_time = time.time() + duration_ms = int((end_time - start_time) * 1000) + + results['direct']['playlists'] = direct_playlists + results['direct']['count'] = len(direct_playlists) + results['direct']['time_ms'] = duration_ms + + # Get total if available from response + if direct_playlists and len(direct_playlists) > 0: + first_result = direct_client.user_playlists(account, limit=1) + results['direct']['total'] = first_result.get('total', 'unknown') + + except Exception as e: + import traceback + current_app.logger.error(f"Error testing direct client: {e}") + current_app.logger.error(traceback.format_exc()) + results['direct']['error'] = str(e) + + # Compare playlists between implementations + comparison = { + 'only_in_spotipy': [], + 'only_in_direct': [], + 'in_both': [] + } + + if results['spotipy']['playlists'] and results['direct']['playlists']: + spotipy_ids = {pl['id'] for pl in results['spotipy']['playlists']} + direct_ids = {pl['id'] for pl in results['direct']['playlists']} + + comparison['only_in_spotipy'] = list(spotipy_ids - direct_ids) + comparison['only_in_direct'] = list(direct_ids - spotipy_ids) + comparison['in_both'] = list(spotipy_ids.intersection(direct_ids)) + + # Add direct auth link to template data + direct_auth_url = url_for('import.direct_spotify_auth') + + # Render the comparison template + return render_template( + 'spotify_client_test.html', + account=account, + results=results, + comparison=comparison, + direct_auth_url=direct_auth_url, + has_bearer_token=bool(session.get('direct_bearer_token')) + ) + +@import_bp.route('/raw-playlists', methods=['GET']) +def get_raw_playlists(): + """ + Get raw playlists from Spotify without any pagination logic. + This helps diagnose issues with the playlist retrieval. + """ + if 'access_token' not in session: + return redirect(url_for('users.login')) + + # Get Spotify account to check + account = request.args.get('account', 'spotify') + # Get limit parameter (max 50) + limit = min(int(request.args.get('limit', '50')), 50) + # Get offset parameter + offset = int(request.args.get('offset', '0')) + + results = { + 'spotipy': { + 'raw_response': None, + 'error': None + }, + 'direct': { + 'raw_response': None, + 'error': None + } + } + + # Test spotipy raw response + try: + sp = current_app.config['sp'] + current_app.logger.info(f"Getting raw playlists with spotipy for {account}, limit={limit}, offset={offset}") + raw_result = sp.user_playlists(account, limit=limit, offset=offset) + results['spotipy']['raw_response'] = raw_result + except Exception as e: + import traceback + current_app.logger.error(f"Error getting raw spotipy playlists: {e}") + current_app.logger.error(traceback.format_exc()) + results['spotipy']['error'] = str(e) + + # Test direct API raw response + try: + from musicround.helpers.spotify_direct import SpotifyDirectClient + + # Get bearer token from session if available + bearer_token = session.get('direct_bearer_token') + if not bearer_token: + current_app.logger.warning("No bearer token in session for direct client") + results['direct']['error'] = "No bearer token available. Please set a token in Direct Auth page first." + else: + direct_client = SpotifyDirectClient(bearer_token=bearer_token) + current_app.logger.info(f"Getting raw playlists with direct API for {account}, limit={limit}, offset={offset}") + raw_result = direct_client.user_playlists(account, limit=limit, offset=offset) + results['direct']['raw_response'] = raw_result + except Exception as e: + import traceback + current_app.logger.error(f"Error getting raw direct playlists: {e}") + current_app.logger.error(traceback.format_exc()) + results['direct']['error'] = str(e) + + # Add direct auth link to template data + direct_auth_url = url_for('import.direct_spotify_auth') + + return render_template( + 'raw_playlists.html', + account=account, + limit=limit, + offset=offset, + results=results, + direct_auth_url=direct_auth_url, + has_bearer_token=bool(session.get('direct_bearer_token')) + ) + +@import_bp.route('/direct-auth', methods=['GET', 'POST']) +def direct_spotify_auth(): + """ + Allow users to manually enter a Spotify bearer token for direct API access. + This bypasses the OAuth flow and is useful when API limitations are in place. + """ + error = None + success = None + + if request.method == 'POST': + bearer_token = request.form.get('bearer_token') + if bearer_token: + try: + # Store the token in session + session['direct_bearer_token'] = bearer_token + + # Test the token with a simple request + from musicround.helpers.spotify_direct import SpotifyDirectClient + client = SpotifyDirectClient(bearer_token=bearer_token) + + # Try to get current user info as a test + result = client._make_api_request("me") + + if result and 'id' in result: + session['direct_spotify_user'] = result['id'] + session['direct_spotify_username'] = result.get('display_name', result['id']) + success = f"Successfully authenticated as {session['direct_spotify_username']}" + else: + error = "Token validation failed. Please check the token and try again." + except Exception as e: + current_app.logger.error(f"Error validating bearer token: {e}") + error = f"Error: {str(e)}" + else: + error = "No bearer token provided" + + # Get stored user info if available + spotify_user = session.get('direct_spotify_user') + spotify_username = session.get('direct_spotify_username') + + return render_template( + 'spotify_direct_auth.html', + error=error, + success=success, + spotify_user=spotify_user, + spotify_username=spotify_username + ) + +@import_bp.route('/update-direct-token', methods=['POST']) +def update_direct_token(): + """Update the direct bearer token and redirect back to the referring page""" + # Get return URL from form or default to playlist page + return_url = request.form.get('return_url') or url_for('import.direct_official_playlists') + + # Check if clearing token was requested + if request.form.get('clear_token'): + session.pop('direct_bearer_token', None) + session.pop('direct_spotify_user', None) + session.pop('direct_spotify_username', None) + flash('Bearer token cleared successfully', 'success') + return redirect(return_url) + + # Get bearer token from form + bearer_token = request.form.get('bearer_token') + if not bearer_token: + flash('No bearer token provided', 'warning') + return redirect(return_url) + + try: + # Store the token in session + session['direct_bearer_token'] = bearer_token + + # Test the token with a simple request + from musicround.helpers.spotify_direct import SpotifyDirectClient + client = SpotifyDirectClient(bearer_token=bearer_token) + + # Try to get current user info as a test + result = client._make_api_request("me") + + if result and 'id' in result: + session['direct_spotify_user'] = result['id'] + session['direct_spotify_username'] = result.get('display_name', result['id']) + flash(f'Successfully authenticated as {session["direct_spotify_username"]}', 'success') + else: + flash('Token validation failed. Please check the token and try again.', 'error') + except Exception as e: + current_app.logger.error(f"Error validating bearer token: {e}") + flash(f'Error validating token: {str(e)}', 'error') + + return redirect(return_url) \ No newline at end of file diff --git a/musicround/routes/import_songs.py b/musicround/routes/import_songs.py new file mode 100644 index 0000000..d774113 --- /dev/null +++ b/musicround/routes/import_songs.py @@ -0,0 +1,111 @@ +import random +import os +import requests +import json +from flask import Blueprint, session, redirect, request, render_template, url_for, current_app, flash +from musicround.models import Song, db +from musicround.helpers.metadata import get_song_metadata_by_isrc +from musicround.helpers.import_helper import ImportHelper + +import_songs_bp = Blueprint('import_songs', __name__, url_prefix='/import') + +# Legacy function retained for backward compatibility +def import_track(track_id): + """Legacy helper function that now uses the new ImportHelper""" + result = ImportHelper.import_item('spotify', 'track', track_id) + return result['imported_count'] > 0 + +# Legacy function retained for backward compatibility +def import_pl(playlist_id): + """Legacy helper function that now uses the new ImportHelper""" + ImportHelper.import_item('spotify', 'playlist', playlist_id) + +# Legacy function retained for backward compatibility +def import_al(album_id): + """Legacy helper function that now uses the new ImportHelper""" + ImportHelper.import_item('spotify', 'album', album_id) + +@import_songs_bp.route('/song', methods=['GET', 'POST']) +def import_song(): + if 'access_token' not in session: + return redirect(url_for('users.login')) + + if request.method == 'POST': + track_id = request.form['song_id'] + result = ImportHelper.import_item('spotify', 'track', track_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} song!', 'success') + elif result['skipped_count'] > 0: + flash('Song was already in the database.', 'info') + else: + flash(f'Error importing song: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + + return render_template('service_import.html', + service_name='Spotify', + item_type='Track', + url_example_prefix='https://open.spotify.com/track/', + url_example_id='6rqhFgbbKwnb9MLmUQDhG6', + id_field='song_id', + form_action=url_for('import_songs.import_song'), + back_url=url_for('core.search')) + +@import_songs_bp.route('/playlist', methods=['GET', 'POST']) +def import_playlist(): + if 'access_token' not in session: + return redirect(url_for('users.login')) + + if request.method == 'POST': + playlist_id = request.form['playlist_id'] + result = ImportHelper.import_item('spotify', 'playlist', playlist_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from playlist!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing playlist: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + + return render_template('service_import.html', + service_name='Spotify', + item_type='Playlist', + url_example_prefix='https://open.spotify.com/playlist/', + url_example_id='37i9dQZF1DXcBWIGoYBM5M', + id_field='playlist_id', + form_action=url_for('import_songs.import_playlist'), + back_url=url_for('core.search')) + +@import_songs_bp.route('/album', methods=['GET', 'POST']) +def import_album(): + if 'access_token' not in session: + return redirect(url_for('users.login')) + + if request.method == 'POST': + album_id = request.form['album_id'] + result = ImportHelper.import_item('spotify', 'album', album_id) + + if result['imported_count'] > 0: + flash(f'Successfully imported {result["imported_count"]} songs from album!', 'success') + elif result['skipped_count'] > 0 and result['error_count'] == 0: + flash(f'All {result["skipped_count"]} songs were already in the database.', 'info') + elif result['error_count'] > 0: + flash(f'Encountered {result["error_count"]} errors during import.', 'warning') + else: + flash(f'Error importing album: {", ".join(result["errors"])}', 'danger') + + return redirect(url_for('core.view_songs')) + + return render_template('service_import.html', + service_name='Spotify', + item_type='Album', + url_example_prefix='https://open.spotify.com/album/', + url_example_id='4aawyAB9vmqN3uQ7FjRGTy', + id_field='album_id', + form_action=url_for('import_songs.import_album'), + back_url=url_for('core.search')) \ No newline at end of file diff --git a/musicround/routes/process.py b/musicround/routes/process.py new file mode 100644 index 0000000..76d5a0d --- /dev/null +++ b/musicround/routes/process.py @@ -0,0 +1,21 @@ +from flask import Blueprint, session, redirect, url_for, jsonify, request, current_app +import base64 + +process_bp = Blueprint('process', __name__, url_prefix='/process') + +@process_bp.route('/base64', methods=['POST']) +def base64_encode_data(): + """ + Return base64-encoded string from data provided in request body. + """ + if 'access_token' not in session: + return redirect(url_for('users.login')) # Assuming 'users.login' is the correct endpoint + + # Get binary data from request + data = request.get_data() + if not data: + return jsonify({'error': 'No data provided'}), 400 + + return jsonify({ + 'encoded': base64.b64encode(data).decode('utf-8') + }) \ No newline at end of file diff --git a/musicround/routes/rounds.py b/musicround/routes/rounds.py new file mode 100644 index 0000000..c025dd8 --- /dev/null +++ b/musicround/routes/rounds.py @@ -0,0 +1,1112 @@ +import os +import smtplib +import shutil +import base64 +import tempfile +import requests +import logging +from datetime import datetime +from io import BytesIO +from email.mime.multipart import MIMEMultipart +from email.mime.text import MIMEText +from email.mime.base import MIMEBase +from email import encoders +import re +import zipfile +import io +import json + +from flask import Blueprint, session, redirect, request, render_template, url_for, current_app, send_file, jsonify, flash +from flask_login import current_user, login_required +from musicround.models import Round, Song, db +from pydub import AudioSegment +from reportlab.lib.pagesizes import A4 +from reportlab.pdfgen import canvas + +rounds_bp = Blueprint('rounds', __name__, url_prefix='/rounds') + +@rounds_bp.route('/') +@login_required +def rounds_list(): + """Display a list of all rounds""" + rounds = Round.query.all() + return render_template('rounds.html', rounds=rounds) + +@rounds_bp.route('/') +@login_required +def round_detail(round_id): + """Display details of a specific round""" + rnd = Round.query.get(round_id) + sp = current_app.config['sp'] + + if rnd: + song_ids = rnd.songs.split(',') + songs = Song.query.filter(Song.id.in_(song_ids)).all() + + # Ensure songs are in the same order as in the round's song list + song_id_to_obj = {str(song.id): song for song in songs} + ordered_songs = [song_id_to_obj.get(song_id) for song_id in song_ids if song_id in song_id_to_obj] + + email_error = session.pop('email_error', None) # Retrieve and remove the error message from the session + + # For sp.current_user(), we need to ensure we have a valid token if needed for this view + user_info = None + try: + if 'access_token' in session: # Only try to get user info if we have a token + user_info = sp.current_user() + except: + # If we can't get user info, continue without it + current_app.logger.warning("Could not get Spotify user info") + + return render_template('round_detail.html', round=rnd, songs=ordered_songs, user_info=user_info, email_error=email_error) + else: + return 'Round not found' + +@rounds_bp.route('//update-name', methods=['POST']) +@login_required +def update_round_name(round_id): + """Update the name of a round""" + rnd = Round.query.get_or_404(round_id) + round_name = request.form.get('round_name', '').strip() + + # Update the round name + rnd.name = round_name if round_name else None + db.session.commit() + + flash('Round name updated successfully', 'success') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + +@rounds_bp.route('//update-songs', methods=['POST']) +@login_required +def update_round_songs(round_id): + """Update the songs in a round (order, additions, removals)""" + rnd = Round.query.get_or_404(round_id) + song_order = request.form.get('song_order', '') + + if song_order: + # Only reset the flags if the song order has actually changed + if rnd.songs != song_order: + rnd.songs = song_order + # Reset the MP3 and PDF generated flags when the song order changes + rnd.reset_generated_status() + db.session.commit() + flash('Round songs updated successfully', 'success') + else: + flash('No changes to save', 'info') + else: + flash('No song order provided', 'error') + + return redirect(url_for('rounds.round_detail', round_id=round_id)) + +@rounds_bp.route('/round//mp3', methods=['POST']) +@login_required +def round_mp3(round_id): + """Generates an MP3 file for a given round with intro, outro, and number announcements.""" + from musicround.helpers.utils import get_mp3_path + + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + # For AJAX requests, keep the response consistent + if not current_user.is_authenticated: + return jsonify({'success': False, 'error': 'Authentication required'}), 401 + + round = Round.query.get_or_404(round_id) + song_ids = [int(song_id) for song_id in round.songs.split(',')] + + # Create a dict mapping song_id to Song object for all songs in the round + songs_dict = {song.id: song for song in Song.query.filter(Song.id.in_(song_ids)).all()} + + # Preserve the exact ordering from the round.songs field + songs = [songs_dict.get(song_id) for song_id in song_ids if songs_dict.get(song_id)] + + # Create a directory for rounds in /data if it doesn't exist + rounds_dir = '/data/rounds' + if not os.path.exists(rounds_dir): + os.makedirs(rounds_dir) + + # Define the path for the MP3 file + mp3_file_path = os.path.join(rounds_dir, f'round_{round_id}.mp3') + current_app.logger.info(f"Checking MP3 generation status for round {round_id}") + + # Check if the MP3 has already been generated and if the file exists + # We'll generate a new file if either the flag is False or the file doesn't exist + if round.mp3_generated and os.path.exists(mp3_file_path): + current_app.logger.info(f"MP3 file already exists and is up to date at: {mp3_file_path}") + download_url = url_for('rounds.download_mp3', round_id=round_id) + + # Check if this is an AJAX request + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({ + 'success': True, + 'message': 'MP3 file already exists', + 'download_url': download_url + }) + else: + # Traditional form submission, send file + return send_file(mp3_file_path, as_attachment=True) + + # Load intro, outro, and replay audio segments - using user's custom ones if available + try: + # Use get_mp3_path helper to get the appropriate path for each MP3 type + intro_path = get_mp3_path(current_user, 'intro') + outro_path = get_mp3_path(current_user, 'outro') + replay_path = get_mp3_path(current_user, 'replay') + + intro = AudioSegment.from_mp3(intro_path) + outro = AudioSegment.from_mp3(outro_path) + replay = AudioSegment.from_mp3(replay_path) + + current_app.logger.info(f"Using MP3 files - Intro: {intro_path}, Outro: {outro_path}, Replay: {replay_path}") + except Exception as e: + error_msg = f"Error loading intro/outro/replay audio: {e}" + current_app.logger.error(error_msg) + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': False, 'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + # Create an empty audio segment + combined_audio = AudioSegment.empty() + combined_audio += intro + + # Create temporary directory for number announcements and song previews + with tempfile.TemporaryDirectory() as temp_dir: + # Store song audio segments for later replay + song_segments = [] + number_segments = [] + + # First pass - append each song's preview with number announcements + for i, song in enumerate(songs): + number_audio_path = os.path.join(current_app.root_path, 'static', 'audio', f'{i+1}.mp3') + try: + number_audio = AudioSegment.from_mp3(number_audio_path) + number_segments.append(number_audio) + except Exception as e: + error_msg = f"Error loading number audio {i+1}: {e}" + current_app.logger.error(error_msg) + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': False, 'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + if song.deezer_id: + try: + # Fetch fresh preview URL from Deezer API + deezer_client = current_app.config['deezer'] + track = deezer_client.get_track(song.deezer_id) + current_app.logger.info(f"Deezer track info: {track}") # Log the track info + preview_url = track.get('preview') + if not preview_url: + current_app.logger.warning(f"No preview available for {song.title} (Deezer ID: {song.deezer_id})") + song_segments.append(None) + continue + + # Download the song preview to a temporary file + response = requests.get(preview_url, stream=True) + response.raise_for_status() # Raise an exception for bad status codes + + temp_song_path = os.path.join(temp_dir, f'song_{song.id}.mp3') + with open(temp_song_path, 'wb') as temp_song_file: + for chunk in response.iter_content(chunk_size=8192): + temp_song_file.write(chunk) + + song_audio = AudioSegment.from_mp3(temp_song_path) + song_segments.append(song_audio) + + # Add to the combined audio for first playthrough + combined_audio += number_audio + combined_audio += song_audio + except requests.exceptions.RequestException as e: + error_msg = f"Error downloading {song.title} (Deezer ID: {song.deezer_id}): {e}" + current_app.logger.error(error_msg) + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': False, 'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + except Exception as e: + error_msg = f"Error processing {song.title} (Deezer ID: {song.deezer_id}): {e}" + current_app.logger.error(error_msg) + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': False, 'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + else: + current_app.logger.warning(f"No Deezer ID available for {song.title}") + song_segments.append(None) + + # Add the replay announcement + combined_audio += replay + + # Second pass - replay all songs + for i, (song_audio, number_audio) in enumerate(zip(song_segments, number_segments)): + if song_audio is not None: + combined_audio += number_audio + combined_audio += song_audio + + combined_audio += outro + + # Export the combined audio to an MP3 file + try: + combined_audio.export(mp3_file_path, format="mp3") + current_app.logger.info(f"MP3 file successfully generated at: {mp3_file_path}") + + # Update the round object to indicate MP3 has been generated and update timestamp + round.mp3_generated = True + round.last_generated_at = datetime.utcnow() + db.session.commit() + + # Check if this is an AJAX request + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + download_url = url_for('rounds.download_mp3', round_id=round_id) + return jsonify({ + 'success': True, + 'message': 'MP3 file successfully generated', + 'download_url': download_url + }) + else: + # Traditional form submission, send file + flash('MP3 generated successfully', 'success') + return send_file(mp3_file_path, as_attachment=True) + + except Exception as e: + error_msg = f"Error generating MP3 file: {e}" + current_app.logger.error(error_msg) + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': False, 'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + +@rounds_bp.route('/download/mp3/round_', methods=['GET']) +@login_required +def download_mp3(round_id): + """Download an MP3 file for a round""" + mp3_file_path = os.path.join('/data/rounds', f'round_{round_id}.mp3') + + if not os.path.exists(mp3_file_path): + flash('MP3 file not found. Please generate the MP3 first.', 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + return send_file(mp3_file_path, as_attachment=True) + +@rounds_bp.route('/download/pdf/round_', methods=['GET']) +@login_required +def download_pdf(round_id): + """Download a PDF file for a round""" + pdf_file_path = os.path.join('/data/pdfs', f'round_{round_id}.pdf') + + if not os.path.exists(pdf_file_path): + flash('PDF file not found. Please generate the PDF first.', 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + return send_file(pdf_file_path, as_attachment=True) + +def generate_pdf(round_id): + """ + Creates a stylish PDF "round_{id}.pdf" that lists the songs in that round. + Returns raw PDF data as bytes, for sending or saving. + """ + rnd = Round.query.get(round_id) + if not rnd: + return 'Round not found' + + file_name = f'round_{round_id}.pdf' + dir_path = '/data/pdfs' # Use /data/pdfs for storing PDFs + if not os.path.exists(dir_path): + os.makedirs(dir_path) + file_path = os.path.join(dir_path, file_name) + + # If it exists and the flag indicates it's up-to-date, read from disk + if os.path.exists(file_path) and rnd.pdf_generated: + with open(file_path, 'rb') as file: + return file.read() + + # Get songs data in the correct order + song_ids = [int(sid) for sid in rnd.songs.split(',')] + + # Create a dict mapping song_id to Song object for all songs in the round + songs_dict = {song.id: song for song in Song.query.filter(Song.id.in_(song_ids)).all()} + + # Preserve the exact ordering from the round.songs field + songs = [songs_dict.get(song_id) for song_id in song_ids if songs_dict.get(song_id)] + + # Import reportlab components + from reportlab.lib import colors + from reportlab.lib.pagesizes import A4 + from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, Table, TableStyle + from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle + from reportlab.lib.units import inch, cm + + # Create a buffer + buffer = BytesIO() + + # Set up the PDF document + doc = SimpleDocTemplate( + buffer, + pagesize=A4, + leftMargin=1.5*cm, + rightMargin=1.5*cm, + topMargin=1.5*cm, + bottomMargin=1.5*cm + ) + + # Styles + styles = getSampleStyleSheet() + + # Create custom styles + title_style = ParagraphStyle( + 'Title', + parent=styles['Heading1'], + fontSize=24, + textColor=colors.HexColor('#00ACC1'), # Teal color for titles + spaceAfter=24, + alignment=1 # Center alignment + ) + + subtitle_style = ParagraphStyle( + 'Subtitle', + parent=styles['Heading2'], + fontSize=16, + textColor=colors.HexColor('#333333'), + spaceBefore=12, + spaceAfter=12 + ) + + info_style = ParagraphStyle( + 'Info', + parent=styles['Normal'], + fontSize=12, + textColor=colors.HexColor('#666666'), + spaceBefore=6, + spaceAfter=12 + ) + + song_style = ParagraphStyle( + 'Song', + parent=styles['Normal'], + fontSize=14, + spaceBefore=4, + spaceAfter=4 + ) + + # Story (container for PDF elements) + story = [] + + # Add logo + logo_path = os.path.join(current_app.root_path, 'static', 'img', 'light', 'logotype.png') + if os.path.exists(logo_path): + img = Image(logo_path) + img.drawHeight = 1.2*cm + img._restrictSize(5*cm, 5*cm) + img.hAlign = 'CENTER' + story.append(img) + story.append(Spacer(1, 0.5*cm)) + + # Add title + title = "Music Quiz Round" + if rnd.name: + title = rnd.name + + story.append(Paragraph(title, title_style)) + + # Add subtitle with round type + round_type_text = f"Round Type: {rnd.round_type}" + if rnd.round_criteria_used: + round_type_text += f" - {rnd.round_criteria_used}" + + story.append(Paragraph(round_type_text, subtitle_style)) + + # Add date info + current_date = datetime.now().strftime("%B %d, %Y") + story.append(Paragraph(f"Generated on {current_date}", info_style)) + + # Add divider + story.append(Spacer(1, 0.75*cm)) + + # Create song table data + data = [["#", "Artist", "Title", "Year", "Genre"]] + + for i, song in enumerate(songs): + if song: + data.append([ + f"{i+1}", + f"{song.artist}", # Artist in separate column + f"{song.title}", # Title in separate column + f"{song.year or ''}", + f"{song.genre or ''}" + ]) + + # Create and style the table + table = Table(data, colWidths=[0.7*cm, 6*cm, 6*cm, 2*cm, 2.5*cm]) + table.setStyle(TableStyle([ + ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#00ACC1')), + ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), + ('ALIGN', (0, 0), (-1, 0), 'CENTER'), + ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'), + ('FONTSIZE', (0, 0), (-1, 0), 12), + ('BOTTOMPADDING', (0, 0), (-1, 0), 12), + ('TOPPADDING', (0, 0), (-1, 0), 12), + ('BACKGROUND', (0, 1), (-1, -1), colors.white), + ('GRID', (0, 0), (-1, -1), 1, colors.lightgrey), + ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), + ('ALIGN', (0, 0), (0, -1), 'CENTER'), # Center the song numbers + ('ALIGN', (3, 1), (3, -1), 'CENTER'), # Center the years + ('FONTNAME', (0, 1), (0, -1), 'Helvetica-Bold'), # Make numbers bold + ('FONTNAME', (1, 1), (1, -1), 'Helvetica-Bold'), # Make artist names bold + # Zebra striping for rows + ('BACKGROUND', (0, 1), (-1, -1), colors.white), + ])) + + # Add alternating row colors + for i in range(1, len(data)): + if i % 2 == 0: + table.setStyle(TableStyle([ + ('BACKGROUND', (0, i), (-1, i), colors.HexColor('#F9FAFB')) + ])) + + story.append(table) + + # Add spacer + story.append(Spacer(1, 0.75*cm)) + + # Add footer + footer_text = "Quizzical Beats - Music Quiz Generator" + story.append(Paragraph(footer_text, info_style)) + + # Build PDF + doc.build(story) + + # Get the value from the buffer + buffer.seek(0) + + # Save to file + with open(file_path, 'wb') as file: + file.write(buffer.getvalue()) + + return buffer.getvalue() + +@rounds_bp.route('//pdf', methods=['POST']) +@login_required +def round_pdf(round_id): + """Generate a PDF file for a round""" + rnd = db.session.get(Round, round_id) + if not rnd: + return jsonify({'success': False, 'error': 'Round not found'}) + + # Define path for the PDF file + pdfs_dir = '/data/pdfs' + if not os.path.exists(pdfs_dir): + os.makedirs(pdfs_dir) + pdf_file_path = os.path.join(pdfs_dir, f'round_{rnd.id}.pdf') + + # Check if the PDF has already been generated and if the file exists + # We'll generate a new file if either the flag is False or the file doesn't exist + if rnd.pdf_generated and os.path.exists(pdf_file_path): + current_app.logger.info(f"PDF file already exists and is up to date at: {pdf_file_path}") + download_url = url_for('rounds.download_pdf', round_id=round_id) + + # Check if this is an AJAX request + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({ + 'success': True, + 'message': 'PDF file already exists', + 'download_url': download_url + }) + else: + # Traditional form submission, send file + return send_file(pdf_file_path, as_attachment=True) + + try: + pdf_data = generate_pdf(round_id) + if isinstance(pdf_data, str) and pdf_data.startswith('Round not found'): + return jsonify({'success': False, 'error': pdf_data}) + + with open(pdf_file_path, 'wb') as f: + f.write(pdf_data) + + # Update the round object to indicate PDF has been generated and update timestamp + rnd.pdf_generated = True + rnd.last_generated_at = datetime.utcnow() + db.session.commit() + + # Check if this is an AJAX request + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + download_url = url_for('rounds.download_pdf', round_id=round_id) + return jsonify({ + 'success': True, + 'message': 'PDF file successfully generated', + 'download_url': download_url + }) + else: + # Traditional form submission, send the file + return send_file(pdf_file_path, as_attachment=True) + + except Exception as e: + error_msg = f"Error generating PDF file: {e}" + current_app.logger.error(error_msg) + return jsonify({'success': False, 'error': error_msg}) + +@rounds_bp.route('//mail', methods=['POST']) +@login_required +def send_email(round_id): + """ + Generate PDF + MP3, attach them to an email, and send via Postmark. + """ + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + # For AJAX requests, keep the response consistent + if not current_user.is_authenticated: + return jsonify({'error': 'Authentication required'}), 401 + + # Check if the round exists + rnd = Round.query.get_or_404(round_id) + + # Generate PDF + pdf_data = generate_pdf(round_id) + if isinstance(pdf_data, str) and pdf_data.startswith('Round not found'): + error_msg = 'Round not found' + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.rounds_list')) + + # Define the path for the MP3 file + mp3_file_path = os.path.join('/data/rounds', f'round_{round_id}.mp3') + + # Check if MP3 exists, if not generate it + if not os.path.exists(mp3_file_path): + # Call the round_mp3 function but don't return its result yet + # This will generate the MP3 file at mp3_file_path + response = round_mp3(round_id) + + if isinstance(response, str) and response.startswith('Error'): + error_msg = response + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'error': error_msg}) + else: + flash(error_msg, 'error') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + # Get mail configuration from environment variables + mail_host = current_app.config.get('MAIL_HOST') + mail_port = current_app.config.get('MAIL_PORT') + mail_username = current_app.config.get('MAIL_USERNAME') + mail_password = current_app.config.get('MAIL_PASSWORD') + mail_sender = current_app.config.get('MAIL_SENDER') + + # Use the current user's email address as the recipient + mail_recipient = current_user.email + + if not mail_recipient: + error_msg = "You don't have an email address in your profile. Please update your profile with an email address." + current_app.logger.error(error_msg) + + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'error': error_msg}) + else: + session['email_error'] = error_msg + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + # Check if all email configuration parameters are available + missing_config = [] + if not mail_host: + missing_config.append("MAIL_HOST") + if not mail_port: + missing_config.append("MAIL_PORT") + if not mail_username: + missing_config.append("MAIL_USERNAME") + if not mail_password: + missing_config.append("MAIL_PASSWORD") + if not mail_sender: + missing_config.append("MAIL_SENDER") + + if missing_config: + missing_params = ", ".join(missing_config) + error_msg = f"Email server configuration is incomplete. Missing parameters: {missing_params}. Please check your .env file." + current_app.logger.error(f"Email configuration error: {error_msg}") + current_app.logger.error(f"Current config values - MAIL_HOST: {'set' if mail_host else 'missing'}, " + f"MAIL_PORT: {'set' if mail_port else 'missing'}, " + f"MAIL_USERNAME: {'set' if mail_username else 'missing'}, " + f"MAIL_PASSWORD: {'set' if mail_password else 'missing'}, " + f"MAIL_SENDER: {'set' if mail_sender else 'missing'}") + + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'error': error_msg}) + else: + session['email_error'] = error_msg # Store the error message in the session + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + msg = MIMEMultipart() + msg['From'] = mail_sender + msg['To'] = mail_recipient + + # Get the round name for the subject + round_title = f'Pub Quiz Round #{round_id}' + if rnd and rnd.name: + round_title = rnd.name + + msg['Subject'] = round_title + msg.attach(MIMEText('Attached please find the MP3 and PDF files for the quiz round.', 'plain')) + + # Attach PDF + pdf_attachment = MIMEBase('application', 'pdf') + pdf_attachment.set_payload(pdf_data) + encoders.encode_base64(pdf_attachment) + pdf_attachment.add_header('Content-Disposition', f'attachment; filename=round_{round_id}.pdf') + msg.attach(pdf_attachment) + + # Attach MP3 + with open(mp3_file_path, 'rb') as mp3_file: + mp3_data = mp3_file.read() + mp3_attachment = MIMEBase('audio', 'mpeg') + mp3_attachment.set_payload(mp3_data) + encoders.encode_base64(mp3_attachment) + mp3_attachment.add_header('Content-Disposition', f'attachment; filename=round_{round_id}.mp3') + msg.attach(mp3_attachment) + + try: + current_app.logger.info(f"Attempting to send email to {mail_recipient} via {mail_host}:{mail_port}") + with smtplib.SMTP(mail_host, mail_port) as server: + server.starttls() + current_app.logger.debug("STARTTLS established") + server.login(mail_username, mail_password) + current_app.logger.debug(f"Login successful for {mail_username}") + server.sendmail(mail_sender, mail_recipient, msg.as_string()) + current_app.logger.info(f"Email sent successfully from {mail_sender} to {mail_recipient}") + + success_msg = f'Email sent successfully to {mail_recipient}!' + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'success': True, 'message': success_msg}) + else: + flash(success_msg, 'success') + return redirect(url_for('rounds.round_detail', round_id=round_id)) + + except smtplib.SMTPException as e: + error_msg = str(e) + current_app.logger.error(f"SMTP Error: {error_msg}") + current_app.logger.error(f"Failed to send email from {mail_sender} to {mail_recipient} via {mail_host}:{mail_port}") + + if request.headers.get('X-Requested-With') == 'XMLHttpRequest': + return jsonify({'error': error_msg}) + else: + session['email_error'] = error_msg + return redirect(url_for('rounds.round_detail', round_id=round_id)) + +@rounds_bp.route('//delete', methods=['POST']) +@login_required +def delete_round(round_id): + """Delete a round and its associated files""" + rnd = Round.query.get_or_404(round_id) + + try: + # Delete associated MP3 file if it exists + mp3_file_path = os.path.join('/data/rounds', f'round_{round_id}.mp3') + if os.path.exists(mp3_file_path): + os.remove(mp3_file_path) + + # Delete associated PDF file if it exists + pdf_file_path = os.path.join('/data/pdfs', f'round_{round_id}.pdf') + if os.path.exists(pdf_file_path): + os.remove(pdf_file_path) + + # Delete the round from the database + db.session.delete(rnd) + db.session.commit() + + flash('Round deleted successfully', 'success') + return jsonify({'success': True}) + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error deleting round: {e}") + flash(f"Error deleting round: {e}", 'error') + return jsonify({'success': False, 'error': str(e)}), 500 + +@rounds_bp.route('//export-to-dropbox', methods=['POST']) +@login_required +def export_to_dropbox(round_id): + """ + Export a round to the user's Dropbox account, including metadata and optionally MP3 files + """ + current_app.logger.info(f"Starting Dropbox export for round ID {round_id} by user {current_user.username}") + round_obj = Round.query.get_or_404(round_id) + + # Properly parse boolean parameters from form data + include_mp3s = request.form.get('include_mp3s', 'true').lower() == 'true' + include_pdf = request.form.get('include_pdf', 'true').lower() == 'true' + custom_folder = request.form.get('custom_folder', '') + + current_app.logger.debug(f"Export options - Include MP3: {include_mp3s}, Include PDF: {include_pdf}, Custom folder: '{custom_folder}'") + + # Default response format + response_data = { + 'success': False, + 'message': 'Unknown error occurred', + 'shared_links': { + 'mp3': None, + 'pdf': None, + 'text': None # For metadata JSON + } + } + + # Validate user has Dropbox connected + if not current_user.dropbox_token or not current_user.dropbox_refresh_token: + current_app.logger.error(f"User {current_user.username} attempted Dropbox export without connected account") + response_data['message'] = 'You need to connect your Dropbox account first' + flash('Please connect your Dropbox account in your profile settings first.', 'error') + return jsonify(response_data) + + current_app.logger.debug(f"Dropbox token exists: {bool(current_user.dropbox_token)}, token expiry: {current_user.dropbox_token_expiry}") + + # Refresh token if needed + from musicround.helpers.dropbox_helper import refresh_dropbox_token_if_needed + token_refresh = refresh_dropbox_token_if_needed(current_user) + current_app.logger.info(f"Token refresh result: {token_refresh}") + + if not token_refresh['success']: + current_app.logger.error(f"Failed to refresh Dropbox token: {token_refresh['message']}") + response_data['message'] = f"Error with Dropbox authentication: {token_refresh['message']}" + flash('There was an error with your Dropbox connection. Please reconnect in your profile.', 'error') + return jsonify(response_data) + + # Initialize the round export record + from musicround.models import RoundExport, db + round_export = RoundExport( + round_id=round_id, + user_id=current_user.id, + export_type='dropbox', + include_mp3s=include_mp3s, + status='in_progress', + destination=current_user.dropbox_export_path + ) + db.session.add(round_export) + db.session.commit() + current_app.logger.debug(f"Created export record with ID: {round_export.id}") + + try: + # Determine base export path + base_folder = current_user.dropbox_export_path or '/QuizzicalBeats' + if custom_folder: + base_folder = os.path.join(base_folder, custom_folder.strip('/')) + + current_app.logger.debug(f"Using base folder: {base_folder}") + + # Create a folder for this round + round_folder_name = f"Round_{round_id}" + if round_obj.name: + # Sanitize round name for folder name (remove invalid characters) + safe_name = re.sub(r'[<>:"/\\|?*]', '', round_obj.name) + round_folder_name = f"Round_{round_id}_{safe_name}" + + round_folder = os.path.join(base_folder, round_folder_name) + metadata_folder = os.path.join(round_folder, "Metadata") + + current_app.logger.debug(f"Round folder path: {round_folder}") + current_app.logger.debug(f"Metadata folder path: {metadata_folder}") + + # Access token for Dropbox API calls + access_token = current_user.dropbox_token + current_app.logger.debug(f"Access token (first 10 chars): {access_token[:10] if access_token else 'None'}") + + # Prepare song list - check if the helper method works + try: + songs = round_obj.song_list + current_app.logger.debug(f"Successfully retrieved {len(songs)} songs") + except Exception as song_err: + current_app.logger.error(f"Error getting song list: {str(song_err)}") + # Fallback method to get songs + song_ids = [int(sid) for sid in round_obj.songs.split(',')] + songs = Song.query.filter(Song.id.in_(song_ids)).all() + current_app.logger.debug(f"Fallback method retrieved {len(songs)} songs") + + # 1. Export song metadata as JSON + song_data = [] + for song in songs: + try: + song_dict = song.to_dict() + song_data.append(song_dict) + except Exception as e: + current_app.logger.error(f"Error converting song {song.id} to dict: {str(e)}") + # Manual conversion fallback + song_data.append({ + 'id': song.id, + 'title': song.title, + 'artist': song.artist, + 'year': song.year, + 'deezer_id': song.deezer_id, + 'spotify_id': song.spotify_id, + }) + + metadata_json = json.dumps({ + 'round_id': round_obj.id, + 'round_name': round_obj.name, + 'round_type': round_obj.round_type, + 'round_criteria': round_obj.round_criteria_used, + 'created_at': round_obj.created_at.isoformat() if round_obj.created_at else None, + 'songs': song_data + }, indent=2) + + current_app.logger.debug(f"Created metadata JSON ({len(metadata_json)} bytes)") + + # Upload metadata JSON + from musicround.helpers.dropbox_helper import upload_to_dropbox, create_shared_link + + json_path = f"{metadata_folder}/round_{round_id}_metadata.json" + current_app.logger.info(f"Uploading JSON metadata to {json_path}") + + json_upload = upload_to_dropbox( + access_token, + json_path, + metadata_json, + mode='text' + ) + + current_app.logger.debug(f"JSON upload result: {json_upload}") + + if not json_upload['success']: + current_app.logger.error(f"Error uploading JSON metadata: {json_upload}") + raise Exception(f"Error uploading JSON metadata: {json_upload['message']}") + + # Create shared link for JSON + current_app.logger.info(f"Creating shared link for JSON at {json_path}") + json_link = create_shared_link(access_token, json_path) + current_app.logger.debug(f"JSON shared link result: {json_link}") + + if json_link['success']: + response_data['shared_links']['text'] = json_link['url'] + + # 2. Export PDF if requested + if include_pdf: + current_app.logger.info(f"PDF export requested for round {round_id}") + + # Generate PDF if not already generated + if not round_obj.pdf_generated: + current_app.logger.debug("PDF not generated yet, generating now") + pdf_data = generate_pdf(round_id) + if isinstance(pdf_data, str) and pdf_data.startswith('Round not found'): + current_app.logger.error(f"Error generating PDF: {pdf_data}") + raise Exception(f"Error generating PDF: {pdf_data}") + else: + # PDF already exists, read it + pdf_file_path = os.path.join('/data/pdfs', f'round_{round_id}.pdf') + current_app.logger.debug(f"Reading existing PDF from {pdf_file_path}") + + if not os.path.exists(pdf_file_path): + current_app.logger.error(f"PDF file doesn't exist at {pdf_file_path} despite pdf_generated=True") + # Generate it anyway + pdf_data = generate_pdf(round_id) + else: + with open(pdf_file_path, 'rb') as f: + pdf_data = f.read() + current_app.logger.debug(f"Read {len(pdf_data)} bytes from PDF file") + + # Upload PDF + pdf_path = f"{round_folder}/round_{round_id}.pdf" + current_app.logger.info(f"Uploading PDF to {pdf_path}") + + pdf_upload = upload_to_dropbox( + access_token, + pdf_path, + pdf_data + ) + + current_app.logger.debug(f"PDF upload result: {pdf_upload}") + + if not pdf_upload['success']: + current_app.logger.error(f"Error uploading PDF: {pdf_upload}") + raise Exception(f"Error uploading PDF: {pdf_upload['message']}") + + # Create shared link for PDF + current_app.logger.info(f"Creating shared link for PDF at {pdf_path}") + pdf_link = create_shared_link(access_token, pdf_path) + current_app.logger.debug(f"PDF shared link result: {pdf_link}") + + if pdf_link['success']: + response_data['shared_links']['pdf'] = pdf_link['url'] + + # 3. Export MP3 if requested + if include_mp3s: + current_app.logger.info(f"MP3 export requested for round {round_id}") + + # Check if MP3 exists, generate if not + mp3_file_path = os.path.join('/data/rounds', f'round_{round_id}.mp3') + current_app.logger.debug(f"Checking for MP3 at {mp3_file_path}") + current_app.logger.debug(f"MP3 generated flag: {round_obj.mp3_generated}") + + if not round_obj.mp3_generated or not os.path.exists(mp3_file_path): + current_app.logger.warning(f"MP3 needs to be generated first. Generated flag: {round_obj.mp3_generated}, File exists: {os.path.exists(mp3_file_path)}") + # Need to redirect to MP3 generation first + response_data['success'] = False + response_data['message'] = 'MP3 needs to be generated first' + response_data['redirect'] = url_for('rounds.round_mp3', round_id=round_id) + + # Update export record + round_export.status = 'pending_mp3' + round_export.error_message = 'MP3 needs to be generated first' + db.session.commit() + + return jsonify(response_data) + + # MP3 exists, upload it + current_app.logger.debug(f"Reading MP3 file from {mp3_file_path}") + with open(mp3_file_path, 'rb') as f: + mp3_data = f.read() + + current_app.logger.debug(f"Read {len(mp3_data)} bytes from MP3 file") + + mp3_path = f"{round_folder}/round_{round_id}.mp3" + current_app.logger.info(f"Uploading MP3 to {mp3_path}") + + mp3_upload = upload_to_dropbox( + access_token, + mp3_path, + mp3_data + ) + + current_app.logger.debug(f"MP3 upload result: {mp3_upload}") + + if not mp3_upload['success']: + current_app.logger.error(f"Error uploading MP3: {mp3_upload}") + raise Exception(f"Error uploading MP3: {mp3_upload['message']}") + + # Create shared link for MP3 + current_app.logger.info(f"Creating shared link for MP3 at {mp3_path}") + mp3_link = create_shared_link(access_token, mp3_path) + current_app.logger.debug(f"MP3 shared link result: {mp3_link}") + + if mp3_link['success']: + response_data['shared_links']['mp3'] = mp3_link['url'] + + # Update export record as success + round_export.status = 'success' + db.session.commit() + current_app.logger.info(f"Export to Dropbox completed successfully for round {round_id}") + + # Success response + response_data['success'] = True + response_data['message'] = 'Round exported to Dropbox successfully' + + return jsonify(response_data) + + except Exception as e: + current_app.logger.error(f"Error exporting round {round_id} to Dropbox: {str(e)}", exc_info=True) + + # Update export record with error + round_export.status = 'failed' + round_export.error_message = str(e) + db.session.commit() + + # Error response + response_data['success'] = False + response_data['message'] = f"Error exporting to Dropbox: {str(e)}" + + return jsonify(response_data) + +def generate_round_text(round_obj): + """Generate a text representation of a round""" + lines = [ + f"ROUND: {round_obj.title}", + f"Created: {round_obj.created_at.strftime('%Y-%m-%d')}", + f"Creator: {round_obj.user.username if round_obj.user else 'Unknown'}", + "", + f"Description: {round_obj.description or 'No description'}", + "", + "SONGS:", + "" + ] + + for idx, song in enumerate(round_obj.songs, 1): + lines.append(f"{idx}. {song.title} - {song.artist}") + if song.year: + lines.append(f" Year: {song.year}") + if song.album: + lines.append(f" Album: {song.album}") + lines.append("") + + return "\n".join(lines) + +def generate_round_pdf(round_obj): + """Generate a PDF representation of a round""" + try: + from reportlab.lib.pagesizes import A4 + from reportlab.lib import colors + from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle + from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle + from io import BytesIO + + buffer = BytesIO() + doc = SimpleDocTemplate(buffer, pagesize=A4) + styles = getSampleStyleSheet() + + # Create custom styles + styles.add(ParagraphStyle( + name='Title', + parent=styles['Heading1'], + fontSize=16, + spaceAfter=12 + )) + + styles.add(ParagraphStyle( + name='SongTitle', + parent=styles['Normal'], + fontSize=12, + fontName='Helvetica-Bold' + )) + + # Build the document content + content = [] + + # Round title + content.append(Paragraph(f"Round: {round_obj.title}", styles['Title'])) + content.append(Spacer(1, 12)) + + # Round info + content.append(Paragraph(f"Created: {round_obj.created_at.strftime('%Y-%m-%d')}", styles['Normal'])) + content.append(Paragraph(f"Creator: {round_obj.user.username if round_obj.user else 'Unknown'}", styles['Normal'])) + content.append(Spacer(1, 12)) + + # Description + if round_obj.description: + content.append(Paragraph("Description:", styles['Heading3'])) + content.append(Paragraph(round_obj.description, styles['Normal'])) + content.append(Spacer(1, 12)) + + # Songs + content.append(Paragraph("Songs:", styles['Heading3'])) + content.append(Spacer(1, 6)) + + for idx, song in enumerate(round_obj.songs, 1): + content.append(Paragraph(f"{idx}. {song.title} - {song.artist}", styles['SongTitle'])) + + # Song details + details = [] + if song.year: + details.append(f"Year: {song.year}") + if song.album: + details.append(f"Album: {song.album}") + + if details: + content.append(Paragraph(", ".join(details), styles['Normal'])) + + content.append(Spacer(1, 6)) + + # Build and return the PDF + doc.build(content) + pdf_data = buffer.getvalue() + buffer.close() + return pdf_data + + except ImportError: + current_app.logger.warning("ReportLab not installed, skipping PDF export") + return None + except Exception as e: + current_app.logger.error(f"Error generating PDF: {str(e)}") + return None + +def safe_filename(filename): + """Convert a string to a safe filename""" + # Replace problematic characters + safe_name = re.sub(r'[^\w\s-]', '', filename).strip().replace(' ', '_') + return safe_name \ No newline at end of file diff --git a/musicround/routes/users.py b/musicround/routes/users.py new file mode 100644 index 0000000..3a48aa5 --- /dev/null +++ b/musicround/routes/users.py @@ -0,0 +1,1743 @@ +""" +User authentication and profile management routes +""" +import os +import time +import uuid +from datetime import datetime, timedelta +from flask import Blueprint, render_template, redirect, url_for, flash, request, current_app, session, jsonify +from flask_login import login_user, current_user, logout_user, login_required +from werkzeug.security import generate_password_hash, check_password_hash +from sqlalchemy.exc import IntegrityError +from spotipy.oauth2 import SpotifyOAuth +from spotipy.exceptions import SpotifyException + +from musicround.models import db, User, Role, SystemSetting +from musicround.helpers.utils import get_available_voices +from musicround.helpers.auth_helpers import oauth, find_or_create_user, update_oauth_tokens, get_google_user_info, get_authentik_user_info + +users_bp = Blueprint('users', __name__, url_prefix='/users') + +def admin_required(f): + from functools import wraps + @wraps(f) + def decorated_function(*args, **kwargs): + if not current_user.is_authenticated or not current_user.is_admin(): + flash('Admin access required.', 'danger') + return redirect(url_for('users.profile')) + return f(*args, **kwargs) + return decorated_function + +# OAuth login routes for Google +@users_bp.route('/login/google') +def google_login(): + """Initiate Google OAuth login flow""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Google login is disabled if client ID is not set + if not current_app.config.get('GOOGLE_CLIENT_ID'): + flash('Google login is not configured.', 'danger') + return redirect(url_for('users.login')) + + redirect_uri = url_for('users.google_callback', _external=True) + return oauth.google.authorize_redirect(redirect_uri) + +@users_bp.route('/login/google/callback') +def google_callback(): + """Handle Google OAuth callback""" + try: + token = oauth.google.authorize_access_token() + user_info = oauth.google.userinfo() + + # Debug the response + current_app.logger.debug(f"Google user info response: {user_info}") + + # Check for required fields and adapt to Google's response format + if 'sub' in user_info and 'id' not in user_info: + user_info['id'] = user_info['sub'] # Google uses 'sub' for the user ID + + # Find or create user + user = find_or_create_user(user_info, 'google') + if not user: + flash('Could not authenticate with Google. Please try again.', 'danger') + return redirect(url_for('users.login')) + + # Update tokens and log in the user + update_oauth_tokens(user, token, 'google') + login_user(user) + + # Set last_login as a datetime object for consistency + user.last_login = datetime.now() + db.session.commit() + + # Redirect to next page or home + next_page = request.args.get('next') + if not next_page or not next_page.startswith('/'): + next_page = url_for('core.index') + + flash('You have been logged in via Google!', 'success') + return redirect(next_page) + + except Exception as e: + current_app.logger.error(f"Error in Google callback: {str(e)}") + flash('An error occurred during Google authentication. Please try again.', 'danger') + return redirect(url_for('users.login')) + +# OAuth login routes for Authentik +@users_bp.route('/login/authentik') +def authentik_login(): + """Initiate Authentik OAuth login flow""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Authentik login is disabled if client ID is not set + if not current_app.config.get('AUTHENTIK_CLIENT_ID'): + flash('Authentik login is not configured.', 'danger') + return redirect(url_for('users.login')) + + redirect_uri = url_for('users.authentik_callback', _external=True) + return oauth.authentik.authorize_redirect(redirect_uri) + +@users_bp.route('/login/authentik/callback') +def authentik_callback(): + """Handle Authentik OAuth callback""" + try: + token = oauth.authentik.authorize_access_token() + user_info = token.get('userinfo') + + # Debug the response + current_app.logger.debug(f"Authentik user info response: {user_info}") + + if not user_info: + # If userinfo not in token, fetch it separately + user_info = get_authentik_user_info(token) + + # Check for required fields and adapt to Authentik's response format + if user_info and 'sub' in user_info and 'id' not in user_info: + user_info['id'] = user_info['sub'] # Authentik uses 'sub' for the user ID + + # Find or create user + user = find_or_create_user(user_info, 'authentik') + if not user: + flash('Could not authenticate with Authentik. Please try again.', 'danger') + return redirect(url_for('users.login')) + + # Update tokens and log in the user + update_oauth_tokens(user, token, 'authentik') + login_user(user) + + user.last_login = datetime.now() + db.session.commit() + + # Redirect to next page or home + next_page = request.args.get('next') + if not next_page or not next_page.startswith('/'): + next_page = url_for('core.index') + + flash('You have been logged in via Authentik!', 'success') + return redirect(next_page) + + except Exception as e: + current_app.logger.error(f"Error in Authentik callback: {str(e)}") + flash('An error occurred during Authentik authentication. Please try again.', 'danger') + return redirect(url_for('users.login')) + +# OAuth login routes for Dropbox +@users_bp.route('/dropbox/auth') +@login_required +def dropbox_auth(): + """Initiate Dropbox OAuth flow""" + from musicround.helpers.dropbox_helper import get_dropbox_auth_url + + # Generate the authorization URL + auth_url = get_dropbox_auth_url() + + if auth_url: + # Store state in session to prevent CSRF + return redirect(auth_url) + else: + flash('Error initiating Dropbox authorization', 'error') + return redirect(url_for('users.profile')) + +@users_bp.route('/dropbox/callback') +@login_required +def dropbox_callback(): + """Handle Dropbox OAuth callback""" + from musicround.helpers.dropbox_helper import exchange_code_for_token, get_dropbox_account_info + + error = request.args.get('error') + if error: + flash(f'Dropbox authorization failed: {error}', 'error') + return redirect(url_for('users.profile')) + + code = request.args.get('code') + if not code: + flash('No authorization code received from Dropbox', 'error') + return redirect(url_for('users.profile')) + + # Exchange the code for a token + result = exchange_code_for_token(code) + + if not result or not result.get('access_token'): + flash('Failed to obtain Dropbox access token', 'error') + return redirect(url_for('users.profile')) + + # Store the tokens in the user's account + current_user.dropbox_token = result.get('access_token') + current_user.dropbox_refresh_token = result.get('refresh_token') + + # Convert expires_in (seconds from now) to an actual datetime + expires_in = result.get('expires_in', 14400) # Default to 4 hours if not provided + current_user.dropbox_token_expiry = datetime.now() + timedelta(seconds=expires_in) + + # Get account information to store the account ID + account_info = get_dropbox_account_info(current_user.dropbox_token) + + if account_info and account_info.get('account_id'): + current_user.dropbox_id = account_info.get('account_id') + + # Store additional info in session for display + session['dropbox_user_info'] = { + 'name': account_info.get('name', {}).get('display_name', ''), + 'email': account_info.get('email', ''), + 'picture': account_info.get('profile_photo_url', '') + } + + # If it's the first time setting up Dropbox, set a default export path + if not current_user.dropbox_export_path: + current_user.dropbox_export_path = '/QuizzicalBeats' + + db.session.commit() + flash('Successfully connected to Dropbox!', 'success') + else: + flash('Connected to Dropbox, but failed to get account information', 'warning') + db.session.commit() + + return redirect(url_for('users.profile')) + +@users_bp.route('/dropbox/disconnect', methods=['POST']) +@login_required +def dropbox_disconnect(): + """Disconnect user's Dropbox account""" + # Revoke token if present (optional but good practice) + if current_user.dropbox_token: + try: + from musicround.helpers.dropbox_helper import revoke_token + revoke_token(current_user.dropbox_token) + except Exception as e: + current_app.logger.error(f"Error revoking Dropbox token: {str(e)}") + + # Clear Dropbox credentials + current_user.dropbox_token = None + current_user.dropbox_refresh_token = None + current_user.dropbox_token_expiry = None + current_user.dropbox_id = None + + # Keep the export path in case they reconnect + + # Remove session info + if 'dropbox_user_info' in session: + session.pop('dropbox_user_info') + + db.session.commit() + flash('Dropbox account disconnected successfully', 'success') + + return redirect(url_for('users.profile')) + +@users_bp.route('/dropbox/export-path', methods=['POST']) +@login_required +def update_dropbox_export_path(): + """Update the user's Dropbox export path""" + export_path = request.form.get('dropbox_export_path', '/QuizzicalBeats') + + # Simple validation + if not export_path.startswith('/'): + export_path = '/' + export_path + + # Remove any trailing slash + if export_path.endswith('/') and len(export_path) > 1: + export_path = export_path[:-1] + + # Save the path + current_user.dropbox_export_path = export_path + db.session.commit() + + flash('Dropbox export path updated successfully', 'success') + return redirect(url_for('users.profile')) + +@users_bp.route('/register', methods=['GET', 'POST']) +def register(): + """Register a new user""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Check if new signups are allowed + allow_signups = SystemSetting.get('allow_signups', 'true') == 'true' + if not allow_signups: + flash('New user registration is currently disabled.', 'danger') + return redirect(url_for('users.login')) + + if request.method == 'POST': + username = request.form.get('username') + email = request.form.get('email') + password = request.form.get('password') + confirm_password = request.form.get('confirm_password') + first_name = request.form.get('first_name') + last_name = request.form.get('last_name') + + # Validate the form data + if not username or not email or not password or not confirm_password: + flash('All fields are required', 'danger') + return render_template('users/register.html') + + if password != confirm_password: + flash('Passwords do not match', 'danger') + return render_template('users/register.html') + + # Check if username or email already exists + if User.query.filter_by(username=username).first(): + flash('Username already exists', 'danger') + return render_template('users/register.html') + + if User.query.filter_by(email=email).first(): + flash('Email already registered', 'danger') + return render_template('users/register.html') + + # Create new user + try: + new_user = User( + username=username, + email=email, + password_hash=generate_password_hash(password), + first_name=first_name, + last_name=last_name, + created_at=datetime.now(), + last_login=datetime.now() + ) + db.session.add(new_user) + db.session.commit() + + flash('Registration successful! You can now log in.', 'success') + return redirect(url_for('users.login')) + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error registering user: {e}") + flash('An error occurred during registration', 'danger') + return render_template('users/register.html') + + return render_template('users/register.html') + +@users_bp.route('/login', methods=['GET', 'POST']) +def login(): + """Log in a user""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Check which OAuth providers are configured + oauth_providers = { + 'google': bool(current_app.config.get('GOOGLE_CLIENT_ID')), + 'authentik': bool(current_app.config.get('AUTHENTIK_CLIENT_ID')) + } + + if request.method == 'POST': + username_or_email = request.form.get('username') + password = request.form.get('password') + remember = True if request.form.get('remember') else False + + # Find user by username or email + user = User.query.filter_by(username=username_or_email).first() + if not user: + user = User.query.filter_by(email=username_or_email).first() + + # Check if user exists and password is correct + if not user or not check_password_hash(user.password_hash, password): + flash('Invalid username/email or password', 'danger') + return render_template('users/login.html', oauth_providers=oauth_providers) + + # Log in the user + login_user(user, remember=remember) + user.last_login = datetime.now() + db.session.commit() + + next_page = request.args.get('next') + if not next_page or not next_page.startswith('/'): + next_page = url_for('core.index') + + flash('You have been logged in!', 'success') + return redirect(next_page) + + return render_template('users/login.html', oauth_providers=oauth_providers) + +@users_bp.route('/logout') +@login_required +def logout(): + """Log out a user""" + logout_user() + flash('You have been logged out', 'success') + return redirect(url_for('users.login')) + +@users_bp.route('/profile') +@login_required +def profile(): + """Display user profile""" + # Check which view functions exist to avoid using current_app in template + available_routes = { + 'rounds_list': 'rounds.rounds_list' in current_app.view_functions, + 'view_songs': 'core.view_songs' in current_app.view_functions, + 'create_round': 'rounds.create' in current_app.view_functions + } + + # Check if any admin users exist + admin_role = Role.query.filter_by(name='admin').first() + admin_exists = False + if admin_role: + admin_exists = admin_role.users.count() > 0 + + # Get current time for token expiry checks + now = datetime.now() + + # Get info about current tokens + system_refresh_token = SystemSetting.get('fallback_spotify_refresh_token', '') + session_bearer = session.get('access_token', '') + token_source = session.get('token_source', '') + client_token_expiry = session.get('client_token_expiry', 0) + + # Fetch user info for the active token + spotify_user_info = None + active_username = None + active_user_id = None + active_user_image = None + active_token_expiry = None + + # Check for an active token in the session + if session_bearer: + try: + # Set up the Spotify client with the token + sp = current_app.config['sp'] + sp.set_auth(session_bearer) + + # Client credentials don't have user context + if token_source != 'client_credentials': + try: + # Use the token to get user info + spotify_user_info = sp.current_user() + + if spotify_user_info: + active_user_id = spotify_user_info.get('id') + active_username = spotify_user_info.get('display_name') or active_user_id + current_app.logger.debug(f"Found Spotify user: {active_username} (ID: {active_user_id})") + + # Get profile image if available + images = spotify_user_info.get('images', []) + if images and len(images) > 0: + active_user_image = images[0].get('url') + + except Exception as user_info_error: + current_app.logger.error(f"Error fetching Spotify user info: {str(user_info_error)}") + + # For manual bearer tokens, try to determine expiry time + if token_source == '' or token_source not in ['user', 'client_credentials', 'system']: + # This is likely a manual bearer token + # Most bearer tokens are valid for 1 hour from issue + # We don't know when it was issued, but we can notify the user + # that these tokens typically expire after 1 hour + from datetime import timedelta + # Manual tokens stored in session likely were just added + token_added_time = session.get('bearer_token_added', now.timestamp()) + typical_expiry = datetime.fromtimestamp(token_added_time) + timedelta(hours=1) + active_token_expiry = typical_expiry + + # Mark it as a manual token for clarity + token_source = 'manual' + session['token_source'] = 'manual' + + except Exception as e: + current_app.logger.error(f"Error setting up Spotify client: {e}") + + # Determine Spotify connection status with corrected priority order + spotify_status = 'none' # Default: no connection + + # Check for manually set bearer token (highest priority) + has_manual_bearer = 'access_token' in session and token_source == 'manual' + if has_manual_bearer: + spotify_status = 'bearer' + + # Check user's own Spotify connection (second priority) + elif token_source == 'user' or (current_user.spotify_token and current_user.spotify_refresh_token): + if current_user.spotify_token_expiry and current_user.spotify_token_expiry > now: + # User has valid token + spotify_status = 'user' + elif check_spotify_token(current_user): + # Token was refreshed successfully + spotify_status = 'user' + + # Check for client credentials token (third priority) + elif token_source == 'client_credentials': + spotify_status = 'client_credentials' + + return render_template( + 'users/profile.html', + available_routes=available_routes, + admin_exists=admin_exists, + spotify_status=spotify_status, + system_refresh_token=system_refresh_token, + session_bearer=session_bearer, + token_source=token_source, + client_token_expiry=client_token_expiry, + now=now, + spotify_user_info=spotify_user_info, + active_username=active_username, + active_user_id=active_user_id, + active_user_image=active_user_image, + active_token_expiry=active_token_expiry + ) + +@users_bp.route('/edit-profile', methods=['GET', 'POST']) +@login_required +def edit_profile(): + """Edit user profile""" + if request.method == 'POST': + username = request.form.get('username') + email = request.form.get('email') + first_name = request.form.get('first_name') + last_name = request.form.get('last_name') + dropbox_export_path = request.form.get('dropbox_export_path', '/QuizzicalBeats').strip() + + # Check if username or email already exists and belongs to another user + if username != current_user.username and User.query.filter_by(username=username).first(): + flash('That username is already taken', 'danger') + return render_template('users/edit_profile.html') + + if email != current_user.email and User.query.filter_by(email=email).first(): + flash('That email is already registered', 'danger') + return render_template('users/edit_profile.html') + + # Update user profile + current_user.username = username + current_user.email = email + current_user.first_name = first_name + current_user.last_name = last_name + current_user.dropbox_export_path = dropbox_export_path + + try: + db.session.commit() + flash('Your profile has been updated', 'success') + return redirect(url_for('users.profile')) + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error updating profile: {e}") + flash('An error occurred while updating your profile', 'danger') + + return render_template('users/edit_profile.html') + +@users_bp.route('/change-password', methods=['GET', 'POST']) +@login_required +def change_password(): + """Change user password""" + if request.method == 'POST': + current_password = request.form.get('current_password') + new_password = request.form.get('new_password') + confirm_password = request.form.get('confirm_password') + + # Check if current password is correct + if not check_password_hash(current_user.password_hash, current_password): + flash('Current password is incorrect', 'danger') + return render_template('users/change_password.html') + + # Check if new passwords match + if new_password != confirm_password: + flash('New passwords do not match', 'danger') + return render_template('users/change_password.html') + + # Update password + current_user.password_hash = generate_password_hash(new_password) + + try: + db.session.commit() + flash('Your password has been changed', 'success') + return redirect(url_for('users.profile')) + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error changing password: {e}") + flash('An error occurred while changing your password', 'danger') + + return render_template('users/change_password.html') + +@users_bp.route('/forgot-password', methods=['GET', 'POST']) +def forgot_password(): + """Handle forgot password requests""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + if request.method == 'POST': + email = request.form.get('email') + + # Find user by email + user = User.query.filter_by(email=email).first() + + if user: + # Generate reset token + token = str(uuid.uuid4()) + user.reset_token = token + user.reset_token_expiry = datetime.now() + timedelta(hours=24) + + try: + db.session.commit() + + # Build reset URL + reset_url = url_for('users.reset_password', token=token, _external=True) + + # Email content + subject = "Quizzical Beats Password Reset" + body_text = f"""Hello {user.username}, + +You recently requested to reset your password for your Quizzical Beats account. +Please click the link below to reset your password: + +{reset_url} + +This link will expire in 24 hours. + +If you did not request a password reset, please ignore this email or contact support if you have questions. + +Best regards, +The Quizzical Beats Team +""" + + # Import and use the email helper + from musicround.helpers.email_helper import send_email + success, message = send_email(recipient=email, subject=subject, body_text=body_text) + + if success: + flash('Password reset instructions have been sent to your email address.', 'success') + current_app.logger.info(f"Password reset email sent to {email}") + else: + # Log the failure but don't reveal to user that the email exists + current_app.logger.error(f"Failed to send password reset email: {message}") + flash('If your email is registered, you will receive a password reset link.', 'success') + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error generating reset token: {e}") + flash('An error occurred. Please try again.', 'danger') + else: + # Don't reveal that email doesn't exist + # Add a small delay to prevent email enumeration + time.sleep(1) + flash('If your email is registered, you will receive a password reset link.', 'success') + current_app.logger.info(f"Password reset attempted for non-existent email: {email}") + + return render_template('users/forgot_password.html') + +@users_bp.route('/reset-password/', methods=['GET', 'POST']) +def reset_password(token): + """Reset password using token""" + if current_user.is_authenticated: + return redirect(url_for('core.index')) + + # Find user by reset token + user = User.query.filter_by(reset_token=token).first() + + # Check if token is valid and not expired + if not user or not user.reset_token_expiry or user.reset_token_expiry < datetime.now(): + flash('The password reset link is invalid or has expired', 'danger') + return redirect(url_for('users.forgot_password')) + + if request.method == 'POST': + password = request.form.get('password') + confirm_password = request.form.get('confirm_password') + + if password != confirm_password: + flash('Passwords do not match', 'danger') + return render_template('users/reset_password.html', token=token) + + # Update password and clear token + user.password_hash = generate_password_hash(password) + user.reset_token = None + user.reset_token_expiry = None + + try: + db.session.commit() + + # Send confirmation email + subject = "Your Quizzical Beats Password Has Been Reset" + body_text = f"""Hello {user.username}, + +Your password has been successfully reset. You can now log in with your new password. + +If you did not reset your password, please contact support immediately. + +Best regards, +The Quizzical Beats Team +""" + + # Import and use email helper + from musicround.helpers.email_helper import send_email + send_email(recipient=user.email, subject=subject, body_text=body_text) + + flash('Your password has been reset. You can now log in.', 'success') + current_app.logger.info(f"Password reset successful for user: {user.username}") + return redirect(url_for('users.login')) + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error resetting password: {e}") + flash('An error occurred while resetting your password', 'danger') + + return render_template('users/reset_password.html', token=token) + +@users_bp.route('/spotify-link', methods=['GET', 'POST']) +@login_required +def spotify_link(): + """Manage Spotify account connection""" + now = datetime.now() + + if request.method == 'POST': + action = request.form.get('action') + + if action == 'disconnect': + # Disconnect Spotify account + current_user.spotify_token = None + current_user.spotify_refresh_token = None + current_user.spotify_token_expiry = None + current_user.oauth_id = None + + try: + db.session.commit() + flash('Your Spotify account has been disconnected', 'success') + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error disconnecting Spotify: {e}") + flash('An error occurred while disconnecting your Spotify account', 'danger') + + return render_template('users/spotify_link.html', now=now) + +@users_bp.route('/spotify-auth') +@login_required +def spotify_auth(): + """Initiate Spotify OAuth flow""" + try: + sp_oauth = SpotifyOAuth( + client_id=current_app.config['SPOTIFY_CLIENT_ID'], + client_secret=current_app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=url_for('users.spotify_callback', _external=True), + scope=current_app.config['SPOTIFY_SCOPE'] + ) + auth_url = sp_oauth.get_authorize_url() + + # Store state in session for validation + session['oauth_state'] = sp_oauth.state + + return redirect(auth_url) + except Exception as e: + current_app.logger.error(f"Error initiating Spotify auth: {e}") + flash('Error connecting to Spotify. Please try again.', 'danger') + return redirect(url_for('users.spotify_link')) + +@users_bp.route('/spotify-callback') +@login_required +def spotify_callback(): + """Handle Spotify OAuth callback""" + try: + # Verify state parameter + if request.args.get('state') != session.get('oauth_state'): + flash('Authentication state mismatch. Please try again.', 'danger') + return redirect(url_for('users.spotify_link')) + + # Get authorization code + code = request.args.get('code') + if not code: + flash('No authorization code received from Spotify.', 'danger') + return redirect(url_for('users.spotify_link')) + + # Exchange code for token + sp_oauth = SpotifyOAuth( + client_id=current_app.config['SPOTIFY_CLIENT_ID'], + client_secret=current_app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=url_for('users.spotify_callback', _external=True), + scope=current_app.config['SPOTIFY_SCOPE'] + ) + + token_info = sp_oauth.get_access_token(code) + + if not token_info or 'access_token' not in token_info: + flash('Failed to obtain access token from Spotify.', 'danger') + return redirect(url_for('users.spotify_link')) + + # Save token to user + current_user.spotify_token = token_info['access_token'] + current_user.spotify_refresh_token = token_info.get('refresh_token') + expiry = datetime.fromtimestamp(token_info['expires_at']) if 'expires_at' in token_info else None + current_user.spotify_token_expiry = expiry + + # Get Spotify user ID + try: + sp = current_app.config['sp'] + sp.set_auth(token_info['access_token']) + user_info = sp.current_user() + current_user.oauth_id = user_info['id'] + except: + # Continue even if we can't get the Spotify ID + current_app.logger.warning("Could not fetch Spotify user ID") + + # Save to database + try: + db.session.commit() + flash('Successfully connected to Spotify!', 'success') + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error saving Spotify token: {e}") + flash('Error saving Spotify connection.', 'danger') + + return redirect(url_for('users.spotify_link')) + + except Exception as e: + current_app.logger.error(f"Error during Spotify callback: {e}") + flash('Error during Spotify authentication. Please try again.', 'danger') + return redirect(url_for('users.spotify_link')) + +@users_bp.route('/update-bearer-token', methods=['POST']) +@login_required +def update_bearer_token(): + """Update the Spotify bearer token in the session""" + # Check if clearing token was requested + if request.form.get('clear_token'): + session.pop('access_token', None) + session.pop('token_source', None) + session.pop('bearer_token_added', None) + flash('Spotify bearer token has been cleared', 'success') + return redirect(url_for('users.profile')) + + # Get bearer token from form + bearer_token = request.form.get('bearer_token', '').strip() + if not bearer_token: + flash('No bearer token provided', 'warning') + return redirect(url_for('users.profile')) + + try: + # Store the token in session with timestamp and mark as manual + session['access_token'] = bearer_token + session['token_source'] = 'manual' + session['bearer_token_added'] = datetime.now().timestamp() + + # Test the token with a simple request to validate it + sp = current_app.config['sp'] + sp.set_auth(bearer_token) + + # Try to get current user info as a test + user_info = sp.current_user() + + if user_info and 'id' in user_info: + username = user_info.get('display_name') or user_info.get('id') + flash(f'Successfully authenticated with Spotify as {username}', 'success') + + # Log who this token belongs to + current_app.logger.info(f"Manual bearer token added for Spotify user: {username} (ID: {user_info.get('id')})") + else: + flash('Token saved but validation failed. The token may be invalid or expired.', 'warning') + except Exception as e: + current_app.logger.error(f"Error validating bearer token: {e}") + flash(f'Token saved but error during validation: {str(e)}', 'warning') + + return redirect(url_for('users.profile')) + +@users_bp.route('/use-refresh-token', methods=['POST']) +@login_required +def use_refresh_token(): + """Generate a new access token using the stored refresh token""" + # Check if user has a refresh token + if not current_user.spotify_refresh_token: + flash('No Spotify refresh token found. Please connect your Spotify account first.', 'warning') + return redirect(url_for('users.profile')) + + try: + # Create OAuth object + sp_oauth = SpotifyOAuth( + client_id=current_app.config['SPOTIFY_CLIENT_ID'], + client_secret=current_app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=url_for('users.spotify_callback', _external=True), + scope=current_app.config['SPOTIFY_SCOPE'] + ) + + # Refresh the token + token_info = sp_oauth.refresh_access_token(current_user.spotify_refresh_token) + + if not token_info or 'access_token' not in token_info: + flash('Failed to refresh access token from Spotify.', 'danger') + return redirect(url_for('users.profile')) + + # Update user model with new token information + current_user.spotify_token = token_info['access_token'] + current_user.spotify_token_expiry = datetime.fromtimestamp(token_info['expires_at']) if 'expires_at' in token_info else None + + # If we got a new refresh token (unusual but possible), store it + if 'refresh_token' in token_info: + current_user.spotify_refresh_token = token_info['refresh_token'] + + # Save to database + db.session.commit() + + # Also set token in the session for direct API access + session['access_token'] = token_info['access_token'] + + # Validate the token by getting user info + sp = current_app.config['sp'] + sp.set_auth(token_info['access_token']) + user_info = sp.current_user() + + if user_info and 'id' in user_info: + flash(f'Successfully generated new token for {user_info.get("display_name", user_info["id"])}', 'success') + else: + flash('Token generated but validation failed.', 'warning') + + except Exception as e: + current_app.logger.error(f"Error refreshing token: {e}") + flash(f'Error refreshing token: {str(e)}', 'danger') + + return redirect(url_for('users.profile')) + +def check_spotify_token(user): + """ + Helper function to check if user's Spotify token needs to be refreshed + Returns True if token is valid, False if not + """ + if not user.spotify_token or not user.spotify_refresh_token or not user.spotify_token_expiry: + return False + + now = datetime.now() + + # If token expires in less than 5 minutes, refresh it + if user.spotify_token_expiry - now < timedelta(minutes=5): + sp_oauth = SpotifyOAuth( + client_id=current_app.config['SPOTIFY_CLIENT_ID'], + client_secret=current_app.config['SPOTIFY_CLIENT_SECRET'], + redirect_uri=url_for('users.spotify_callback', _external=True), + scope=current_app.config['SPOTIFY_SCOPE'] + ) + + try: + token_info = sp_oauth.refresh_access_token(user.spotify_refresh_token) + user.spotify_token = token_info['access_token'] + user.spotify_token_expiry = datetime.fromtimestamp(token_info['expires_at']) + db.session.commit() + return True + except Exception as e: + current_app.logger.error(f"Error refreshing Spotify token: {e}") + return False + + return True + +@users_bp.route('/setup') +@login_required +def setup(): + """One-time setup route to promote the current user to admin""" + if current_user.is_admin(): + flash('You are already an administrator.', 'info') + return redirect(url_for('users.profile')) + + try: + # Check if the admin role exists + admin_role = Role.query.filter_by(name='admin').first() + + # Check if any admin users already exist + admin_exists = False + if admin_role: + admin_exists = admin_role.users.count() > 0 + + if admin_exists: + flash('An administrator already exists in the system. Only the first user can be promoted to admin.', 'warning') + return redirect(url_for('users.profile')) + + # Create the admin role if it doesn't exist + if not admin_role: + admin_role = Role(name='admin', description='Administrator role with full system access') + db.session.add(admin_role) + db.session.commit() + current_app.logger.info(f"Created admin role with ID {admin_role.id}") + + # Assign the admin role to the current user + if admin_role not in current_user.roles: + current_user.roles.append(admin_role) + db.session.commit() + current_app.logger.info(f"User {current_user.username} promoted to admin") + flash('You have been promoted to administrator!', 'success') + else: + flash('You already have the admin role, but it may not be working correctly.', 'warning') + + return redirect(url_for('users.profile')) + + except Exception as e: + db.session.rollback() + current_app.logger.error(f"Error promoting user to admin: {str(e)}") + flash(f'Error setting up admin privileges: {str(e)}', 'danger') + return redirect(url_for('users.profile')) + +@users_bp.route('/audio-settings', methods=['GET', 'POST']) +@login_required +def audio_settings(): + """Manage custom audio settings including intro, outro, and replay MP3s""" + from musicround.helpers.utils import save_user_mp3, generate_tts_mp3, get_available_voices + + if request.method == 'POST': + action = request.form.get('action') + mp3_type = request.form.get('mp3_type') + + if not mp3_type or mp3_type not in ['intro', 'outro', 'replay']: + flash('Invalid audio type specified', 'danger') + return redirect(url_for('users.audio_settings')) + + if action == 'upload': + # Handle file upload + if 'audio_file' not in request.files: + flash('No file provided', 'danger') + return redirect(request.url) + + file = request.files['audio_file'] + if file.filename == '': + flash('No file selected', 'danger') + return redirect(request.url) + + # Save the user's uploaded MP3 + file_path = save_user_mp3(file, current_user.username, mp3_type) + if file_path: + # Update user's MP3 setting + setattr(current_user, f'{mp3_type}_mp3', file_path) + db.session.commit() + flash(f'Your {mp3_type} audio has been updated', 'success') + else: + flash('Invalid file format. Please upload an MP3 file.', 'danger') + + elif action == 'generate': + # Handle text-to-speech generation + text = request.form.get('tts_text') + service = request.form.get('tts_service', 'polly') + voice = request.form.get('tts_voice') + + # Process advanced options for each service + model = None + stability = None + similarity = None + + if service == 'openai': + model = request.form.get('openai_model', 'tts-1') + elif service == 'elevenlabs': + model = request.form.get('elevenlabs_model', 'eleven_monolingual_v1') + # Convert string values to float + try: + stability = float(request.form.get('stability', 0.5)) + similarity = float(request.form.get('similarity_boost', 0.75)) + except (ValueError, TypeError): + stability = 0.5 + similarity = 0.75 + + if not text: + flash('No text provided for speech generation', 'danger') + return redirect(request.url) + + # Generate MP3 with the selected service and options + file_path = generate_tts_mp3( + text=text, + username=current_user.username, + mp3_type=mp3_type, + service=service, + voice=voice, + model=model, + stability=stability, + similarity=similarity + ) + + if file_path: + # Update user's MP3 setting + setattr(current_user, f'{mp3_type}_mp3', file_path) + db.session.commit() + flash(f'Your {mp3_type} audio has been generated', 'success') + else: + flash('Error generating audio. Please check your settings and try again.', 'danger') + + elif action == 'reset': + # Reset to default MP3 + setattr(current_user, f'{mp3_type}_mp3', None) + db.session.commit() + flash(f'Your {mp3_type} audio has been reset to default', 'success') + + return redirect(url_for('users.audio_settings')) + + # Define default text templates for each type + default_texts = { + 'intro': 'Welcome to the music quiz! Get ready to test your knowledge of songs and artists.', + 'outro': 'That concludes our music round. How many songs did you recognize?', + 'replay': 'Now we will play all the songs again. Listen carefully!' + } + + # Check which TTS services are available + tts_services = [] + + # Check for AWS credentials + has_aws = all([ + current_app.config.get('AWS_ACCESS_KEY_ID'), + current_app.config.get('AWS_SECRET_ACCESS_KEY') + ]) + if has_aws: + tts_services.append({ + 'id': 'polly', + 'name': 'Amazon Polly', + 'description': 'High-quality natural-sounding voices', + 'voices': get_available_voices('polly') + }) + + # Check for OpenAI credentials + has_openai = bool(current_app.config.get('OPENAI_API_KEY')) + if has_openai: + tts_services.append({ + 'id': 'openai', + 'name': 'OpenAI TTS', + 'description': 'Realistic speech synthesis from OpenAI', + 'voices': get_available_voices('openai'), + 'models': [ + {'id': 'tts-1', 'name': 'TTS-1 (Standard)', 'description': 'Standard quality voice'}, + {'id': 'tts-1-hd', 'name': 'TTS-1-HD (High Definition)', 'description': 'Higher quality voice'} + ] + }) + + # Check for ElevenLabs credentials + has_elevenlabs = bool(current_app.config.get('ELEVENLABS_API_KEY')) + if has_elevenlabs: + tts_services.append({ + 'id': 'elevenlabs', + 'name': 'ElevenLabs', + 'description': 'Ultra-realistic AI voices with emotion', + 'voices': get_available_voices('elevenlabs'), + 'models': [ + {'id': 'eleven_monolingual_v1', 'name': 'Monolingual V1', 'description': 'English only, faster generation'}, + {'id': 'eleven_multilingual_v2', 'name': 'Multilingual V2', 'description': 'Supports multiple languages'} + ], + 'settings': True # Flag to indicate this service has additional settings + }) + + # Handle TTS service selection for the form + selected_service = request.args.get('tts_service') + mp3_type = request.args.get('mp3_type') or 'intro' + + # Find the selected service dict + selected_service_dict = None + for svc in tts_services: + if svc['id'] == selected_service: + selected_service_dict = svc + break + if not selected_service_dict and tts_services: + selected_service_dict = tts_services[0] + + return render_template( + 'users/audio_settings.html', + default_texts=default_texts, + tts_services=tts_services, + has_tts_services=bool(tts_services), + selected_service=selected_service_dict, + mp3_type=mp3_type + ) + +@users_bp.route('/system-settings', methods=['GET', 'POST']) +@login_required +@admin_required +def system_settings(): + """Admin view to edit global/system settings.""" + from musicround.helpers.utils import get_available_voices + + # Define editable system settings keys and their labels + editable_settings = [ + ('default_tts_service', 'Default TTS Service'), + ('default_tts_voice', 'Default TTS Voice'), + ('default_tts_model', 'Default TTS Model'), + ('fallback_spotify_refresh_token', 'Fallback Spotify Refresh Token'), + ('spotify_region', 'Default Spotify Region'), + ('max_songs_per_round', 'Maximum Songs Per Round'), + ('enable_public_rounds', 'Enable Public Rounds'), + ('allow_signups', 'Allow New User Registrations'), + # Add more keys/labels as needed + ] + + # Define which settings are checkboxes (boolean values) + checkbox_settings = ['enable_public_rounds', 'allow_signups'] + + if request.method == 'POST': + # Process all settings from the form + for key, _ in editable_settings: + # Handle checkboxes differently - they're only in the form if checked + if key in checkbox_settings: + # Set 'true' if checkbox is in form data, otherwise 'false' + value = 'true' if key in request.form else 'false' + current_app.logger.debug(f"Setting {key} to {value}") + SystemSetting.set(key, value) + else: + # Normal text/select fields + value = request.form.get(key, '') + current_app.logger.debug(f"Setting {key} to {value}") + SystemSetting.set(key, value) + + # Add a database commit to ensure changes are saved + db.session.commit() + + flash('System settings updated.', 'success') + return redirect(url_for('users.system_settings')) + + # Get all current settings + settings = SystemSetting.all_settings() + + # Check which TTS services are available + tts_services = [] + + # Check for AWS credentials + has_aws = all([ + current_app.config.get('AWS_ACCESS_KEY_ID'), + current_app.config.get('AWS_SECRET_ACCESS_KEY') + ]) + if has_aws: + tts_services.append({ + 'id': 'polly', + 'name': 'Amazon Polly', + 'description': 'High-quality natural-sounding voices', + 'voices': get_available_voices('polly') + }) + + # Check for OpenAI credentials + has_openai = bool(current_app.config.get('OPENAI_API_KEY')) + if has_openai: + tts_services.append({ + 'id': 'openai', + 'name': 'OpenAI TTS', + 'description': 'Realistic speech synthesis from OpenAI', + 'voices': get_available_voices('openai'), + 'models': [ + {'id': 'tts-1', 'name': 'TTS-1 (Standard)', 'description': 'Standard quality voice'}, + {'id': 'tts-1-hd', 'name': 'TTS-1-HD (High Definition)', 'description': 'Higher quality voice'} + ] + }) + + # Check for ElevenLabs credentials + has_elevenlabs = bool(current_app.config.get('ELEVENLABS_API_KEY')) + if has_elevenlabs: + tts_services.append({ + 'id': 'elevenlabs', + 'name': 'ElevenLabs', + 'description': 'Ultra-realistic AI voices with emotion', + 'voices': get_available_voices('elevenlabs'), + 'models': [ + {'id': 'eleven_monolingual_v1', 'name': 'Monolingual V1', 'description': 'English only, faster generation'}, + {'id': 'eleven_multilingual_v2', 'name': 'Multilingual V2', 'description': 'Supports multiple languages'} + ] + }) + + # List of available regions for Spotify + spotify_regions = [ + {'code': 'US', 'name': 'United States'}, + {'code': 'GB', 'name': 'United Kingdom'}, + {'code': 'DE', 'name': 'Germany'}, + {'code': 'FR', 'name': 'France'}, + {'code': 'ES', 'name': 'Spain'}, + {'code': 'IT', 'name': 'Italy'}, + {'code': 'JP', 'name': 'Japan'}, + {'code': 'AU', 'name': 'Australia'}, + {'code': 'BR', 'name': 'Brazil'}, + {'code': 'CA', 'name': 'Canada'}, + ] + + return render_template( + 'admin/system_settings.html', + settings=settings, + editable_settings=editable_settings, + tts_services=tts_services, + spotify_regions=spotify_regions + ) + +@users_bp.route('/backup-manager') +@login_required +@admin_required +def backup_manager(): + """Backup Manager interface for administrators""" + from musicround.helpers.backup_helper import list_backups, get_backup_summary, generate_backup_config_suggestion + + # Get list of existing backups + backups = list_backups() + + # Get backup system status and summary + backup_summary = get_backup_summary() + + # Extract key information from summary + backup_count = backup_summary.get('backup_count', 0) + latest_backup = backup_summary.get('latest_backup') + schedule_enabled = backup_summary.get('schedule_enabled', False) + schedule_time = backup_summary.get('schedule_time') + schedule_frequency = backup_summary.get('schedule_frequency', 'daily') + next_backup = backup_summary.get('next_backup') + backup_location = backup_summary.get('backup_location') + retention_days = backup_summary.get('retention_days', 30) + + # Generate configuration suggestion instead of Docker Compose labels + config_suggestion = generate_backup_config_suggestion(retention_days=retention_days) + + # Check if we should show the schedule or create forms + show_schedule_form = request.args.get('show_schedule') == 'true' + show_create_form = request.args.get('show_create') == 'true' + + # Check for notifications from other backup operations + notification = None + if 'backup_notification' in session: + notification = session.pop('backup_notification') + + return render_template( + 'admin/backup_manager.html', + backups=backups, + backup_count=backup_count, + latest_backup=latest_backup, + schedule_enabled=schedule_enabled, + schedule_time=schedule_time, + schedule_frequency=schedule_frequency, + next_backup=next_backup, + backup_location=backup_location, + retention_days=retention_days, + show_schedule_form=show_schedule_form, + show_create_form=show_create_form, + notification=notification, + config_suggestion=config_suggestion + ) + +@users_bp.route('/create-backup', methods=['POST']) +@login_required +@admin_required +def create_backup(): + """Create a new backup""" + from musicround.helpers.backup_helper import create_backup as create_backup_helper + + # Check for automation token for scheduled backups + automation_token = request.headers.get('X-Automation-Token') or request.args.get('token') + if automation_token == current_app.config.get('AUTOMATION_TOKEN'): + # Allow the request without authentication for automation + pass + elif not current_user.is_authenticated or not current_user.is_admin(): + return jsonify({"status": "error", "message": "Unauthorized"}), 401 + + # Get custom backup name if provided + backup_name = request.form.get('backup_name', '').strip() + + # Get options for what to include + include_mp3s = request.form.get('include_mp3s', 'true') == 'true' + include_config = request.form.get('include_config', 'true') == 'true' + + # Create the backup + result = create_backup_helper( + backup_name=backup_name if backup_name else None, + include_mp3s=include_mp3s, + include_config=include_config + ) + + # If this is an API request, return JSON + if request.headers.get('Accept') == 'application/json' or automation_token: + return jsonify(result) + + # Otherwise, store the result for display in the UI and redirect + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/schedule-backup', methods=['POST']) +@login_required +@admin_required +def schedule_backup(): + """Schedule automatic backups""" + from musicround.helpers.backup_helper import schedule_backup as schedule_backup_helper + + # Get schedule settings from form + schedule_time = request.form.get('schedule_time', '03:00') + frequency = request.form.get('frequency', 'daily') + enabled = request.form.get('enabled') == 'true' + + # Get retention days from form + retention_days = request.form.get('retention_days', '30') + try: + retention_days = int(retention_days) + except ValueError: + retention_days = 30 # Default to 30 days if invalid input + + # Save schedule settings + result = schedule_backup_helper(schedule_time=schedule_time, frequency=frequency, retention_days=retention_days) + + # Update enabled status + from musicround.models import SystemSetting + SystemSetting.set('backup_schedule_enabled', 'true' if enabled else 'false') + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/verify-backup/', methods=['GET', 'POST']) +@login_required +@admin_required +def verify_backup(filename): + """Verify the integrity of a backup file""" + from musicround.helpers.backup_helper import verify_backup as verify_backup_helper + + # Verify the backup + result = verify_backup_helper(filename) + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/restore-backup/', methods=['POST']) +@login_required +@admin_required +def restore_backup(filename): + """Restore from a backup file""" + from musicround.helpers.backup_helper import restore_backup as restore_backup_helper + + # Restore the backup + result = restore_backup_helper(filename) + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/delete-backup/', methods=['POST']) +@login_required +@admin_required +def delete_backup(filename): + """Delete a backup file""" + from musicround.helpers.backup_helper import delete_backup as delete_backup_helper + + # Delete the backup + result = delete_backup_helper(filename) + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/download-backup/', methods=['GET', 'POST']) +@login_required +@admin_required +def download_backup(filename): + """Download a backup file""" + import os + from flask import send_file, abort + + # Security check: only allow .zip files + if not filename.endswith('.zip'): + abort(400, "Invalid file type") + + # Only allow downloading from the backup directory + backup_dir = os.path.join('/data', 'backups') + backup_path = os.path.join(backup_dir, filename) + + # Check if the file exists + if not os.path.exists(backup_path): + abort(404, "Backup file not found") + + # Send the file + return send_file( + backup_path, + mimetype='application/zip', + as_attachment=True, + download_name=filename + ) + +@users_bp.route('/upload-backup', methods=['POST']) +@login_required +@admin_required +def upload_backup(): + """Upload a backup file to the system""" + from musicround.helpers.backup_helper import upload_backup as upload_backup_helper + + # Check if a file was uploaded + if 'backup_file' not in request.files: + flash('No file selected', 'danger') + return redirect(url_for('users.backup_manager')) + + file = request.files['backup_file'] + + # Check if the file has a name + if file.filename == '': + flash('No file selected', 'danger') + return redirect(url_for('users.backup_manager')) + + # Upload the file + result = upload_backup_helper(file) + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message') + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/apply-retention-policy', methods=['POST']) +@login_required +@admin_required +def apply_retention_policy(): + """Apply retention policy to backups""" + from musicround.helpers.backup_helper import apply_retention_policy as apply_retention_policy_helper + from musicround.models import SystemSetting + + # Get retention days from form + retention_days = request.form.get('retention_days', '30') + try: + retention_days = int(retention_days) + except ValueError: + retention_days = 30 # Default to 30 days if invalid input + + # Save the retention policy setting + SystemSetting.set('backup_retention_days', str(retention_days)) + + # Apply the retention policy + result = apply_retention_policy_helper(retention_days) + + # Store the result for display + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message'), + 'details': { + 'deleted_count': result.get('deleted_count', 0), + 'deleted_backups': result.get('deleted_backups', []) + } + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/update-scheduler', methods=['POST']) +@login_required +@admin_required +def update_scheduler(): + """Update the Ofelia scheduler configuration based on current system settings""" + from musicround.helpers.backup_helper import update_ofelia_config + + # Get the current retention days setting + from musicround.models import SystemSetting + retention_days = int(SystemSetting.get('backup_retention_days', '30')) + + # Update the scheduler configuration + result = update_ofelia_config(retention_days=retention_days) + + # Store result for display in the UI + session['backup_notification'] = { + 'status': result.get('status'), + 'message': result.get('message'), + 'details': { + 'schedule': result.get('schedule'), + 'config_content': result.get('config_content'), + 'instructions': result.get('instructions') + } + } + + return redirect(url_for('users.backup_manager')) + +@users_bp.route('/system-health') +@login_required +@admin_required +def system_health(): + """Display system health status""" + import os + import platform + import sys + import flask + import sqlite3 + from datetime import datetime + from musicround.models import Song, Round, User, db + from musicround.version import VERSION_INFO + + # Check database status + database_status = {"color": "green", "message": "Database is operational and accessible."} + database_stats = {} + + try: + # Count database records + database_stats["song_count"] = Song.query.count() + database_stats["round_count"] = Round.query.count() + database_stats["user_count"] = User.query.count() + + # Get database file size + db_path = current_app.config['SQLALCHEMY_DATABASE_URI'].replace('sqlite:///', '') + if os.path.exists(db_path): + size_bytes = os.path.getsize(db_path) + size_mb = size_bytes / (1024 * 1024) + database_stats["file_size"] = f"{size_mb:.2f} MB" + else: + database_stats["file_size"] = "Unknown" + database_status = {"color": "yellow", "message": "Database file not found at expected location."} + except Exception as e: + current_app.logger.error(f"Error checking database status: {str(e)}") + database_status = {"color": "red", "message": f"Database error: {str(e)}"} + + # Check storage status + storage_status = {"color": "green", "message": "All storage locations are accessible and writable."} + storage_stats = [] + + # Check important directories + dirs_to_check = [ + {"path": '/data', "name": "Data Directory"}, + {"path": '/data/backups', "name": "Backups Directory"}, + {"path": os.path.join(os.path.dirname(current_app.root_path), 'mp3'), "name": "MP3 Directory"}, + {"path": os.path.join(current_app.root_path, 'static'), "name": "Static Files"} + ] + + for dir_info in dirs_to_check: + dir_path = dir_info["path"] + dir_name = dir_info["name"] + dir_stat = {"name": dir_name, "path": dir_path} + + # Create directory if it doesn't exist (for backups) + if dir_name == "Backups Directory" and not os.path.exists(dir_path): + try: + os.makedirs(dir_path, exist_ok=True) + except Exception: + pass + + if os.path.exists(dir_path): + # Check if directory is writable + dir_stat["writable"] = os.access(dir_path, os.W_OK) + + # Count files and calculate size + try: + files = [f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))] + dir_stat["file_count"] = len(files) + + total_size = sum(os.path.getsize(os.path.join(dir_path, f)) for f in files) + size_mb = total_size / (1024 * 1024) + dir_stat["size"] = f"{size_mb:.2f} MB" + except Exception: + dir_stat["file_count"] = "Error" + dir_stat["size"] = "Error" + else: + dir_stat["writable"] = False + dir_stat["file_count"] = 0 + dir_stat["size"] = "0.00 MB" + + # Update overall status + if storage_status["color"] != "red": + storage_status = {"color": "yellow", "message": f"Directory not found: {dir_name}"} + + storage_stats.append(dir_stat) + + # Check API services status + api_status = {"color": "green", "message": "All API services are available."} + service_stats = [] + + # Check Spotify API + spotify_service = { + "name": "Spotify API", + "status": "ok", + "message": "Connected and operational" + } + + try: + spotify_credentials = all([ + current_app.config.get('SPOTIFY_CLIENT_ID'), + current_app.config.get('SPOTIFY_CLIENT_SECRET') + ]) + + if not spotify_credentials: + spotify_service["status"] = "error" + spotify_service["message"] = "Missing API credentials" + if api_status["color"] == "green": + api_status = {"color": "yellow", "message": "Some API services are unavailable."} + except Exception as e: + spotify_service["status"] = "error" + spotify_service["message"] = f"Error: {str(e)}" + api_status = {"color": "yellow", "message": "Some API services have errors."} + + service_stats.append(spotify_service) + + # Check Deezer API + deezer_service = { + "name": "Deezer API", + "status": "ok", + "message": "Connected and operational" + } + + try: + deezer_client = current_app.config.get('deezer') + if not deezer_client: + deezer_service["status"] = "warning" + deezer_service["message"] = "Deezer client not initialized" + if api_status["color"] == "green": + api_status = {"color": "yellow", "message": "Some API services have warnings."} + except Exception as e: + deezer_service["status"] = "error" + deezer_service["message"] = f"Error: {str(e)}" + api_status = {"color": "yellow", "message": "Some API services have errors."} + + service_stats.append(deezer_service) + + # Check memory usage + memory_status = {"color": "gray", "message": "Memory usage information not available."} + + try: + import psutil + process = psutil.Process(os.getpid()) + memory_info = process.memory_info() + memory_mb = memory_info.rss / (1024 * 1024) + + if memory_mb > 500: # More than 500MB + memory_status = {"color": "yellow", "message": f"High memory usage: {memory_mb:.2f} MB"} + else: + memory_status = {"color": "green", "message": f"Memory usage: {memory_mb:.2f} MB"} + except ImportError: + # psutil module not installed + memory_status = {"color": "gray", "message": "Memory usage information not available (psutil not installed)."} + except Exception as e: + # Other errors + memory_status = {"color": "gray", "message": f"Error checking memory: {str(e)}"} + current_app.logger.error(f"Error checking memory: {str(e)}") + + # System information + system_info = { + "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}", + "platform": platform.platform(), + "flask_version": flask.__version__ + } + + # Get last backup timestamp + from musicround.helpers.backup_helper import list_backups + backups = list_backups() + if backups: + latest_backup = backups[0] + timestamp = latest_backup.get('timestamp') + if timestamp: + try: + backup_time = datetime.fromisoformat(timestamp) + database_stats["last_backup"] = backup_time.strftime("%Y-%m-%d %H:%M:%S") + except (ValueError, TypeError): + database_stats["last_backup"] = "Unknown format" + else: + database_stats["last_backup"] = "Unknown" + else: + database_stats["last_backup"] = "Never" + + return render_template( + 'admin/system_health.html', + database_status=database_status, + storage_status=storage_status, + api_status=api_status, + memory_status=memory_status, + database_stats=database_stats, + storage_stats=storage_stats, + service_stats=service_stats, + system_info=system_info, + version_info=VERSION_INFO + ) \ No newline at end of file diff --git a/musicround/static/audio/1.mp3 b/musicround/static/audio/1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..db0b7445d216192ab0dea4b1d7ff110eb7a8faa6 GIT binary patch literal 6381 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 Hzgztu7zX+$ literal 0 HcmV?d00001 diff --git a/musicround/static/audio/3.mp3 b/musicround/static/audio/3.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..ae461ec3935899cee9fd92a62ca775c7ff858560 GIT binary patch literal 6669 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 X0-v8$CVgtgk^yYN|JC{bL;L>#JS~ac literal 0 HcmV?d00001 diff --git a/musicround/static/audio/7.mp3 b/musicround/static/audio/7.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..0ee88f0db5b03dddc33d7d8fbda0f079742fd2b8 GIT binary patch literal 6813 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 Z{{I)k^GLU?I0g6){QUpF-2b`4{{W;XBW3^q literal 0 HcmV?d00001 diff --git a/musicround/static/audio/8.mp3 b/musicround/static/audio/8.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..c943a7548799cf4f8aecd66560bc61fdbdd245f5 GIT binary patch literal 6093 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 I{{JuZKm3mxP5=M^ literal 0 HcmV?d00001 diff --git a/musicround/static/audio/outro.mp3 b/musicround/static/audio/outro.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..600fbaf6d247bff3f3ebbd8f74fa532ceccd22aa GIT binary patch literal 16461 zcmb{3bx@m6{3r0>4k0)M3!VbS3l#TY#i0~;cW-ei?(Xizr9g3a_u|E+Ewr>~?wkH* zZtl;Uo7+EL`mO3jyVwY$QHSu-d6QG=q;#TTRvSm(^pwRtERSK9*q?vmxG$Zxu z`&bwQc<%=o1?A&xEiFd>4;P^KUpn$f3G&e0kN>?ec<1tAjt&!@6ce4#MS@oRN56{% z5LFykhafcQBS9rlPz{LdcDxM0q?175LY?!J(PDHxEPqJ-p`}|u)%z0RA*UUJvXbPm zB28QqCISe>%`nN`uyJ1Hsr{h)aZ<>_yt*GDnL;8aXQkWBEekvkw6}n`a=UemrJqf{ z*M&SBgkb<<|L}4ZT>f(UcB=F#*&82U=xbPJ$frFvyB1c1RLZCqyEBBl{Mw*OcWni zVv!z`$RSRmsZr55w(z+iIoWY@5@^n*pb;Oh&o7C-bp^NwktL-Ep$aVUd6_)W{WWvJ zt=V1HuPvxBE2P|Sr>Ec^)3Y=*n`e=e3~5gJxxF+c3%=?S_j^a8UtP^KAzv|^>JUb~ zGB*NvhqE9N0gYMrjX-#a=o_Cq@@9RIl@?U(nauWZ)nxccj)d_+yE^rVxxvGTX{8L9D6yYJD z?W!Km9~jDq%BWt}xp8Hc7mu523zRbvyEgu?o&vGq@y z+VfjyLo)Bw+)d9xVGjHXn5bL#-xhZFS%?&H6=le{eBAygAI-Yf4+C=fe+=!G0(alx zh)S26s8kJp>+HZfrf=}Mkg#8vIxsrdwAx*?&Mtd<*TYB=UyW_{IgA(8u8(u(;{!j_ zyZVtl4Q%~de&{DrMOsCE_{W{+jOszS^JzetR$-W|>Q(AgKv zYfBQalJ>2N0N9ECnl(Cq;OZN5o^WY4X~E2Ct}zjzT)tZ zztSfD(io72c zR#wMQwrVr3D(K<2^?K}jG>`C0)jTOl@^vRD(c+vh z0=gZWMB#Af+PGD|e(qo-)D5FNpbIFAz>*~Cr+J%g$0*+Dxix-eMF+wI1y?;U82O>z zGj6bXuU_%y)%ImkJK2?_mhb-_(H|OV7->q)`18vs;cSy_OPO6w9m!-Z?w+(|ZB^^= z)r}4N(sTR9_R)8%u&WqjndHRZA`<{s1;F~PTVH)6BdVQxiPH&shzZGrK*JJ9p^=WWH;SmNWWf%1+|znkz_ ze6AqIycH}t9f7l{f3_FeM8z!Auw^~T!pP*t_Pmug>THkm(+c`ai?plO*W?!P36>)5 zpg5k0Ba$k!b(Ft#6NvCAf|I-&QwMQVyPS5Mf!%xqo%F8*{}>q?!%wOz$*qJ*DL+Qd zWzg1c9HmEmTR9TTt`4rMSyf}Bd~ZRlKcC8?IwXW^R8TX`GvobXeVCXJFHW9YhNoXwX#$7CxK6pPYaV~Nl8?w33iEj=4h05 z#kthUOAXJNqfYXdt@a6*KgOUyOe7sbs)Jv-&jYyohmKtR-ovvki3?6NRtE@=6E%h1zS!W1!0b#G z^}Rp;umsb@xY?Y-Fx0E>Fedq-8{4e>ntUaVwwfxbuHyU7CSHO)o(eRNKu{W)r6NN> zlRLoToCazJ?lqj`kCJ6oE*^-6mFe7XdOcByp43=$HSF=2^+86nIZLP(py*OtIsrnV zacm`3%};Ah@t8*uz3^^K8=VA#y}%N_emCx80^x+s*szL)u7Xi|!1pkOh{ zZ$W3kFnd;@%dZ7`60`luSMRi)nMQ;@*Uo*t; z#U8yM-CXmHI=#g}3dc)~zqkDjpC|puK}14-ZXc^fo2jqdM48nPt*mQgA>E5T0zX zpYU+LX$*U}0O!xlW2K^CdD^tNrkPETrECwhmfDO}c>6=n#9PCqvru^|@G+$+A4i!l z^nm7Nwkc_|N5Y?b^+5FC`75loa!z!hOtN8F+w*Jlt(>bve3kD%XPn+vX%@QIZd`4F zfv8E726aCb%-mkR$j2`eup)4x=Qa=r4_C|yr{;{#uQbqd*dKUj`)-_nh~1OA%M~tb zdCRaoBIRPT2vJ{CY=^_2*wdx?5uQOB`}Fl5SUB&L7q^0~;>@D3L)6hG5A*5^O5X)p z^bG#76Z59`aCmp;r>^;!4vO3XW%kM;DGKT2XAl${1a90ZYciJv-ge&km9tb$^t^TR*I^Ww%bd8{v5SooYP}W+zkirjn>s=*qU%D2 z0KFczGZ3CBTAYdD9+P1uY@CoEvo%!= z-2r9fxAWJ3C}CD>iVWS1)d9Ct4P?3AilKPnn1e+!tti6uoy4pwgj%L}Rd<4!6g=WD zz1BT3+1>Y6J`_DAI6amZsGx+Km}CZjG~4>xBBy0-*RGKc%cG`=9JcuPf4D$-k3Za_ zFiZ*$bao6hQ?31asHxbO)%D`Vs2(wj2WgVub6uby9R_=fEklxQDh|%sL`1lfQZXxg zUx}BZURtP_otjM}gO-|<*935Blp4jvyhYoXWAnff{O@&0JqwaLXJSy*Utn z3v(K0Q1=d?GdpSAlH!yam>K3(-0qH3-WIdCkdswn!6X***!@9%9YbvKfP)>4tZGMP zjz!4$5u=LG8 zDnz+y5~isemrIjFyN>#d+KW*%h#cp*G+0hhQzML3ev25gfSEJZuq{d2!STkU+pIrf zdoa}DvJ9tohwKmWGE-ivqz#o3Z;wrwvrPWP`C)NI2Un2##9c`fzucA!Vc6E*G_8#8 zM0ieU<~bci7UaJ9&PT+MSbAY5Vb7$QW_08wtQ#sgw4UD%4jWXPSigGr zCKWkO%A*p$pVxg`slwtrwg_L-u>RsJ)43XrWHvpUnyBxuAo;HuYyJ{TT}#CvJl|=@1@tgiK;*O3 zpe)S?^(R+5!RbLtT&_g7-SkpDl1E2|GX4-35WgaI7zC*C`UR>Y(2wy|dgG){X4&D_ z3!RpCPgp0r5cQRCgIm1*soUw8-ph%OC1+k|LD{SUkwTH|Vz#7dONeu{mzte+f#>Aa za&%<<>B~!e?LbLJ7q}~Szg52vHJhAp;v(2120!X zUNGX0GiEjWuOrv6xvnPL0(I6>aJg|9=u$I zH@~COUs)e!So>aq@Z8d>H}Mf4pi|7fI`e+Kw&UvQ>oXCc4;>n!EXksRVxuAbU721a z(Ph6dg$=qi6*JU8gx?qFcfCL+1DoTYlJrq(;JMYkS5ri-mE)~tlrss|bNS%nz}l@i z6vJ$#9~rYvL1j?Ls>>~B!`D9ksae2%++p#6qcGyB_%?5BV__EJ1ilHg(EV$)$cyky z5UH12_7uwHdOnFfCt1jk@Jh3s+&UYuXVvj}{_mi)|Br^L-c>6qITh8JNS&AyV@+Up z2(HP_oL-E{K8rcLxz{Zt>4bWsvMcu`_lFG!{}L2r0;?qyg6h?yMz{HWK1oM>CeTEp z{NCzpzYxbap>B9iB6~uGk*<-Hi15G}&aYW9576Hl#?g$x#9Wopa|OQPQL za%)#0lLiLDvqjF$EF-cW#uo^Oe|>CP!1@)0Jj4X)|4JH``o!P>u^?btK9;$<2<$PJ zot7oz+FaF}T0<^hB(fW8h7RV#mV|-aSz};Q*qQd=SKEm@%XWPaF z+LseDnV#PEOaAct5lA1Yk|I{tmPk@K8ik8X&bQjlvxkzL(`i*|I2U%)ULV3Ze8ZG0 z<4Lc4cVte3Kbru_DKOE=-J}@|3QEfH*BzVQIW$QMNwoo{(aa-+6#|tdWWxzZo)^jJ7W@G&|fJb!s^?3A?@F+`Bd^;4}&trmcm!{rctj~~o5Z4P$mUj%@} z_~evi=Ft>@F#{}vx=(z~2@5ety^--`L<&^obi~*b!%;Rr8C2*0s2w9t12wpVA?*(CK%WXlVoRH-3 zJ;MY!F}YR;T1#Q%)I!*yP#PK(uov%q+7uLMLC2*Zow+|=6&VyX7K$W4?sJZT?TTkC z(LSU$8ni|0MyYjrq|jh?CEQNv<&|T>%~o2?2=|DJ{jH>c@R;)xg?xD2T=?;r$N*Dd z-j@T?%LrVO8~f?5X;`{B9|C!Dz`Nz|hFf3@|vS2d%BB zO1Sb{PUJDDQ+n6bq8=*}doP84zlHD+(nWg>_xMKK4rh|Z7vY;2(IZ2Bd8E~He3r;V zXCVQ(;HuZU(N;^d?*eZIy_L9LQW?Jwco5el6^Eq|4y_Z%Cx2~zhQm)(18@B&S)#C{ zySY`MS;G-nkyHfwZ$Il*(Lu+e`mCk(~XyYuRW;>*KZ!dcFBcXsk`}&=Qc6BFQ zaAS(0AHe9Jhjw3}s%HZAFH6pVHegyMQVxdsre{grW35AE*5$~R>nkN@9CO^(rkI`H zq+;oPu5ERA4JB_6MMb~$Q;D!e(0Q6ICEGBFbgZcDYsHWc!=q!Hc~%~ z4gGapvEazfzLd25TPLwB8mO*=h!#d|WEs6e3S!FV3 z?o?5?FG0=qs}eTKO@SQ$w2Yj*^_Q2+I`RH?oi84=u~wz{!k*&!F8DWJC51RZ3LoF2b63qZE7nn#kuE)l z3wDbN|D>Mj;vlB~j;XikPEXPqh(%t0^?{EiuwqB~vGY9~XHRpsJKFfgXsngYrRomL zbbcyOUO7HVGQNn4!>m+cLNkq!<35b=exr=B)$X{Qao%OJwCs* z`h>G3XNme~7+t#TviOT%4Et9eO?I(VZW~`+mt4ZIFV>JQA{voTLYAZOq9AFjLHA1^ ze)s>IZ_tAkc|JeCM?-(PgaPRm7bK`m#3W~Wsg3*P<3+#4m-^H&x1^&rN_34bg^85c zdM&)K17S?oRhlL6C*jvsNJ(a;>5V8x$>UO6?w=Rw8NG$D*JXG9{Mq`o4Cuh#X=%H( z@P=lOFIh?c!fn%HnEOE@RQZ&W%-4`cDUT<+@ToLPe$}ZgSaCw)p_&zu4-dFQu{+;S zS+34=#9lC}@k{$F#n!HfQATd%T?Dc|nnJ>jpa1YqQjO zU1J$vQX2Hs!IhkM>I{?sN35;ZWJ7l^f$<)t`-R;wS*L6XhQjPK)oy9{vnFNmPv^)L z&TVWlWI`kiQZtVJhB9;xx%pWuVl|)Ovqmr8K7>aKtjIZ>?xcJPc+LTkBr#oNPJ#i>tQI_>#_(ol&0$mkHX*#WxNR9=hc+3Oyya$j$lc(f>PN7F zW|EjbZFhCPpY#PT@<>vOu_{xNBll$<2M~6mZZ%q&u5a(kD5z1=Ty3{d!Vg>guO|H4 zTr~vKF7X0WnqWTqtN`KBq^8oJ&i9iEaP)@z=jWZCT0^OE_Xn~fy@`be==YomgzVK3->D8R2RER2?(;i8cb-JiU zcuc9rttO02Bid@K>C}>%B@dWY<1X2kwE>(V@7$LdK`%tSm}Jd%checK%eg}%m!s8-kj9|af)&2YS_3)ZH4Kc~br~QNE zDp1K5I(cM8_fS`c1&XWpHX-39A))BiXPNqcMSA!Hyw{^5=Z`G)4O`rf9svZ$mhE#6mW{2@Vbh>{?R--8=>c4JQO&qlpQki|D17&Us^GKYxcm z_XPZ{hs)I0Bl5A~spavR7@!b+b{;GG=M1lb%4}?D1C$&48lNEtxZO%XvnHQZXJwPLl;`djHq+i(gmm4qFRC`#mVx zZXsfSc+d6o=VXyW=8n=Au!wO9Gqo>Be&sW|6{)UcAv|OdWag%AKjqw+h1ScExTFT; z2uw_%=NA7;WaKYm$C~90wFN~BDiELI0F;g=Uu^7oI^Cb=#U*JIX1K6kzLuCk@=zX1 z%%h0;oxLx$hx;52+oVuoH4Q6tG*SsHA~M#9!DgSgqYoI@ciH2Sk2kW=Ui$7(0q>}` zch`+=Tl>0OXcCEy1fUWQ3qW{4^jJo1Jx9vy9IkPs)`})kxW%ze3l8llV@h>}4|8>_ z!59muG_~vp$f(Fc+oB<;5FOftxGIj;XMy(L8$Hi=#^0w#IDXDs@!fjfl$z|+1w8$en!ff=z))HXD&u~Y-xkj`QybapIBR`s{aAIFugpyq4^!X6)PNtW9tn$bcE z(?Y(;S-1#d6XIXjk0U$e>B>q$W00*Z%(}*#Me&5&RPTQ|!ygibmROlVG`S8{H^xGD z8=6gEWX577y*#PHO4aoH^X}*6P$agsk8Mo&BmgXCdP4MSFVI9`6CxiH@U?L1*9n=H z)8MoeBYT(2dK$UCV{vvIX$L#a8gVG|y_aiOQf+91etsk%>~E*1%^iFRoi;9l!JNPx|E%A-i5* zqH^R1aY1I{RT>Nckf5-Pr6%7=6+`N8e1MYN{w{L>Q_7`#eAdL98O;i3-U}hV&0_&y ztP{uw@1Hd5w9n!-@Lg$Sh&b0z9(h_P=Le3iI>Zk-Rj5~%di}O27yoO+mx7qSzO}haOLLZBB_x{@%Ph8C3&ImRmzQd; zgXuWLHl@g+pYoQ|M4}UKOMYtLk^0z<`^T7p3LS^5y{jj4tK$1CD&)J6rqHs_n$q7O zJVaD)b=qkLFY$m*)Oe+Mo&9E|;EH!R$gI^$D{{?Ia2&-853m%n?vd-0>eYd0r)uoXQr z(#K0ENDEt5B6Cqg6xQj4ey=O#YJ&COUZ5_0=5G&GRQ7f&!a{_Hm16$Z;IMAo;1k?Ml%C-L6KYjheg0w7F6LiPai*iotulF|Y;JUEX(x(&F zHsHB)?Gin+Q^|q4=ujl{tLs`@P+vDE%|TN0GLbv(_uNZSRT(V0ypkfg^h~BZVFu$k%^&V%y%I@xnqlCO4F;CL*l$ zQ8Dc%r;xD(vo8?&0KrijUBpMp?5M^(SYe}?LYnam465IDYiRJvn6c$9_#-dfwOA#e z>UKUEQq$Q2ZYuMnF{NTF2YpGuC|FStHlnhNUIZ{Eg1{H5T31rFqbd zQtfq!X!rN4B1DsRnu+#Y#z>dj021{|qQ&$9P;e-Cx7C2B3H+2s6tk4c;yLSc2oD|A z$ywd=CaAW7s%fu=icyQu3@b4aQb+SKY053m?bj(O&k&j-9#g60n3(8Rm!@Wz#%Va^ zh)zh5c87HOx(Br+e%m+IdUoz`1F*aJZ$tQVV?9UX%Ni*_Z&*h_vVMMqQs1|L{Ep{v z1wA=R61VQ8?&%2~@0w2O4+a%FLfhocQ+X0=OI|`>Re2B|UT`s}Ki@a(x?>?#zjgJm z`9??5T}!2Y`qPPw!lZq%=-atCc~7GW;93m)`>P$A=n)`Ih>I3wo^K6^cxl#mFBF+= zVCYP>6HqX&(z9}wH8?fJ*r?BQ5bl)4(4enU=lS2p%UtXX#i#SOMrd|{cFQ~D;=c!c z=_edkj$tBmC<&v3F{v$($M5MjL*ZWdsm^L zJ+FqfYhOzuQ9NJ^8792dX;{?ap#m&dzQf!%0shDofrjy)d?80hxegoTBHn(H z4mus7{e(PJRIX#l|I><_tc8<@Ug|bR5zqI-r|UeTmsk*sIZPfHnmZtRFEtBYx`?98 z+>o;o;n4sKUipX}X|Rrlm>udMv!nV2D&CP|8ZIvIy3&6&G&eATaITh}uK-R#^?|ob z@Au`HtZ4XbFUwbmHazQ1*$$6y`2mB{l1IRj81ge!m7Oa51f0kBI>lU-RW)z{mqX@S z>4PR&P&MXT5__b)1Z+kg<*71zA2aKk)(FM{o7Xx^f&;RYKfTdF{s@l+m=g4OT4njaVH^Q%8g6x&QlY+^u?a8?itW#Drn9;VfCfRZqJ=+lnT z!=c-{0X_u3Pw09OeKSfh;uF@u=Xfg!1glSIA@WU_wC7=;jb7I|y*_$J6w#P9Js)@9Z=ZcA0KlmwOUX5lJ z3i0DjI@Z}mUZriK8BIB!#2t(5`#eez)C!KhHP&5eJpdGwy8+=L1Pf{88!V#Nz9{4q zA~vH34E1rLqn^$y;$pJXSMbUGpfgfL0VWd=)io&Sfd?P0j&W9Y(D~#TVpFY!t(@VH zGq>L7Ew0Lxf&{t!6-TFpXyRseoZK0{^`A_G@Yr-)p4YyX zZi$0Q74o4g5%rVb>?QsomSQlNl?k726aM{K{ECM8tiJ9p=66m>(mlDt54uGc4+zO? zcLmO0ercYu{xPM&{S^DHP^dK(eGXTuw-PE<6tps;b;i#ZKm z-v2H&(x18Ae<3`qU>=^tfbj^Av-NDw(Mu`~VyiOC%gN`Z6|yt^P$b^j8}aYy?@#&1 zbKBJ;OQ@}XFNHKz>WSfT>@}lCD!(eXT?l z3a2+&q`7#6OAP}}xR~gn>yv&CJsRK-GR+e#B-u=70=}B(4)|%`zeQD2j{Yr2c!Z&Y z+XF_v9}|pZ#>)!~4ZfLLnA$C|uCKixOE%qKZ)pGg;zQsA{0Y86IrZ7Xp4K(@&?#|g z2(>;9R|7plnIV;HKr()1kfQ%oBn~#?*dMhgC9JPlDo$KbJk8@C5L4fqH4ncs7$45W zyj3WkGY6XRh$LfQy#81QsPi9x;W#;q1!4vo$IEQ+4kA1t@B(RTet$SrNw)2M`c>{3 z3|I253r{)l4FKfz5ENCuG%t7%ck@K z_)^(oy_Kpaaj|>~d&a9-#V6$E*KkqyU?%xA)r$L>FSgp74|V{EREFba+bJDYP17(V z>CKHyH5ZMu8s6f?^ z`WI%0wBd#Z2{R-1niozR{XeiIeAZYU0?sxLLTb>Dw7V`pwadz)KkV~dc;#A~@L_?& z=hds_iAYBp?_bT#uJ+u|RKNWOMutzJ9^#& zy%;US$FURe^CF712>c6pA3F=tKcUUxeIk3_@zY)1u4E>poYKimtwbHzrijHK>4mC4$OQFLn=MG;)RZ17SDCyZBy?X9eG4sf>-fyL0ubaxnG;2QvgI;b zWidn2ApGrP97AzsupvQy%nLJmfIL0zbFNia6HB(RJe)M=9m2Fw#k^$AaD(Q@am4-lvt{Ezo=6XonDP`w~$8W zWZw6w3+NR2-ob?5Sehb_?^ltvb?a{UyygZgRk#pNTh17hL(XJ75=OwqKO<_#+*+Rf-VKq9&MGD>W&UP$O6{LzzdApOz zw%m1_+^%gfksL{n*0Oqq)}WIGl{6$3TJ6a03wHt!)L~w5Ae}1%|P8h#By#($#(EO-M-o zr-$ax-!@eG0?`)ttM9n6T`O_%#}zD@G=yOJ-wpjpdwaXs=vH>V5pRi>IzoUl*z(#{ zFi=g3beWmFH1SpwwO`A7Uj9deX;=T@pQ~6sjoid5?$nZ(Mq5in>n|xhtZ86JEb-dr z(lIAXJd<~s5eSb8y9{<0SbFqRPKE7u@f(&^w{*fYtGKqYU$vxUf^l!YZ8HqGMjV20 z!8&+US@gZWk$;1EuRh&wR?e)xF_qipD#Ey+hN2;%`>BsrQ!`B^y_34E^naFrGaUfO zZz&~CD3xs1Hr9_1Hhr9wEePDE-qcAJV;tV%`@w&jGdrOW3nNmgnQoGf;!OWnkD>+B z4-9AWg-+9F_I^Y(78bCzmjnjNzl8G>8P6#TopB3s`K&1AjZ7()Sc-ngtiEJkDgCP9Vttj9|qXamS2ndtr=8)Iw<;U4z? z0L(p>R}(1JB`YjcA2T^R+|OZ7Gx5HR*9g^CTP~p#Xqu|xyLX*jS;2{dB=-FUO;wF56`*4`*! z{rja?Q>dOpp-Uv};t1pok;4KBvBcGXO}gv8?qHgB820tBz3vvsNnt;_IB=LnQ?#ni zOLm;N7;0^$aLmf~9i3qE>5U0?J7arX|1_s3PcJ~XAeEf+D(&hFCDK|?`}OirFi}gN zW&&bE8=vvO%si`%Dbs2H>(%fGh?oHi-?` z^YTM8IT|Dn6dCVafG1FW-lSY?4^CJA-O{SCE}3$f4dHPHg(*Um=6Rkg^nR%;f8w1q zRG9;~?%%`hC_oYa5}Bk-2bLNfUUB~llJnFGV58nRkDHt=Og08xDwQET1mFqbPx<{} z0qurt%TtFK3;?Ft2?4$HSH}2^dW!5je|+uC(;aecSfR%u=o<7nTCWXe%WxePgCtaY zmsu}s=-&M?KGjW&wY1likWj0{a>*`G%dER|8Yn9;DmtL4C^P5gEV?2@4eqcDAFW0s zE6Ff!YZ59dl?SE75rJfEv-JGf=k)kyKRO(0Av`qTJ-ccnKV?qFJdouu>`lQ1@v4VA zu`kWaenk>)yQ1y(9oC2tJcR4NIwN}^ppl@gdp!Guobzl*4*qf3zP7qJ$# zV`A9tl{l{#I#Q<)|dKFQZ;#^dUcAmi;Twbh9>jo3=O~(5&zz?lMbai3zM@A*p%3o${J)F>1DuZ!)@XN zKzL}ujSI!k6Y`8nAfy3rCXG(pp4HyF)v7oAuW;P^$HS2|l)-ueBUGC#&V;oJ4kzNS zW({K-htpXd@LzFpYXh9T+=CB?MFIf~=Q!4KOszXXvpQc8|{2^Bi{V;V0c zmBBK$J4a1N=(`390Lc;R{3odr2|%YH$b*6%G^0&{LgDaxN1bS~Eq6y-=DeYIAJFPO6K;$C{{=4sGw2g~tGw1Pxr|^WhQle_l6C?uR z|1IXjipIdP68rW$!>x&-x#h5HP53&Js-DRbFvVfF~Xb3G9-C_zqWYHlfVpI zzv0Is!N2?sQ?^qVY_L1bM3ZzaY`X{xXVaQEap4*{N$SJ(8?tmHEHNyOR2}6|w7HqY z$0XBi9P#MgJgt40;Jnds>n*qYORLK>%)uL<++5f~n>#=(<1R(29eyPo~E74<&b{JJH4qN}J~Z)TS!%*%PR-=Anh9V@5Q1yI z$K@4Dw-gkTymqPmk;}hW>j4*yiXn9cdrUxa_))O6EsjeiiLTO9W}`OTf^(IGhmMYV z>iFcw z2{<-|+^-LZsu^1p71zyxi`HQ&7pfC?)DyjH}=~UgpG|y_Y&?9GCTlz0II7>m}m&~bu`?E9V2lCbB}&a zq>4?ZbHy~3_0MdQ_;#7%c$vI?ZYv*#Gdl3z?$xRkT5e{B|10+no~?iN4O$vx=J}oh zC2V^mYZJ%fU0D)3E^LWJlalf2x{at`xOG%oa{e6`FA{s%ue_xj!wvAMX)vVe%}Fq& z0=E9^zd!#S7YxN=<@#WzcKd)El)rfN5mdctz>U^x54$j}&`OCyqw%^rNHGZY2vyZw zGfY<=J-n`N!PCHZuD0rIv0~F^Sg|M^z~{8OZbIY(1+SY8J^QIJGhc*gi0mog^7xk$ zX#k46fJf6TXri3#Uq-_hWM*Sirfum_naP&F!Yf?{UKBD%_|yNQ`)IvA#F3_xUI}s7 z{TsF~_x0GL`H4h=*`ni1vY`Z!nz0>kls*|`&YdK?#r|Vl<4=d@rj{nxU&b(!x2TV< z26P>xFM92q?L^ZYDzE$05gs9MG39^z-HJvhd~fl+s@A85zr&4onjk3*a<@3bTMadWjtm4a(m0l_2Z}SQTX($>5n9U zm+Ow+t6X_ZNv`3DlzSmkjUMttE<0%T_vJ zG-tajM9}ot+IsGg9Pecw_KsP&_|229G)Oao*&cVihD!6XSA3oFGa?@&uwr&&uAf|I zI`1E&=9c+Pwwm5=MQqLVmOh8o=<{zLi;#buQwLLt>jM=OffBH2R~)UpcklHYdF>~W zE?c7)Nrw{jlqT0g^0FVT3f}I1rne59e*Nd8dl@b*-8-EhPl;*gJ5LT16BNftz^Px| zi|n-x3vV9UpfbEevz)2&@L@{WQ6ei74Hq9C!s86C#twV*8Rn8!{_GFz$x~v`;kWal ztxr>%U7h%dg|lQMBTt@et<{owH6+tsGxw z4#pW~yFE>hKPAPz2tO&Xs$s&eDy#6+5LMRbO0Xc7vQbh%cA2-%{>r&Ou{14qE<5*U zU34K?5%@lD9MS-UUL!n#)cVC~xxUfqj0d;3+U@Vjlhfoq*7D`MswkeG$0ehzrFimF z66s~b02Wj)*Y`$!f$fdZ#h6ytBs86E+ZH?CCDGXSm~6wF!6dyxb0K_%j4f^ze@&Nx zKG6`|J>+1bLnJhCYClgFZr2$q>LEcQGYig>J;Co~5Ej^WoDpe&xPwPU=xs#_wEA1@!`z!EIh~dL+#k^jwxwO~FM6sK0Ew4;O1l60x zYJQ3zb9H#q5W!=xec~5VqWR#ybz(^z8;`Bq7%20;%h<4zXkOfVOdNgi!%lXVdVVBv zKoj~SwMLPas(JL+683GChk63tSIEVFgDgS9>e-hMsvON@ow`tIf zi;Ly%@z#bftaB4$HdwLnzQ0?ofd}S(6MLR~>ZlsXxc$YAJ`_iQ9=)SZn0)$Ilq6FM z$0xC-A3LJaJl8D_n4eQbCxeNp&lUNvKITLB$kR*X8$p;OC}Ba_08j{X!mg9|{ao;~M1GOSpbu8qd|CKV)S081N{kC;6_L0#CKVof z>fKVwG5pi45QNCb8w_P0x$lq2MvBPkCR#odp1_I4!hKttRw}rFQIdqNV2W#`5o^iX z=d!BNah!2x%92rhsF~gMyv1<8U7qwQQiE| zIJMeY!aS4@lZ7LWi==GW`Hpdi-}4QJhPHlXPPV-N94d)I4X+@`9gI(gjVU6D@I--= zLV67P6KRmFn7s0A4K}x@&F1D|$VKIu?=`KQ#H_QMqd?GNk+T6M&*2a$_3%ic0aoaV zXPAsy(L7Ll3j3D#wT^zV6i|C8vheD$%4V{t?7GXZukgiqMCIDMsx#CYnLZS3ec`0k z{$xgvABk#ZspH&J`i$myd5&%i?7K9C49kngr03Mq|N1M7O7E5Q!}h!sbDSs-|SuQ7Pvgl}GJ+H44$Olm-}(bhRNQj)BX8nQ6p z7>Z;uHjHBM2@k%&`7(O|x}lHAr;eJi+B9`Ok-FuYL$5?YF$6YLuWoNq$x$W8*N%oYjSPK zr?~5m@d)j<2%deO^Ohvb()Y;kXdY2-X31c>DWU9YpPiUK{8*~{$Q&;6Q{y*M9I5Oc zeG<`H#u(YX6!vvYDZB!f>V-S6$mdigU=^Bl`Qw1Q>VtrJuREtesrPh= zCoC)BIYM0OW1_ZbAiM$^^)j`??%MiZ%)Z%8+_e4s(L`AdEkSIzvH0W~!m~!ny1@?E zix4@LnBd>Jar^y_obgOqGAOI$P5!G!Q@S}dk_+SH1rA?dFaW@ERLTj%*(P#OHt-PNQ^BMQdG}*hHhy50zjY<&2Zr-zq6j09olas8ye$?q7$!=l?MIj$Zkgl? z-SYdq*JS--CD9Q);gOWE2)VHwnPh~)z-zY>3ozIyE!Dm*V-X8CELqMH?vW-(YTyIR zgnqiMYL|%nvwuAk>882%ASkEh^x|f@FcW`^S3biynh#5$5c)+k|D%SFcH(53xA}KS zI5HDN;OV=NkYc3z7s7HvOaKpP?bxD)2|O6u^ZSXLD5}%(mn@kx)pviRb_yt9=LV&g zKhpH}DIs>&LgQkqxGZj)?G*yV3&MtaWTt^GR zr~j)8gZYjCFRn2Ac@Xlwn5ab~5VoC#hgML@%F?{rVVAcvwp+v#G#|Xn-G9jEITLG3F{ zZ1oY>C6S3|tyvm_6Z?_i9s(L4oJhdH;5<1Qlg96A9?JAdZkkq%E&1BD`B!-0Z{h0? z1ZzNgLPDuj00c?6FQZI;&^n-%RolguzMR8(M}DE3;z!p{(e_12WCuYQ?8KK=G>5Dp zL(dacCx5o5J1iz$Q0WgwTp}@T&}PX%k?7*dmV2>N8=QbK8A^FF5;d;uc>5yLLCQ`CLQGHa@^dxJiIJ|K%o(i!f-0d>~Sj57kg;`m zOYo6hAzfGIY8GJ;GRoGV@0g&89wxNnN2k~EEZdDKgZE09JVKrVTm87}tTZCE>qy?@oK3XO*i&=B(7dCRV^CM7N+OxNG zY>baZIZxvMkH^5j!=xX1vpESTOwrzO3jnrV%DOBlkCdDw?yPQb9S;68`5NOXi?tsWyEE zRrcXZ*O<`fbQCCh?q40I1-B232J+0%@tB_$l>p3g8o@imf+0~<$^5_N|MCZz>60e0 zhNX-@lu>aRxCl7H!kR~9zzYgT&5Ntf&tmocwdK{Q`g4kfk-L7HDak{bQ0IPY&-cEo zb!sX1`Jh~o?MU&%h34)~6QP~}RyMIW%yHhBg6&+J(^==8yt1+9bm#2XJ8tp!rTWAG zp-6=ByQC4@SV@dZZQjhomA29vEWWS`B- zNdX+;_?21pm7{TzICcZe>y0E6aNAcI(x&92exMm9T4d{7Cgd5zfKe85K?Hmq;Lee^ z{h$Vgq$~y@^fZ!TqEgR_N8tN`9Lc9;r5lgw z+u*f_>-jrk&$n>OnB933?%|+C@JRv8p~=|A;M%D+^fMFLV1cXwpob$J3>k^Ny7xBv z?5_z^@Dcf>Luah>I@7qx%UiX*% z@`8KlsqkIvz3KJ!cFep0%P4}TP0kP74d|A+i*03Q- zbk8{CWDJUL?56CFmC!UhTGg%e$h-Gd{WxofM4d7sG-cBEW+fHw;ROmi)O8O`Wo$*) z^Um|^CK&J>CRD^3WkVc}l}+rFUpNF?R+pZhpE7px z-Eo(inwHHSmP01LEqS$3?`n#28U{uP^Jm#8sgIb{j@h&B0OBNhi&t+Pu^>mM?tcza z4nX#Jvg%d(IkjhDvP>C~b%hO?N-!rF+#^dx+dZ1=H8%YYY;vRRq128-v;-}puyi-s zJayAutvNp3z|X-gT+iyxT@850=*^T4j=DmlYDrD=FFkN-7f>LtiiqmsWLJ3afDv%$ z{Du>OzmtkB-q%iE6}QKib@S0CZez0892uLIwEBnR#ut;@ZUw1xC-ki!rw_67F>_-Q zhPgKX%?>yovJkjOld_Ov#@{=9(<(fL?4a}uc?{czllHglU3>Opn07v7!IC1AKle9! z=gs0Xl=6d{I)3R@Wa`w=nb$RcviV;HP(`m|evN(Ij{HPM7yR!vMh0}m=*xkmDnD(k=5{y&c` zFiT`K*9Y3>LR=f9kH-|YyK^-LqATOJ4 z3ZZg-W-PcT6X-xO)2%Sry~gmNM6H^=Lrqg{aPlKo?`}m?jZWcIz{1b_t)J%s6SW12 z8N|l-8bj`P&po^x5HCA5GEDTyI=N6qeW{)@jVY7}JfQMM`Y$2_Z5FO**R_DOalAwp ztT69Y)d^Xilj*x$CMK~CHprC>wnW`>$)SMgo}s`d4-dJ`;PkLmuY;~N{{KF5DZMJE}L z!$RCg%;D&j9O5V_Z?dTx%2HO@_FJLz07%=5MS`GjILi#$D@zav>L4Y$&GfA_&sa?T z5G>1c7P$!<^w7lqp5SZQzw0Xajugw!s+M{?Kgj#5ap#r~7<;~7!UpHES$@EVHa)lg z%g+BiD-<&h8BhIk693gs7y%!~5ChUKjK{ZHS6i#T39C_! zt2*&lrd%$u>%v7VRJ)sL%g100x7xKweM>w=H`IgOQXHxAi3HD->ujz;@wCN)R0`qHr>@RFtR% z3`P_y3DgR=#|bSuR|+?wncgB9Tnv7)rGfMaCrA2@G!l6X5^t9NLK?iEb#?CMGzL@1 zcQQ~lqrem`$CHYf0VPs0?a%>bKu)37R2bZIPMw4q*4-EG{ez9SKDw?Fd48+J+UBLI zLRnHpmKXkqt@3{lD%d0t5#M8O_z4P*BG}frAGO2N6rpdmp+Ar(QPZYy=uB_q>4B|MJSPU_xkC@4OIHR(Xq|Kv`NsFQ>s4i43x*F~LN>G_VeTYxY81!2y z(hDCAj71LBSMGFKxDqrQb|;n%9yq<_m)s>@fo~;TY-h2* zHiUB(Ei4=%(BTTQo^FZ$k=8138;CieT~kUkyw62vVE&3#iC6_OnQ6l>xip&#(D*5& zE$B{#?hA8_cR7nNJ(x;LjFrp)VR2pIj6Sk?jC0YNR`-hOj(R?!M4mSRY8145>K?oB zE=@Di!g%L{ejK#a#z|XYn8m9FrkOYn_uRjx8RH_@L&bNM7<$_HD}URYsP~o$7rEr; z%_m6Lsqj8P(c;^50d!jpOrJ|tx4eE9bBy`D%&`>Oz_j(|&G#zjopgT0ddvt@oj6dIy>*y8 z3&RZ$XzI>{ss8i8=t3yy0H>(>5guD52g#Y%*A_6Gcfzlf7bXx`2=gO|f&!7fOrkJ% zJLZtuK^BMzZSi)56zR~21I@B$QFPn^#8YpTBRz|a^r&WnWou2;o576$YC@T*l+kRU z=`HDI@>Py&;GL)LP?PDrSjo(ne?A6QHQSJzsGiD9U^0TA7zZxj#cCEGsGf)UQcN8 zwT5z?%s9T{T5M&Y#$3HM0~)l34L6>#>VJ7ikZ5 zXawy2nKW*Ac|W#~o>C+i`my5Fb`J*-K5i5YX}zao>)C>Pu3q1pumSc^jrn0Mtv0rg zKlA3C&t#F4a}RG94?V-6*U&~ zuzk0dUscTm1~pvZb$=IAr-OTL!IWc6fL*!Nadb2RwMhRrD6@TBfTqRy{?g${HWWfI z2|7SB?5KfYSDwjj!^agZNk&qEZzh9<5?2EA%v=0xAadZ`E}NDz1k7YVz&@Hl=WwyF z{E;I78gOX$HVjIvNI0=+o2$)Vc?S;LdfU$iEB#r#scQKV>1i>hsX!bDtz@cA-MctQ z4dEW{Ii}=35hBzU!BAipli&VUzbB!URbc zDlsw!2AMhMAFOvraRP@5Y?MvqL27Hs>fyHH(DbClN2dnBVH3t^FWdv8^%da)tc2Hq z&s- z^@mYyg>HO&GEQBmmi)Ygm~mNL%V$a8_drY{*C+MJH4uo0k?5^0I6EWPxP-)GyF}j4 zuQ&=}GN0gWa+I~1ENd5SVuyo8U@WK)mly825iY8gbo-^@=>K^%Sk90(cSXh=AE9zH zf>a?>OalXlY+KAU^fwCXS|1>mLzh|*85OJ6o|{a}i^Ck!&{VqZD>R@I+TLEie&@+F zI%Ls6`Ny;F+MciaovR-q<-*3P>fXRNOmEA9Z(hIeuqW$Rsh_Qz67eyldgImVzYaK9 zb>96P^u2#+`V{|52kuGWT|>41wm0!tY$a)E<_m{DkA0H$DuR6mK1t5dGwcnl#rE+Q z7CYAJxbm=i+CR9{tHokhrw#UMtB&08P735=W=3uh29}(trR+C+w{lgmPuKpTAK;Bh-Q(fQ3$7rs8q{2_le&nKO-6WGuXpD z(yV(D_1&XkN!9Pw6@9T`Y#Q28ovxl1nr{?dlxODp8}fY3FFs%1)t3& z>a-t1vCMz3WI}7TDcnATI5{N;DX<7d(o*q4J3UMoFJO626nSfRO0P9bj@Uw7(YTQ@ z#sLGiNI}2lY~8X%Rx1Gph1d}x6<;C|nWn{pP$6N&m@QeDa1ROC)gt55+$)(HaH${Us$cr$s=X}ul8)YnpEi&Rz$S_2wC9SI zjBAxZbpmWk-g_JrX_LxJhG#*bQo%%GQs>W2v#sH$Gr5>IMJZJ1Fe>l;r%{|0ESlZ*ijLzY^=;(44!6F;?dlujMSl<3k3js?7(m zs82G7O)jc{Aby_tn3#Bm=FZB~AUcjnJjfz`uqz}mNs!Og9N0Y-Np`dZ_<6XBf`Vl( zDeVA?tT|(l3nQnzM?FvG|6j>ezXG2he6TyEX!|A(v3%`NddOCclpN@0@s2?=_ z^g4@IDgQzI$#G9k_ZbB%$fit75;f-hy8d}+8aJB&cmz3V3KWqA$ja)7U@#sQJvd}j z!AoN<4D>sEGLaC(xg^uS{fH}jiOD}fBNrQ0XZR5bi;q!Hhmu3x^3eClv^-Ls$9&Lr zo+x$9CP9Or;psB0HPu1BOQEXUUn7Q~b?S=&-qm`TY_Zm_QXg}y44u`D<`%hWbTB@* z(cCZJoVCTL5+b;V2$;CJXy7BW`2layhT(55%guh5hkNHo+t#tnRs8bXC7#Gcsh@id zkiUtEtysfvZpr*!YSo0gxaV_uIvkoaqXTrRUia#w)bs~I=Lc%>iJ6ivEoSLFz`r)9 zD&4uMdv2?mN6M5=YO6;!%LWalG|mA+x$|_ThaKs+V0ww#690yoPt1n#C(^A6ATO@%6Z~I?X<(lHs(riwQn{9ax^<`;Yk3a=nP9b@S zZ51R_<8Nqd%|yz|S!pwCo013vPEWt_T`_rNnX_6smT{!^(afu4?3HMe^Tom5MOiDX zkIioCL_;>}S-S3MMf)u=+rM9S9Q1s%e}ySNO%NM&8_BR(r7=1D&BuR98CqU(A?I+! zHvaVc@eCdxb)bdCqDemrPtP3eCB@5=egdeE!=ykXgKie7B~ae>?xn_{QCY}JAi6yC z1%Ep{8tojs-};3o$;au>3a`Vwtf#$eVTa&b77`$&X#f{>M>!ptr zrhL`qh9Vb7H{8(#xY^>E)W6IbjXu_w@Gw^nTS*7N{5gUuAPtz45`s;f8iJ=gRv!QtTfq~d zZi%wSjtLgviZC5QR01uyCxp`6ria5C#U9BuxK~r006KA7FNE4^m;4E9zhjTw-STYqG$ig+B=Kdh1Ttie26^ z?e6`g<@kE;xsfJOHvWn}wh$SqMM=x#rnvc-ndBzL-Gj%)Y=xL*uT*_wU1w}^!&0iw zy94gY0A8A8n2Zk}srr&Ek+&Sg4HnL5GYYxBMMSR@qo`r63JM2iaUJ%aV|b5k$9}iT zid)j{%nkJgJI=GhUY5Y|1q%I&Zw1ImL9e~KY{}oFIlXyVE>~3v#c*1)*{3*2*`OC7 z&|E+NJZ|w`dToc-W*+Uv_wyCXorpiv$0QiDvh_EN!PtS^5f1RlNVy9rHkAEvBm zQuq29r1M{j^Fk8{=vovFlO_W_L87hts>20tpIs#;BTlbBv1SCJ|LIdpMWi1q%^mQi zecmCJvC`p3LDO8GZ`c0V)ar&=ZNb`FxdQjJ0#`*QseO?j{3AG~MqytKh$)KAK3Et_ z7#6kTv~-qeKVF+2+uUh5xpQY9k?r$hcnbuSPo~ObFOC`}wb?DP(?nsLVJp7^vAZ$< zB-P;MLB}}Ul&+`6DQ7ztJ{?dZQfJ7f;-;QW7B%Qd#Z=ho^w_BK%NR78_n8`NDr<#p zxtFM&1S>~>?iBd9o;gf;YBJjG9Xe%WuM>R%b6}Wc_FH@KR$jCyXOi(*zNma41}JK3 zAs4Bcnq^kZVuS7F`FHycrZE^86lEqNQ(4qp@MQYcA?1J_#n@t-Vx0NHc9!bP_agLy zP}Zq^R<)_AX1Q-%L+U8H9-HG0sV4TPBYH zCyc)Du$_=RBQoz@_6x{^!Dc-e^Wgb&Nk3~6>pvQS_j9GSgxv^4&+j#tWKwN$-N1d< zsu_nH@B;huZfe}nK+Zc?yHpNGr@#xu1KG)8b}>P1IDu&*we$OTIvF_}gv!e5dO=;xihCb@C;he# zAI>zCn)U6jWl(f33)TMCfq*D#S!(7rby}HMoNQc7e|ZYI(Q2+0<9y8{;huR)4gZ;L z^YHkEFWtEZn^%$MypB!nm8&5ahgynj z(w*eKL&q50~rFDT6)LO?$K8-gdbp%CS*MOH63-*N7wP6`3oMKSkGc*SS) z96l5Tg3*Do<+K#I7|M~taL)zZ4Wje|R8tE?RVsJMoeYWaz!_e*9q6He`+s^au z2BlEAXOmw~16Zs#|DXb4I$FhoVj?6V zsM9y=Ya1tqezA9&0|TzwN!h>72$$H5l@(55({9_;O{!A*lBeBAWU-}7f{tkQO)X7- z)gB0BZ!MxunW^Yp`M@ORSPF>uAt!Q(%;9j4Jk^*$lY}pF8w~b`Gvy!=SJMXCYB@MxQR?uq569CX2nR&RP~NCdq6=tzN+TRZM}i zt9BFp`RHGY%F<$;4FZO7Zb73H-R9=knM8bGj!Lo;m#cH;*KDzZ?6LHH*#OM<@Q)5NY=vWp0^DQkHA=`Ko{P3)`7NV(qx-+gM zX`3nX-V;V@=JMoZ8*LEC=0-`n2X?(Lo}v59V(_d{qQp`N$vCnsWj|qERy}?At^)U% zQTIa!Uo22hFC4$07XFC=hxTMKqFl78&2?=(W!dHsZ>1dq1XklWZj+80wCId#1a_s= z#2HiAN_7O|W)rh#J-6yk9Fma9)f5S2H~SVwh+n^7ra?R?@zJ0>GyHuGz&FX?VE;^m zE&{>?s3^9l*aq7K27&r+$sWpHM9&b(rB@4|Upa+$0r8089y=g&bYHiRoWDe}?HFK( zT-6#N8rtq2HyWI=BcL1+zl3t&EM>u3BRa&+t02L4Lg_LV!0o^a5t3#TG9Sv07wK6z z_AiSK5TAHj7po6ZBzwU`qv(2gKmHQmbx%Fanu<>~SQzlKp(q8;=~+36mE{#CAK7_3 z@`J{hqG#!OgWV(vg-H@Ep_nLs2k!9!5pFi;`XF!0N|lp6bPxkP!I=70isOoot;siD z?6l09Ljc*vgzIDQ{BY5_#zBl?lnBMS@>z1T*x5)gULB^e_OZ?j{X07wx~+G+_a@5; z`!o?N-Ru@1gP#g@Cc!^&s!zXLn7#~5EPA3sMEc4jZz{H)en(QUV8(h8nelN^pr)dD z5wuePMy24MPr#YdobJAamH{G{I0;E)KILg7)KDZ8jLop;j)Z{j5sQSGO_rw54clBUK zT!0A0j5T*ZY<*X7&lkh=P;_M!5oTJX2?jv1_orM(EdT(qJ{W*2PLxa?Zi8S)jX-8V zhS4V8fn`@p9U2sAfQk^9LqI>1&l2(eq2xLQT^y6HEj8@M4ryIEqMSK!we<=z{eT+& zJtnL-CQrd^BGmC7!V>V({%P~9=>wUo*&S!*zx~rJelY}3+k0?e6Y1&R*%BHK z_zr`8&C7a*nSQ$vnH$07)+0Ei=CAboq$HAMKGPeyk7D4_Ob#+ji5V*Qcjm3}e-?l} zR|4E!0sJZN6|4eLkNMEzkXb(kwFjMI2YnT2+WE_0aRuD}n5JT_4Y5xAJf9R-#bUOaK9yTd{ zWWgKyrcNLeKAw!;OCZe=B9iNAFbaqezB@Tl%%pY@N#i3H3Zd+wE32_8)j}cVX{6V} z!R5mcS0@~9sYDN=Wys{F*BL~rBOBy zXSY=*B(jg~B{8dc_R=-8=E$I->-S-BMTa9x(q^+_u=o7EPxaq*Iv|Op^ll}tUi1}EMNX;Yi+4EN}=#0ormBjk$9X1 zPt-tRroc5(C%@bt>GoePF8ezobqtb zTi|s^d#-nAc4lJIbMaFNOezVuLovMvijq5;S%s!8X^oIX zs&Hdmlo^I9i>NvwK}z7`G$m`!uxC1A8UbE%yj^^b^;Rg+*NK`iM#o+oxH zlX;~q=$E$b~pH9b&@oEZ_ zVhlg&%+2}Sj>Tu-tR{Mr!`OOaPSePREUot5)Ml z5g{9P&3I=tiQ|cR;SYRq)j}}eHJaxwv1c{1Pf=gxXa48)3UofI!CG*|QY{r1!1XHJ zY+Disr2Jd?-+IC)${-uBZv&`eiJ4O5d*2dpa7&toE$Y`z%;wo>4}{M49R-Xf@B$;R zy4MuU8@|cAL(y&2gJ}DoeF=Y=Twe?24^8^h=*emxr+F(rkE609p;3jJZ98(MmhZV0 z2{^}@XBqJ^68q+iPz!aYeKtn!Lo;4POhe$1B_Y;C#jx;}cj!%yCS|`jsE7Wme-i)u zeVG}Jqw2A#-4#yOE+4q`?HbhP4{X@IY@}~hj=erlod6YjJIFSPh>nmvR$L&o zfF~j>4$b#h*Wf!4AjvI!0F_g2by#>`s^#5n4yrfS+W{y0enlZ_1;fD@q%&!~)>@jv zdg`M36EzrAuzRpx@J$I#?bQZ6e`reaa@hpJ@rS9FweEMY53Y(I=-JWdPc?2d z>p71PI@Zox%h1ozsQr3f9V|qAM)QMatF%pq^xyAoP`TsOxen$N0Rs6jC5LwtCTS>t zE;J8^6uMyzHCuqWR#MH*e(99%?uszUV1I{*px3CmTUYZ%i^UUhM=HyMF>I0n6-DJt zM0RY`!EjFxa1~Y0XnZ((9EY&(NKIRTl#QGN)#^$E%*22eftjH3UTXT?%2vSFvjxv* z1!YMHfrQ;&NN_>mcJXDFUt2XBQ(;pu*x-87)N||CYH6Q(MN^|g*J7-VEgj~s^~g0@JysvpHMs)_;%QMWodlQD*{j_#;Cgw#&BX9@`Tqd>5# zSH9LDu;%d6Og=f38G`s5#E5`GpB!u$BLp!}Y>aSu@Tn61Z5jJpvUXowRWP(c)@J>W z)*L6YZ0<;gjNFg}$uR>xLB@Jqko=b-bL&Pn=JcR~%fNYIS@|kE>tu>Fy9av>rd5|L z5{t+I*OdCCkIREa_0I+4owsa4irn%N#NCZ(|K^J=vivKx|MmvC_Sn3Pp!zvKm=yyV zQa3fSRE(YFwzHaTqGk`INj(Ct!#D{UCytTQ+;3xLYGcqp(WIM`J0NKx08nv}`R-&_ zQxrhLvh8wTRfXFPmY-s;@G9K0%+@BOpo)gD)mdX%UuJ@n;qJdxooq$umVX@WHlW{) z^TxlDjMFJ%nudi+SgNJK;{#)D>}EngL36U7kwU`Z2I=*iihC2c=V;YdxzK!YwFfr_5)s=ZRhmvbnQPkr z>(`p2#+Vf%*pj+h_jo9rpk6C;u;SXq>wM literal 0 HcmV?d00001 diff --git a/musicround/static/css/style.css b/musicround/static/css/style.css new file mode 100644 index 0000000..ebc3aeb --- /dev/null +++ b/musicround/static/css/style.css @@ -0,0 +1,32 @@ +body { + background-color: #DEDEDE; + color: #232323; +} + +.card { + margin-top: 50px; + border-radius: 10px; + box-shadow: 0 0 10px rgba(0, 0, 0, 0.3); +} + +.card-header { + background-color: #191414; + color: #fff; + border-top-left-radius: 10px; + border-top-right-radius: 10px; +} + +.btn-primary { + background-color: #1DB954; + border-color: #1DB954; +} + +.btn-primary:hover { + background-color: #1ed760; + border-color: #1ed760; +} + +.alert { + margin-top: 50px; +} + diff --git a/musicround/static/favicon.ico b/musicround/static/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..d2246c33597972a386badce498c5f015cad634e6 GIT binary patch literal 1252505 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¬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 z zt|U5X7oPy*-K{84Gt;(*`?RSH0yQ8o+R>ESK{vEX$D?f*nyd7DZC6-@Nr9biFrEl1 z#fjEKuQmtUgm7N~&H6cqc6=Kd2(Kpc)dcb3>hzECK(c0Jkw%iGQ5bo$;VOXuh^4EH zlx%Uc>OD2j_|op8RAjBjR-T};G-l*eU)1ujiaZtoTEYr(Pw5j%6SxNx|WFCW_=U7Ip z9w%hT#=T=1K=Jc-DY;nNRE6r;8AWPYZS$y~?na{4or?-NdHy-DV&l)r&Fb%l?;80H zlw;kM>@yFkRJ(M}mMt`eroj_3e4DNLWid1TT}2B|jZ0W1!&zL%5f`d0PJ=eXOvv_K z=xI8nRA4>sJ)oV%Dlc0tyKa5p`7CXJn%vjMg&rrPuj!S>78u~Tk`Wbo>j=tqysPmL zF2Kd=0P1%s0qQ909SxV3j1Q9k{2i?E7eEs4h&FP+q!}A zZO5o~OC0nc@3D^+8<2?ja}9i*TqZXOP27WG9P@08V{;-fqS?kNlVgTXg7uMl89Ht^ zy9BLe7FtFD4jBeU@UV}3l?8;Wv~GO5In8RlqH{Utccux!u@Gy?KudHc!!Ceh@6zm8 zse|_p888J^umHx74poKq>48G$w?^UWBEubk=gxV=!z@x6Y`CBU&mM*KwAOX(pp4<3 zFCtT2+2zkwd_dwbg_ad;E3gFqcV@2}G8G&PWh+0lJO2&9z7YTYKmUf4D8)L)$A;#Z z;_Jzn8!b_pqGG1T%6uu(_G%(i_uvhtcS-`l;xM5@U~9LN^Uc}Ns2|P0Ku2e8;$V?` zGpWX(VLTP2C~UFV0Ruek@s+W7glEVrZ#2elpjkANPf53@g1B?{^kL!m_t%@kHAjQp z^}AcoRBhO1=ANIQd#@IiSwtp67Q;K2UFGC0OYl^ytz(qkVyI}l>n$eNWIG{@yU!?) zNge9Sro@l@Z-~|DVMoFiY;XW5d8m)kAo;2Y`sj$_nX#h-@0TNTEXdiS+z}+iJ zUDXZkXKZluEhJCPy&F?~r&{o-NCBE#{bO`p^7J^O%ekAb0DQgpShBaM!++ZCh4;Id zf-kodsy!L8G6%}wzpKna5^S}WSU$}0`Ayxj12%>l+*rWnW-R84`tu!gTaP`Ez)dE! zBsjIOw7*+jk_zPn)MJ5aY>k|~SpNL9k21}`(9rH`EadT3YJBy8EY55-q|(l*zUlj4 z?yQMR*o9p}$&Tbg0rzw7E*9G< z=P+a4`9M7X`q|mpt=wJNtSB8+1}0Gx5t-NL%

0EM&zR-N}h!H)hg+GX$U2%guO& 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

19|KPD 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 $eq^{f(8j-B- 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
tFRIk&)@U*tmKIBx8f#vS$%5`jys z19Cj`5Mjp5=9m}&J_aRgC~DU`pLn?s{>I<%Z{2^@H$T39wWOmEF0F!cQc{)H6-Dg5 zBQD(g?%Dkp|HL2pIlu59eSWt-dj0CUt`OkPb7Y5KaM-b7l*kDUn%BFb2!un|AZ3KN zVp=h$J>E8BcOx83ly$v{5uAf-iAi|uOS4DdnFG;&XwV#ACf?4 zB=#rX{zP0jS}6@=@f33asJnt`WF`cu>+P`K`}M=?zU{5eMU+KOW9f_tBPaW|7uO&8 zli!t(k1yYT`R3NKhV1joAg0)5KDD(Gj1=(dOJDr@Z~Vqf;0vGo{?*rDFY zh$hg*l{&PK*PnX(<=^&GfAXLE!+(4QA1NVLtRU3Nm1gQ=1rC%pu)wQYaeeo9{m$Qm z|I0siy}KT_T1$awZILnQ)eN$mcDd{-(!Hm6c7K63r&Ky1U+(}@Xa&%&38R8r#jbX? z76@(O(%rc(wTqdd^LCeAn=#2Y0JqZ?n#?B+jk6j{9pTIw zA=qa_#B6RjRjptI_wER;CmzE$aWgMb*v@&aNf-hVRdq=s+|z6}Ijn^69PIE^^Rcwp z9bQR$!tB5{90kV+!p%@tgN#7RDj&`8bH1(SN214ArJ<)FFqHN-MTk%r6iS9_&yHk@ z$peCmuV$dKF<|60GuLHi3w;#V7)vmBTY+FZF4=lbSGTpFuT#Peiy%DZ1Okh4>cLbl z;Pkkewt~5*64qQmaz2p1ST!41fv#o-;WIYZif*B!TiT^7BO+2jE2Ovh3QxL9ZzGs%l_Ns%>zOv6SkOMR@i6fi*jdJjjHy>NON z-+e0>O*i(B<%b0E#;_A zu2KufHUM+mdbZ$Ab>6mxewK_6NhW91)$|Rc|z(VG>SFeuX z-4MSP3;B%s0RydD1FR|Q?%pEsEB@vGCm!(DXTIuIZ+ZjRh!CqwIUFDGL+OI^w$#e)MSw*?e0ANdL5BE&04(lGdxXkVdC;Nwi9qq!5a2KF0Zz7uI z7sJ<{YwtV$sbBT$fxGJ`->uu5P=Z3HI$+t0#5`p=$P4+XSjorl`3wKhFaPCl-_-~2 zeKGUd)(!>H1j|kri1R--2Z2EPXL14X*+W0ed4$|tgd9JNX-87%a<*lgt!K%cn3ri4 z(JlKejF2$G<9Bb&FdaZKGOg7e{(V+*MMq!*c=^`b-~as|MC4;Xz}LlD+{ziM!9XF_ zE=>vc{kmJC_2xJ}di~~uk3Rh9!#5wk|G^jDJl4^#Uq8Hl^XARR4EB|HXg!sTcPjKD>{xPI;ac%VvZKb?t(7L;uO|{Qbv^`^(++@$n-PjbLyw+^-`r zqy%nIQ0(0i{p!_E|A+rKrFijGpSmJL?q^Q$_74If5Wf)^|f*0 zX_c|GmO&AQxjGCcFI3lyulxGH`X~Ovt#tqFPWzEg{T36f!7tH{nas1qqbG9Yop;{_ z+M1+em(9?ft>WbpavDL4E7|Qr3*2@`pQ*;3D-?Ssl^8_K6R8VHhNN;MS)BlEYtzD2 zPqf4!e-f0D){YoJGX&S&F^Xq!G$9H^p#o|~8>K#hH|@^BedaOr9qETCg3f}oLx>Tr zqSg7Gh|1X{F}xPp)ySZlNNM5?8q;07!Ke5LcoP~SE3GV%>PfWS66KD?l0eaY^)ymx zlgaE$zG*v1Nj(!T&sZeuIKnH3rzyjx_J}6APe#MCnW@;DXK!XU&j0b37gb1t9b1(% zonZk8W?S_hwwgN54up#q1Ugu>C}AZLc?!S|G-@NR!emCyJ?P{S?^X^X>COQuNp!BD zu)8zPX-t}CHO5o#{%6s&uql|8tk)TNr$mO>-WZN|rLSm71^$!yOz*kd5d zt$%UWGtQK2sgsBM$@~W*mY=w)W)oK4532(2!$?88M69)J`azK8R2%F0r!G(bbc#BXYirX2k7r_v=^J>obhfCf1VR(Xauf5P5mj<2!fP@B5Sg zXaeeNn+(KV6p;amZUF9Q&ktppdN_QpP z9^d`c+aCDEbBv^)4gi6?05JF`49hf zKk=u3-6x*!$Jd2ggs?a@H_hP_yGxAhY*rfqQa}k59Pv`(nl+;Yd;1X$21-v_TbgO* zi0UP<9v)x5e5Zo{*1z%V@4x;>Ui*05h0A?#s}w5&7j!fmrIrcSVqSUStM@;`e*AZS z%|ETit=6;ao$zRC0%UqQNvMfxj8l~M?YD$>%Y;NC80CkJP=TY)a0WCeAV(U2`9|71 zk5BWBLJ;MbGZfuE5gp8#x7q-)K!+Rjs0r81pd%lzKH_>Q;MvRP_}mvXMSVP<(zT!l zBGYnJb{7NPFD{A8+kfi2zgysDFXI=!)B_}{gcdJRMuAW{RsqoPA>+1hA!hJL{-nR_ zyZ`tfCa#uLV==T8sZzwXDfEF5cqNn93&_Rm?SsGiAN{u9^~?UDpYynn=l3s~9gc5? zvkN;xl9}<=%Xf~}Z~JY(V?F=$>(?7<$8N#*TC2Gc7X(~C@BD+i>vetdQ{Vny{GlKA z-~NKvAH4VJPkic=pZ>(BKK0I9FW&m(yDy$y^8T&s-MY)nB=4@51a)2a*Y(~PKf=qe z*vFd=vX~ccft*v?_yL4qCb|Q-Jv@8y)k zs67(Lv5f|~d+MSk53_qp-%-_^fe0G@5(Zm;fWnPBhk%G&;W(C>XMhP+4-Z{KM3`GG zq)iaUfn=$~lcWcTCd1M5v#iV_Fsz#uj!qsSeTYX@Gbo;wvVhckYsDHweQqvapyM8H z&FI(0Qnx zWkzJ}%E+b@C9I0E@+D4n5)8u@l*TuR-Zi9w#uG+hR{?QhlqX}~j+y>$y<);L1&>dD zV8;P60CCU+x%t6%3Zl39Dg%NFq+N^=(Onrqa1f{-qG0C#(`)NpI1oNz4P9E%I)xMv z!*He#S#{gd;|Ry0*-rDIhkun((lgHX#GU(uA6kf!{{R_LhKO(i*G9}|B9?JVdp^5> zU?NVXxih;bj>H@D2ul1PwW+*WMF{c|>UOM=0lNTqRu)K9Ft*JN2!I!?V%J_Pq9>6Q z#L?DJF{2+l*#*YfV;+vkY-~U*XpsV{3qW^VFRBfHz9gioo;}+&Zk|UvBCxBtJtk2- z!?{CR2V0{Cg9VY(LSnx*U27{~))Xh~8Z6C-_~Hj2pl`g(t`f0C=k5=hQmUv@Kks<; z@eQ{x{NH}fKV7PiKYqQg*Ga_5WKFwlfU>kJ(|%eSlJgm2*^}YSu_pt@5G9ad^Ns(o zseZAF=}c)bRMtMXb4bWSOUVUY*Sg%t4UrMCZ-*o$#mZ6Ssj4Cn-7oLgWA8VQxBKMngQCu4_rd$@b~Vuiluh~|4p_RVUt2dbowZHkZUyr3!?XIicI7tNduAr5G zkr!f%>ea&K^6I1aAu!qc|1tI6@wTp4S?Dvyc)vMU+iUNA`bj-GA?1(+(ocZ}!$ z@x0#-`~eBSv(H{@&hLBQF`ioHVn#$1hJ2r7hKCKoi9>J7$ey)`l>wX0277y?mB1fx z%ioYBORb)SN)&Yaqmo$z!w z&)M1<0++K^EtVfgVme-z&PW27av`w64c@2q>id7{H?45fgKj##dWr_K?sP(jQ2?13 zoVVAoG^WMLyuyjRxrYn)^wP*_1^wt8%DJx+XC%FOP3CRU?jEsW7F%f}PZ5_R* z0XJN@_<`+Tw&b=)+iQJzu2XY8%iWxr@Ca+^TY6!=_o}zP%ZpP?W)gTPbx1LMZXSJ3 za5NDQax%4L8)561I*Q=OKR)B)UAI2=kt;)iZLqjWG&8yfT6EE&WyR{dUF@y?&r7eI zzj!gUua0>TR^SqZX@PR9T^?UJy4H6ec*|QZJo?FHGrWzEUzOc-GnnaCL721Ljnif` z-*Cf)YbV?LKk|_|`LPdujGIKAg58tWSwq?5V1sQ@26WK<@W$hZJjkatGSN798-3nI z!V=vm$+d3_Q=rQC4+GP|fBT(3{jtY9cxFwKbzsn7G)w7H)6I+UfJIri*$S~X^o>vE zr`zt6&9g_);ow|oRz`6))>!7MXzW!icLTkcI^LEcdBE=;=FaS}fWeX}v4%os^v@2#UeHUxt4xML z8hgTRm;uIRjH;1vgdxuv7oa9B8z*1F=n+{vCaaf^i1DFFF<0xAj1Yr5(fEz=Hwo1p zRKud4mlju1;O0bI2rHDLN+EkWUDt7@MI=kU3Yh2I-6K4Q1v16N=x>aXfT3W;v~o_- zxahSol;x@QAw=C6O1k`H85HD~tbpfGOxZB|s^J^~QwWwVx#VT;ULh}s=`c%Mq#?Fw z3j|4nHWcWZJA`?wQ&6cUECrGei*C&f^T8Uqak&M1m1e-jat%s^30F&|J`Xc9lu)6O zY=$MuuY%dr2f{YWA{O0}EX+AtavAZtNL9$^sQ9J;2_ zNvU4aNv2sC7~_?ZC9cNVpOr-v!hvnMvZ4zddQe9g1&kWakfSh5T4`+^=1!K&2jv#t zJV+%(NkT>tP7xm^&C&RdwTzjOZL|wpLH1gQlfFZF^EP`2?e%YY7v^m1eO|qWup%wV z01#%RgPpXf3&$US?d$*AXMEwqA8^yQZ>P4_Ml)Qt*FEBT4VHNGA;Th6@`p0817;fX z%!@AM$|TIg$_!cF%$vb^)9tqiI#qHZq(81C+=^4PndoJ=J>Vwz)H}^h^7%@N_zsI= z!phQMmQ{rgZ};4DNk6xnu@p6}H%`$PzC0-m`JeQz(P^Y5yde!1Q%sIIgcvf08bR`cHnJhP{aA81L=@XD0UwkuBee$-$#?Y)m`Z4#wV0S&qrMm?LW3rLT z7{Tfk>;zvTdyPOYPmx!^Syj2?(R!8e@Bg;%vRm)i)f|&_9f9Uib1;gQ!ZikI&Yp-i zuh;wcz3ZJfKkBc2&Zj(fvpEA;*1%c&cfqtQ>d^v58k|fF&=ce`E4Xvm$gc0TAXr@( zI!1~`z}Va}i7YtD;G9QC=XSvNe&_d37jNIrJ9h)olMzm`ITFT{Xh)Z5!D7$t>ir*w z^`HEq=k(+@v5rXwW!=TDa%Bt`O1M|$vYSbW!z71mklsxTgW6BE5L#*XAb>L0R2_!! z66*kJK$XAN=oJti2XH_*%ZxtHMR)kRdG)^8LFR1d9*3KHxK|}MXDrp^i?WSh1-QFtTh-galt|}r_ zr3qtYfGH|>zXV<58WX*EXT zq9_{-+>ADI%=>sEd}ydumRGv*;ifPKr&V1~-j&2gcWBKWk~=V5!l9ZHNbX6apHp=3pYnQTKY?0uv~18!kV2~1^jaQCjL54keND&UH5*H7ca2j$cd zRzoE#4TiQJF7%GmdZt1^WNGBkyDS-}g{*W#RynN3Tsyvu(FmwfeQ32r8_=pyWlXw< zfe9yF_af=qFN|rjCysBy9aieP`2--2o*ZioP@-I*>DfH=;f^ZVA*>Jsle&&nw_pzQ zVU!gNFA?(yc%n!=FNO3QSn`)FQWg`{FuI}uQ|t^&`TQ;}h{e+DVXDei)^^pxUXAB1 zR2FB(a;Bv8OOZ8w$?FrbLDCj5-k^+U0+9B>MituFx(S5RHwc#6YX)Shed2mdA%_27 zQaZWeFvM(FB2!CNRI9>M$@Y*jOM58{u{OReB3*wM)Nm2Pn0jycpHrU-RP;Wx@g21}(BBeEP$hDRjO3CsBy=?9t7jR|!eH*GqGg{Z5A-~}imUJb&p-Wd3EN&fS?$FV%d{l;=x0h5HjrW=sL05! z))ht9fUM50@43iKF-VJNK(U^Sgv2!Ti@Zt!a8=0^+oZk>7`dLj%y(z0-KB9+u>yJ> zpk#`$GPkO|gChcOd)Eg5q*v0|Jk7Pj309WiUr#*-JPrtl(EjRlvd=qj>({;UJ-l{p z|LCCawpG2evv)JP-smu9MFa(eMKvvL{p>Lhf3S=m1yE0xVxJ5n3t;ku9l$`Fx3i-m z_3PNwqPeL@Gr8abEX+XL|M-3P!hO9C4Gl};1xEjp(L+8F)bhW~%#`-KosA4Y}bJW8AiT`o) z!AA+(NN(~>?`e*0*B5QLt`q%SBVRh15mwl>y~CgQ`QJS`z30YTZo_sqM>HG!8=43r z^HSPtA?Hj3XTqjcU3&iy{ouc;;N`PxZOmKJ2rq@bHIXn~s3HSt*DpNo3L&>_U4s%hrdd z?|$1?eAB-;=XT}led}pYaD*N*8QJx>d?HobU;#lI>QRpH8qJF-R~(s2S1AmlF9hp| zxh4!~9_8lDFoPAHFe+28U@Dy}xBni@KD#HbFhovsYP#uyqQ#JZ}hIVjZ_ z6G{)ja`W1C@YYB<%@lF3N5e4;y@E~5u8(oD_`;O8Yv!SltEH7#=Xx$FX&AFb^`ZTM zx_Dvc9xkBO&E;b&z&y}Qc=FP2O&F{9$^?v+R7!&fS#nX>fGlhnmx?wTCrOM%e;R43 zl9pExBRE{u0c2`;=SX`rSVT}OloPO~Lj+dC4FFP_IdQc*6g3;^K^}n~VK$;vCAO5P z#az(4DN{`+H)+oCv&)NSC?t`>O2J{uhs$n}T;}Ix)lv4M67CYT7#&O2ZV&F>>k zPv3(Xt=VFig~9c)Eh=O+fZYCa0H>7oxoxc6SZK6vxH-b++tg?U&_UKTEFPluRTK?TbKK49r^O~7V` z^di0RYrp?;ww3wRi_O;nyVc;1%m6P3a=6zTJ!v@`BR}m4pFCu;3P>2tr#3|^K`PrF z!rS4|=JX7q_&S>VoGHj7IgSkZspsl`?(ie;eh+~urW$#^BEe`hAm^_(7ev1KNX>4d_RsDGH&>jEk+rJyP zJY0ZCvS(*AcV5r9VRf)1tZeHk%pAfE~Jig_t|ITOUS*?A~+-=E7dARcLElEn3RB0bz9_JX!7;%>?r8V$@g z{@$UxzOLT2(FcxNo-*rMsastU(T1>~fmW)lMZp<(L=UshhGa zZG>6d&|}b;5xept+G;O}vul@D>;1V>jwxq3!8CZmm|)Mco-BajWd@wiTX;O~t~)Dd z<#BkG?#4_VH>rS%{k?s2fAMes0ngn$k3nMj=*>K|r#I7@9By8fT^N9KB!j1!87FtQ zhSs9lSbM#NoB4{S5?&~^ILn~u9yhvWCkvf31;U1bY^@oSta9H}KY!zm*j{?i2R_td z8XXt_-Kz#~0vB_$fJqJ~WleTtIm4FiW$3C=*vwWAV5 zB9^!bLGm0pRDwhm!bpWiB4EghaGwN~D*Zw!cQ#5n#ZQrdWfhjXfl8&(=qx8}v4;wo z4I8LFZNc{kD>?bfuxMJ8nG0nUBFl6rVu8;LG>@Sr@+EiNgfkB0f@4}AJ9>B%G{b?b zkHL$BgBelCPCPOF~Ikc+*1%vyo3>;49qIJTcg0GF$9V6844&9sz;%@ z)w7s1v+!7M%w^9POl^RNo3K!;tg4P741yH`bipqu3?fZj5XPo#z`}BC@EzQ*@*KJN zI{}W@0)w0~LP@TpaG7SyFRy`45uF&YX;q5lFO5WYeIBDpa5@r@P<^0c2v<-jN6AaM zcyzdGs1eJuEaGT{Bbe@OU+=&S^-#&3jD@NM8K143tqypTS--}wsLN=O z1dwV0AVdNeLBzndAOvfyW3=Iuca8%aBkXc88RHQcc&_Lo#sUu4cyUNn87$>?8uOnr zu(ah_dM3)7MFWeR_0j7Cax6I(n%!)~J`M*n6&f}G+63U?`Y}y;2HJ{ZqyiWQq%-CM zu|a00=>K=_bBK0-909!aSNq2Vx5g(|RD^Qp?;{Q5Wg4L57QD=iJuC7Ok< z+}zHaEiV7%uRZSvyV<-wnQHQ>eEgVDu9Nn-XoKJwOA>~qmnbLPo9VRl&@x;kOrM%v zw+SqU9J3{YZ`nIhnFJ`=f;cJZ{W@AqHXYR_5m_CnlTMnGW%1HkLkK9^c@2%bWTfgz*cK$~AY_z$`O3C8Zd^kSw+hPur7GW^uuw|=k5-A(aXo(``?c7#-&wIh2Z9o2j8z1!Gp4&2_9Arna zF!$6J#L3*vTR5uRyJg$kpFjH6@B7hzj~Q3{wdSLvp3=FQQvn^Qp*n(24+&u z%F>XoZh_9!X6FU18SWv3PD7^VO%DWMRVxo<{NnHaF<|m%>YN|F1GNO3g`0bc+Ke#6 zO*h`C^eyo%j&Qh2I3z9+86`f*ikT^aOwfg5Bj`jQFgO+pSv7HPT1ndJiC&)5csu#T@tm`fBu!0#cjPrU*CdJ*yZPh>XS} z-6%?b9dES&l)nP9NqVzzoyL-V*dVk-2?+!Yo`0S-bw^P{jyzke3fM3sYdX z99d*x`3Hp}*|LTWIG$syrp{cGH?9DT-e8W`evIeZO;yL@jx3b^M?1lAwT+!Y`cC~f z9Vmj9=*(r~G(c+60i9z!C_=o*lx9o|{qVn9z?z(x;{Z0{11cc{vx7sJq|-T~htyaME!^efcH(*$d)1PAZ~x zl{2X7DJMJzzX!6IW2giu#j3;1O89fZ{a4Yqq*Rsp#9~*;(&W~EyTj{DD z=8op$GAELQdGo+--ma&HwmQ3f*~?6Mb5f00C(N7P2{$)}_3XX()zRVWUiYSQv^Hh! z$Uavu0xlL-n7sO33{udEBGucW+iBh$pF4L-y!S1Cest?C=xE_KnKf(8ViMy~(qFkx z-dcFXwDSGw?4C=}E?ziyE_T_X=>XAqqgb>`CTr!9nHlwnN8V{Cmu+e^L&*njy6sH; zJ17LpgFV;BN6327pS&`rJt|jZ={g}zsUt2Q!*G$H>r@}eZMp#rL-$zau3(^bDb~bI zxgo+xb|x4GYk<$Y2i|r&2xQtwz?2h36TPZ+x0*2b*3>UqRssjYA__J4xiT$H zmN$Bv+*+GhU0S9}IUz)wn3P&78mls8hRr>XkB{B)tY?1P{*8~eU_`SBUtWtcbA$dh zYj;P})nrMpI{DCt+uq?bzvdri+fM096sbXg5HR{sz+ETwblMwJ(}RKw+$Hw5fpFNe z9YczR!GRlVP@yOd^;x@vqsbBf^y|Od4{w`1JlYOv2$qrA6y#S-N0MLP}xzLCa9q-f-TL?Xw`Zi7XK#fus47~wNM_&*& zRPfjH<4GM{q*W$KcVu>}>RA}sj`}Eav<>Q+5)5Pm^!5@9R9VV39XPh`kKRi+M;S5P zLJLtLnL;3xy~C0nQ`3{ML`#e=gYjVxiVMSsscKt@e$jNEOTv^s@R9d4fD}{MteylA ztnPp}WqL~0F^aOsy{yp-3y`hQh_UlmXb7$%u1Cge|Ojb|}oK!sq`GfNka!lTD}$ zYLg_W0OKVg-v>cu7;>PoB8rF|C^ev$F}&Hx+#LUOjb9bDkSpr4tLkP;{`7c$hlCNu z-FBPcO}Ad0`?W9=BTuu;s4LCrNqYa!ZPT2Hx0 zuz*Vgj4^olBq3&H&fN<9*-xGXhLifoFC%&=qqOO2i2(b7FPjXMf?> zVY%{7lv+Lv=A4Eln_vB!ZUa=5_w)PzO)11OczC>OGBaXzMA~`|CF8o`)mh zF4Y7bt&M0nU#Qz9EkOwcrXc}+H?3ALc-bqieB|BhJ8tdU?N*cl-CGPvFsV4RN>rs6 z;p~;`{c|UGzvrKS_jC5aEBBqoM5a^Xc$6z{IBR(;p|vW#~gTv$9?ljuUIzfiTXi}v} zo#8&QP;kZ2kAw$%J^vSf8++%&V3m@eW@lv=?w0e8RYPNTT{`S}WIUA0T4p`+2-J-zY zKuELI5GFfD!W?^(TP6D7(lqhF5D3y}*2fby^zz|eL^@e%VF(!0l4ek1uY#`S6bdnx zNGybJBL*u<~n%8OEIV0Y?bcb$td6b8lgxAFP;V>9V+SY5y3k55oq~uJvC+*phg_*vvtPH1s;wSeT1ix^(st zaBJfym;KSWh?)d84@rbzeRpx;(yyv|#xOJ=Ld&4NzX~kKaZR%bD^%%>@@5WHDVj(t zUSVv@tu><*6fp#yQW!}0RBnNYW$4wxr(?n)2yIL)RXz+5k_rTCL`)GSbaPBWwP=2Z zYgE*ZnQJ*7;x45D(e+ugGBb0a66zPlP)7_(eEcY8BN+;1I&(p3>cdUXidLrOsMfYK zJjoUwAqtoYK*3MWQr4g(`ab^iCw8(b5@qx;!NFW#)Z(755gBrQ9HnKUwDHCevFQvj zcbK|MMD>yI5z7ZHOEnZ75t@SyivUhS3X?YrO|Fj)`uX`pk6|&=zF??67kU=aKIhY(i0nC6 zwbqTDm8#Fp0vQs3=!~&AIon-$=p%pkmwtIBk1ibbxhrtLv%nFG$_4Kr6T?nqxvc%9 z{jcBtJ+Rj6RY$K(WG!%jvLt+9L`~UePMFu}V;}i2BX;vV^nTZ=J5~vya=p}kbnXbb zojB?JM>^={UVS!D^%fBUCRshRs=AVd05EL~OcHkq_Sc;?49au${evSEpYcz=6E{3E z;Bc&R*j)hwO6UVoWnR9>cFSVjHkYq>ZvWkLz6rfgEqYov7So+B*#z7a?_WyzU$!E% z7(!4~GC2ZU#69Z*)uHch2n!$YlAtoOP-3#McX*yYKjRy}$NiSQn^xoIW5L-#bE%DO zG6UQhC2P=Xx_r+itXBW&x&J!58=X`0*=fPd4mF_|NMtPlnFgh@Ws;DhK!?5NFo{S8 zoNHs&85fY=D|a`M$X1!aTt%m1f;6@cb%(pThtb^ISdz&CR<-CaDwiJ$$&v;|pEpbC zPTZYt&FYK4;BR7c$wU0sh$kF#yYfurEHD5Os;XW)+WF`F@GqoWDHd7ztmL>HxXA6U2?s|Y!!hK8X^HGWDZEqgBoQ4;pUF84iISo zZS>TF5oTfXB|2IW=~-E<9;3nB0Z|AvV>EqR9xXgv*+qam3ht44aN`lLoqgcrm!eI& zgqPb*Ha_Way?g|%YmPctuUKAk@6>?ZHF}#f%$r29Bb;0+4sjPEl@)sKSqcykXtN{> zhGf)Bguu`}QK4v1y_cJrYwaGB=c0m>7g2x6B}+7D+J}R36{?F>|095uW1vde6_F?| z{0cY%&9p!RsvR0Lm|@wHOZUucvC&xO_qLkcT!jFVC3U!b_mV~f;< zBmfWh@B++22#ykva)^u6gG)oHhZo@hZ9o%z9j4*`^=;bH)A1 zbKb%#=sc&;T7~^DWC!65dR~=Wki{&J%mn31@`&M|a(6GZ<-fbDH!Tp-bb>JXl|(WP zGH!s?mFfpGA0pX;F`Xl;qXkysO%a=6<-;_*m`o&3hJ$@{0cw%6fxaVJ8xcUd`H~PA zsMmA1+tQ=F4eH6sqIIj>mC@<*ZZ~HkEX-Ch4XLGZnpWsVrcG-j$+?h2R+=z%0KsV1 z3s~ql3}bFecQ#lPebiztM=%D5GFGojWzNY`rj-^4P+E}j+e_OAEQ_ix+Sc>@;bb0v z^hbXhx7>=^X|M>ZE;W-!%el9yef)jzU!A}Chri=%d#|3eTUs#)_FmNqjvY%B;Q*+r z`q11F`Z;U#ER3I$V|Am7b<@le*EvV(59;NY=F>F=>NtTFSzOL0!rbu$c&Apgp=gvHEblWfg;tK(+Ca#c^89bUbGNb{hf#8?S`ldoz zGjA=k(6N8uzx9&WeBjkDz2T1AcH14yi-8drd!i~i_sVVUwf)IszPf>3`-(6A zyyoT3-uvLL-Jur>@M6)y`EYfR$j^A}oxpb9Wf+@VM2ptE1>C9x#+2K-EJ!r;^$mxJ z^*4U&j{qU&FFhhAgd0Lec3Nf6f}sU~szlay+t1&4gPA?=zrO(IZ$8^>-CJu>;W;3E zXSgW$V%d(9_3p*Ksm7;0^+^CKO~tok8X9sLmb@(;G_0*7R@DY0(U$oaX4$LHIdA8= zcR9orw*|M@cLV0$y+wGi%A1ktOKd}-8m)Y7%)NvC-~O}L-}~Obxa|=S&3X3pVk);L zvyUt;=GZF3Ev71S<9dB?>FuxiN8kJ{N7H=Yoo3+-}c~4p#5|=(V^0*-H){`moc>n;P}1Ml}r$ zfQX!`ISexknQe!-_Q5xN?X$kYSGacVQmi7FbXe~MTe%_3qj~cw!hF=L6+m0KXMl7j zvdfrl!Yh*_Dg&UQa+ugMYt9t7mDy1}Cb!sM3Cc!ukLw=AF@x#Uuhd|-BIvD&Hxzs( za7F-)0^tJY?$LUcJA+oJulVA>1@638c~m7m;H^c3ds&#uc0$H8z|B_Vt{>d;uwVSI zzp&fxZn){@nMm_wVrXbwaFGd!9ycUlK5yqL?C;r&Uis$x@45Tp#e=K8D|fO|n2dBJ zr4SCKIGedQtXJ!MK6W?GoqzIOkKX0HYAYEM2vf|wSs>HkyIo)Jtv+(!ecO9JcGGP) z^rE4|)SOhi>@^oM*AYW&zdT)qbXc?r;j;jeO4{geNb@X|F<~T=eOE{w=7lsXxFU4r z3orJpMYRc$56B!E6*sDhwC65XduaIG-+w8}dUoT`a15=9zBLa= zAS#%ErB#Yw*MOXunbixhIbqrLRU*PY%IStcMobuDep8BrnRnfO?h;v{3Zd>Rlat5c zaBr=-iS5A%w1tmAiXu^Zd@BnJ-5A%QJcWMxKzIiMpBXTZ!0HOv=7Mr-aR)2=E>oyB3Y9`=X`wtB6AA{4QsGD`umG%T@YW25 zz9{arkQunxmE18_iW*83A2Y10kcyQ0o!8~N95b#Y71?_+QE7v&8ChEk;5^6@L3|jC z6MHY2M2sovnkIxcwUXpfG*Fm>X2BsbSR^=O*)1^_(OR@Hgix`?BQb~pz(^UyByboY z6~#pkji&BVJupVItR2Rw%2IGQ2s+ zzz7)D9R@DBV&!TQWRS+@A%TTdp=Mqx|IYDX#t^U#b)w#I1Or8Z(XeIh#s1aJ?(Pq~^Wsf6p7m3AH__`(&fQwrdcSvU zKKhQ|_|>0VwYqZUviT%UdZvyIfgi)W2&B$~V#(u3P_@#w#P$!JkNNTli~jKCj@RBY zgxpvTp|QQ{7=m`s3VEdla%fpJYoGf$Pl?W?VQN0lKzDRQc{2}ls|eGw7~w6v^;|vR z*57^p^G~uLU%X*s7A-S=LC|hDWXkny`J`C`tYUG55MD`7asJ0=;gHD&0UYZ_bg^NQ+}xzGqX?bm+!fX ztWW=IpG=#h(R>rBbhv-|DB_R8e>Uiw}rdZ zoN5bvaAD#E@mYi5bdGl3sYY}dktD9-srG>&9SYBin!DLsy6KmHc;ma|wrMiI> zjR~gi&3rD*nyKLC3Z5<& zRY|1pfWWzP2YMZ0mh(_4hJ|HGFRPHKCb*%{9BrB!Jb~(kBIb^u#YBKCk0!{Ry^?ef zf>EUwcg5DEFjg3| z7{LLAhq;GG_?X>CtiE)NSh}AHy<3v~EJEG^p?h7Q2cbtrTi+s1(z@HmE=X9Q!3S}} za0wCs0}X`vOG%z#;pl6EN>AxpJc=}8vbjFLD9mgD~oEAy)E?$W*i zAT6^h;34U~W%@XB65Tdl$!WU-^*7KL;tYIYiti5=lpNMb1Ah9BDGqStY+mwFL( zYOc|8sLz(Yqz$MVVuhi+7(RBf;y_8XXeO~9OiB&HOzEy-?m=?yyWSD_-50+cS8MNZ zZK+sDq*?az)oPwM2P@qDhS&V{FZ!}C{H(`rPq!8!W?Nzf?QF(^54eE~(>6wP&GEx> zv532_pHf2yptfJlQE2EHrgJry-zB zprRG~oUA&zau#k+fBNU(-jA;KCPb@|#E>llA+4Kb0p6@qy}awgeLH&C6F=?gGjPMj zoBMX_Bw|Xm7HBIU8*?>BG!M9KciWs#;QZ>Z{VoeTIzE^|n^^3_uu`RyQ`w9Hle@>X zj?+t*_HV!AV9z%vyIQgqbjOU}%mZQN*4%;IUp1h@2USjebOu53oWU|u_k#^B**vcg z_W@YSEvrWlgpE)mLzrcs9esaq^`~$9%lE(KHMie!mu=?e4W)A{iWP(JwklZBNLo*z zA=?z&_r2{4zwV#iavHQdf5;T44&Pa91b+lJSj1O7n4?_bws6n0P2J)$>-$-g?J8w0c>ECBdCOnkjQl|8{w18AeujQ6qI!kjsebSZ%B!~B6la3 zoc<-x_=kDV2V-v-Cz4sCQqiKhdh3i`e%Q1M7<(Q({K-G@{oi-#w9a2VzdJptS$dCX zggJ-aR8tH>W!q^y+&_Hfo8R`qH^1rNlO9&v3Ns)F6Etp23|Y3j(=BPVbho_;XCM2T zFa1JR?)q#deKH***9Wpu_qq85v)_KvOYQK1TV_nk#PVdS5{3q9u`mw!GSes>U&OSx zKefHRX@8p9Dx$@Diq&M(GniL`JfG?;tAs?XwS!y+O)+|4of zIV;TR)~05Oy<2X7#YF`*!>qY5&15P_!oviG zLf#6(Y2lDpJ3%LqOhZLDJayqUL2<*RE;M}|lf1$Kk7x)tl(`ZKVlI==STp_{)EG!K|s|w-~I*?0!n`kwsIrMxkAGQxX+{`UA$7Up`QeUld73oTV)xhtI zl@?=P(uLsTz%T-ql~W5?{_ubP73?2n_0~9Iz|Etr=Q+Ji_rL$6;rN69@uNNcWV?&e z!UZFs8ax;UK1s5nPga}jpdE#68G*2n`<%;@t)x=<+5{SgV17zdJT@3J6M0Po5ZzMn zi&T{~Rm;13ob~x=)o!};5tlynQD3i;BDau4R%WKv`0T?htTCERQ8k}?)RSKDGe7&$ z%O^*NM`zqkE15y7ySTs6LEt_m!N3Z>txc@V5BLA|bN|cl{o4P$`4LavZRQw*i)r1} zu2Vo*a|;rN^wvB%A@0BTGW_7HzWDQcAN)qFJx!eBD=|pY3*i zJX8_M%3XpC*#gUu-Q?A%xpteI9{Gq%AN%MhKlw}Gym;Y!q3679NFX*dBsXl6dsd>h z^W3I5zTwvY`Qn%S;S2uz`8yxI+3bL1`lRAM3pZLwC?ZJ!)5)9-4OiarkDu}7q-}Qd zv^QDJBRLMlhy|l*b|*=t&0vAeTi%gdR!+QCAcT9KRFI~RW~FJ&;Hi$ zgZsH#ZaAIig<(LBa~k6fGp{tSoGs?)Cm*^TtLeY~$a8=QbF*eSK3lWQ5oyh(`y@MP zUfn9ePGw$?5OHTtK&bORhF4VjYbfJx9Hk0!8ERDZ?+^}SG8GH6P}`hV$~e_sh#Cn5 z5)V)%lg1)af+3fUd_)V_Acj$B<`HQPtnYgEGk`fycOH||n3bI{V>A>}QM?2*hZ8NL z=I!|#j(5EAGr#cbTIJEfF`28jHU~Wl4yfmdk|}u@`|kYFaS~tj`Tvy1w;WEZKF?vP z`Pgbn=%_;J_6Jigf?S22e)L{6|B5gBBDZL^}Mz_+s@mw?de%R+iuQw z+wIw|&)e_6;h58r zTDYE%*jyC~hRC6tHb`G9Ks1LFA;fNskm#{)EV-Ealgj6iI?@)M8L||l=gr+)a9sTk zj2{=v8DND7FJ0+nHo&*xi)aJ%w`w-(f|a+H5(JIn<*}boTP#g~9ZT#pfWWY+O1D(z z%|Hw2NH?-jQSL5neH!2vfN|)61r%|d(NqkD7DHJ}U?Hqx@GPU7WB~M}v3i*))>F?m zQF2s{t^kbOR;^`YbgQIEnvjUrFvuWc#D%N=1w}1kFta4Xf-=|WDk3zT$@XdpM=hr= z7DbnN#E@-_NwR2EoWYn)MwlB-epNFN)`0S$(Q4UJFbEwGKr`<0!dl?DhO#DQM2)OXn_FTYPT5@m=2*=LY$dcYXoESbh2d_>-GcoWRZ=n@|o)w~Qh zbu>^r;82Z9*&|e-#C2&5&Pv!o#D~X&<$;38OFTXwn9a-!=PsVX zU;QU9Ie*8afan=5!kn#gmz-MTSzi6%o1gc;|JPot`|rKd_Ewhj2s<>O(j`X}Zkr=Z zZj3X`A&cSy{YqHr2I$7u^DQ20m?^=iMR?{GRZHrt4qb>%U%w!qURrw1u>TexV zwIO@3O3S_T=T2Yts(<`V-xAHQ-FxqP|J;W2K}lBzCfqAw^dK^MHlID}u7?~v z=+3L}ec!oWpMBHU&vlgfq$u72eIf@|MRv@!fBI)r}8)>bu_bhqv5#Jn!@B z{rBar*A$G_lH1;OUmTym5Uk((<5&Nq&-?Q8pY-W_(=@slMjV9uh__5SqO4r`jyARZ zvu(%O>34k7SDO``-qq!u+R@~sF4EQX1PA^2!UcG;EX=ED&Qd21mqS&cxiV&~dJ^+) zeRu#MtHW2itPJK(SZL2T1FIijxNtW2H@^0D7jJ!N?=!ld_Ry9`H$adM!p1Cv^=Ys#K!Agwhqv ziJOiNKlqkE{(`UkvLoQ5ci&gJi6)|+UMQBkITBV~n(k)Sg*8c!1gh;x+WeuvD>|!l zudQN=G3&#cd6w?C9N;7w7^Gkomo0;U!@E^;K?7zEOV(h@70axoc5fJg5^e;di%<|Y zX&SiX3uF@%ceA|-h-|>i#zw-k(Kk6a#Ji9jp!LUq1YV@jbb3}N7L3Ud0&Te_c zC%x^ZFZ#c}|G)j{cRiD*ecRIvGcZ{h!cg79Q0|;}^TD};so58P>A$+~(tWpo%BP;~ zx_R$x8h_xeNjDpXUMRqsLa%itXCzRR+#gOLP&@d9r0?Ine&~ab4i8QHvtfaG7DQFlJv~1 z+CO*hK2E>?ve$mq)Bje^CB|+2#V!>GEAzzlT`7{I}+E8uNl6RD$0c-%RvglwL9hpmgC1J2O zp1-1!HMD!_8WI9N^d%$>VXm}6%MLedhKig!tPd4}iDzdnY5am$;T~GcDnW(^A&pVe z%q^H5FeN9r-kTv8bA!04@zD+)gSljL9__jgb3|mSU=)VtvgQttI6zl)w2k9fy(l{T zGX=rQB_UZB$0kNIW`WMIR!oOQMDJB&Zz&s5vc@6ucT)_owi=CWS~Cf{Qy(kLCH+@y zrU4^DSVuV=O2w-p9pxr9x*{xTuohn6uDW-g?arD{9ofter~QMy13NH}1|S7Im2$>t z(Y#aKLvcAKeHoD@w(Whh-ORgfpJUf^HC3spH9Qbx7J8%+KrUG$Ld~oy;VqQ?u($xq z46D|dGra*j3FSD%X=7YhpsNC2inKuWEO%zFsmaw=kq!|MPKy|&;H84^Vhe1JFQnRRBH;IER@Cp9k#|H%^35oyD_xX zkB4lKYg%JjHr@|`cwwH&!D*Vd-=T4+g2Hm)W`!io^?x9&Ox^-_@A53B0r;2C{+b{8 zzn^<{-_=;R&TM6gGE3bkB`G;eOS2OGcc*8!KK3ymdDCkj@q{mb+n+!G{DmXXPIjBk z)l)DN8}nisr+xRh;f5neY&yR1@BOns{+<85|A4h34Mu@68 zfpBA1i`CT+-B)$xrvQCGg1>+C+tQG7U$Q#jRz*GNM$kM!!h+1IYAc+aZ1+}2|KZ<% z>$AW98xJ3TC$?LLFcm!kmDycyHsH;`3FBYR+n(^b_rK?@x88Kezx=u$Jk zvBEt|rgkAriMVn$|Ko4|x4-lAKeN8$sdjjr?;qNTeo}v z;)Az6>N6j9`|-)yS&L@GZWwu3aIjRK0RQ6F3tL8ytRZfm6 zq9RW3JN3i;*SzFckp0HUtVYnw(2zXY zoMl?HDSMeMN!>nRB0Bro*>rUDAD{P|*lZ3S_<+26WpYo4d$8Er5aeL^0<9uf9=-DZ zD_3xQ+i(2z4+6ODmK(Cl350{JEV$9pG%kpJRI=HiX`M_|SU_(&6srRO9Vk}IO`o$T zGOH5ZyfG6{uCLRwFbpkas$&jtE+%HT&=pfL61NBRO;{&nPISTiAZUr%Y5@9z{skbI zIhWQ@nDvv>{Tugw@VoxyGymB)!0rfRqL4=K0Tiu8NX>1S2-QG_d!aDrl&tc6eqg&5xZh2PNUHdOT{2ff_G1TM{7>*xv^8~%IwnYE67yJq7>%G{WZJP(l z<{>-0LaU}03Z>Ty)}4E+^+(?E#;<(lS3duT{*|B@i&PMEVTfj8m`#qY#ra1)CSl161tLoL1$SeXn}Q%rSarD*`?vhk|Mz1erNg=$9UXi9qd(sL6s51AqWA2%`AuBB$bg|=T`k=~4nsKiEy@qo)y#Le+cNvszkve#+G8k2kGI=v@-Yz*Oa>0!UaCVpp#EYp+hu?MWs%)4HIRt zGNs6YCJkGm^q;aS+(#afgK$f|1X2f4<%SY5Na3J3ijta%qorFW;~}jjeYmHoC>~Le zum-DurF4}w+N2E99su7uD&K>)OG9)oM3t6zso81RK zbk95A^??t5@S`8S@4kC4pWJ`%rL)u1?RE?2)SAQgR(t0!o;!Ep`1V^bJmB`5p8B}I zcK+P@=%BUL`Y>7^(hOE%HP5|YJ-gPoAfq*l^~$QOYXcv>0W@=KVP&)gOsG(f5P)e~ z!2@9F#M9C=cZ*>N*6>(#;h6?2DOQ~#$v_Y}!bCWN7skj80=wP3Iy?vZ5C6ws#I)~iwcBi` z7R?>3ZDPH5^uf2k;oJir_FsSMJ9D1%+L=Wg{X6s=OqQFnpuxg*vv!e2RnTamT6BCh zG%Zp&N@>UlAL(FBqm_bkz>)r-L$s_wc1DDYV=K1Sgdt&3V3=aLnJ1^G4?I5n*W5=l}ML|K>U0gS1A2crkNpS(v7%oQW9hk|4TbR(eioNzPaAJ9@|+)A3C|_W%6QkNw9V`hqX|`~UQ- z{_f}h?N4nro$cli+q!r|@wj%pc6xurN*nP=mSe&KSySv2_ESIqYl!1=Pbjx3 zjAibXEL94d0$PIG>XBtWpKNY=&;x(wMXz|*tNwJ`y@H#0XLBTyMWu!Vs6<$Gnx%@1 zE8SLY+FyCZ{e}(4^dh}72Q~c$i{(w z&*@3HRzR?_=w4JdM0Ai4-MGmnX!%%FHu}-S+Fh=IQ_Z zTW`7dFF$nCoe!GNP9}rwVImER#h%mTIaji*8Bk$iJ+Ye3-}R(#fA+urlh?iBH-7s6 zx#_}Tz-!Lzb2`_pnK!U5Z?;eQysvxP>t1uqW1qC`Rh>L?|#S8Lm%<*2i%m~Gxteyr*SS9mbw88T3a>3e*J~NkM&IrS!U*qox7a52!DB< z|Cjm_-eTIFZg6tVy!oljwE~6kp zhw|<`F;uHV5-2t%ER{+Gvlebl^Dw9*7BnlBfmN$@O!r>eJnSJ)#o3jy#$%0@!y4)o z^N@MLo74!<;+KY%V^-4ZgqFwx9NYjd+uBQB^?RTBDR*4Dd}ZBMtOA^s%DWL@Jdzm* z#UN-@tICLx%mE-PLy`jz^ll+W-!zYtQf7=$JR2y1jp=So6?6vRy2^#38Qfu2C3IN$ zY$X@Jy`F^SekBYT9^k>FEMt$7kCsdZ52rjRz#!zUhU(T)*)`Kp2$3xu_Tu7`i#$_n ze!x?|!GZ%bi|&do6e=m{IK~78>6STE4i1cih(ymc_fT4-xZO4+PIUP|3-r=^0}z2F z0d&M?44HsH>PirFctj%+5KO5y-eG%IoJpmb7jg+MG#fF|7KFUHE=RewA+c{w6PE$y zZV;ysuGElfTxcTmrI~?6^JdGcsF6thVv@ho(m!z>n)$LinG)g{i!z8~sKp?aOqRYf z^8o0rM&?n4va^SjP1*uekE4w?izaX( zWWM5hWi<#6>^3l|We9{sdWd;HTr{jq=RDNnlb;?cQjY90nV zJ3Bi&J?U9(-JB-P+mOhQz#;2m56I(y<+IaR zuUTpEqLmfNCcPtiK$0BYVbA_$NK(Q=asgyB=`sZPVV`cJr&>@~-DS?{_}> zj#nY#==O&nJ>b^u=FE0m^GP^tgypWpi-_TwEO!Rk#{$M)ZGUz5``@{LQ9dfZ$Jldf?c*Q*P`hyBSAYKJ^tm^0(!^WzQG4%Z z<;k+7xVz>K;OOuW#;Ph~EaJNFG97EfJ zW3Nqf)~Z>0D-jV&CWq;2wq|IN$;1v7M+Zl{kKglUpZ`^`*>;_6jhZnoVnY$p!i)%d zD5-jxSOFv$!dl2Q4^hKlAZKs~7Wm;8{O-%1{&`Q`^?6@$D#5V^jPJkp4)&|?&R4w> z7akb9v+d+z)y9QfV1>s5$^~Gn@B#_nTOXWVI{m-Cfi_4A${S}w*b8Y~1H}-h zO8}UOwb_nx`8tf@sGT#?3$_M!ZMXXyU-l(0{^cL_lc{qXQv*?ydVuIuo0Z9#Y6;LL zvr==sg~(ge*JHliiDZY2yD*=oMYNDMqRfYdoXnmKbM|y^Jrf=@P7(K9zIOA?>tFis z|M5$o{-yn44_TRYGAx29Lt2GW z%)<$HPcZL)?=Sz>i@k99WV^R&^H9_XlNjn6MSJg^JI=yu|KKIl%@3%a?5vvA%oT0L z>Q?md>P1$>q;`!4zvsUD+PRx=KYzo?c6YYx>$Suz#a*wo&O$_#ZA2XutrOv38mydi znPqzO<~V=u;-f$P3GaC8yKcSX!Sk+Qp_w!#XMo$}26#=9aCh3a=lP@KyWjh|%e@~= zE6!JK)hw0YT5jQ?IPE|sfL>a9qzx@rTASuwdAJGTBIv9Nv#J8STk(dA$GaOJwTd=P z)3$o;I?~!?9iEWt+|(zN8hb1~v$L2=*iP3&-&Tp@jD!8X`~Tu4&;Evg^Tt>F>fUOl zW);()cLS9FW>}PqV2yARR)jCIoid9EML9{W8W??#sG`9H_iBk65SHd{w;&P`!Fkk& z!ovwxmC@aFWP2)-EPZ&qE4gmMyVDogz`w%=Al?f}QhRj7- zG-CsY=0l}uk{xM4=gfs*vxJhW3P4M=$o2A$N4iiu^W z@4<^=P64`m6g3x?s{o;Srnj)USJh18(ZSLAw(>@l?F_H}i}(EUZ@u`1zy62seb-;$ z^fWy@_G)#`_uBr09(4ZvIT~#wpjF80)Cpr_D;vD8R@W?6uibVFx9psEd3JjCrdPl1 zO@I9IpX3&Xy&KLw<_Vwn#b5FTU-9(6e&;PW?H}x;l5<|2^X&AjY(CiEpS!u0JJF3{ zEVgJlXOqsP9I$3K!`d8j2=mZ5co@L`sXO30Yk_+<)>n zevk9+`27Ca$yEfZZ+n?f?R2xl2ma8WU({Od?QA=+UxTlhvzD z)~}wOJ>jl9Kkf5A_f;=@>rIdUQ>yz}+H{L59Iy+)if;{2@_AOGp=l}FEcyKC-MPG-S9yk{zgvuAqtPU8gI z7Q&H1-^Jm<*|i-%_U>1|=S@IfxqNN43L-I9H7{{+HUN?Wk)Wl~=9(Sq)Igti-}2Re z=ehs(M?UoCH{A4?C-$pXVSO^|JsmqmDHSc?@XqpLNkLfPyxE}h@P^|XZu?XMIiDgc zRx6m7x8A!~&D$+xd`_#dc#;^Exq)g;}8n@?zV{qk<~nGwSt=f&Q_D*8kc&eP4=%?JA*yL!g$wevR|S7u;> zRVw)Xdh&w17t6dV2`l!PBJa8Pp-*^31J2IQrb%(dW)?Dam<0jEAcv_E< zPhmg-AMl@Ps-!zA%LO!I%nYWP1C?3XV`}7Z()b{XiBSzCq=oLDHJX%cNNtCp*kULX zdFCnmid0F?r33iFZBl$sE;VCY#sOb7%tF(=?HNQ?uQwn#e{-cz$%mGu#iFlKdJ zH={rhl#irV8-;ce26nZWL6auOi>TqA825)8mzH8Knj%=`@;~P1A?uXRn{C9 zeOI|Rtq=B(5su1Br>DR6`!D^;pZXtfeAO#(?F_5^^}+t?);kU^9jZbbI1k&cR+~DVcixOi4(qxzlSy-iVYRls{k7k??+>}TRc3NayLRuD*T3S8ul?f} zfA=?Y@B9Nl=josQwO{!UKl?Kuf8i*O_V*CDeCaB-r#Luh<~`D22yNF^i3-*raIIi- zbtC94+!C}JTB+*2wMk>E0t#3KP*D4NCHIILMYynsraT_hNM|x+p^`F@$UI&gdM;Al zGJ-%r27nMPB;T+Uc21X;&cssM5LbdmbQH`B-FD3L`$qu27I6?O z;{Lb%$@l-vPe1KbAGN)DMQ^W5$U9CeNXG9}_9zWtR*iUrkhLVnGilUs67tY{cKI)d zcR~UuA%aa6ZJ8N?2?9bvWvzYKB!Mn_}YZ4&!@!T#Da$BI0y&c6fOF2fy>*KI6%s)laXPM`TBv!Y8X;nl@Fh>Zo8?=(P>= z#bm+c_UuGsvPWcRZ8s#7eSf{@nS~Hx=vI1wL;3qwBB#33&FHME_5S)J?|jesTORhT zuY3A-vzgjn*)V2t;M1v72}ospngJ6W+}~TH=Iq_c-ZyRzOyS0|$}FP~D1;v7?u8Ck z2rJHVqTN&A}$1y`anGqz}6ZBr2T{ELOV_O?k z(W+45X+wgfCV?2GE~_kam^YG=A^a7GE~t*2UJV8K$L_f|tyU5&S)d9dP|oGL3wVT? z!7~G%o&{@is%18B(qAU6D&5Tx#e}Mx$kVwyMwPD?j|zG@g$1M(j9G~Y+YI@^P^DCs zHxI?%IKX6CObvb8&K(+f_oaIuc*`-OP_4%IV8SQS#yw*Y@iEhk5`5`sf*H(xFq}Cq zq;gnm4nS3j!q-?F{NZ9?P_n97*=UukG=rC=UpcvU!;S5Yum6n)-}JEUy$|w(wQb96 zM)NFnN28e~%@jhaAEZf)z^WN%I6Qy;!e=~rdp6ITUEj^%YI?{+F0S{ z7T#_Q=yg39NAHwAHQLRpGJPQ0dQvo_033<#&@C(ns)O)E#t1*uEi5_G zA~A;+B1i_PY6KdSZG2EgQz+8NJ`t@c_{6*`7Yp($g!W^gjl3Cs84AFH3Ej{UFF%vS z5w6HliQ54St&wC>TaCe7u|-M~u`-9{_$$qA$QTOA^d{Y%rOa${1=FHgRhc4l1tZ&d z9t4|@uqAn&#%NA=D!_Ro0^fTu0YD)U0@uqT6H5{>VKC<73MqkgID5qLX#aQu)vk8iv=khY#S*Urf7^A^`;d8gpz%Cdx)0dtihMCs54 z-O@_hH~?W@4fH-D-8S80GOG=@RX!c8j&43Yy8SrvPMTl-=)EuerQdns^L`cUgU3AP zv0wYlFZsGJ`=X2I&%yRDpY%D6eV!&yp;Cmm3GiuZ!)Q_THhOdD79R9I(!VtjhgT-6 zhp(2T3ii!zf8F%)ej;>G7mo?aridVgXT*rbFI}A@Y!xF|OLmUY95P(?6b%In<1z{Z zAQKFID}$>O!Q|e|PiH^&-+b8{`-k6l%cnoRZ?@42nP!bM{?8l!=o#PqtbhG=fA{3{ ztP9BOoo4PKF{XjbxhCjv>5P0ge-7Psp zvD$JL6&k5{T^WVKsI8r2#ezp5vjTMYD_2f#KHC4mpZwA1Jp0+_Z~WZe&j9ODQr%{D z7_tn`f-`)AcY>8Z^1hgbnm4<7mJ2?Oo6RO!Q%vsObc$G|`Bag%1H4A{Rv!T8z-g#R!lcaS$5Nn=h1jJZ$S{&z;r#S z^l~c9)T4p(D6C1kN&Oe8On{0={mv7b=(;L-tj#cx3Igy{`3zVVK42Dv53>%CmVqjR zx6_lY8V&VEhy@yNE1ZU1?<-qPac-wpW99e5i>2aMJuRb1z$}r~i8f9HnY7yEy{DU_ zxn&MSiE=U05;2(@y0ELvCFj#YV+`#h(V`hs(!FBXrTZ=cpwR?Nh^QRk#UL_h01Id+ zwU1TP`5<%xk(I#pTdjE|1idz(l06lzWSK*gQR5!+pyG?1DPSwp$eO0r)q5{J=*Ej* z`<(Ck*&q3#n;!SHo$V&eq$>*oz-k(ir4rCeg-i<@3v%a%yEzH$t*3s_CI-kpZ*tz1 zyGJviOyv1cVN_XoD3(|ZdRi63QQ3HII{4rl-|z)r^$kz`@B&1HJDYp=A5A1Z=aJQS+Dmz0Wh0Rhia)S=R?P zq#Im|j|H3s6AL8SX;~VZmBF3%*Prw_7_yI)0Qvq*aVF+orCM&d(Zgs&1!*_l{E`>H z6jsMa=X&n21e6QZTxJ+2yG9Y#9IjGpmKh2jsMOjg)BvWqJa=;s1GEgfja(KM7$I!P z+}*0WyoWU;yKGYvOe~O_K$;QOYu=0fWWXBBY!x`uwX%S`T0cRP-OasnB(b`f6qDwD zkXd8;GZwOeDs*8hA zI*)t+Ww3}g;HBX(9ndBuSd-Fkyv*iscVrUda$ST)GSG>pCvAZ5!vrQ%U6GEUVoW66 z#BdA_4idshjaE(@2|(oFx~07C(v|9iL|AC1a+ydJxdUI?d@3=zg8&!ppi|cfm-9JB zkPuB;Vv!wEVaQLdo#(Gqln?jTKz0bToNJzYulc&cKox1FsIMU!;-YeZbXG&Gk_$Qy zsi1@6YvFWQEip1=nf6Lnga=hI!CZ7$q?(?dSvako9?sYeg}q_@8R zga7gyo^^cqh^PI-Z+!i`?>T?Ce}2EUX(GZ(6X@c~(*4OH`VBM-BdTW-UXWczZQ+Dj z!L3X`l5%U;dxs2*=B6HsCDBP+bhwT!VmwdF>{8Oaj6#UgaSy1KO#3|ozPL$DR!@=~ z^>srMGxR}vNP@84F82`}=+Gwtd%(7iB9yIQZymU;L?`{e}PK$G@}hw$_wqbGdE=Y8}|e~$GUtmro9mhcG{Xw^)4 zG|fUQ<*H57YCZfpRqie1NOQP(p{*l8_Czm1XmFMQ3SVebvg8cW^ct{)6*wJEcfa+m zk9fkTzUVi9yx^x-E>CS;ZY?arXGlA7otGR`xw+do8O6g%w9;1*o8IScKl`7)^WvR% z-TkIFwbdR2ok*a7@Q`3lEmw*JQdqEn)o39RAY}NmQKsN%!mtPW3_&jz&qt zfu8Vv-#@zl^{@B`&-msiKJo!qF5fSsEx>@NDpL)2kuynlNkoTh&Cn_gjS9&E5LTJG zFIkFNBP+=uOEC{9pPFMy%q*{jU}akbW2V-iPCGn4wlwteqys(CVCD#Si(!#Ba931@ zl3toYe=lxDor_^X8v9(mLosWW36jiYWt#j~Lo_g+-v$#?&N<~AYPyV8iXe#q%mn)B zW-+qD9hK&Yb*s~zsXM+BW&!H8u+ggkcNd~7LPqx?h+>wg+7PDX;pU;$y^qfb&U!X6lvz1_P0I%^Z)xTw>Fg?na}6PqAJ_BjFYqvAuIg7>xts4p~)=+Hf>=Z^L{GSHU zRUWJ9%Sa%`k*3f#0&s+dyICcAR`yw8!=RJtaQA3!h`u0TnIk?#>VMdXKz0nsG%Mw< zlVZY5Xdyub_bo?~O1~B2VQ8VrL0QjQwnEoZK`*X0UM-d|jCxlyxWyP^SY?T!Uh(C0 z5Ws*G$z&te*n{DpOF(C__310%@$~fgc>lqVeAt6O<8NPl%#;4? z#V>#IBR=)q9Z&l|ci(?>u%CUViy}hhY{bMu&Dxp>6oy#CtWZfSm50GbZ>c#G>ii&C zs9d*T_dd^Ntl?Mjfz!hWQ=pbKwQTC~;24=%EEQ=$co8!>FgI9MDX(a3$0O<3P*NO? zJ=llXq72nD*Zb4!-u|I?zwQq%-1Ydr*+t`SUCpPDyz-A8^_iddvfuu%Nt|BWSgdOX z7)8U#2NgF6#2Cs2B{+vsNl3sb4$>?Z;c%h47Otomb1V1=2P<6v<5fZd6!4|OVQD7R z=Um`*?scf6j0-R$5RSz@N7~A3HO1A_6T)8p;-B9;cW~d^-x8}erpZ=~0K?U3HZp-& z=}4q@T!ggYt`&uhz&dRKepb`UU2^)=_QD$PS+3Ru5vQl4?#>#5T4}i*~+i;{6vLfg} zDbx!YXfB|KTyyvH`}Ym?@CzQ9ht)YS95yo5j!5lwW(HZTZD^AlG@8M@I{TN2id1)O z=^CZ16jDP?$riNtB6^}vZsnBKs$c2-Xa|5C?#LQepm&m|Sa53c_rhTtE$6rI)q8&C-@f5n9Luw}p1N|fZ{TP>g01AY>Wrkpiik7hyKmpm+wZ^n$b*W~DM-csz3P_1*7&@rV8v1lHrl9yX;4eO@fb{=nd%ZAscar0D4n z%XV#*A7`4^)rTIwc;*=eOlOp;eT&GP8MCscQg4f?6ug9AzmDlY{qt{jv*Y3DQ3g}Y zI8v~?y0ubuua#J58WR;{S{6~Jh;lNk9RyW$ql-tN4dZZ{Ym>4~@Y=OI+Tg(|`qca< z@C4-mQD$J$7Asao7>Ed92;CC=+}8NgQ`R$m<*cr5%2saz5@U2|eb3~j#YJ0B6|AG3 z1=VJi9yJZD1=1JI6FNAgB^Bv9XN2Pa`^xKNABEDGU~ef0l%LS7iSmY;d{ympM{Z^2 z6fmQ?s{qrC9NGjsHA{%NA`=vtf+}W4D44-$MGZ4zfP^yZRB2j4x%WhW79{AFtcr5*(!*x$5JI2}K}D+ES+LxCMsB?BAjlLHbYyc^f0u>8RaKG)JN6 zHfWS84W%WMN?ol=GZ4(IsEo{j&ZTl|=}46t@#v*X>}hDpG0 zMjO3!)=XBpo=XC>^Nc(9&d=BN5R?Q6d`TG1#4)0Q?{R$d~ZOhhBZ?^vD_*S606J z7k=s`uld+t`oVuuORcwWVHoo07L^lOeJkswh$bz{C=JG?8ceFBQV2RENXmW&6&9*Y zs;2NHDauucp!GE%;gF-^yQ_qP~d>D3fZSKxz0GkjkEpPul>{yKl#BQ^tPXQ{YkFR9?xxvk(KzCWYUU&yLm&g2BTXUUG+916%1)b zNX`kPFL$4P_Msc6Z~D0(j=R79{$GB}?&>4=b5@$e%)8W{M8hS0^MILI(K2n4?IYCD zTuY{Mp{>b>LRkmY`VjJ-5y#?KPTu?GH`}%Owl{tsDlcw7=O_C@RoBO)Bya*rq`y_{ zOKl(r%%TD_Sy7d~04PNBx-$H0=}Q!6nN?cBeRs0!@4X6Lp@kqPXV9sFt@ z4?{r{QuWCZot^bnYnF`3nV@9~{8tNU*BlOd!KzpYmJOPf5BIkFBEbw&`f7KU3USqx zoH3i$Dl*d+R9!i}Qa~@eo0(18TnT&E05YF^>5C8-hFYksIg?(zVv69SBu6o;71eBk zgCyH5_FA1F5+RN{t)N*;1Ctu_G|nUnG#?#h2>@0VnUR>97thXiuv!HgZ`f1+qjEXX zkt!?qRy&#~!b;N3V1{8N1|2ChF|(4`?Uw;^RtAxTt4y&p!!*`kMVXrd1qjEdL0c^E zKlSX{)%_cP>J96AfAR3_-JPEuEh2~3pG+9ijKfm%SHu)Dv&M{^b51ZsESq-Gn3a)$ zxoXKqW=U8w++cutB8l!>1~Ljbu6N(^V_*8W{`RMT;)h<`yLWba)hdXYZaH>+0%S=@ z;;15P4J`ipH~c36cH+(nEF{X)mJWj4@Af3B!U<#?D~Gw$aQ|JO`?;Uytiw7_cKa4S zXqw@sM{e4zq$f}S2uL_r88hV@sW{%hFyKR9^Xm2PZ4!hFzjBb3Mnjon7-{gz%nrP+ zF^II+zu`Ye#bP4}qyq2QxQTWVYf(obhC8bLlrtOc7u4e#kPNbqW)<9kGWfDvAYj+c zjPn?3o&#a@(VfD|%&^FaNT{((bBzOm#fRCLMcZ_#ffIux>sZBlQbP+1Wru1>Tsp~VxGoNF*Q4GDk(KBgx&h`S63XD}`$56GG9fafLgYtgcj!v8n5x**z1!+C zi8`z#^w2towygHrUWO=eXvyjQ3R{RgX$}K2S`;QTn)b2i+VBJtV+^+BLMTKk{)rrw zQB_ml$aX%lG-nX3L9=RmqC`=$15oR>lnuHFh@pQbtHkkbIy$EewOY44seD&twK!o$ z%#dVE0y-ee=wfZZxgJiC29TV4XUb}w%?49@WlRo#)Tz}wY|N0xg{^|#P z^b;TRDc7HP^xnnH^9xBec0Q7o8D%paS@Ss8%ACyZ?o=LY23eF`0m*V7gqha9at1OZ zif|4ZXba7YZdM#cXHKPyI0_8Xz2s&QKLT?OBgc#rbB`nP{O;kf6maE{I6VWaStIHF zq|&!3)Om_-+8k`cE-MjAuvM^@5^dOjva&Fbr&mwV@l&PtfNFbhPbl23Oa!tNHr4m- z_DB#UhW0hO!8o>jWJs*rVr6Ucjs(n{E@BlhW)Y(@ubu3E{#Sne9Y6aYU-0q|INrX4 zQ!X>#_0#|PHNWk3Z~5_Wor!zTJvV7^hT9~I9EFlBSP!AN2xa=rWM1Zt_GroHBR}PH zs?y3^C`H1{P6(jKls>U5leP)|qj_QpsU;@{^`KWqZJ%8ebtVgcRXNhf%uI3(bF-(P zd+x!r<(fPu+j-PyE2ge)8}5wV(NJce{7Ef9lTK)m9X2ZdIHr`kL~#qa=lu znxzu1DFuK`2}=c6N=1L(IrpBj&nBMg%b7 z@@8s`g3X9fzMW<)p(Ev;41hx9jI0WSm@OU9lA7A-+0|#?@{4i){`b87r*J7DW^GpiTEWuGC zg=AZ*8Koq9RH0GjiqfebEJYyRxOxfz$z%}KM>Ey4S_STQ1FRQ5_Cl-|MMhCX625CXM=Zb3&f5*4KA&Ilo)0!E^6bY$$qjXO|Y1U2_XhMr1bT_4ouPWmJ z%H8!+RFy#ZV;tvU&B&rdWUGBkT_%d$*vc}j)$UbgE>b`*sZ=oqKzSI|61ui~RiOn2CKGH%MYY?{1l578 zs*P$uwRITVuSTn+yHQGd&FzY?pyh)3abH|6*D3fz+W4Ps6+*=lIXpirl$DH)YGF97H;9x zEYn^X6-6oa%|^>WvNmRE&d&SqjZS_lC5LukbPuQ8QbLG9&Z^VvXAfRKJFfNn|HrR* z@q;h>k?;P&7rgQl9{bo&x_*6kINsaM-0!&VRdrTTVLl9QiBTAYyCiQ44B(~OAyPw$ zinq&^X5|~=TUM3MA%Y_3DxnJ_8JroxJjR-pI-Ze5w=rxvSqx@{%$Z4Zq%*l3(sCXR zVXK|(P5>^$Q5ruuV6{CpdJ|B|V4$N&9Mw#PqfI)6i3l6BDul|-xf>2*Lfm1s=TWDU zR)X3V4;2AczlS~lvMN)W#;W!@3dbdekVWIr!_ht^VJoHgjtacbV#d6(J6X*?^S}So z`|BTY^99#=n0J5eJ@0(e8-Ca4eZiaF@DE1Cy?f6szSwZAk%wfERTFdgkd~;aruMgx zU3{fj00{xbYC-ct5z{supg}A^leM%#A9QZ#L*v@ENftp(L#3O+8fLc+9s;1$B?0Cw zX0@UT8Yx)K9d~=+?%g{##(3u4KlQ{bKIpw~{NZDc-TutvNm>@>G&nm(Au?-5&)PHT z1qG!b%Z4F+*sx*c#S|t)y}wmJlr-gNmX>+vIG=jQpZM~>^5ft4kC^kl&pqe7Vsk}x z895^>NZ2qvO52#El}8FC5LGs4?ky>m%fpJ!Q5aWGp1XhV!$06fPd)vX-8g;E&;OJy zbn}>pNJQq0l>P>$tC0%8A$;M6s#Qj=-Ampw65j|fH@NV(iV0MipFDW>-d}uE9S_gm z`L7S1U3>QS1;*m0?Kv}9X@r@j*f=woo2X9P$lzH3>U_O`1n_3rIWkIE$pLRN$%Y$c zztgUJ#ZS%5;ck6rHy?^lIMeK%ISt__`@{KtgTD5u)+sBx>p9ckBV(a3nqU<(EemEa zIDBijM50(;5ml*m6o!bZWEvu(+;vt67}J(KR5HUHT!s~@PEO7=+gi#stN;la%+nC( zhXa5Yz4!$@&NDMwSykXz1pD5Xcn;#7%*btMkg%?1cAroctg@zU;_PXB5 zvkD442{4igWW^M2UxYt+FDV|g3SL$-CKBZegsCi>6I^x`>(f8= z@BYxA{)?~w2Y+=2@86rJYPh`=C1eyR{g;7NC@?dwUA<1nPyL7gG#-9vJ--+lDj-uA z(Tss@iFgIFvg~Ak_nGJH^pV%R^o3DJy1V2;rO78{S2lp|l>p6Y<|fd%#9~zr z43tl(ZLF5l6Dz4fgy9Mwa=o{$3vuW3ok=B~gguXWr{q)sfHd>eeYT-WqBJ+)x3Bun z5zuO?+#Uc0H<~Xkf;SYJKvXTV%s2h~7YZ2kSaZ(K?NuMAG%l_>4C!ndJa4(-rkd2R z*gv9tsD!z@1SSw<-`XSEWj=SJznRkDiv%+xD+AawG{cy5LhW7 z#g!*y<(85bMu637elr8gVR~fHmIYQtBkNRtdZA;1OgfzY{bVOkmHieFvOI&7Fe|HM zzLjikMgYv5F%zqnf}%v&Wt$_oL=MQ;oe2X|q*%d9`K8&uA1 z5S0_dhNf6?cfq6+%$hTD&SONZhr>aRo;ejRTTqIsytl%LlLbrXLTBY-mpwXhjH$CC zXBI21Yz%k6$jF`HRFOEwgume034nQ6mEgG|!_tbAj>!?$S(`IL zfy8crOOPe?>LKQHzy8+0{q#9r+7|A4Dx0gu! zRy;I-BY-yxA^+HV?3HB?+~@?4mx5Iy z=`omPnP3vRW)zSIpfCy}g?Lv?1O)Aj46E=$Rm{pHmwg@cJ^%R!U;F`2+`jdTH+H*c zZ#^|C>o|3Ci(Yh=6K+G729lMLGb*Z&{6eh((cJ|i-UYgQ0Zq`6=$0#=@J)IWh- zBH+YsSBy2IA^Yss_e@r(UZ`TN;~~bd2OfPC=j%GES!~j30G@Ow7P46DEVJRms^D$E z7C@SrIW4L?TSR%0^vYJiRSG52-A$^5*c#CbEhm|2i404|EZF_C2OpG*TbHK*M0H}Xd)T4!Un#2)CHaJuWzt-;y=All zW<(moh04zw2+K4EraLao3de^Zy$Qm~B83?04lSrMU4C^nh5D&`m{UA6U^BBgQYX8b zoU4dgf&F?2#O`D-x_~g`G$}jH%ftt=Lqa4FFA(s==4T0Tq$6g=#o_MV=lWT_-+%wTZ~B4%<;(u+H+{|jemov-J^Mb6Wu^>#~#m=j{`)_HBl+`9Be50w&fL0mY=`>-LLw{R{?hS*1cUBq^Z%f z+QW}}jiQ(pQ;`vwgv2Z+(O#K}YJu(cAb!`!{FXHG;!r+d7F9KoIim7#n30ie!pVnA zjG7ng+4Zx!`~Elo+PimynK7z{1qk{U7gP=Zi+@_#3Fb|jnY6y-aF9vpjCDn_ft46s zT&VtTkQS~sOC~a`0*Hi?bd&6+0Aod#FXnD$2gAyhYwazpjvNk-IaiY!09TsqX)iOWrsxegM43qmlr(oA=I%v>v{p`G{3yAQ&44k? zeYDye#clDA3^R;jV(lp9M^%wAGo$AYr6?KNXJ%$@viAjKA~5P#H&ZsRvzW5PW=2$G zXlYr@h6`e*6mh7n<++h}n$ub0D`}mZg+iPAbg5TbWFe*4CZGoim68Q$dY8P+O#(0} zUxaQ*WRMlsnN85+REky320BohaA71I{S_E3D=WHeQnrQ?JYIUkq*0;{d`&ZfOchX= zhLj3K^Akq#lM<=AJGXHRX7rMSP{<8nvUDg6xXi`JFr|+-Lo!p*y&#phsOKq=Xj78p z5k;c`mckTjLuRVkwBEPGLkQjw30+$hh!N7YLn%f)SVh%CS8qJ~7z`cZ|uj;lq3Yma1+>I?GwZ&33ykC+L-x$du1xbCJ_%?t`EU z2-;LKHU@gFgbdhZ4M{UgYnImILHcla8*aXHcS0I=6-3iXqhkzXCIVqe3p3c&t0zE> z-DvCG=7_H%YihuiXtIb>He#6%E8rMM{rB>RxA?WR+2wxh07%aSv-VMCr}aczWiLfP zRWjP6%F^jsRkK9E$@T~9)j{BizDi0e*)bHw_SDMYBU~OBBM$3lyzbSn`1sF$^us>* z_kGdt`L6%)&9~q6qhI_7KlN~NesSkHUv`_gP?EDwqC$J8ot zN&1QbrQ>FsLbpI7iID>(u}nd~*d~rbuduEU-sBW(wGEKf$px|;iKY`{Cd-q$FJvkx zaM;-GZr#0Yhxt9<{MY~azx=ktbHD!nAN}6rb9Z)U4~*pmLs&|gnK_qXm%X!?6IH`u zF70(jPDxe*8K^Krt&Sm6m^*->iEv=K^5_e{^w0hu?|9FxlV!nz+6^vd6`4^K37>rn zwivb=1rvweVpV;(+cpFM2rEL=rBB!dm$Tii=kDx*AN#l8_|@O^^?c7Sz3)eV02TY2 zr+eCQW@Tos7Aq|{q|SEtrgn@%BU%^1w47-*U3|(RGu^J7?XH}?@0Z{D^e=w@7ypGn z`;IsM+nvYl+xM6KPRh#aHB>OPSCc+Ek9%_t^^Bv+U}FdPt=o4ok1~yhMBSEIu?mcX z6LvH#W3j5pIwBDl*Y~2cEp@M0CxIxOI?JlcPi$5o_{a+$nsL783Capg2fUJqTmepm zDHliGls!11=%%a7M`c&;$#vN{&aCL@p1@3Iv@@(in=oj;$Oapg88ah`d02Tw@yVMH z1ek6`xmS#|>`B2g8Bw6W^5riDz!@wLK;`3|=!)%DHBCifA~BafLeC&K_07Y(EZ zr;^ktR9N?fbJ&0=02TKk0P6kC2uBpN)(I4CLDfXLiM*ton$na(PG8xlq6{qAqq4HX zD^P)C_Klfjt>v(syMfC4$F)*WUyNqMgr+GyMtBf%PHN_A(JKn*lB}#MTgxhO|8W10 zeD){*^;y~l z=*x2?ZNED?S$6M!<1gNQ`_KM^fBKDo=PUk99M`+|@9j>`7TGkC6EU-9UJ64p`#6xz zJd^qQH~g^KIu}&IQtC8o$tN9FhIEILlLVhEXFJ^gwJ-d_-)C6Qk1LIH)yvqkST?1o zrIxs?V^r6b;K*q5Ol7uinN<%x_#k7scYZX-60zuwR1+hDm2%;mo+awha6fU>@*Us( z!&%Po!&>W6>XFvzfkYyqAcVB6wIURV$imcVlmgo>g%y31wewILYha&B* zVnHxs#$-&jyec_^a|%sC25Ko|j!|nZzRt`sOozNQzv5xrDo!}0p@chofY-(%MK~cy zi*4#Dn7*gZ@@MOa!S2{-il%u10}9L%C*AU#k~LPnxX8)~x%Q(<`tB*z0c<_z=7SJm zE`q|g51yJB6Psc_LtvBguM=s~WgrU(%*v@-Ny7YQECgy6ret~9uoN{l_9lU^YmcV$oPO76-S=aV9!!5^# z^|=eJ&;p7|iglgK(Rxa#I79qlNok6XUQ7t@mx&{*|3*_@T*FnGB(%P`qk&{S1ez`s z`>Bsj%fXuHfefHDh`w2j!-oze&(X#g z(X#ub@U^;kaj_?U=|{i$y+8A>{`FUX`KN!N#a`b9TP=(5E{MT1g zsRKb72bt|q)A@*k+$6dtvdVn9d+*-e`}aTpb3f^L_idl`N50_hTYl=@Km7yePd~Fi zyUwL@Fi=rZ^JrATx}f2oZ5oo)C?@UP_~?BOK%~-r90nQe>SD1Tv~c5r82xvy#K?*4^8&+MoY| z-}j!UfBBO>`*WW9+5hz3H@@litSi^AaW?>~XsOweQ#=Yd&I*vH_rSg{>zX5gTL{=PMf!H-O;bG=_EA{v-iScO1oB+dA%Qnrb}}{ z0eJR(@5T_J+07PJE~!98&N(B(3XyY4-s%hL_|lg=PS~6?3TW-CdASrrWYNr%F;_Sq zdiX)yxySv`uc)4HRxRdWW%;UzOud{;nrNuZYLc7)45Msu$n6LgJAQ;wQ&4#K8@a=! zKc(u3<@$;Mqr#2%Cyu!J@HK}CHaD}<{3@@mbaGx*@sbxkgt1%WqQ*$K#+#B6QvxTz zt!S`-nD*w3lqjosBD&0PR@K!(X2}v~=q6E6L}dsRwA5@078r;bh`B~&+Wq_Y0o$V@ z)9E#5u|pCzzjTw#E+qoyZg^pxFyzU--6Z~lNMU-Z5o|DN+(cdlN$fgBk%jb2fBfv7`psNOeWN}9ahd}H7$$q~-eeS*Qe$ShJ=*h>fy!Y;Z{bOJ7 zSr>Qj-95k9Ehnf7iG3=R52ImB@k$9Yr%2+xS(Sa~>;FSudGv&a3M^DblfI2LW=74q zrVeE3=AHB20oeb6&-=83kMfKa=nxld_N}U_&dzU#t*#WL#1y3+2ucnISQatIusXr< zx%)mmWzDgI*dMwO5m-}SslUd2al`V^cYWUvTjt5$5;43GqUnT$mw+Rtp<6QCEWNl> zB}wEcLlk@8qJlXk;Li5(5>TsbJhPu&PqpNA;Pq&n(Ct)a%QtZBXGp z4Xc6MPD>4aeQTIdd6vf8%2sm-fV2*P-}ZUUM0&;}w&B%CgW3E|UOvi!QOZ%(;v)fy z8x?-xrnDn52{MMcn|r6z&|16QP6Sq|nk_ej0_C){t~zkdFa^^6vS7JU5tW=&88})? z5K1$s#as`#6gcB@B^PR120@J}IZ0j`JJ47ftt`-Dw1Od3STFjdgl4IplZMQsTNI@G za@Qzc4VJ^bCwwSZ2+B|C0tQ^(<(i|6EGy&I9oxKD_E?!fAuH9$DDd9;FVVdZS`TAj zrC0}v6WDHj>FIP#l=|pUG^<(WY6futsL**KEm(O1S3zOJ+|Y*=}Bu3OkXuPdflAiXPlvtO_G- z47O&kjEq?}`Z>>3g`-@UH8XVgumG4eU^Sa?BZ-($V0O_{N&}4DNdZ;?I5{@!m%^`T z0;ZiOW0}WUGi(@x#!%HMcgE&3f@Fb1HdD#O35g&!22OfWZZ#9AsEq^=%&oH^BwzEg zG*$#iC~ zI8CVjMvOEk#qIUVEm9Y)6HmDu_ZofVJ<_A6W_=7w-+no$M9%hm;k%+O-90XGpN-LsPWL4~J7bw83+rafB z0hcQ}?fm@yBTqc}81*Hpo*#X|*^Osz-(Gg2!y1kOfvH$d&ly|NsR^S%`^f~& zS81+=!t!gDhD=Ehr*SuYJ->g4M|8_=T@{ z=~%8_94}C`!wAe2yE)e>@MyHt%gC{_#TP5i^LxMklfQ^~-*WSbzxNNn{!jnW&m`>r z?K`tDcIxB-os5``mMgvDp5A^QmAgZ(A*Q%Z@cb z4jZtro!dOwpW^sj%z@xY8_ucIVdF>GE?P52%?jX&haZJq#5~SfV>gk;TCH#Gyf;u&?PHzD2- zwz(xRSxyeBLOncp6Z7!QGdCZ4_$@#8oqzT3|MM^Zb6ia9p$w|b;Gw*u(_!~dR)3dMsy1(`3zUU9K z@a$91@Wg30qZHe2(i*^YRtu-BOG^xx6(?sW5%@1Z^K*9Xq4V<#(ARmCZGDWM>1KtI z%yo?_bnN)u_r3q>jVB(xdJ>0qw=*}-vcL+s)Y=)H5QPjgQ+`E}Iz_87#;PiqxYz`+ z&ULqpho5}$Q@4{oBJQEwhcjmB8>k?CT~|lt^g-r~v^t!xeDtB8`H44@X8V&mKc`hn z{hn2{;XaW>`2y^(?6^c7n1o|Z**h5Qq033g4M~)xXBj*z%#3by$#LNWMhm2+6_Lr6 zIcxzE<%x8Hm=@-XA6IxC<8-W(%WlElI~U`wn_V1NGXPm3TVzY8lqRVEh$0c7>3?!# z2`=s1vQ)Bd8gF$MD~_dukPsczEumn`W*X~(=GA^a0IJiMTjEx3h7D7auMpx^(N@EA z)!0&|jH&Da6ll_{LF{tH(vZkXnzj|+o=Vz4MO63Q>wMSjU#NoFQW?sOaiPi8{&K8-3nH~#4N&@eV_}#VC=^)@EP?|1QAUzbAP0zE z0~$8&r%;BL;WjhnEh&>1tcvW~HS53E1u;aKrgv0jvV)?kYg#3r$tK<|#mU>3>)H8b z$zq16oi<}=2&_glD4%%FG-<3&;JrzWCPj??GN2GNM^+gunX**2@4CQ3Q~>6()n^n< z^=^egnm%h*CFlu~hZu#62dQJ@eo+WLxt%%4nM@6YQ)!iah zft8AD)rXiW|0bYKxmueO73`RL%TcAAuG+XBxKJ-)Y{q_9^p#~rw$Qvx6)!Bz%BbO% z1=`3?9aSpr#BLM-48a8g5v`-X4DzkZTLU370%^jQh1p6q&V;#MrmB=asbdHhiX@RI ziHdJiaHMn?2}PQ!s6J4>oDEA~M(%eeaJ<{WV{D{^>xqO`MZDRZ~o(d^tJ!!H-7YcffHPP|C#sT;x^*q$q)XBulkC=^?ASdb?(5dXKvrNMVT;j z#_DAer7ZJk;+`sy@eYYGqB~5X;~0eFWWNV+|48iie*M~h9>?Of=0&WPI2@1j_MLUT z$oofJ+(lg=FEEMuG+3Yh$sZMxDXgIfjvGs+`I!vZlC?VOp%*-W0`^y6_i2kIYShp} zF0Ubwv@*jiBL*wr@L@m<_mE?H5atz5?0guPsekFPoZ)7vqQpcT4=mnCF5q0_aQl29 zu*SvxyLq_4@iuC5zW<3QAI(~UNjSg(z%0A1fKKdpXKTf&?Z(;l!Z=+PlpS-HBS4^b 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

?QX)!cX02zk*HF+6-r&%9$xc< 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