├── .github
    └── images
    │   └── jizzarr.png
├── .gitignore
├── LICENSE
├── README.md
├── jizzarr
    ├── app.py
    ├── config.py
    ├── models.py
    ├── search_stash.py
    ├── watcher.py
    └── web
    │   ├── static
    │       ├── Jdownloader.png
    │       ├── collection.css
    │       ├── config.css
    │       ├── favicon.ico
    │       ├── index.css
    │       ├── logs.css
    │       ├── script.js
    │       ├── stash.png
    │       ├── styles.css
    │       └── tpdblogo.png
    │   └── templates
    │       ├── collection.html
    │       ├── config.html
    │       ├── index.html
    │       ├── logs.html
    │       └── stats.html
├── poetry.lock
└── pyproject.toml


/.github/images/jizzarr.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Serechops/Jizzarr/ab59265a44f80a192dfd243d2ab20be3cface2f6/.github/images/jizzarr.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | **/.DS_Store
 2 | .vscode
 3 | .idea
 4 | __pycache__/
 5 | .coverage
 6 | /htmlcov/
 7 | cov.xml
 8 | coverage.xml
 9 | UNKNOWN.egg-info/
10 | dist/
11 | node_modules
12 | .env
13 | .flakeheaven_cache
14 | .ruff_cache
15 | Thumbs.db
16 | jizzarr/instance
17 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <https://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # <img src=".github/images/jizzarr.png" alt="Jizzarr" width="36" align="left" /> Jizzarr
 2 | 
 3 | ## Introduction
 4 | Jizzarr is a web application designed to manage and organize adult content metadata. It has the ability to integrate with both TPDB and Stash.
 5 | 
 6 | ## Releases
 7 | 
 8 | Please check the [Releases](https://github.com/Serechops/Jizzarr/releases) page for the latest Jizzarr binaries.
 9 | 
10 | ## Key Features
11 | 
12 | 1. API Integration
13 | - **ThePornDB (TPDB) Integration**: Fetches scene details and metadata from TPDB.
14 | - **Stash Integration**: Allows population of sites and scenes from the Stash service.
15 | 
16 | ### 2. Scene Matching
17 | Jizzarr offers a powerful scene matching feature using fuzzy logic and UUID tags. It supports:
18 | - Matching scenes based on title, date, performers, and duration.
19 | - Using custom UUID tags embedded in video files for precise matching.
20 | 
21 | ### 3. Library Directory Management
22 | Jizzarr allows setting up and managing library directories. It can:
23 | - Scan and match directories with site names.
24 | - Automatically update site directories with new files.
25 | 
26 | ### 4. User Interface
27 | - **Configuration Page**: Set up and manage endpoints, API keys, and library directories.
28 | - **Collection Page**: View and manage the collection of sites and scenes.
29 | - **Statistics Page**: Display comprehensive statistics about the collection.
30 | - **Logs Page**: View and download application logs.
31 | 
32 | ### 5. System Tray Integration
33 | A system tray icon provides easy access to open the application in a browser and quit the application.
34 | 
35 | ## Getting Started
36 | 
37 | ### Prerequisites
38 | - Python 3.9 or later
39 | - Poetry
40 | 
41 | ### Installation
42 | 
43 | 1. Clone the repository:
44 |     ```sh
45 |     git clone https://github.com/your-repository/jizzarr.git
46 |     cd jizzarr
47 |     ```
48 | 
49 | 2. Install the required packages:
50 |     ```sh
51 |     poetry install
52 |     ```
53 | 
54 | ### Running the Application
55 | 
56 | 1. Start the application:
57 |     ```sh
58 |     poetry run python app.py
59 |     ```
60 | 
61 | 2. Open your browser and navigate to `http://127.0.0.1:6900`.
62 | 
63 | ## Usage
64 | 
65 | ### Configuration
66 | - Navigate to the configuration page to set up Stash and TPDB API keys, endpoints, and download folder.
67 | - Add or remove library directories.
68 | 
69 | ### Collection Management
70 | - View and manage sites and scenes in your collection.
71 | - Add new sites and scenes manually or populate from Stash.
72 | 
73 | ### Scene Matching
74 | - Use the scene matching feature to automatically match video files with scenes in the database.
75 | - View potential matches and manually match scenes if necessary.
76 | 
77 | ### Logs
78 | - Monitor application logs in real-time.
79 | - Download logs for offline review or troubleshooting.
80 | 
81 | ### Statistics
82 | - View detailed statistics about the number of scenes, total and collected duration, average site rating, and more.
83 | 
84 | ## License
85 | This project is licensed under the Unilicense.
86 | 
87 | ## Acknowledgments
88 | - To Gykes and having this crazy inspiration!
89 | - ThePornDB and Stash for their comprehensive adult content databases and media management system.
90 | 


--------------------------------------------------------------------------------
/jizzarr/config.py:
--------------------------------------------------------------------------------
 1 | class Config:
 2 |     SQLALCHEMY_DATABASE_URI = 'sqlite:///jizzarr.db'
 3 |     SQLALCHEMY_TRACK_MODIFICATIONS = False
 4 |     SQLALCHEMY_ENGINE_OPTIONS = {
 5 |         'pool_size': 20,
 6 |         'max_overflow': 30,
 7 |         'pool_timeout': 30,
 8 |         'pool_recycle': 1800,
 9 |     }
10 | 


--------------------------------------------------------------------------------
/jizzarr/models.py:
--------------------------------------------------------------------------------
  1 | import datetime
  2 | 
  3 | from flask_sqlalchemy import SQLAlchemy
  4 | from sqlalchemy import Index
  5 | from sqlalchemy.dialects.sqlite import JSON
  6 | from sqlalchemy.orm import configure_mappers
  7 | 
  8 | db = SQLAlchemy()
  9 | 
 10 | 
 11 | class Config(db.Model):
 12 |     id = db.Column(db.Integer, primary_key=True)
 13 |     key = db.Column(db.String, unique=True, nullable=False)
 14 |     value = db.Column(db.String, nullable=False)
 15 | 
 16 | 
 17 | class Site(db.Model):
 18 |     id = db.Column(db.Integer, primary_key=True)
 19 |     uuid = db.Column(db.String, unique=True, nullable=False)
 20 |     name = db.Column(db.String, nullable=False)
 21 |     url = db.Column(db.String)
 22 |     description = db.Column(db.Text)
 23 |     rating = db.Column(db.Float)
 24 |     network = db.Column(db.String)
 25 |     parent = db.Column(db.String)
 26 |     logo = db.Column(db.String)
 27 |     home_directory = db.Column(db.String)
 28 |     scenes = db.relationship('Scene', backref='site', lazy=True)
 29 | 
 30 | 
 31 | class Scene(db.Model):
 32 |     id = db.Column(db.Integer, primary_key=True)
 33 |     site_id = db.Column(db.Integer, db.ForeignKey('site.id'), nullable=False)
 34 |     title = db.Column(db.String, nullable=False)
 35 |     date = db.Column(db.String)
 36 |     duration = db.Column(db.Integer)
 37 |     image = db.Column(db.String)
 38 |     performers = db.Column(JSON)
 39 |     status = db.Column(db.String)
 40 |     local_path = db.Column(db.String)
 41 |     year = db.Column(db.Integer)
 42 |     episode_number = db.Column(db.Integer)
 43 |     slug = db.Column(db.String)
 44 |     overview = db.Column(db.Text)
 45 |     credits = db.Column(JSON)
 46 |     release_date_utc = db.Column(db.String)
 47 |     images = db.Column(JSON)
 48 |     trailer = db.Column(db.String)
 49 |     genres = db.Column(JSON)
 50 |     foreign_guid = db.Column(db.String)
 51 |     foreign_id = db.Column(db.Integer)
 52 |     url = db.Column(db.String(255))
 53 | 
 54 |     def __init__(self, site_id, title, date, duration, image, performers, status, local_path, year, episode_number, slug, overview, credits, release_date_utc, images, trailer, genres, foreign_guid, foreign_id, url):
 55 |         self.site_id = site_id
 56 |         self.title = title
 57 |         self.date = date
 58 |         self.duration = duration
 59 |         self.image = image
 60 |         self.performers = performers
 61 |         self.status = status
 62 |         self.local_path = local_path
 63 |         self.year = year
 64 |         self.episode_number = episode_number
 65 |         self.slug = slug
 66 |         self.overview = overview
 67 |         self.credits = credits
 68 |         self.release_date_utc = release_date_utc
 69 |         self.images = images
 70 |         self.trailer = trailer
 71 |         self.genres = genres
 72 |         self.foreign_guid = foreign_guid
 73 |         self.foreign_id = foreign_id
 74 |         self.url = url
 75 | 
 76 |     def to_dict(self):
 77 |         return {
 78 |             'id': self.id,
 79 |             'site_id': self.site_id,
 80 |             'title': self.title,
 81 |             'date': self.date,
 82 |             'duration': self.duration,
 83 |             'image': self.image,
 84 |             'performers': self.performers,
 85 |             'status': self.status,
 86 |             'local_path': self.local_path,
 87 |             'year': self.year,
 88 |             'episode_number': self.episode_number,
 89 |             'slug': self.slug,
 90 |             'overview': self.overview,
 91 |             'credits': self.credits,
 92 |             'release_date_utc': self.release_date_utc,
 93 |             'images': self.images,
 94 |             'trailer': self.trailer,
 95 |             'genres': self.genres,
 96 |             'foreign_guid': self.foreign_guid,
 97 |             'foreign_id': self.foreign_id,
 98 |             'url': self.url,
 99 |         }
100 | 
101 | 
102 | class LibraryDirectory(db.Model):
103 |     id = db.Column(db.Integer, primary_key=True)
104 |     path = db.Column(db.String, nullable=False, unique=True)
105 | 
106 | 
107 | # Configure mappers to use confirm_deleted_rows=False
108 | configure_mappers()
109 | for mapper in db.Model.registry.mappers:
110 |     mapper.confirm_deleted_rows = False
111 | 
112 | # Add indexing for the Scene model
113 | Index('idx_scene_foreign_guid', Scene.foreign_guid)
114 | 
115 | 
116 | class Log(db.Model):
117 |     id = db.Column(db.Integer, primary_key=True)
118 |     level = db.Column(db.String, nullable=False)
119 |     message = db.Column(db.Text, nullable=False)
120 |     timestamp = db.Column(db.DateTime, default=datetime.datetime.now(datetime.timezone.utc), nullable=False)
121 | 


--------------------------------------------------------------------------------
/jizzarr/search_stash.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | 
  3 | import requests
  4 | from flask import Flask
  5 | 
  6 | from jizzarr.models import db, Site, Scene
  7 | 
  8 | 
  9 | def create_app():
 10 |     app = Flask(__name__)
 11 |     app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///jizzarr.db'
 12 |     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 13 |     db.init_app(app)
 14 |     return app
 15 | 
 16 | 
 17 | def get_scenes_for_site(site_uuid):
 18 |     app = create_app()
 19 |     with app.app_context():
 20 |         site = Site.query.filter_by(uuid=site_uuid).first()
 21 |         if not site:
 22 |             print(f'Site not found for UUID: {site_uuid}')
 23 |             return {'error': 'Site not found'}, 404
 24 | 
 25 |         print(f'Site found: {site.name}')
 26 | 
 27 |         scenes = Scene.query.filter_by(site_id=site.id).all()
 28 |         scene_list = []
 29 |         for scene in scenes:
 30 |             scene_list.append({
 31 |                 'id': scene.id,
 32 |                 'title': scene.title,
 33 |                 'date': scene.date,
 34 |                 'duration': scene.duration,
 35 |                 'image': scene.image,
 36 |                 'performers': scene.performers,
 37 |                 'status': scene.status,
 38 |                 'local_path': scene.local_path,
 39 |                 'year': scene.year,
 40 |                 'episode_number': scene.episode_number,
 41 |                 'slug': scene.slug,
 42 |                 'overview': scene.overview,
 43 |                 'credits': scene.credits,
 44 |                 'release_date_utc': scene.release_date_utc,
 45 |                 'images': scene.images,
 46 |                 'trailer': scene.trailer,
 47 |                 'genres': scene.genres,
 48 |                 'foreign_guid': scene.foreign_guid,
 49 |                 'foreign_id': scene.foreign_id
 50 |             })
 51 | 
 52 |         return scene_list
 53 | 
 54 | 
 55 | def search_stash_for_matches(scenes):
 56 |     stash_endpoint = "http://192.168.1.54:9999/graphql"
 57 |     stash_headers = {
 58 |         "Accept-Encoding": "gzip, deflate, br",
 59 |         "Content-Type": "application/json",
 60 |         "Accept": "application/json"
 61 |     }
 62 | 
 63 |     for scene in scenes:
 64 |         foreign_guid = scene.get('foreign_guid')
 65 |         if not foreign_guid:
 66 |             continue
 67 | 
 68 |         print(f'Searching Stash for ForeignGUID: {foreign_guid}')
 69 | 
 70 |         query = {
 71 |             "query": f"""
 72 |                 query FindScenes {{
 73 |                     findScenes(
 74 |                         scene_filter: {{
 75 |                             stash_id_endpoint: {{
 76 |                                 stash_id: "{foreign_guid}"
 77 |                                 modifier: EQUALS
 78 |                             }}
 79 |                         }}
 80 |                     ) {{
 81 |                         scenes {{
 82 |                             title
 83 |                             files {{
 84 |                                 path
 85 |                             }}
 86 |                         }}
 87 |                     }}
 88 |                 }}
 89 |             """
 90 |         }
 91 | 
 92 |         try:
 93 |             response = requests.post(stash_endpoint, json=query, headers=stash_headers)
 94 |             if response.status_code != 200:
 95 |                 print(f'Error {response.status_code}: {response.text}')
 96 |                 continue
 97 | 
 98 |             result = response.json()
 99 |             matched_scenes = result['data']['findScenes']['scenes']
100 | 
101 |             if matched_scenes:
102 |                 matched_scene = matched_scenes[0]  # Assuming first match is the desired one
103 |                 title = matched_scene['title']
104 |                 file_path = matched_scene['files'][0]['path'] if matched_scene['files'] else 'No file path'
105 |                 print(f'Match found for ForeignGUID {foreign_guid}: Title: {title}, File Path: {file_path}')
106 | 
107 |         except requests.exceptions.RequestException as e:
108 |             print(f'Request failed: {e}')
109 | 
110 | 
111 | def main():
112 |     if len(sys.argv) != 2:
113 |         print("Usage: python get_scenes.py <site_uuid>")
114 |         sys.exit(1)
115 | 
116 |     site_uuid = sys.argv[1]
117 |     scenes = get_scenes_for_site(site_uuid)
118 |     if isinstance(scenes, dict) and 'error' in scenes:
119 |         print(scenes['error'])
120 |     else:
121 |         search_stash_for_matches(scenes)
122 | 
123 | 
124 | if __name__ == "__main__":
125 |     main()
126 | 


--------------------------------------------------------------------------------
/jizzarr/watcher.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import logging
  3 | import os
  4 | import re
  5 | import shutil
  6 | import time
  7 | from pathlib import Path
  8 | 
  9 | import requests
 10 | from flask import Flask
 11 | from mutagen.mp4 import MP4, MP4Tags
 12 | from sqlalchemy import create_engine, inspect
 13 | from sqlalchemy.orm import sessionmaker
 14 | from watchdog.events import FileSystemEventHandler
 15 | from watchdog.observers import Observer
 16 | 
 17 | from jizzarr.models import db, Site, Scene, Config
 18 | 
 19 | logging.basicConfig(level=logging.INFO)
 20 | logger = logging.getLogger(__name__)
 21 | 
 22 | # Flask application for database context
 23 | main_path = Path(__file__).parent.parent.resolve() / 'jizzarr'
 24 | app = Flask(__name__)
 25 | # Using an absolute path to the database file
 26 | db_path = main_path / 'instance' / 'jizzarr.db'
 27 | app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{db_path}'
 28 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
 29 | db.init_app(app)
 30 | 
 31 | 
 32 | def initialize_database():
 33 |     with app.app_context():
 34 |         db.create_all()
 35 |         # Log the existing tables
 36 |         inspector = inspect(db.engine)
 37 |         tables = inspector.get_table_names()
 38 |         if 'site' not in tables:
 39 |             logger.error("The 'site' table does not exist. Ensure database initialization.")
 40 |             raise Exception("Database not properly initialized. 'site' table is missing.")
 41 | 
 42 | 
 43 | class Watcher:
 44 |     DIRECTORY_TO_WATCH = None
 45 | 
 46 |     def __init__(self):
 47 |         self.observer = Observer()
 48 | 
 49 |     def run(self):
 50 |         if not self.DIRECTORY_TO_WATCH:
 51 |             logger.error("No directory to watch")
 52 |             return
 53 |         self.scan_existing_files(self.DIRECTORY_TO_WATCH)  # Scan existing files on start
 54 |         event_handler = Handler()
 55 |         self.observer.schedule(event_handler, self.DIRECTORY_TO_WATCH, recursive=True)
 56 |         self.observer.start()
 57 |         logger.info(f"Started watching directory: {self.DIRECTORY_TO_WATCH}")
 58 |         try:
 59 |             while True:
 60 |                 time.sleep(5)
 61 |         except KeyboardInterrupt:
 62 |             self.observer.stop()
 63 |             logger.info("Observer stopped")
 64 |         self.observer.join()
 65 | 
 66 |     @staticmethod
 67 |     def scan_existing_files(directory):
 68 |         logger.info(f"Scanning existing files in directory: {directory}")
 69 |         for root, _, files in os.walk(directory):
 70 |             for file in files:
 71 |                 file_path = os.path.join(root, file)
 72 |                 if file_path.endswith(('.mp4', '.m4v', '.mov', '.json')):
 73 |                     logger.info(f"Processing existing file: {file_path}")
 74 |                     Handler().process_file(file_path, directory)
 75 | 
 76 | 
 77 | class Handler(FileSystemEventHandler):
 78 |     def process(self, event):
 79 |         if event.is_directory:
 80 |             return None
 81 |         elif event.event_type == 'created':
 82 |             logger.info(f"New file detected: {event.src_path}")
 83 | 
 84 |             # Ignore .part files
 85 |             if event.src_path.endswith('.part'):
 86 |                 logger.info(f"Ignoring .part file: {event.src_path}")
 87 |                 return
 88 | 
 89 |             # Wait for the file to be completely written
 90 |             time.sleep(5)  # Adjust the delay as necessary
 91 | 
 92 |             # Ensure the file exists and is not empty
 93 |             if not os.path.exists(event.src_path) or os.path.getsize(event.src_path) == 0:
 94 |                 logger.warning(f"File {event.src_path} does not exist or is empty after waiting")
 95 |                 return
 96 | 
 97 |             if event.src_path.endswith(('.mp4', '.m4v', '.mov', '.json')):
 98 |                 logger.info(f"Detected new file: {event.src_path}")
 99 |                 self.process_file(event.src_path, Watcher.DIRECTORY_TO_WATCH)
100 | 
101 |     def on_created(self, event):
102 |         logger.info(f"on_created event detected: {event.src_path}")
103 |         self.process(event)
104 | 
105 |     @staticmethod
106 |     def process_file(file_path, download_dir):
107 |         if file_path.endswith('.json'):
108 |             process_json_file(file_path, download_dir)
109 |         else:
110 |             uuid = fetch_custom_tag(file_path)
111 |             if uuid:
112 |                 matched = match_scene_by_uuid(uuid, file_path)
113 |                 if matched:
114 |                     logger.info(f"Automatically matched file {file_path} by UUID {uuid}")
115 |                 else:
116 |                     logger.info(f"No match found for file {file_path} with UUID {uuid}")
117 | 
118 | 
119 | def fetch_custom_tag(file_path):
120 |     try:
121 |         video = MP4(file_path)
122 |         if "----:com.apple.iTunes:UUID" in video:
123 |             return video["----:com.apple.iTunes:UUID"][0]  # Retrieve the custom UUID tag
124 |         else:
125 |             return None
126 |     except Exception:
127 |         return None
128 | 
129 | 
130 | def match_scene_by_uuid(uuid, file_path):
131 |     with app.app_context():
132 |         engine = create_engine(f'sqlite:///{db_path}')
133 |         session = sessionmaker(bind=engine)()
134 | 
135 |         try:
136 |             matching_scene = session.query(Scene).filter_by(foreign_guid=uuid.decode('utf-8')).first()
137 |             if matching_scene:
138 |                 matching_scene.local_path = file_path
139 |                 matching_scene.status = 'Found'
140 |                 session.commit()
141 |                 logger.info(f"Automatically matched scene ID: {matching_scene.id} with file: {file_path}")
142 |                 return True
143 |             else:
144 |                 logger.info(f"No match found for UUID: {uuid}")
145 |                 return False
146 |         except Exception as e:
147 |             logger.error(f"Failed to match file {file_path} with UUID {uuid}: {e}")
148 |             return False
149 |         finally:
150 |             session.close()
151 | 
152 | 
153 | def process_json_file(json_file_path, download_dir):
154 |     with app.app_context():
155 |         engine = create_engine(f'sqlite:///{db_path}')
156 |         session = sessionmaker(bind=engine)()
157 | 
158 |         try:
159 |             json_file_path = str(json_file_path)  # Ensure the path is a string
160 |             if json_file_path.endswith('.json'):
161 |                 with open(json_file_path, 'r') as f:
162 |                     data = json.load(f)
163 | 
164 |                 scene_url = data['URL']
165 |                 original_filename = data['filename']
166 |                 metadata = fetch_metadata(scene_url)
167 | 
168 |                 if metadata:
169 |                     new_filename = construct_filename(metadata, original_filename)
170 |                     original_filepath = os.path.join(download_dir, original_filename)
171 |                     new_filepath = os.path.join(download_dir, new_filename)
172 | 
173 |                     # Only rename if the original file exists
174 |                     if os.path.exists(original_filepath):
175 |                         try:
176 |                             os.rename(original_filepath, new_filepath)
177 |                             logger.info(f"Renamed {original_filename} to {new_filename}")
178 | 
179 |                             # Tag the file with metadata before moving
180 |                             tag_file_with_metadata(new_filepath, metadata)
181 |                             logger.info(f"Metadata tagged for file {new_filepath}")
182 | 
183 |                             # Update the JSON file with the new filename
184 |                             data['filename'] = new_filename
185 |                             new_json_filepath = os.path.join(download_dir, new_filename.replace(new_filename.split('.')[-1], 'json'))
186 |                             os.rename(json_file_path, new_json_filepath)
187 |                             with open(new_json_filepath, 'w') as f:
188 |                                 json.dump(data, f, indent=4)
189 |                             logger.info(f"Updated and renamed JSON file {json_file_path} to {new_json_filepath} with new filename {new_filename}")
190 | 
191 |                             # Move the files and update paths
192 |                             new_file_path, new_json_file_path = move_files_to_site_directory(new_filepath, new_json_filepath, metadata['site']['name'], session)
193 | 
194 |                             # Added delay after moving the file
195 |                             time.sleep(2)
196 | 
197 |                             # Directly match the scene using the scene URL
198 |                             if new_file_path:
199 |                                 match_scene_with_uuid(metadata['foreign_guid'], new_file_path, session)
200 |                             else:
201 |                                 logger.error(f"Failed to move file {new_filepath}")
202 | 
203 |                             return new_filename
204 |                         except Exception as e:
205 |                             logger.error(f"Failed to rename file: {e}")
206 |                     else:
207 |                         logger.error(f"File {original_filename} not found.")
208 |                         return None
209 |                 else:
210 |                     logger.error("Failed to fetch metadata.")
211 |                     return None
212 |         finally:
213 |             session.close()
214 | 
215 | 
216 | def fetch_metadata(scene_url):
217 |     response = requests.post('http://localhost:6900/get_metadata', json={'scene_url': scene_url})
218 |     if response.status_code == 200:
219 |         return response.json()
220 |     else:
221 |         logger.error(f"Failed to fetch metadata: {response.status_code}")
222 |         return None
223 | 
224 | 
225 | def construct_filename(metadata, original_filename):
226 |     performers = ', '.join([performer['name'] for performer in metadata['performers']])
227 |     file_extension = original_filename[original_filename.rfind('.'):]
228 |     new_filename = f"{metadata['site']['name']} - {metadata['date']} - {metadata['title']} - {performers}"
229 |     return sanitize_filename(new_filename + file_extension)
230 | 
231 | 
232 | def tag_file_with_metadata(file_path, metadata):
233 |     try:
234 |         logger.info(f"Tagging file {file_path} with metadata: {metadata}")
235 |         video = MP4(file_path)
236 |         video_tags = video.tags or MP4Tags()
237 |         video_tags["\xa9nam"] = metadata['title']
238 |         video_tags["\xa9ART"] = ', '.join([performer['name'] for performer in metadata['performers']])
239 |         video_tags["\xa9alb"] = metadata['site']['name']
240 |         video_tags["\xa9day"] = metadata['date']
241 |         video_tags["desc"] = metadata['site']['name']
242 |         video_tags["----:com.apple.iTunes:UUID"] = [bytes(metadata['foreign_guid'], 'utf-8')]  # Add custom UUID tag
243 |         video.tags = video_tags
244 |         video.save()
245 |     except KeyError as e:
246 |         logger.error(f"Metadata missing key: {e}")
247 |     except Exception as e:
248 |         logger.error(f"Failed to tag metadata: {e}")
249 | 
250 | 
251 | def sanitize_filename(filename):
252 |     sanitized = re.sub(r'[<>:"/\\|?*]', '', filename)
253 |     sanitized = re.sub(r'\s+', ' ', sanitized)
254 |     sanitized = sanitized.strip()
255 |     return sanitized
256 | 
257 | 
258 | def move_files_to_site_directory(file_path, json_file_path, site_name, session):
259 |     try:
260 |         site = session.query(Site).filter_by(name=site_name).first()
261 |         if not site or not site.home_directory:
262 |             logger.error(f"Site {site_name} not found or has no home directory set.")
263 |             return None, None
264 | 
265 |         try:
266 |             destination_dir = Path(site.home_directory)
267 |             destination_dir.mkdir(parents=True, exist_ok=True)
268 | 
269 |             new_file_path = destination_dir / Path(file_path).name
270 |             new_json_file_path = destination_dir / Path(json_file_path).name
271 | 
272 |             shutil.move(file_path, new_file_path)
273 |             shutil.move(json_file_path, new_json_file_path)
274 | 
275 |             logger.info(f"Moved {file_path} to {new_file_path}")
276 |             logger.info(f"Moved {json_file_path} to {new_json_file_path}")
277 | 
278 |             return str(new_file_path), str(new_json_file_path)
279 | 
280 |         except Exception as e:
281 |             logger.error(f"Failed to move files: {e}")
282 |             return None, None
283 |     finally:
284 |         session.close()
285 | 
286 | 
287 | def match_scene_with_uuid(uuid, file_path, session):
288 |     try:
289 |         logger.info(f"Matching file {file_path} with UUID {uuid}")
290 |         scene = session.query(Scene).filter_by(foreign_guid=uuid).first()
291 | 
292 |         if scene:
293 |             scene.local_path = file_path
294 |             scene.status = 'Found'
295 |             session.commit()
296 |             logger.info(f"Automatically matched file {file_path} with UUID {uuid}")
297 |         else:
298 |             logger.error(f"No match found for UUID {uuid}")
299 |     except Exception as e:
300 |         logger.error(f"Failed to match file {file_path} with UUID {uuid}: {e}")
301 | 
302 | 
303 | def main():
304 |     with app.app_context():
305 |         initialize_database()
306 |         download_folder = Config.query.filter_by(key='downloadFolder').first()
307 |         if download_folder:
308 |             Watcher.DIRECTORY_TO_WATCH = download_folder.value
309 |             watcher = Watcher()
310 |             watcher.run()
311 | 
312 | 
313 | if __name__ == '__main__':
314 |     main()
315 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/Jdownloader.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Serechops/Jizzarr/ab59265a44f80a192dfd243d2ab20be3cface2f6/jizzarr/web/static/Jdownloader.png


--------------------------------------------------------------------------------
/jizzarr/web/static/collection.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     font-family: 'Montserrat', Arial, sans-serif;
  3 |     background-color: #121212;
  4 |     color: #ffffff;
  5 | }
  6 | 
  7 | .container {
  8 |     max-width: 1920px;
  9 |     margin: 0 auto;
 10 |     padding: 20px;
 11 |     position: relative;
 12 | }
 13 | 
 14 | #site-collection {
 15 |     margin-top: 30px;
 16 |     margin-bottom: 20px;
 17 | }
 18 | 
 19 | .site-card {
 20 |     background-color: #1e1e1e;
 21 |     color: #ffffff;
 22 |     border-radius: 8px;
 23 |     padding: 10px;
 24 |     margin-bottom: 10px;
 25 |     margin-top: 50px;
 26 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
 27 |     display: flex;
 28 |     align-items: center;
 29 |     transition: background-color 0.3s;
 30 |     cursor: pointer;
 31 |     position: relative;
 32 | }
 33 | 
 34 | .no-results {
 35 |     border: 2px solid red !important;
 36 | }
 37 | 
 38 | .site-card:hover {
 39 |     background-color: #333333;
 40 | }
 41 | 
 42 | .site-title {
 43 |     text-align: center;
 44 | }
 45 | 
 46 | .site-card img {
 47 |     max-width: 100%;
 48 |     max-height: 100px;
 49 |     object-fit: contain;
 50 |     margin-right: 10px;
 51 |     border-radius: 4px;
 52 |     justify-content: center;
 53 | }
 54 | 
 55 | .site-card h2 {
 56 |     margin: 0;
 57 |     display: none;
 58 | }
 59 | 
 60 | .site-card .no-logo h2 {
 61 |     display: block;
 62 | }
 63 | 
 64 | .site-card button {
 65 |     background-color: #ff5f6d;
 66 |     color: white;
 67 |     border: none;
 68 |     border-radius: 4px;
 69 |     cursor: pointer;
 70 |     display: block;
 71 |     margin-top: 20px;
 72 | }
 73 | 
 74 | button.btn.btn-danger.remove-site-button {
 75 |     position: absolute;
 76 |     bottom: 1px;
 77 |     left: 1px;
 78 | }
 79 | 
 80 | .site-card button.remove {
 81 |     background-color: red;
 82 | }
 83 | 
 84 | .highlight-missing {
 85 |     background-color: red !important;
 86 | }
 87 | 
 88 | .highlight-found {
 89 |     background-color: green !important;
 90 | }
 91 | 
 92 | th, td {
 93 |     padding: 10px;
 94 |     text-align: left;
 95 |     border-bottom: 1px solid #444;
 96 | }
 97 | 
 98 | th {
 99 |     background-color: #333;
100 |     color: white;
101 | }
102 | 
103 | .file-path-icon {
104 |     color: green;
105 |     margin-right: 5px;
106 |     font-size: 1em;
107 | }
108 | 
109 | .match-controls {
110 |     display: flex;
111 |     justify-content: center;
112 |     gap: 5px;
113 |     margin-top: 10px;
114 | 
115 | }
116 | 
117 | .scene-count {
118 |     text-align: center;
119 |     margin-bottom: 10px;
120 |     margin-top: 10px;
121 |     font-size: 1.2em;
122 | }
123 | 
124 | .site-logo img {
125 |     max-height: 200px;
126 |     object-fit: cover;
127 |     border-radius: 8px;
128 | }
129 | 
130 | #compare-container.compare-container {
131 |     text-align: center;
132 | }
133 | 
134 | #back-button-container {
135 |     margin-top: 25px;
136 | }
137 | 
138 | .btn-dark-mode {
139 |     background-color: #333;
140 |     color: white;
141 | }
142 | 
143 | .btn-dark-mode:hover {
144 |     background-color: #444;
145 | }
146 | 
147 | .table-dark-mode {
148 |     background-color: #1e1e1e;
149 |     color: white;
150 | }
151 | 
152 | #site-logo {
153 |     text-align: center;
154 |     max-width: 100%;
155 |     max-height: 100%;
156 | }
157 | 
158 | .action-buttons {
159 |     display: flex;
160 |     align-items: center;
161 |     justify-content: flex-start;
162 |     gap: 5px; /* Adjust this value as needed */
163 | }
164 | 
165 | .highlight-found {
166 |     background-color: green;
167 |     color: white;
168 | }
169 | 
170 | .favicon {
171 |     width: 25px;
172 |     height: 25px;
173 |     margin-right: 8px;
174 |     vertical-align: middle;
175 | }
176 | 
177 | .custom-navbar {
178 |     width: 100%;
179 |     position: fixed;
180 |     top: 0;
181 |     z-index: 1000;
182 |     background-color: rgba(0, 0, 0, 0.5);
183 |     padding: 10px 0;
184 |     display: flex;
185 |     justify-content: center;
186 |     align-items: center;
187 |     backdrop-filter: blur(6px);
188 | }
189 | 
190 | .custom-navbar a {
191 |     color: #ffffff;
192 |     text-decoration: none;
193 |     margin: 0 10px;
194 |     padding: 5px 10px;
195 | }
196 | 
197 | .custom-navbar a:hover {
198 |     background-color: #495057;
199 |     border-radius: 4px;
200 | }
201 | 
202 | .status.found {
203 |     color: green;
204 | }
205 | 
206 | .progress-bar {
207 |     position: absolute;
208 |     bottom: 10px;
209 |     left: 50%;
210 |     transform: translateX(-40%);
211 |     width: 75%;
212 |     background-color: rgba(0, 0, 0, 0.5);
213 |     border-radius: 5px;
214 |     height: 20px;
215 | }
216 | 
217 | .progress-bar-inner {
218 |     height: 100%;
219 |     background-color: #007bff;
220 |     border-radius: 5px;
221 |     transition: width 0.3s;
222 | }
223 | 
224 | .progress-bar-text {
225 |     position: absolute;
226 |     top: 50%;
227 |     left: 50%;
228 |     transform: translate(-50%, -50%);
229 |     color: #fff;
230 |     font-weight: bold;
231 | }
232 | 
233 | .pagnination-controls {
234 |     top: 1px;
235 |     position: absolute;
236 | }
237 | 
238 | .mb-3 {
239 |     margin-top: 25px;
240 | }
241 | 
242 | .jdownloader-icon {
243 |     width: 24px;
244 |     height: 24px;
245 |     margin-left: 30px;
246 |     cursor: pointer;
247 |     vertical-align: middle;
248 | }
249 | 
250 | .badge.bg-success {
251 |     background-color: #28a745;
252 |     color: #fff;
253 |     padding: 0.5em;
254 |     border-radius: 0.25em;
255 |     font-size: 0.9em;
256 |     margin-right: 0.5em;
257 | }
258 | 
259 | #status {
260 |     height: 100px;
261 |     max-width: 100%;
262 |     overflow-y: auto;
263 |     border: 1px solid #ccc;
264 |     padding: 10px;
265 |     background-color: black;
266 |     color: white;
267 |     margin: 20px 0;
268 | }
269 | 
270 | #status div {
271 |     padding: 5px;
272 |     border-bottom: 1px solid #eee;
273 | }
274 | 
275 | #status div:last-child {
276 |     border-bottom: none;
277 | }
278 | 
279 | /* Fix the button size */
280 | #get-all-urls-button {
281 |     width: 200px; /* Adjust the width as needed */
282 |     height: 40px; /* Set a fixed height */
283 |     white-space: nowrap;
284 |     text-align: center;
285 |     line-height: 40px; /* Align text vertically */
286 |     overflow: hidden; /* Hide any overflow content */
287 |     padding: 0 10px; /* Add some padding for better appearance */
288 |     box-sizing: border-box; /* Ensure padding and border are included in the element's total width and height */
289 | }
290 | 
291 | /* Ensure the icon does not resize */
292 | #get-all-urls-button .fa {
293 |     display: inline-block;
294 |     vertical-align: middle;
295 | }
296 | 
297 | /* Ensure the SVG icon maintains its size */
298 | .svg-inline--fa {
299 |     width: 16px; /* Set a fixed width for the icon */
300 |     height: 16px; /* Set a fixed height for the icon */
301 |     vertical-align: middle; /* Align with text */
302 | }
303 | 
304 | /* Ensure g.missing does not resize */
305 | g.missing {
306 |     width: 16px; /* Set a fixed width if needed */
307 |     height: 16px; /* Set a fixed height if needed */
308 |     display: inline-block;
309 |     vertical-align: middle;
310 | }
311 | 
312 | /* Prevent the button from resizing its height */
313 | #get-all-urls-button {
314 |     height: 40px; /* Set a fixed height */
315 |     line-height: 40px; /* Align text vertically */
316 |     overflow: hidden; /* Hide any overflow content */
317 |     padding: 0 10px; /* Add some padding for better appearance */
318 |     box-sizing: border-box; /* Ensure padding and border are included in the element's total width and height */
319 | }
320 | 
321 | @media (max-width: 768px) {
322 |     .container {
323 |         padding: 10px;
324 |     }
325 | 
326 |     .site-card {
327 |         flex-direction: column;
328 |         align-items: flex-start;
329 |     }
330 | 
331 |     .site-card img {
332 |         max-width: 100%;
333 |         margin: 0 0 10px 0;
334 |     }
335 | 
336 |     .match-controls {
337 |         flex-direction: column;
338 |         gap: 10px;
339 |     }
340 | 
341 |     .table-dark-mode th, .table-dark-mode td {
342 |         padding: 5px;
343 |         font-size: 0.8em;
344 |     }
345 | 
346 |     .action-buttons {
347 |         flex-direction: column;
348 |         gap: 5px;
349 |     }
350 |     
351 |     .progress-bar {
352 |         transform: translateY(-50px);
353 |         left: 50px;
354 |     }
355 |     
356 |     .btn {
357 |         width: 100%;
358 |         margin-bottom: 5px;
359 |     }
360 | }
361 | 
362 | @media (max-width: 611px) {
363 |     .site-card {
364 |         padding: 10px 5px;
365 |     }
366 | 
367 |     .match-controls {
368 |         gap: 5px;
369 |     }
370 | 
371 |     .btn {
372 |         width: 100%;
373 |         margin-bottom: 5px;
374 |     }
375 |     
376 |     #search-input {
377 |         margin-top: 50px;
378 |     }
379 |     
380 |     .progress-bar {
381 |         transform: translateY(-50px);
382 |         left: 50px;
383 |     }
384 | }
385 | 
386 | @media (max-width: 530px) {
387 |     .site-card {
388 |         padding: 10px 5px;
389 |     }
390 | 
391 |     .match-controls {
392 |         gap: 5px;
393 |     }
394 | 
395 |     .btn {
396 |         width: 100%;
397 |         margin-bottom: 5px;
398 |     }
399 |     
400 |     #search-input {
401 |         margin-top: 75px;
402 |     }
403 | }
404 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/config.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     font-family: 'Montserrat', Arial, sans-serif;
  3 |     background-color: #121212;
  4 |     color: #ffffff;
  5 |     margin: 0;
  6 |     padding: 0;
  7 | }
  8 | 
  9 | .favicon {
 10 |     width: 25px;
 11 |     height: 25px;
 12 |     margin-right: 8px;
 13 |     vertical-align: middle;
 14 | }
 15 | 
 16 | .custom-navbar {
 17 |     width: 100%;
 18 |     position: fixed;
 19 |     top: 0;
 20 |     z-index: 1000;
 21 |     background-color: rgba(0, 0, 0, 0.5);
 22 |     padding: 10px 0;
 23 |     display: flex;
 24 |     justify-content: center;
 25 |     align-items: center;
 26 |     backdrop-filter: blur(6px);
 27 | }
 28 | 
 29 | .custom-navbar a {
 30 |     color: #ffffff;
 31 |     text-decoration: none;
 32 |     margin: 0 10px;
 33 |     padding: 5px 10px;
 34 | }
 35 | 
 36 | .custom-navbar a:hover {
 37 |     background-color: #495057;
 38 |     border-radius: 4px;
 39 | }
 40 | 
 41 | .container {
 42 |     max-width: 100%; /* Full width */
 43 |     padding: 20px;
 44 |     margin: 0 auto;
 45 | }
 46 | 
 47 | .config-wrapper {
 48 |     display: flex;
 49 |     justify-content: center;
 50 | }
 51 | 
 52 | .config-container {
 53 |     padding: 20px;
 54 |     background-color: #1e1e1e;
 55 |     border-radius: 8px;
 56 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
 57 |     width: 100%; /* Use full width */
 58 |     max-width: 1600px; /* Maximum width of the config container */
 59 | }
 60 | 
 61 | h1 {
 62 |     text-align: center;
 63 |     margin-bottom: 20px;
 64 |     margin-top: 100px;
 65 | }
 66 | 
 67 | .form-group {
 68 |     margin-bottom: 20px;
 69 |     width: 100%; /* Full width */
 70 |     position: relative;
 71 | }
 72 | 
 73 | .form-label {
 74 |     display: block;
 75 |     margin-bottom: 5px;
 76 |     font-weight: 500;
 77 | }
 78 | 
 79 | .form-control-dark {
 80 |     background-color: #333;
 81 |     border: 1px solid #444;
 82 |     color: #ffffff;
 83 |     padding: 10px;
 84 |     border-radius: 4px;
 85 |     width: 100%; /* Full width */
 86 |     box-sizing: border-box;
 87 | }
 88 | 
 89 | .btn-primary-dark {
 90 |     background-color: #1a73e8;
 91 |     border: none;
 92 |     color: #ffffff;
 93 |     padding: 10px 20px;
 94 |     border-radius: 4px;
 95 |     width: 100%;
 96 |     cursor: pointer;
 97 |     font-weight: 500;
 98 |     margin-top: 20px;
 99 | }
