Massive rewrite

.dockerignore

@@ -0,0 +1,33 @@
+# Static files
+static/instructions
+static/minifigs
+static/parts
+static/sets
+
+# Docker
+Dockerfile
+compose.yaml
+
+# Documentation
+LICENSE
+*.md
+*.sample
+
+# Temporary
+*.csv
+
+# Database
+*.db
+
+# Python
+**/__pycache__
+*.pyc
+
+# Git
+.git
+
+# IDE
+.vscode
+
+# Dev
+test-server.sh

.env.sample

@@ -1,2 +1,257 @@
-REBRICKABLE_API_KEY=xxxx
+# Note on *_DEFAULT_ORDER
-DOMAIN_NAME=https://lego.example.com
+# If set, it will append a direct ORDER BY <whatever you set> to the SQL query
+# while listing objects. You can look at the structure of the SQLite database to
+# see the schema and the column names. Some fields are compound and not visible
+# directly from the schema (joins). You can check the query in the */list.sql files
+# in the source to see all column names.
+# The usual syntax for those variables is <table>.<column> [ASC|DESC].
+# For composite fields (CASE, SUM, COUNT) the syntax is <field>, there is no <table> name.
+# For instance:
+# - table.name (by table.name, default order)
+# - table.name ASC (by table.name, ascending)
+# - table.name DESC (by table.name, descending)
+# - field (by field, default order)
+# - ...
+# You can combine the ordering options.
+# You can use the special column name 'rowid' to order by insertion order.
+
+# Optional: A unique password to protect sensitive areas of the app
+# Useful if you want to share the page with other in read-only
+# Security: Currently not fully protecting the socket action, would be better
+# to have server-side sessions, with flask-session for instance
+# BK_AUTHENTICATION_PASSWORD="my-secret-password"
+
+# Optional/Mandatory: A unique key used to sign the secrets when using authentication
+# Do not share it with anyone, and you MUST make it random.
+# You can use the following command in your terminal to generate such random secret:
+#       python3 -c 'import secrets; print(secrets.token_hex())'
+# BK_AUTHENTICATION_KEY="change-this-to-something-random"
+
+# Optional: Pattern of the link to Bricklink for a part. Will be passed to Python .format()
+# Default: "https://www.bricklink.com/v2/catalog/catalogitem.page?P={number}"
+# BK_BRICKLINK_LINK_PART_PATTERN=""
+
+# Optional: Display Bricklink links wherever applicable
+# Default: false
+# BK_BRICKLINK_LINKS=true
+
+# Optional: Path to the database.
+# Useful if you need it mounted in a Docker volume. Keep in mind that it will not
+# do any check on the existence of the path, or if it is dangerous.
+# Default: "./app.db"
+# BK_DATABASE_PATH="/var/lib/bricktracker/app.db"
+
+# Optional: Format of the timestamp added to the database file when downloading it
+# Check https://docs.python.org/3/library/time.html#time.strftime for format details
+# Default: "%Y-%m-%d-%H-%M-%S"
+# BK_DATABASE_TIMESTAMP_FORMAT="%Y%m%d-%H%M%S"
+
+# Optional: Enable debugging.
+# Default: false
+# BK_DEBUG=true
+
+# Optional: Default number of items per page displayed for big tables
+# You can put whatever value but the exist steps are: 10, 25, 50, 100, 500, 1000
+# Default: 25
+# BK_DEFAULT_TABLE_PER_PAGE=50
+
+# Optional: if set up, will add a CORS allow origin restriction to the socket.
+# Default: ""
+# Legacy name: DOMAIN_NAME
+# BK_DOMAIN_NAME="http://localhost:3333"
+
+# Optional: IP address the server will listen on.
+# Default: "0.0.0.0"
+# BK_HOST="0.0.0.0"
+
+# Optional: By default, accordion items are linked together and only one can be in
+# a collapsed state. This makes all the items indepedent.
+# Default: false
+# BK_INDEPENDENT_ACCORDIONS=true
+
+# Optional: A comma separated list of extensions allowed for uploading and displaying
+# instruction files. You need to keep the dot (.) in the extension.
+# Security: not really
+# Default: .pdf
+# BK_INSTRUCTIONS_ALLOWED_EXTENSIONS=".pdf, .docx, .png"
+
+# Optional: Folder where to store the instructions, relative to the 'static/' folder
+# Default: "instructions"
+# BK_INSTRUCTIONS_FOLDER="/var/lib/bricktracker/instructions/"
+
+# Optional: Hide the 'Add' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ADD_SET=true
+
+# Optional: Hide the 'Bulk add' entry from the add page. Does not disable the route.
+# Default: false
+# BK_HIDE_ADD_BULK_SET=true
+
+# Optional: Hide the 'Admin' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ADMIN=true
+
+# Optional: Hide the 'Instructions' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ALL_INSTRUCTIONS=true
+
+# Optional: Hide the 'Minifigures' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ALL_MINIFIGURES=true
+
+# Optional: Hide the 'Parts' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ALL_PARTS=true
+
+# Optional: Hide the 'Sets' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_ALL_SETS=true
+
+# Optional: Hide the 'Missing' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_MISSING_PARTS=true
+
+# Optional: Hide the 'Wishlist' entry from the menu. Does not disable the route.
+# Default: false
+# BK_HIDE_WISHES=true
+
+# Optional: Change the default order of minifigures. By default ordered by insertion order.
+# Useful column names for this option are:
+# - minifigures.fig_num: minifigure ID (fig-xxxxx)
+# - minifigures.name: minifigure name
+# Default: "minifigures.name ASC"
+# BK_MINIFIGURES_DEFAULT_ORDER="minifigures.name ASC"
+
+# Optional: Folder where to store the minifigures images, relative to the 'static/' folder
+# Default: "minifigs/"
+# BK_MINIFIGURES_FOLDER="minifigures/"
+
+# Optional: Disable threading on the task executed by the socket.
+# You should not need to change this parameter unless you are debugging something with the
+# socket itself.
+# Default: false
+# BK_NO_THREADED_SOCKET=true
+
+# Optional: Change the default order of parts. By default ordered by insertion order.
+# Useful column names for this option are:
+# - inventory.part_num: part number
+# - inventory.name: part name
+# - inventory.color_name: par color name
+# - total_missing: number of missing parts
+# Default: "inventory.name ASC, inventory.color_name ASC, is_spare ASC"
+# BK_PARTS_DEFAULT_ORDER="total_missing DESC, inventory.name ASC"
+
+# Optional: Folder where to store the parts images, relative to the 'static/' folder
+# Default: "parts/"
+# BK_PARTS_FOLDER="parts/"
+
+# Optional: Port the server will listen on.
+# Default: 3333
+# BK_PORT=3333
+
+# Optional: Shuffle the lists on the front page.
+# Default: false
+# Legacy name: RANDOM
+# BK_RANDOM=true
+
+# Optional/Mandatory: The API key used to retrieve sets from the Rebrickable API.
+# It is not necessary to set it to display the site, but it will limit its capabilities
+# as you will not be able to add new sets
+# Default: ""
+# Legacy name: REBRICKABLE_API_KEY
+# BK_REBRICKABLE_API_KEY="xxxx"
+
+# Optional: URL of the image representing a missing image in Rebrickable
+# Default: "https://rebrickable.com/static/img/nil.png"
+# BK_REBRICKABLE_IMAGE_NIL=""
+
+# Optional: URL of the image representing a missing minifigure image in Rebrickable
+# Default: "https://rebrickable.com/static/img/nil_mf.jpg"
+# BK_REBRICKABLE_IMAGE_NIL_MINIFIGURE=""
+
+# Optional: Pattern of the link to Rebrickable for a minifigure. Will be passed to Python .format()
+# Default: "https://rebrickable.com/minifigs/{number}"
+# BK_REBRICKABLE_LINK_MINIFIGURE_PATTERN=""
+
+# Optional: Pattern of the link to Rebrickable for a part. Will be passed to Python .format()
+# Default: "https://rebrickable.com/parts/{number}/_/{color}"
+# BK_REBRICKABLE_LINK_PART_PATTERN=""
+
+# Optional: Pattern of the link to Rebrickable for a set. Will be passed to Python .format()
+# Default: "https://rebrickable.com/sets/{number}"
+# BK_REBRICKABLE_LINK_SET_PATTERN=""
+
+# Optional: Display Rebrickable links wherever applicable
+# Default: false
+# Legacy name: LINKS
+# BK_REBRICKABLE_LINKS=true
+
+# Optional: The amount of items to retrieve per Rebrickable API call when.
+# Default: 100
+# BK_REBRICKABLE_PAGE_SIZE=200
+
+# Optional: URL to the unofficial retired sets list on Google Sheets
+# Default: "https://docs.google.com/spreadsheets/d/1rlYfEXtNKxUOZt2Mfv0H17DvK7bj6Pe0CuYwq6ay8WA/gviz/tq?tqx=out:csv&sheet=Sorted%20by%20Retirement%20Date"
+# BK_RETIRED_SETS_FILE_URL=""
+
+# Optional: Path to the unofficial retired sets lists
+# You can name it whatever you want, but content has to be a CSV
+# Default: "./retired_sets.csv"
+# BK_RETIRED_SETS_PATH="/var/lib/bricktracker/retired_sets.csv"
+
+# Optional: Change the default order of sets. By default ordered by insertion order.
+# Useful column names for this option are:
+# - sets.set_num: set number as a string
+# - sets.name: set name
+# - sets.year: set release year
+# - sets.num_parts: set number of parts
+# - set_number: the number part of set_num as an integer
+# - set_version: the version part of set_num as an integer
+# - total_missing: number of missing parts
+# - total_minifigures: number of minifigures
+# Default: "set_number DESC, set_version ASC"
+# BK_SETS_DEFAULT_ORDER="sets.year ASC"
+
+# Optional: Folder where to store the sets images, relative to the 'static/' folder
+# Default: "sets/"
+# BK_SETS_FOLDER="sets/"
+
+# Optional: Skip saving or displaying spare parts
+# Default: false
+# BK_SKIP_SPARE_PARTS=true
+
+# Optional: Namespace of the Socket.IO socket
+# Default: "bricksocket"
+# BK_SOCKET_NAMESPACE="customsocket"
+
+# Optional: Namespace of the Socket.IO path
+# Default: "/bricksocket/"
+# BK_SOCKET_PATH="custompath"
+
+# Optional: URL to the themes.csv.gz on Rebrickable
+# Default: "https://cdn.rebrickable.com/media/downloads/themes.csv.gz"
+# BK_THEMES_FILE_URL=""
+
+# Optional: Path to the themes file
+# You can name it whatever you want, but content has to be a CSV
+# Default: "./themes.csv"
+# BK_THEMES_PATH="/var/lib/bricktracker/themes.csv"
+
+# Optional: Timezone to use to display datetimes
+# Check your system for available timezone/TZ values
+# Default: "Etc/UTC"
+# BK_TIMEZONE="Europe/Copenhagen"
+
+# Optional: Use remote image rather than the locally stored ones
+# Also prevents downloading any image when adding sets
+# Default: false
+# BK_USE_REMOTE_IMAGES=true
+
+# Optional: Change the default order of sets. By default ordered by insertion order.
+# Useful column names for this option are:
+# - wishlist.set_num: set number as a string
+# - wishlist.name: set name
+# - wishlist.year: set release year
+# - wishlist.num_parts: set number of parts
+# Default: "wishlist.rowid DESC"
+# BK_WISHES_DEFAULT_ORDER="set_number DESC, set_version ASC"

.gitignore

@@ -1,11 +1,22 @@
-api
+# Application
 .env
-*.csv
 *.db
-*.png
+
-*.pdf
+# Python specifics
-*.jpg
+__pycache__/
-*.log
+*.pyc
-/info
+
-/__pycache__
+# Static folders
-*.bk
+static/instructions/
+static/minifigs/
+static/parts/
+static/sets/
+
+# IDE
+.vscode/
+
+# Temporary
+*.csv
+
+# Apple idiocy
+.DS_Store

Dockerfile

@@ -1,8 +1,12 @@
 FROM python:slim
+
 WORKDIR /app
+
+# Python library requirements
 COPY requirements.txt .
 RUN pip install -r requirements.txt
+
+# Bricktracker
 COPY . .
-RUN bash lego.sh
+
-#CMD ["python", "app.py"]
+ENTRYPOINT ["entrypoint.sh"]
-CMD ["gunicorn","--bind","0.0.0.0:3333","app:app","--worker-class","eventlet"]

archive/lego.py

@@ -1,193 +0,0 @@
-import sys #using argv
-import logging #logging errors
-
-from pathlib import Path # creating folders
-import rebrick #rebrickable api
-
-# json things
-import json
-from pprint import pprint as pp
-import requests # request img from web
-import shutil # save img locally
-
-log_name='lego.log'
-
-logging.basicConfig(filename=log_name, level=logging.DEBUG)
-logging.FileHandler(log_name,mode='w')
-
-if '-' not in sys.argv[1]:
-    set_num = sys.argv[1] + '-1'
-else:
-    set_num=sys.argv[1]
-
-#online_set_num=set_num+"-1"
-
-print ("Adding set: " + set_num)
-
-set_path="./static/sets/" + set_num + "/"
-Path('./static/parts').mkdir(parents=True, exist_ok=True)
-Path('./static/figs').mkdir(parents=True, exist_ok=True)
-Path('./info').mkdir(parents=True, exist_ok=True)
-
-with open('api','r') as f:
-    api_key = f.read().replace('\n','')
-
-rb = rebrick.init(api_key)
-
-# if Path(set_path).is_dir():
-#     print('Set exists, exitting')
-#     logging.error('Set exists!')
-#     #exit()
-
-Path(set_path).mkdir(parents=True, exist_ok=True)
-
-# Get set info
-response = json.loads(rebrick.lego.get_set(set_num).read())
-
-if Path("./info/"+set_num + ".json").is_file():
-
-    ans = input('Set exists, would you like to add another copy (Y/N)?\n')
-    if ans.lower() == 'yes' or ans.lower() == 'y':
-        with open("./info/" + set_num + ".json",'r') as f:
-            data = json.load(f)
-            data['count'] = data['count'] + 1
-
-            tmp = {"location": "","minifigs": "","bricks": {"missing": []}}
-            
-            data['unit'].append(tmp)
-            pp(data)
-        with open("./info/" + set_num + ".json",'w') as f:
-            json.dump(data,f,indent = 4)
-
-with open(set_path+'info.json', 'w', encoding='utf-8') as f:
-    json.dump(response, f, ensure_ascii=False, indent=4)
-
-# save set image to folder
-set_img_url = response["set_img_url"]
-
-print('Saving set image:',end='')
-
-res = requests.get(set_img_url, stream = True)
-
-if res.status_code == 200:
-    with open(set_path+"cover.jpg",'wb') as f:
-        shutil.copyfileobj(res.raw, f)
-        print(' OK')
-else:
-    print('Image Couldn\'t be retrieved for set ' + set_num)
-    logging.error('set_img_url: ' + set_num)
-    print(' ERROR')
-
-# set inventory
-print('Saving set inventory')
-response = json.loads(rebrick.lego.get_set_elements(set_num,page_size=20000).read())
-with open(set_path+'inventory.json', 'w', encoding='utf-8') as f:
-    json.dump(response, f, ensure_ascii=False, indent=4)
-
-# get part images if not exists
-print('Saving part images')
-for i in response["results"]:
-    try:
-        if i['element_id'] == None:
-            if not Path("./static/parts/p_"+i["part"]["part_id"]+".jpg").is_file():
-                res = requests.get(i["part"]["part_img_url"], stream = True)
-                if res.status_code == 200:
-                    with open("./static/parts/p_"+i["part"]["part_id"]+".jpg",'wb') as f:
-                        shutil.copyfileobj(res.raw, f)
-        else:
-            if not Path("./static/parts/"+i["element_id"]+".jpg").is_file():
-                res = requests.get(i["part"]["part_img_url"], stream = True)
-
-                if res.status_code == 200:
-                    with open("./static/parts/"+i["element_id"]+".jpg",'wb') as f:
-                        shutil.copyfileobj(res.raw, f)
-            if not Path("./static/parts/"+i["element_id"]+".jpg").is_file():
-                res = requests.get(i["part"]["part_img_url"], stream = True)
-
-                if res.status_code == 200:
-                    with open("./static/parts/"+i["element_id"]+".jpg",'wb') as f:
-                        shutil.copyfileobj(res.raw, f)
-    except Exception as e:
-        print(e)
-        logging.error(set_num + ": " + str(e))
-
-# read info file with missing pieces
-
-if Path("./info/"+set_num + ".json").is_file():
-    with open("./info/" + set_num + ".json") as f:
-        data = json.load(f)
-else:
-    shutil.copy("set_template.json", "./info/"+set_num+".json")
-
-## Minifigs ##
-print('Savings minifigs')
-response = json.loads(rebrick.lego.get_set_minifigs(set_num).read())
-
-figures = {"figs": []}
-
-for x in response["results"]:
-    print("    " + x["set_name"])
-    fig = {
-        "set_num": x["set_num"],
-        "name": x["set_name"],
-        "quantity": x["quantity"],
-        "set_img_url": x["set_img_url"],
-        "parts": []
-    }
-
-    res = requests.get(x["set_img_url"], stream = True)
-
-    if res.status_code == 200:
-        with open("./static/figs/"+x["set_num"]+".jpg",'wb') as f:
-            shutil.copyfileobj(res.raw, f)
-    else:
-        print('Image Couldn\'t be retrieved for set ' + set_num)
-        logging.error('set_img_url: ' + set_num)
-
-    response = json.loads(rebrick.lego.get_minifig_elements(x["set_num"]).read())
-
-    for i in response["results"]:
-        part = {
-            "name": i["part"]["name"],
-            "quantity": i["quantity"],
-            "color_name": i["color"]["name"],
-            "part_num": i["part"]["part_num"],
-            "part_img_url": i["part"]["part_img_url"]
-
-        }
-        fig["parts"].append(part)
-
-        try:
-            if i['element_id'] == None:
-                if not Path("./static/figs/p_"+i["part"]["part_num"]+".jpg").is_file():
-                    res = requests.get(i["part"]["part_img_url"], stream = True)
-
-                    if res.status_code == 200:
-                        with open("./static/figs/p_"+i["part"]["part_num"]+".jpg",'wb') as f:
-                            shutil.copyfileobj(res.raw, f)
-            else:
-                if not Path("./static/figs/"+i["part"]["part_num"]+".jpg").is_file():
-                    res = requests.get(i["part"]["part_img_url"], stream = True)
-
-                    if res.status_code == 200:
-                        with open("./static/figs/"+i["part"]["part_num"]+".jpg",'wb') as f:
-                            shutil.copyfileobj(res.raw, f)
-                if not Path("./static/figs/"+i["part"]["part_num"]+".jpg").is_file():
-                    res = requests.get(i["part"]["part_img_url"], stream = True)
-
-                    if res.status_code == 200:
-                        with open("./static/figs/"+i["part"]["part_num"]+".jpg",'wb') as f:
-                            shutil.copyfileobj(res.raw, f)
-        except Exception as e:
-            print(e)
-            logging.error(set_num + ": " + str(e))
-
-    figures["figs"].append(fig)
-    part = {}
-    fig = {}
-
-with open(set_path+'minifigs.json', 'w', encoding='utf-8') as f:
-    json.dump(figures, f, ensure_ascii=False, indent=4)
-####
-
-print('Done!')

archive/set_template.json

@@ -1,12 +0,0 @@
-{
-  "count": 1,
-  "unit": [
-    {
-      "location": "",
-      "minifigs": "",
-      "bricks": {
-        "missing": []
-      }
-    }
-  ]
-}

bricktracker/__init__.py

@@ -0,0 +1 @@
+VERSION = '0.1.0'

bricktracker/app.py

@@ -0,0 +1,101 @@
+import logging
+import sys
+import time
+from zoneinfo import ZoneInfo
+
+from flask import current_app, Flask, g
+from werkzeug.middleware.proxy_fix import ProxyFix
+
+from bricktracker.configuration_list import BrickConfigurationList
+from bricktracker.login import LoginManager
+from bricktracker.navbar import Navbar
+from bricktracker.sql import close
+from bricktracker.version import __version__
+from bricktracker.views.add import add_page
+from bricktracker.views.admin import admin_page
+from bricktracker.views.error import error_404
+from bricktracker.views.index import index_page
+from bricktracker.views.instructions import instructions_page
+from bricktracker.views.login import login_page
+from bricktracker.views.minifigure import minifigure_page
+from bricktracker.views.part import part_page
+from bricktracker.views.set import set_page
+from bricktracker.views.wish import wish_page
+
+
+def setup_app(app: Flask) -> None:
+    # Load the configuration
+    BrickConfigurationList(app)
+
+    # Set the logging level
+    if app.config['DEBUG'].value:
+        logging.basicConfig(
+            stream=sys.stdout,
+            level=logging.DEBUG,
+            format='[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s',  # noqa: E501
+        )
+    else:
+        logging.basicConfig(
+            stream=sys.stdout,
+            level=logging.INFO,
+            format='[%(asctime)s] %(levelname)s - %(message)s',
+        )
+
+    # Load the navbar
+    Navbar(app)
+
+    # Setup the login manager
+    LoginManager(app)
+
+    # I don't know :-)
+    app.wsgi_app = ProxyFix(
+        app.wsgi_app,
+        x_for=1,
+        x_proto=1,
+        x_host=1,
+        x_port=1,
+        x_prefix=1,
+    )
+
+    # Register errors
+    app.register_error_handler(404, error_404)
+
+    # Register routes
+    app.register_blueprint(add_page)
+    app.register_blueprint(admin_page)
+    app.register_blueprint(index_page)
+    app.register_blueprint(instructions_page)
+    app.register_blueprint(login_page)
+    app.register_blueprint(minifigure_page)
+    app.register_blueprint(part_page)
+    app.register_blueprint(set_page)
+    app.register_blueprint(wish_page)
+
+    # An helper to make global variables available to the
+    # request
+    @app.before_request
+    def before_request() -> None:
+        def request_time() -> str:
+            elapsed = time.time() - g.request_start_time
+            if elapsed < 1:
+                return '{elapsed:.0f}ms'.format(elapsed=elapsed*1000)
+            else:
+                return '{elapsed:.2f}s'.format(elapsed=elapsed)
+
+        # Login manager
+        g.login = LoginManager
+
+        # Execution time
+        g.request_start_time = time.time()
+        g.request_time = request_time
+
+        # Register the timezone
+        g.timezone = ZoneInfo(current_app.config['TIMEZONE'].value)
+
+        # Version
+        g.version = __version__
+
+    # Make sure all connections are closed at the end
+    @app.teardown_appcontext
+    def close_connections(exception, /) -> None:
+        close()

