fix extension selection

html/app.py

@@ -57,9 +57,9 @@
 
 from filehandler import sanitize_file, safe_file, delete_file, get_all_images_for_all_users
 from queuehandler import approve_file
-from db_models import db, create_roles
+from db_models import db, create_roles, create_extensions
 from db_user_helper import add_user_to_users, get_user_from_users, get_users_data_for_dashboard
-from db_config_helper import get_extensions_info_from_config, get_extensions_from_config
+from db_extension_helper import get_extensions_info_from_extensions, get_extensions_from_extensions
 from helper import logging, sanitize_string
 
 from role_based_access import check_access
@@ -78,6 +78,7 @@
 with app.app_context():
     db.create_all()
     create_roles()
+    create_extensions()
 
 # Configure flask app with parameters from .env file
 app.secret_key = os.environ.get('FLASK_SECRET_KEY')
@@ -330,6 +331,7 @@ def management_update_upload_limit():
         return error_page("You are not allowed to access this page")
 
     # Check and prepare URL parameters
+    #TODO Update all parameter checks to use .get()
     if not request.form['upload_limit'] or not request.form['target_user_name']:
         return error_page("Specified parameters aren't valid")
     upload_limit = sanitize_string(request.form['upload_limit'])
@@ -353,40 +355,41 @@ def management_update_upload_limit():
     return redirect(url_for('management_users'))
 
 
-@app.route('/management/config')
+@app.route('/management/extensions')
 @login_required
-def management_config():
+def management_extensions():
     if not check_access(session['user_name'], 9):
         return error_page("You are not allowed to access this page")
 
-    extension_config = get_extensions_info_from_config()
+    extension_config = get_extensions_info_from_extensions()
 
-    return render_template('management/delete.html', extension_config=extension_config)
+    return render_template('management/extension.html', extension_config=extension_config)
 
 @app.route('/management/update_extensions', methods=['POST'])
 @login_required
-def management_config():
+def management_update_extensions():
     if not check_access(session['user_name'], 9):
         return error_page("You are not allowed to access this page")
 
-    # Check and prepare URL parameters
-    if not request.form['selected_extensions']:
-        return error_page("Specified parameters aren't valid")
+    req_extensions = request.form.get('selected_extensions')
+    if not req_extensions: req_extensions = []
+    else: req_extensions = req_extensions.split(",")
 
     selected_extensions = []
-    for extension in request.form['selected_extensions']:
+    for extension in req_extensions:
         extension = sanitize_string(extension)
         if len(extension) > 10:
             return error_page("Specified parameters are too large")
         selected_extensions.append(extension)
 
-    for extension in get_extensions_from_config():
+    for extension in get_extensions_from_extensions():
+        print(extension.extension_name)
         if extension.extension_name in selected_extensions: 
-            if not extension.activate(): return error_page("While updating the extensions, an error occured")
+            extension.activate()
         else: 
-            if not extension.deactivate(): return error_page("While updating the extensions, an error occured")
+            extension.deactivate()
 
-    return redirect(url_for('management_config'))
+    return redirect(url_for('management_extensions'))
 
 
 @app.route('/faq')
@@ -414,4 +417,4 @@ def req_entity_to_large(e):
     return error_page(f"413 - File is larger than '{app.config['MAX_CONTENT_LENGTH']}'"), 413
 
 if __name__ == '__main__':
-    app.run(debug=False)
+    app.run(debug=True)

html/db_config_helper.py → html/db_extension_helper.py

@@ -1,22 +1,22 @@
 from sqlalchemy.exc import SQLAlchemyError
 
-from db_models import Config, db
+from db_models import Extension, db
 from helper import logging
 
 def get_extension_from_config(extension_name: str):
     try:
-        extension = db.session.query(Config).filter(Config.extension_name == extension_name).first()
+        extension = db.session.query(Extension).filter(Extension.extension_name == extension_name).first()
         if extension: return extension
     except SQLAlchemyError as e:
-        logging(f"An error occurred while retrieving an extension from the config table: {e}")
+        logging(f"An error occurred while retrieving an extension from the extension table: {e}")
     return False
 
-def get_extensions_from_config():
-    extensions = Config.query.all()
+def get_extensions_from_extensions():
+    extensions = Extension.query.all()
     if not extensions: return []
     return extensions
 