100 | 
101 | .btn-primary-dark:hover {
102 |     background-color: #155ab6;
103 | }
104 | 
105 | .btn-show {
106 |     position: absolute;
107 |     top: 40%;
108 |     right: 10px;
109 |     transform: translateX(15%);
110 |     background-color: #1a73e8;
111 |     border: none;
112 |     color: #ffffff;
113 |     padding: 10px 20px;
114 |     border-radius: 4px;
115 |     cursor: pointer;
116 |     font-weight: 500;
117 | }
118 | 
119 | .btn-show:hover {
120 |     background-color: #155ab6;
121 | }
122 | 
123 | .path {
124 |     color: lime;
125 | }
126 | 
127 | .scrollable-container {
128 |     max-height: 400px;
129 |     overflow-y: auto;
130 |     border: 1px solid #ccc;
131 |     padding: 10px;
132 | }
133 | 
134 | /* Media Queries */
135 | @media (max-width: 1200px) {
136 |     .container {
137 |         max-width: 100%;
138 |         margin-top: 10px;
139 |     }
140 | }
141 | 
142 | @media (max-width: 992px) {
143 |     .container {
144 |         max-width: 100%;
145 |         margin-top: 10px;
146 |     }
147 | }
148 | 
149 | @media (max-width: 768px) {
150 |     .container {
151 |         max-width: 100%;
152 |         margin-top: 10px;
153 |     }
154 | }
155 | 
156 | @media (max-width: 576px) {
157 |     .container {
158 |         max-width: 100%;
159 |         padding: 0 10px;
160 |         margin-top: 10px;
161 |     }
162 | }
163 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Serechops/Jizzarr/ab59265a44f80a192dfd243d2ab20be3cface2f6/jizzarr/web/static/favicon.ico


--------------------------------------------------------------------------------
/jizzarr/web/static/index.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     font-family: 'Montserrat', Arial, sans-serif;
  3 |     background-color: #121212;
  4 |     color: #ffffff;
  5 |     margin: 0;
  6 |     padding: 0;
  7 | }
  8 | 
  9 | .container {
 10 |     margin-top: 75px;
 11 |     max-width: 80%;
 12 | }
 13 | 
 14 | .favicon {
 15 |     width: 25px;
 16 |     height: 25px;
 17 |     margin-right: 8px;
 18 |     vertical-align: middle;
 19 | }
 20 | 
 21 | .custom-navbar {
 22 |     width: 100%;
 23 |     position: fixed;
 24 |     top: 0;
 25 |     z-index: 1000;
 26 |     background-color: rgba(0, 0, 0, 0.5);
 27 |     padding: 10px 0;
 28 |     display: flex;
 29 |     justify-content: center;
 30 |     align-items: center;
 31 |     backdrop-filter: blur(6px);
 32 | }
 33 | 
 34 | .custom-navbar a {
 35 |     color: #ffffff;
 36 |     text-decoration: none;
 37 |     margin: 0 10px;
 38 |     padding: 5px 10px;
 39 | }
 40 | 
 41 | .custom-navbar a:hover {
 42 |     background-color: #495057;
 43 |     border-radius: 4px;
 44 | }
 45 | 
 46 | .form-control-dark {
 47 |     background-color: #333;
 48 |     border-color: #444;
 49 |     color: #ffffff;
 50 |     width: 100%;
 51 | }
 52 | 
 53 | .btn-primary-dark {
 54 |     background-color: #1a73e8;
 55 |     border-color: #1a73e8;
 56 | }
 57 | 
 58 | .card {
 59 |     background-color: #1e1e1e;
 60 |     color: #ffffff;
 61 |     border: 1px solid #333;
 62 | }
 63 | 
 64 | .card .btn {
 65 |     color: #ffffff;
 66 | }
 67 | 
 68 | .input-group-centered {
 69 |     display: flex;
 70 |     justify-content: center;
 71 |     flex-direction: column;
 72 |     align-items: center;
 73 |     margin-bottom: 1rem;
 74 | }
 75 | 
 76 | .search-container {
 77 |     width: 50%;
 78 | }
 79 | 
 80 | .tpdb-logo {
 81 |     max-height: 50px;
 82 |     display: inline-block;
 83 | }
 84 | 
 85 | .infographic {
 86 |     position: fixed;
 87 |     top: 75px;
 88 |     left: 10px;
 89 |     background-color: #1e1e1e;
 90 |     padding: 10px;
 91 |     border-radius: 8px;
 92 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
 93 |     text-align: center;
 94 | }
 95 | 
 96 | .infographic h4, .infographic p {
 97 |     margin: 0;
 98 |     padding: 0;
 99 | }