bricktracker/config.py

@@ -0,0 +1,61 @@
+from typing import Any, Final
+
+# Configuration map:
+# - n: internal name (str)
+# - e: extra environment name (str, optional=None)
+# - d: default value (Any, optional=None)
+# - c: cast to type (Type, optional=None)
+# - s: interpret as a path within static (bool, optional=False)
+# Easy to change an environment variable name without changing all the code
+CONFIG: Final[list[dict[str, Any]]] = [
+    {'n': 'AUTHENTICATION_PASSWORD', 'd': ''},
+    {'n': 'AUTHENTICATION_KEY', 'd': ''},
+    {'n': 'BRICKLINK_LINK_PART_PATTERN', 'd': 'https://www.bricklink.com/v2/catalog/catalogitem.page?P={number}'},  # noqa: E501
+    {'n': 'BRICKLINK_LINKS', 'c': bool},
+    {'n': 'DATABASE_PATH', 'd': './app.db'},
+    {'n': 'DATABASE_TIMESTAMP_FORMAT', 'd': '%Y-%m-%d-%H-%M-%S'},
+    {'n': 'DEBUG', 'c': bool},
+    {'n': 'DEFAULT_TABLE_PER_PAGE', 'd': 25, 'c': int},
+    {'n': 'DOMAIN_NAME', 'e': 'DOMAIN_NAME', 'd': ''},
+    {'n': 'FILE_DATETIME_FORMAT', 'd': '%d/%m/%Y, %H:%M:%S'},
+    {'n': 'HOST', 'd': '0.0.0.0'},
+    {'n': 'INDEPENDENT_ACCORDIONS', 'c': bool},
+    {'n': 'INSTRUCTIONS_ALLOWED_EXTENSIONS', 'd': ['.pdf'], 'c': list},  # noqa: E501
+    {'n': 'INSTRUCTIONS_FOLDER', 'd': 'instructions', 's': True},
+    {'n': 'HIDE_ADD_SET', 'c': bool},
+    {'n': 'HIDE_ADD_BULK_SET', 'c': bool},
+    {'n': 'HIDE_ADMIN', 'c': bool},
+    {'n': 'HIDE_ALL_INSTRUCTIONS', 'c': bool},
+    {'n': 'HIDE_ALL_MINIFIGURES', 'c': bool},
+    {'n': 'HIDE_ALL_PARTS', 'c': bool},
+    {'n': 'HIDE_ALL_SETS', 'c': bool},
+    {'n': 'HIDE_MISSING_PARTS', 'c': bool},
+    {'n': 'HIDE_WISHES', 'c': bool},
+    {'n': 'MINIFIGURES_DEFAULT_ORDER', 'd': 'minifigures.name ASC'},
+    {'n': 'MINIFIGURES_FOLDER', 'd': 'minifigs', 's': True},
+    {'n': 'NO_THREADED_SOCKET', 'c': bool},
+    {'n': 'PARTS_DEFAULT_ORDER', 'd': 'inventory.name ASC, inventory.color_name ASC, is_spare ASC'},  # noqa: E501
+    {'n': 'PARTS_FOLDER', 'd': 'parts', 's': True},
+    {'n': 'PORT', 'd': 3333, 'c': int},
+    {'n': 'RANDOM', 'e': 'RANDOM', 'c': bool},
+    {'n': 'REBRICKABLE_API_KEY', 'e': 'REBRICKABLE_API_KEY', 'd': ''},
+    {'n': 'REBRICKABLE_IMAGE_NIL', 'd': 'https://rebrickable.com/static/img/nil.png'},  # noqa: E501
+    {'n': 'REBRICKABLE_IMAGE_NIL_MINIFIGURE', 'd': 'https://rebrickable.com/static/img/nil_mf.jpg'},  # noqa: E501
+    {'n': 'REBRICKABLE_LINK_MINIFIGURE_PATTERN', 'd': 'https://rebrickable.com/minifigs/{number}'},  # noqa: E501
+    {'n': 'REBRICKABLE_LINK_PART_PATTERN', 'd': 'https://rebrickable.com/parts/{number}/_/{color}'},  # noqa: E501
+    {'n': 'REBRICKABLE_LINK_SET_PATTERN', 'd': 'https://rebrickable.com/sets/{number}'},  # noqa: E501
+    {'n': 'REBRICKABLE_LINKS', 'e': 'LINKS', 'c': bool},
+    {'n': 'REBRICKABLE_PAGE_SIZE', 'd': 100, 'c': int},
+    {'n': 'RETIRED_SETS_FILE_URL', 'd': 'https://docs.google.com/spreadsheets/d/1rlYfEXtNKxUOZt2Mfv0H17DvK7bj6Pe0CuYwq6ay8WA/gviz/tq?tqx=out:csv&sheet=Sorted%20by%20Retirement%20Date'},  # noqa: E501
+    {'n': 'RETIRED_SETS_PATH', 'd': './retired_sets.csv'},
+    {'n': 'SETS_DEFAULT_ORDER', 'd': 'set_number DESC, set_version ASC'},
+    {'n': 'SETS_FOLDER', 'd': 'sets', 's': True},
+    {'n': 'SKIP_SPARE_PARTS', 'c': bool},
+    {'n': 'SOCKET_NAMESPACE', 'd': 'bricksocket'},
+    {'n': 'SOCKET_PATH', 'd': '/bricksocket/'},
+    {'n': 'THEMES_FILE_URL', 'd': 'https://cdn.rebrickable.com/media/downloads/themes.csv.gz'},  # noqa: E501
+    {'n': 'THEMES_PATH', 'd': './themes.csv'},
+    {'n': 'TIMEZONE', 'd': 'Etc/UTC'},
+    {'n': 'USE_REMOTE_IMAGES', 'c': bool},
+    {'n': 'WISHES_DEFAULT_ORDER', 'd': 'wishlist.rowid DESC'},
+]

bricktracker/configuration.py

@@ -0,0 +1,87 @@
+import os
+from typing import Any, Type
+
+
+# Configuration item
+class BrickConfiguration(object):
+    name: str
+    cast: Type | None
+    default: Any
+    env_name: str
+    extra_name: str | None
+    mandatory: bool
+    static_path: bool
+    value: Any
+
+    def __init__(
+        self,
+        /,
+        n: str,
+        e: str | None = None,
+        d: Any = None,
+        c: Type | None = None,
+        m: bool = False,
+        s: bool = False,
+    ):
+        # We prefix all default variable name with 'BK_' for the
+        # environment name to avoid interfering
+        self.name = n
+        self.env_name = 'BK_{name}'.format(name=n)
+        self.extra_name = e
+        self.default = d
+        self.cast = c
+        self.mandatory = m
+        self.static_path = s
+
+        # Default for our booleans is False
+        if self.cast == bool:
+            self.default = False
+
+        # Try default environment name
+        value = os.getenv(self.env_name)
+        if value is None:
+            # Try the extra name
+            if self.extra_name is not None:
+                value = os.getenv(self.extra_name)
+
+            # Set the default
+            if value is None:
+                value = self.default
+
+        # Special treatment
+        if value is not None:
+            # Comma seperated list
+            if self.cast == list and isinstance(value, str):
+                value = [item.strip() for item in value.split(',')]
+                self.cast = None
+
+            # Boolean string
+            if self.cast == bool and isinstance(value, str):
+                value = value.lower() in ('true', 'yes', '1')
+
+            # Static path fixup
+            if self.static_path and isinstance(value, str):
+                value = os.path.normpath(value)
+
+                # Remove any leading slash or dots
+                value = value.lstrip('/.')
+
+                # Remove static prefix
+                value = value.removeprefix('static/')
+
+        if self.cast is not None:
+            self.value = self.cast(value)
+        else:
+            self.value = value
+
+    # Tells whether the value is changed from its default
+    def is_changed(self, /) -> bool:
+        return self.value != self.default
+
+    # Tells whether the value is secret
+    def is_secret(self, /) -> bool:
+        return self.name in [
+            'REBRICKABLE_API_KEY',
+            'AUTHENTICATION_PASSWORD',
+            'AUTHENTICATION_KEY'
+        ]

bricktracker/configuration_list.py

@@ -0,0 +1,43 @@
+from typing import Generator
+
+from flask import current_app, Flask
+
+from .config import CONFIG
+from .configuration import BrickConfiguration
+from .exceptions import ConfigurationMissingException
+
+
+# Application configuration
+class BrickConfigurationList(object):
+    app: Flask
+
+    # Load configuration
+    def __init__(self, app: Flask, /):
+        self.app = app
+
+        # Process all configuration items
+        for config in CONFIG:
+            item = BrickConfiguration(**config)
+            self.app.config[item.name] = item
+
+    # Check whether a str configuration is set
+    @staticmethod
+    def error_unless_is_set(name: str):
+        value = current_app.config[name].value
+
+        if value is None or value == '':
+            raise ConfigurationMissingException(
+                '{name} must be defined'.format(name=name),
+            )
+
+    # Get all the configuration items from the app config
+    @staticmethod
+    def list() -> Generator[BrickConfiguration, None, None]:
+        keys = list(current_app.config.keys())
+        keys.sort()
+
+        for name in keys:
+            config = current_app.config[name]
+
+            if isinstance(config, BrickConfiguration):
+                yield config

bricktracker/exceptions.py

@@ -0,0 +1,23 @@
+# Something was not found
+class NotFoundException(Exception):
+    ...
+
+
+# Generic error exception
+class ErrorException(Exception):
+    title: str = 'Error'
+
+
+# Configuration error
+class ConfigurationMissingException(ErrorException):
+    title: str = 'Configuration missing'
+
+
+# Database error
+class DatabaseException(ErrorException):
+    title: str = 'Database error'
+
+
+# Download error
+class DownloadException(ErrorException):
+    title: str = 'Download error'

bricktracker/fields.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+
+# SQLite record fields
+class BrickRecordFields(object):
+    def __getattr__(self, name: str, /) -> Any:
+        return self.__dict__[name]
+
+    def __setattr__(self, name: str, value: Any, /) -> None:
+        self.__dict__[name] = value

bricktracker/instructions.py

@@ -0,0 +1,137 @@
+from datetime import datetime, timezone
+import logging
+import os
+from typing import TYPE_CHECKING
+
+from flask import current_app, g, url_for
+import humanize
+from werkzeug.datastructures import FileStorage
+from werkzeug.utils import secure_filename
+
+from .exceptions import ErrorException
+if TYPE_CHECKING:
+    from .set import BrickSet
+
+logger = logging.getLogger(__name__)
+
+
+class BrickInstructions(object):
+    allowed: bool
+    brickset: 'BrickSet | None'
+    extension: str
+    filename: str
+    mtime: datetime
+    number: 'str | None'
+    name: str
+    size: int
+
+    def __init__(self, file: os.DirEntry | str, /):
+        if isinstance(file, str):
+            self.filename = file
+        else:
+            self.filename = file.name
+
+            # Store the file stats
+            stat = file.stat()
+            self.size = stat.st_size
+            self.mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+
+        # Store the name and extension, check if extension is allowed
+        self.name, self.extension = os.path.splitext(self.filename)
+        self.extension = self.extension.lower()
+        self.allowed = self.extension in current_app.config['INSTRUCTIONS_ALLOWED_EXTENSIONS'].value  # noqa: E501
+
+        # Placeholder
+        self.brickset = None
+        self.number = None
+
+        # Extract the set number
+        if self.allowed:
+            # Normalize special chars to improve set detection
+            normalized = self.name.replace('_', '-')
+            normalized = normalized.replace(' ', '-')
+
+            splits = normalized.split('-', 2)
+
+            if len(splits) >= 2:
+                self.number = '-'.join(splits[:2])
+
+    # Delete an instruction file
+    def delete(self, /) -> None:
+        os.remove(self.path())
+
+    # Display the size in a human format
+    def human_size(self) -> str:
+        return humanize.naturalsize(self.size)
+
+    # Display the time in a human format
+    def human_time(self) -> str:
+        return self.mtime.astimezone(g.timezone).strftime(
+            current_app.config['FILE_DATETIME_FORMAT'].value
+        )
+
+    # Compute the path of an instruction file
+    def path(self, /, filename=None) -> str:
+        if filename is None:
+            filename = self.filename
+
+        return os.path.join(
+            current_app.static_folder,  # type: ignore
+            current_app.config['INSTRUCTIONS_FOLDER'].value,
+            filename
+        )
+
+    # Rename an instructions file
+    def rename(self, filename: str, /) -> None:
+        # Add the extension
+        filename = '{name}{ext}'.format(name=filename, ext=self.extension)
+
+        if filename != self.filename:
+            # Check if it already exists
+            target = self.path(filename=filename)
+            if os.path.isfile(target):
+                raise ErrorException('Cannot rename {source} to {target} as it already exists'.format(  # noqa: E501
+                    source=self.filename,
+                    target=filename
+                ))
+
+            os.rename(self.path(), target)
+
+    # Upload a new instructions file
+    def upload(self, file: FileStorage, /) -> None:
+        target = self.path(secure_filename(self.filename))
+
+        if os.path.isfile(target):
+            raise ErrorException('Cannot upload {target} as it already exists'.format(  # noqa: E501
+                target=self.filename
+            ))
+
+        file.save(target)
+
+        # Info
+        logger.info('The instruction file {file} has been imported'.format(
+            file=self.filename
+        ))
+
+    # Compute the url for a set instructions file
+    def url(self, /) -> str:
+        if not self.allowed:
+            return ''
+
+        folder: str = current_app.config['INSTRUCTIONS_FOLDER'].value
+
+        # Compute the path
+        path = os.path.join(folder, self.filename)
+
+        return url_for('static', filename=path)
+
+    # Return the icon depending on the extension
+    def icon(self, /) -> str:
+        if self.extension == '.pdf':
+            return 'file-pdf-2-line'
+        elif self.extension in ['.doc', '.docx']:
+            return 'file-word-line'
+        elif self.extension in ['.png', '.jpg', '.jpeg']:
+            return 'file-image-line'
+        else:
+            return 'file-line'

bricktracker/instructions_list.py

@@ -0,0 +1,110 @@
+import logging
+import os
+from typing import Generator
+
+from flask import current_app
+
+from .exceptions import NotFoundException
+from .instructions import BrickInstructions
+
+logger = logging.getLogger(__name__)
+
+
+# Lego sets instruction list
+class BrickInstructionsList(object):
+    all: dict[str, BrickInstructions]
+    rejected_total: int
+    sets: dict[str, list[BrickInstructions]]
+    sets_total: int
+    unknown_total: int
+
+    def __init__(self, /, force=False):
+        # Load instructions only if there is none already loaded
+        all = getattr(self, 'all', None)
+
+        if all is None or force:
+            logger.info('Loading instructions file list')
+
+            BrickInstructionsList.all = {}
+            BrickInstructionsList.rejected_total = 0
+            BrickInstructionsList.sets = {}
+            BrickInstructionsList.sets_total = 0
+            BrickInstructionsList.unknown_total = 0
+
+            # Try to list the files in the instruction folder
+            try:
+                # Make a folder relative to static
+                folder: str = os.path.join(
+                    current_app.static_folder,  # type: ignore
+                    current_app.config['INSTRUCTIONS_FOLDER'].value,
+                )
+
+                for file in os.scandir(folder):
+                    instruction = BrickInstructions(file)
+
+                    # Unconditionnally add to the list
+                    BrickInstructionsList.all[instruction.filename] = instruction  # noqa: E501
+
+                    if instruction.allowed:
+                        if instruction.number:
+                            # Instantiate the list if not existing yet
+                            if instruction.number not in BrickInstructionsList.sets:  # noqa: E501
+                                BrickInstructionsList.sets[instruction.number] = []  # noqa: E501
+
+                            BrickInstructionsList.sets[instruction.number].append(instruction)  # noqa: E501
+                            BrickInstructionsList.sets_total += 1
+                        else:
+                            BrickInstructionsList.unknown_total += 1
+                    else:
+                        BrickInstructionsList.rejected_total += 1
+
+                # Associate bricksets
+                # Not ideal, to avoid a circular import
+                from .set import BrickSet
+                from .set_list import BrickSetList
+
+                # Grab the generic list of sets
+                bricksets: dict[str, BrickSet] = {}
+                for brickset in BrickSetList().generic().records:
+                    bricksets[brickset.fields.set_num] = brickset
+
+                # Return the files
+                for instruction in self.all.values():
+                    # Inject the brickset if it exists
+                    if (
+                        instruction.allowed and
+                        instruction.number is not None and
+                        instruction.brickset is None and
+                        instruction.number in bricksets
+                    ):
+                        instruction.brickset = bricksets[instruction.number]
+
+            # Ignore errors
+            except Exception:
+                pass
+
+    # Grab instructions for a set
+    def get(self, number: str) -> list[BrickInstructions]:
+        if number in self.sets:
+            return self.sets[number]
+        else:
+            return []
+
+    # Grab instructions for a file
+    def get_file(self, name: str) -> BrickInstructions:
+        if name not in self.all:
+            raise NotFoundException('Instruction file {name} does not exist'.format(  # noqa: E501
+                name=name
+            ))
+
+        return self.all[name]
+
+    # List of all instruction files
+    def list(self, /) -> Generator[BrickInstructions, None, None]:
+        # Get the filenames and sort them
+        filenames = list(self.all.keys())
+        filenames.sort()
+
+        # Return the files
+        for filename in filenames:
+            yield self.all[filename]

bricktracker/login.py

@@ -0,0 +1,65 @@
+from flask import current_app, Flask
+from flask_login import current_user, login_manager, UserMixin
+
+
+# Login manager wrapper
+class LoginManager(object):
+    # Login user
+    class User(UserMixin):
+        def __init__(self, name: str, password: str, /):
+            self.id = name
+            self.password = password
+
+    def __init__(self, app: Flask, /):
+        # Setup basic authentication
+        app.secret_key = app.config['AUTHENTICATION_KEY'].value
+
+        manager = login_manager.LoginManager()
+        manager.login_view = 'login.login'  # type: ignore
+        manager.init_app(app)
+
+        # User loader with only one user
+        @manager.user_loader
+        def user_loader(*arg) -> LoginManager.User:
+            return self.User(
+                'admin',
+                app.config['AUTHENTICATION_PASSWORD'].value
+            )
+
+        # If the password is unset, globally disable
+        app.config['LOGIN_DISABLED'] = app.config['AUTHENTICATION_PASSWORD'].value == ''  # noqa: E501
+
+    # Tells whether the user is authenticated, meaning:
+    # - Authentication disabled
+    # - or User is authenticated
+    @staticmethod
+    def is_authenticated() -> bool:
+        return (
+            current_app.config['LOGIN_DISABLED'] or
+            current_user.is_authenticated
+        )
+
+    # Tells whether authentication is enabled
+    @staticmethod
+    def is_enabled() -> bool:
+        return not current_app.config['LOGIN_DISABLED']
+
+    # Tells whether we need the user authenticated, meaning:
+    # - Authentication enabled
+    # - and User not authenticated
+    @staticmethod
+    def is_not_authenticated() -> bool:
+        return (
+            not current_app.config['LOGIN_DISABLED'] and
+            not current_user.is_authenticated
+        )
+
+    # Tell whether we are in read-only, meaning:
+    # - Authentication enabled
+    # - and User not authenticated
+    @staticmethod
+    def is_readonly() -> bool:
+        return (
+            not current_app.config['LOGIN_DISABLED'] and
+            not current_user.is_authenticated
+        )

bricktracker/minifigure.py