-def get_extensions_info_from_config():
-    extensions = Config.query.all()
+def get_extensions_info_from_extensions():
+    extensions = Extension.query.all()
     if not extensions: return []
     return [(extension.extension_name, extension.active) for extension in extensions]

html/db_models.py

@@ -286,33 +286,36 @@ def set_user_upload_limit(self, new_upload_limit: int):
             return False
         return True
 
+
 def create_roles():
     # Check if the roles already exist
     existing_admin = Role.query.filter_by(name='admin').first()
+    existing_moderator = Role.query.filter_by(name='moderator').first()
     existing_default = Role.query.filter_by(name='default').first()
+    existing_block = Role.query.filter_by(name='block').first()    
 
     # Create new roles only if they don't exist
     if not existing_admin:
         admin = Role(id=9, name='admin')
         db.session.add(admin)
 
-    if not existing_admin:
+    if not existing_moderator:
         moderator = Role(id=6, name='moderator')
         db.session.add(moderator)
 
     if not existing_default:
         default = Role(id=1, name='default')
         db.session.add(default)
 
-    if not existing_default:
+    if not existing_block:
         block = Role(id=0, name='block')
         db.session.add(block)
 
     db.session.commit()
 
 
-### Config ###
-class Config(db.Model):
+### Extension ###
+class Extension(db.Model):
     """
     Model for config table.
 
@@ -321,39 +324,40 @@ class Config(db.Model):
         extension_name (str): Name of the extension.
         active (bool): True if extension is active, false otherwise.
     """
-    __tablename__ = 'config'
+    __tablename__ = 'extension'
     id = db.Column(db.Integer, primary_key=True)
     extension_name = db.Column(db.String(50), unique=True)
     active = db.Column(db.Boolean)
 
-    def is_active(extension_name: str):
-        extension = Config.query.filter_by(name=extension_name).first()
-        if not extension:
-            logging("Extension do not exist")
-            return False
+    def is_active(self):
+        return self.active
 
-        if extension.active == True:
-            return True
-        return False
+    def activate(self):
+        self.active = True
 
-    def activate(extension_name: str):
-        extension = Config.query.filter_by(name=extension_name).first()
-        if not extension:
-            logging("Extension do not exist")
+        if not commit_db_changes():
+            logging("Error committing changes to the database.")
             return False
-
-        extension.active = True
         return True
 
-    def deactivate(extension_name: str):
-        extension = Config.query.filter_by(name=extension_name).first()
-        if not extension:
-            logging("Extension do not exist")
-            return False
+    def deactivate(self):
+        self.active = False
 
-        extension.active = False
+        if not commit_db_changes():
+            logging("Error committing changes to the database.")
+            return False
         return True
 
+def create_extensions():
+    # Check if the extension already exist
+    existing_mastodon = Extension.query.filter_by(extension_name='mastodon').first()    
+
+    # Create new extensions only if they don't exist
+    if not existing_mastodon:
+        mastodon = Extension(extension_name='mastodon', active=False)
+        db.session.add(mastodon)
+
+    db.session.commit()
 
 ### Mastodon Extension ###
 class Mastodon(db.Model):

html/static/css/style.css

@@ -208,6 +208,10 @@ th, td {
     width: 50%; /* Both forms will take 50% of the width by default */
 }
 
+.extension-management{
+    text-align: center;
+}
+
 @media (max-width: 600px) {
     .menu {
         display: block;

html/templates/management/config.html → html/templates/management/extension.html

@@ -25,11 +25,11 @@
     </div>
 
     <h1>Configuration</h1>
-    <div class="config-container">
-        <div class="config-extension-management">
+    <div class="extension-container">
+        <div class="extension-management">
             <form action="/management/update_extensions" method="post">
                 <label for="mastodon">Extensions</label><br>
-                {% for extension_name, active in extension_config.items() %}
+                {% for extension_name, active in extension_config %}
                 <input type="checkbox" id="{{ extension_name }}" name="selected_extensions" value="{{ extension_name }}" {% if active %}checked{% endif %}>
                 <label for="{{ extension_name }}">{{ extension_name }}</label><br>
                 {% endfor %}