100 | 
101 | .legend-container {
102 |     display: flex;
103 |     justify-content: space-around;
104 |     margin-bottom: 10px;
105 | }
106 | 
107 | .legend-item {
108 |     display: flex;
109 |     align-items: center;
110 |     font-size: 14px;
111 | }
112 | 
113 | .legend-color {
114 |     width: 12px;
115 |     height: 12px;
116 |     display: inline-block;
117 |     margin-right: 5px;
118 | }
119 | 
120 | .legend-collected {
121 |     background-color: #00b09b;
122 | }
123 | 
124 | .legend-missing {
125 |     background-color: #ff5f6d;
126 | }
127 | 
128 | #collectionChart {
129 |     width: 200px;
130 |     height: 200px;
131 | }
132 | 
133 | #progress-bar-container {
134 |     display: none;
135 |     position: fixed;
136 |     top: 10px;
137 |     right: 10px;
138 |     width: 300px;
139 |     background-color: #333;
140 |     border-radius: 8px;
141 |     overflow: hidden;
142 |     align-items: center;
143 |     padding: 5px;
144 |     z-index: 1000;
145 | }
146 | 
147 | #stash-logo {
148 |     width: 30px;
149 |     height: 30px;
150 |     margin-right: 10px; /* Space between logo and progress bar */
151 | }
152 | 
153 | #progress-bar {
154 |     width: 100%;
155 |     height: 25px;
156 |     background-color: #444;
157 |     flex-grow: 1; /* Ensure the progress bar fills the remaining space */
158 | }
159 | 
160 | #progress-bar-inner {
161 |     height: 100%;
162 |     width: 0;
163 |     background-color: #1a73e8;
164 |     text-align: center;
165 |     color: white;
166 |     line-height: 25px; /* Center the text vertically */
167 |     font-weight: bold;
168 | }
169 | 
170 | .modal-footer .btn {
171 |     background-color: red;
172 | }
173 | 
174 | .list-group-item h5 {
175 |     color: orange;
176 | }
177 | 
178 | /* Fix the button size */
179 | #search-stash {
180 |     width: 200px; /* Adjust the width as needed */
181 |     height: 40px; /* Set a fixed height */
182 |     white-space: nowrap;
183 |     text-align: center;
184 |     line-height: 40px; /* Align text vertically */
185 |     overflow: hidden; /* Hide any overflow content */
186 |     padding: 0 10px; /* Add some padding for better appearance */
187 |     box-sizing: border-box; /* Ensure padding and border are included in the element's total width and height */
188 | }
189 | 
190 | /* Ensure the icon does not resize */
191 | #search-stash .fa {
192 |     display: inline-block;
193 |     vertical-align: middle;
194 | }
195 | 
196 | /* Ensure the SVG icon maintains its size */
197 | .svg-inline--fa {
198 |     width: 16px; /* Set a fixed width for the icon */
199 |     height: 16px; /* Set a fixed height for the icon */
200 |     vertical-align: middle; /* Align with text */
201 | }
202 | 
203 | /* Prevent the button from resizing its height */
204 | #search-stash {
205 |     height: 40px; /* Set a fixed height */
206 |     line-height: 40px; /* Align text vertically */
207 |     overflow: hidden; /* Hide any overflow content */
208 |     padding: 0 10px; /* Add some padding for better appearance */
209 |     box-sizing: border-box; /* Ensure padding and border are included in the element's total width and height */
210 | }
211 | 
212 | /* Media Queries */
213 | @media (max-width: 1200px) {
214 |     .container {
215 |         max-width: 90%;
216 |         margin-top: 75px;
217 |     }
218 | 
219 |     .search-container {
220 |         width: 60%;
221 |     }
222 | 
223 |     #progress-bar-container {
224 |         width: 250px;
225 |     }
226 | }
227 | 
228 | @media (max-width: 992px) {
229 |     .container {
230 |         max-width: 95%;
231 |         margin-top: 75px;
232 |     }
233 | 
234 |     .search-container {
235 |         width: 70%;
236 |     }
237 | 
238 |     #progress-bar-container {
239 |         max-height: 30px;
240 |         max-width: 200px;
241 |         transform: translateY(120%);
242 |     }
243 | }
244 | 
245 | @media (max-width: 768px) {
246 |     .container {
247 |         margin-top: 75px;
248 |     }
249 | 
250 |     .search-container {
251 |         width: 80%;
252 |     }
253 | 
254 |     #progress-bar-container {
255 |         transform: translateY(120%);
256 |         max-height: 30px;
257 |         max-width: 120px;
258 |     }
259 | }
260 | 
261 | @media (max-width: 576px) {
262 |     .container {
263 |         margin-top: 120px;
264 |     }
265 | 
266 |     .search-container {
267 |         width: 90%;
268 |     }
269 | 
270 | 
271 |     #progress-bar-container {
272 |         transform: translateY(210%);
273 |         max-height: 30px;
274 |         max-width: 235px;
275 |     }
276 | }
277 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/logs.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |     font-family: 'Montserrat', Arial, sans-serif;
 3 |     background-color: #121212;
 4 |     color: #ffffff;
 5 |     margin: 0;
 6 |     padding: 0;
 7 | }
 8 | 
 9 | .container {
10 |     margin-top: 75px;
11 |     max-width: 80%;
12 | }
13 | 
14 | .favicon {
15 |     width: 25px;
16 |     height: 25px;
17 |     margin-right: 8px;
18 |     vertical-align: middle;
19 | }
20 | 
21 | .custom-navbar {
22 |     width: 100%;
23 |     position: fixed;
24 |     top: 0;
25 |     z-index: 1000;
26 |     background-color: rgba(0, 0, 0, 0.5);
27 |     padding: 10px 0;
28 |     display: flex;
29 |     justify-content: center;
30 |     align-items: center;
31 |     backdrop-filter: blur(6px);
32 | }
33 | 
34 | .custom-navbar a {
35 |     color: #ffffff;
36 |     text-decoration: none;
37 |     margin: 0 10px;
38 |     padding: 5px 10px;
39 | }
40 | 
41 | .custom-navbar a:hover {
42 |     background-color: #495057;
43 |     border-radius: 4px;
44 | }
45 | 
46 | table {
47 |     width: 100%;
48 |     border-collapse: collapse;
49 | }
50 | 
51 | th, td {
52 |     border: 1px solid #333;
53 |     padding: 8px;
54 |     text-align: left;
55 | }
56 | 
57 | th {
58 |     background-color: #1e1e1e;
59 |     color: #ffffff;
60 | }
61 | 
62 | .log-level {
63 |     font-weight: bold;
64 | }
65 | 
66 | .log-message {
67 |     white-space: pre-wrap;
68 | }
69 | 
70 | .btn-primary-dark {
71 |     background-color: #1a73e8;
72 |     border-color: #1a73e8;
73 |     color: #ffffff;
74 | }
75 | 
76 | .highlight {
77 |     background-color: yellow;
78 |     color: black;
79 | }
80 | 
81 | .btn-danger-dark {
82 |     background-color: red;
83 | }
84 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/script.js:
--------------------------------------------------------------------------------
  1 | document.addEventListener('DOMContentLoaded', function () {
  2 |     const searchButton = document.getElementById('search-button');
  3 |     const searchInput = document.getElementById('search-input');
  4 |     const siteDetails = document.getElementById('site-details');
  5 |     const scenesGrid = document.getElementById('scenes-grid');
  6 |     const pagination = document.getElementById('pagination');
  7 |     const loadingIndicator = document.getElementById('loading-indicator');
  8 |     const searchResults = document.getElementById('search-results');
  9 |     const siteCollectionContainer = document.getElementById('site-collection');
 10 |     const sceneCollectionContainer = document.getElementById('scene-collection');
 11 |     const compareButton = document.getElementById('compare-button');
 12 |     const directoryInput = document.getElementById('directory-input');
 13 |     const searchStashButton = document.getElementById('search-stash');
 14 |     const progressBarContainer = document.getElementById('progress-bar-container');
 15 |     const progressBarInner = document.getElementById('progress-bar-inner');
 16 | 
 17 |     let progressInterval;
 18 | 
 19 |     searchStashButton.addEventListener('click', async function () {
 20 |         // Show loading indicator when search-stash button is pressed
 21 |         loadingIndicator.classList.remove('hidden');
 22 |         progressBarContainer.style.display = 'block';
 23 |         updateProgressBar(0);
 24 |         startProgressUpdate();
 25 | 
 26 |         try {
 27 |             const response = await fetch('/populate_from_stash', {
 28 |                 method: 'POST',
 29 |                 headers: {
 30 |                     'Content-Type': 'application/json'
 31 |                 }
 32 |             });
 33 | 
 34 |             if (!response.ok) {
 35 |                 throw new Error(`Error ${response.status}: ${await response.text()}`);
 36 |             }
 37 | 
 38 |             const result = await response.json();
 39 |             console.log('Sites and scenes fetched from Stash:', result);
 40 |             Toastify({
 41 |                 text: 'Sites and scenes successfully populated from Stash.',
 42 |                 duration: 3000,
 43 |                 close: true,
 44 |                 gravity: "top",
 45 |                 position: "right",
 46 |                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 47 |             }).showToast();
 48 |             displayCollection(); // Refresh the collection display
 49 |         } catch (error) {
 50 |             console.error('Error fetching from Stash:', error);
 51 |             Toastify({
 52 |                 text: `Error fetching from Stash: ${error.message}`,
 53 |                 duration: 3000,
 54 |                 close: true,
 55 |                 gravity: "top",
 56 |                 position: "right",
 57 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 58 |             }).showToast();
 59 |         }
 60 | 
 61 |         // Hide loading indicator once fetching is complete
 62 |         loadingIndicator.classList.add('hidden');
 63 |         progressBarContainer.style.display = 'none';
 64 |         clearInterval(progressInterval);
 65 |     });
 66 | 
 67 |     function startProgressUpdate() {
 68 |         progressInterval = setInterval(async () => {
 69 |             const response = await fetch('/progress');
 70 |             if (response.ok) {
 71 |                 const progress = await response.json();
 72 |                 const percentage = Math.round((progress.completed / progress.total) * 100);
 73 |                 updateProgressBar(percentage);
 74 |             }
 75 |         }, 10000); // Update progress every second
 76 |     }
 77 | 
 78 |     function updateProgressBar(percentage) {
 79 |         progressBarInner.style.width = percentage + '%';
 80 |         progressBarInner.innerText = percentage + '%';
 81 |     }
 82 | 
 83 |     let currentScenes = [];
 84 |     let currentPage = 1;
 85 |     const scenesPerPage = 16;
 86 | 
 87 |     async function getApiKey() {
 88 |         try {
 89 |             const response = await fetch('/get_tpdb_api_key');
 90 |             if (response.ok) {
 91 |                 const data = await response.json();
 92 |                 return data.tpdbApiKey;
 93 |             } else {
 94 |                 console.error('Failed to fetch API key:', response.status);
 95 |                 return null;
 96 |             }
 97 |         } catch (error) {
 98 |             console.error('Error fetching API key:', error);
 99 |             return null;
100 |         }
101 |     }
102 | 
103 |     // Fetch data from API
104 |     async function fetchData(endpoint) {
105 |         const apiKey = await getApiKey();
106 |         if (!apiKey) {
107 |             console.error('API key is missing');
108 |             return null;
109 |         }
110 | 
111 |         const url = `https://api.theporndb.net/jizzarr/${endpoint}`;
112 |         const headers = {
113 |             'Authorization': `Bearer ${apiKey}`
114 |         };
115 | 
116 |         try {
117 |             const response = await fetch(url, {headers});
118 |             if (response.ok) {
119 |                 const data = await response.json();
120 |                 console.log(`Data from ${endpoint}:`, data); // Print the API response for debugging
121 |                 return data;
122 |             } else {
123 |                 console.error(`Failed to fetch data from ${endpoint}: ${response.status}`);
124 |                 return null;
125 |             }
126 |         } catch (error) {
127 |             console.error('Error fetching data:', error);
128 |             return null;
129 |         }
130 |     }
131 | 
132 |     // Search for site by name
133 |     async function searchSiteByName(siteName) {
134 |         const data = await fetchData(`site/search?q=${siteName}`);
135 |         return data ? data : [];
136 |     }
137 | 
138 |     function displayScenes() {
139 |         scenesGrid.innerHTML = '';
140 |         if (Array.isArray(currentScenes)) {
141 |             const scenesToDisplay = currentScenes.slice(currentPage * scenesPerPage, (currentPage + 1) * scenesPerPage);
142 |             scenesToDisplay.forEach(scene => {
143 |                 const sceneElement = document.createElement('div');
144 |                 sceneElement.classList.add('scene-card');
145 |                 sceneElement.innerHTML = `
146 |                     <img src="${scene.Images.find(img => img.CoverType === 'Screenshot')?.Url}" alt="${scene.Title}">
147 |                     <h3>${scene.Title}</h3>
148 |                     <p><strong>Date:</strong> ${scene.ReleaseDate}</p>
149 |                     <p class="overview"><strong>Overview:</strong> ${scene.Overview}</p>
150 |                     <p><strong>Duration:</strong> ${scene.Duration} minutes</p>
151 |                     <p><strong>Performers:</strong> ${scene.Credits.map(credit => credit.Name).sort().join(', ')}</p>
152 |                 `;
153 |                 scenesGrid.appendChild(sceneElement);
154 |             });
155 |         } else {
156 |             scenesGrid.innerHTML = '<p>No scenes available</p>';
157 |         }
158 |     }
159 | 
160 |     function setupPagination() {
161 |         pagination.innerHTML = '';
162 |         if (Array.isArray(currentScenes) && currentScenes.length > 0) {
163 |             const totalPages = Math.ceil(currentScenes.length / scenesPerPage);
164 | 
165 |             const firstButton = document.createElement('button');
166 |             firstButton.textContent = 'First';
167 |             firstButton.addEventListener('click', () => {
168 |                 currentPage = 0;
169 |                 displayScenes();
170 |             });
171 | 
172 |             const prevButton = document.createElement('button');
173 |             prevButton.textContent = 'Previous';
174 |             prevButton.addEventListener('click', () => {
175 |                 if (currentPage > 0) {
176 |                     currentPage--;
177 |                     displayScenes();
178 |                 }
179 |             });
180 | 
181 |             const nextButton = document.createElement('button');
182 |             nextButton.textContent = 'Next';
183 |             nextButton.addEventListener('click', () => {
184 |                 if (currentPage < totalPages - 1) {
185 |                     currentPage++;
186 |                     displayScenes();
187 |                 }
188 |             });
189 | 
190 |             const lastButton = document.createElement('button');
191 |             lastButton.textContent = 'Last';
192 |             lastButton.addEventListener('click', () => {
193 |                 currentPage = totalPages - 1;
194 |                 displayScenes();
195 |             });
196 | 
197 |             pagination.appendChild(firstButton);
198 |             pagination.appendChild(prevButton);
199 |             pagination.appendChild(nextButton);
200 |             pagination.appendChild(lastButton);
201 |         }
202 |     }
203 | 
204 |     function downloadSiteData(title, scenes) {
205 |         const dataStr = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(scenes, null, 4));
206 |         const downloadAnchorNode = document.createElement('a');
207 |         downloadAnchorNode.setAttribute("href", dataStr);
208 |         downloadAnchorNode.setAttribute("download", `${title}_data.json`);
209 |         document.body.appendChild(downloadAnchorNode);
210 |         downloadAnchorNode.click();
211 |         document.body.removeChild(downloadAnchorNode);
212 |     }
213 | 
214 |     // Populate site details and scenes
215 |     async function populateSiteDetails(site) {
216 |         // Show loading indicator when fetching scenes
217 |         loadingIndicator.classList.remove('hidden');
218 | 
219 |         siteDetails.innerHTML = '';
220 |         scenesGrid.innerHTML = '';
221 |         pagination.innerHTML = '';
222 |         currentScenes = [];
223 | 
224 |         console.log('Fetching details for site with ForeignId:', site.ForeignId);
225 | 
226 |         try {
227 |             const siteData = await fetchData(`site/${site.ForeignId}`);
228 |             console.log('Site data received:', siteData);
229 | 
230 |             if (siteData) {
231 |                 const siteDetailsData = siteData;
232 |                 console.log('Processing site details data:', siteDetailsData);
233 | 
234 |                 const scenes = siteDetailsData.Episodes || [];
235 |                 console.log('Scenes data:', scenes);
236 | 
237 |                 const sceneCount = scenes.length;
238 |                 const siteInfo = `
239 |                 <div class="site-info">
240 |                     <h2>${siteDetailsData.Title}</h2>
241 |                     <p><strong>URL:</strong> <a href="${siteDetailsData.Homepage}" target="_blank">${siteDetailsData.Homepage}</a></p>
242 |                     <p><strong>Description:</strong> ${siteDetailsData.Overview}</p>
243 |                     <p><strong>Network:</strong> ${siteDetailsData.Network}</p>
244 |                     <p><strong>Status:</strong> ${siteDetailsData.Status}</p>
245 |                     <p><strong>Total Scenes:</strong> ${sceneCount}</p>
246 |                     ${siteDetailsData.Images && siteDetailsData.Images.length > 0 ? `<a href="${siteDetailsData.Homepage}" target="_blank"><img src="${siteDetailsData.Images[0].Url}" alt="${siteDetailsData.Title} Poster"></a>` : `<a href="${siteDetailsData.Homepage}" target="_blank">${siteDetailsData.Title}</a>`}
247 |                     <button id="download-button">Download Site Data</button>
248 |                     <button id="add-site-button">Add Site to Collection</button>
249 |                 </div>
250 |                 `;
251 |                 siteDetails.innerHTML = siteInfo;
252 | 
253 |                 if (scenes.length > 0) {
254 |                     currentScenes = scenes;
255 |                     displayScenes();
256 |                     setupPagination();
257 |                 } else {
258 |                     siteDetails.innerHTML += '<p>No scenes available</p>';
259 |                 }
260 | 
261 |                 // Add event listeners to buttons
262 |                 const downloadButton = document.getElementById('download-button');
263 |                 const addSiteButton = document.getElementById('add-site-button');
264 |                 downloadButton.addEventListener('click', () => downloadSiteData(siteDetailsData.Title, scenes));
265 |                 addSiteButton.addEventListener('click', () => addSiteToCollection(siteDetailsData, scenes));
266 | 
267 |             } else {
268 |                 console.log('No site data found.');
269 |                 siteDetails.innerHTML = '<p>No site details available</p>';
270 |             }
271 |         } catch (error) {
272 |             console.error('Error fetching site details:', error);
273 |             siteDetails.innerHTML = `<p>Error fetching site details: ${error.message}</p>`;
274 |         }
275 | 
276 |         // Hide loading indicator once scenes are populated
277 |         loadingIndicator.classList.add('hidden');
278 |     }
279 | 
280 |     // Display search results
281 |     function displaySearchResults(sites) {
282 |         searchResults.innerHTML = '';
283 |         sites.forEach(site => {
284 |             const siteCard = document.createElement('div');
285 |             siteCard.classList.add('site-card');
286 |             siteCard.innerHTML = `
287 |                 <div class="p-4 md:w-1/5 flex md:justify-end items-center">
288 |                     <img src="${site.Images.find(img => img.CoverType === 'Logo')?.Url}" class="max-h-24" alt="${site.Title}">
289 |                 </div>
290 |             `;
291 |             siteCard.addEventListener('click', () => {
292 |                 // Show loading indicator when a site is selected
293 |                 loadingIndicator.classList.remove('hidden');
294 |                 populateSiteDetails(site);
295 |             });
296 |             searchResults.appendChild(siteCard);
297 |         });
298 | 
299 |         // Hide loading indicator once search results are populated
300 |         loadingIndicator.classList.add('hidden');
301 |     }
302 | 
303 |     // Add site to collection
304 |     function addSiteToCollection(site, scenes) {
305 |         const siteData = {
306 |             site: {
307 |                 uuid: site.ForeignGuid,
308 |                 name: site.Title,
309 |                 url: site.Homepage,
310 |                 description: site.Overview,
311 |                 rating: '',
312 |                 network: site.Network,
313 |                 parent: '',
314 |                 logo: site.Images && site.Images.length > 0 ? site.Images.find(img => img.CoverType === 'Logo')?.Url : ''
315 |             },
316 |             scenes: scenes.map(scene => ({
317 |                 title: scene.Title,
318 |                 date: scene.ReleaseDate,
319 |                 duration: scene.Duration,
320 |                 image: scene.Images.find(img => img.CoverType === 'Screenshot')?.Url,
321 |                 performers: scene.Credits,
322 |                 status: scene.status || null,
323 |                 local_path: scene.local_path || null,
324 |                 year: scene.Year,
325 |                 episode_number: scene.EpisodeNumber,
326 |                 slug: scene.Slug,
327 |                 overview: scene.Overview,
328 |                 credits: scene.Credits,
329 |                 release_date_utc: scene.ReleaseDateUtc,
330 |                 images: scene.Images,
331 |                 trailer: scene.Trailer,
332 |                 genres: scene.Genres,
333 |                 foreign_guid: scene.ForeignGuid,
334 |                 foreign_id: scene.ForeignId
335 |             }))
336 |         };
337 | 
338 |         // Save to server-side database
339 |         fetch('/add_site', {
340 |             method: 'POST',
341 |             headers: {
342 |                 'Content-Type': 'application/json'
343 |             },
344 |             body: JSON.stringify(siteData)
345 |         }).then(response => {
346 |             if (!response.ok) {
347 |                 throw new Error('Failed to save to server-side database.');
348 |             }
349 |             return response.json();
350 |         }).then(data => {
351 |             console.log('Saved to server-side database:', data);
352 |             Toastify({
353 |                 text: `${site.Title} has been added to your collection.`,
354 |                 duration: 3000,
355 |                 close: true,
356 |                 gravity: "top",
357 |                 position: "right",
358 |                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
359 |             }).showToast();
360 |             displayCollection(); // Refresh the collection display
361 |         }).catch(error => {
362 |             console.error('Error saving to server-side database:', error);
363 |             Toastify({
364 |                 text: 'Failed to add site to collection.',
365 |                 duration: 3000,
366 |                 close: true,
367 |                 gravity: "top",
368 |                 position: "right",
369 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
370 |             }).showToast();
371 |         });
372 |     }
373 | 
374 | 
375 |     // Event listener for search button
376 |     if (searchButton) {
377 |         searchButton.addEventListener('click', async function () {
378 |             const siteName = searchInput.value.trim();
379 |             if (siteName) {
380 |                 // Show loading indicator when search button is pressed
381 |                 loadingIndicator.classList.remove('hidden');
382 |                 const sites = await searchSiteByName(siteName);
383 |                 if (sites && sites.length > 0) {
384 |                     displaySearchResults(sites);
385 |                 } else {
386 |                     searchResults.innerHTML = '<p>No sites found</p>';
387 |                     // Hide loading indicator if no sites are found
388 |                     loadingIndicator.classList.add('hidden');
389 |                 }
390 |             } else {
391 |                 searchResults.innerHTML = '<p>Please enter a site name</p>';
392 |                 // Hide loading indicator if input is empty
393 |                 loadingIndicator.classList.add('hidden');
394 |             }
395 |         });
396 |     }
397 | 
398 |     // Function to display the collection
399 |     async function displayCollection() {
400 |         siteCollectionContainer.innerHTML = '';
401 | 
402 |         // Fetch collection from server-side database
403 |         const response = await fetch('/collection_data');
404 |         const siteCollection = await response.json();
405 | 
406 |         // Display site collection
407 |         siteCollection.forEach(item => {
408 |             const siteCard = document.createElement('div');
409 |             siteCard.classList.add('site-card');
410 |             siteCard.innerHTML = `
411 |                 <h2>${item.site.name}</h2>
412 |                 ${item.site.poster ? `<img src="${item.site.poster}" alt="${item.site.name} Poster">` : ''}
413 |                 <p>${item.site.description}</p>
414 |                 <button class="remove-site-button" data-site-uuid="${item.site.uuid}">Remove Site</button>
415 |                 <div class="site-scenes">
416 |                     ${item.scenes.map(scene => `
417 |                         <div class="scene-row">
418 |                             <div class="scene-info">
419 |                                 <p><strong>${scene.title}</strong></p>
420 |                                 <p><strong>Release Date:</strong> ${new Date(scene.date).toLocaleDateString()}</p>
421 |                                 <p><strong>Duration:</strong> ${scene.duration} minutes</p>
422 |                                 <p><strong>Performers:</strong> ${scene.performers}</p>
423 |                                 <p class="status ${scene.status === 'Found' ? 'found' : 'missing'}">${scene.status}</p>
424 |                                 <button class="match-button" data-scene-id="${scene.id}">Match</button>
425 |                             </div>
426 |                             <div class="scene-preview hidden">
427 |                                 <img src="${scene.image}" alt="${scene.title}">
428 |                             </div>
429 |                         </div>
430 |                     `).join('')}
431 |                 </div>
432 |             `;
433 |             siteCard.querySelectorAll('.scene-row').forEach(row => {
434 |                 row.addEventListener('click', () => {
435 |                     const preview = row.querySelector('.scene-preview');
436 |                     preview.classList.toggle('hidden');
437 |                 });
438 |             });
439 |             siteCollectionContainer.appendChild(siteCard);
440 |         });
441 | 
442 |         // Add event listeners to remove buttons
443 |         const removeSiteButtons = document.querySelectorAll('.remove-site-button');
444 |         removeSiteButtons.forEach(button => {
445 |             button.addEventListener('click', (e) => {
446 |                 const siteUuid = e.target.getAttribute('data-site-uuid');
447 |                 removeSiteFromCollection(siteUuid);
448 |             });
449 |         });
450 | 
451 |         // Add event listeners to match buttons
452 |         const matchButtons = document.querySelectorAll('.match-button');
453 |         matchButtons.forEach(button => {
454 |             button.addEventListener('click', (e) => {
455 |                 const sceneId = e.target.getAttribute('data-scene-id');
456 |                 handleMatchButtonClick(sceneId);
457 |             });
458 |         });
459 |     }
460 | 
461 |     // Remove site from collection
462 |     function removeSiteFromCollection(siteUuid) {
463 |         fetch(`/remove_site/${siteUuid}`, {method: 'DELETE'})
464 |             .then(response => response.json())
465 |             .then(data => {
466 |                 console.log('Site removed:', data);
467 |                 Toastify({
468 |                     text: 'Site has been removed from your collection.',
469 |                     duration: 3000,
470 |                     close: true,
471 |                     gravity: "top",
472 |                     position: "right",
473 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
474 |                 }).showToast();
475 |                 displayCollection(); // Update the display
476 |             })
477 |             .catch(error => {
478 |                 console.error('Error removing site from collection:', error);
479 |                 Toastify({
480 |                     text: 'Failed to remove site from collection.',
481 |                     duration: 3000,
482 |                     close: true,
483 |                     gravity: "top",
484 |                     position: "right",
485 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
486 |                 }).showToast();
487 |             });
488 |     }
489 | 
490 |     // Handle match button click
491 |     function handleMatchButtonClick(sceneId) {
492 |         const input = document.createElement('input');
493 |         input.type = 'file';
494 |         input.accept = '.mp4';
495 |         input.onchange = async (event) => {
496 |             const file = event.target.files[0];
497 |             if (file) {
498 |                 try {
499 |                     const response = await fetch('/match_scene', {
500 |                         method: 'POST',
501 |                         headers: {
502 |                             'Content-Type': 'application/json'
503 |                         },
504 |                         body: JSON.stringify({scene_id: sceneId, file_path: file.path})
505 |                     });
506 | 
507 |                     const result = await response.json();
508 |                     if (response.ok) {
509 |                         Toastify({
510 |                             text: result.message,
511 |                             duration: 3000,
512 |                             close: true,
513 |                             gravity: "top",
514 |                             position: "right",
515 |                             backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
516 |                         }).showToast();
517 |                         displayCollection();
518 |                     } else {
519 |                         throw new Error(result.error);
520 |                     }
521 |                 } catch (error) {
522 |                     console.error('Error matching scene:', error);
523 |                     Toastify({
524 |                         text: 'Error matching scene: ' + error.message,
525 |                         duration: 3000,
526 |                         close: true,
527 |                         gravity: "top",
528 |                         position: "right",
529 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
530 |                     }).showToast();
531 |                 }
532 |             }
533 |         };
534 |         input.click();
535 |     }
536 | 
537 |     // Compare collection with local directory
538 |     function compareCollection(siteUuid, localDirectory) {
539 |         fetch('/compare', {
540 |             method: 'POST',
541 |             headers: {
542 |                 'Content-Type': 'application/json'
543 |             },
544 |             body: JSON.stringify({siteUuid, localDirectory})
545 |         }).then(response => response.json())
546 |             .then(data => {
547 |                 console.log('Comparison results:', data);
548 |                 updateTableWithComparison(data.missing_files, data.matched_files);
549 |             }).catch(error => {
550 |             console.error('Error comparing collection:', error);
551 |         });
552 |     }
553 | 
554 |     function updateTableWithComparison(missingFiles, matchedFiles) {
555 |         // Fetch updated collection from server-side database
556 |         fetch('/collection_data')
557 |             .then(response => response.json())
558 |             .then(siteCollection => {
559 |                 siteCollection.forEach(siteData => {
560 |                     siteData.scenes.forEach(scene => {
561 |                         const sceneFileName = `${siteData.site.name} - ${scene.title} - ${scene.date}.mp4`;
562 |                         if (missingFiles.includes(sceneFileName)) {
563 |                             scene.status = 'Missing';
564 |                         } else if (matchedFiles.includes(sceneFileName)) {
565 |                             scene.status = 'Found';
566 |                         } else {
567 |                             scene.status = 'Unknown';
568 |                         }
569 |                     });
570 |                 });
571 |                 displayCollection();
572 |             })
573 |             .catch(error => {
574 |                 console.error('Error fetching updated collection:', error);
575 |             });
576 |     }
577 | 
578 |     // Event listener for the compare button
579 |     if (compareButton) {
580 |         compareButton.addEventListener('click', () => {
581 |             const siteCard = document.querySelector('.site-card.active');
582 |             if (siteCard) {
583 |                 const siteUuid = siteCard.getAttribute('data-site-uuid');
584 |                 const localDirectory = directoryInput.files[0].webkitRelativePath.split('/')[0];
585 |                 compareCollection(siteUuid, localDirectory);
586 |             } else {
587 |                 Toastify({
588 |                     text: 'Please select a site first.',
589 |                     duration: 3000,
590 |                     close: true,
591 |                     gravity: "top",
592 |                     position: "right",
593 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
594 |                 }).showToast();
595 |             }
596 |         });
597 |     }
598 | 
599 |     // Add event listeners to directory input
600 |     if (directoryInput) {
601 |         directoryInput.addEventListener('change', () => {
602 |             console.log('Directory selected:', directoryInput.files);
603 |         });
604 |     }
605 | 
606 |     // Load collection when collection page is loaded
607 |     if (window.location.pathname.endsWith('collection.html')) {
608 |         displayCollection();
609 |     }
610 | });
611 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/stash.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Serechops/Jizzarr/ab59265a44f80a192dfd243d2ab20be3cface2f6/jizzarr/web/static/stash.png


