quasarr 0.1.6__py3-none-any.whl → 1.23.0__py3-none-any.whl

quasarr/storage/setup.py

@@ -4,15 +4,21 @@
 
 import os
 import sys
-from urllib import parse
 
+import requests
 from bottle import Bottle, request
 
 import quasarr
-from quasarr.downloads.sources import nx
-from quasarr.storage.config import Config
+import quasarr.providers.html_images as images
+import quasarr.providers.sessions.al
+import quasarr.providers.sessions.dd
+import quasarr.providers.sessions.dl
+import quasarr.providers.sessions.nx
 from quasarr.providers.html_templates import render_button, render_form, render_success, render_fail
+from quasarr.providers.log import info
+from quasarr.providers.shared_state import extract_valid_hostname
 from quasarr.providers.web_server import Server
+from quasarr.storage.config import Config
 
 
 def path_config(shared_state):
@@ -24,7 +30,7 @@ def path_config(shared_state):
     def config_form():
         config_form_html = f'''
             <form action="/api/config" method="post">
-                <label for="config_path">Path</label><br>
+                <label for="config_path">Path</label>
                 <input type="text" id="config_path" name="config_path" placeholder="{current_path}"><br>
                 {render_button("Save", "primary", {"type": "submit"})}
             </form>
@@ -57,129 +63,285 @@ def path_config(shared_state):
         return render_success(f'Config path set to: "{config_path}"',
                               5)
 
-    print(f'Starting web server for config at: "{shared_state.values['internal_address']}".')
-    print("Please set desired config path there!")
+    info(f'Starting web server for config at: "{shared_state.values['internal_address']}".')
+    info("Please set desired config path there!")
     return Server(app, listen='0.0.0.0', port=shared_state.values['port']).serve_temporarily()
 
 
+def hostname_form_html(shared_state, message):
+    hostname_fields = '''
+    <label for="{id}" style="display:inline-flex; align-items:center; gap:4px;">{label}{img_html}</label>
+    <input type="text" id="{id}" name="{id}" placeholder="example.com" autocorrect="off" autocomplete="off" value="{value}"><br>
+    '''
+
+    field_html = []
+    hostnames = Config('Hostnames')  # Load once outside the loop
+    for label in shared_state.values["sites"]:
+        field_id = label.lower()
+        img_html = ''
+        try:
+            img_data = getattr(images, field_id)
+            if img_data:
+                img_html = f' <img src="{img_data}" width="16" height="16" style="filter: blur(2px);" alt="{label} icon">'
+        except AttributeError:
+            pass
+
+        # Get the current value (if any and non-empty)
+        current_value = hostnames.get(field_id)
+        if not current_value:
+            current_value = ''  # Ensure it's empty if None or ""
+
+        field_html.append(hostname_fields.format(
+            id=field_id,
+            label=label,
+            img_html=img_html,
+            value=current_value
+        ))
+
+    hostname_form_content = "".join(field_html)
+    button_html = render_button("Save", "primary", {"type": "submit"})
+
+    template = """
+<div id="message" style="margin-bottom:0.5em;">{message}</div>
+<div id="error-msg" style="color:red; margin-bottom:1em;"></div>
+
+<form action="/api/hostnames" method="post" onsubmit="return validateHostnames(this)">
+    {hostname_form_content}
+    {button}
+</form>
+
+<script>
+  function validateHostnames(form) {{
+    var errorDiv = document.getElementById('error-msg');
+    errorDiv.textContent = '';
+
+    var inputs = form.querySelectorAll('input[type="text"]');
+    for (var i = 0; i < inputs.length; i++) {{
+      if (inputs[i].value.trim() !== '') {{
+        return true;
+      }}
+    }}
+
+    errorDiv.textContent = 'Please fill in at least one hostname!';
+    inputs[0].focus();
+    return false;
+  }}
+</script>
+"""
+    return template.format(
+        message=message,
+        hostname_form_content=hostname_form_content,
+        button=button_html
+    )
+
+
+def save_hostnames(shared_state, timeout=5, first_run=True):
+    hostnames = Config('Hostnames')
+
+    # Collect submitted hostnames, validate, and track errors
+    valid_domains = {}
+    errors = {}
+
+    for site_key in shared_state.values['sites']:
+        shorthand = site_key.lower()
+        raw_value = request.forms.get(shorthand)
+        # treat missing or empty string as intentional clear, no validation
+        if raw_value is None or raw_value.strip() == '':
+            continue
+
+        # non-empty submission: must validate
+        result = extract_valid_hostname(raw_value, shorthand)
+        domain = result.get('domain')
+        message = result.get('message', 'Error checking the hostname you provided!')
+        if domain:
+            valid_domains[site_key] = domain
+        else:
+            errors[site_key] = message
+
+    # Filter out any accidental empty domains and require at least one valid hostname overall
+    valid_domains = {k: d for k, d in valid_domains.items() if d}
+    if not valid_domains:
+        # report last or generic message
+        fail_msg = next(iter(errors.values()), 'No valid hostname provided!')
+        return render_fail(fail_msg)
+
+    # Save: valid ones, explicit empty for those omitted cleanly, leave untouched if error
+    changed_sites = []
+    for site_key in shared_state.values['sites']:
+        shorthand = site_key.lower()
+        raw_value = request.forms.get(shorthand)
+        # determine if change applies
+        if site_key in valid_domains:
+            new_val = valid_domains[site_key]
+            old_val = hostnames.get(shorthand) or ''
+            if old_val != new_val:
+                hostnames.save(shorthand, new_val)
+                changed_sites.append(shorthand)
+        elif raw_value is None:
+            # no submission: leave untouched
+            continue
+        elif raw_value.strip() == '':
+            old_val = hostnames.get(shorthand) or ''
+            if old_val != '':
+                hostnames.save(shorthand, '')
+
+    quasarr.providers.web_server.temp_server_success = True
+
+    # Build success message, include any per-site errors
+    success_msg = 'At least one valid hostname set!'
+    if errors:
+        optional_text = "<br>".join(f"{site}: {msg}" for site, msg in errors.items()) + "<br>"
+    else:
+        optional_text = "All provided hostnames are valid.<br>"
+
+    if not first_run:
+        # Append restart notice for specific sites that actually changed
+        for site in changed_sites:
+            if site.lower() in {'al', 'dd', 'dl', 'nx'}:
+                optional_text += f"{site.upper()}: You must restart Quasarr and follow additional steps to start using this site.<br>"
+
+    return render_success(success_msg, timeout, optional_text=optional_text)
+
+
 def hostnames_config(shared_state):
     app = Bottle()
 
     @app.get('/')
     def hostname_form():
-        hostname_fields = '''
-        <label for="{id}">{label}</label><br>
-        <input type="text" id="{id}" name="{id}" placeholder="example.com" autocorrect="off" autocomplete="off"><br>
-        '''
-
-        hostname_form_content = "".join(
-            [hostname_fields.format(id=label.lower(), label=label) for label in shared_state.values["sites"]])
-
-        hostname_form_html = f'''
-        <form action="/api/hostnames" method="post">
-            {hostname_form_content}
-            {render_button("Save", "primary", {"type": "submit"})}
-        </form>
-        '''
-
-        return render_form("Set at least one valid hostname", hostname_form_html)
+        message = """<p>
+          If you're having trouble setting this up, take a closer look at 
+          <a href="https://github.com/rix1337/Quasarr?tab=readme-ov-file#instructions" target="_blank" rel="noopener noreferrer">
+            step one of these instructions.
+          </a>
+        </p>"""
+        return render_form("Set at least one valid hostname", hostname_form_html(shared_state, message))
 
     @app.post("/api/hostnames")
     def set_hostnames():
-        def extract_domain(url, shorthand):
-            # Check if both characters from the shorthand appear in the url
-            try:
-                if '://' not in url:
-                    url = 'http://' + url
-                result = parse.urlparse(url)
-                domain = result.netloc
-
-                # Check if both characters in the shorthand are in the domain
-                if all(char in domain for char in shorthand):
-                    print(f"{domain} matches both characters from {shorthand}. Continuing...")
-                    return domain
-                else:
-                    print(f"Invalid domain {domain}: Does not contain both characters from shorthand {shorthand}")
-                    return None
-            except Exception as e:
-                print(f"Error parsing URL {url}: {e}")
-                return None
-
-        hostnames = Config('Hostnames')
-
-        hostname_set = False
-
-        for key in shared_state.values["sites"]:
-            shorthand = key.lower()
-            hostname = request.forms.get(shorthand)
-            try:
-                if hostname:
-                    hostname = extract_domain(hostname, shorthand)
-            except Exception as e:
-                print(f"Error extracting domain from {hostname}: {e}")
-                continue
-
-            if hostname:
-                hostnames.save(key, hostname)
-                hostname_set = True
-
-        if hostname_set:
-            quasarr.providers.web_server.temp_server_success = True
-            return render_success("At least one valid hostname set",
-                                  5)
-        else:
-            return render_fail("No valid hostname provided!")
+        return save_hostnames(shared_state)
 
-    print(
-        f'Hostnames not set. Starting web server for config at: "{shared_state.values['internal_address']}".')
-    print("Please set at least one valid hostname there!")
+    info(f'Hostnames not set. Starting web server for config at: "{shared_state.values['internal_address']}".')
+    info("Please set at least one valid hostname there!")
     return Server(app, listen='0.0.0.0', port=shared_state.values['port']).serve_temporarily()
 
 
-def nx_credentials_config(shared_state):
+def hostname_credentials_config(shared_state, shorthand, domain):
     app = Bottle()
 
+    shorthand = shorthand.upper()
+
     @app.get('/')
-    def nx_credentials_form():
-        form_content = '''
-        <label for="user">Username</label><br>
-        <input type="text" id="user" name="user" placeholder="user" autocorrect="off"><br>
+    def credentials_form():
+        form_content = f'''
+        <span>If required register account at: <a href="https://{domain}">{domain}</a>!</span><br><br>
+        <label for="user">Username</label>
+        <input type="text" id="user" name="user" placeholder="User" autocorrect="off"><br>
 
-        <label for="password">Password</label><br>
+        <label for="password">Password</label>
         <input type="password" id="password" name="password" placeholder="Password"><br>
         '''
 
         form_html = f'''
-        <form action="/api/nx_credentials" method="post">
+        <form action="/api/credentials/{shorthand}" method="post">
             {form_content}
             {render_button("Save", "primary", {"type": "submit"})}
         </form>
         '''
 
