Use correct naming scheme for views

gallery/views/api.py

@@ -0,0 +1,206 @@
+"""
+Onlylegs - API endpoints
+"""
+from uuid import uuid4
+import os
+import pathlib
+import logging
+from datetime import datetime as dt
+import platformdirs
+
+from flask import Blueprint, send_from_directory, abort, flash, jsonify, request, g, current_app
+from werkzeug.utils import secure_filename
+
+from colorthief import ColorThief
+
+from sqlalchemy.orm import sessionmaker
+from gallery.auth import login_required
+
+from gallery import db
+from gallery.utils import metadata as mt
+from gallery.utils.generate_image import generate_thumbnail
+
+
+blueprint = Blueprint('api', __name__, url_prefix='/api')
+db_session = sessionmaker(bind=db.engine)
+db_session = db_session()
+
+
+@blueprint.route('/file/<file_name>', methods=['GET'])
+def file(file_name):
+    """
+    Returns a file from the uploads folder
+    r for resolution, 400x400 or thumb for thumbnail
+    """
+    res = request.args.get('r', default=None, type=str)  # Type of file (thumb, etc)
+    ext = request.args.get('e', default=None, type=str)  # File extension
+    file_name = secure_filename(file_name)  # Sanitize file name
+
+    # if no args are passed, return the raw file
+    if not request.args:
+        if not os.path.exists(os.path.join(current_app.config['UPLOAD_FOLDER'], file_name)):
+            abort(404)
+        return send_from_directory(current_app.config['UPLOAD_FOLDER'], file_name)
+
+    thumb = generate_thumbnail(file_name, res, ext)
+    if not thumb:
+        abort(404)
+
+    return send_from_directory(os.path.dirname(thumb), os.path.basename(thumb))
+
+
+@blueprint.route('/upload', methods=['POST'])
+@login_required
+def upload():
+    """
+    Uploads an image to the server and saves it to the database
+    """
+    form_file = request.files['file']
+    form = request.form
+
+    # If no image is uploaded, return 404 error
+    if not form_file:
+        return abort(404)
+
+    # Get file extension, generate random name and set file path
+    img_ext = pathlib.Path(form_file.filename).suffix.replace('.', '').lower()
+    img_name = "GWAGWA_"+str(uuid4())
+    img_path = os.path.join(current_app.config['UPLOAD_FOLDER'], img_name+'.'+img_ext)
+
+    # Check if file extension is allowed
+    if img_ext not in current_app.config['ALLOWED_EXTENSIONS'].keys():
+        logging.info('File extension not allowed: %s', img_ext)
+        abort(403)
+
+    # Save file
+    try:
+        form_file.save(img_path)
+    except OSError as err:
+        logging.info('Error saving file %s because of %s', img_path, err)
+        abort(500)
+
+    img_exif = mt.Metadata(img_path).yoink()  # Get EXIF data
+    img_colors = ColorThief(img_path).get_palette(color_count=3)  # Get color palette
+
+    # Save to database
+    query = db.Posts(author_id=g.user.id,
+                     created_at=dt.utcnow(),
+                     file_name=img_name+'.'+img_ext,
+                     file_type=img_ext,
+                     image_exif=img_exif,
+                     image_colours=img_colors,
+                     post_description=form['description'],
+                     post_alt=form['alt'])
+
+    db_session.add(query)
+    db_session.commit()
+
+    return 'Gwa Gwa'  # Return something so the browser doesn't show an error
+
+
+@blueprint.route('/delete/<int:image_id>', methods=['POST'])
+@login_required
+def delete_image(image_id):
+    """
+    Deletes an image from the server and database
+    """
+    img = db_session.query(db.Posts).filter_by(id=image_id).first()
+
+    # Check if image exists and if user is allowed to delete it (author)
+    if img is None:
+        abort(404)
+    if img.author_id != g.user.id:
+        abort(403)
+
+    # Delete file
+    try:
+        os.remove(os.path.join(current_app.config['UPLOAD_FOLDER'], img.file_name))
+    except FileNotFoundError:
+        logging.warning('File not found: %s, already deleted or never existed', img.file_name)
+
+    # Delete cached files
+    cache_path = os.path.join(platformdirs.user_config_dir('onlylegs'), 'cache')
+    cache_name = img.file_name.rsplit('.')[0]
+    for cache_file in pathlib.Path(cache_path).glob(cache_name + '*'):
+        os.remove(cache_file)
+
+    # Delete from database
+    db_session.query(db.Posts).filter_by(id=image_id).delete()
+
+    # Remove all entries in junction table
+    groups = db_session.query(db.GroupJunction).filter_by(post_id=image_id).all()
+    for group in groups:
+        db_session.delete(group)
+
+    # Commit all changes
+    db_session.commit()
+
+    logging.info('Removed image (%s) %s', image_id, img.file_name)
+    flash(['Image was all in Le Head!', '1'])
+    return 'Gwa Gwa'
+
+
+@blueprint.route('/group/create', methods=['POST'])
+@login_required
+def create_group():
+    """
+    Creates a group
+    """
+    new_group = db.Groups(name=request.form['name'],
+                          description=request.form['description'],
+                          author_id=g.user.id,
+                          created_at=dt.utcnow())
+
+    db_session.add(new_group)
+    db_session.commit()
+
+    return ':3'
+
+
+@blueprint.route('/group/modify', methods=['POST'])
+@login_required
+def modify_group():
+    """
+    Changes the images in a group
+    """
+    group_id = request.form['group']
+    image_id = request.form['image']
+
+    group = db_session.query(db.Groups).filter_by(id=group_id).first()
+
+    if group is None:
+        abort(404)
+    elif group.author_id != g.user.id:
+        abort(403)
+
+    if request.form['action'] == 'add':
+        if not (db_session.query(db.GroupJunction)
+                          .filter_by(group_id=group_id, post_id=image_id)
+                          .first()):
+            db_session.add(db.GroupJunction(group_id=group_id,
+                                            post_id=image_id,
+                                            date_added=dt.utcnow()))
+    elif request.form['action'] == 'remove':
+        (db_session.query(db.GroupJunction)
+                   .filter_by(group_id=group_id, post_id=image_id)
+                   .delete())
+
+    db_session.commit()
+
+    return ':3'
+
+
+@blueprint.route('/metadata/<int:img_id>', methods=['GET'])
+def metadata(img_id):
+    """
+    Yoinks metadata from an image
+    """
+    img = db_session.query(db.Posts).filter_by(id=img_id).first()
+
+    if not img:
+        abort(404)
+
+    img_path = os.path.join(current_app.config['UPLOAD_FOLDER'], img.file_name)
+    exif = mt.Metadata(img_path).yoink()
+
+    return jsonify(exif)