--------------------------------------------------------------------------------
/jizzarr/web/static/styles.css:
--------------------------------------------------------------------------------
  1 | body {
  2 |     font-family: Arial, sans-serif;
  3 |     background-color: #121212;
  4 |     color: #e0e0e0;
  5 |     margin: 0;
  6 |     padding: 0;
  7 |     display: flex;
  8 |     justify-content: center;
  9 |     align-items: flex-start;
 10 |     height: 100vh;
 11 |     overflow: auto;
 12 | }
 13 | 
 14 | .favicon {
 15 |     width: 25px;
 16 |     height: 25px;
 17 |     margin-right: 8px;
 18 |     vertical-align: middle;
 19 | }
 20 | 
 21 | .container {
 22 |     background-color: #1e1e1e;
 23 |     padding: 20px;
 24 |     border-radius: 8px;
 25 |     box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
 26 |     width: 100%;
 27 |     max-width: 1920px;
 28 |     display: flex;
 29 |     flex-direction: column;
 30 |     align-items: center;
 31 |     margin-top: 20px;
 32 |     box-sizing: border-box;
 33 | }
 34 | 
 35 | h1 {
 36 |     text-align: center;
 37 |     color: #e0e0e0;
 38 | }
 39 | 
 40 | input[type="text"] {
 41 |     width: 100%;
 42 |     max-width: 600px;
 43 |     padding: 8px;
 44 |     margin-bottom: 10px;
 45 |     border: 1px solid #ccc;
 46 |     border-radius: 4px;
 47 |     background-color: #333;
 48 |     color: #e0e0e0;
 49 | }
 50 | 
 51 | button {
 52 |     max-width: 600px;
 53 |     width: 100%;
 54 |     padding: 10px;
 55 |     background-color: #007BFF;
 56 |     color: white;
 57 |     border: none;
 58 |     border-radius: 4px;
 59 |     cursor: pointer;
 60 |     margin-bottom: 20px;
 61 | }
 62 | 
 63 | button:hover {
 64 |     background-color: #0056b3;
 65 | }
 66 | 
 67 | #site-details {
 68 |     margin-top: 20px;
 69 |     text-align: center;
 70 |     width: 100%;
 71 |     max-width: 1920px;
 72 | }
 73 | 
 74 | .site-info img {
 75 |     display: none;
 76 | }
 77 | 
 78 | #site-collection .site-card img {
 79 |     display: none;
 80 | }
 81 | 
 82 | #search-results {
 83 |     display: flex;
 84 |     flex-wrap: wrap;
 85 |     justify-content: center;
 86 |     gap: 10px;
 87 |     margin-top: 20px;
 88 |     width: 100%;
 89 |     max-width: 1920px;
 90 | }
 91 | 
 92 | .site-card {
 93 |     background-color: #4a4a4a;
 94 |     display: flex;
 95 |     justify-content: center;
 96 |     align-items: center;
 97 |     margin: 10px;
 98 |     border-radius: 8px;
 99 |     overflow: hidden;
100 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
101 |     width: auto;
102 |     max-width: 600px;
103 |     padding: 10px;
104 |     cursor: pointer;
105 | }
106 | 
107 | .site-card img {
108 |     max-height: 100px;
109 |     object-fit: contain;
110 |     display: block;
111 |     margin: 0 auto;
112 | }
113 | 
114 | .site-card:hover {
115 |     cursor: pointer;
116 | }
117 | 
118 | #scenes-grid {
119 |     display: grid;
120 |     grid-template-columns: repeat(4, 1fr);
121 |     gap: 10px;
122 |     margin-top: 20px;
123 |     width: 100%;
124 |     max-width: 1920px;
125 | }
126 | 
127 | .scene-card {
128 |     height: auto;
129 |     margin: 10px;
130 |     background-color: #2a2a2a;
131 |     border-radius: 8px;
132 |     overflow: hidden;
133 |     box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5);
134 |     text-align: center;
135 |     color: white;
136 | }
137 | 
138 | .scene-card img {
139 |     width: 100%;
140 |     height: auto;
141 |     max-height: 200px;
142 |     object-fit: cover;
143 | }
144 | 
145 | .scene-card:hover img {
146 |     transform: scale(1.05);
147 | }
148 | 
149 | .scene-card .scene-details {
150 |     background-color: rgba(38, 38, 38, 0.8);
151 |     color: #e0e0e0;
152 |     position: absolute;
153 |     bottom: 0;
154 |     width: 100%;
155 |     padding: 5px;
156 |     display: flex;
157 |     justify-content: space-between;
158 | }
159 | 
160 | .scene-card .scene-info {
161 |     padding: 10px;
162 |     text-align: left;
163 | }
164 | 
165 | .scene-card .scene-info h2 {
166 |     font-size: 1.25rem;
167 |     margin: 0;
168 | }
169 | 
170 | .scene-card .scene-info p {
171 |     margin: 5px 0;
172 | }
173 | 
174 | .scene-card .scene-info a {
175 |     color: #007BFF;
176 | }
177 | 
178 | .scene-card p {
179 |     display: -webkit-box;
180 |     -webkit-box-orient: vertical;
181 |     -webkit-line-clamp: 3;
182 |     overflow: hidden;
183 |     text-overflow: ellipsis;
184 | }
185 | 
186 | #pagination {
187 |     display: flex;
188 |     justify-content: center;
189 |     margin-top: 20px;
190 |     flex-wrap: wrap;
191 |     width: 100%;
192 |     max-width: 1920px;
193 | }
194 | 
195 | .pagination-button {
196 |     margin: 0 5px;
197 |     padding: 5px 10px;
198 |     background-color: #007BFF;
199 |     color: white;
200 |     border: none;
201 |     border-radius: 4px;
202 |     cursor: pointer;
203 | }
204 | 
205 | .pagination-button:hover {
206 |     background-color: #0056b3;
207 | }
208 | 
209 | .pagination-button.disabled {
210 |     background-color: #cccccc;
211 |     cursor: not-allowed;
212 | }
213 | 
214 | #loading-indicator {
215 |     display: none;
216 |     justify-content: center;
217 |     align-items: center;
218 |     height: 100px;
219 |     width: 100px;
220 |     border: 8px solid #e0e0e0;
221 |     border-top: 8px solid #007BFF;
222 |     border-radius: 50%;
223 |     animation: spin 1s linear infinite;
224 |     margin-top: 20px;
225 | }
226 | 
227 | .loading {
228 |     display: flex !important;
229 | }
230 | 
231 | .hidden {
232 |     display: none !important;
233 | }
234 | 
235 | @keyframes spin {
236 |     0% {
237 |         transform: rotate(0deg);
238 |     }
239 |     100% {
240 |         transform: rotate(360deg);
241 |     }
242 | }
243 | 
244 | /* Tabulator dark mode styles */
245 | .tabulator {
246 |     background-color: #1e1e1e;
247 |     color: #ffffff;
248 | }
249 | 
250 | .tabulator .tabulator-row {
251 |     background-color: #2c2c2c;
252 | }
253 | 
254 | .tabulator .tabulator-row:nth-child(even) {
255 |     background-color: #2e2e2e;
256 | }
257 | 
258 | .tabulator .tabulator-row:hover {
259 |     background-color: #3a3a3a;
260 | }
261 | 
262 | .tabulator .tabulator-cell {
263 |     border-right: 1px solid #444444;
264 |     color: #ffffff;
265 | }
266 | 
267 | .tabulator .tabulator-cell img {
268 |     border-radius: 4px;
269 | }
270 | 
271 | span.tabulator-paginator {
272 |     display: none;
273 | }
274 | 
275 | /* Toastify dark mode styles */
276 | .toastify {
277 |     background-color: #333333 !important;
278 |     color: #ffffff !important;
279 |     border-radius: 4px;
280 | }
281 | 
282 | /* Center the back button */
283 | #back-button-container {
284 |     display: flex;
285 |     justify-content: center;
286 |     margin: 20px 0;
287 | }
288 | 
289 | #back-button {
290 |     background-color: #ff5f6d;
291 |     color: #ffffff;
292 |     border: none;
293 |     padding: 10px 20px;
294 |     border-radius: 4px;
295 |     cursor: pointer;
296 |     text-align: center;
297 | }
298 | 
299 | #back-button:hover {
300 |     background-color: #ff7f8d;
301 | }
302 | 
303 | .pagination-controls {
304 |     padding: 10px 20px;
305 | }
306 | 
307 | /* Media Queries for responsive design */
308 | @media (max-width: 1200px) {
309 |     .container, #site-details, #search-results, #scenes-grid, #pagination {
310 |         max-width: 100%;
311 |     }
312 | }
313 | 
314 | @media (max-width: 768px) {
315 |     .container {
316 |         padding: 10px;
317 |     }
318 | 
319 |     input[type="text"], button {
320 |         max-width: 100%;
321 |     }
322 | 
323 |     .site-card, .scene-card {
324 |         width: calc(50% - 10px);
325 |     }
326 | 
327 |     #scenes-grid {
328 |         grid-template-columns: repeat(2, 1fr);
329 |     }
330 | }
331 | 
332 | @media (max-width: 480px) {
333 |     .site-card, .scene-card {
334 |         width: calc(100% - 10px);
335 |     }
336 | 
337 |     #scenes-grid {
338 |         grid-template-columns: 1fr;
339 |     }
340 | }
341 | 


--------------------------------------------------------------------------------
/jizzarr/web/static/tpdblogo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Serechops/Jizzarr/ab59265a44f80a192dfd243d2ab20be3cface2f6/jizzarr/web/static/tpdblogo.png