-        return render_form("Set User and Password for NX", form_html)
+        return render_form(f"Set User and Password for {shorthand}", form_html)
 
-    @app.post("/api/nx_credentials")
-    def set_nx_credentials():
+    @app.post("/api/credentials/<sh>")
+    def set_credentials(sh):
         user = request.forms.get('user')
         password = request.forms.get('password')
-        nx_config = Config("NX")
+        config = Config(shorthand)
 
         if user and password:
-            nx_config.save("user", user)
-            nx_config.save("password", password)
-
-            if nx.create_and_persist_session(shared_state):
-                quasarr.providers.web_server.temp_server_success = True
-                return render_success("NX credentials set successfully", 5)
+            config.save("user", user)
+            config.save("password", password)
+
+            if sh.lower() == "al":
+                if quasarr.providers.sessions.al.create_and_persist_session(shared_state):
+                    quasarr.providers.web_server.temp_server_success = True
+                    return render_success(f"{sh} credentials set successfully", 5)
+            elif sh.lower() == "dd":
+                if quasarr.providers.sessions.dd.create_and_persist_session(shared_state):
+                    quasarr.providers.web_server.temp_server_success = True
+                    return render_success(f"{sh} credentials set successfully", 5)
+            elif sh.lower() == "dl":
+                if quasarr.providers.sessions.dl.create_and_persist_session(shared_state):
+                    quasarr.providers.web_server.temp_server_success = True
+                    return render_success(f"{sh} credentials set successfully", 5)
+            elif sh.lower() == "nx":
+                if quasarr.providers.sessions.nx.create_and_persist_session(shared_state):
+                    quasarr.providers.web_server.temp_server_success = True
+                    return render_success(f"{sh} credentials set successfully", 5)
+            else:
+                quasarr.providers.web_server.temp_server_success = False
+                return render_fail(f"Unknown site shorthand! ({sh})")
 