gallery/views/groups.py

@@ -0,0 +1,139 @@
+"""
+Onlylegs - Image Groups
+Why groups? Because I don't like calling these albums
+sounds more limiting that it actually is in this gallery
+"""
+from flask import Blueprint, abort, render_template, url_for
+
+from sqlalchemy.orm import sessionmaker
+from gallery import db
+from gallery.utils import contrast
+
+
+blueprint = Blueprint('group', __name__, url_prefix='/group')
+db_session = sessionmaker(bind=db.engine)
+db_session = db_session()
+
+
+@blueprint.route('/', methods=['GET'])
+def groups():
+    """
+    Group overview, shows all image groups
+    """
+    groups = db_session.query(db.Groups).all()
+
+    # For each group, get the 3 most recent images
+    for group in groups:
+        group.author_username = (db_session.query(db.Users.username)
+                                           .filter(db.Users.id == group.author_id)
+                                           .first()[0])
+
+        # Get the 3 most recent images
+        images = (db_session.query(db.GroupJunction.post_id)
+                            .filter(db.GroupJunction.group_id == group.id)
+                            .order_by(db.GroupJunction.date_added.desc())
+                            .limit(3))
+
+        # For each image, get the image data and add it to the group item
+        group.images = []
+        for image in images:
+            group.images.append(db_session.query(db.Posts.file_name, db.Posts.post_alt,
+                                                 db.Posts.image_colours, db.Posts.id)
+                                          .filter(db.Posts.id == image[0])
+                                          .first())
+
+    return render_template('groups/list.html', groups=groups)
+
+
+@blueprint.route('/<int:group_id>')
+def group(group_id):
+    """
+    Group view, shows all images in a group
+    """
+    # Get the group, if it doesn't exist, 404
+    group = (db_session.query(db.Groups)
+                       .filter(db.Groups.id == group_id)
+                       .first())
+
+    if group is None:
+        abort(404, 'Group not found! D:')
+
+    # Get the group's author username
+    group.author_username = (db_session.query(db.Users.username)
+                                       .filter(db.Users.id == group.author_id)
+                                       .first()[0])
+
+    # Get all images in the group from the junction table
+    junction = (db_session.query(db.GroupJunction.post_id)
+                          .filter(db.GroupJunction.group_id == group_id)
+                          .order_by(db.GroupJunction.date_added.desc())
+                          .all())
+
+    # Get the image data for each image in the group
+    images = []
+    for image in junction:
+        images.append(db_session.query(db.Posts)
+                                .filter(db.Posts.id == image[0])
+                                .first())
+
+    # Check contrast for the first image in the group for the banner
+    text_colour = 'rgb(var(--fg-black))'
+    if images:
+        text_colour = contrast.contrast(images[0].image_colours[0],
+                                        'rgb(var(--fg-black))',
+                                        'rgb(var(--fg-white))')
+
+    return render_template('groups/group.html',
+                           group=group,
+                           images=images,
+                           text_colour=text_colour)
+
+
+@blueprint.route('/<int:group_id>/<int:image_id>')
+def group_post(group_id, image_id):
+    """
+    Image view, shows the image and its metadata from a specific group
+    """
+    # Get the image, if it doesn't exist, 404
+    image = (db_session.query(db.Posts)
+                       .filter(db.Posts.id == image_id)
+                       .first())
+    if image is None:
+        abort(404, 'Image not found')
+
+    # Get the image's author username
+    image.author_username = (db_session.query(db.Users.username)
+                                       .filter(db.Users.id == image.author_id)
+                                       .first()[0])
+
+    # Get all groups the image is in
+    groups = (db_session.query(db.GroupJunction.group_id)
+                        .filter(db.GroupJunction.post_id == image_id)
+                        .all())
+
+    # Get the group data for each group the image is in
+    image.groups = []
+    for group in groups:
+        image.groups.append(db_session.query(db.Groups.id, db.Groups.name)
+                                      .filter(db.Groups.id == group[0])
+                                      .first())
+
+    # Get the next and previous images in the group
+    next_url = (db_session.query(db.GroupJunction.post_id)
+                          .filter(db.GroupJunction.group_id == group_id)
+                          .filter(db.GroupJunction.post_id > image_id)
+                          .order_by(db.GroupJunction.date_added.asc())
+                          .first())
+    prev_url = (db_session.query(db.GroupJunction.post_id)
+                          .filter(db.GroupJunction.group_id == group_id)
+                          .filter(db.GroupJunction.post_id < image_id)
+                          .order_by(db.GroupJunction.date_added.desc())
+                          .first())
+
+    # If there is a next or previous image, get the URL for it
+    if next_url:
+        next_url = url_for('group.group_post', group_id=group_id, image_id=next_url[0])
+    if prev_url:
+        prev_url = url_for('group.group_post', group_id=group_id, image_id=prev_url[0])
+
+    return render_template('image.html', image=image, next_url=next_url, prev_url=prev_url)