--------------------------------------------------------------------------------
/jizzarr/web/templates/collection.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE html>
   2 | <html lang="en">
   3 | <head>
   4 |     <meta charset="UTF-8">
   5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
   6 |     <title>My Collection</title>
   7 |     <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}">
   8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/css/bootstrap.min.css">
   9 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.css">
  10 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css">
  11 |     <link rel="stylesheet" href="{{ url_for('static', filename='collection.css') }}">
  12 |     <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;700&display=swap" rel="stylesheet">
  13 | </head>
  14 | <body>
  15 |     <nav class="custom-navbar">
  16 |         <a href="{{ url_for('index') }}">
  17 |             <img src="{{ url_for('static', filename='favicon.ico') }}" alt="Favicon" class="favicon">
  18 |             Jizzarr Home
  19 |         </a>
  20 |         <a href="{{ url_for('collection') }}">My Collection</a>
  21 |         <a href="{{ url_for('config_page') }}">Settings</a>
  22 |         <a href="{{ url_for('logs') }}">Logs</a>
  23 |         <a href="{{ url_for('stats_page') }}">Stats</a>
  24 |     </nav>
  25 |     <div class="container mt-4">
  26 |         <div class="mb-3">
  27 |             <input type="text" id="search-input" class="form-control" placeholder="Search by site name...">
  28 |         </div>
  29 |         <div class="d-flex justify-content-start mb-3 button-container">
  30 |         <div class="d-flex flex-column align-items-start">
  31 |             <button id="sort-asc" class="btn btn-secondary mb-2">Sort A-Z</button>
  32 |             <button id="sort-desc" class="btn btn-secondary mb-2">Sort Z-A</button>
  33 |         </div>
  34 |     </div>
  35 |         <button id="filter-matched-sites" class="btn btn-primary mb-2">Show Only Matched Sites</button>
  36 |         <center><h5>Site Pages</h5></center>
  37 |         <center><span id="site-page-info" class="mx-2"></span></center>
  38 |         <div class="pagination-controls d-flex justify-content-center mt-4">
  39 |             <button id="site-first-page" class="btn btn-outline-secondary me-2">First</button>
  40 |             <button id="site-prev-page" class="btn btn-outline-secondary me-2">Prev</button>
  41 |             <button id="site-next-page" class="btn btn-outline-secondary me-2">Next</button>
  42 |             <button id="site-last-page" class="btn btn-outline-secondary">Last</button>
  43 |         </div>
  44 |         <div id="site-collection" class="row g-4"></div>
  45 |         <div id="scene-collection" class="d-none">
  46 |             <div id="back-button-container" class="mb-3">
  47 |                 <button id="back-button" class="btn btn-secondary">Back to Sites</button>
  48 |             </div>
  49 |             <div class="site-logo" id="site-logo"></div>
  50 |             <p class="site-title" id="site-title"></p>
  51 |             <div class="scene-count" id="scene-count"></div>
  52 |             <div class="match-controls">
  53 |                 <div>
  54 |                     <label for="page-size">Results per page:</label>
  55 |                     <select id="page-size" class="form-select w-auto d-inline-block">
  56 |                         <option value="10">10</option>
  57 |                         <option value="25">25</option>
  58 |                         <option value="50">50</option>
  59 |                         <option value="100" selected>100</option>
  60 |                         <option value="250">250</option>
  61 |                         <option value="500">500</option>
  62 |                         <option value="1000">1000</option>
  63 |                     </select>
  64 |                 </div>
  65 |                 <button id="toggle-matches" class="btn btn-primary">Show Only Matched Scenes</button>
  66 |                 <button id="set-home-directory-button" class="btn btn-primary">Set Home Directory</button>
  67 |                 <button id="suggest-matches-button" class="btn btn-primary">Suggest Matches</button>
  68 |                 <button id="match-by-uuid-button" class="btn btn-primary">Match by UUID</button>
  69 |                 <button id="bulk-update-button" class="btn btn-primary">Bulk Update Matches</button>
  70 |                 <button id="search-stash-button" class="btn btn-primary">Search Stash for Matches</button>
  71 |                 <button id="copy-all-urls-button" class="btn btn-primary">Copy All URLs to Clipboard</button>
  72 |             </div>
  73 |             <div id="compare-container" class="compare-container mt-3">
  74 |                 <h4>Current Home Directory:</h4>
  75 |                 <h5><span id="home-directory-display"></span></h5>
  76 |             </div>
  77 |             <div class="mb-3">
  78 |                 <input type="text" id="performer-search-input" class="form-control" placeholder="Search by performer name...">
  79 |             </div>
  80 |             <center><h5>Scene Pages:</h5></center>
  81 |             <center><span id="scene-page-info" class="mx-2"></span></center>
  82 |             <div class="pagination-controls d-flex justify-content-center mt-4">
  83 |                 <button id="scene-first-page" class="btn btn-outline-secondary me-2">First</button>
  84 |                 <button id="scene-prev-page" class="btn btn-outline-secondary me-2">Prev</button>
  85 |                 <button id="scene-next-page" class="btn btn-outline-secondary me-2">Next</button>
  86 |                 <button id="scene-last-page" class="btn btn-outline-secondary">Last</button>
  87 |             </div>            
  88 |             <table class="table table-dark-mode">
  89 |                 <thead>
  90 |                     <tr>
  91 |                         <th data-column="title">Title</th>
  92 |                         <th data-column="date">Release Date</th>
  93 |                         <th data-column="duration">Duration</th>
  94 |                         <th data-column="performers">Performers</th>
  95 |                         <th data-column="status">Status</th>
  96 |                         <th data-column="file_path">File Directory</th>
  97 |                         <th data-column="foreign_guid">TPDB Scene UUID</th>
  98 |                         <th>Action</th>
  99 |                         <th>Scene URL</th>
 100 |                     </tr>
 101 |                 </thead>
 102 |                 <tbody id="scene-table-body"></tbody>
 103 |             </table>
 104 |         </div>
 105 |     </div>
 106 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/js/bootstrap.bundle.min.js"></script>
 107 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.js"></script>
 108 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/js/fontawesome.min.js"></script>
 109 |     <script>
 110 |     function copyToClipboard(url) {
 111 |         navigator.clipboard.writeText(url).then(() => {
 112 |         });
 113 |     }
 114 |     
 115 | document.addEventListener('DOMContentLoaded', function() {
 116 |     const siteCollectionContainer = document.getElementById('site-collection');
 117 |     const sceneCollectionContainer = document.getElementById('scene-collection');
 118 |     const backButton = document.getElementById('back-button');
 119 |     const sceneTableBody = document.getElementById('scene-table-body');
 120 |     const firstPageButton = document.getElementById('site-first-page');
 121 |     const prevPageButton = document.getElementById('site-prev-page');
 122 |     const nextPageButton = document.getElementById('site-next-page');
 123 |     const lastPageButton = document.getElementById('site-last-page');
 124 |     const sceneFirstPageButton = document.getElementById('scene-first-page');
 125 |     const scenePrevPageButton = document.getElementById('scene-prev-page');
 126 |     const sceneNextPageButton = document.getElementById('scene-next-page');
 127 |     const sceneLastPageButton = document.getElementById('scene-last-page');
 128 |     const setHomeDirectoryButton = document.getElementById('set-home-directory-button');
 129 |     const suggestMatchesButton = document.getElementById('suggest-matches-button');
 130 |     const matchByUUIDButton = document.getElementById('match-by-uuid-button');
 131 |     const bulkUpdateButton = document.getElementById('bulk-update-button');
 132 |     const pageSizeSelect = document.getElementById('page-size');
 133 |     const homeDirectoryDisplay = document.getElementById('home-directory-display');
 134 |     const toggleMatchesButton = document.getElementById('toggle-matches');
 135 |     const siteLogoContainer = document.getElementById('site-logo');
 136 |     const siteTitleContainer = document.getElementById('site-title');
 137 |     const sceneCountDisplay = document.getElementById('scene-count');
 138 |     const compareContainer = document.getElementById('compare-container');
 139 |     const searchInput = document.getElementById('search-input');
 140 |     const sortAscButton = document.getElementById('sort-asc');
 141 |     const sortDescButton = document.getElementById('sort-desc');
 142 |     const searchStashButton = document.getElementById('search-stash-button');
 143 |     const getAllUrlsButton = document.getElementById('get-all-urls-button');
 144 |     const performerSearchInput = document.getElementById('performer-search-input');
 145 |     const sitePageInfo = document.getElementById('site-page-info');
 146 |     const filterMatchedSitesButton = document.getElementById('filter-matched-sites');
 147 |     const searchInputContainer = document.querySelector('.mb-3');
 148 |     const buttonContainer = document.querySelector('.button-container');
 149 |     const sitePaginationControls = document.querySelector('.pagination-controls');
 150 |     const siteASCPaginationControls = document.querySelector('button#sort-asc');
 151 |     const siteDESCPaginationControls = document.querySelector('button#sort-desc');
 152 |     const siteFIRSTPaginationControls = document.querySelector('button#site-first-page');
 153 |     const siteNEXTPaginationControls = document.querySelector('button#site-next-page');
 154 |     const sitePREVPaginationControls = document.querySelector('button#site-prev-page');
 155 |     const siteLASTPaginationControls = document.querySelector('button#site-last-page');
 156 |     const sitePagesHeading = document.querySelector('center > h5');
 157 |     const copyAllUrlsButton = document.getElementById('copy-all-urls-button');
 158 |     
 159 |     let filteredScenes = [];
 160 |     let selectedDirectoryPath = '';
 161 |     let currentSiteUuid = '';
 162 |     let homeDirectory = '';
 163 |     let currentPage = 1;
 164 |     let sitesPerPage = 12;
 165 |     let scenesPerPage = parseInt(pageSizeSelect.value, 10);
 166 |     let currentScenes = [];
 167 |     let allSites = [];
 168 |     let sortColumn = '';
 169 |     let sortDirection = 'asc';
 170 |     let showOnlyMatches = false;
 171 |     let suggestedMatches = [];
 172 |     let excludedMatches = new Set();
 173 |     let totalPages = 1;
 174 |     let totalScenePages = 1;
 175 |     let showOnlyMatchedSites = false;
 176 |     
 177 |     function handleSiteCardClick() {
 178 |         // Hide site-related elements
 179 |         searchInputContainer.style.display = 'none';
 180 |         buttonContainer.style.display = 'none';
 181 |         sitePaginationControls.style.display = 'none';
 182 |         siteASCPaginationControls.style.display = 'none';
 183 |         siteDESCPaginationControls.style.display = 'none';
 184 |         sitePageInfo.style.display = 'none';
 185 |         sitePagesHeading.style.display = 'none';
 186 |         filterMatchedSitesButton.style.display = 'none';
 187 |         
 188 |         // Show scene-related elements
 189 |         siteCollectionContainer.classList.add('d-none');
 190 |         sceneCollectionContainer.classList.remove('d-none');
 191 |         
 192 |         // Update scenes for the clicked site
 193 |         fetchScenesForSite(currentSiteUuid).then(scenes => {
 194 |             showScenesForSite(scenes);
 195 |         }).catch(error => {
 196 |             console.error('Error fetching scenes for site:', error);
 197 |             showScenesForSite([]);
 198 |         });
 199 |     }
 200 |     
 201 |     backButton.addEventListener('click', () => {
 202 |         // Show site-related elements
 203 |         searchInputContainer.style.display = '';
 204 |         buttonContainer.style.display = '';
 205 |         sitePaginationControls.style.display = '';
 206 |         siteASCPaginationControls.style.display = '';
 207 |         siteDESCPaginationControls.style.display = '';
 208 |         siteFIRSTPaginationControls.style.display = '';
 209 |         siteNEXTPaginationControls.style.display = '';
 210 |         sitePREVPaginationControls.style.display = '';
 211 |         siteLASTPaginationControls.style.display = '';
 212 |         sitePageInfo.style.display = '';
 213 |         sitePagesHeading.style.display = '';
 214 |         filterMatchedSitesButton.style.display = '';
 215 |         
 216 |         // Hide scene-related elements
 217 |         siteCollectionContainer.classList.remove('d-none');
 218 |         sceneCollectionContainer.classList.add('d-none');
 219 |     });
 220 | 
 221 |      copyAllUrlsButton.addEventListener('click', function() {
 222 |         let urls = [];
 223 |         const sceneTableRows = document.querySelectorAll('#scene-table-body tr');
 224 |         
 225 |         sceneTableRows.forEach(row => {
 226 |             const sceneUrlElement = row.querySelector('td:last-child a'); // Target the Scene URL specifically
 227 |             if (sceneUrlElement && sceneUrlElement.href) {
 228 |                 urls.push(sceneUrlElement.href);
 229 |             }
 230 |         });
 231 | 
 232 |         if (urls.length > 0) {
 233 |             const urlsText = urls.join('\n');
 234 |             navigator.clipboard.writeText(urlsText).then(() => {
 235 |                 Toastify({
 236 |                     text: 'All Scene URLs copied to clipboard!',
 237 |                     duration: 3000,
 238 |                     close: true,
 239 |                     gravity: "top",
 240 |                     position: "right",
 241 |                     backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 242 |                 }).showToast();
 243 |             }).catch(err => {
 244 |                 console.error('Error copying Scene URLs to clipboard:', err);
 245 |                 Toastify({
 246 |                     text: 'Error copying Scene URLs to clipboard: ' + err.message,
 247 |                     duration: 3000,
 248 |                     close: true,
 249 |                     gravity: "top",
 250 |                     position: "right",
 251 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 252 |                 }).showToast();
 253 |             });
 254 |         } else {
 255 |             Toastify({
 256 |                 text: 'No Scene URLs found to copy!',
 257 |                 duration: 3000,
 258 |                 close: true,
 259 |                 gravity: "top",
 260 |                 position: "right",
 261 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 262 |             }).showToast();
 263 |         }
 264 |     });
 265 |     
 266 |     setHomeDirectoryButton.addEventListener('click', function() {
 267 |         const input = document.createElement('input');
 268 |         input.type = 'text';
 269 |         input.placeholder = 'Enter home directory path';
 270 |         input.classList.add('form-control', 'mt-2');
 271 |         const saveButton = document.createElement('button');
 272 |         saveButton.textContent = 'Save';
 273 |         saveButton.classList.add('btn', 'btn-primary', 'mt-2');
 274 |         saveButton.addEventListener('click', async () => {
 275 |             selectedDirectoryPath = input.value.replace(/\\/g, '/');
 276 |             console.log('Selected directory:', selectedDirectoryPath);
 277 | 
 278 |             try {
 279 |                 const response = await fetch('/set_home_directory', {
 280 |                     method: 'POST',
 281 |                     headers: {
 282 |                         'Content-Type': 'application/json'
 283 |                     },
 284 |                     body: JSON.stringify({ site_uuid: currentSiteUuid, directory: selectedDirectoryPath })
 285 |                 });
 286 | 
 287 |                 const result = await response.json();
 288 |                 if (response.ok) {
 289 |                     homeDirectory = selectedDirectoryPath;
 290 |                     homeDirectoryDisplay.textContent = homeDirectory;
 291 |                     Toastify({
 292 |                         text: result.message,
 293 |                         duration: 3000,
 294 |                         close: true,
 295 |                         gravity: "top",
 296 |                         position: "right",
 297 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 298 |                     }).showToast();
 299 |                 } else {
 300 |                     throw new Error(result.error);
 301 |                 }
 302 |             } catch (error) {
 303 |                 console.error('Error setting home directory:', error);
 304 |                 Toastify({
 305 |                     text: 'Error setting home directory: ' + error.message,
 306 |                     duration: 3000,
 307 |                     close: true,
 308 |                     gravity: "top",
 309 |                     position: "right",
 310 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 311 |                 }).showToast();
 312 |             }
 313 |         });
 314 |         compareContainer.innerHTML = '';
 315 |         compareContainer.appendChild(input);
 316 |         compareContainer.appendChild(saveButton);
 317 |     });
 318 |     
 319 |     function filterScenesByPerformers() {
 320 |         const searchTerm = performerSearchInput.value.toLowerCase();
 321 |         if (searchTerm) {
 322 |             filteredScenes = currentScenes.filter(scene => {
 323 |                 const performers = Array.isArray(scene.performers) ? scene.performers.join(', ') : scene.performers;
 324 |                 return performers.toLowerCase().includes(searchTerm);
 325 |             });
 326 |         } else {
 327 |             filteredScenes = [];
 328 |         }
 329 |         currentPage = 1; // Reset to the first page when filtering
 330 |         displayScenes();
 331 |         updateScenePaginationButtons();
 332 |         updateSearchFieldOutline();
 333 |     }
 334 | 
 335 |     function updateSearchFieldOutline() {
 336 |         if (performerSearchInput.value && filteredScenes.length === 0) {
 337 |             performerSearchInput.classList.add('no-results');
 338 |         } else {
 339 |             performerSearchInput.classList.remove('no-results');
 340 |         }
 341 |     }
 342 | 
 343 |     performerSearchInput.addEventListener('input', debounce(filterScenesByPerformers, 300));
 344 | 
 345 |     suggestMatchesButton.addEventListener('click', async function() {
 346 |         try {
 347 |             const response = await fetch('/suggest_matches', {
 348 |                 method: 'POST',
 349 |                 headers: {
 350 |                     'Content-Type': 'application/json'
 351 |                 },
 352 |                 body: JSON.stringify({ site_uuid: currentSiteUuid, tolerance: 95 })
 353 |             });
 354 |     
 355 |             if (!response.ok) {
 356 |                 const errorText = await response.text();
 357 |                 throw new Error(`Error ${response.status}: ${errorText}`);
 358 |             }
 359 |     
 360 |             suggestedMatches = await response.json();
 361 |             const matchedScenes = [];
 362 |     
 363 |             suggestedMatches.forEach(match => {
 364 |                 const scene = currentScenes.find(scene => scene.id === match.scene_id);
 365 |                 if (scene && !matchedScenes.find(s => s.id === scene.id)) {
 366 |                     matchedScenes.push(scene);
 367 |                     scene.suggested_file = match.suggested_file;
 368 |                 }
 369 |             });
 370 |     
 371 |             currentScenes = matchedScenes;
 372 |             displayScenesWithActions();
 373 |             enableBulkUpdate = false;
 374 |             bulkUpdateButton.disabled = true;
 375 |         } catch (error) {
 376 |             console.error('Error suggesting matches:', error);
 377 |             Toastify({
 378 |                 text: 'Error suggesting matches: ' + error.message,
 379 |                 duration: 3000,
 380 |                 close: true,
 381 |                 gravity: "top",
 382 |                 position: "right",
 383 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 384 |             }).showToast();
 385 |         }
 386 |     });
 387 | 
 388 |     matchByUUIDButton.addEventListener('click', async function() {
 389 |         try {
 390 |             const response = await fetch('/match_by_uuid', {
 391 |                 method: 'POST',
 392 |                 headers: {
 393 |                     'Content-Type': 'application/json'
 394 |                 },
 395 |                 body: JSON.stringify({ site_uuid: currentSiteUuid })
 396 |             });
 397 |     
 398 |             if (!response.ok) {
 399 |                 const errorText = await response.text();
 400 |                 throw new Error(`Error ${response.status}: ${errorText}`);
 401 |             }
 402 |     
 403 |             const uuidMatches = await response.json();
 404 |             console.log('UUID matches:', uuidMatches);
 405 |     
 406 |             // Clear current table
 407 |             sceneTableBody.innerHTML = '';
 408 |     
 409 |             // Display matched results
 410 |             uuidMatches.forEach(match => {
 411 |                 const scene = currentScenes.find(s => s.id === match.scene_id && s.status !== 'Found');
 412 |                 if (scene) {
 413 |                     const row = document.createElement('tr');
 414 |                     row.setAttribute('data-scene-id', scene.id);
 415 |                     row.setAttribute('data-foreign-guid', scene.foreign_guid);
 416 |     
 417 |                     const filePathCellContent = `<i class="fa-regular fa-square-check file-path-icon"></i>${match.suggested_file}`;
 418 |                     row.innerHTML = `
 419 |                         <td>${scene.title}</td>
 420 |                         <td>${scene.date}</td>
 421 |                         <td>${formatDuration(scene.duration)}</td>
 422 |                         <td>${formatPerformers(scene.performers)}</td>
 423 |                         <td>Missing</td>
 424 |                         <td data-column="file_path">${filePathCellContent}</td>
 425 |                         <td data-column="foreign_guid">${scene.foreign_guid}</td>
 426 |                         <td data-column="action" class="action-buttons">
 427 |                             <button class="btn btn-success me-2 confirm-match" data-scene-id="${scene.id}" data-file-path="${match.suggested_file}">Confirm</button>
 428 |                             <button class="btn btn-danger cancel-match">Cancel</button>
 429 |                         </td>
 430 |                         <td>${scene.url ? `<a href="${scene.url}" target="_blank">View Scene</a>` : ''}</td>
 431 |                     `;
 432 |     
 433 |                     row.querySelector('.confirm-match').addEventListener('click', async () => {
 434 |                         try {
 435 |                             const fullFilePath = match.suggested_file;
 436 |                             const response = await fetch('/match_scene', {
 437 |                                 method: 'POST',
 438 |                                 headers: {
 439 |                                     'Content-Type': 'application/json'
 440 |                                 },
 441 |                                 body: JSON.stringify({ scene_id: match.scene_id, file_path: fullFilePath })
 442 |                             });
 443 |     
 444 |                             if (!response.ok) {
 445 |                                 const errorText = await response.text();
 446 |                                 throw new Error(`Error ${response.status}: ${errorText}`);
 447 |                             }
 448 |     
 449 |                             const result = await response.json();
 450 |                             Toastify({
 451 |                                 text: result.message,
 452 |                                 duration: 3000,
 453 |                                 close: true,
 454 |                                 gravity: "top",
 455 |                                 position: "right",
 456 |                                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 457 |                             }).showToast();
 458 |     
 459 |                             const confirmedRow = document.querySelector(`tr[data-foreign-guid="${match.scene_id}"]`);
 460 |                             if (confirmedRow) {
 461 |                                 confirmedRow.querySelector('td[data-column="file_path"]').innerHTML = filePathCellContent;
 462 |                                 confirmedRow.querySelector('td[data-column="file_path"]').classList.add('highlight-found');
 463 |                                 confirmedRow.querySelector('td[data-column="action"]').innerHTML = '';
 464 |                             }
 465 |                         } catch (error) {
 466 |                             console.error('Error confirming match:', error);
 467 |                             Toastify({
 468 |                                 text: 'Error confirming match: ' + error.message,
 469 |                                 duration: 3000,
 470 |                                 close: true,
 471 |                                 gravity: "top",
 472 |                                 position: "right",
 473 |                                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 474 |                             }).showToast();
 475 |                         }
 476 |                     });
 477 |     
 478 |                     row.querySelector('.cancel-match').addEventListener('click', () => {
 479 |                         const filePathCell = row.querySelector('td[data-column="file_path"]');
 480 |                         filePathCell.innerHTML = '';
 481 |                         const actionCell = row.querySelector('td[data-column="action"]');
 482 |                         actionCell.innerHTML = '';
 483 |                     });
 484 |     
 485 |                     sceneTableBody.appendChild(row);
 486 |                 }
 487 |             });
 488 |     
 489 |             Toastify({
 490 |                 text: 'UUID matches found successfully!',
 491 |                 duration: 3000,
 492 |                 close: true,
 493 |                 gravity: "top",
 494 |                 position: "right",
 495 |                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 496 |             }).showToast();
 497 |         } catch (error) {
 498 |             console.error('Error matching by UUID:', error);
 499 |             Toastify({
 500 |                 text: 'Error matching by UUID: ' + error.message,
 501 |                 duration: 3000,
 502 |                 close: true,
 503 |                 gravity: "top",
 504 |                 position: "right",
 505 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 506 |             }).showToast();
 507 |         }
 508 |     });
 509 | 
 510 |     function formatDuration(totalSeconds) {
 511 |         if (totalSeconds === null || totalSeconds === undefined) return 'N/A';
 512 |         
 513 |         console.log(`Original duration: ${totalSeconds}`); // Debugging line
 514 |     
 515 |         totalSeconds = parseInt(totalSeconds, 10); // Ensure totalSeconds is an integer
 516 |         if (isNaN(totalSeconds)) {
 517 |             console.error(`Invalid duration: ${totalSeconds}`); // Debugging line
 518 |             return 'N/A';
 519 |         }
 520 |     
 521 |         totalSeconds = Math.round(totalSeconds); // Ensure totalSeconds is rounded to the nearest integer
 522 |     
 523 |         const hours = Math.floor(totalSeconds / 3600);
 524 |         const minutes = Math.floor((totalSeconds % 3600) / 60);
 525 |         const seconds = totalSeconds % 60;
 526 |     
 527 |         let durationString = '';
 528 |         if (hours > 0) {
 529 |             durationString += `${hours}h `;
 530 |         }
 531 |         if (minutes > 0 || hours > 0) { // Include minutes if there are hours, even if minutes are zero
 532 |             durationString += `${minutes}m `;
 533 |         }
 534 |         durationString += `${seconds}s`;
 535 |     
 536 |         console.log(`Converted duration: ${durationString}`); // Debugging line
 537 |     
 538 |         return durationString.trim(); // Trim any trailing space
 539 |     }
 540 | 
 541 | 
 542 |     
 543 |     function formatPerformers(performers) {
 544 |         return Array.isArray(performers) ? performers.join(', ') : performers;
 545 |     }
 546 | 
 547 |     function displayScenesWithActions() {
 548 |         sceneTableBody.innerHTML = '';
 549 |         const sortedScenes = sortScenes(currentScenes);
 550 |     
 551 |         sortedScenes.forEach(scene => {
 552 |             const row = document.createElement('tr');
 553 |             row.setAttribute('data-scene-id', scene.id);
 554 |             row.setAttribute('data-foreign-guid', scene.foreign_guid);
 555 |             const cleanFilePath = scene.suggested_file ? scene.suggested_file.replace(homeDirectory, '') : '';
 556 |             row.innerHTML = `
 557 |                 <td>${scene.title}</td>
 558 |                 <td>${scene.date}</td>
 559 |                 <td>${formatDuration(scene.duration)}</td>
 560 |                 <td>${formatPerformers(scene.performers)}</td>
 561 |                 <td>${scene.status === 'Found' ? 'Found' : '<i class="fa-solid fa-triangle-exclamation" style="color: red;"></i> Missing'}</td>
 562 |                 <td data-column="file_path">${scene.local_path ? `<i class="fa-regular fa-square-check file-path-icon"></i>${scene.local_path}` : cleanFilePath}</td>
 563 |                 <td data-column="foreign_guid">${scene.foreign_guid}</td>
 564 |                 <td data-column="action" class="action-buttons">
 565 |                     <button class="btn btn-success me-2 confirm-match" data-scene-id="${scene.id}" data-file-path="${cleanFilePath}">Confirm</button>
 566 |                     <button class="btn btn-danger cancel-match">Cancel</button>
 567 |                 </td>
 568 |             `;
 569 |     
 570 |             row.querySelector('.confirm-match').addEventListener('click', async () => {
 571 |                 try {
 572 |                     const fullFilePath = `${cleanFilePath}`;
 573 |                     const response = await fetch('/match_scene', {
 574 |                         method: 'POST',
 575 |                         headers: {
 576 |                             'Content-Type': 'application/json'
 577 |                         },
 578 |                         body: JSON.stringify({
 579 |                             scene_id: scene.id,
 580 |                             file_path: fullFilePath,
 581 |                             prepend_home_directory: true  // Indicate to prepend home directory
 582 |                         })
 583 |                     });
 584 |     
 585 |                     if (!response.ok) {
 586 |                         const errorText = await response.text();
 587 |                         throw new Error(`Error ${response.status}: ${errorText}`);
 588 |                     }
 589 |     
 590 |                     const result = await response.json();
 591 |                     Toastify({
 592 |                         text: result.message,
 593 |                         duration: 3000,
 594 |                         close: true,
 595 |                         gravity: "top",
 596 |                         position: "right",
 597 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 598 |                     }).showToast();
 599 |     
 600 |                     scene.status = 'Found';
 601 |                     scene.local_path = fullFilePath;
 602 |     
 603 |                     row.querySelector('td[data-column="file_path"]').innerHTML = `<i class="fa-regular fa-square-check file-path-icon"></i>${fullFilePath}`;
 604 |                     row.querySelector('td[data-column="file_path"]').classList.add('highlight-found');
 605 |                     row.querySelector('td[data-column="action"]').innerHTML = '';
 606 |                 } catch (error) {
 607 |                     console.error('Error confirming match:', error);
 608 |                     Toastify({
 609 |                         text: 'Error confirming match: ' + error.message,
 610 |                         duration: 3000,
 611 |                         close: true,
 612 |                         gravity: "top",
 613 |                         position: "right",
 614 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 615 |                     }).showToast();
 616 |                 }
 617 |             });
 618 |     
 619 |             row.querySelector('.cancel-match').addEventListener('click', () => {
 620 |                 const filePathCell = row.querySelector('td[data-column="file_path"]');
 621 |                 filePathCell.innerHTML = '';
 622 |                 const actionCell = row.querySelector('td[data-column="action"]');
 623 |                 actionCell.innerHTML = '';
 624 |             });
 625 |     
 626 |             sceneTableBody.appendChild(row);
 627 |         });
 628 |     }
 629 | 
 630 |     searchStashButton.addEventListener('click', async function() {
 631 |         try {
 632 |             const response = await fetch('/search_stash_for_matches', {
 633 |                 method: 'POST',
 634 |                 headers: {
 635 |                     'Content-Type': 'application/json'
 636 |                 },
 637 |                 body: JSON.stringify({ site_uuid: currentSiteUuid })
 638 |             });
 639 | 
 640 |             if (!response.ok) {
 641 |                 const errorText = await response.text();
 642 |                 throw new Error(`Error ${response.status}: ${errorText}`);
 643 |             }
 644 | 
 645 |             const stashMatches = await response.json();
 646 |             displayStashMatches(stashMatches);
 647 | 
 648 |             Toastify({
 649 |                 text: 'Stash matches found successfully!',
 650 |                 duration: 3000,
 651 |                 close: true,
 652 |                 gravity: "top",
 653 |                 position: "right",
 654 |                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 655 |             }).showToast();
 656 |         } catch (error) {
 657 |             console.error('Error searching stash for matches:', error);
 658 |             Toastify({
 659 |                 text: 'Error searching stash for matches: ' + error.message,
 660 |                 duration: 3000,
 661 |                 close: true,
 662 |                 gravity: "top",
 663 |                 position: "right",
 664 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 665 |             }).showToast();
 666 |         }
 667 |     });
 668 | 
 669 |     function displayStashMatches(matches) {
 670 |         sceneTableBody.innerHTML = ''; // Clear the existing table content
 671 | 
 672 |         matches.forEach(match => {
 673 |             const row = document.createElement('tr');
 674 |             row.setAttribute('data-scene-id', match.scene_id);
 675 |             if (match.scene_status === 'Found') return; // Skip already matched scenes
 676 |             row.innerHTML = `
 677 |                 <td>${match.scene_title}</td>
 678 |                 <td>${match.scene_date}</td>
 679 |                 <td>${formatDuration(match.scene_duration)}</td>
 680 |                 <td>${formatPerformers(match.scene_performers)}</td>
 681 |                 <td>${match.scene_status === 'Found' ? 'Found' : '<i class="fa-solid fa-triangle-exclamation" style="color: red;"></i> Missing'}</td>
 682 |                 <td>${match.scene_local_path ? match.scene_local_path : match.matched_file_path}</td>
 683 |                 <td>${match.foreign_guid}</td>
 684 |                 <td>
 685 |                     <button class="btn btn-success confirm-match" data-scene-id="${match.scene_id}" data-file-path="${match.matched_file_path}">Confirm</button>
 686 |                 </td>
 687 |             `;
 688 | 
 689 |             row.querySelector('.confirm-match').addEventListener('click', async (e) => {
 690 |                 const button = e.target;
 691 |                 const sceneId = button.getAttribute('data-scene-id');
 692 |                 const filePath = button.getAttribute('data-file-path');
 693 | 
 694 |                 try {
 695 |                     const response = await fetch('/match_scene', {
 696 |                         method: 'POST',
 697 |                         headers: {
 698 |                             'Content-Type': 'application/json'
 699 |                         },
 700 |                         body: JSON.stringify({ scene_id: sceneId, file_path: filePath })
 701 |                     });
 702 | 
 703 |                     if (!response.ok) {
 704 |                         const errorText = await response.text();
 705 |                         throw new Error(`Error ${response.status}: ${errorText}`);
 706 |                     }
 707 | 
 708 |                     const result = await response.json();
 709 |                     Toastify({
 710 |                         text: result.message,
 711 |                         duration: 3000,
 712 |                         close: true,
 713 |                         gravity: "top",
 714 |                         position: "right",
 715 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 716 |                     }).showToast();
 717 | 
 718 |                     // Update the row to reflect the confirmed match
 719 |                     row.querySelector('td:nth-child(6)').innerText = filePath;
 720 |                     row.querySelector('td:nth-child(5)').innerHTML = 'Found';
 721 |                     button.remove();
 722 |                 } catch (error) {
 723 |                     console.error('Error confirming match:', error);
 724 |                     Toastify({
 725 |                         text: 'Error confirming match: ' + error.message,
 726 |                         duration: 3000,
 727 |                         close: true,
 728 |                         gravity: "top",
 729 |                         position: "right",
 730 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 731 |                     }).showToast();
 732 |                 }
 733 |             });
 734 | 
 735 |             sceneTableBody.appendChild(row);
 736 |         });
 737 |     }
 738 | 
 739 |     bulkUpdateButton.addEventListener('click', async function() {
 740 |         let matchesToProcess = [];
 741 | 
 742 |         document.querySelectorAll('tr').forEach(row => {
 743 |             const confirmButton = row.querySelector('.confirm-match');
 744 |             if (confirmButton) {
 745 |                 const sceneId = confirmButton.getAttribute('data-scene-id');
 746 |                 const filePath = confirmButton.getAttribute('data-file-path');
 747 |                 matchesToProcess.push({
 748 |                     scene_id: sceneId,
 749 |                     file_path: filePath
 750 |                 });
 751 |             }
 752 |         });
 753 | 
 754 |         for (const match of matchesToProcess) {
 755 |             try {
 756 |                 const response = await fetch('/match_scene', {
 757 |                     method: 'POST',
 758 |                     headers: {
 759 |                         'Content-Type': 'application/json'
 760 |                     },
 761 |                     body: JSON.stringify({ scene_id: match.scene_id, file_path: match.file_path })
 762 |                 });
 763 | 
 764 |                 if (!response.ok) {
 765 |                     const errorText = await response.text();
 766 |                     throw new Error(`Error ${response.status}: ${errorText}`);
 767 |                 }
 768 | 
 769 |                 const result = await response.json();
 770 | 
 771 |                 const scene = currentScenes.find(s => s.id == match.scene_id);
 772 |                 if (scene) {
 773 |                     scene.status = 'Found';
 774 |                     scene.local_path = match.file_path;
 775 |                 }
 776 |             } catch (error) {
 777 |                 console.error('Error confirming match:', error);
 778 |                 Toastify({
 779 |                     text: 'Error confirming match: ' + error.message,
 780 |                     duration: 3000,
 781 |                     close: true,
 782 |                     gravity: "top",
 783 |                     position: "right",
 784 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 785 |                 }).showToast();
 786 |             }
 787 |         }
 788 |         displayScenes();
 789 |         Toastify({
 790 |             text: 'All matches confirmed!',
 791 |             duration: 3000,
 792 |             close: true,
 793 |             gravity: "top",
 794 |             position: "right",
 795 |             backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 796 |         }).showToast();
 797 |     });
 798 | 
 799 |     function enableBulkUpdateButton() {
 800 |         enableBulkUpdate = true;
 801 |         bulkUpdateButton.disabled = false;
 802 |     }
 803 | 
 804 |     async function fetchCollection() {
 805 |         try {
 806 |             const response = await fetch('/collection_data?per_page=1000'); // Fetch all data at once
 807 |             if (!response.ok) {
 808 |                 throw new Error(`Error ${response.status}: ${await response.text()}`);
 809 |             }
 810 |             const siteCollection = await response.json();
 811 |             console.log('Collection fetched:', siteCollection);
 812 |     
 813 |             allSites = siteCollection.collection_data;
 814 |             totalPages = Math.ceil(allSites.length / sitesPerPage);
 815 |             displayCollection();
 816 |         } catch (error) {
 817 |             console.error('Error fetching collection:', error);
 818 |             Toastify({
 819 |                 text: 'Error fetching collection: ' + error.message,
 820 |                 duration: 3000,
 821 |                 close: true,
 822 |                 gravity: "top",
 823 |                 position: "right",
 824 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 825 |             }).showToast();
 826 |         }
 827 |     }
 828 |     
 829 |     filterMatchedSitesButton.addEventListener('click', () => {
 830 |         showOnlyMatchedSites = !showOnlyMatchedSites;
 831 |         filterMatchedSitesButton.textContent = showOnlyMatchedSites ? 'Show All Sites' : 'Show Only Matched Sites';
 832 |         displayCollection();
 833 |     });
 834 | 
 835 | 
 836 |     function displayCollection(page = 1, filteredCollection = null) {
 837 |         siteCollectionContainer.innerHTML = '';
 838 | 
 839 |         let collectionData = filteredCollection || allSites;
 840 |         
 841 |         if (showOnlyMatchedSites) {
 842 |             collectionData = collectionData.filter(site => site.collected_scenes > 0);
 843 |         }
 844 | 
 845 |         totalPages = Math.ceil(collectionData.length / sitesPerPage);
 846 |         currentPage = page;
 847 | 
 848 |         const paginatedSites = collectionData.slice((page - 1) * sitesPerPage, page * sitesPerPage);
 849 | 
 850 |         paginatedSites.forEach(item => {
 851 |             const totalScenes = item.total_scenes;
 852 |             const collectedScenes = item.collected_scenes;
 853 |             const progressPercentage = totalScenes > 0 ? (collectedScenes / totalScenes) * 100 : 0;
 854 |             const logoUrl = item.site.logo;
 855 | 
 856 |             const siteCard = document.createElement('div');
 857 |             siteCard.classList.add('col-md-4');
 858 |             siteCard.innerHTML = `
 859 |                 <div class="card h-100 site-card ${logoUrl ? '' : 'no-logo'}">
 860 |                     <div class="card-body">
 861 |                         <div class="d-flex flex-column align-items-center">
 862 |                             ${logoUrl ? 
 863 |                                 `<img src="${logoUrl}" class="max-h-24 object-contain mb-3" alt="${item.site.name}" onerror="this.onerror=null;this.src='default_image.png';">` : 
 864 |                                 ''}
 865 |                             <h2 class="site-title">${item.site.name}</h2>
 866 |                         </div>
 867 |                         <div class="progress-bar">
 868 |                             <div class="progress-bar-inner" style="width: ${progressPercentage}%;"></div>
 869 |                             <div class="progress-bar-text">${collectedScenes} / ${totalScenes}</div>
 870 |                         </div>
 871 |                         <p class="site-title">${item.site.name}</p>
 872 |                         <button class="btn btn-danger remove-site-button" data-site-uuid="${item.site.uuid}">Remove</button>
 873 |                     </div>
 874 |                 </div>
 875 |             `;
 876 | 
 877 |         siteCard.addEventListener('click', () => {
 878 |             currentSiteUuid = item.site.uuid;
 879 |             homeDirectory = item.site.home_directory || '';
 880 |             homeDirectoryDisplay.textContent = homeDirectory;
 881 |             siteLogoContainer.innerHTML = logoUrl ? `<img src="${logoUrl}" alt="${item.site.name}">` : '';
 882 |             siteTitleContainer.innerText = item.site.name;
 883 |             
 884 |             // Hide site-related elements
 885 |             searchInputContainer.style.display = 'none';
 886 |             buttonContainer.style.display = 'none';
 887 |             sitePaginationControls.style.display = 'none';
 888 |             siteASCPaginationControls.style.display = 'none';
 889 |             siteDESCPaginationControls.style.display = 'none';
 890 |             siteFIRSTPaginationControls.style.display = 'none';
 891 |             sitePREVPaginationControls.style.display = 'none'; 
 892 |             siteNEXTPaginationControls.style.display = 'none';
 893 |             siteLASTPaginationControls.style.display = 'none';            
 894 |             sitePageInfo.style.display = 'none';
 895 |             sitePagesHeading.style.display = 'none';
 896 |             filterMatchedSitesButton.style.display = 'none';
 897 |         
 898 |             // Show scene-related elements
 899 |             siteCollectionContainer.classList.add('d-none');
 900 |             sceneCollectionContainer.classList.remove('d-none');
 901 |         
 902 |             fetchScenesForSite(item.site.uuid).then(scenes => {
 903 |                 showScenesForSite(scenes);
 904 |             }).catch(error => {
 905 |                 console.error('Error fetching scenes for site:', error);
 906 |                 showScenesForSite([]);
 907 |             });
 908 |         });
 909 |         
 910 |             siteCollectionContainer.appendChild(siteCard);
 911 |         });
 912 | 
 913 |         document.querySelectorAll('.remove-site-button').forEach(button => {
 914 |             button.addEventListener('click', async (e) => {
 915 |                 e.stopPropagation();
 916 |                 const siteUuid = e.target.getAttribute('data-site-uuid');
 917 |                 await removeSiteFromCollection(siteUuid);
 918 |             });
 919 |         });
 920 | 
 921 |         updatePaginationButtons();
 922 |         updateSitePageInfo();
 923 |     }
 924 |     
 925 |     async function fetchScenesForSite(siteUuid) {
 926 |         const response = await fetch(`/scenes_data?site_uuid=${siteUuid}`);
 927 |         if (!response.ok) {
 928 |             throw new Error(`Error ${response.status}: ${await response.text()}`);
 929 |         }
 930 |         const scenesData = await response.json();
 931 |         return scenesData.scenes || [];
 932 |     }
 933 | 
 934 | 
 935 |     async function removeSiteFromCollection(siteUuid) {
 936 |         const response = await fetch(`/remove_site/${siteUuid}`, { method: 'DELETE' });
 937 |         const data = await response.json();
 938 |         console.log('Site removed:', data);
 939 |         Toastify({
 940 |             text: 'Site has been removed from your collection.',
 941 |             duration: 3000,
 942 |             close: true,
 943 |             gravity: "top",
 944 |             position: "right",
 945 |             backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
 946 |         }).showToast();
 947 |         fetchCollection();
 948 |     }
 949 | 
 950 |     function showScenesForSite(scenes) {
 951 |         if (!scenes || !Array.isArray(scenes)) {
 952 |             console.error('Scenes data is undefined or not an array');
 953 |             scenes = []; // Ensure scenes is at least an empty array to avoid further errors
 954 |         }
 955 |         
 956 |         currentScenes = scenes.map(scene => {
 957 |             return {
 958 |                 ...scene,
 959 |                 status: scene.status || 'Missing'
 960 |             };
 961 |         });
 962 |         currentScenes = sortScenes(currentScenes, 'title', 'asc');
 963 |         currentPage = 1;
 964 |         totalScenePages = Math.ceil(currentScenes.length / scenesPerPage);
 965 |         updateSceneCount();
 966 |         displayScenes();
 967 |         updatePaginationButtons();
 968 |         updateScenePaginationButtons();
 969 |     }
 970 | 
 971 | 
 972 |     function displayScenes() {
 973 |         const scenesToDisplay = filteredScenes.length > 0 ? filteredScenes : currentScenes;
 974 |         sceneTableBody.innerHTML = '';
 975 |     
 976 |         const filteredScenesToShow = showOnlyMatches ? scenesToDisplay.filter(scene => scene.status === 'Found') : scenesToDisplay;
 977 |         const sortedScenes = sortScenes(filteredScenesToShow);
 978 |     
 979 |         // Calculate total pages and update the scene page info
 980 |         totalScenePages = Math.ceil(sortedScenes.length / scenesPerPage);
 981 |         updateScenePageInfo();
 982 |     
 983 |         const scenesToShow = sortedScenes.slice((currentPage - 1) * scenesPerPage, currentPage * scenesPerPage);
 984 |     
 985 |         scenesToShow.forEach(scene => {
 986 |             const row = document.createElement('tr');
 987 |             row.setAttribute('data-scene-id', scene.id);
 988 |             row.setAttribute('data-foreign-guid', scene.foreign_guid);
 989 |             row.innerHTML = `
 990 |                 <td>${scene.title}</td>
 991 |                 <td>${scene.date}</td>
 992 |                 <td>${scene.duration ? formatDuration(scene.duration) : 'N/A'}</td>
 993 |                 <td>${formatPerformers(scene.performers)}</td>
 994 |                 <td>${scene.status === 'Found' ? 'Found' : '<i class="fa-solid fa-triangle-exclamation" style="color: red;"></i> Missing'}</td>
 995 |                 <td data-column="file_path">${scene.local_path ? `<i class="fa-regular fa-square-check file-path-icon"></i>${scene.local_path}` : ''}</td>
 996 |                 <td data-column="foreign_guid">
 997 |                     ${scene.foreign_guid ? `<a href="https://theporndb.net/scenes/${scene.foreign_guid}" target="_blank">${scene.foreign_guid}</a>` : ''}
 998 |                 </td>
 999 |                 <td><button class="btn btn-primary match-button">Match</button></td>
1000 |                 <td>
1001 |                     ${scene.url ? `
1002 |                         <a href="${scene.url}" target="_blank">View Scene</a>
1003 |                         <img src="{{ url_for('static', filename='Jdownloader.png') }}" class="jdownloader-icon" data-url="${scene.url}" title="Copy to JDownloader" onclick="copyToClipboard('${scene.url}')">
1004 |                     ` : `
1005 |                         <button class="btn btn-info find-url-button" data-scene-id="${scene.foreign_guid}">Find URL</button>
1006 |                     `}
1007 |                 </td>
1008 |             `;
1009 |     
1010 |             row.querySelector('.match-button').addEventListener('click', () => handleMatchButtonClick(scene));
1011 |     
1012 |             const findUrlButton = row.querySelector('.find-url-button');
1013 |             if (findUrlButton) {
1014 |                 findUrlButton.addEventListener('click', () => findSceneUrl(scene.foreign_guid));
1015 |             }
1016 |     
1017 |             sceneTableBody.appendChild(row);
1018 |         });
1019 |     
1020 |         updateScenePaginationButtons();
1021 |     }
1022 |     
1023 |     function updateScenePageInfo() {
1024 |         const scenesToDisplay = filteredScenes.length > 0 ? filteredScenes : currentScenes;
1025 |         totalScenePages = Math.ceil(scenesToDisplay.length / scenesPerPage);
1026 |         document.getElementById('scene-page-info').textContent = `Page ${currentPage} of ${totalScenePages}`;
1027 |     }
1028 | 
1029 | 
1030 | 
1031 | function formatDuration(seconds) {
1032 |     if (!seconds) return 'N/A';
1033 |     const h = Math.floor(seconds / 3600);
1034 |     const m = Math.floor((seconds % 3600) / 60);
1035 |     const s = seconds % 60;
1036 |     return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
1037 | }
1038 | 
1039 | 
1040 |     toggleMatchesButton.addEventListener('click', () => {
1041 |         showOnlyMatches = !showOnlyMatches;
1042 |         displayScenes();
1043 |     });
1044 | 
1045 |     function sortScenes(scenes) {
1046 |         if (sortColumn) {
1047 |             return scenes.sort((a, b) => {
1048 |                 let valA = a[sortColumn];
1049 |                 let valB = b[sortColumn];
1050 | 
1051 |                 if (typeof valA === 'string') {
1052 |                     valA = valA.toLowerCase();
1053 |                 }
1054 |                 if (typeof valB === 'string') {
1055 |                     valB = valB.toLowerCase();
1056 |                 }
1057 | 
1058 |                 if (valA < valB) {
1059 |                     return sortDirection === 'asc' ? -1 : 1;
1060 |                 }
1061 |                 if (valA > valB) {
1062 |                     return sortDirection === 'asc' ? 1 : -1;
1063 |                 }
1064 |                 return 0;
1065 |             });
1066 |         }
1067 |         return scenes;
1068 |     }
1069 | 
1070 |     function updateSceneCount() {
1071 |         const totalScenes = currentScenes.length;
1072 |         const matchedScenes = currentScenes.filter(scene => scene.status === 'Found').length;
1073 |         sceneCountDisplay.textContent = `${matchedScenes}/${totalScenes} scenes in collection`;
1074 |     }
1075 | 
1076 |     document.querySelectorAll('th[data-column]').forEach(th => {
1077 |         th.addEventListener('click', () => {
1078 |             const column = th.getAttribute('data-column');
1079 |             if (column) {
1080 |                 if (sortColumn === column) {
1081 |                     sortDirection = sortDirection === 'asc' ? 'desc' : 'asc';
1082 |                 } else {
1083 |                     sortColumn = column;
1084 |                     sortDirection = 'asc';
1085 |                 }
1086 |                 displayScenes();
1087 |             }
1088 |         });
1089 |     });
1090 | 
1091 |     pageSizeSelect.addEventListener('change', () => {
1092 |         scenesPerPage = parseInt(pageSizeSelect.value, 10);
1093 |         totalScenePages = Math.ceil(currentScenes.length / scenesPerPage);
1094 |         displayScenes();
1095 |         updateScenePaginationButtons();
1096 |     });
1097 | 
1098 |     async function handleMatchButtonClick(scene) {
1099 |         const input = document.createElement('input');
1100 |         input.type = 'file';
1101 |         input.accept = '.mp4';
1102 |         input.onchange = async (event) => {
1103 |             const file = event.target.files[0];
1104 |             if (file) {
1105 |                 try {
1106 |                     const filePath = homeDirectory ? `${homeDirectory}/${file.webkitRelativePath || file.name}` : file.webkitRelativePath || file.name;
1107 |                     const response = await fetch('/match_scene', {
1108 |                         method: 'POST',
1109 |                         headers: {
1110 |                             'Content-Type': 'application/json'
1111 |                         },
1112 |                         body: JSON.stringify({ scene_id: scene.id, file_path: filePath })
1113 |                     });
1114 | 
1115 |                     if (!response.ok) {
1116 |                         const errorText = await response.text();
1117 |                         throw new Error(`Error ${response.status}: ${errorText}`);
1118 |                     }
1119 | 
1120 |                     const result = await response.json();
1121 | 
1122 |                     scene.status = 'Found';
1123 |                     scene.local_path = filePath;
1124 | 
1125 |                     Toastify({
1126 |                         text: result.message,
1127 |                         duration: 3000,
1128 |                         close: true,
1129 |                         gravity: "top",
1130 |                         position: "right",
1131 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
1132 |                     }).showToast();
1133 |                     displayScenes();
1134 |                     enableBulkUpdateButton();
1135 |                 } catch (error) {
1136 |                     console.error('Error matching scene:', error);
1137 |                     Toastify({
1138 |                         text: 'Error matching scene: ' + error.message,
1139 |                         duration: 3000,
1140 |                         close: true,
1141 |                         gravity: "top",
1142 |                         position: "right",
1143 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
1144 |                     }).showToast();
1145 |                 }
1146 |             }
1147 |         };
1148 |         input.click();
1149 |     }
1150 |     
1151 |     function updateSitePageInfo() {
1152 |         sitePageInfo.textContent = `Page ${currentPage} of ${totalPages}`;
1153 |     }
1154 | 
1155 |     function updatePaginationButtons() {
1156 |         firstPageButton.disabled = currentPage === 1;
1157 |         prevPageButton.disabled = currentPage === 1;
1158 |         nextPageButton.disabled = currentPage === totalPages;
1159 |         lastPageButton.disabled = currentPage === totalPages;
1160 |     
1161 |         firstPageButton.classList.toggle('disabled', currentPage === 1);
1162 |         prevPageButton.classList.toggle('disabled', currentPage === 1);
1163 |         nextPageButton.classList.toggle('disabled', currentPage === totalPages);
1164 |         lastPageButton.classList.toggle('disabled', currentPage === totalPages);
1165 |     
1166 |         updateSitePageInfo();  // Update the page info display
1167 |     }
1168 | 
1169 |     function updateScenePaginationButtons() {
1170 |         const scenesToDisplay = filteredScenes.length > 0 ? filteredScenes : currentScenes;
1171 |         const totalScenePages = Math.ceil(scenesToDisplay.length / scenesPerPage);
1172 | 
1173 |         sceneFirstPageButton.disabled = currentPage === 1;
1174 |         scenePrevPageButton.disabled = currentPage === 1;
1175 |         sceneNextPageButton.disabled = currentPage === totalScenePages;
1176 |         sceneLastPageButton.disabled = currentPage === totalScenePages;
1177 | 
1178 |         sceneFirstPageButton.classList.toggle('disabled', currentPage === 1);
1179 |         scenePrevPageButton.classList.toggle('disabled', currentPage === 1);
1180 |         sceneNextPageButton.classList.toggle('disabled', currentPage === totalScenePages);
1181 |         sceneLastPageButton.classList.toggle('disabled', currentPage === totalScenePages);
1182 |     }
1183 | 
1184 |     firstPageButton.addEventListener('click', () => {
1185 |         currentPage = 1;
1186 |         displayCollection(currentPage);
1187 |     });
1188 | 
1189 |     prevPageButton.addEventListener('click', () => {
1190 |         if (currentPage > 1) {
1191 |             currentPage--;
1192 |             displayCollection(currentPage);
1193 |         }
1194 |     });
1195 | 
1196 |     nextPageButton.addEventListener('click', () => {
1197 |         if (currentPage < totalPages) {
1198 |             currentPage++;
1199 |             displayCollection(currentPage);
1200 |         }
1201 |     });
1202 | 
1203 |     lastPageButton.addEventListener('click', () => {
1204 |         currentPage = totalPages;
1205 |         displayCollection(currentPage);
1206 |     });
1207 | 
1208 |     sceneFirstPageButton.addEventListener('click', () => {
1209 |         currentPage = 1;
1210 |         displayScenes();
1211 |     });
1212 | 
1213 |     scenePrevPageButton.addEventListener('click', () => {
1214 |         if (currentPage > 1) {
1215 |             currentPage--;
1216 |             displayScenes();
1217 |         }
1218 |     });
1219 | 
1220 |     sceneNextPageButton.addEventListener('click', () => {
1221 |         if (currentPage < totalScenePages) {
1222 |             currentPage++;
1223 |             displayScenes();
1224 |         }
1225 |     });
1226 | 
1227 |     sceneLastPageButton.addEventListener('click', () => {
1228 |         currentPage = totalScenePages;
1229 |         displayScenes();
1230 |     });
1231 | 
1232 |     backButton.addEventListener('click', () => {
1233 |         siteCollectionContainer.classList.remove('d-none');
1234 |         sceneCollectionContainer.classList.add('d-none');
1235 |     });
1236 | 
1237 |     searchInput.addEventListener('input', debounce(() => {
1238 |         const searchTerm = searchInput.value.toLowerCase();
1239 |         const filteredCollection = allSites.filter(item => item.site.name.toLowerCase().includes(searchTerm));
1240 |         displayCollection(1, filteredCollection);
1241 |     }, 300));
1242 | 
1243 |     sortAscButton.addEventListener('click', () => {
1244 |         sortDirection = 'asc';
1245 |         allSites.sort((a, b) => a.site.name.localeCompare(b.site.name));
1246 |         displayCollection(currentPage);
1247 |     });
1248 | 
1249 |     sortDescButton.addEventListener('click', () => {
1250 |         sortDirection = 'desc';
1251 |         allSites.sort((a, b) => b.site.name.localeCompare(a.site.name));
1252 |         displayCollection(currentPage);
1253 |     });
1254 | 
1255 |     fetchCollection();
1256 | 
1257 |     function debounce(func, wait) {
1258 |         let timeout;
1259 |         return function(...args) {
1260 |             const context = this;
1261 |             clearTimeout(timeout);
1262 |             timeout = setTimeout(() => func.apply(context, args), wait);
1263 |         };
1264 |     }
1265 | 
1266 |     async function findSceneUrl(sceneUuid) {
1267 |         console.log('Finding URL for scene UUID:', sceneUuid); // Logging the scene UUID
1268 |         try {
1269 |             const response = await fetch('/get_scene_details', {
1270 |                 method: 'POST',
1271 |                 headers: {
1272 |                     'Content-Type': 'application/json'
1273 |                 },
1274 |                 body: JSON.stringify({ scene_uuid: sceneUuid })
1275 |             });
1276 | 
1277 |             if (!response.ok) {
1278 |                 const errorText = await response.text();
1279 |                 throw new Error(`Error ${response.status}: ${errorText}`);
1280 |             }
1281 | 
1282 |             const result = await response.json();
1283 |             console.log('Result from /get_scene_details:', result); // Logging the result
1284 |             const sceneUrl = result.url;
1285 |             const sceneRow = document.querySelector(`tr[data-foreign-guid="${sceneUuid}"]`);
1286 |             if (sceneRow && sceneUrl) {
1287 |                 sceneRow.querySelector('td:last-child').innerHTML = `
1288 |                     <a href="${sceneUrl}" target="_blank">View Scene</a>
1289 |                     <img src="{{ url_for('static', filename='Jdownloader.png') }}" class="jdownloader-icon" data-url="${sceneUrl}" title="Copy to JDownloader" onclick="copyToClipboard('${sceneUrl}')">
1290 |                 `;
1291 |             }
1292 | 
1293 |             // Save the URL to the local database
1294 |             await saveSceneUrl(sceneUuid, sceneUrl);
1295 | 
1296 |             return true;
1297 |         } catch (error) {
1298 |             console.error('Error finding scene URL:', error);
1299 |             Toastify({
1300 |                 text: 'Error finding scene URL: ' + error.message,
1301 |                 duration: 3000,
1302 |                 close: true,
1303 |                 gravity: "top",
1304 |                 position: "right",
1305 |                 backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
1306 |             }).showToast();
1307 |             return false;
1308 |         }
1309 |     }
1310 | 
1311 |     async function saveSceneUrl(sceneUuid, url) {
1312 |         try {
1313 |             const response = await fetch('/save_scene_url', {
1314 |                 method: 'POST',
1315 |                 headers: {
1316 |                     'Content-Type': 'application/json'
1317 |                 },
1318 |                 body: JSON.stringify({ scene_uuid: sceneUuid, url: url })
1319 |             });
1320 | 
1321 |             if (!response.ok) {
1322 |                 const errorText = await response.text();
1323 |                 throw new Error(`Error ${response.status}: ${errorText}`);
1324 |             }
1325 | 
1326 |             const result = await response.json();
1327 |             console.log('Scene URL saved successfully:', result);
1328 |         } catch (error) {
1329 |             console.error('Error saving scene URL:', error);
1330 |         }
1331 |     }
1332 | 
1333 |     // Event listener to copy URL to clipboard
1334 |     document.addEventListener('click', function(e) {
1335 |         if (e.target && e.target.classList.contains('jdownloader-icon')) {
1336 |             const url = e.target.getAttribute('data-url');
1337 |             navigator.clipboard.writeText(url).then(() => {
1338 |                 Toastify({
1339 |                     text: 'URL copied to clipboard!',
1340 |                     duration: 3000,
1341 |                     close: true,
1342 |                     gravity: "top",
1343 |                     position: "right",
1344 |                     backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
1345 |                 }).showToast();
1346 |             }).catch(err => {
1347 |                 console.error('Error copying URL to clipboard:', err);
1348 |                 Toastify({
1349 |                     text: 'Error copying URL to clipboard: ' + err.message,
1350 |                     duration: 3000,
1351 |                     close: true,
1352 |                     gravity: "top",
1353 |                     position: "right",
1354 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
1355 |                 }).showToast();
1356 |             });
1357 |         }
1358 |     });
1359 | 
1360 |     fetchCollection();
1361 |     });
1362 | 
1363 | </script>
1364 | </body>
1365 | </html>
1366 | 