-        nx_config.save("user", "")
-        nx_config.save("password", "")
+        config.save("user", "")
+        config.save("password", "")
         return render_fail("User and Password wrong or empty!")
 
-    print(
-        f'NX credentials required to decrypt download links. '
+    info(
+        f'"{shorthand.lower()}" credentials required to access download links. '
         f'Starting web server for config at: "{shared_state.values['internal_address']}".')
-    print("Please set your NX user and password there! First register an account if you don't have one yet.")
+    info(f"If needed register here: 'https://{domain}'")
+    info("Please set your credentials now, to allow Quasarr to launch!")
+    return Server(app, listen='0.0.0.0', port=shared_state.values['port']).serve_temporarily()
+
+
+def flaresolverr_config(shared_state):
+    app = Bottle()
+
+    @app.get('/')
+    def url_form():
+        form_content = '''
+        <span><a href="https://github.com/FlareSolverr/FlareSolverr?tab=readme-ov-file#installation">A local instance</a>
+        must be running and reachable to Quasarr!</span><br><br>
+        <label for="url">FlareSolverr URL</label>
+        <input type="text" id="url" name="url" placeholder="http://192.168.0.1:8191/v1"><br>
+        '''
+        form_html = f'''
+        <form action="/api/flaresolverr" method="post">
+            {form_content}
+            {render_button("Save", "primary", {"type": "submit"})}
+        </form>
+        '''
+        return render_form("Set FlareSolverr URL", form_html)
+
+    @app.post('/api/flaresolverr')
+    def set_flaresolverr_url():
+        url = request.forms.get('url').strip()
+        config = Config("FlareSolverr")
+
+        if url:
+            try:
+                headers = {"Content-Type": "application/json"}
+                data = {
+                    "cmd": "request.get",
+                    "url": "http://www.google.com/",
+                    "maxTimeout": 30000
+                }
+                response = requests.post(url, headers=headers, json=data, timeout=30)
+                if response.status_code == 200:
+                    config.save("url", url)
+                    print(f'Using Flaresolverr URL: "{url}"')
+                    quasarr.providers.web_server.temp_server_success = True
+                    return render_success("FlareSolverr URL saved successfully!", 5)
+            except requests.RequestException:
+                pass
+
+        # on failure, clear any existing value and notify user
+        config.save("url", "")
+        return render_fail("Could not reach FlareSolverr at that URL (expected HTTP 200).")
+
+    info(
+        '"flaresolverr" URL is required for proper operation. '
+        f'Starting web server for config at: "{shared_state.values["internal_address"]}".'
+    )
+    info("Please enter your FlareSolverr URL now.")
     return Server(app, listen='0.0.0.0', port=shared_state.values['port']).serve_temporarily()
 
 
@@ -187,24 +349,33 @@ def jdownloader_config(shared_state):
     app = Bottle()
 
     @app.get('/')
-    def hostname_form():
+    def jd_form():
         verify_form_html = f'''
+        <span>If required register account at: <a href="https://my.jdownloader.org/login.html#register">
+        my.jdownloader.org</a>!</span><br>
+
+        <p><strong>JDownloader must be running and connected to My JDownloader!</strong></p><br>
+
         <form id="verifyForm" action="/api/verify_jdownloader" method="post">
-            <label for="user">E-Mail</label><br>
+            <label for="user">E-Mail</label>
             <input type="text" id="user" name="user" placeholder="user@example.org" autocorrect="off"><br>
-            <label for="pass">Password</label><br>
+            <label for="pass">Password</label>
             <input type="password" id="pass" name="pass" placeholder="Password"><br>
             {render_button("Verify Credentials",
                            "secondary",
                            {"id": "verifyButton", "type": "button", "onclick": "verifyCredentials()"})}
         </form>
+
+        <p>Some JDownloader settings will be enforced by Quasarr on startup.</p>
+
         <form action="/api/store_jdownloader" method="post" id="deviceForm" style="display: none;">
             <input type="hidden" id="hiddenUser" name="user">
             <input type="hidden" id="hiddenPass" name="pass">
-            <label for="device">JDownloader</label><br>
+            <label for="device">JDownloader</label>
             <select id="device" name="device"></select><br>
             {render_button("Save", "primary", {"type": "submit"})}
         </form>
+        <p><strong>Saving may take a while!</strong></p><br>
         '''
 
         verify_script = '''
@@ -243,7 +414,7 @@ def jdownloader_config(shared_state):
         }
         </script>
         '''
-        return render_form("Set your credentials from my.jdownloader.org", verify_form_html, verify_script)
+        return render_form("Set your credentials for My JDownloader", verify_form_html, verify_script)
 
     @app.post("/api/verify_jdownloader")
     def verify_jdownloader():
@@ -287,8 +458,9 @@ def jdownloader_config(shared_state):
 
         return render_fail("Could not set credentials!")
 
-    print(
+    info(
         f'My-JDownloader-Credentials not set. '
         f'Starting web server for config at: "{shared_state.values['internal_address']}".')
-    print("Please set your Credentials there!")
+    info("If needed register here: 'https://my.jdownloader.org/login.html#register'")
+    info("Please set your credentials now, to allow Quasarr to launch!")
     return Server(app, listen='0.0.0.0', port=shared_state.values['port']).serve_temporarily()

quasarr/storage/sqlite_database.py

@@ -6,6 +6,7 @@ import sqlite3
 import time
 
 from quasarr.providers import shared_state
+from quasarr.providers.log import info
 
 
 class DataBase(object):
@@ -27,7 +28,7 @@ class DataBase(object):
                     self._conn.execute(f"CREATE TABLE {self._table} (key, value)")
                     self._conn.commit()
             except sqlite3.OperationalError as e:
-                print(f"Error accessing Quasarr.db: {e}")
+                info(f"Error accessing Quasarr.db: {e}")
 
     def retrieve(self, key):
         query = f"SELECT value FROM {self._table} WHERE key=?"
@@ -54,6 +55,7 @@ class DataBase(object):
         # using this parameterized query to prevent SQL injection, which requires a tuple as second argument
         self._conn.execute(query, (key, value))
         self._conn.commit()
+        return True
 
     def update_store(self, key, value):
         delete_query = f"DELETE FROM {self._table} WHERE key=?"
@@ -63,13 +65,16 @@ class DataBase(object):
         # using this parameterized query to prevent SQL injection, which requires a tuple as second argument
         self._conn.execute(insert_query, (key, value))
         self._conn.commit()
+        return True
 
     def delete(self, key):
         query = f"DELETE FROM {self._table} WHERE key=?"
         # using this parameterized query to prevent SQL injection, which requires a tuple as second argument
         self._conn.execute(query, (key,))
         self._conn.commit()
+        return True
 
     def reset(self):
         self._conn.execute(f"DROP TABLE IF EXISTS {self._table}")
         self._conn.commit()
+        return True