gallery/views/routing.py

@@ -0,0 +1,92 @@
+"""
+Onlylegs Gallery - Routing
+"""
+from flask import Blueprint, render_template, url_for, request
+from werkzeug.exceptions import abort
+
+from sqlalchemy.orm import sessionmaker
+from gallery import db
+
+
+blueprint = Blueprint('gallery', __name__)
+db_session = sessionmaker(bind=db.engine)
+db_session = db_session()
+
+
+@blueprint.route('/')
+def index():
+    """
+    Home page of the website, shows the feed of the latest images
+    """
+    images = db_session.query(db.Posts.file_name,
+                              db.Posts.post_alt,
+                              db.Posts.image_colours,
+                              db.Posts.created_at,
+                              db.Posts.id).order_by(db.Posts.id.desc()).all()
+
+    if request.args.get('coffee') == 'please':
+        abort(418)
+
+    return render_template('index.html', images=images)
+
+
+@blueprint.route('/image/<int:image_id>')
+def image(image_id):
+    """
+    Image view, shows the image and its metadata
+    """
+    # Get the image, if it doesn't exist, 404
+    image = db_session.query(db.Posts).filter(db.Posts.id == image_id).first()
+    if not image:
+        abort(404, 'Image not found :<')
+
+    # Get the image's author username
+    image.author_username = (db_session.query(db.Users.username)
+                                       .filter(db.Users.id == image.author_id)
+                                       .first()[0])
+
+    # Get the image's groups
+    groups = (db_session.query(db.GroupJunction.group_id)
+                        .filter(db.GroupJunction.post_id == image_id)
+                        .all())
+
+    # For each group, get the group data and add it to the image item
+    image.groups = []
+    for group in groups:
+        image.groups.append(db_session.query(db.Groups.id, db.Groups.name)
+                                      .filter(db.Groups.id == group[0])
+                                      .first())
+
+    # Get the next and previous images
+    next_url = (db_session.query(db.Posts.id)
+                          .filter(db.Posts.id > image_id)
+                          .order_by(db.Posts.id.asc())
+                          .first())
+    prev_url = (db_session.query(db.Posts.id)
+                          .filter(db.Posts.id < image_id)
+                          .order_by(db.Posts.id.desc())
+                          .first())
+
+    # If there is a next or previous image, get the url
+    if next_url:
+        next_url = url_for('gallery.image', image_id=next_url[0])
+    if prev_url:
+        prev_url = url_for('gallery.image', image_id=prev_url[0])
+
+    return render_template('image.html', image=image, next_url=next_url, prev_url=prev_url)
+
+
+@blueprint.route('/profile')
+def profile():
+    """
+    Profile overview, shows all profiles on the onlylegs gallery
+    """
+    return render_template('profile.html', user_id='gwa gwa')
+
+
+@blueprint.route('/profile/<int:user_id>')
+def profile_id(user_id):
+    """
+    Shows user ofa given id, displays their uploads and other info
+    """
+    return render_template('profile.html', user_id=user_id)

gallery/views/settings.py

@@ -0,0 +1,45 @@
+"""
+OnlyLegs - Settings page
+"""
+from flask import Blueprint, render_template
+
+from gallery.auth import login_required
+
+
+blueprint = Blueprint('settings', __name__, url_prefix='/settings')
+
+
+@blueprint.route('/')
+@login_required
+def general():
+    """
+    General settings page
+    """
+    return render_template('settings/general.html')
+
+
+@blueprint.route('/server')
+@login_required
+def server():
+    """
+    Server settings page
+    """
+    return render_template('settings/server.html')
+
+
+@blueprint.route('/account')
+@login_required
+def account():
+    """
+    Account settings page
+    """
+    return render_template('settings/account.html')
+
+
+@blueprint.route('/logs')
+@login_required
+def logs():
+    """
+    Logs settings page
+    """
+    return render_template('settings/logs.html')