--------------------------------------------------------------------------------
/jizzarr/web/templates/config.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Configuration</title>
  7 |     <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}">
  8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.css">
  9 |     <link rel="stylesheet" href="{{ url_for('static', filename='config.css') }}">
 10 |     <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;700&display=swap" rel="stylesheet">
 11 | </head>
 12 | <body>
 13 |     <nav class="custom-navbar">
 14 |         <a href="{{ url_for('index') }}">
 15 |             <img src="{{ url_for('static', filename='favicon.ico') }}" alt="Favicon" class="favicon">
 16 |             Jizzarr Home
 17 |         </a>
 18 |         <a href="{{ url_for('collection') }}">My Collection</a>
 19 |         <a href="{{ url_for('config_page') }}">Settings</a>
 20 |         <a href="{{ url_for('logs') }}">Logs</a>
 21 |         <a href="{{ url_for('stats_page') }}">Stats</a>
 22 |     </nav>
 23 |     <div class="container">
 24 |         <h1>Configuration</h1>
 25 |         <div class="config-wrapper">
 26 |             <div class="config-container">
 27 |                 <form id="config-form">
 28 |                     <div class="form-group">
 29 |                         <label for="stashEndpoint" class="form-label">Stash Server Endpoint</label>
 30 |                         <input type="text" class="form-control-dark" id="stashEndpoint" name="stashEndpoint" placeholder="http://localhost:9999/graphql" value="{{ stash_endpoint }}">
 31 |                     </div>
 32 |                     <div class="form-group">
 33 |                         <label for="stashApiKey" class="form-label">Stash API Key</label>
 34 |                         <input type="password" class="form-control-dark" id="stashApiKey" name="stashApiKey" placeholder="Enter your Stash API Key" value="{{ stash_api_key }}">
 35 |                         <button type="button" class="btn-show" onclick="toggleVisibility('stashApiKey')">Show</button>
 36 |                     </div>
 37 |                     <div class="form-group">
 38 |                         <label for="tpdbApiKey" class="form-label">TPDB API Key</label>
 39 |                         <input type="password" class="form-control-dark" id="tpdbApiKey" name="tpdbApiKey" placeholder="Enter your TPDB API Key" value="{{ tpdb_api_key }}">
 40 |                         <button type="button" class="btn-show" onclick="toggleVisibility('tpdbApiKey')">Show</button>
 41 |                     </div>
 42 |                     <div class="form-group">
 43 |                         <label for="downloadFolder" class="form-label">Set Download Watch Folder</label>
 44 |                         <input type="text" class="form-control-dark" id="downloadFolder" name="downloadFolder" value="{{ download_folder }}">
 45 |                     </div>
 46 |                     <div class="form-group">
 47 |                         <label for="libraryDirectory" class="form-label">Add Library Directory</label>
 48 |                         <input type="text" class="form-control-dark" id="libraryDirectory" name="libraryDirectory" placeholder="Enter library directory path">
 49 |                         <button type="button" class="btn-primary-dark" id="setLibraryButton">Add Library Directory</button>
 50 |                     </div>
 51 |                     <button type="submit" class="btn-primary-dark">Save Configuration</button>
 52 |                 </form>
 53 |                 <button type="button" class="btn-primary-dark mt-3" id="scanLibrariesButton">Scan Libraries for Changes</button>
 54 |                 <div class="config-container mt-4 scrollable-container">
 55 |                     <ul id="mainLibraryList">
 56 |                         {% for library, sites in libraries_with_sites.items() %}
 57 |                         <div class="row">
 58 |                             <div class="col">
 59 |                                 <h2>{{ library.path }}</h2>
 60 |                                 <button class="btn-remove" onclick="removeLibrary('{{ library.id }}')">Remove</button>
 61 |                                 <ul>
 62 |                                     {% for site in sites %}
 63 |                                     <li><b>{{ site.name }}</b>: <span class="path">{{ site.home_directory }}</span></li>
 64 |                                     {% endfor %}
 65 |                                 </ul>
 66 |                             </div>
 67 |                         </div>
 68 |                         {% endfor %}
 69 |                     </ul>
 70 |                     <ul id="homeSiteList">
 71 |                         <!-- Populated dynamically by JS -->
 72 |                     </ul>
 73 |                 </div>
 74 |             </div>
 75 |         </div>
 76 |     </div>
 77 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.js"></script>
 78 |     <script>
 79 |         document.getElementById('config-form').addEventListener('submit', async function(event) {
 80 |             event.preventDefault();
 81 | 
 82 |             const stashEndpoint = document.getElementById('stashEndpoint').value;
 83 |             const stashApiKey = document.getElementById('stashApiKey').value;
 84 |             const tpdbApiKey = document.getElementById('tpdbApiKey').value;
 85 |             const downloadFolder = document.getElementById('downloadFolder').value;
 86 | 
 87 |             const configData = {
 88 |                 stashEndpoint,
 89 |                 stashApiKey,
 90 |                 tpdbApiKey,
 91 |                 downloadFolder
 92 |             };
 93 | 
 94 |             try {
 95 |                 const response = await fetch('/save_config', {
 96 |                     method: 'POST',
 97 |                     headers: {
 98 |                         'Content-Type': 'application/json'
 99 |                     },
100 |                     body: JSON.stringify(configData)
101 |                 });
102 | 
103 |                 if (response.ok) {
104 |                     Toastify({
105 |                         text: 'Configuration saved successfully',
106 |                         duration: 3000,
107 |                         close: true,
108 |                         gravity: "top",
109 |                         position: "right",
110 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
111 |                     }).showToast();
112 |                 } else {
113 |                     const result = await response.json();
114 |                     Toastify({
115 |                         text: `Failed to save configuration: ${result.error || 'Unknown error'}`,
116 |                         duration: 3000,
117 |                         close: true,
118 |                         gravity: "top",
119 |                         position: "right",
120 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
121 |                     }).showToast();
122 |                 }
123 |             } catch (error) {
124 |                 Toastify({
125 |                     text: `Failed to save configuration: ${error.message}`,
126 |                     duration: 3000,
127 |                     close: true,
128 |                     gravity: "top",
129 |                     position: "right",
130 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
131 |                 }).showToast();
132 |             }
133 |         });
134 | 
135 |         document.getElementById('setLibraryButton').addEventListener('click', async function() {
136 |             const libraryDirectory = document.getElementById('libraryDirectory').value;
137 | 
138 |             if (!libraryDirectory) {
139 |                 Toastify({
140 |                     text: 'Library directory is required',
141 |                     duration: 3000,
142 |                     close: true,
143 |                     gravity: "top",
144 |                     position: "right",
145 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
146 |                 }).showToast();
147 |                 return;
148 |             }
149 | 
150 |             try {
151 |                 const response = await fetch('/set_library_directory', {
152 |                     method: 'POST',
153 |                     headers: {
154 |                         'Content-Type': 'application/json'
155 |                     },
156 |                     body: JSON.stringify({ libraryDirectory })
157 |                 });
158 | 
159 |                 if (response.ok) {
160 |                     const result = await response.json();
161 |                     Toastify({
162 |                         text: result.message,
163 |                         duration: 3000,
164 |                         close: true,
165 |                         gravity: "top",
166 |                         position: "right",
167 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
168 |                     }).showToast();
169 | 
170 |                     // Add the new library directory to the main library list
171 |                     const mainLibraryList = document.getElementById('mainLibraryList');
172 |                     const newMainListItem = document.createElement('li');
173 |                     newMainListItem.innerHTML = `${libraryDirectory} <button class="btn-remove" onclick="removeLibrary('${result.directory_id}')">Remove</button>`;
174 |                     mainLibraryList.appendChild(newMainListItem);
175 | 
176 |                     // Add the matched home site directories to the home site list
177 |                     const homeSiteList = document.getElementById('homeSiteList');
178 |                     result.matches.forEach(match => {
179 |                         const newHomeListItem = document.createElement('li');
180 |                         newHomeListItem.textContent = `${match.site_name}: ${match.directory}`;
181 |                         homeSiteList.appendChild(newHomeListItem);
182 |                     });
183 | 
184 |                     // Sort the home site list alphabetically
185 |                     sortHomeSiteList();
186 |                 } else {
187 |                     const result = await response.json();
188 |                     Toastify({
189 |                         text: `Failed to add library directory: ${result.error || 'Unknown error'}`,
190 |                         duration: 3000,
191 |                         close: true,
192 |                         gravity: "top",
193 |                         position: "right",
194 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
195 |                     }).showToast();
196 |                 }
197 |             } catch (error) {
198 |                 Toastify({
199 |                     text: `Failed to add library directory: ${error.message}`,
200 |                     duration: 3000,
201 |                     close: true,
202 |                     gravity: "top",
203 |                     position: "right",
204 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
205 |                 }).showToast();
206 |             }
207 |         });
208 | 
209 |         document.getElementById('scanLibrariesButton').addEventListener('click', async function() {
210 |             try {
211 |                 const response = await fetch('/scan_libraries', {
212 |                     method: 'POST',
213 |                     headers: {
214 |                         'Content-Type': 'application/json'
215 |                     }
216 |                 });
217 | 
218 |                 if (response.ok) {
219 |                     const result = await response.json();
220 |                     Toastify({
221 |                         text: result.message,
222 |                         duration: 3000,
223 |                         close: true,
224 |                         gravity: "top",
225 |                         position: "right",
226 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
227 |                     }).showToast();
228 | 
229 |                     // Refresh the home site list
230 |                     const homeSiteList = document.getElementById('homeSiteList');
231 |                     homeSiteList.innerHTML = '';
232 |                     result.matches.forEach(match => {
233 |                         const newHomeListItem = document.createElement('li');
234 |                         newHomeListItem.textContent = `${match.site_name}: ${match.directory}`;
235 |                         homeSiteList.appendChild(newHomeListItem);
236 |                     });
237 | 
238 |                     // Sort the home site list alphabetically
239 |                     sortHomeSiteList();
240 |                 } else {
241 |                     const result = await response.json();
242 |                     Toastify({
243 |                         text: `Failed to scan libraries: ${result.error || 'Unknown error'}`,
244 |                         duration: 3000,
245 |                         close: true,
246 |                         gravity: "top",
247 |                         position: "right",
248 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
249 |                     }).showToast();
250 |                 }
251 |             } catch (error) {
252 |                 Toastify({
253 |                     text: `Failed to scan libraries: ${error.message}`,
254 |                     duration: 3000,
255 |                     close: true,
256 |                     gravity: "top",
257 |                     position: "right",
258 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
259 |                 }).showToast();
260 |             }
261 |         });
262 | 
263 |         async function removeLibrary(libraryId) {
264 |             try {
265 |                 const response = await fetch(`/remove_library/${libraryId}`, {
266 |                     method: 'DELETE'
267 |                 });
268 | 
269 |                 if (response.ok) {
270 |                     Toastify({
271 |                         text: 'Library removed successfully',
272 |                         duration: 3000,
273 |                         close: true,
274 |                         gravity: "top",
275 |                         position: "right",
276 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
277 |                     }).showToast();
278 | 
279 |                     // Remove the library from the main library list
280 |                     const removeButton = document.querySelector(`button[onclick="removeLibrary('${libraryId}')"]`);
281 |                     if (removeButton) {
282 |                         const libraryItem = removeButton.parentElement;
283 |                         if (libraryItem) {
284 |                             libraryItem.remove();
285 |                         }
286 |                     }
287 | 
288 |                     // Refresh the home site list
289 |                     const homeSiteList = document.getElementById('homeSiteList');
290 |                     homeSiteList.innerHTML = '';
291 |                     const responseSites = await fetch('/get_home_directories');
292 |                     if (responseSites.ok) {
293 |                         const sites = await responseSites.json();
294 |                         sites.forEach(site => {
295 |                             const newHomeListItem = document.createElement('li');
296 |                             newHomeListItem.textContent = `${site.name}: ${site.home_directory}`;
297 |                             homeSiteList.appendChild(newHomeListItem);
298 |                         });
299 |                     }
300 | 
301 |                     // Sort the home site list alphabetically
302 |                     sortHomeSiteList();
303 |                 } else {
304 |                     const result = await response.json();
305 |                     Toastify({
306 |                         text: `Failed to remove library: ${result.error || 'Unknown error'}`,
307 |                         duration: 3000,
308 |                         close: true,
309 |                         gravity: "top",
310 |                         position: "right",
311 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
312 |                     }).showToast();
313 |                 }
314 |             } catch (error) {
315 |                 Toastify({
316 |                     text: `Failed to remove library: ${error.message}`,
317 |                     duration: 3000,
318 |                     close: true,
319 |                     gravity: "top",
320 |                     position: "right",
321 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
322 |                 }).showToast();
323 |             }
324 |         }
325 | 
326 |         function sortHomeSiteList() {
327 |             const homeSiteList = document.getElementById('homeSiteList');
328 |             const items = Array.from(homeSiteList.querySelectorAll('li'));
329 |             items.sort((a, b) => a.textContent.localeCompare(b.textContent));
330 |             homeSiteList.innerHTML = '';
331 |             items.forEach(item => homeSiteList.appendChild(item));
332 |         }
333 | 
334 |         function toggleVisibility(id) {
335 |             const input = document.getElementById(id);
336 |             if (input.type === 'password') {
337 |                 input.type = 'text';
338 |             } else {
339 |                 input.type = 'password';
340 |             }
341 |         }
342 |     </script>
343 | </body>
344 | </html>
345 | 