@@ -0,0 +1,183 @@
+import os
+from sqlite3 import Row
+from typing import Any, Self, TYPE_CHECKING
+
+from flask import current_app, url_for
+
+from .exceptions import ErrorException, NotFoundException
+from .part_list import BrickPartList
+from .rebrickable_image import RebrickableImage
+from .record import BrickRecord
+if TYPE_CHECKING:
+    from .set import BrickSet
+
+
+# Lego minifigure
+class BrickMinifigure(BrickRecord):
+    brickset: 'BrickSet | None'
+
+    # Queries
+    insert_query: str = 'minifigure/insert'
+    generic_query: str = 'minifigure/select/generic'
+    select_query: str = 'minifigure/select/specific'
+
+    def __init__(
+        self,
+        /,
+        brickset: 'BrickSet | None' = None,
+        record: Row | dict[str, Any] | None = None,
+    ):
+        super().__init__()
+
+        # Save the brickset
+        self.brickset = brickset
+
+        # Ingest the record if it has one
+        if record is not None:
+            self.ingest(record)
+
+    # Return the number just in digits format
+    def clean_number(self, /) -> str:
+        number: str = self.fields.fig_num
+        number = number.removeprefix('fig-')
+        number = number.lstrip('0')
+
+        return number
+
+    # Parts
+    def generic_parts(self, /) -> BrickPartList:
+        return BrickPartList().from_minifigure(self)
+
+    # Parts
+    def parts(self, /) -> BrickPartList:
+        if self.brickset is None:
+            raise ErrorException('Part list for minifigure {number} requires a brickset'.format(  # noqa: E501
+                number=self.fields.fig_num,
+            ))
+
+        return BrickPartList().load(self.brickset, minifigure=self)
+
+    # Select a generic minifigure
+    def select_generic(self, fig_num: str, /) -> Self:
+        # Save the parameters to the fields
+        self.fields.fig_num = fig_num
+
+        record = self.select(override_query=self.generic_query)
+
+        if record is None:
+            raise NotFoundException(
+                'Minifigure with number {number} was not found in the database'.format(  # noqa: E501
+                    number=self.fields.fig_num,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        return self
+
+    # Select a specific minifigure (with a set and an number)
+    def select_specific(self, brickset: 'BrickSet', fig_num: str, /) -> Self:
+        # Save the parameters to the fields
+        self.brickset = brickset
+        self.fields.fig_num = fig_num
+
+        record = self.select()
+
+        if record is None:
+            raise NotFoundException(
+                'Minifigure with number {number} from set {set} was not found in the database'.format(  # noqa: E501
+                    number=self.fields.fig_num,
+                    set=self.brickset.fields.set_num,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        return self
+
+    # Return a dict with common SQL parameters for a minifigure
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters = super().sql_parameters()
+
+        # Supplement from the brickset
+        if self.brickset is not None:
+            if 'u_id' not in parameters:
+                parameters['u_id'] = self.brickset.fields.u_id
+
+            if 'set_num' not in parameters:
+                parameters['set_num'] = self.brickset.fields.set_num
+
+        return parameters
+
+    # Self url
+    def url(self, /) -> str:
+        return url_for(
+            'minifigure.details',
+            number=self.fields.fig_num,
+        )
+
+    # Compute the url for minifigure part image
+    def url_for_image(self, /) -> str:
+        if not current_app.config['USE_REMOTE_IMAGES'].value:
+            if self.fields.set_img_url is None:
+                file = RebrickableImage.nil_minifigure_name()
+            else:
+                file = self.fields.fig_num
+
+            folder: str = current_app.config['MINIFIGURES_FOLDER'].value
+
+            # /!\ Everything is saved as .jpg, even if it came from a .png
+            # not changing this behaviour.
+
+            # Grab the extension
+            # _, extension = os.path.splitext(self.part_img_url)
+            extension = '.jpg'
+
+            # Compute the path
+            path = os.path.join(folder, '{number}{ext}'.format(
+                number=file,
+                ext=extension,
+            ))
+
+            return url_for('static', filename=path)
+
+        else:
+            if self.fields.set_img_url is None:
+                return current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE'].value  # noqa: E501
+            else:
+                return self.fields.set_img_url
+
+    # Compute the url for the rebrickable page
+    def url_for_rebrickable(self, /) -> str:
+        if current_app.config['REBRICKABLE_LINKS'].value:
+            try:
+                return current_app.config['REBRICKABLE_LINK_MINIFIGURE_PATTERN'].value.format(  # noqa: E501
+                    number=self.fields.fig_num.lower(),
+                )
+            except Exception:
+                pass
+
+        return ''
+
+    # Normalize from Rebrickable
+    @staticmethod
+    def from_rebrickable(
+        data: dict[str, Any],
+        /,
+        brickset: 'BrickSet | None' = None,
+        **_,
+    ) -> dict[str, Any]:
+        record = {
+            'fig_num': data['set_num'],
+            'name': data['set_name'],
+            'quantity': data['quantity'],
+            'set_img_url': data['set_img_url'],
+        }
+
+        if brickset is not None:
+            record['set_num'] = brickset.fields.set_num
+            record['u_id'] = brickset.fields.u_id
+
+        return record

bricktracker/minifigure_list.py

@@ -0,0 +1,124 @@
+from typing import Any, Self, TYPE_CHECKING
+
+from flask import current_app
+
+from .minifigure import BrickMinifigure
+from .record_list import BrickRecordList
+if TYPE_CHECKING:
+    from .set import BrickSet
+
+
+# Lego minifigures
+class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
+    brickset: 'BrickSet | None'
+
+    # Queries
+    all_query: str = 'minifigure/list/all'
+    last_query: str = 'minifigure/list/last'
+    select_query: str = 'minifigure/list/from_set'
+    using_part_query: str = 'minifigure/list/using_part'
+    missing_part_query: str = 'minifigure/list/missing_part'
+
+    def __init__(self, /):
+        super().__init__()
+
+        # Placeholders
+        self.brickset = None
+
+    # Load all minifigures
+    def all(self, /) -> Self:
+        for record in self.select(
+            override_query=self.all_query,
+            order=current_app.config['MINIFIGURES_DEFAULT_ORDER'].value
+        ):
+            minifigure = BrickMinifigure(record=record)
+
+            self.records.append(minifigure)
+
+        return self
+
+    # Last added minifigure
+    def last(self, /, limit: int = 6) -> Self:
+        # Randomize
+        if current_app.config['RANDOM'].value:
+            order = 'RANDOM()'
+        else:
+            order = 'minifigures.rowid DESC'
+
+        for record in self.select(
+            override_query=self.last_query,
+            order=order,
+            limit=limit
+        ):
+            minifigure = BrickMinifigure(record=record)
+
+            self.records.append(minifigure)
+
+        return self
+
+    # Load minifigures from a brickset
+    def load(self, brickset: 'BrickSet', /) -> Self:
+        # Save the brickset
+        self.brickset = brickset
+
+        # Load the minifigures from the database
+        for record in self.select(
+            order=current_app.config['MINIFIGURES_DEFAULT_ORDER'].value
+        ):
+            minifigure = BrickMinifigure(brickset=self.brickset, record=record)
+
+            self.records.append(minifigure)
+
+        return self
+
+    # Return a dict with common SQL parameters for a minifigures list
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters: dict[str, Any] = super().sql_parameters()
+
+        if self.brickset is not None:
+            parameters['u_id'] = self.brickset.fields.u_id
+            parameters['set_num'] = self.brickset.fields.set_num
+
+        return parameters
+
+    # Minifigures missing a part
+    def missing_part(
+        self,
+        part_num: str,
+        color_id: int,
+        /,
+        element_id: int | None = None,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.part_num = part_num
+        self.fields.color_id = color_id
+        self.fields.element_id = element_id
+
+        # Load the sets from the database
+        for record in self.select(override_query=self.missing_part_query):
+            minifigure = BrickMinifigure(record=record)
+
+            self.records.append(minifigure)
+
+        return self
+
+    # Minifigure using a part
+    def using_part(
+        self,
+        part_num: str,
+        color_id: int,
+        /,
+        element_id: int | None = None,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.part_num = part_num
+        self.fields.color_id = color_id
+        self.fields.element_id = element_id
+
+        # Load the sets from the database
+        for record in self.select(override_query=self.using_part_query):
+            minifigure = BrickMinifigure(record=record)
+
+            self.records.append(minifigure)
+
+        return self

bricktracker/navbar.py

@@ -0,0 +1,51 @@
+from typing import Any, Final
+
+from flask import Flask
+
+# Navbar map:
+# - e: url endpoint (str)
+# - t: title (str)
+# - i: icon (str, optional=None)
+# - f: flag name (str, optional=None)
+NAVBAR: Final[list[dict[str, Any]]] = [
+    {'e': 'set.list', 't': 'Sets', 'i': 'grid-line', 'f': 'HIDE_ALL_SETS'},  # noqa: E501
+    {'e': 'add.add', 't': 'Add', 'i': 'add-circle-line', 'f': 'HIDE_ADD_SET'},  # noqa: E501
+    {'e': 'part.list', 't': 'Parts', 'i': 'shapes-line', 'f': 'HIDE_ALL_PARTS'},  # noqa: E501
+    {'e': 'part.missing', 't': 'Missing', 'i': 'error-warning-line', 'f': 'HIDE_MISSING_PARTS'},  # noqa: E501
+    {'e': 'minifigure.list', 't': 'Minifigures', 'i': 'group-line', 'f': 'HIDE_ALL_MINIFIGURES'},  # noqa: E501
+    {'e': 'instructions.list', 't': 'Instructions', 'i': 'file-line', 'f': 'HIDE_ALL_INSTRUCTIONS'},  # noqa: E501
+    {'e': 'wish.list', 't': 'Wishlist', 'i': 'gift-line', 'f': 'HIDE_WISHES'},
+    {'e': 'admin.admin', 't': 'Admin', 'i': 'settings-4-line', 'f': 'HIDE_ADMIN'},  # noqa: E501
+]
+
+
+# Navbar configuration
+class Navbar(object):
+    # Navbar item
+    class NavbarItem(object):
+        endpoint: str
+        title: str
+        icon: str | None
+        flag: str | None
+
+        def __init__(
+            self,
+            *,
+            e: str,
+            t: str,
+            i: str | None = None,
+            f: str | None = None,
+        ):
+            self.endpoint = e
+            self.title = t
+            self.icon = i
+            self.flag = f
+
+    # Load configuration
+    def __init__(self, app: Flask, /):
+        # Navbar storage
+        app.config['_NAVBAR'] = []
+
+        # Process all configuration items
+        for item in NAVBAR:
+            app.config['_NAVBAR'].append(self.NavbarItem(**item))

bricktracker/part.py

@@ -0,0 +1,304 @@
+import os
+from sqlite3 import Row
+from typing import Any, Self, TYPE_CHECKING
+from urllib.parse import urlparse
+
+from flask import current_app, url_for
+
+from .exceptions import DatabaseException, ErrorException, NotFoundException
+from .rebrickable_image import RebrickableImage
+from .record import BrickRecord
+from .sql import BrickSQL
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .set import BrickSet
+
+
+# Lego set or minifig part
+class BrickPart(BrickRecord):
+    brickset: 'BrickSet | None'
+    minifigure: 'BrickMinifigure | None'
+
+    # Queries
+    insert_query: str = 'part/insert'
+    generic_query: str = 'part/select/generic'
+    select_query: str = 'part/select/specific'
+
+    def __init__(
+        self,
+        /,
+        brickset: 'BrickSet | None' = None,
+        minifigure: 'BrickMinifigure | None' = None,
+        record: Row | dict[str, Any] | None = None,
+    ):
+        super().__init__()
+
+        # Save the brickset and minifigure
+        self.brickset = brickset
+        self.minifigure = minifigure
+
+        # Ingest the record if it has one
+        if record is not None:
+            self.ingest(record)
+
+    # Delete missing part
+    def delete_missing(self, /) -> None:
+        BrickSQL().execute_and_commit(
+            'missing/delete/from_set',
+            parameters=self.sql_parameters()
+        )
+
+    # Set missing part
+    def set_missing(self, quantity: int, /) -> None:
+        parameters = self.sql_parameters()
+        parameters['quantity'] = quantity
+
+        # Can't use UPSERT because the database has no keys
+        # Try to update
+        database = BrickSQL()
+        rows, _ = database.execute(
+            'missing/update/from_set',
+            parameters=parameters,
+        )
+
+        # Insert if no row has been affected
+        if not rows:
+            rows, _ = database.execute(
+                'missing/insert',
+                parameters=parameters,
+            )
+
+            if rows != 1:
+                raise DatabaseException(
+                    'Could not update the missing quantity for part {id}'.format(  # noqa: E501
+                        id=self.fields.id
+                    )
+                )
+
+        database.commit()
+
+    # Select a generic part
+    def select_generic(
+        self,
+        part_num: str,
+        color_id: int,
+        /,
+        element_id: int | None = None
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.part_num = part_num
+        self.fields.color_id = color_id
+        self.fields.element_id = element_id
+
+        record = self.select(override_query=self.generic_query)
+
+        if record is None:
+            raise NotFoundException(
+                'Part with number {number}, color ID {color} and element ID {element} was not found in the database'.format(  # noqa: E501
+                    number=self.fields.part_num,
+                    color=self.fields.color_id,
+                    element=self.fields.element_id,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        return self
+
+    # Select a specific part (with a set and an id, and option. a minifigure)
+    def select_specific(
+        self,
+        brickset: 'BrickSet',
+        id: str,
+        /,
+        minifigure: 'BrickMinifigure | None' = None,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.brickset = brickset
+        self.minifigure = minifigure
+        self.fields.id = id
+
+        record = self.select()
+
+        if record is None:
+            raise NotFoundException(
+                'Part with ID {id} from set {set} was not found in the database'.format(  # noqa: E501
+                    id=self.fields.id,
+                    set=self.brickset.fields.set_num,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        return self
+
+    # Return a dict with common SQL parameters for a part
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters = super().sql_parameters()
+
+        # Supplement from the brickset
+        if 'u_id' not in parameters and self.brickset is not None:
+            parameters['u_id'] = self.brickset.fields.u_id
+
+        if 'set_num' not in parameters:
+            if self.minifigure is not None:
+                parameters['set_num'] = self.minifigure.fields.fig_num
+
+            elif self.brickset is not None:
+                parameters['set_num'] = self.brickset.fields.set_num
+
+        return parameters
+
+    # Update the missing part
+    def update_missing(self, missing: Any, /) -> None:
+        # If empty, delete it
+        if missing == '':
+            self.delete_missing()
+
+        else:
+            # Try to understand it as a number
+            try:
+                missing = int(missing)
+            except Exception:
+                raise ErrorException('"{missing}" is not a valid integer'.format(  # noqa: E501
+                    missing=missing
+                ))
+
+            # If 0, delete it
+            if missing == 0:
+                self.delete_missing()
+
+            else:
+                # If negative, it's an error
+                if missing < 0:
+                    raise ErrorException('Cannot set a negative missing value')
+
+                # Otherwise upsert it
+                # Not checking if it is too much, you do you
+                self.set_missing(missing)
+
+    # Self url
+    def url(self, /) -> str:
+        return url_for(
+            'part.details',
+            number=self.fields.part_num,
+            color=self.fields.color_id,
+            element=self.fields.element_id,
+        )
+
+    # Compute the url for the bricklink page
+    def url_for_bricklink(self, /) -> str:
+        if current_app.config['BRICKLINK_LINKS'].value:
+            try:
+                return current_app.config['BRICKLINK_LINK_PART_PATTERN'].value.format(  # noqa: E501
+                    number=self.fields.part_num.lower(),
+                )
+            except Exception:
+                pass
+
+        return ''
+
+    # Compute the url for the part image
+    def url_for_image(self, /) -> str:
+        if not current_app.config['USE_REMOTE_IMAGES'].value:
+            if self.fields.part_img_url is None:
+                file = RebrickableImage.nil_name()
+            else:
+                file = self.fields.part_img_url_id
+
+            folder: str = current_app.config['PARTS_FOLDER'].value
+
+            # /!\ Everything is saved as .jpg, even if it came from a .png
+            # not changing this behaviour.
+
+            # Grab the extension
+            # _, extension = os.path.splitext(self.part_img_url)
+            extension = '.jpg'
+
+            # Compute the path
+            path = os.path.join(folder, '{number}{ext}'.format(
+                number=file,
+                ext=extension,
+            ))
+
+            return url_for('static', filename=path)
+
+        else:
+            if self.fields.part_img_url is None:
+                return current_app.config['REBRICKABLE_IMAGE_NIL'].value
+            else:
+                return self.fields.part_img_url
+
+    # Compute the url for missing part
+    def url_for_missing(self, /) -> str:
+        # Different URL for a minifigure part
+        if self.minifigure is not None:
+            return url_for(
+                'set.missing_minifigure_part',
+                id=self.fields.u_id,
+                minifigure_id=self.minifigure.fields.fig_num,
+                part_id=self.fields.id,
+            )
+
+        return url_for(
+            'set.missing_part',
+            id=self.fields.u_id,
+            part_id=self.fields.id
+        )
+
+    # Compute the url for the rebrickable page
+    def url_for_rebrickable(self, /) -> str:
+        if current_app.config['REBRICKABLE_LINKS'].value:
+            try:
+                return current_app.config['REBRICKABLE_LINK_PART_PATTERN'].value.format(  # noqa: E501
+                    number=self.fields.part_num.lower(),
+                    color=self.fields.color_id,
+                )
+            except Exception:
+                pass
+
+        return ''
+
+    # Normalize from Rebrickable
+    @staticmethod
+    def from_rebrickable(
+        data: dict[str, Any],
+        /,
+        brickset: 'BrickSet | None' = None,
+        minifigure: 'BrickMinifigure | None' = None,
+        **_,
+    ) -> dict[str, Any]:
+        record = {
+            'set_num': data['set_num'],
+            'id': data['id'],
+            'part_num': data['part']['part_num'],
+            'name': data['part']['name'],
+            'part_img_url': data['part']['part_img_url'],
+            'part_img_url_id': None,
+            'color_id': data['color']['id'],
+            'color_name': data['color']['name'],
+            'quantity': data['quantity'],
+            'is_spare': data['is_spare'],
+            'element_id': data['element_id'],
+        }
+
+        if brickset is not None:
+            record['u_id'] = brickset.fields.u_id
+
+        if minifigure is not None:
+            record['set_num'] = data['fig_num']
+
+        # Extract the file name
+        if data['part']['part_img_url'] is not None:
+            part_img_url_file = os.path.basename(
+                urlparse(data['part']['part_img_url']).path
+            )
+
+            part_img_url_id, _ = os.path.splitext(part_img_url_file)
+
+            if part_img_url_id is not None or part_img_url_id != '':
+                record['part_img_url_id'] = part_img_url_id
+
+        return record

bricktracker/part_list.py

@@ -0,0 +1,130 @@
+from typing import Any, Self, TYPE_CHECKING
+
+from flask import current_app
+
+from .part import BrickPart
+from .record_list import BrickRecordList
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .set import BrickSet
+
+
+# Lego set or minifig parts
+class BrickPartList(BrickRecordList[BrickPart]):
+    brickset: 'BrickSet | None'
+    minifigure: 'BrickMinifigure | None'
+
+    # Queries
+    all_query: str = 'part/list/all'
+    last_query: str = 'part/list/last'
+    minifigure_query: str = 'part/list/from_minifigure'
+    missing_query: str = 'part/list/missing'
+    select_query: str = 'part/list/from_set'
+
+    def __init__(self, /):
+        super().__init__()
+
+        # Placeholders
+        self.brickset = None
+        self.minifigure = None
+
+    # Load all parts
+    def all(self, /) -> Self:
+        for record in self.select(
+            override_query=self.all_query,
+            order=current_app.config['PARTS_DEFAULT_ORDER'].value
+        ):
+            part = BrickPart(record=record)
+
+            self.records.append(part)
+
+        return self
+
+    # Load parts from a brickset or minifigure
+    def load(
+        self,
+        brickset: 'BrickSet',
+        /,
+        minifigure: 'BrickMinifigure | None' = None,
+    ) -> Self:
+        # Save the brickset and minifigure
+        self.brickset = brickset
+        self.minifigure = minifigure
+
+        # Load the parts from the database
+        for record in self.select(
+            order=current_app.config['PARTS_DEFAULT_ORDER'].value
+        ):
+            part = BrickPart(
+                brickset=self.brickset,
+                minifigure=minifigure,
+                record=record,
+            )
+
+            if (
+                current_app.config['SKIP_SPARE_PARTS'].value and
+                part.fields.is_spare
+            ):
+                continue
+
+            self.records.append(part)
+
+        return self
+
+    # Load generic parts from a minifigure
+    def from_minifigure(
+        self,
+        minifigure: 'BrickMinifigure',
+        /,
+    ) -> Self:
+        # Save the  minifigure
+        self.minifigure = minifigure
+
+        # Load the parts from the database
+        for record in self.select(
+            override_query=self.minifigure_query,
+            order=current_app.config['PARTS_DEFAULT_ORDER'].value
+        ):
+            part = BrickPart(
+                minifigure=minifigure,
+                record=record,
+            )
+
+            if (
+                current_app.config['SKIP_SPARE_PARTS'].value and
+                part.fields.is_spare
+            ):
+                continue
+
+            self.records.append(part)
+
+        return self
+
+    # Load missing parts
+    def missing(self, /) -> Self:
+        for record in self.select(
+            override_query=self.missing_query,
+            order=current_app.config['PARTS_DEFAULT_ORDER'].value
+        ):
+            part = BrickPart(record=record)
+
+            self.records.append(part)
+
+        return self
+
+    # Return a dict with common SQL parameters for a parts list
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters: dict[str, Any] = {}
+
+        # Set id
+        if self.brickset is not None:
+            parameters['u_id'] = self.brickset.fields.u_id
+
+        # Use the minifigure number if present,
+        # otherwise use the set number
+        if self.minifigure is not None:
+            parameters['set_num'] = self.minifigure.fields.fig_num
+        elif self.brickset is not None:
+            parameters['set_num'] = self.brickset.fields.set_num
+
+        return parameters

bricktracker/rebrickable.py

@@ -0,0 +1,156 @@
+import json
+from typing import Any, Callable, Generic, Type, TypeVar, TYPE_CHECKING
+from urllib.error import HTTPError
+
+from flask import current_app
+from rebrick import lego
+
+from .exceptions import NotFoundException, ErrorException
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .part import BrickPart
+    from .set import BrickSet
+    from .socket import BrickSocket
+    from .wish import BrickWish
+
+T = TypeVar('T', 'BrickSet', 'BrickPart', 'BrickMinifigure', 'BrickWish')
+
+
+# An helper around the rebrick library, autoconverting
+class Rebrickable(Generic[T]):
+    method: Callable
+    method_name: str
+    number: str
+    model: Type[T]
+
+    socket: 'BrickSocket | None'
+    brickset: 'BrickSet | None'
+    minifigure: 'BrickMinifigure | None'
+    kind: str
+
+    def __init__(
+        self,
+        method: str,
+        number: str,
+        model: Type[T],
+        /,
+        socket: 'BrickSocket | None' = None,
+        brickset: 'BrickSet | None' = None,
+        minifigure: 'BrickMinifigure | None' = None
+    ):
+        if not hasattr(lego, method):
+            raise ErrorException('{method} is not a valid method for the rebrick.lego module'.format(  # noqa: E501
+                method=method,
+            ))
+
+        self.method = getattr(lego, method)
+        self.method_name = method
+        self.number = number
+        self.model = model
+
+        self.socket = socket
+        self.brickset = brickset
+        self.minifigure = minifigure
+
+        if self.minifigure is not None:
+            self.kind = 'Minifigure'
+        else:
+            self.kind = 'Set'
+
+    # Get one element from the Rebrickable API
+    def get(self, /) -> T:
+        model_parameters = self.model_parameters()
+
+        return self.model(
+            **model_parameters,
+            record=self.model.from_rebrickable(
+                self.load(),
+                brickset=self.brickset,
+            ),
+        )
+
+    # Get paginated elements from the Rebrickable API
+    def list(self, /) -> list[T]:
+        model_parameters = self.model_parameters()
+
+        results: list[T] = []
+
+        # Bootstrap a first set of parameters
+        parameters: dict[str, Any] | None = {
+            'page_size': current_app.config['REBRICKABLE_PAGE_SIZE'].value,
+        }
+
+        # Read all pages
+        while parameters is not None:
+            response = self.load(parameters=parameters)
+
+            # Grab the results
+            if 'results' not in response:
+                raise ErrorException('Missing "results" field from {method} for {number}'.format(  # noqa: E501
+                    method=self.method_name,
+                    number=self.number,
+                ))
+
+            # Update the total
+            if self.socket is not None:
+                self.socket.total_progress(len(response['results']), add=True)
+
+            # Convert to object
+            for result in response['results']:
+                results.append(
+                    self.model(
+                        **model_parameters,
+                        record=self.model.from_rebrickable(result),
+                    )
+                )
+
+            # Check for a next page
+            if 'next' in response and response['next'] is not None:
+                parameters['page'] = response['next']
+            else:
+                parameters = None
+
+        return results
+
+    # Load from the API
+    def load(self, /, parameters: dict[str, Any] = {}) -> dict[str, Any]:
+        # Inject the API key
+        parameters['api_key'] = current_app.config['REBRICKABLE_API_KEY'].value,  # noqa: E501
+
+        try:
+            return json.loads(
+                self.method(
+                    self.number,
+                    **parameters,
+                ).read()
+            )
+
+        # HTTP errors
+        except HTTPError as e:
+            # Not found
+            if e.code == 404:
+                raise NotFoundException('{kind} {number} was not found on Rebrickable'.format(  # noqa: E501
+                    kind=self.kind,
+                    number=self.number,
+                ))
+            else:
+                # Re-raise as ErrorException
+                raise ErrorException(e)
+
+        # Other errors
+        except Exception as e:
+            # Re-raise as ErrorException
+            raise ErrorException(e)
+
+    # Get the model parameters
+    def model_parameters(self, /) -> dict[str, Any]:
+        parameters: dict[str, Any] = {}
+
+        # Overload with objects
+        if self.brickset is not None:
+            parameters['brickset'] = self.brickset
+
+        if self.minifigure is not None:
+            parameters['minifigure'] = self.minifigure
+
+        return parameters

bricktracker/rebrickable_image.py

@@ -0,0 +1,140 @@
+import os
+from typing import TYPE_CHECKING
+from urllib.parse import urlparse
+
+from flask import current_app
+import requests
+from shutil import copyfileobj
+
+from .exceptions import DownloadException
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .part import BrickPart
+    from .set import BrickSet
+
+
+# A set, part or minifigure image from Rebrickable
+class RebrickableImage(object):
+    brickset: 'BrickSet'
+    minifigure: 'BrickMinifigure | None'
+    part: 'BrickPart | None'
+
+    extension: str | None
+
+    def __init__(
+        self,
+        brickset: 'BrickSet',
+        /,
+        minifigure: 'BrickMinifigure | None' = None,
+        part: 'BrickPart | None' = None,
+    ):
+        # Save all objects
+        self.brickset = brickset
+        self.minifigure = minifigure
+        self.part = part
+
+        # Currently everything is saved as 'jpg'
+        self.extension = 'jpg'
+
+        # Guess the extension
+        # url = self.url()
+        # if url is not None:
+        #     _, extension = os.path.splitext(url)
+        #     # TODO: Add allowed extensions
+        #     if extension != '':
+        #         self.extension = extension
+
+    # Import the image from Rebrickable
+    def download(self, /) -> None:
+        path = self.path()
+
+        # Avoid doing anything if the file exists
+        if os.path.exists(path):
+            return
+
+        url = self.url()
+        if url is None:
+            return
+
+        # Grab the image
+        response = requests.get(url, stream=True)
+        if response.ok:
+            with open(path, 'wb') as f:
+                copyfileobj(response.raw, f)
+        else:
+            raise DownloadException('could not get image {id} at {url}'.format(
+                id=self.id(),
+                url=url,
+            ))
+
+    # Return the folder depending on the objects provided
+    def folder(self, /) -> str:
+        if self.part is not None:
+            return current_app.config['PARTS_FOLDER'].value
+
+        if self.minifigure is not None:
+            return current_app.config['MINIFIGURES_FOLDER'].value
+
+        return current_app.config['SETS_FOLDER'].value
+
+    # Return the id depending on the objects provided
+    def id(self, /) -> str:
+        if self.part is not None:
+            if self.part.fields.part_img_url_id is None:
+                return RebrickableImage.nil_name()
+            else:
+                return self.part.fields.part_img_url_id
+
+        if self.minifigure is not None:
+            if self.minifigure.fields.set_img_url is None:
+                return RebrickableImage.nil_minifigure_name()
+            else:
+                return self.minifigure.fields.fig_num
+
+        return self.brickset.fields.set_num
+
+    # Return the path depending on the objects provided
+    def path(self, /) -> str:
+        return os.path.join(
+            current_app.static_folder,  # type: ignore
+            self.folder(),
+            '{id}.{ext}'.format(id=self.id(), ext=self.extension),
+        )
+
+    # Return the url depending on the objects provided
+    def url(self, /) -> str:
+        if self.part is not None:
+            if self.part.fields.part_img_url is None:
+                return current_app.config['REBRICKABLE_IMAGE_NIL'].value
+            else:
+                return self.part.fields.part_img_url
+
+        if self.minifigure is not None:
+            if self.minifigure.fields.set_img_url is None:
+                return current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE'].value  # noqa: E501
+            else:
+                return self.minifigure.fields.set_img_url
+
+        return self.brickset.fields.set_img_url
+
+    # Return the name of the nil image file
+    @staticmethod
+    def nil_name() -> str:
+        filename, _ = os.path.splitext(
+            os.path.basename(
+                urlparse(current_app.config['REBRICKABLE_IMAGE_NIL'].value).path  # noqa: E501
+            )
+        )
+
+        return filename
+
+    # Return the name of the nil minifigure image file
+    @staticmethod
+    def nil_minifigure_name() -> str:
+        filename, _ = os.path.splitext(
+            os.path.basename(
+                urlparse(current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE'].value).path  # noqa: E501
+            )
+        )
+
+        return filename

bricktracker/rebrickable_minifigures.py

@@ -0,0 +1,85 @@
+import logging
+from typing import TYPE_CHECKING
+
+from flask import current_app
+
+from .minifigure import BrickMinifigure
+from .rebrickable import Rebrickable
+from .rebrickable_image import RebrickableImage
+from .rebrickable_parts import RebrickableParts
+if TYPE_CHECKING:
+    from .set import BrickSet
+    from .socket import BrickSocket
+
+logger = logging.getLogger(__name__)
+
+
+# Minifigures from Rebrickable
+class RebrickableMinifigures(object):
+    socket: 'BrickSocket'
+    brickset: 'BrickSet'
+
+    def __init__(self, socket: 'BrickSocket', brickset: 'BrickSet', /):
+        # Save the socket
+        self.socket = socket
+
+        # Save the objects
+        self.brickset = brickset
+
+    # Import the minifigures from Rebrickable
+    def download(self, /) -> None:
+        self.socket.auto_progress(
+            message='Set {number}: loading minifigures from Rebrickable'.format(  # noqa: E501
+                number=self.brickset.fields.set_num,
+            ),
+            increment_total=True,
+        )
+
+        logger.debug('rebrick.lego.get_set_minifigs("{set_num}")'.format(
+            set_num=self.brickset.fields.set_num,
+        ))
+
+        minifigures = Rebrickable[BrickMinifigure](
+            'get_set_minifigs',
+            self.brickset.fields.set_num,
+            BrickMinifigure,
+            socket=self.socket,
+            brickset=self.brickset,
+        ).list()
+
+        # Process each minifigure
+        total = len(minifigures)
+        for index, minifigure in enumerate(minifigures):
+            # Insert into the database
+            self.socket.auto_progress(
+                message='Set {number}: inserting minifigure {current}/{total} into database'.format(  # noqa: E501
+                    number=self.brickset.fields.set_num,
+                    current=index+1,
+                    total=total,
+                )
+            )
+
+            # Insert into database
+            minifigure.insert(commit=False)
+
+            # Grab the image
+            self.socket.progress(
+                message='Set {number}: downloading minifigure {current}/{total} image'.format(  # noqa: E501
+                    number=self.brickset.fields.set_num,
+                    current=index+1,
+                    total=total,
+                )
+            )
+
+            if not current_app.config['USE_REMOTE_IMAGES'].value:
+                RebrickableImage(
+                    self.brickset,
+                    minifigure=minifigure
+                ).download()
+
+            # Load the inventory
+            RebrickableParts(
+                self.socket,
+                self.brickset,
+                minifigure=minifigure,
+            ).download()

bricktracker/rebrickable_parts.py

@@ -0,0 +1,112 @@
+import logging
+from typing import TYPE_CHECKING
+
+from flask import current_app
+
+from .part import BrickPart
+from .rebrickable import Rebrickable
+from .rebrickable_image import RebrickableImage
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .set import BrickSet
+    from .socket import BrickSocket
+
+logger = logging.getLogger(__name__)
+
+
+# A list of parts from Rebrickable
+class RebrickableParts(object):
+    socket: 'BrickSocket'
+    brickset: 'BrickSet'
+    minifigure: 'BrickMinifigure | None'
+
+    number: str
+    kind: str
+    method: str
+
+    def __init__(
+        self,
+        socket: 'BrickSocket',
+        brickset: 'BrickSet',
+        /,
+        minifigure: 'BrickMinifigure | None' = None,
+    ):
+        # Save the socket
+        self.socket = socket
+
+        # Save the objects
+        self.brickset = brickset
+        self.minifigure = minifigure
+
+        if self.minifigure is not None:
+            self.number = self.minifigure.fields.fig_num
+            self.kind = 'Minifigure'
+            self.method = 'get_minifig_elements'
+        else:
+            self.number = self.brickset.fields.set_num
+            self.kind = 'Set'
+            self.method = 'get_set_elements'
+
+    # Import the parts from Rebrickable
+    def download(self, /) -> None:
+        self.socket.auto_progress(
+            message='{kind} {number}: loading parts inventory from Rebrickable'.format(  # noqa: E501
+                kind=self.kind,
+                number=self.number,
+            ),
+            increment_total=True,
+        )
+
+        logger.debug('rebrick.lego.{method}("{number}")'.format(
+            method=self.method,
+            number=self.number,
+        ))
+
+        inventory = Rebrickable[BrickPart](
+            self.method,
+            self.number,
+            BrickPart,
+            socket=self.socket,
+            brickset=self.brickset,
+            minifigure=self.minifigure,
+        ).list()
+
+        # Process each part
+        total = len(inventory)
+        for index, part in enumerate(inventory):
+            # Skip spare parts
+            if (
+                current_app.config['SKIP_SPARE_PARTS'].value and
+                part.fields.is_spare
+            ):
+                continue
+
+            # Insert into the database
+            self.socket.auto_progress(
+                message='{kind} {number}: inserting part {current}/{total} into database'.format(  # noqa: E501
+                    kind=self.kind,
+                    number=self.number,
+                    current=index+1,
+                    total=total,
+                )
+            )
+
+            # Insert into database
+            part.insert(commit=False)
+
+            # Grab the image
+            self.socket.progress(
+                message='{kind} {number}: downloading part {current}/{total} image'.format(  # noqa: E501
+                    kind=self.kind,
+                    number=self.number,
+                    current=index+1,
+                    total=total,
+                )
+            )
+
+            if not current_app.config['USE_REMOTE_IMAGES'].value:
+                RebrickableImage(
+                    self.brickset,
+                    minifigure=self.minifigure,
+                    part=part,
+                ).download()

bricktracker/rebrickable_set.py

@@ -0,0 +1,214 @@
+import logging
+import traceback
+from typing import Any, TYPE_CHECKING
+from uuid import uuid4
+
+from flask import current_app
+
+from .exceptions import ErrorException, NotFoundException
+from .rebrickable import Rebrickable
+from .rebrickable_image import RebrickableImage
+from .rebrickable_minifigures import RebrickableMinifigures
+from .rebrickable_parts import RebrickableParts
+from .set import BrickSet
+from .sql import BrickSQL
+from .wish import BrickWish
+if TYPE_CHECKING:
+    from .socket import BrickSocket
+
+logger = logging.getLogger(__name__)
+
+
+# A set from Rebrickable
+class RebrickableSet(object):
+    socket: 'BrickSocket'
+
+    def __init__(self, socket: 'BrickSocket', /):
+        # Save the socket
+        self.socket = socket
+
+    # Import the set from Rebrickable
+    def download(self, data: dict[str, Any], /) -> None:
+        # Reset the progress
+        self.socket.progress_count = 0
+        self.socket.progress_total = 0
+
+        # Load the set
+        brickset = self.load(data, from_download=True)
+
+        # None brickset means loading failed
+        if brickset is None:
+            return
+
+        try:
+            # Insert into the database
+            self.socket.auto_progress(
+                message='Set {number}: inserting into database'.format(
+                    number=brickset.fields.set_num
+                ),
+                increment_total=True,
+            )
+
+            # Assign a unique ID to the set
+            brickset.fields.u_id = str(uuid4())
+
+            # Insert into database
+            brickset.insert(commit=False)
+
+            if not current_app.config['USE_REMOTE_IMAGES'].value:
+                RebrickableImage(brickset).download()
+
+            # Load the inventory
+            RebrickableParts(self.socket, brickset).download()
+
+            # Load the minifigures
+            RebrickableMinifigures(self.socket, brickset).download()
+
+            # Commit the transaction to the database
+            self.socket.auto_progress(
+                message='Set {number}: writing to the database'.format(
+                    number=brickset.fields.set_num
+                ),
+                increment_total=True,
+            )
+
+            BrickSQL().commit()
+
+            # Info
+            logger.info('Set {number}: imported (id: {id})'.format(
+                number=brickset.fields.set_num,
+                id=brickset.fields.u_id,
+            ))
+
+            # Complete
+            self.socket.complete(
+                message='Set {number}: imported (<a href="{url}">Go to the set</a>)'.format(  # noqa: E501
+                    number=brickset.fields.set_num,
+                    url=brickset.url()
+                ),
+                download=True
+            )
+
+        except Exception as e:
+            self.socket.fail(
+                message='Error while importing set {number}: {error}'.format(
+                    number=brickset.fields.set_num,
+                    error=e,
+                )
+            )
+
+            logger.debug(traceback.format_exc())
+
+    # Load the set from Rebrickable
+    def load(
+        self,
+        data: dict[str, Any],
+        /,
+        from_download=False,
+    ) -> BrickSet | None:
+        # Reset the progress
+        self.socket.progress_count = 0
+        self.socket.progress_total = 2
+
+        try:
+            self.socket.auto_progress(message='Parsing set number')
+            set_num = RebrickableSet.parse_number(str(data['set_num']))
+
+            self.socket.auto_progress(
+                message='Set {num}: loading from Rebrickable'.format(
+                    num=set_num,
+                ),
+            )
+
+            logger.debug('rebrick.lego.get_set("{set_num}")'.format(
+                set_num=set_num,
+            ))
+
+            brickset = Rebrickable[BrickSet](
+                'get_set',
+                set_num,
+                BrickSet,
+            ).get()
+
+            short = brickset.short()
+            short['download'] = from_download
+
+            self.socket.emit('SET_LOADED', short)
+
+            if not from_download:
+                self.socket.complete(
+                    message='Set {num}: loaded from Rebrickable'.format(
+                        num=brickset.fields.set_num
+                    )
+                )
+
+            return brickset
+        except Exception as e:
+            self.socket.fail(
+                message='Could not load the set from Rebrickable: {error}. Data: {data}'.format(  # noqa: E501
+                    error=str(e),
+                    data=data,
+                )
+            )
+
+            if not isinstance(e, (NotFoundException, ErrorException)):
+                logger.debug(traceback.format_exc())
+
+        return None
+
+    # Make sense of the number from the data
+    @staticmethod
+    def parse_number(set_num: str, /) -> str:
+        number, _, version = set_num.partition('-')
+
+        # Making sure both are integers
+        if version == '':
+            version = 1
+
+        try:
+            number = int(number)
+        except Exception:
+            raise ErrorException('Number "{number}" is not a number'.format(
+                number=number,
+            ))
+
+        try:
+            version = int(version)
+        except Exception:
+            raise ErrorException('Version "{version}" is not a number'.format(
+                version=version,
+            ))
+
+        # Make sure both are positive
+        if number < 0:
+            raise ErrorException('Number "{number}" should be positive'.format(
+                number=number,
+            ))
+
+        if version < 0:
+            raise ErrorException('Version "{version}" should be positive'.format(  # noqa: E501
+                version=version,
+            ))
+
+        return '{number}-{version}'.format(number=number, version=version)
+
+    # Wish from Rebrickable
+    # Redefine this one outside of the socket logic
+    @staticmethod
+    def wish(set_num: str) -> None:
+        set_num = RebrickableSet.parse_number(set_num)
+        logger.debug('rebrick.lego.get_set("{set_num}")'.format(
+            set_num=set_num,
+        ))
+
+        brickwish = Rebrickable[BrickWish](
+            'get_set',
+            set_num,
+            BrickWish,
+        ).get()
+
+        # Insert into database
+        brickwish.insert()
+
+        if not current_app.config['USE_REMOTE_IMAGES'].value:
+            RebrickableImage(brickwish).download()

bricktracker/record.py

@@ -0,0 +1,60 @@
+from sqlite3 import Row
+from typing import Any, ItemsView
+
+from .fields import BrickRecordFields
+from .sql import BrickSQL
+
+
+# SQLite record
+class BrickRecord(object):
+    select_query: str
+    insert_query: str
+
+    # Fields
+    fields: BrickRecordFields
+
+    def __init__(self, /):
+        self.fields = BrickRecordFields()
+
+    # Load from a record
+    def ingest(self, record: Row | dict[str, Any], /) -> None:
+        # Brutally ingest the record
+        for key in record.keys():
+            setattr(self.fields, key, record[key])
+
+    # Insert into the database
+    # If we do not commit immediately, we defer the execute() call
+    def insert(self, /, commit=True) -> None:
+        database = BrickSQL()
+        rows, q = database.execute(
+            self.insert_query,
+            parameters=self.sql_parameters(),
+            defer=not commit,
+        )
+
+        if commit:
+            database.commit()
+
+    # Shorthand to field items
+    def items(self, /) -> ItemsView[str, Any]:
+        return self.fields.__dict__.items()
+
+    # Get from the database using the query
+    def select(self, /, override_query: str | None = None) -> Row | None:
+        if override_query:
+            query = override_query
+        else:
+            query = self.select_query
+
+        return BrickSQL().fetchone(
+            query,
+            parameters=self.sql_parameters()
+        )
+
+    # Generic SQL parameters from fields
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters: dict[str, Any] = {}
+        for name, value in self.items():
+            parameters[name] = value
+
+        return parameters

bricktracker/record_list.py

@@ -0,0 +1,67 @@
+from sqlite3 import Row
+from typing import Any, Generator, Generic, ItemsView, TypeVar, TYPE_CHECKING
+
+from .fields import BrickRecordFields
+from .sql import BrickSQL
+if TYPE_CHECKING:
+    from .minifigure import BrickMinifigure
+    from .part import BrickPart
+    from .set import BrickSet
+    from .wish import BrickWish
+
+T = TypeVar('T', 'BrickSet', 'BrickPart', 'BrickMinifigure', 'BrickWish')
+
+
+# SQLite records
+class BrickRecordList(Generic[T]):
+    select_query: str
+    records: list[T]
+
+    # Fields
+    fields: BrickRecordFields
+
+    def __init__(self, /):
+        self.fields = BrickRecordFields()
+        self.records = []
+
+    # Shorthand to field items
+    def items(self, /) -> ItemsView[str, Any]:
+        return self.fields.__dict__.items()
+
+    # Get all from the database
+    def select(
+        self,
+        /,
+        override_query: str | None = None,
+        order: str | None = None,
+        limit: int | None = None,
+    ) -> list[Row]:
+        # Select the query
+        if override_query:
+            query = override_query
+        else:
+            query = self.select_query
+
+        return BrickSQL().fetchall(
+            query,
+            parameters=self.sql_parameters(),
+            order=order,
+            limit=limit,
+        )
+
+    # Generic SQL parameters from fields
+    def sql_parameters(self, /) -> dict[str, Any]:
+        parameters: dict[str, Any] = {}
+        for name, value in self.items():
+            parameters[name] = value
+
+        return parameters
+
+    # Make the list iterable
+    def __iter__(self, /) -> Generator[T, Any, Any]:
+        for record in self.records:
+            yield record
+
+    # Make the sets measurable
+    def __len__(self, /) -> int:
+        return len(self.records)

bricktracker/retired.py

@@ -0,0 +1,28 @@
+# Lego retired set
+class BrickRetired(object):
+    theme: str
+    subtheme: str
+    number: str
+    name: str
+    age: str
+    piece_count: str
+    retirement_date: str
+
+    def __init__(
+        self,
+        theme: str,
+        subtheme: str,
+        number: str,
+        name: str,
+        age: str,
+        piece_count: str,
+        retirement_date: str,
+        *_,
+    ):
+        self.theme = theme
+        self.subtheme = subtheme
+        self.number = number
+        self.name = name
+        self.age = age
+        self.piece_count = piece_count
+        self.retirement_date = retirement_date

bricktracker/retired_list.py

@@ -0,0 +1,105 @@
+from datetime import datetime, timezone
+import csv
+import gzip
+import logging
+import os
+from shutil import copyfileobj
+
+from flask import current_app, g
+import humanize
+import requests
+
+from .exceptions import ErrorException
+from .retired import BrickRetired
+
+logger = logging.getLogger(__name__)
+
+
+# Lego retired sets
+class BrickRetiredList(object):
+    retired: dict[str, BrickRetired]
+    mtime: datetime | None
+    size: int | None
+    exception: Exception | None
+
+    def __init__(self, /, force: bool = False):
+        # Load sets only if there is none already loaded
+        retired = getattr(self, 'retired', None)
+
+        if retired is None or force:
+            logger.info('Loading retired sets list')
+
+            BrickRetiredList.retired = {}
+
+            # Try to read the themes from a CSV file
+            try:
+                with open(current_app.config['RETIRED_SETS_PATH'].value, newline='') as themes_file:  # noqa: E501
+                    themes_reader = csv.reader(themes_file)
+
+                    # Ignore the header
+                    next(themes_reader, None)
+
+                    for row in themes_reader:
+                        retired = BrickRetired(*row)
+                        BrickRetiredList.retired[retired.number] = retired
+
+                # File stats
+                stat = os.stat(current_app.config['RETIRED_SETS_PATH'].value)
+                BrickRetiredList.size = stat.st_size
+                BrickRetiredList.mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)  # noqa: E501
+
+                BrickRetiredList.exception = None
+
+            # Ignore errors
+            except Exception as e:
+                BrickRetiredList.exception = e
+                BrickRetiredList.size = None
+                BrickRetiredList.mtime = None
+
+    # Get a retirement date for a set
+    def get(self, number: str, /) -> str:
+        if number in self.retired:
+            return self.retired[number].retirement_date
+        else:
+            number, _, _ = number.partition('-')
+
+            if number in self.retired:
+                return self.retired[number].retirement_date
+            else:
+                return ''
+
+    # Display the size in a human format
+    def human_size(self) -> str:
+        if self.size is not None:
+            return humanize.naturalsize(self.size)
+        else:
+            return ''
+
+    # Display the time in a human format
+    def human_time(self) -> str:
+        if self.mtime is not None:
+            return self.mtime.astimezone(g.timezone).strftime(
+                current_app.config['FILE_DATETIME_FORMAT'].value
+            )
+        else:
+            return ''
+
+    # Update the file
+    @staticmethod
+    def update() -> None:
+        response = requests.get(
+            current_app.config['RETIRED_SETS_FILE_URL'].value,
+            stream=True,
+        )
+
+        if not response.ok:
+            raise ErrorException('An error occured while downloading the retired sets file ({code})'.format(  # noqa: E501
+                code=response.status_code
+            ))
+
+        content = gzip.GzipFile(fileobj=response.raw)
+
+        with open(current_app.config['RETIRED_SETS_PATH'].value, 'wb') as f:
+            copyfileobj(content, f)
+
+    logger.info('Retired sets list updated')

bricktracker/set.py

@@ -0,0 +1,233 @@
+import os
+from sqlite3 import Row
+from typing import Any, Self
+
+from flask import current_app, url_for
+
+from .exceptions import DatabaseException, NotFoundException
+from .instructions import BrickInstructions
+from .instructions_list import BrickInstructionsList
+from .minifigure_list import BrickMinifigureList
+from .part_list import BrickPartList
+from .record import BrickRecord
+from .sql import BrickSQL
+from .theme_list import BrickThemeList
+
+
+# Lego brick set
+class BrickSet(BrickRecord):
+    instructions: list[BrickInstructions]
+    theme_name: str
+
+    # Queries
+    select_query: str = 'set/select'
+    insert_query: str = 'set/insert'
+
+    def __init__(
+        self,
+        /,
+        record: Row | dict[str, Any] | None = None,
+    ):
+        super().__init__()
+
+        # Placeholders
+        self.theme_name = ''
+        self.instructions = []
+
+        # Ingest the record if it has one
+        if record is not None:
+            self.ingest(record)
+
+            # Resolve the theme
+            self.resolve_theme()
+
+            # Check for the instructions
+            self.resolve_instructions()
+
+    # Delete a set
+    def delete(self, /) -> None:
+        database = BrickSQL()
+        parameters = self.sql_parameters()
+
+        # Delete the set
+        database.execute('set/delete/set', parameters=parameters)
+
+        # Delete the minifigures
+        database.execute(
+            'minifigure/delete/all_from_set', parameters=parameters)
+
+        # Delete the parts
+        database.execute(
+            'part/delete/all_from_set', parameters=parameters)
+
+        # Delete missing parts
+        database.execute('missing/delete/all_from_set', parameters=parameters)
+
+        # Commit to the database
+        database.commit()
+
+    # Minifigures
+    def minifigures(self, /) -> BrickMinifigureList:
+        return BrickMinifigureList().load(self)
+
+    # Parts
+    def parts(self, /) -> BrickPartList:
+        return BrickPartList().load(self)
+
+    # Add instructions to the set
+    def resolve_instructions(self, /) -> None:
+        if self.fields.set_num is not None:
+            self.instructions = BrickInstructionsList().get(
+                self.fields.set_num
+            )
+
+    # Add a theme to the set
+    def resolve_theme(self, /) -> None:
+        try:
+            id = self.fields.theme_id
+        except Exception:
+            id = 0
+
+        theme = BrickThemeList().get(id)
+        self.theme_name = theme.name
+
+    # Return a short form of the set
+    def short(self, /) -> dict[str, Any]:
+        return {
+            'name': self.fields.name,
+            'set_img_url': self.fields.set_img_url,
+            'set_num': self.fields.set_num,
+        }
+
+    # Select a specific part (with a set and an id)
+    def select_specific(self, u_id: str, /) -> Self:
+        # Save the parameters to the fields
+        self.fields.u_id = u_id
+
+        # Load from database
+        record = self.select()
+
+        if record is None:
+            raise NotFoundException(
+                'Set with ID {id} was not found in the database'.format(
+                    id=self.fields.u_id,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        # Resolve the theme
+        self.resolve_theme()
+
+        # Check for the instructions
+        self.resolve_instructions()
+
+        return self
+
+    # Update a checked state
+    def update_checked(self, name: str, status: bool, /) -> None:
+        parameters = self.sql_parameters()
+        parameters['status'] = status
+
+        # Update the checked status
+        rows, _ = BrickSQL().execute_and_commit(
+            'set/update_checked',
+            parameters=parameters,
+            name=name,
+        )
+
+        if rows != 1:
+            raise DatabaseException('Could not update the status {status} for set {number}'.format(  # noqa: E501
+                status=name,
+                number=self.fields.set_num,
+            ))
+
+    # Self url
+    def url(self, /) -> str:
+        return url_for('set.details', id=self.fields.u_id)
+
+    # Deletion url
+    def url_for_delete(self, /) -> str:
+        return url_for('set.delete', id=self.fields.u_id)
+
+    # Actual deletion url
+    def url_for_do_delete(self, /) -> str:
+        return url_for('set.do_delete', id=self.fields.u_id)
+
+    # Compute the url for the set image
+    def url_for_image(self, /) -> str:
+        if not current_app.config['USE_REMOTE_IMAGES'].value:
+            folder: str = current_app.config['SETS_FOLDER'].value
+
+            # /!\ Everything is saved as .jpg, even if it came from a .png
+            # not changing this behaviour.
+
+            # Grab the extension
+            # _, extension = os.path.splitext(self.fields.img_url)
+            extension = '.jpg'
+            # Grab the extension
+            _, extension = os.path.splitext(self.fields.set_img_url)
+
+            # Compute the path
+            path = os.path.join(folder, '{number}{ext}'.format(
+                number=self.fields.set_num,
+                ext=extension,
+            ))
+
+            return url_for('static', filename=path)
+
+        else:
+            return self.fields.set_img_url
+
+    # Compute the url for the set instructions
+    def url_for_instructions(self, /) -> str:
+        if len(self.instructions):
+            return url_for(
+                'set.details',
+                id=self.fields.u_id,
+                open_instructions=True
+            )
+        else:
+            return ''
+
+    # Check minifigure collected url
+    def url_for_minifigures_collected(self, /) -> str:
+        return url_for('set.minifigures_collected', id=self.fields.u_id)
+
+    # Compute the url for the rebrickable page
+    def url_for_rebrickable(self, /) -> str:
+        if current_app.config['REBRICKABLE_LINKS'].value:
+            try:
+                return current_app.config['REBRICKABLE_LINK_SET_PATTERN'].value.format(  # noqa: E501
+                    number=self.fields.set_num.lower(),
+                )
+            except Exception:
+                pass
+
+        return ''
+
+    # Check set checked url
+    def url_for_set_checked(self, /) -> str:
+        return url_for('set.set_checked', id=self.fields.u_id)
+
+    # Check set collected url
+    def url_for_set_collected(self, /) -> str:
+        return url_for('set.set_collected', id=self.fields.u_id)
+
+    # Normalize from Rebrickable
+    @staticmethod
+    def from_rebrickable(data: dict[str, Any], /, **_) -> dict[str, Any]:
+        return {
+            'set_num': data['set_num'],
+            'name': data['name'],
+            'year': data['year'],
+            'theme_id': data['theme_id'],
+            'num_parts': data['num_parts'],
+            'set_img_url': data['set_img_url'],
+            'set_url': data['set_url'],
+            'last_modified_dt': data['last_modified_dt'],
+            'mini_col': False,
+            'set_col': False,
+            'set_check': False,
+        }

bricktracker/set_list.py

@@ -0,0 +1,146 @@
+from typing import Self
+
+from flask import current_app
+
+from .record_list import BrickRecordList
+from .set import BrickSet
+
+
+# All the sets from the database
+class BrickSetList(BrickRecordList[BrickSet]):
+    themes: list[str]
+
+    # Queries
+    generic_query: str = 'set/list/generic'
+    missing_minifigure_query: str = 'set/list/missing_minifigure'
+    missing_part_query: str = 'set/list/missing_part'
+    select_query: str = 'set/list/all'
+    using_minifigure_query: str = 'set/list/using_minifigure'
+    using_part_query: str = 'set/list/using_part'
+
+    def __init__(self, /):
+        super().__init__()
+
+        # Placeholders
+        self.themes = []
+
+    # All the sets
+    def all(self, /) -> Self:
+        themes = set()
+
+        # Load the sets from the database
+        for record in self.select(
+            order=current_app.config['SETS_DEFAULT_ORDER'].value
+        ):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+            themes.add(brickset.theme_name)
+
+        # Convert the set into a list and sort it
+        self.themes = list(themes)
+        self.themes.sort()
+
+        return self
+
+    # A generic list of the different sets
+    def generic(self, /) -> Self:
+        for record in self.select(override_query=self.generic_query):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self
+
+    # Last added sets
+    def last(self, /, limit: int = 6) -> Self:
+        # Randomize
+        if current_app.config['RANDOM'].value:
+            order = 'RANDOM()'
+        else:
+            order = 'sets.rowid DESC'
+
+        for record in self.select(order=order, limit=limit):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self
+
+    # Sets missing a minifigure
+    def missing_minifigure(
+        self,
+        fig_num: str,
+        /,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.fig_num = fig_num
+
+        # Load the sets from the database
+        for record in self.select(
+            override_query=self.missing_minifigure_query
+        ):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self
+
+    # Sets missing a part
+    def missing_part(
+        self,
+        part_num: str,
+        color_id: int,
+        /,
+        element_id: int | None = None,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.part_num = part_num
+        self.fields.color_id = color_id
+        self.fields.element_id = element_id
+
+        # Load the sets from the database
+        for record in self.select(override_query=self.missing_part_query):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self
+
+    # Sets using a minifigure
+    def using_minifigure(
+        self,
+        fig_num: str,
+        /,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.fig_num = fig_num
+
+        # Load the sets from the database
+        for record in self.select(override_query=self.using_minifigure_query):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self
+
+    # Sets using a part
+    def using_part(
+        self,
+        part_num: str,
+        color_id: int,
+        /,
+        element_id: int | None = None,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.fields.part_num = part_num
+        self.fields.color_id = color_id
+        self.fields.element_id = element_id
+
+        # Load the sets from the database
+        for record in self.select(override_query=self.using_part_query):
+            brickset = BrickSet(record=record)
+
+            self.records.append(brickset)
+
+        return self

bricktracker/socket.py

@@ -0,0 +1,231 @@
+import logging
+from typing import Any, Final, Tuple
+
+from flask import copy_current_request_context, Flask, request
+from flask_socketio import SocketIO
+
+from .configuration_list import BrickConfigurationList
+from .login import LoginManager
+from .rebrickable_set import RebrickableSet
+from .sql import close as sql_close
+
+logger = logging.getLogger(__name__)
+
+# Messages valid through the socket
+MESSAGES: Final[dict[str, str]] = {
+    'ADD_SET': 'add_set',
+    'COMPLETE': 'complete',
+    'CONNECT': 'connect',
+    'DISCONNECT': 'disconnect',
+    'FAIL': 'fail',
+    'IMPORT_SET': 'import_set',
+    'LOAD_SET': 'load_set',
+    'PROGRESS': 'progress',
+    'SET_LOADED': 'set_loaded',
+}
+
+
+# Flask socket.io with our extra features
+class BrickSocket(object):
+    app: Flask
+    socket: SocketIO
+    threaded: bool
+
+    # Progress
+    progress_message: str
+    progress_total: int
+    progress_count: int
+
+    def __init__(
+        self,
+        app: Flask,
+        *args,
+        threaded: bool = True,
+        **kwargs
+    ):
+        # Save the app
+        self.app = app
+
+        # Progress
+        self.progress_message = ''
+        self.progress_count = 0
+        self.progress_total = 0
+
+        # Save the threaded flag
+        self.threaded = threaded
+
+        # Compute the namespace
+        self.namespace = '/{namespace}'.format(
+            namespace=app.config['SOCKET_NAMESPACE'].value
+        )
+
+        # Inject CORS if a domain is defined
+        if app.config['DOMAIN_NAME'].value != '':
+            kwargs['cors_allowed_origins'] = app.config['DOMAIN_NAME'].value
+
+        # Instantiate the socket
+        self.socket = SocketIO(
+            self.app,
+            *args,
+            **kwargs,
+            path=app.config['SOCKET_PATH'].value,
+            async_mode='eventlet',
+        )
+
+        # Store the socket in the app config
+        self.app.config['_SOCKET'] = self
+
+        # Setup the socket
+        @self.socket.on(MESSAGES['CONNECT'], namespace=self.namespace)
+        def connect() -> None:
+            self.connected()
+
+        @self.socket.on(MESSAGES['DISCONNECT'], namespace=self.namespace)
+        def disconnect() -> None:
+            self.disconnected()
+
+        @self.socket.on(MESSAGES['IMPORT_SET'], namespace=self.namespace)
+        def import_set(data: dict[str, Any], /) -> None:
+            # Needs to be authenticated
+            if LoginManager.is_not_authenticated():
+                self.fail(message='You need to be authenticated')
+                return
+
+            # Needs the Rebrickable API key
+            try:
+                BrickConfigurationList.error_unless_is_set('REBRICKABLE_API_KEY')  # noqa: E501
+            except Exception as e:
+                self.fail(message=str(e))
+                return
+
+            brickset = RebrickableSet(self)
+
+            # Start it in a thread if requested
+            if self.threaded:
+                @copy_current_request_context
+                def do_download() -> None:
+                    brickset.download(data)
+
+                self.socket.start_background_task(do_download)
+            else:
+                brickset.download(data)
+
+        @self.socket.on(MESSAGES['LOAD_SET'], namespace=self.namespace)
+        def load_set(data: dict[str, Any], /) -> None:
+            # Needs to be authenticated
+            if LoginManager.is_not_authenticated():
+                self.fail(message='You need to be authenticated')
+                return
+
+            # Needs the Rebrickable API key
+            try:
+                BrickConfigurationList.error_unless_is_set('REBRICKABLE_API_KEY')  # noqa: E501
+            except Exception as e:
+                self.fail(message=str(e))
+                return
+
+            brickset = RebrickableSet(self)
+
+            # Start it in a thread if requested
+            if self.threaded:
+                @copy_current_request_context
+                def do_load() -> None:
+                    brickset.load(data)
+
+                self.socket.start_background_task(do_load)
+            else:
+                brickset.load(data)
+
+    # Update the progress auto-incrementing
+    def auto_progress(
+        self,
+        /,
+        message: str | None = None,
+        increment_total=False,
+    ) -> None:
+        # Auto-increment
+        self.progress_count += 1
+
+        if increment_total:
+            self.progress_total += 1
+
+        self.progress(message=message)
+
+    # Send a complete
+    def complete(self, /, **data: Any) -> None:
+        self.emit('COMPLETE', data)
+
+        # Close any dangling connection
+        sql_close()
+
+    # Socket is connected
+    def connected(self, /) -> Tuple[str, int]:
+        logger.debug('Socket: client connected')
+
+        return '', 301
+
+    # Socket is disconnected
+    def disconnected(self, /) -> None:
+        logger.debug('Socket: client disconnected')
+
+    # Emit a message through the socket
+    def emit(self, name: str, *arg, all=False) -> None:
+        # Emit to all sockets
+        if all:
+            to = None
+        else:
+            # Grab the request SID
+            # This keeps message isolated between clients (and tabs!)
+            try:
+                to = request.sid  # type: ignore
+            except Exception:
+                logger.debug('Unable to load request.sid')
+                to = None
+
+            logger.debug('Socket: {name}={args} (to: {to})'.format(
+                name=name,
+                args=arg,
+                to=to,
+            ))
+
+        self.socket.emit(
+            MESSAGES[name],
+            *arg,
+            namespace=self.namespace,
+            to=to,
+        )
+
+    # Send a failed
+    def fail(self, /, **data: Any) -> None:
+        self.emit('FAIL', data)
+
+        # Close any dangling connection
+        sql_close()
+
+    # Update the progress
+    def progress(self, /, message: str | None = None) -> None:
+        # Save the las message
+        if message is not None:
+            self.progress_message = message
+
+        # Prepare data
+        data: dict[str, Any] = {
+            'message': self.progress_message,
+            'count': self.progress_count,
+            'total': self.progress_total,
+        }
+
+        self.emit('PROGRESS', data)
+
+    # Update the progress total only
+    def update_total(self, total: int, /, add: bool = False) -> None:
+        if add:
+            self.progress_total += total
+        else:
+            self.progress_total = total
+
+    # Update the total
+    def total_progress(self, total: int, /, add: bool = False) -> None:
+        self.update_total(total, add=add)
+
+        self.progress()

bricktracker/sql.py

@@ -0,0 +1,316 @@
+import logging
+import os
+import sqlite3
+from typing import Any, Tuple
+
+from .sql_stats import BrickSQLStats
+
+from flask import current_app, g
+from jinja2 import Environment, FileSystemLoader
+from werkzeug.datastructures import FileStorage
+
+logger = logging.getLogger(__name__)
+
+
+# SQLite3 client with our extra features
+class BrickSQL(object):
+    connection: sqlite3.Connection
+    cursor: sqlite3.Cursor
+    stats: BrickSQLStats
+
+    def __init__(self, /):
+        # Instantiate the database connection in the Flask
+        # application context so that it can be used by all
+        # requests without re-opening connections
+        database = getattr(g, 'database', None)
+
+        # Grab the existing connection if it exists
+        if database is not None:
+            self.connection = database
+            self.stats = getattr(g, 'database_stats', BrickSQLStats())
+        else:
+            # Instantiate the stats
+            self.stats = BrickSQLStats()
+
+            # Stats: connect
+            self.stats.connect += 1
+
+            logger.debug('SQLite3: connect')
+            self.connection = sqlite3.connect(
+                current_app.config['DATABASE_PATH'].value
+            )
+
+            # Setup the row factory to get pseudo-dicts rather than tuples
+            self.connection.row_factory = sqlite3.Row
+
+            # Debug: Attach the debugger
+            # Uncomment manually because this is ultra verbose
+            # self.connection.set_trace_callback(print)
+
+            # Save the connection globally for later use
+            g.database = self.connection
+            g.database_stats = self.stats
+
+        # Grab a cursor
+        self.cursor = self.connection.cursor()
+
+    # Clear the defer stack
+    def clear_defer(self, /) -> None:
+        g.database_defer = []
+
+    # Shorthand to commit
+    def commit(self, /) -> None:
+        # Stats: commit
+        self.stats.commit += 1
+
+        # Process the defered stack
+        for item in self.get_defer():
+            self.raw_execute(item[0], item[1])
+
+        self.clear_defer()
+
+        logger.debug('SQLite3: commit')
+        return self.connection.commit()
+
+    # Defer a call to execute
+    def defer(self, query: str, parameters: dict[str, Any], /):
+        defer = self.get_defer()
+
+        logger.debug('SQLite3: defer execute')
+
+        # Add the query and parameters to the defer stack
+        defer.append((query, parameters))
+
+        # Save the defer stack
+        g.database_defer = defer
+
+    # Shorthand to execute, returning number of affected rows
+    def execute(
+        self,
+        query: str,
+        /,
+        parameters: dict[str, Any] = {},
+        defer: bool = False,
+        **context,
+    ) -> Tuple[int, str]:
+        # Stats: execute
+        self.stats.execute += 1
+
+        # Load the query
+        query = self.load_query(query, **context)
+
+        # Defer
+        if defer:
+            self.defer(query, parameters)
+
+            return -1, query
+        else:
+            result = self.raw_execute(query, parameters)
+
+            # Stats: changed
+            if result.rowcount > 0:
+                self.stats.changed += result.rowcount
+
+            return result.rowcount, query
+
+    # Shorthand to executescript
+    def executescript(self, query: str, /, **context) -> None:
+        # Load the query
+        query = self.load_query(query, **context)
+
+        # Stats: executescript
+        self.stats.executescript += 1
+
+        logger.debug('SQLite3: executescript')
+        self.cursor.executescript(query)
+
+    # Shorthand to execute and commit
+    def execute_and_commit(
+        self,
+        query: str,
+        /,
+        parameters: dict[str, Any] = {},
+        **context,
+    ) -> Tuple[int, str]:
+        rows, query = self.execute(query, parameters=parameters, **context)
+        self.commit()
+
+        return rows, query
+
+    # Shorthand to execute and fetchall
+    def fetchall(
+        self,
+        query: str,
+        /,
+        parameters: dict[str, Any] = {},
+        **context,
+    ) -> list[sqlite3.Row]:
+        _, query = self.execute(query, parameters=parameters, **context)
+
+        # Stats: fetchall
+        self.stats.fetchall += 1
+
+        logger.debug('SQLite3: fetchall: {query}'.format(
+            query=BrickSQL.clean_query(query)
+        ))
+        records = self.cursor.fetchall()
+
+        # Stats: fetched
+        self.stats.fetched += len(records)
+
+        return records
+
+    # Shorthand to execute and fetchone
+    def fetchone(
+        self,
+        query: str,
+        /,
+        parameters: dict[str, Any] = {},
+        **context,
+    ) -> sqlite3.Row | None:
+        _, query = self.execute(query, parameters=parameters, **context)
+
+        # Stats: fetchone
+        self.stats.fetchone += 1
+
+        logger.debug('SQLite3: fetchone: {query}'.format(
+            query=BrickSQL.clean_query(query)
+        ))
+        record = self.cursor.fetchone()
+
+        # Stats: fetched
+        if record is not None:
+            self.stats.fetched += len(record)
+
+        return record
+
+    # Grab the defer stack
+    def get_defer(self, /) -> list[Tuple[str, dict[str, Any]]]:
+        defer: list[Tuple[str, dict[str, Any]]] = getattr(
+            g,
+            'database_defer',
+            []
+        )
+
+        return defer
+
+    # Load a query by name
+    def load_query(self, name: str, /, **context) -> str:
+        # Grab the existing environment if it exists
+        environment = getattr(g, 'database_loader', None)
+
+        # Instantiate Jinja environment for SQL files
+        if environment is None:
+            environment = Environment(
+                loader=FileSystemLoader(
+                    os.path.join(os.path.dirname(__file__), 'sql/')
+                )
+            )
+
+            # Save the environment globally for later use
+            g.database_environment = environment
+
+        # Grab the template
+        logger.debug('SQLite: loading {name} (context: {context})'.format(
+            name=name,
+            context=context,
+        ))
+        template = environment.get_template('{name}.sql'.format(
+            name=name,
+        ))
+
+        return template.render(**context)
+
+    # Raw execute the query without any options
+    def raw_execute(
+        self,
+        query: str,
+        parameters: dict[str, Any]
+    ) -> sqlite3.Cursor:
+        logger.debug('SQLite3: execute: {query}'.format(
+            query=BrickSQL.clean_query(query)
+        ))
+
+        return self.cursor.execute(query, parameters)
+
+    # Clean the query for debugging
+    @staticmethod
+    def clean_query(query: str, /) -> str:
+        cleaned: list[str] = []
+
+        for line in query.splitlines():
+            # Keep the non-comment side
+            line, sep, comment = line.partition('--')
+
+            # Clean the non-comment side
+            line = line.strip()
+
+            if line:
+                cleaned.append(line)
+
+        return ' '.join(cleaned)
+
+    # Delete the database
+    @staticmethod
+    def delete() -> None:
+        os.remove(current_app.config['DATABASE_PATH'].value)
+
+        # Info
+        logger.info('The database has been deleted')
+
+    # Drop the database
+    @staticmethod
+    def drop() -> None:
+        BrickSQL().executescript('schema/drop')
+
+        # Info
+        logger.info('The database has been dropped')
+
+    # Count the database records
+    @staticmethod
+    def count_records() -> dict[str, int]:
+        database = BrickSQL()
+
+        counters: dict[str, int] = {}
+        for table in ['sets', 'minifigures', 'inventory', 'missing']:
+            record = database.fetchone('schema/count', table=table)
+
+            if record is not None:
+                counters[table] = record['count']
+
+        return counters
+
+    # Initialize the database
+    @staticmethod
+    def initialize() -> None:
+        BrickSQL().executescript('migrations/init')
+
+        # Info
+        logger.info('The database has been initialized')
+
+    # Check if the database is initialized
+    @staticmethod
+    def is_init() -> bool:
+        return BrickSQL().fetchone('schema/is_init') is not None
+
+    # Replace the database with a new file
+    @staticmethod
+    def upload(file: FileStorage, /) -> None:
+        file.save(current_app.config['DATABASE_PATH'].value)
+
+        # Info
+        logger.info('The database has been imported using file {file}'.format(
+            file=file.filename
+        ))
+
+
+# Close all existing SQLite3 connections
+def close() -> None:
+    database: sqlite3.Connection | None = getattr(g, 'database', None)
+
+    if database is not None:
+        logger.debug('SQLite3: close')
+        database.close()
+
+        # Remove the database from the context
+        delattr(g, 'database')

bricktracker/sql/migrations/init.sql

@@ -0,0 +1,61 @@
+-- FROM sqlite3 app.db .schema > init.sql with extra IF NOT EXISTS and transaction
+BEGIN transaction;
+
+CREATE TABLE IF NOT EXISTS wishlist (
+        set_num TEXT,
+        name TEXT,
+        year INTEGER,
+        theme_id INTEGER,
+        num_parts INTEGER,
+        set_img_url TEXT,
+        set_url TEXT,
+        last_modified_dt TEXT
+    );
+CREATE TABLE IF NOT EXISTS sets (
+        set_num TEXT,
+        name TEXT,
+        year INTEGER,
+        theme_id INTEGER,
+        num_parts INTEGER,
+        set_img_url TEXT,
+        set_url TEXT,
+        last_modified_dt TEXT,
+        mini_col BOOLEAN,
+        set_check BOOLEAN,
+        set_col BOOLEAN,
+        u_id TEXT
+    );
+CREATE TABLE IF NOT EXISTS inventory (
+        set_num TEXT,
+        id INTEGER,
+        part_num TEXT,
+        name TEXT,
+        part_img_url TEXT,
+        part_img_url_id TEXT,
+        color_id INTEGER,
+        color_name TEXT,
+        quantity INTEGER,
+        is_spare BOOLEAN,
+        element_id INTEGER,
+        u_id TEXT
+    );
+CREATE TABLE IF NOT EXISTS minifigures (
+        fig_num TEXT,
+        set_num TEXT,
+        name TEXT,
+        quantity INTEGER,
+        set_img_url TEXT,
+        u_id TEXT
+    );
+CREATE TABLE IF NOT EXISTS missing (
+        set_num TEXT,
+        id INTEGER,
+        part_num TEXT,
+        part_img_url_id TEXT,
+        color_id INTEGER,
+        quantity INTEGER,
+        element_id INTEGER,
+        u_id TEXT
+    );
+
+COMMIT;

bricktracker/sql/minifigure/base/select.sql

@@ -0,0 +1,31 @@
+SELECT
+    minifigures.fig_num,
+    minifigures.set_num,
+    minifigures.name,
+    minifigures.quantity,
+    minifigures.set_img_url,
+    minifigures.u_id,
+    {% block total_missing %}
+    NULL AS total_missing, -- dummy for order: total_missing
+    {% endblock %}
+    {% block total_quantity %}
+    NULL AS total_quantity, -- dummy for order: total_quantity
+    {% endblock %}
+    {% block total_sets %}
+    NULL AS total_sets -- dummy for order: total_sets
+    {% endblock %}
+FROM minifigures
+
+{% block join %}{% endblock %}
+
+{% block where %}{% endblock %}
+
+{% block group %}{% endblock %}
+
+{% if order %}
+ORDER BY {{ order }}
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/minifigure/delete/all_from_set.sql

@@ -0,0 +1,2 @@
+DELETE FROM minifigures
+WHERE u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/minifigure/insert.sql

@@ -0,0 +1,15 @@
+INSERT INTO minifigures (
+    fig_num,
+    set_num,
+    name,
+    quantity,
+    set_img_url,
+    u_id
+) VALUES (
+    :fig_num,
+    :set_num,
+    :name,
+    :quantity,
+    :set_img_url,
+    :u_id
+)

bricktracker/sql/minifigure/list/all.sql

@@ -0,0 +1,34 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing_join.total, 0)) AS total_missing,
+{% endblock %}
+
+{% block total_quantity %}
+SUM(IFNULL(minifigures.quantity, 0)) AS total_quantity,
+{% endblock %}
+
+{% block total_sets %}
+COUNT(minifigures.set_num) AS total_sets
+{% endblock %}
+
+{% block join %}
+-- LEFT JOIN + SELECT to avoid messing the total
+LEFT JOIN (
+    SELECT
+        set_num,
+        u_id,
+        SUM(quantity) AS total
+    FROM missing
+    GROUP BY
+        set_num,
+        u_id
+) missing_join
+ON minifigures.u_id IS NOT DISTINCT FROM missing_join.u_id
+AND minifigures.fig_num IS NOT DISTINCT FROM missing_join.set_num
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    minifigures.fig_num
+{% endblock %}

bricktracker/sql/minifigure/list/from_set.sql

@@ -0,0 +1,6 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block where %}
+WHERE u_id IS NOT DISTINCT FROM :u_id
+AND set_num IS NOT DISTINCT FROM :set_num
+{% endblock %}

bricktracker/sql/minifigure/list/last.sql

@@ -0,0 +1,17 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing.quantity, 0)) AS total_missing,
+{% endblock %}
+
+{% block join %}
+LEFT JOIN missing
+ON minifigures.fig_num IS NOT DISTINCT FROM missing.set_num
+AND minifigures.u_id IS NOT DISTINCT FROM missing.u_id
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    minifigures.fig_num,
+    minifigures.u_id
+{% endblock %}

bricktracker/sql/minifigure/list/missing_part.sql

@@ -0,0 +1,15 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block where %}
+WHERE minifigures.fig_num IN (
+    SELECT
+        missing.set_num
+    FROM missing
+
+    WHERE missing.color_id IS NOT DISTINCT FROM :color_id
+    AND missing.element_id IS NOT DISTINCT FROM :element_id
+    AND missing.part_num IS NOT DISTINCT FROM :part_num
+
+    GROUP BY missing.set_num
+)
+{% endblock %}

bricktracker/sql/minifigure/list/using_part.sql

@@ -0,0 +1,15 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block where %}
+WHERE minifigures.fig_num IN (
+    SELECT
+        inventory.set_num
+    FROM inventory
+
+    WHERE inventory.color_id IS NOT DISTINCT FROM :color_id
+    AND inventory.element_id IS NOT DISTINCT FROM :element_id
+    AND inventory.part_num IS NOT DISTINCT FROM :part_num
+
+    GROUP BY inventory.set_num
+)
+{% endblock %}

bricktracker/sql/minifigure/select/generic.sql

@@ -0,0 +1,38 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing_join.total, 0)) AS total_missing,
+{% endblock %}
+
+{% block total_quantity %}
+SUM(IFNULL(minifigures.quantity, 0)) AS total_quantity,
+{% endblock %}
+
+{% block total_sets %}
+COUNT(minifigures.set_num) AS total_sets
+{% endblock %}
+
+{% block join %}
+-- LEFT JOIN + SELECT to avoid messing the total
+LEFT JOIN (
+    SELECT
+        set_num,
+        u_id,
+        SUM(quantity) AS total
+    FROM missing
+    GROUP BY
+        set_num,
+        u_id
+) missing_join
+ON minifigures.u_id IS NOT DISTINCT FROM missing_join.u_id
+AND minifigures.fig_num IS NOT DISTINCT FROM missing_join.set_num
+{% endblock %}
+
+{% block where %}
+WHERE fig_num IS NOT DISTINCT FROM :fig_num
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    minifigures.fig_num
+{% endblock %}

bricktracker/sql/minifigure/select/specific.sql

@@ -0,0 +1,7 @@
+{% extends 'minifigure/base/select.sql' %}
+
+{% block where %}
+WHERE fig_num IS NOT DISTINCT FROM :fig_num
+AND u_id IS NOT DISTINCT FROM :u_id
+AND set_num IS NOT DISTINCT FROM :set_num
+{% endblock %}

bricktracker/sql/missing/delete/all_from_set.sql

@@ -0,0 +1,2 @@
+DELETE FROM missing
+WHERE u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/missing/delete/from_set.sql

@@ -0,0 +1,4 @@
+DELETE FROM missing
+WHERE set_num IS NOT DISTINCT FROM :set_num
+AND id IS NOT DISTINCT FROM :id
+AND u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/missing/insert.sql

@@ -0,0 +1,20 @@
+INSERT INTO missing (
+    set_num,
+    id,
+    part_num,
+    part_img_url_id,
+    color_id,
+    quantity,
+    element_id,
+    u_id
+)
+VALUES(
+    :set_num,
+    :id,
+    :part_num,
+    :part_img_url_id,
+    :color_id,
+    :quantity,
+    :element_id,
+    :u_id
+)

bricktracker/sql/missing/update/from_set.sql

@@ -0,0 +1,5 @@
+UPDATE missing
+SET quantity = :quantity
+WHERE set_num IS NOT DISTINCT FROM :set_num
+AND id IS NOT DISTINCT FROM :id
+AND u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/part/base/select.sql

@@ -0,0 +1,43 @@
+SELECT
+    inventory.set_num,
+    inventory.id,
+    inventory.part_num,
+    inventory.name,
+    inventory.part_img_url,
+    inventory.part_img_url_id,
+    inventory.color_id,
+    inventory.color_name,
+    inventory.quantity,
+    inventory.is_spare,
+    inventory.element_id,
+    inventory.u_id,
+    {% block total_missing %}
+    NULL AS total_missing, -- dummy for order: total_missing
+    {% endblock %}
+    {% block total_quantity %}
+    NULL AS total_quantity, -- dummy for order: total_quantity
+    {% endblock %}
+    {% block total_spare %}
+    NULL AS total_spare, -- dummy for order: total_spare
+    {% endblock %}
+    {% block total_sets %}
+    NULL AS total_sets, -- dummy for order: total_sets
+    {% endblock %}
+    {% block total_minifigures %}
+    NULL AS total_minifigures -- dummy for order: total_minifigures
+    {% endblock %}
+FROM inventory
+
+{% block join %}{% endblock %}
+
+{% block where %}{% endblock %}
+
+{% block group %}{% endblock %}
+
+{% if order %}
+ORDER BY {{ order }}
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/part/delete/all_from_set.sql

@@ -0,0 +1,2 @@
+DELETE FROM inventory
+WHERE u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/part/insert.sql

@@ -0,0 +1,27 @@
+INSERT INTO inventory (
+    set_num,
+    id,
+    part_num,
+    name,
+    part_img_url,
+    part_img_url_id,
+    color_id,
+    color_name,
+    quantity,
+    is_spare,
+    element_id,
+    u_id
+) VALUES (
+    :set_num,
+    :id,
+    :part_num,
+    :name,
+    :part_img_url,
+    :part_img_url_id,
+    :color_id,
+    :color_name,
+    :quantity,
+    :is_spare,
+    :element_id,
+    :u_id
+)

bricktracker/sql/part/list/all.sql

@@ -0,0 +1,43 @@
+{% extends 'part/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing.quantity, 0)) AS total_missing,
+{% endblock %}
+
+{% block total_quantity %}
+SUM(inventory.quantity * IFNULL(minifigures.quantity, 1)) AS total_quantity,
+{% endblock %}
+
+{% block total_sets %}
+COUNT(DISTINCT sets.u_id) AS total_sets,
+{% endblock %}
+
+{% block total_minifigures %}
+SUM(IFNULL(minifigures.quantity, 0)) AS total_minifigures
+{% endblock %}
+
+{% block join %}
+LEFT JOIN missing
+ON inventory.set_num IS NOT DISTINCT FROM missing.set_num
+AND inventory.id IS NOT DISTINCT FROM missing.id
+AND inventory.part_num IS NOT DISTINCT FROM missing.part_num
+AND inventory.color_id IS NOT DISTINCT FROM missing.color_id
+AND inventory.element_id IS NOT DISTINCT FROM missing.element_id
+AND inventory.u_id IS NOT DISTINCT FROM missing.u_id
+
+LEFT JOIN minifigures
+ON inventory.set_num IS NOT DISTINCT FROM minifigures.fig_num
+AND inventory.u_id IS NOT DISTINCT FROM minifigures.u_id
+
+LEFT JOIN sets
+ON inventory.u_id IS NOT DISTINCT FROM sets.u_id
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    inventory.part_num,
+    inventory.name,
+    inventory.color_id,
+    inventory.is_spare,
+    inventory.element_id
+{% endblock %}

bricktracker/sql/part/list/from_minifigure.sql

@@ -0,0 +1,28 @@
+
+{% extends 'part/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing.quantity, 0)) AS total_missing,
+{% endblock %}
+
+{% block join %}
+LEFT JOIN missing
+ON missing.set_num IS NOT DISTINCT FROM inventory.set_num
+AND missing.id IS NOT DISTINCT FROM inventory.id
+AND missing.part_num IS NOT DISTINCT FROM inventory.part_num
+AND missing.color_id IS NOT DISTINCT FROM inventory.color_id
+AND missing.element_id IS NOT DISTINCT FROM inventory.element_id
+{% endblock %}
+
+{% block where %}
+WHERE inventory.set_num IS NOT DISTINCT FROM :set_num
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    inventory.part_num,
+    inventory.name,
+    inventory.color_id,
+    inventory.is_spare,
+    inventory.element_id
+{% endblock %}

bricktracker/sql/part/list/from_set.sql

@@ -0,0 +1,21 @@
+
+{% extends 'part/base/select.sql' %}
+
+{% block total_missing %}
+IFNULL(missing.quantity, 0) AS total_missing,
+{% endblock %}
+
+{% block join %}
+LEFT JOIN missing
+ON inventory.set_num IS NOT DISTINCT FROM missing.set_num
+AND inventory.id IS NOT DISTINCT FROM missing.id
+AND inventory.part_num IS NOT DISTINCT FROM missing.part_num
+AND inventory.color_id IS NOT DISTINCT FROM missing.color_id
+AND inventory.element_id IS NOT DISTINCT FROM missing.element_id
+AND inventory.u_id IS NOT DISTINCT FROM missing.u_id
+{% endblock %}
+
+{% block where %}
+WHERE inventory.u_id IS NOT DISTINCT FROM :u_id
+AND inventory.set_num IS NOT DISTINCT FROM :set_num
+{% endblock %}

bricktracker/sql/part/list/missing.sql

@@ -0,0 +1,36 @@
+{% extends 'part/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing.quantity, 0)) AS total_missing,
+{% endblock %}
+
+{% block total_sets %}
+COUNT(inventory.u_id)  - COUNT(minifigures.u_id) AS total_sets,
+{% endblock %}
+
+{% block total_minifigures %}
+SUM(IFNULL(minifigures.quantity, 0)) AS total_minifigures
+{% endblock %}
+
+{% block join %}
+INNER JOIN missing
+ON missing.set_num IS NOT DISTINCT FROM inventory.set_num
+AND missing.id IS NOT DISTINCT FROM inventory.id
+AND missing.part_num IS NOT DISTINCT FROM inventory.part_num
+AND missing.color_id IS NOT DISTINCT FROM inventory.color_id
+AND missing.element_id IS NOT DISTINCT FROM inventory.element_id
+AND missing.u_id IS NOT DISTINCT FROM inventory.u_id
+
+LEFT JOIN minifigures
+ON missing.set_num IS NOT DISTINCT FROM minifigures.fig_num
+AND missing.u_id IS NOT DISTINCT FROM minifigures.u_id
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    inventory.part_num,
+    inventory.name,
+    inventory.color_id,
+    inventory.is_spare,
+    inventory.element_id
+{% endblock %}

bricktracker/sql/part/select/generic.sql

@@ -0,0 +1,36 @@
+{% extends 'part/base/select.sql' %}
+
+{% block total_missing %}
+SUM(IFNULL(missing.quantity, 0)) AS total_missing,
+{% endblock %}
+
+{% block total_quantity %}
+SUM(IFNULL((NOT inventory.is_spare) * inventory.quantity, 0)) AS total_quantity,
+{% endblock %}
+
+{% block total_spare %}
+SUM(IFNULL(inventory.is_spare * inventory.quantity, 0)) AS total_spare,
+{% endblock %}
+
+{% block join %}
+LEFT JOIN missing
+ON inventory.set_num IS NOT DISTINCT FROM missing.set_num
+AND inventory.id IS NOT DISTINCT FROM missing.id
+AND inventory.part_num IS NOT DISTINCT FROM missing.part_num
+AND inventory.color_id IS NOT DISTINCT FROM missing.color_id
+AND inventory.element_id IS NOT DISTINCT FROM missing.element_id
+AND inventory.u_id IS NOT DISTINCT FROM missing.u_id
+{% endblock %}
+
+{% block where %}
+WHERE inventory.part_num IS NOT DISTINCT FROM :part_num
+AND inventory.color_id IS NOT DISTINCT FROM :color_id
+AND inventory.element_id IS NOT DISTINCT FROM :element_id
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    inventory.part_num,
+    inventory.color_id,
+    inventory.element_id
+{% endblock %}

bricktracker/sql/part/select/specific.sql

@@ -0,0 +1,24 @@
+{% extends 'part/base/select.sql' %}
+
+{% block join %}
+LEFT JOIN missing
+ON inventory.set_num IS NOT DISTINCT FROM missing.set_num
+AND inventory.id IS NOT DISTINCT FROM missing.id
+AND inventory.u_id IS NOT DISTINCT FROM missing.u_id
+{% endblock %}
+
+{% block where %}
+WHERE inventory.u_id IS NOT DISTINCT FROM :u_id
+AND inventory.set_num IS NOT DISTINCT FROM :set_num
+AND inventory.id IS NOT DISTINCT FROM :id
+{% endblock %}
+
+{% block group %}
+GROUP BY
+    inventory.set_num,
+    inventory.id,
+    inventory.part_num,
+    inventory.color_id,
+    inventory.element_id,
+    inventory.u_id
+{% endblock %}

bricktracker/sql/schema/count.sql

@@ -0,0 +1,2 @@
+SELECT COUNT(*) AS count
+FROM {{ table }}

bricktracker/sql/schema/drop.sql

@@ -0,0 +1,9 @@
+BEGIN transaction;
+
+DROP TABLE IF EXISTS wishlist;
+DROP TABLE IF EXISTS sets;
+DROP TABLE IF EXISTS inventory;
+DROP TABLE IF EXISTS minifigures;
+DROP TABLE IF EXISTS missing;
+
+COMMIT;

bricktracker/sql/schema/is_init.sql

@@ -0,0 +1,4 @@
+SELECT name
+FROM sqlite_master
+WHERE type="table"
+AND name="sets"

bricktracker/sql/set/base/select.sql

@@ -0,0 +1,52 @@
+SELECT
+    sets.set_num,
+    sets.name,
+    sets.year,
+    sets.theme_id,
+    sets.num_parts,
+    sets.set_img_url,
+    sets.set_url,
+    sets.last_modified_dt,
+    sets.mini_col,
+    sets.set_check,
+    sets.set_col,
+    sets.u_id,
+    {% block number %}
+    CAST(SUBSTR(sets.set_num, 1, INSTR(sets.set_num, '-') - 1) AS INTEGER) AS set_number,
+    CAST(SUBSTR(sets.set_num, 1, INSTR(sets.set_num, '-') + 1) AS INTEGER) AS set_version,
+    {% endblock %}
+    IFNULL(missing_join.total, 0) AS total_missing,
+    IFNULL(minifigures_join.total, 0) AS total_minifigures
+FROM sets
+
+-- LEFT JOIN + SELECT to avoid messing the total
+LEFT JOIN (
+    SELECT
+        u_id,
+        SUM(quantity) AS total
+    FROM missing
+    {% block where_missing %}{% endblock %}
+    GROUP BY u_id
+) missing_join
+ON sets.u_id IS NOT DISTINCT FROM missing_join.u_id
+
+-- LEFT JOIN + SELECT to avoid messing the total
+LEFT JOIN (
+    SELECT
+        u_id,
+       SUM(quantity) AS total
+    FROM minifigures
+    {% block where_minifigures %}{% endblock %}
+    GROUP BY u_id
+) minifigures_join
+ON sets.u_id IS NOT DISTINCT FROM minifigures_join.u_id
+
+{% block where %}{% endblock %}
+
+{% if order %}
+ORDER BY {{ order }}
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/set/delete/set.sql

@@ -0,0 +1,2 @@
+DELETE FROM sets
+WHERE u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/set/insert.sql

@@ -0,0 +1,27 @@
+INSERT INTO sets (
+    set_num,
+    name,
+    year,
+    theme_id,
+    num_parts,
+    set_img_url,
+    set_url,
+    last_modified_dt,
+    mini_col,
+    set_check,
+    set_col,
+    u_id
+) VALUES (
+    :set_num,
+    :name,
+    :year,
+    :theme_id,
+    :num_parts,
+    :set_img_url,
+    :set_url,
+    :last_modified_dt,
+    :mini_col,
+    :set_check,
+    :set_col,
+    :u_id
+)

bricktracker/sql/set/list/all.sql

@@ -0,0 +1 @@
+{% extends 'set/base/select.sql' %}

bricktracker/sql/set/list/generic.sql

@@ -0,0 +1,12 @@
+SELECT
+    sets.set_num,
+    sets.name,
+    sets.year,
+    sets.theme_id,
+    sets.num_parts,
+    sets.set_img_url,
+    sets.set_url
+FROM sets
+
+GROUP BY
+    sets.set_num

bricktracker/sql/set/list/missing_minifigure.sql

@@ -0,0 +1,13 @@
+{% extends 'set/base/select.sql' %}
+
+{% block where %}
+WHERE sets.u_id IN (
+    SELECT
+        missing.u_id
+    FROM missing
+
+    WHERE missing.set_num IS NOT DISTINCT FROM :fig_num
+
+    GROUP BY missing.u_id
+)
+{% endblock %}

bricktracker/sql/set/list/missing_part.sql

@@ -0,0 +1,15 @@
+{% extends 'set/base/select.sql' %}
+
+{% block where %}
+WHERE sets.u_id IN (
+    SELECT
+        missing.u_id
+    FROM missing
+
+    WHERE missing.color_id IS NOT DISTINCT FROM :color_id
+    AND missing.element_id IS NOT DISTINCT FROM :element_id
+    AND missing.part_num IS NOT DISTINCT FROM :part_num
+
+    GROUP BY missing.u_id
+)
+{% endblock %}

bricktracker/sql/set/list/using_minifigure.sql

@@ -0,0 +1,13 @@
+{% extends 'set/base/select.sql' %}
+
+{% block where %}
+WHERE sets.u_id IN (
+    SELECT
+        inventory.u_id
+    FROM inventory
+
+    WHERE inventory.set_num IS NOT DISTINCT FROM :fig_num
+
+    GROUP BY inventory.u_id
+)
+{% endblock %}

bricktracker/sql/set/list/using_part.sql

@@ -0,0 +1,15 @@
+{% extends 'set/base/select.sql' %}
+
+{% block where %}
+WHERE sets.u_id IN (
+    SELECT
+        inventory.u_id
+    FROM inventory
+
+    WHERE inventory.color_id IS NOT DISTINCT FROM :color_id
+    AND inventory.element_id IS NOT DISTINCT FROM :element_id
+    AND inventory.part_num IS NOT DISTINCT FROM :part_num
+
+    GROUP BY inventory.u_id
+)
+{% endblock %}

bricktracker/sql/set/select.sql

@@ -0,0 +1,13 @@
+{% extends 'set/base/select.sql' %}
+
+{% block where_missing %}
+WHERE u_id IS NOT DISTINCT FROM :u_id
+{% endblock %}
+
+{% block where_minifigures %}
+WHERE u_id IS NOT DISTINCT FROM :u_id
+{% endblock %}
+
+{% block where %}
+WHERE sets.u_id IS NOT DISTINCT FROM :u_id
+{% endblock %}

bricktracker/sql/set/update_checked.sql

@@ -0,0 +1,3 @@
+UPDATE sets
+SET {{name}} = :status
+WHERE u_id IS NOT DISTINCT FROM :u_id

bricktracker/sql/wish/base/select.sql

@@ -0,0 +1,20 @@
+SELECT
+    wishlist.set_num,
+    wishlist.name,
+    wishlist.year,
+    wishlist.theme_id,
+    wishlist.num_parts,
+    wishlist.set_img_url,
+    wishlist.set_url,
+    wishlist.last_modified_dt
+FROM wishlist
+
+{% block where %}{% endblock %}
+
+{% if order %}
+ORDER BY {{ order }}
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/wish/delete/wish.sql

@@ -0,0 +1,2 @@
+DELETE FROM wishlist
+WHERE set_num IS NOT DISTINCT FROM :set_num

bricktracker/sql/wish/insert.sql

@@ -0,0 +1,19 @@
+INSERT INTO wishlist (
+    set_num,
+    name,
+    year,
+    theme_id,
+    num_parts,
+    set_img_url,
+    set_url,
+    last_modified_dt
+) VALUES (
+    :set_num,
+    :name,
+    :year,
+    :theme_id,
+    :num_parts,
+    :set_img_url,
+    :set_url,
+    :last_modified_dt
+)

bricktracker/sql/wish/list/all.sql

@@ -0,0 +1 @@
+{% extends 'wish/base/select.sql' %}

bricktracker/sql/wish/select.sql

@@ -0,0 +1,5 @@
+{% extends 'wish/base/select.sql' %}
+
+{% block where %}
+WHERE wishlist.set_num IS NOT DISTINCT FROM :set_num
+{% endblock %}

bricktracker/sql_stats.py

@@ -0,0 +1,36 @@
+# Some stats on the database
+class BrickSQLStats(object):
+    # Functions
+    connect: int
+    commit: int
+    execute: int
+    executescript: int
+    fetchall: int
+    fetchone: int
+
+    # Records
+    fetched: int
+    changed: int
+
+    def __init__(self, /):
+        self.connect = 0
+        self.commit = 0
+        self.execute = 0
+        self.executescript = 0
+        self.fetchall = 0
+        self.fetchone = 0
+        self.fetched = 0
+        self.changed = 0
+
+    # Print the stats
+    def print(self, /) -> str:
+        items: list[str] = []
+
+        for key, value in self.__dict__.items():
+            if value:
+                items.append('{key}: {value}'.format(
+                    key=key.capitalize(),
+                    value=value,
+                ))
+
+        return ' - '.join(items)

bricktracker/theme.py

@@ -0,0 +1,14 @@
+# Lego set theme
+class BrickTheme(object):
+    id: int
+    name: str
+    parent: int | None
+
+    def __init__(self, id: str | int, name: str, parent: str | None = None, /):
+        self.id = int(id)
+        self.name = name
+
+        if parent is not None and parent != '':
+            self.parent = int(parent)
+        else:
+            self.parent = None

bricktracker/theme_list.py

@@ -0,0 +1,104 @@
+from datetime import datetime, timezone
+import csv
+import gzip
+import logging
+import os
+from shutil import copyfileobj
+
+from flask import current_app, g
+import humanize
+import requests
+
+from .exceptions import ErrorException
+from .theme import BrickTheme
+
+logger = logging.getLogger(__name__)
+
+
+# Lego sets themes
+class BrickThemeList(object):
+    themes: dict[int, BrickTheme]
+    mtime: datetime | None
+    size: int | None
+    exception: Exception | None
+
+    def __init__(self, /, force: bool = False):
+        # Load themes only if there is none already loaded
+        themes = getattr(self, 'themes', None)
+
+        if themes is None or force:
+            logger.info('Loading themes list')
+
+            BrickThemeList.themes = {}
+
+            # Try to read the themes from a CSV file
+            try:
+                with open(current_app.config['THEMES_PATH'].value, newline='') as themes_file:  # noqa: E501
+                    themes_reader = csv.reader(themes_file)
+
+                    # Ignore the header
+                    next(themes_reader, None)
+
+                    for row in themes_reader:
+                        theme = BrickTheme(*row)
+                        BrickThemeList.themes[theme.id] = theme
+
+                # File stats
+                stat = os.stat(current_app.config['THEMES_PATH'].value)
+                BrickThemeList.size = stat.st_size
+                BrickThemeList.mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)  # noqa: E501
+
+                BrickThemeList.exception = None
+
+            # Ignore errors
+            except Exception as e:
+                BrickThemeList.exception = e
+                BrickThemeList.size = None
+                BrickThemeList.mtime = None
+
+    # Get a theme
+    def get(self, id: int, /) -> BrickTheme:
+        # Seed a fake entry if missing
+        if id not in self.themes:
+            BrickThemeList.themes[id] = BrickTheme(
+                id,
+                'Unknown ({id})'.format(id=id)
+            )
+
+        return self.themes[id]
+
+    # Display the size in a human format
+    def human_size(self) -> str:
+        if self.size is not None:
+            return humanize.naturalsize(self.size)
+        else:
+            return ''
+
+    # Display the time in a human format
+    def human_time(self) -> str:
+        if self.mtime is not None:
+            return self.mtime.astimezone(g.timezone).strftime(
+                current_app.config['FILE_DATETIME_FORMAT'].value
+            )
+        else:
+            return ''
+
+    # Update the file
+    @staticmethod
+    def update() -> None:
+        response = requests.get(
+            current_app.config['THEMES_FILE_URL'].value,
+            stream=True,
+        )
+
+        if not response.ok:
+            raise ErrorException('An error occured while downloading the themes file ({code})'.format(  # noqa: E501
+                code=response.status_code
+            ))
+
+        content = gzip.GzipFile(fileobj=response.raw)
+
+        with open(current_app.config['THEMES_PATH'].value, 'wb') as f:
+            copyfileobj(content, f)
+
+        logger.info('Theme list updated')

bricktracker/version.py

@@ -0,0 +1 @@
+__version__ = '1.0.0'

bricktracker/views/add.py

@@ -0,0 +1,38 @@
+from flask import Blueprint, current_app, render_template
+from flask_login import login_required
+
+from ..configuration_list import BrickConfigurationList
+from .exceptions import exception_handler
+from ..socket import MESSAGES
+
+add_page = Blueprint('add', __name__, url_prefix='/add')
+
+
+# Add a set
+@add_page.route('/', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def add() -> str:
+    BrickConfigurationList.error_unless_is_set('REBRICKABLE_API_KEY')
+
+    return render_template(
+        'add.html',
+        path=current_app.config['SOCKET_PATH'].value,
+        namespace=current_app.config['SOCKET_NAMESPACE'].value,
+        messages=MESSAGES
+    )
+
+
+# Bulk add sets
+@add_page.route('/bulk', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def bulk() -> str:
+    BrickConfigurationList.error_unless_is_set('REBRICKABLE_API_KEY')
+
+    return render_template(
+        'bulk.html',
+        path=current_app.config['SOCKET_PATH'].value,
+        namespace=current_app.config['SOCKET_NAMESPACE'].value,
+        messages=MESSAGES
+    )

bricktracker/views/admin.py

@@ -0,0 +1,258 @@
+from datetime import datetime
+import logging
+import os
+
+from flask import (
+    Blueprint,
+    current_app,
+    g,
+    redirect,
+    request,
+    render_template,
+    send_file,
+    url_for,
+)
+from flask_login import login_required
+from werkzeug.wrappers.response import Response
+
+from ..configuration_list import BrickConfigurationList
+from .exceptions import exception_handler
+from ..instructions_list import BrickInstructionsList
+from ..retired_list import BrickRetiredList
+from ..sql import BrickSQL
+from ..theme_list import BrickThemeList
+from .upload import upload_helper
+
+logger = logging.getLogger(__name__)
+
+admin_page = Blueprint('admin', __name__, url_prefix='/admin')
+
+
+# Admin
+@admin_page.route('/', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def admin() -> str:
+    counters: dict[str, int] = {}
+    exception: Exception | None = None
+    is_init: bool = False
+
+    # This view needs to be protected against SQL errors
+    try:
+        is_init = BrickSQL.is_init()
+
+        if is_init:
+            counters = BrickSQL.count_records()
+    except Exception as e:
+        exception = e
+
+        # Warning
+        logger.warning('An exception occured while loading the admin page: {exception}'.format(  # noqa: E501
+            exception=str(e),
+        ))
+
+    open_instructions = request.args.get('open_instructions', None)
+    open_logout = request.args.get('open_logout', None)
+    open_retired = request.args.get('open_retired', None)
+    open_theme = request.args.get('open_theme', None)
+
+    open_database = (
+        open_instructions is not None and
+        open_logout is not None and
+        open_logout is not None and
+        open_theme is not None
+    )
+
+    return render_template(
+        'admin.html',
+        configuration=BrickConfigurationList.list(),
+        counters=counters,
+        error=request.args.get('error'),
+        exception=exception,
+        instructions=BrickInstructionsList(),
+        is_init=is_init,
+        open_database=open_database,
+        open_instructions=open_instructions,
+        open_logout=open_logout,
+        open_retired=open_retired,
+        open_theme=open_theme,
+        retired=BrickRetiredList(),
+        theme=BrickThemeList(),
+    )
+
+
+# Initialize the database
+@admin_page.route('/init-database', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='admin.admin')
+def init_database() -> Response:
+    BrickSQL.initialize()
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('admin.admin'))
+
+
+# Delete the database
+@admin_page.route('/delete-database', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def delete_database() -> str:
+    return render_template(
+        'admin.html',
+        delete_database=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually delete the database
+@admin_page.route('/delete-database', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='admin.delete_database')
+def do_delete_database() -> Response:
+    BrickSQL.delete()
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('admin.admin'))
+
+
+# Download the database
+@admin_page.route('/download-database', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def download_database() -> Response:
+    # Create a file name with a timestamp embedded
+    name, extension = os.path.splitext(
+        os.path.basename(current_app.config['DATABASE_PATH'].value)
+    )
+
+    # Info
+    logger.info('The database has been downloaded')
+
+    return send_file(
+        current_app.config['DATABASE_PATH'].value,
+        as_attachment=True,
+        download_name='{name}-{timestamp}{extension}'.format(
+            name=name,
+            timestamp=datetime.now().astimezone(g.timezone).strftime(
+                current_app.config['DATABASE_TIMESTAMP_FORMAT'].value
+            ),
+            extension=extension
+        )
+    )
+
+
+# Drop the database
+@admin_page.route('/drop-database', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def drop_database() -> str:
+    return render_template(
+        'admin.html',
+        drop_database=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually drop the database
+@admin_page.route('/drop-database', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='admin.drop_database')
+def do_drop_database() -> Response:
+    BrickSQL.drop()
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('admin.admin'))
+
+
+# Import a database
+@admin_page.route('/import-database', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def import_database() -> str:
+    return render_template(
+        'admin.html',
+        import_database=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually import a database
+@admin_page.route('/import-database', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='admin.import_database')
+def do_import_database() -> Response:
+    file = upload_helper(
+        'database',
+        'admin.import_database',
+        extensions=['.db'],
+    )
+
+    if isinstance(file, Response):
+        return file
+
+    BrickSQL.upload(file)
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('admin.admin'))
+
+
+# Refresh the instructions cache
+@admin_page.route('/refresh-instructions', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def refresh_instructions() -> Response:
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('admin.admin', open_instructions=True))
+
+
+# Refresh the retired sets cache
+@admin_page.route('/refresh-retired', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def refresh_retired() -> Response:
+    BrickRetiredList(force=True)
+
+    return redirect(url_for('admin.admin', open_retired=True))
+
+
+# Refresh the themes cache
+@admin_page.route('/refresh-themes', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def refresh_themes() -> Response:
+    BrickThemeList(force=True)
+
+    return redirect(url_for('admin.admin', open_theme=True))
+
+
+# Update the themes file
+@admin_page.route('/update-retired', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def update_retired() -> Response:
+    BrickRetiredList().update()
+
+    BrickRetiredList(force=True)
+
+    return redirect(url_for('admin.admin', open_retired=True))
+
+
+# Update the themes file
+@admin_page.route('/update-themes', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def update_themes() -> Response:
+    BrickThemeList().update()
+
+    BrickThemeList(force=True)
+
+    return redirect(url_for('admin.admin', open_theme=True))

bricktracker/views/error.py

@@ -0,0 +1,144 @@
+import logging
+from sqlite3 import Error, OperationalError
+import traceback
+from typing import Tuple
+
+from flask import jsonify, redirect, request, render_template, url_for
+from werkzeug.wrappers.response import Response
+
+from ..exceptions import DatabaseException, ErrorException, NotFoundException
+
+logger = logging.getLogger(__name__)
+
+
+# Get the cleaned exception
+def cleaned_exception(e: Exception, /) -> str:
+    trace = traceback.TracebackException.from_exception(e)
+
+    cleaned: list[str] = []
+
+    # Hacky: stripped from the call to the decorator wrapper() or outer()
+    for line in trace.format():
+        if 'in wrapper' not in line and 'in outer' not in line:
+            cleaned.append(line)
+
+    return ''.join(cleaned)
+
+
+# Generic error
+def error(
+    error: Exception | None,
+    file: str,
+    /,
+    json: bool = False,
+    post_redirect: str | None = None,
+    **kwargs,
+) -> str | Tuple[str | Response, int] | Response:
+    # Back to the index if no error (not sure if this can happen)
+    if error is None:
+        if json:
+            return jsonify({'error': 'error() called without an error'})
+        else:
+            return redirect(url_for('index.index'))
+
+    # Convert SQLite errors
+    if isinstance(error, (Error, OperationalError)):
+        error = DatabaseException(error)
+
+    # Clear redirect if not POST or json
+    if json or request.method != 'POST':
+        post_redirect = None
+
+    # Not found
+    if isinstance(error, NotFoundException):
+        return error_404(
+            error,
+            json=json,
+            post_redirect=post_redirect,
+            **kwargs
+        )
+
+    # Common error
+    elif isinstance(error, ErrorException):
+        # Error
+        logger.error('{title}: {error}'.format(
+            title=error.title,
+            error=str(error),
+        ))
+
+        # Debug
+        logger.debug(cleaned_exception(error))
+
+        if json:
+            return jsonify({'error': str(error)})
+        elif post_redirect is not None:
+            return redirect(url_for(
+                post_redirect,
+                error=str(error),
+                **kwargs,
+            ))
+        else:
+            return render_template(
+                'error.html',
+                title=error.title,
+                error=str(error)
+            )
+
+    # Exception
+    else:
+        # Error
+        logger.error(cleaned_exception(error))
+
+        if error.__traceback__ is not None:
+            line = error.__traceback__.tb_lineno
+        else:
+            line = None
+
+        if json:
+            return jsonify({
+                'error': 'Exception: {error}'.format(error=str(error)),
+                'name': type(error).__name__,
+                'line': line,
+                'file': file,
+            }), 500
+        elif post_redirect is not None:
+            return redirect(url_for(
+                post_redirect,
+                error=str(error),
+                **kwargs,
+            ))
+        else:
+            return render_template(
+                'exception.html',
+                error=str(error),
+                name=type(error).__name__,
+                line=line,
+                file=file,
+            )
+
+
+# Error 404
+def error_404(
+    error: Exception,
+    /,
+    json: bool = False,
+    post_redirect: str | None = None,
+    **kwargs,
+) -> Tuple[str | Response, int]:
+    # Warning
+    logger.warning('Not found: {error}'.format(
+        error=str(error),
+    ))
+
+    if json:
+        return jsonify({
+            'error': 'Not found: {error}'.format(error=str(error))
+        }), 404
+    elif post_redirect is not None:
+        return redirect(url_for(
+            post_redirect,
+            error=str(error),
+            **kwargs
+        )), 404
+    else:
+        return render_template('404.html', error=str(error)), 404

bricktracker/views/exceptions.py

@@ -0,0 +1,46 @@
+from functools import wraps
+import logging
+from typing import Callable, ParamSpec, Tuple, Union
+
+from werkzeug.wrappers.response import Response
+
+from .error import error
+
+logger = logging.getLogger(__name__)
+
+# Decorator type hinting is hard.
+# What a view can return (str or Response or (Response, xxx))
+ViewReturn = Union[
+    str,
+    Response,
+    Tuple[str | Response, int]
+]
+
+# View signature (*arg, **kwargs -> (str or Response or (Response, xxx))
+P = ParamSpec('P')
+ViewCallable = Callable[P, ViewReturn]
+
+
+# Return the exception template or response if an exception occured
+def exception_handler(
+    file: str,
+    /,
+    json: bool = False,
+    post_redirect: str | None = None
+) -> Callable[[ViewCallable], ViewCallable]:
+    def outer(function: ViewCallable, /) -> ViewCallable:
+        @wraps(function)
+        def wrapper(*args, **kwargs) -> ViewReturn:
+            try:
+                return function(*args, **kwargs)
+            # Catch SQLite errors as database errors
+            except Exception as e:
+                return error(
+                    e,
+                    file,
+                    json=json,
+                    post_redirect=post_redirect,
+                    **kwargs,
+                )
+        return wrapper
+    return outer

bricktracker/views/index.py

@@ -0,0 +1,18 @@
+from flask import Blueprint, render_template
+
+from .exceptions import exception_handler
+from ..minifigure_list import BrickMinifigureList
+from ..set_list import BrickSetList
+
+index_page = Blueprint('index', __name__)
+
+
+# Index
+@index_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def index() -> str:
+    return render_template(
+        'index.html',
+        brickset_collection=BrickSetList().last(),
+        minifigure_collection=BrickMinifigureList().last(),
+    )

bricktracker/views/instructions.py

@@ -0,0 +1,128 @@
+from flask import (
+    current_app,
+    Blueprint,
+    redirect,
+    render_template,
+    request,
+    url_for
+)
+from flask_login import login_required
+from werkzeug.wrappers.response import Response
+from werkzeug.utils import secure_filename
+
+from .exceptions import exception_handler
+from ..instructions import BrickInstructions
+from ..instructions_list import BrickInstructionsList
+from .upload import upload_helper
+
+instructions_page = Blueprint(
+    'instructions',
+    __name__,
+    url_prefix='/instructions'
+)
+
+
+# Index
+@instructions_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def list() -> str:
+    return render_template(
+        'instructions.html',
+        table_collection=BrickInstructionsList().list(),
+    )
+
+
+# Delete an instructions file
+@instructions_page.route('/<name>/delete/', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def delete(*, name: str) -> str:
+    return render_template(
+        'instructions.html',
+        item=BrickInstructionsList().get_file(name),
+        delete=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually delete an instructions file
+@instructions_page.route('/<name>/delete/', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='instructions.delete')
+def do_delete(*, name: str) -> Response:
+    instruction = BrickInstructionsList().get_file(name)
+
+    # Delete the instructions file
+    instruction.delete()
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('instructions.list'))
+
+
+# Rename an instructions file
+@instructions_page.route('/<name>/rename/', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def rename(*, name: str) -> str:
+    return render_template(
+        'instructions.html',
+        item=BrickInstructionsList().get_file(name),
+        rename=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually rename an instructions file
+@instructions_page.route('/<name>/rename/', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='instructions.rename')
+def do_rename(*, name: str) -> Response:
+    instruction = BrickInstructionsList().get_file(name)
+
+    # Grab the new filename
+    filename = secure_filename(request.form.get('filename', ''))
+
+    if filename != '':
+        # Delete the instructions file
+        instruction.rename(filename)
+
+        # Reload the instructions
+        BrickInstructionsList(force=True)
+
+    return redirect(url_for('instructions.list'))
+
+
+# Upload an instructions file
+@instructions_page.route('/upload/', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def upload() -> str:
+    return render_template(
+        'instructions.html',
+        upload=True,
+        error=request.args.get('error')
+    )
+
+
+# Actually upload an instructions file
+@instructions_page.route('/upload', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='instructions.upload')
+def do_upload() -> Response:
+    file = upload_helper(
+        'file',
+        'instructions.upload',
+        extensions=current_app.config['INSTRUCTIONS_ALLOWED_EXTENSIONS'].value,
+    )
+
+    if isinstance(file, Response):
+        return file
+
+    BrickInstructions(file.filename).upload(file)  # type: ignore
+
+    # Reload the instructions
+    BrickInstructionsList(force=True)
+
+    return redirect(url_for('instructions.list'))

bricktracker/views/login.py

@@ -0,0 +1,86 @@
+import logging
+
+from flask import (
+    Blueprint,
+    current_app,
+    redirect,
+    render_template,
+    request,
+    url_for
+)
+from flask_login import (
+    AnonymousUserMixin,
+    current_user,
+    login_user,
+    logout_user
+)
+from werkzeug.wrappers.response import Response
+
+from .exceptions import exception_handler
+from ..login import LoginManager
+
+logger = logging.getLogger(__name__)
+
+login_page = Blueprint('login', __name__)
+
+
+# Index
+@login_page.route('/login', methods=['GET'])
+@exception_handler(__file__)
+def login() -> str:
+    return render_template(
+        'login.html',
+        next=request.args.get('next'),
+        wrong_password=request.args.get('wrong_password'),
+    )
+
+
+# Authenticate the user
+@login_page.route('/login', methods=['POST'])
+@exception_handler(__file__)
+def do_login() -> Response:
+    # Grab our unique user
+    user: LoginManager.User = current_app.login_manager.user_callback()  # type: ignore # noqa: E501
+
+    # Security: Does not check if the next url is compromised
+    next = request.args.get('next')
+
+    # Grab the password
+    password: str = request.form.get('password', '')
+
+    if password == '' or user.password != password:
+        return redirect(url_for('login.login', wrong_password=True, next=next))
+
+    # Set the user as logged in
+    login_user(user)
+
+    # Info
+    logger.info('{user}: logged in'.format(
+        user=user.id,
+    ))
+
+    # Disconnect all sockets
+    current_app.config['_SOCKET'].emit('DISCONNECT', all=True)
+
+    # Redirect the user
+    return redirect(next or url_for('index.index'))
+
+
+# Logout
+@login_page.route('/logout', methods=['GET'])
+@exception_handler(__file__)
+def logout() -> Response:
+    if not isinstance(current_user, AnonymousUserMixin):
+        id = current_user.id
+
+        logout_user()
+
+        # Info
+        logger.info('{user}: logged out'.format(
+            user=id,
+        ))
+
+    # Disconnect all sockets
+    current_app.config['_SOCKET'].emit('DISCONNECT', all=True)
+
+    return redirect(url_for('index.index'))

bricktracker/views/minifigure.py

@@ -0,0 +1,30 @@
+from flask import Blueprint, render_template
+
+from .exceptions import exception_handler
+from ..minifigure import BrickMinifigure
+from ..minifigure_list import BrickMinifigureList
+from ..set_list import BrickSetList
+
+minifigure_page = Blueprint('minifigure', __name__, url_prefix='/minifigures')
+
+
+# Index
+@minifigure_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def list() -> str:
+    return render_template(
+        'minifigures.html',
+        table_collection=BrickMinifigureList().all(),
+    )
+
+
+# Minifigure details
+@minifigure_page.route('/<number>/details')
+@exception_handler(__file__)
+def details(*, number: str) -> str:
+    return render_template(
+        'minifigure.html',
+        item=BrickMinifigure().select_generic(number),
+        using=BrickSetList().using_minifigure(number),
+        missing=BrickSetList().missing_minifigure(number),
+    )

bricktracker/views/part.py

@@ -0,0 +1,60 @@
+from flask import Blueprint, render_template
+
+from .exceptions import exception_handler
+from ..minifigure_list import BrickMinifigureList
+from ..part import BrickPart
+from ..part_list import BrickPartList
+from ..set_list import BrickSetList
+
+part_page = Blueprint('part', __name__, url_prefix='/parts')
+
+
+# Index
+@part_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def list() -> str:
+    return render_template(
+        'parts.html',
+        table_collection=BrickPartList().all()
+    )
+
+
+# Missing
+@part_page.route('/missing', methods=['GET'])
+@exception_handler(__file__)
+def missing() -> str:
+    return render_template(
+        'missing.html',
+        table_collection=BrickPartList().missing()
+    )
+
+
+# Part details
+@part_page.route('/<number>/<int:color>/details', defaults={'element': None}, methods=['GET'])  # noqa: E501
+@part_page.route('/<number>/<int:color>/<int:element>/details', methods=['GET'])  # noqa: E501
+@exception_handler(__file__)
+def details(*, number: str, color: int, element: int | None) -> str:
+    return render_template(
+        'part.html',
+        item=BrickPart().select_generic(number, color, element_id=element),
+        sets_using=BrickSetList().using_part(
+            number,
+            color,
+            element_id=element
+        ),
+        sets_missing=BrickSetList().missing_part(
+            number,
+            color,
+            element_id=element
+        ),
+        minifigures_using=BrickMinifigureList().using_part(
+            number,
+            color,
+            element_id=element
+        ),
+        minifigures_missing=BrickMinifigureList().missing_part(
+            number,
+            color,
+            element_id=element
+        ),
+    )

bricktracker/views/set.py

@@ -0,0 +1,195 @@
+import logging
+
+from flask import (
+    Blueprint,
+    jsonify,
+    render_template,
+    redirect,
+    request,
+    url_for,
+)
+from flask_login import login_required
+from werkzeug.wrappers.response import Response
+
+from .exceptions import exception_handler
+from ..minifigure import BrickMinifigure
+from ..part import BrickPart
+from ..set import BrickSet
+from ..set_list import BrickSetList
+
+logger = logging.getLogger(__name__)
+
+set_page = Blueprint('set', __name__, url_prefix='/sets')
+
+
+# List of all sets
+@set_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def list() -> str:
+    return render_template('sets.html', collection=BrickSetList().all())
+
+
+# Change the set checked status of one set
+@set_page.route('/<id>/checked', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def set_checked(*, id: str) -> Response:
+    state: bool = request.json.get('state', False)  # type: ignore
+
+    brickset = BrickSet().select_specific(id)
+    brickset.update_checked('set_check', state)
+
+    # Info
+    logger.info('Set {number} ({id}): changed set checked status to {state}'.format(  # noqa: E501
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+        state=state,
+    ))
+
+    return jsonify({'state': state})
+
+
+# Change the set collected status of one set
+@set_page.route('/<id>/collected', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def set_collected(*, id: str) -> Response:
+    state: bool = request.json.get('state', False)  # type: ignore
+
+    brickset = BrickSet().select_specific(id)
+    brickset.update_checked('set_col', state)
+
+    # Info
+    logger.info('Set {number} ({id}): changed set collected status to {state}'.format(  # noqa: E501
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+        state=state,
+    ))
+
+    return jsonify({'state': state})
+
+
+# Ask for deletion of a set
+@set_page.route('/<id>/delete', methods=['GET'])
+@login_required
+@exception_handler(__file__)
+def delete(*, id: str) -> str:
+    return render_template(
+        'delete.html',
+        item=BrickSet().select_specific(id),
+        error=request.args.get('error'),
+    )
+
+
+# Actually delete of a set
+@set_page.route('/<id>/delete', methods=['POST'])
+@exception_handler(__file__, post_redirect='set.delete')
+def do_delete(*, id: str) -> Response:
+    brickset = BrickSet().select_specific(id)
+    brickset.delete()
+
+    # Info
+    logger.info('Set {number} ({id}): deleted'.format(
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+    ))
+
+    return redirect(url_for('set.deleted', id=id))
+
+
+# Set is deleted
+@set_page.route('/<id>/deleted', methods=['GET'])
+@exception_handler(__file__)
+def deleted(*, id: str) -> str:
+    return render_template(
+        'success.html',
+        message='Set "{id}" has been successfuly deleted.'.format(id=id),
+    )
+
+
+# Details of one set
+@set_page.route('/<id>/details', methods=['GET'])
+@exception_handler(__file__)
+def details(*, id: str) -> str:
+    return render_template(
+        'set.html',
+        item=BrickSet().select_specific(id),
+        open_instructions=request.args.get('open_instructions'),
+    )
+
+
+# Change the minifigures collected status of one set
+@set_page.route('/sets/<id>/minifigures/collected', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def minifigures_collected(*, id: str) -> Response:
+    state: bool = request.json.get('state', False)  # type: ignore
+
+    brickset = BrickSet().select_specific(id)
+    brickset.update_checked('mini_col', state)
+
+    # Info
+    logger.info('Set {number} ({id}): changed minifigures collected status to {state}'.format(  # noqa: E501
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+        state=state,
+    ))
+
+    return jsonify({'state': state})
+
+
+# Update the missing pieces of a minifig part
+@set_page.route('/<id>/minifigures/<minifigure_id>/parts/<part_id>/missing', methods=['POST'])  # noqa: E501
+@login_required
+@exception_handler(__file__, json=True)
+def missing_minifigure_part(
+    *,
+    id: str,
+    minifigure_id: str,
+    part_id: str
+) -> Response:
+    brickset = BrickSet().select_specific(id)
+    minifigure = BrickMinifigure().select_specific(brickset, minifigure_id)
+    part = BrickPart().select_specific(
+        brickset,
+        part_id,
+        minifigure=minifigure,
+    )
+
+    missing = request.json.get('missing', '')  # type: ignore
+
+    part.update_missing(missing)
+
+    # Info
+    logger.info('Set {number} ({id}): updated minifigure ({minifigure}) part ({part}) missing count to {missing}'.format(  # noqa: E501
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+        minifigure=minifigure.fields.fig_num,
+        part=part.fields.id,
+        missing=missing,
+    ))
+
+    return jsonify({'missing': missing})
+
+
+# Update the missing pieces of a part
+@set_page.route('/<id>/parts/<part_id>/missing', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def missing_part(*, id: str, part_id: str) -> Response:
+    brickset = BrickSet().select_specific(id)
+    part = BrickPart().select_specific(brickset, part_id)
+
+    missing = request.json.get('missing', '')  # type: ignore
+
+    part.update_missing(missing)
+
+    # Info
+    logger.info('Set {number} ({id}): updated part ({part}) missing count to {missing}'.format(  # noqa: E501
+        number=brickset.fields.set_num,
+        id=brickset.fields.u_id,
+        part=part.fields.id,
+        missing=missing,
+    ))
+
+    return jsonify({'missing': missing})

bricktracker/views/upload.py

@@ -0,0 +1,38 @@
+import os
+
+from flask import redirect, request, url_for
+from werkzeug.datastructures import FileStorage
+from werkzeug.wrappers.response import Response
+
+from ..exceptions import ErrorException
+
+
+# Helper for a standard file upload process
+def upload_helper(
+    name: str,
+    endpoint: str,
+    /,
+    extensions: list[str] = [],
+) -> FileStorage | Response:
+    # Bogus submit
+    if name not in request.files:
+        return redirect(url_for(endpoint))
+
+    file = request.files[name]
+
+    # Empty submit
+    if not file or file.filename is None or file.filename == '':
+        return redirect(url_for(endpoint, empty_file=True))
+
+    # Not allowed extension
+    # Security: not really
+    if len(extensions):
+        _, extension = os.path.splitext(file.filename)
+
+        if extension not in extensions:
+            raise ErrorException('{file} extension is not an allowed. Expected: {allowed}'.format(  # noqa: E501
+                file=file.filename,
+                allowed=', '.join(extensions)
+            ))
+
+    return file

bricktracker/views/wish.py

@@ -0,0 +1,47 @@
+from flask import Blueprint, redirect, render_template, request, url_for
+from flask_login import login_required
+from werkzeug.wrappers.response import Response
+
+from .exceptions import exception_handler
+from ..retired_list import BrickRetiredList
+from ..wish import BrickWish
+from ..wish_list import BrickWishList
+
+wish_page = Blueprint('wish', __name__, url_prefix='/wishlist')
+
+
+# Index
+@wish_page.route('/', methods=['GET'])
+@exception_handler(__file__)
+def list() -> str:
+    return render_template(
+        'wishes.html',
+        table_collection=BrickWishList().all(),
+        retired=BrickRetiredList(),
+        error=request.args.get('error')
+    )
+
+
+# Add a set to the wishlit
+@wish_page.route('/add', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='wish.list')
+def add() -> Response:
+    # Grab the set number
+    number: str = request.form.get('number', '')
+
+    if number != '':
+        BrickWishList.add(number)
+
+    return redirect(url_for('wish.list'))
+
+
+# Delete a set from the wishlit
+@wish_page.route('/delete/<number>', methods=['POST'])
+@login_required
+@exception_handler(__file__, post_redirect='wish.list')
+def delete(*, number: str) -> Response:
+    brickwish = BrickWish().select_specific(number)
+    brickwish.delete()
+
+    return redirect(url_for('wish.list'))

bricktracker/wish.py

@@ -0,0 +1,81 @@
+from sqlite3 import Row
+from typing import Any, Self
+
+from flask import url_for
+
+from .exceptions import NotFoundException
+from .set import BrickSet
+from .sql import BrickSQL
+
+
+# Lego brick wished set
+class BrickWish(BrickSet):
+    # Queries
+    select_query: str = 'wish/select'
+    insert_query: str = 'wish/insert'
+
+    def __init__(
+        self,
+        /,
+        record: Row | dict[str, Any] | None = None,
+    ):
+        # Don't init BrickSet, init the parent of BrickSet directly
+        super(BrickSet, self).__init__()
+
+        # Placeholders
+        self.theme_name = ''
+
+        # Ingest the record if it has one
+        if record is not None:
+            self.ingest(record)
+
+            # Resolve the theme
+            self.resolve_theme()
+
+    # Delete a wished set
+    def delete(self, /) -> None:
+        BrickSQL().execute_and_commit(
+            'wish/delete/wish',
+            parameters=self.sql_parameters()
+        )
+
+    # Select a specific part (with a set and an id)
+    def select_specific(self, set_num: str, /) -> Self:
+        # Save the parameters to the fields
+        self.fields.set_num = set_num
+
+        # Load from database
+        record = self.select()
+
+        if record is None:
+            raise NotFoundException(
+                'Wish with number {number} was not found in the database'.format(  # noqa: E501
+                    number=self.fields.set_num,
+                ),
+            )
+
+        # Ingest the record
+        self.ingest(record)
+
+        # Resolve the theme
+        self.resolve_theme()
+
+        return self
+
+    # Deletion url
+    def url_for_delete(self, /) -> str:
+        return url_for('wish.delete', number=self.fields.set_num)
+
+    # Normalize from Rebrickable
+    @staticmethod
+    def from_rebrickable(data: dict[str, Any], /, **_) -> dict[str, Any]:
+        return {
+            'set_num': data['set_num'],
+            'name': data['name'],
+            'year': data['year'],
+            'theme_id': data['theme_id'],
+            'num_parts': data['num_parts'],
+            'set_img_url': data['set_img_url'],
+            'set_url': data['set_url'],
+            'last_modified_dt': data['last_modified_dt'],
+        }

bricktracker/wish_list.py

@@ -0,0 +1,37 @@
+from typing import Self
+
+from flask import current_app
+
+from bricktracker.exceptions import NotFoundException
+
+from .rebrickable_set import RebrickableSet
+from .record_list import BrickRecordList
+from .wish import BrickWish
+
+
+# All the wished sets from the database
+class BrickWishList(BrickRecordList[BrickWish]):
+    # Queries
+    select_query: str = 'wish/list/all'
+
+    # All the wished sets
+    def all(self, /) -> Self:
+        # Load the wished sets from the database
+        for record in self.select(
+            order=current_app.config['WISHES_DEFAULT_ORDER'].value
+        ):
+            brickwish = BrickWish(record=record)
+
+            self.records.append(brickwish)
+
+        return self
+
+    # Add a set to the wishlist
+    @staticmethod
+    def add(set_num: str, /) -> None:
+        # Check if it already exists
+        try:
+            set_num = RebrickableSet.parse_number(set_num)
+            BrickWish().select_specific(set_num)
+        except NotFoundException:
+            RebrickableSet.wish(set_num)

database.py

@@ -1,89 +0,0 @@
-import sqlite3
-from pathlib import Path # creating folders
-import sys
-
-conn = sqlite3.connect('app.db')
-cursor = conn.cursor()
-
-if len(sys.argv) > 1:
-
-    cursor.execute('DELETE FROM sets where u_id="' +sys.argv[1]+ '";')
-    conn.commit()
-
-    cursor.execute('DELETE FROM inventory where u_id="' +sys.argv[1]+ '";')
-    conn.commit()
-
-    cursor.execute('DELETE FROM minifigures where u_id="' +sys.argv[1]+ '";')
-    conn.commit()
-
-    cursor.execute('DELETE FROM missing where u_id="' +sys.argv[1]+ '";')
-    conn.commit()
-
-    cursor.close()
-    conn.close()
-
-    exit()
-
-
-
-
-
-cursor.execute('''DROP TABLE sets''')
-cursor.execute('''DROP TABLE inventory''')
-cursor.execute('''DROP TABLE minifigures''')
-cursor.execute('''DROP TABLE missing''')
-
-cursor.execute('''CREATE TABLE IF NOT EXISTS sets (
-    set_num TEXT,
-    name TEXT,
-    year INTEGER,
-    theme_id INTEGER,
-    num_parts INTEGER,
-    set_img_url TEXT,
-    set_url TEXT,
-    last_modified_dt TEXT,
-    mini_col BOOLEAN,
-    set_check BOOLEAN,
-    set_col BOOLEAN, 
-    u_id TEXT
-)''')
-
-cursor.execute('''CREATE TABLE IF NOT EXISTS inventory (
-    set_num TEXT,
-    id INTEGER,
-    part_num INTEGER,
-    name TEXT,
-    part_img_url TEXT,
-    part_img_url_id TEXT,
-    color_id INTEGER,
-    color_name TEXT,
-    quantity INTEGER,
-    is_spare BOOLEAN,
-    element_id INTEGER,
-    u_id TEXT
-)''')
-
-cursor.execute('''CREATE TABLE IF NOT EXISTS minifigures (
-    fig_num TEXT,
-    set_num TEXT,
-    name TEXT,
-    quantity INTEGER,
-    set_img_url TEXT,
-    u_id TEXT
-)''')
-
-cursor.execute('''CREATE TABLE IF NOT EXISTS missing (
-    set_num TEXT,
-    id INTEGER,
-    part_num INTEGER,
-    part_img_url_id TEXT,
-    color_id INTEGER,
-    quantity INTEGER,
-    element_id INTEGER,
-    u_id TEXT
-)''')
-
-
-
-conn.close()
-

db.py

@@ -1,116 +0,0 @@
-import os
-import sqlite3
-
-def initialize_database():
-    db_path = 'app.db'
-    tables = ['sets', 'inventory', 'minifigures', 'missing']
-    row_counts = {}
-
-    # Connect to the database (this will create the file if it doesn't exist)
-    conn = sqlite3.connect(db_path)
-    cursor = conn.cursor()
-
-    # Create the required tables if they do not exist
-    cursor.execute('''CREATE TABLE IF NOT EXISTS wishlist (
-        set_num TEXT,
-        name TEXT,
-        year INTEGER,
-        theme_id INTEGER,
-        num_parts INTEGER,
-        set_img_url TEXT,
-        set_url TEXT,
-        last_modified_dt TEXT
-    )''')
-
-    cursor.execute('''CREATE TABLE IF NOT EXISTS sets (
-        set_num TEXT,
-        name TEXT,
-        year INTEGER,
-        theme_id INTEGER,
-        num_parts INTEGER,
-        set_img_url TEXT,
-        set_url TEXT,
-        last_modified_dt TEXT,
-        mini_col BOOLEAN,
-        set_check BOOLEAN,
-        set_col BOOLEAN, 
-        u_id TEXT
-    )''')
-
-    cursor.execute('''CREATE TABLE IF NOT EXISTS inventory (
-        set_num TEXT,
-        id INTEGER,
-        part_num INTEGER,
-        name TEXT,
-        part_img_url TEXT,
-        part_img_url_id TEXT,
-        color_id INTEGER,
-        color_name TEXT,
-        quantity INTEGER,
-        is_spare BOOLEAN,
-        element_id INTEGER,
-        u_id TEXT
-    )''')
-
-    cursor.execute('''CREATE TABLE IF NOT EXISTS minifigures (
-        fig_num TEXT,
-        set_num TEXT,
-        name TEXT,
-        quantity INTEGER,
-        set_img_url TEXT,
-        u_id TEXT
-    )''')
-
-    cursor.execute('''CREATE TABLE IF NOT EXISTS missing (
-        set_num TEXT,
-        id INTEGER,
-        part_num TEXT,
-        part_img_url_id TEXT,
-        color_id INTEGER,
-        quantity INTEGER,
-        element_id INTEGER,
-        u_id TEXT
-    )''')
-    
-    # Commit the changes
-    conn.commit()
-    conn.close()
-
-def get_rows():
-    db_path = 'app.db'
-    tables = ['sets', 'inventory', 'minifigures', 'missing']
-    row_counts = {}
-
-    # Connect to the database (this will create the file if it doesn't exist)
-    conn = sqlite3.connect(db_path)
-    cursor = conn.cursor()
-    
-    # Get the row count for each table
-    for table in tables:
-        cursor.execute(f"SELECT COUNT(*) FROM {table}")
-        row_count = cursor.fetchone()[0]
-        row_counts[table] = row_count
-
-    # Close the connection
-    conn.close()
-
-    return row_counts
-
-
-def delete_tables():
-    db_path = 'app.db'
-    tables = ['sets', 'inventory', 'minifigures', 'missing']
-    row_counts = {}
-
-    # Connect to the database (this will create the file if it doesn't exist)
-    conn = sqlite3.connect(db_path)
-    cursor = conn.cursor()
-
-    cursor.execute('''DROP TABLE sets''')
-    cursor.execute('''DROP TABLE inventory''')
-    cursor.execute('''DROP TABLE minifigures''')
-    cursor.execute('''DROP TABLE missing''')
-
-    # Close the connection
-    conn.close()
-