--------------------------------------------------------------------------------
/jizzarr/web/templates/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Jizzarr Home</title>
  7 |     <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}">
  8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/css/bootstrap.min.css">
  9 |     <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
 10 |     <link rel="stylesheet" href="{{ url_for('static', filename='index.css') }}">
 11 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.css">
 12 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css">
 13 |     <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;700&display=swap" rel="stylesheet">
 14 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/fuse.js/6.4.6/fuse.min.js"></script>
 15 |     <style>
 16 |         .modal-body {
 17 |             max-height: 800px;
 18 |             overflow-y: auto;
 19 |         }
 20 |         .list-group-item p strong {
 21 |         color: #28a745;
 22 |         font-weight: bold;
 23 |         }
 24 |     </style>
 25 | </head>
 26 | <body class="bg-dark text-light">
 27 |     <nav class="custom-navbar">
 28 |         <a href="{{ url_for('index') }}">
 29 |             <img src="{{ url_for('static', filename='favicon.ico') }}" alt="Favicon" class="favicon">
 30 |             Jizzarr Home
 31 |         </a>
 32 |         <a href="{{ url_for('collection') }}">My Collection</a>
 33 |         <a href="{{ url_for('config_page') }}">Settings</a>
 34 |         <a href="{{ url_for('logs') }}">Logs</a>
 35 |         <a href="{{ url_for('stats_page') }}">Stats</a>
 36 |     </nav>
 37 |     <div class="container">
 38 |         <h1 class="text-center">Search Sites via <img src="{{ url_for('static', filename='tpdblogo.png') }}" alt="TPDB" class="tpdb-logo"></h1>
 39 |         <div class="input-group-centered search-container">
 40 |             <input type="text" class="form-control form-control-dark" id="search-input" placeholder="Enter site name">
 41 |             <button class="btn btn-primary-dark mt-2 w-100" id="search-button">Search</button>
 42 |             <button id="search-stash" data-state="start" class="btn btn-primary-dark mt-2 w-100">
 43 |                 <i class="fa fa-play"></i> Populate Sites from Stash
 44 |             </button>
 45 |             <button id="search-all-sites-stash" class="btn btn-primary-dark mt-2 w-100">
 46 |                 <i class="fa fa-sync"></i> Search All Sites for Matches
 47 |             </button>
 48 |         </div>
 49 |         <div id="search-results" class="row row-cols-1 row-cols-md-3 g-4"></div>
 50 |         <div id="site-details" class="mt-4"></div>
 51 |         <div id="loading-indicator" class="loading hidden"></div>
 52 |         <div id="scenes-grid" class="mt-4"></div>
 53 |         <div id="pagination" class="mt-4"></div>
 54 |     </div>
 55 | 
 56 |     <!-- Progress Bar -->
 57 |     <div id="progress-bar-container">
 58 |         <img id="stash-logo" src="{{ url_for('static', filename='stash.png') }}" alt="Stash Logo">
 59 |         <div id="progress-bar">
 60 |             <div id="progress-bar-inner">0%</div>
 61 |         </div>
 62 |     </div>
 63 | 
 64 |     <!-- Modal for displaying matched scenes -->
 65 |     <div class="modal fade" id="matchesModal" tabindex="-1" aria-labelledby="matchesModalLabel" aria-hidden="true">
 66 |         <div class="modal-dialog modal-lg">
 67 |             <div class="modal-content bg-dark text-light">
 68 |                 <div class="modal-header">
 69 |                     <h5 class="modal-title" id="matchesModalLabel">Matched Scenes Review</h5>
 70 |                     <button type="button" class="btn-close btn-close-white" data-bs-dismiss="modal" aria-label="Close"></button>
 71 |                 </div>
 72 |                 <div class="modal-body">
 73 |                     <div id="matches-list" class="list-group list-group-flush"></div>
 74 |                 </div>
 75 |                 <div class="modal-footer">
 76 |                     <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
 77 |                 </div>
 78 |             </div>
 79 |         </div>
 80 |     </div>
 81 | 
 82 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/js/bootstrap.bundle.min.js"></script>
 83 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.js"></script>
 84 |     <script src="{{ url_for('static', filename='script.js') }}"></script>
 85 |     <script>
 86 |         document.addEventListener('DOMContentLoaded', function() {
 87 |             const searchStashButton = document.getElementById('search-stash');
 88 |             const progressBarContainer = document.getElementById('progress-bar-container');
 89 |             const progressBarInner = document.getElementById('progress-bar-inner');
 90 |             const searchAllSitesButton = document.getElementById('search-all-sites-stash');
 91 |             const matchesModal = new bootstrap.Modal(document.getElementById('matchesModal'));
 92 |             const matchesList = document.getElementById('matches-list');
 93 | 
 94 |             searchStashButton.addEventListener('click', async function() {
 95 |                 const currentState = searchStashButton.getAttribute('data-state');
 96 |                 if (currentState === 'start') {
 97 |                     stopPopulateSites = false;
 98 |                     searchStashButton.setAttribute('data-state', 'stop');
 99 |                     searchStashButton.innerHTML = '<i class="fa fa-stop"></i> Stop';
100 |                     searchStashButton.classList.remove('btn-primary-dark');
101 |                     searchStashButton.classList.add('btn-danger');
102 |                     await populateSitesFromStash();
103 |                 } else {
104 |                     stopPopulateSites = true;
105 |                     searchStashButton.setAttribute('data-state', 'start');
106 |                     searchStashButton.innerHTML = '<i class="fa fa-play"></i> Populate Sites from Stash';
107 |                     searchStashButton.classList.remove('btn-danger');
108 |                     searchStashButton.classList.add('btn-primary-dark');
109 |                     await stopPopulateSitesProcess();
110 |                 }
111 |             });
112 | 
113 |             async function populateSitesFromStash() {
114 |                 setProgressBarVisibility(true);
115 | 
116 |                 try {
117 |                     const response = await fetch('/populate_from_stash', {
118 |                         method: 'POST',
119 |                         headers: {
120 |                             'Content-Type': 'application/json'
121 |                         }
122 |                     });
123 | 
124 |                     if (!response.ok) {
125 |                         throw new Error(`Error ${response.status}: ${await response.text()}`);
126 |                     }
127 | 
128 |                     const result = await response.json();
129 | 
130 |                     // Reset progress bar
131 |                     updateProgressBar(0);
132 |                     setProgressBarVisibility(false);
133 |                     localStorage.removeItem('stashProgress');
134 |                 } catch (error) {
135 |                     console.error('Error fetching from Stash:', error);
136 |                     Toastify({
137 |                         text: `Error fetching from Stash: ${error.message}`,
138 |                         duration: 3000,
139 |                         close: true,
140 |                         gravity: "top",
141 |                         position: "right",
142 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
143 |                     }).showToast();
144 |                 } finally {
145 |                     // Reset button state when the process is complete or stopped
146 |                     searchStashButton.setAttribute('data-state', 'start');
147 |                     searchStashButton.innerHTML = '<i class="fa fa-play"></i> Populate Sites from Stash';
148 |                     searchStashButton.classList.remove('btn-danger');
149 |                     searchStashButton.classList.add('btn-primary-dark');
150 |                 }
151 |             }
152 | 
153 |             searchAllSitesButton.addEventListener('click', async function() {
154 |                 try {
155 |                     const response = await fetch('/search_stash_for_all_sites', {
156 |                         method: 'POST',
157 |                         headers: {
158 |                             'Content-Type': 'application/json'
159 |                         }
160 |                     });
161 | 
162 |                     if (!response.ok) {
163 |                         throw new Error(`Error ${response.status}: ${await response.text()}`);
164 |                     }
165 | 
166 |                     const matches = await response.json();
167 |                     console.log('All site matches:', matches);
168 | 
169 |                     // Populate the modal with match details
170 |                     matchesList.innerHTML = ''; // Clear previous matches
171 |                     if (matches.length > 0) {
172 |                         matches.forEach(match => {
173 |                             const matchItem = document.createElement('a');
174 |                             matchItem.classList.add('list-group-item', 'list-group-item-action', 'bg-dark', 'text-light');
175 |                             matchItem.innerHTML = `
176 |                                 <h5>${match.site_name}: ${match.scene_title}</h5>
177 |                                 <p><strong>Matched File Path:</strong> ${match.matched_file_path}</p>
178 |                             `;
179 |                             matchesList.appendChild(matchItem);
180 |                         });
181 |                     } else {
182 |                         matchesList.innerHTML = '<p class="text-center">No matches found.</p>';
183 |                     }
184 | 
185 |                     // Show the modal
186 |                     matchesModal.show();
187 | 
188 |                     // Display success message or process matches as needed
189 |                     Toastify({
190 |                         text: 'Stash search completed for all sites',
191 |                         duration: 3000,
192 |                         close: true,
193 |                         gravity: "top",
194 |                         position: "right",
195 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
196 |                     }).showToast();
197 |                 } catch (error) {
198 |                     console.error('Error searching stash for all sites:', error);
199 |                     Toastify({
200 |                         text: 'Error searching stash for all sites: ' + error.message,
201 |                         duration: 3000,
202 |                         close: true,
203 |                         gravity: "top",
204 |                         position: "right",
205 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
206 |                     }).showToast();
207 |                 }
208 |             });
209 | 
210 |             async function stopPopulateSitesProcess() {
211 |                 try {
212 |                     const response = await fetch('/stop_populate_sites', { method: 'POST' });
213 |                     if (!response.ok) {
214 |                         throw new Error(`Error stopping the process: ${response.statusText}`);
215 |                     }
216 |                     const result = await response.json();
217 |                     Toastify({
218 |                         text: result.message,
219 |                         duration: 3000,
220 |                         close: true,
221 |                         gravity: "top",
222 |                         position: "right",
223 |                         backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
224 |                     }).showToast();
225 |                 } catch (error) {
226 |                     console.error('Error stopping the process:', error);
227 |                     Toastify({
228 |                         text: 'Error stopping the process: ' + error.message,
229 |                         duration: 3000,
230 |                         close: true,
231 |                         gravity: "top",
232 |                         position: "right",
233 |                         backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
234 |                     }).showToast();
235 |                 } finally {
236 |                     // Ensure the button is reset to play state even if there's an error
237 |                     searchStashButton.setAttribute('data-state', 'start');
238 |                     searchStashButton.innerHTML = '<i class="fa fa-play"></i> Populate Sites from Stash';
239 |                     searchStashButton.classList.remove('btn-danger');
240 |                     searchStashButton.classList.add('btn-primary-dark');
241 |                 }
242 |             }
243 | 
244 |             function updateProgressBar(percentage) {
245 |                 progressBarInner.style.width = percentage + '%';
246 |                 progressBarInner.innerText = percentage + '%';
247 |             }
248 | 
249 |             function setProgressBarVisibility(visible) {
250 |                 progressBarContainer.style.display = visible ? 'flex' : 'none';
251 |             }
252 | 
253 |             // Initialize progress bar visibility based on localStorage
254 |             const storedProgress = localStorage.getItem('stashProgress');
255 |             if (storedProgress) {
256 |                 updateProgressBar(parseInt(storedProgress, 10));
257 |                 setProgressBarVisibility(true);
258 |             } else {
259 |                 setProgressBarVisibility(false);
260 |             }
261 | 
262 |             // Function to handle progress updates from the server
263 |             async function handleProgressUpdates() {
264 |                 const eventSource = new EventSource('/progress');
265 |                 eventSource.onmessage = function(event) {
266 |                     const data = JSON.parse(event.data);
267 |                     const progress = data.total > 0 ? Math.round((data.completed / data.total) * 100) : 0;
268 |                     updateProgressBar(progress);
269 |                     localStorage.setItem('stashProgress', progress);
270 |                     if (progress >= 100) {
271 |                         eventSource.close();
272 |                         setProgressBarVisibility(false); // Hide the progress bar
273 |                         localStorage.removeItem('stashProgress');
274 |                     }
275 |                 };
276 |                 eventSource.onerror = function() {
277 |                     eventSource.close();
278 |                 };
279 |             }
280 | 
281 |             handleProgressUpdates();
282 |         });
283 |     </script>
284 | </body>
285 | </html>
286 | 


--------------------------------------------------------------------------------
/jizzarr/web/templates/logs.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Logs</title>
  7 |     <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}">
  8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/css/bootstrap.min.css">
  9 |     <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
 10 |     <link rel="stylesheet" href="{{ url_for('static', filename='logs.css') }}">
 11 |     <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;700&display=swap" rel="stylesheet">
 12 |     <script src="https://unpkg.com/js-logger/src/logger.min.js"></script>
 13 |     <style>
 14 |         .highlight {
 15 |             background-color: yellow;
 16 |         }
 17 |     </style>
 18 | </head>
 19 | <body>
 20 |     <nav class="custom-navbar">
 21 |         <a href="{{ url_for('index') }}">
 22 |             <img src="{{ url_for('static', filename='favicon.ico') }}" alt="Favicon" class="favicon">
 23 |             Jizzarr Home
 24 |         </a>
 25 |         <a href="{{ url_for('collection') }}">My Collection</a>
 26 |         <a href="{{ url_for('config_page') }}">Settings</a>
 27 |         <a href="{{ url_for('logs') }}">Logs</a>
 28 |         <a href="{{ url_for('stats_page') }}">Stats</a>
 29 |     </nav>
 30 |     <div class="container">
 31 |         <h1 class="text-center">Logs</h1>
 32 |         <div class="d-flex mb-4">
 33 |             <button class="btn btn-primary-dark me-2" onclick="downloadLogs()">Download Logs</button>
 34 |             <button class="btn btn-danger-dark me-2" onclick="clearLogs()">Clear Logs</button>
 35 |             <input type="text" class="form-control" id="search-input" placeholder="Search logs...">
 36 |         </div>
 37 |         <table class="table table-dark table-striped">
 38 |             <thead>
 39 |                 <tr>
 40 |                     <th>Timestamp</th>
 41 |                     <th>Level</th>
 42 |                     <th>Message</th>
 43 |                 </tr>
 44 |             </thead>
 45 |             <tbody id="log-entries">
 46 |                 <!-- Log entries will be loaded here -->
 47 |             </tbody>
 48 |         </table>
 49 |         <div class="pagination-controls d-flex justify-content-center mt-4">
 50 |             <button id="first-page" class="btn btn-outline-secondary me-2">First</button>
 51 |             <button id="prev-page" class="btn btn-outline-secondary me-2">Prev</button>
 52 |             <button id="next-page" class="btn btn-outline-secondary me-2">Next</button>
 53 |             <button id="last-page" class="btn btn-outline-secondary">Last</button>
 54 |         </div>
 55 |     </div>
 56 |     <script>
 57 |         const logEntriesContainer = document.getElementById('log-entries');
 58 |         const searchInput = document.getElementById('search-input');
 59 |         const firstPageButton = document.getElementById('first-page');
 60 |         const prevPageButton = document.getElementById('prev-page');
 61 |         const nextPageButton = document.getElementById('next-page');
 62 |         const lastPageButton = document.getElementById('last-page');
 63 | 
 64 |         let currentPage = 1;
 65 |         let totalPages = 1;
 66 |         const logsPerPage = 20;
 67 | 
 68 |         function downloadLogs() {
 69 |             window.location.href = '/download_logs';
 70 |         }
 71 | 
 72 |         function clearLogs() {
 73 |             if (confirm('Are you sure you want to clear all logs?')) {
 74 |                 fetch('/clear_logs', { method: 'POST' })
 75 |                     .then(response => response.json())
 76 |                     .then(data => {
 77 |                         if (data.success) {
 78 |                             fetchLogs();
 79 |                             Toastify({
 80 |                                 text: 'Logs cleared successfully',
 81 |                                 duration: 3000,
 82 |                                 close: true,
 83 |                                 gravity: "top",
 84 |                                 position: "right",
 85 |                                 backgroundColor: "linear-gradient(to right, #00b09b, #96c93d)"
 86 |                             }).showToast();
 87 |                         } else {
 88 |                             throw new Error(data.error);
 89 |                         }
 90 |                     })
 91 |                     .catch(error => {
 92 |                         console.error('Error clearing logs:', error);
 93 |                         Toastify({
 94 |                             text: 'Error clearing logs: ' + error.message,
 95 |                             duration: 3000,
 96 |                             close: true,
 97 |                             gravity: "top",
 98 |                             position: "right",
 99 |                             backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
100 |                         }).showToast();
101 |                     });
102 |             }
103 |         }
104 | 
105 |         function highlight(text, search) {
106 |             if (!search) return text;
107 |             const pattern = new RegExp(`(${search})`, 'gi');
108 |             return text.replace(pattern, '<span class="highlight">$1</span>');
109 |         }
110 | 
111 |         async function fetchLogs(page = 1, search = '') {
112 |             try {
113 |                 const response = await fetch(`/logs_data?page=${page}&per_page=${logsPerPage}&search=${search}`);
114 |                 const data = await response.json();
115 |                 totalPages = data.total_pages;
116 |                 currentPage = data.current_page;
117 |                 displayLogs(data.logs, search);
118 |                 updatePaginationButtons();
119 |             } catch (error) {
120 |                 console.error('Error fetching logs:', error);
121 |             }
122 |         }
123 | 
124 |         function displayLogs(logs, search) {
125 |             logEntriesContainer.innerHTML = '';
126 |             logs.forEach(log => {
127 |                 const row = document.createElement('tr');
128 |                 row.innerHTML = `
129 |                     <td>${log.timestamp}</td>
130 |                     <td class="log-level">${highlight(log.level, search)}</td>
131 |                     <td class="log-message">${highlight(log.message, search)}</td>
132 |                 `;
133 |                 logEntriesContainer.appendChild(row);
134 |             });
135 |         }
136 | 
137 |         function updatePaginationButtons() {
138 |             firstPageButton.disabled = currentPage === 1;
139 |             prevPageButton.disabled = currentPage === 1;
140 |             nextPageButton.disabled = currentPage === totalPages;
141 |             lastPageButton.disabled = currentPage === totalPages;
142 |         }
143 | 
144 |         firstPageButton.addEventListener('click', () => {
145 |             currentPage = 1;
146 |             fetchLogs(currentPage, searchInput.value);
147 |         });
148 | 
149 |         prevPageButton.addEventListener('click', () => {
150 |             if (currentPage > 1) {
151 |                 currentPage--;
152 |                 fetchLogs(currentPage, searchInput.value);
153 |             }
154 |         });
155 | 
156 |         nextPageButton.addEventListener('click', () => {
157 |             if (currentPage < totalPages) {
158 |                 currentPage++;
159 |                 fetchLogs(currentPage, searchInput.value);
160 |             }
161 |         });
162 | 
163 |         lastPageButton.addEventListener('click', () => {
164 |             currentPage = totalPages;
165 |             fetchLogs(currentPage, searchInput.value);
166 |         });
167 | 
168 |         searchInput.addEventListener('input', debounce(() => {
169 |             fetchLogs(1, searchInput.value);
170 |         }, 300));
171 | 
172 |         function debounce(func, wait) {
173 |             let timeout;
174 |             return function(...args) {
175 |                 const context = this;
176 |                 clearTimeout(timeout);
177 |                 timeout = setTimeout(() => func.apply(context, args), wait);
178 |             };
179 |         }
180 | 
181 |         fetchLogs();
182 |     </script>
183 | </body>
184 | </html>
185 | 


--------------------------------------------------------------------------------
/jizzarr/web/templates/stats.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>Jizzarr Collection Stats</title>
  7 |     <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}">
  8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/css/bootstrap.min.css">
  9 |     <link rel="stylesheet" href="{{ url_for('static', filename='styles.css') }}">
 10 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.css">
 11 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css">
 12 |     <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@400;500;700&display=swap" rel="stylesheet">
 13 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/fuse.js/6.4.6/fuse.min.js"></script>
 14 |     <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 15 |     <style>
 16 |         body {
 17 |             display: flex;
 18 |             flex-direction: column;
 19 |             min-height: 100vh;
 20 |             font-family: 'Montserrat', Arial, sans-serif;
 21 |         }
 22 |         .container {
 23 |             flex: 1;
 24 |             display: flex;
 25 |             justify-content: center;
 26 |             align-items: center !important;
 27 |             flex-direction: column;
 28 |             text-align: center !important;
 29 |             margin-top: 50px;
 30 |         }
 31 |         #infographic {
 32 |             width: 100%; 
 33 |             max-width: 1400px;
 34 |             margin: 20px auto;
 35 |         }
 36 |         #collectionChart {
 37 |             width: 100%;
 38 |             height: 500px;
 39 |         }
 40 |         .legend-container {
 41 |             display: flex;
 42 |             flex-direction: column; /* Stack items vertically */
 43 |             align-items: center; /* Center items horizontally */
 44 |             margin-bottom: 20px;
 45 |         }
 46 |         .legend-item {
 47 |             margin: 0 10px;
 48 |         }
 49 |         .custom-navbar {
 50 |             width: 100%;
 51 |             position: fixed;
 52 |             top: 0;
 53 |             z-index: 1000;
 54 |             background-color: rgba(0, 0, 0, 0.5);
 55 |             padding: 10px 0;
 56 |             display: flex;
 57 |             justify-content: center;
 58 |             align-items: center;
 59 |             backdrop-filter: blur(6px);
 60 |         }
 61 |         .custom-navbar a {
 62 |             color: #ffffff;
 63 |             text-decoration: none;
 64 |             margin: 0 10px;
 65 |             padding: 5px 10px;
 66 |         }
 67 |         .custom-navbar a:hover {
 68 |             background-color: #495057;
 69 |             border-radius: 4px;
 70 |         }
 71 |         .column {
 72 |             margin-bottom: 20px;
 73 |         }
 74 | 		.legend-item {
 75 | 		margin: 0 10px;
 76 | 		font-size: 1.2rem;
 77 | 		}		
 78 |     </style>
 79 | </head>
 80 | <body>
 81 |     <nav class="custom-navbar">
 82 |         <a href="{{ url_for('index') }}">
 83 |             <img src="{{ url_for('static', filename='favicon.ico') }}" alt="Favicon" class="favicon">
 84 |             Jizzarr Home
 85 |         </a>
 86 |         <a href="{{ url_for('collection') }}">My Collection</a>
 87 |         <a href="{{ url_for('config_page') }}">Settings</a>
 88 |         <a href="{{ url_for('logs') }}">Logs</a>
 89 |         <a href="{{ url_for('stats_page') }}">Stats</a>
 90 |     </nav>
 91 |     <div class="container">
 92 |         <div id="infographic" class="infographic">
 93 |             <h4 class="text-center">Collection Stats</h4>
 94 |             <div class="row">
 95 |                 <div class="col-md-6">
 96 |                     <div class="legend-container">
 97 |                         <div class="legend-item">
 98 |                             <div class="legend-color legend-collected"></div>
 99 |                             <span>Missing Scenes: <span id="total-scenes">0</span></span>
100 |                         </div>
101 |                         <div class="legend-item">
102 |                             <div class="legend-color legend-missing"></div>
103 |                             <span>Collected Scenes: <span id="collected-scenes">0</span></span>
104 |                         </div>
105 |                         <div class="legend-item">
106 |                             <div class="legend-color legend-collected-duration"></div>
107 |                             <span>Collected Duration: <span id="collected-duration">0</span></span>
108 |                         </div>
109 |                         <div class="legend-item">
110 |                             <div class="legend-color legend-missing-duration"></div>
111 |                             <span>Missing Duration: <span id="missing-duration">0</span></span>
112 |                         </div>
113 |                         <div class="legend-item">
114 |                             <div class="legend-color legend-rating"></div>
115 |                             <span>Average Rating: <span id="avg-rating">0</span></span>
116 |                         </div>
117 |                     </div>
118 |                 </div>
119 |                 <div class="col-md-6">
120 |                     <canvas id="collectionChart"></canvas>
121 |                 </div>
122 |             </div>
123 |             <h4><div id="encouragement-message" class="mt-4"></div></h4>
124 |         </div>
125 |     </div>
126 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.0.1/js/bootstrap.bundle.min.js"></script>
127 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/toastify-js/1.6.1/toastify.min.js"></script>
128 |     <script src="{{ url_for('static', filename='script.js') }}"></script>
129 |     <script>
130 |         function convertMinutesToDetailedDuration(minutes) {
131 |             const years = Math.floor(minutes / 525600);
132 |             minutes %= 525600;
133 |             const days = Math.floor(minutes / 1440);
134 |             minutes %= 1440;
135 |             const hours = Math.floor(minutes / 60);
136 |             const mins = minutes % 60;
137 | 
138 |             return `${years} Year(s) ${days} Days ${hours} Hours and ${mins} Minutes`;
139 |         }
140 | 
141 |         async function fetchCollectionStats() {
142 |             const response = await fetch('/collection_stats');
143 |             if (!response.ok) {
144 |                 throw new Error(`Error ${response.status}: ${await response.text()}`);
145 |             }
146 |             return response.json();
147 |         }
148 | 
149 |         async function drawChart() {
150 |             try {
151 |                 const stats = await fetchCollectionStats();
152 |                 
153 |                 document.getElementById('total-scenes').textContent = stats.total;
154 |                 document.getElementById('collected-scenes').textContent = stats.collected;
155 |                 document.getElementById('collected-duration').textContent = convertMinutesToDetailedDuration(stats.collected_duration);
156 |                 document.getElementById('missing-duration').textContent = convertMinutesToDetailedDuration(stats.missing_duration);
157 |                 document.getElementById('avg-rating').textContent = stats.avg_rating;
158 | 
159 |                 const ctx = document.getElementById('collectionChart').getContext('2d');
160 |                 const chart = new Chart(ctx, {
161 |                     type: 'doughnut',
162 |                     data: {
163 |                         labels: ['Collected', 'Missing'],
164 |                         datasets: [{
165 |                             label: 'Collection Stats',
166 |                             data: [stats.collected, stats.total - stats.collected],
167 |                             backgroundColor: ['#00b09b', '#ff5f6d'],
168 |                             borderColor: ['#00b09b', '#ff5f6d'],
169 |                             borderWidth: 1
170 |                         }]
171 |                     },
172 |                     options: {
173 |                         responsive: true,
174 |                         plugins: {
175 |                             legend: {
176 |                                 position: 'top',
177 |                             },
178 |                             title: {
179 |                                 display: true,
180 |                                 text: 'Collection Stats'
181 |                             }
182 |                         }
183 |                     }
184 |                 });
185 | 
186 |                 const differenceDuration = stats.missing_duration - stats.collected_duration;
187 |                 document.getElementById('encouragement-message').textContent = `You only need to collect a total of ${convertMinutesToDetailedDuration(differenceDuration)} worth of viewing time!`;
188 | 
189 |             } catch (error) {
190 |                 console.error('Error fetching collection stats:', error);
191 |                 Toastify({
192 |                     text: 'Error fetching collection stats: ' + error.message,
193 |                     duration: 3000,
194 |                     close: true,
195 |                     gravity: "top",
196 |                     position: "right",
197 |                     backgroundColor: "linear-gradient(to right, #ff5f6d, #ffc371)"
198 |                 }).showToast();
199 |             }
200 |         }
201 | 
202 |         document.addEventListener('DOMContentLoaded', drawChart);
203 |     </script>
204 | </body>
205 | </html>
206 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
 1 | [tool.poetry]
 2 | name = "jizzarr"
 3 | version = "0.17"
 4 | description = "A collection tracker that integrates with TPDB and Stash."
 5 | readme = "README.md"
 6 | authors = ["Serechops"]
 7 | include = ["**/static/**/*", "**/templates/**/*", "**/instance/**/*"]
 8 | 
 9 | [tool.poetry.dependencies]
10 | python = ">=3.9,<3.13"
11 | Flask = "^3.0.0"
12 | Flask-Cors = "^3.0.10"
13 | Flask-SQLAlchemy = "^3.1.1"
14 | mutagen = "^1.45.1"
15 | requests = "^2.26.0"
16 | pystray = "^0.19"
17 | Pillow = "^10.4.0"
18 | moviepy = "^1.0.3"
19 | watchdog = "^5.0"
20 | fuzzywuzzy = { extras = ["speedup"], version = "^0.18.0" }
21 | aiohttp = "^3.10"
22 | asyncio = "^3.4.3"
23 | ffmpeg-python = "^0.2"
24 | 
25 | [tool.poetry.group.dev.dependencies]
26 | ruff = "^0.5"
27 | 
28 | [tool.ruff]
29 | exclude = [".git", "__pycache__", "build", "dist", "node_modules"]
30 | line-length = 320
31 | indent-width = 4
32 | target-version = "py39"
33 | 
34 | [tool.ruff.format]
35 | quote-style = "single"
36 | indent-style = "space"
37 | line-ending = "auto"
38 | 
39 | [tool.ruff.lint]
40 | select = ["E", "F"]
41 | ignore = ["E501", "E722"]
42 | 
43 | [tool.poetry.build]
44 | generate-setup-file = true
45 | 
46 | [tool.poetry.scripts]
47 | jizzarr = "jizzarr.app:main"
48 | 
49 | [build-system]
50 | requires = ["poetry-core"]
51 | build-backend = "poetry.core.masonry.api"
52 | 


--------------------------------------------------------------------------------