FrederikBaerentsen/BrickTracker
4
6
Fork 6
Code Issues 13 Pull Requests 2 Actions Packages Projects 1 Releases 3 Wiki Activity

Merge remote-tracking branch 'origin/master' into instructions

Browse Source
This commit is contained in:
FrederikBaerentsen 2025-01-24 19:40:30 +01:00
commit 6abf4a314f
198 changed files with 3436 additions and 1888 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.dockerignore
View File

@ -19,6 +19,8 @@ LICENSE
# Database
*.db
*.db-shm
*.db-wal
# Python
**/__pycache__

67
.env.sample
View File

@ -4,13 +4,13 @@
# 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].
# 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)
# - "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.
@ -117,10 +117,10 @@
# 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
# - "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 '/app/static/' folder
# Default: minifigs
@ -134,12 +134,13 @@
# 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
# - "inventory"."part_num": part number
# - "inventory"."name": part name
# - "inventory"."color_name": part color name
# - "inventory"."is_spare": par is a spare part
# - "total_missing": number of missing parts
# Default: "inventory"."name" ASC, "inventory"."color_name" ASC, "inventory"."is_spare" ASC
# BK_PARTS_DEFAULT_ORDER="total_missing" DESC, "inventory"."name" ASC
# Optional: Folder where to store the parts images, relative to the '/app/static/' folder
# Default: parts
@ -177,10 +178,6 @@
# 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
@ -201,16 +198,16 @@
# 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
# - "rebrickable_sets"."set": set number as a string
# - "rebrickable_sets"."number": the number part of set as an integer
# - "rebrickable_sets"."version": the version part of set as an integer
# - "rebrickable_sets"."name": set name
# - "rebrickable_sets"."year": set release year
# - "rebrickable_sets"."number_of_parts": set number of parts
# - "total_missing": number of missing parts
# - "total_minifigures": number of minifigures
# Default: "rebrickable_sets"."number" DESC, "rebrickable_sets"."version" ASC
# BK_SETS_DEFAULT_ORDER="rebrickable_sets"."year" ASC
# Optional: Folder where to store the sets images, relative to the '/app/static/' folder
# Default: sets
@ -249,9 +246,9 @@
# 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
# - "bricktracker_wishes"."set": set number as a string
# - "bricktracker_wishes"."name": set name
# - "bricktracker_wishes"."year": set release year
# - "bricktracker_wishes"."number_of_parts": set number of parts
# Default: "bricktracker_wishes"."rowid" DESC
# BK_WISHES_DEFAULT_ORDER="bricktracker_wishes"."set" DESC

3
.gitignore vendored
View File

@ -1,6 +1,8 @@
# Application
.env
*.db
*.db-shm
*.db-wal
# Python specifics
__pycache__/
@ -9,6 +11,7 @@ __pycache__/
# Static folders
static/instructions/
static/minifigs/
static/minifigures/
static/parts/
static/sets/

196
CHANGELOG.md Normal file
View File

@ -0,0 +1,196 @@
# Changelog
## 1.1.0: Deduped sets, custom checkboxes and database upgrade
### Database
- Sets
- Deduplicating rebrickable sets (unique) and bricktracker sets (can be n bricktracker sets for one rebrickable set)
### Docs
- Removed extra `<br>` to accomodate Gitea Markdown
- Add an organized DOCS.md documentation page
- Database upgrade/migration
- Checkboxes
### Code
- Admin
- Split the views before admin because an unmanageable monster view
- Checkboxes
- Customizable checkboxes for set (amount and names, displayed on the grid or not)
- Replaced the 3 original routes to update the status with a generic route to accomodate any custom status
- Instructions
- Base instructions on RebrickableSet (the generic one) rather than BrickSet (the specific one)
- Refine set number detection in file name by making sure each first items is an integer
- Python
- Make stricter function definition with no "arg_or_keyword" parameters
- Records
- Consolidate the select() -> not None or Exception -> ingest() process duplicated in every child class
- SQL
- Forward-only migration mechanism
- Check for database too far in version
- Inject the database version in the file when downloading it
- Quote all indentifiers as best practice
- Allow insert query to be overriden
- Allow insert query to force not being deferred even if not committed
- Allow select query to push context in BrickRecord and BrickRecordList
- Make SQL record counters failsafe as they are used in the admin and it should always work
- Remove BrickSQL.initialize() as it is replaced by upgrade()
- Sets
- Now that it is deduplicated, adding the same set more than once will not pull it fully from the Rebrickable API (minifigures and parts)
- Make RebrickableSet extend BrickRecord since it is now an item in database
- Make BrickSet extend RebrickableSet now that RebrickableSet is a proper database item
### UI
- Checkboxes
- Possibility to hide the checkbox in the grid ("Sets") but sill have all them in the set details
- Management
- Database
- Migration tool
- Javascript
- Generic BrickChanger class to handle quick modification through a JSON request with a visual feedback indicator
- Simplify the way javascript scripts are loaded and instantiated
- Set grid
- Filter by checkboxes and NOT checkboxes
- Tables
- Fix table search looking inside links pills
- Wishlist
- Add Rebrickable link badge for sets (@matthew)
## 1.0.0: New Year revamp
### Code
- Authentication
- Basic authentication mechanism with ONE password to protect admin and writes
- CSV
- Remove dependencies to numpy and panda for simpler built-in csv
- Code
- Refactored the Python code
- Modularity (more functions, splitting files)
- Type hinting whenever possible
- Flake8 linter
- Retained most of the original behaviour (with its quirks)
- Colors
- Remove dependency on color.csv
- Configuration
- Moved all the hard-coded parameters into configuration variables
- Most of the variables are configuration through environment variables
- Force instruction, sets, etc path to be relative to static
- Docker
- Added an entrypoint to grab PORT / HOST from the environment if set
- Remove the need to seed the container with files (*.csv, nil files)
- Flask
- Fix improper socketio.run(app.run()) call which lead to hard crash on ^C
- Make use of url_for to create URLs
- Use blueprints to implement routes
- Move views into their own files
- Split GET and POST methods into two different routes for clarity
- Images
- Add an option to use remote images from the Rebrickable CDN rather than downloading everything locally
- Handle nil.png and nil_mf.jpg as true images in /static/sets/ so that they are downloaded whenever necessary when importing a se with missing images
- Instructions
- Scan the files once for the whole app, and re-use the data
- Refresh the instructions from the admin
- More lenient set number detection
- Update when uploading a new one
- Basic file management
- Logs
- Added log lines for change actions (add, check, missing, delete) so that the server is not silent when DEBUG=false
- Minifigures
- Added a variable to control default ordering
- Part(s)
- Added a variable to control default ordering of listing
- Retired sets
- Open the themes once for the whole app, and re-use the data
- Do not hard fail if themes.csv is missing, simply display the IDs
- Light management: resync, download
- Set(s)
- Reworked the set checkboxes with a dedicated route per status
- Switch from homemade ID generator to proven UUID4 for sets ID
- Does not interfere with previously created sets
- Do not rely on sets.csv to check if the set exists
- When adding, commit the set to database only once everything has been processed
- Added a bulk add page
- Keep spare parts when importing
- Added a variable to control default ordering of listing
- Socket
- Make use of socket.io rooms to avoid broadcasting messages to all clients
- SQLite
- Do not hard fail if the database is not present or not initialized
- Open the database once for the context, and re-use the connection
- Move queries to .sql files and load them as Jinja templates
- Use named arguments rather than sets for SQLite queries
- Allow execute() to be deferred to the commit() call to avoid locking the database for long period while importing (locked while downloading images)
- Themes
- Open the themes once for the whole app, and re-use the data
- Do not hard fail if themes.csv is missing, simply display the IDs
- Light management: resync, download
### UI
- Admin
- Initialize the database from the web interface
- Reset the database
- Delete the database
- Download the database
- Import the database
- Display the configuration variables
- Many things
- Accordions
- Added a flag to make the accordion items independent
- Branding:
- Add a brick as a logo (CC0 image from: https://iconduck.com/icons/71631/brick)
- Global
- Redesign of the whole app
- Sticky menu bar on top of the page
- Execution time and SQL stats for fun
- Libraries
- Switch from Bulma to Bootstrap, arbitrarily :D
- Use of baguettebox for images (https://github.com/feimosi/baguetteBox.js)
- Use of tinysort to sort and filter the grid (https://github.com/Sjeiti/TinySort)
- Use of sortable for set card tables (https://github.com/tofsjonas/sortable)
- Use of simple-datatables for big tables (https://github.com/fiduswriter/simple-datatables)
- Minifigures
- Added a detail view for a minifigure
- Display which sets are using a minifigure
- Display which sets are missing a minifigure
- Parts
- Added a detail view for a part
- Display which sets are using a part
- Display which sets are missing a part
- Templates
- Use a common base template
- Use HTML fragments/macros for repeted or parametrics items
- a 404 page for wrong URLs
- an error page for expected error messages
- an exception page for unexpected error messages
- Set add
- Two-tiered (with override) import where you see what you will import before importing it
- Add a visual indicator that the socket is connected
- Set card
- Badges to display info like theme, year, parts, etc
- Set image on top of the card, filling the space
- Trick to have a blurry background image fill the void in the card
- Save missing parts on input change rather than by clicking
- Visual feedback of success
- Parts and minifigure in accordions
- Instructions file list
- Set grid
- 4-2-1 card distribution depending on screen size
- Display the index with no set added, rather than redirecting
- Keep last sort in a cookie, and trigger it on page load (can be cleared)

4
README.md
View File

@ -27,6 +27,6 @@ See [first steps](docs/first-steps.md).
## Documentation
Most of the pages should be self explanatory to use.
However, you can find more specific documentation in the [docs](docs/) folder.
However, you can find more specific documentation in the [documentation](docs/DOCS.md).
You can find screenshots of the application in the [bricktracker](docs/bricktracker.md) documentation file.
You can find screenshots of the application in the [overview](docs/overview.md) documentation file.

44
app.py
View File

@ -11,28 +11,44 @@ from bricktracker.socket import BrickSocket # noqa: E402
logger = logging.getLogger(__name__)
# Create the Flask app
app = Flask(__name__)
# Setup the app
setup_app(app)
# Create the app
# Using 'app' globally interferse with the teardown handlers of Flask
def create_app(main: bool = False, /) -> Flask | BrickSocket:
# Create the Flask app
app = Flask(__name__)
# Create the socket
s = BrickSocket(
# Setup the app
setup_app(app)
# Create the socket
s = BrickSocket(
app,
threaded=not app.config['NO_THREADED_SOCKET'].value,
)
threaded=not app.config['NO_THREADED_SOCKET'],
)
if main:
return s
else:
return app
if __name__ == '__main__':
s = create_app(True)
# This never happens, but makes the linter happy
if isinstance(s, Flask):
logger.critical('Cannot run locally with a Flask object, needs a BrickSocket. Use create_app(True) to return a BrickSocket') # noqa: E501
exit(1)
# Run the application
logger.info('Starting BrickTracker on {host}:{port}'.format(
host=app.config['HOST'].value,
port=app.config['PORT'].value,
host=s.app.config['HOST'],
port=s.app.config['PORT'],
))
s.socket.run(
app,
host=app.config['HOST'].value,
debug=app.config['DEBUG'].value,
port=app.config['PORT'].value,
s.app,
host=s.app.config['HOST'],
debug=s.app.config['DEBUG'],
port=s.app.config['PORT'],
)

28
bricktracker/app.py
View File

@ -12,7 +12,13 @@ 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.admin.admin import admin_page
from bricktracker.views.admin.checkbox import admin_checkbox_page
from bricktracker.views.admin.database import admin_database_page
from bricktracker.views.admin.image import admin_image_page
from bricktracker.views.admin.instructions import admin_instructions_page
from bricktracker.views.admin.retired import admin_retired_page
from bricktracker.views.admin.theme import admin_theme_page
from bricktracker.views.error import error_404
from bricktracker.views.index import index_page
from bricktracker.views.instructions import instructions_page
@ -28,7 +34,7 @@ def setup_app(app: Flask) -> None:
BrickConfigurationList(app)
# Set the logging level
if app.config['DEBUG'].value:
if app.config['DEBUG']:
logging.basicConfig(
stream=sys.stdout,
level=logging.DEBUG,
@ -60,9 +66,8 @@ def setup_app(app: Flask) -> None:
# Register errors
app.register_error_handler(404, error_404)
# Register routes
# Register app 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)
@ -71,6 +76,15 @@ def setup_app(app: Flask) -> None:
app.register_blueprint(set_page)
app.register_blueprint(wish_page)
# Register admin routes
app.register_blueprint(admin_page)
app.register_blueprint(admin_checkbox_page)
app.register_blueprint(admin_database_page)
app.register_blueprint(admin_image_page)
app.register_blueprint(admin_instructions_page)
app.register_blueprint(admin_retired_page)
app.register_blueprint(admin_theme_page)
# An helper to make global variables available to the
# request
@app.before_request
@ -90,12 +104,12 @@ def setup_app(app: Flask) -> None:
g.request_time = request_time
# Register the timezone
g.timezone = ZoneInfo(current_app.config['TIMEZONE'].value)
g.timezone = ZoneInfo(current_app.config['TIMEZONE'])
# Version
g.version = __version__
# Make sure all connections are closed at the end
@app.teardown_appcontext
def close_connections(exception, /) -> None:
@app.teardown_request
def teardown_request(_: BaseException | None) -> None:
close()

9
bricktracker/config.py
View File

@ -31,10 +31,10 @@ CONFIG: Final[list[dict[str, Any]]] = [
{'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_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_DEFAULT_ORDER', 'd': '"inventory"."name" ASC, "inventory"."color_name" ASC, "inventory"."is_spare" ASC'}, # noqa: E501
{'n': 'PARTS_FOLDER', 'd': 'parts', 's': True},
{'n': 'PORT', 'd': 3333, 'c': int},
{'n': 'RANDOM', 'e': 'RANDOM', 'c': bool},
@ -43,12 +43,11 @@ CONFIG: Final[list[dict[str, Any]]] = [
{'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_DEFAULT_ORDER', 'd': '"rebrickable_sets"."number" DESC, "rebrickable_sets"."version" ASC'}, # noqa: E501
{'n': 'SETS_FOLDER', 'd': 'sets', 's': True},
{'n': 'SKIP_SPARE_PARTS', 'c': bool},
{'n': 'SOCKET_NAMESPACE', 'd': 'bricksocket'},
@ -57,5 +56,5 @@ CONFIG: Final[list[dict[str, Any]]] = [
{'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'},
{'n': 'WISHES_DEFAULT_ORDER', 'd': '"bricktracker_wishes"."rowid" DESC'},
]

2
bricktracker/configuration.py
View File

@ -16,6 +16,7 @@ class BrickConfiguration(object):
def __init__(
self,
/,
*,
n: str,
e: str | None = None,
d: Any = None,
@ -69,6 +70,7 @@ class BrickConfiguration(object):
# Remove static prefix
value = value.removeprefix('static/')
# Type casting
if self.cast is not None:
self.value = self.cast(value)
else:

38
bricktracker/configuration_list.py
View File

@ -1,46 +1,60 @@
import logging
from typing import Generator
from flask import current_app, Flask
from flask import Flask
from .config import CONFIG
from .configuration import BrickConfiguration
from .exceptions import ConfigurationMissingException
logger = logging.getLogger(__name__)
# Application configuration
class BrickConfigurationList(object):
app: Flask
configurations: dict[str, BrickConfiguration]
# Load configuration
def __init__(self, app: Flask, /):
self.app = app
# Load the configurations only there is none already loaded
configurations = getattr(self, 'configurations', None)
if configurations is None:
logger.info('Loading configuration variables')
BrickConfigurationList.configurations = {}
# Process all configuration items
for config in CONFIG:
item = BrickConfiguration(**config)
self.app.config[item.name] = item
# Store in the list
BrickConfigurationList.configurations[item.name] = item
# Only store the value in the app to avoid breaking any
# existing variables
self.app.config[item.name] = item.value
# Check whether a str configuration is set
@staticmethod
def error_unless_is_set(name: str):
config: BrickConfiguration = current_app.config[name]
configuration = BrickConfigurationList.configurations[name]
if config.value is None or config.value == '':
if configuration.value is None or configuration.value == '':
raise ConfigurationMissingException(
'{name} must be defined (using the {environ} environment variable)'.format( # noqa: E501
name=config.name,
environ=config.env_name
name=name,
environ=configuration.env_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()
keys = sorted(BrickConfigurationList.configurations.keys())
for name in keys:
config = current_app.config[name]
if isinstance(config, BrickConfiguration):
yield config
yield BrickConfigurationList.configurations[name]

3
bricktracker/fields.py
View File

@ -4,6 +4,9 @@ from typing import Any
# SQLite record fields
class BrickRecordFields(object):
def __getattr__(self, name: str, /) -> Any:
if name not in self.__dict__:
raise AttributeError(name)
return self.__dict__[name]
def __setattr__(self, name: str, value: Any, /) -> None:

31
bricktracker/instructions.py
View File

@ -13,18 +13,18 @@ from bs4 import BeautifulSoup
from .exceptions import ErrorException
if TYPE_CHECKING:
from .set import BrickSet
from .rebrickable_set import RebrickableSet
logger = logging.getLogger(__name__)
class BrickInstructions(object):
allowed: bool
brickset: 'BrickSet | None'
rebrickable: 'RebrickableSet | None'
extension: str
filename: str
mtime: datetime
number: 'str | None'
set: 'str | None'
name: str
size: int
@ -42,11 +42,11 @@ class BrickInstructions(object):
# 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
self.allowed = self.extension in current_app.config['INSTRUCTIONS_ALLOWED_EXTENSIONS'] # noqa: E501
# Placeholder
self.brickset = None
self.number = None
self.rebrickable = None
self.set = None
# Extract the set number
if self.allowed:
@ -57,7 +57,14 @@ class BrickInstructions(object):
splits = normalized.split('-', 2)
if len(splits) >= 2:
self.number = '-'.join(splits[:2])
try:
# Trying to make sense of each part as integers
int(splits[0])
int(splits[1])
self.set = '-'.join(splits[:2])
except Exception:
pass
# Delete an instruction file
def delete(self, /) -> None:
@ -70,17 +77,17 @@ class BrickInstructions(object):
# 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
current_app.config['FILE_DATETIME_FORMAT']
)
# Compute the path of an instruction file
def path(self, /, filename=None) -> str:
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,
current_app.config['INSTRUCTIONS_FOLDER'],
filename
)
@ -102,7 +109,7 @@ class BrickInstructions(object):
# Upload a new instructions file
def upload(self, file: FileStorage, /) -> None:
target = self.path(secure_filename(self.filename))
target = self.path(filename=secure_filename(self.filename))
if os.path.isfile(target):
raise ErrorException('Cannot upload {target} as it already exists'.format( # noqa: E501
@ -180,7 +187,7 @@ class BrickInstructions(object):
if not self.allowed:
return ''
folder: str = current_app.config['INSTRUCTIONS_FOLDER'].value
folder: str = current_app.config['INSTRUCTIONS_FOLDER']
# Compute the path
path = os.path.join(folder, self.filename)

48
bricktracker/instructions_list.py
View File

@ -1,11 +1,14 @@
import logging
import os
from typing import Generator
from typing import Generator, TYPE_CHECKING
from flask import current_app
from .exceptions import NotFoundException
from .instructions import BrickInstructions
from .rebrickable_set_list import RebrickableSetList
if TYPE_CHECKING:
from .rebrickable_set import RebrickableSet
logger = logging.getLogger(__name__)
@ -18,7 +21,7 @@ class BrickInstructionsList(object):
sets_total: int
unknown_total: int
def __init__(self, /, force=False):
def __init__(self, /, *, force=False):
# Load instructions only if there is none already loaded
all = getattr(self, 'all', None)
@ -36,7 +39,7 @@ class BrickInstructionsList(object):
# Make a folder relative to static
folder: str = os.path.join(
current_app.static_folder, # type: ignore
current_app.config['INSTRUCTIONS_FOLDER'].value,
current_app.config['INSTRUCTIONS_FOLDER'],
)
for file in os.scandir(folder):
@ -46,47 +49,40 @@ class BrickInstructionsList(object):
BrickInstructionsList.all[instruction.filename] = instruction # noqa: E501
if instruction.allowed:
if instruction.number:
if instruction.set:
# Instantiate the list if not existing yet
if instruction.number not in BrickInstructionsList.sets: # noqa: E501
BrickInstructionsList.sets[instruction.number] = [] # noqa: E501
if instruction.set not in BrickInstructionsList.sets: # noqa: E501
BrickInstructionsList.sets[instruction.set] = [] # noqa: E501
BrickInstructionsList.sets[instruction.number].append(instruction) # noqa: E501
BrickInstructionsList.sets[instruction.set].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
# List of Rebrickable sets
rebrickable_sets: dict[str, RebrickableSet] = {}
for rebrickable_set in RebrickableSetList().all():
rebrickable_sets[rebrickable_set.fields.set] = rebrickable_set # noqa: E501
# 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
for instruction in self.all.values():
if (
instruction.allowed and
instruction.number is not None and
instruction.brickset is None and
instruction.number in bricksets
instruction.set is not None and
instruction.rebrickable is None and
instruction.set in rebrickable_sets
):
instruction.brickset = bricksets[instruction.number]
instruction.rebrickable = rebrickable_sets[instruction.set] # noqa: E501
# 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]
def get(self, set: str) -> list[BrickInstructions]:
if set in self.sets:
return self.sets[set]
else:
return []

6
bricktracker/login.py
View File

@ -12,7 +12,7 @@ class LoginManager(object):
def __init__(self, app: Flask, /):
# Setup basic authentication
app.secret_key = app.config['AUTHENTICATION_KEY'].value
app.secret_key = app.config['AUTHENTICATION_KEY']
manager = login_manager.LoginManager()
manager.login_view = 'login.login' # type: ignore
@ -23,11 +23,11 @@ class LoginManager(object):
def user_loader(*arg) -> LoginManager.User:
return self.User(
'admin',
app.config['AUTHENTICATION_PASSWORD'].value
app.config['AUTHENTICATION_PASSWORD']
)
# If the password is unset, globally disable
app.config['LOGIN_DISABLED'] = app.config['AUTHENTICATION_PASSWORD'].value == '' # noqa: E501
app.config['LOGIN_DISABLED'] = app.config['AUTHENTICATION_PASSWORD'] == '' # noqa: E501
# Tells whether the user is authenticated, meaning:
# - Authentication disabled

34
bricktracker/minifigure.py
View File

@ -23,6 +23,7 @@ class BrickMinifigure(BrickRecord):
def __init__(
self,
/,
*,
brickset: 'BrickSet | None' = None,
record: Row | dict[str, Any] | None = None,
):
@ -61,18 +62,13 @@ class BrickMinifigure(BrickRecord):
# Save the parameters to the fields
self.fields.fig_num = fig_num
record = self.select(override_query=self.generic_query)
if record is None:
if not self.select(override_query=self.generic_query):
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)
@ -81,19 +77,14 @@ class BrickMinifigure(BrickRecord):
self.brickset = brickset
self.fields.fig_num = fig_num
record = self.select()
if record is None:
if not self.select():
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,
set=self.brickset.fields.set,
),
)
# Ingest the record
self.ingest(record)
return self
# Return a dict with common SQL parameters for a minifigure
@ -103,10 +94,10 @@ class BrickMinifigure(BrickRecord):
# Supplement from the brickset
if self.brickset is not None:
if 'u_id' not in parameters:
parameters['u_id'] = self.brickset.fields.u_id
parameters['u_id'] = self.brickset.fields.id
if 'set_num' not in parameters:
parameters['set_num'] = self.brickset.fields.set_num
parameters['set_num'] = self.brickset.fields.set
return parameters
@ -119,7 +110,7 @@ class BrickMinifigure(BrickRecord):
# Compute the url for minifigure part image
def url_for_image(self, /) -> str:
if not current_app.config['USE_REMOTE_IMAGES'].value:
if not current_app.config['USE_REMOTE_IMAGES']:
if self.fields.set_img_url is None:
file = RebrickableImage.nil_minifigure_name()
else:
@ -128,15 +119,15 @@ class BrickMinifigure(BrickRecord):
return RebrickableImage.static_url(file, 'MINIFIGURES_FOLDER')
else:
if self.fields.set_img_url is None:
return current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE'].value # noqa: E501
return current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE']
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:
if current_app.config['REBRICKABLE_LINKS']:
try:
return current_app.config['REBRICKABLE_LINK_MINIFIGURE_PATTERN'].value.format( # noqa: E501
return current_app.config['REBRICKABLE_LINK_MINIFIGURE_PATTERN'].format( # noqa: E501
number=self.fields.fig_num.lower(),
)
except Exception:
@ -149,6 +140,7 @@ class BrickMinifigure(BrickRecord):
def from_rebrickable(
data: dict[str, Any],
/,
*,
brickset: 'BrickSet | None' = None,
**_,
) -> dict[str, Any]:
@ -160,7 +152,7 @@ class BrickMinifigure(BrickRecord):
}
if brickset is not None:
record['set_num'] = brickset.fields.set_num
record['u_id'] = brickset.fields.u_id
record['set_num'] = brickset.fields.set
record['u_id'] = brickset.fields.id
return record

12
bricktracker/minifigure_list.py
View File

@ -27,7 +27,7 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
self.brickset = None
# Store the order for this list
self.order = current_app.config['MINIFIGURES_DEFAULT_ORDER'].value
self.order = current_app.config['MINIFIGURES_DEFAULT_ORDER']
# Load all minifigures
def all(self, /) -> Self:
@ -42,9 +42,9 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
return self
# Last added minifigure
def last(self, /, limit: int = 6) -> Self:
def last(self, /, *, limit: int = 6) -> Self:
# Randomize
if current_app.config['RANDOM'].value:
if current_app.config['RANDOM']:
order = 'RANDOM()'
else:
order = 'minifigures.rowid DESC'
@ -78,8 +78,8 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
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
parameters['u_id'] = self.brickset.fields.id
parameters['set_num'] = self.brickset.fields.set
return parameters
@ -89,6 +89,7 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
part_num: str,
color_id: int,
/,
*,
element_id: int | None = None,
) -> Self:
# Save the parameters to the fields
@ -113,6 +114,7 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
part_num: str,
color_id: int,
/,
*,
element_id: int | None = None,
) -> Self:
# Save the parameters to the fields

38
bricktracker/part.py
View File

@ -27,6 +27,7 @@ class BrickPart(BrickRecord):
def __init__(
self,
/,
*,
brickset: 'BrickSet | None' = None,
minifigure: 'BrickMinifigure | None' = None,
record: Row | dict[str, Any] | None = None,
@ -83,6 +84,7 @@ class BrickPart(BrickRecord):
part_num: str,
color_id: int,
/,
*,
element_id: int | None = None
) -> Self:
# Save the parameters to the fields
@ -90,9 +92,7 @@ class BrickPart(BrickRecord):
self.fields.color_id = color_id
self.fields.element_id = element_id
record = self.select(override_query=self.generic_query)
if record is None:
if not self.select(override_query=self.generic_query):
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,
@ -101,9 +101,6 @@ class BrickPart(BrickRecord):
),
)
# Ingest the record
self.ingest(record)
return self
# Select a specific part (with a set and an id, and option. a minifigure)
@ -112,6 +109,7 @@ class BrickPart(BrickRecord):
brickset: 'BrickSet',
id: str,
/,
*,
minifigure: 'BrickMinifigure | None' = None,
) -> Self:
# Save the parameters to the fields
@ -119,19 +117,14 @@ class BrickPart(BrickRecord):
self.minifigure = minifigure
self.fields.id = id
record = self.select()
if record is None:
if not self.select():
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,
set=self.brickset.fields.set,
),
)
# Ingest the record
self.ingest(record)
return self
# Return a dict with common SQL parameters for a part
@ -140,14 +133,14 @@ class BrickPart(BrickRecord):
# Supplement from the brickset
if 'u_id' not in parameters and self.brickset is not None:
parameters['u_id'] = self.brickset.fields.u_id
parameters['u_id'] = self.brickset.fields.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
parameters['set_num'] = self.brickset.fields.set
return parameters
@ -190,9 +183,9 @@ class BrickPart(BrickRecord):
# Compute the url for the bricklink page
def url_for_bricklink(self, /) -> str:
if current_app.config['BRICKLINK_LINKS'].value:
if current_app.config['BRICKLINK_LINKS']:
try:
return current_app.config['BRICKLINK_LINK_PART_PATTERN'].value.format( # noqa: E501
return current_app.config['BRICKLINK_LINK_PART_PATTERN'].format( # noqa: E501
number=self.fields.part_num,
)
except Exception:
@ -202,7 +195,7 @@ class BrickPart(BrickRecord):
# Compute the url for the part image
def url_for_image(self, /) -> str:
if not current_app.config['USE_REMOTE_IMAGES'].value:
if not current_app.config['USE_REMOTE_IMAGES']:
if self.fields.part_img_url is None:
file = RebrickableImage.nil_name()
else:
@ -211,7 +204,7 @@ class BrickPart(BrickRecord):
return RebrickableImage.static_url(file, 'PARTS_FOLDER')
else:
if self.fields.part_img_url is None:
return current_app.config['REBRICKABLE_IMAGE_NIL'].value
return current_app.config['REBRICKABLE_IMAGE_NIL']
else:
return self.fields.part_img_url
@ -234,9 +227,9 @@ class BrickPart(BrickRecord):
# Compute the url for the rebrickable page
def url_for_rebrickable(self, /) -> str:
if current_app.config['REBRICKABLE_LINKS'].value:
if current_app.config['REBRICKABLE_LINKS']:
try:
return current_app.config['REBRICKABLE_LINK_PART_PATTERN'].value.format( # noqa: E501
return current_app.config['REBRICKABLE_LINK_PART_PATTERN'].format( # noqa: E501
number=self.fields.part_num,
color=self.fields.color_id,
)
@ -250,6 +243,7 @@ class BrickPart(BrickRecord):
def from_rebrickable(
data: dict[str, Any],
/,
*,
brickset: 'BrickSet | None' = None,
minifigure: 'BrickMinifigure | None' = None,
**_,
@ -269,7 +263,7 @@ class BrickPart(BrickRecord):
}
if brickset is not None:
record['u_id'] = brickset.fields.u_id
record['u_id'] = brickset.fields.id
if minifigure is not None:
record['set_num'] = data['fig_num']

17
bricktracker/part_list.py
View File

@ -30,7 +30,7 @@ class BrickPartList(BrickRecordList[BrickPart]):
self.minifigure = None
# Store the order for this list
self.order = current_app.config['PARTS_DEFAULT_ORDER'].value
self.order = current_app.config['PARTS_DEFAULT_ORDER']
# Load all parts
def all(self, /) -> Self:
@ -49,6 +49,7 @@ class BrickPartList(BrickRecordList[BrickPart]):
self,
brickset: 'BrickSet',
/,
*,
minifigure: 'BrickMinifigure | None' = None,
) -> Self:
# Save the brickset and minifigure
@ -63,10 +64,7 @@ class BrickPartList(BrickRecordList[BrickPart]):
record=record,
)
if (
current_app.config['SKIP_SPARE_PARTS'].value and
part.fields.is_spare
):
if current_app.config['SKIP_SPARE_PARTS'] and part.fields.is_spare:
continue
self.records.append(part)
@ -92,10 +90,7 @@ class BrickPartList(BrickRecordList[BrickPart]):
record=record,
)
if (
current_app.config['SKIP_SPARE_PARTS'].value and
part.fields.is_spare
):
if current_app.config['SKIP_SPARE_PARTS'] and part.fields.is_spare:
continue
self.records.append(part)
@ -120,13 +115,13 @@ class BrickPartList(BrickRecordList[BrickPart]):
# Set id
if self.brickset is not None:
parameters['u_id'] = self.brickset.fields.u_id
parameters['u_id'] = self.brickset.fields.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
parameters['set_num'] = self.brickset.fields.set
return parameters

35
bricktracker/rebrickable.py
View File

@ -9,11 +9,12 @@ from .exceptions import NotFoundException, ErrorException
if TYPE_CHECKING:
from .minifigure import BrickMinifigure
from .part import BrickPart
from .rebrickable_set import RebrickableSet
from .set import BrickSet
from .socket import BrickSocket
from .wish import BrickWish
T = TypeVar('T', 'BrickSet', 'BrickPart', 'BrickMinifigure', 'BrickWish')
T = TypeVar('T', 'RebrickableSet', 'BrickPart', 'BrickMinifigure', 'BrickWish')
# An helper around the rebrick library, autoconverting
@ -23,10 +24,11 @@ class Rebrickable(Generic[T]):
number: str
model: Type[T]
socket: 'BrickSocket | None'
brickset: 'BrickSet | None'
minifigure: 'BrickMinifigure | None'
instance: T | None
kind: str
minifigure: 'BrickMinifigure | None'
socket: 'BrickSocket | None'
def __init__(
self,
@ -34,9 +36,11 @@ class Rebrickable(Generic[T]):
number: str,
model: Type[T],
/,
socket: 'BrickSocket | None' = None,
*,
brickset: 'BrickSet | None' = None,
minifigure: 'BrickMinifigure | None' = None
instance: T | None = None,
minifigure: 'BrickMinifigure | None' = None,
socket: 'BrickSocket | None' = None,
):
if not hasattr(lego, method):
raise ErrorException('{method} is not a valid method for the rebrick.lego module'.format( # noqa: E501
@ -48,9 +52,10 @@ class Rebrickable(Generic[T]):
self.number = number
self.model = model
self.socket = socket
self.brickset = brickset
self.instance = instance
self.minifigure = minifigure
self.socket = socket
if self.minifigure is not None:
self.kind = 'Minifigure'
@ -61,13 +66,15 @@ class Rebrickable(Generic[T]):
def get(self, /) -> T:
model_parameters = self.model_parameters()
return self.model(
**model_parameters,
record=self.model.from_rebrickable(
if self.instance is None:
self.instance = self.model(**model_parameters)
self.instance.ingest(self.model.from_rebrickable(
self.load(),
brickset=self.brickset,
),
)
))
return self.instance
# Get paginated elements from the Rebrickable API
def list(self, /) -> list[T]:
@ -77,7 +84,7 @@ class Rebrickable(Generic[T]):
# Bootstrap a first set of parameters
parameters: dict[str, Any] | None = {
'page_size': current_app.config['REBRICKABLE_PAGE_SIZE'].value,
'page_size': current_app.config['REBRICKABLE_PAGE_SIZE'],
}
# Read all pages
@ -113,9 +120,9 @@ class Rebrickable(Generic[T]):
return results
# Load from the API
def load(self, /, parameters: dict[str, Any] = {}) -> dict[str, Any]:
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
parameters['api_key'] = current_app.config['REBRICKABLE_API_KEY']
try:
return json.loads(

29
bricktracker/rebrickable_image.py
View File

@ -10,12 +10,12 @@ from .exceptions import DownloadException
if TYPE_CHECKING:
from .minifigure import BrickMinifigure
from .part import BrickPart
from .set import BrickSet
from .rebrickable_set import RebrickableSet
# A set, part or minifigure image from Rebrickable
class RebrickableImage(object):
brickset: 'BrickSet'
set: 'RebrickableSet'
minifigure: 'BrickMinifigure | None'
part: 'BrickPart | None'
@ -23,13 +23,14 @@ class RebrickableImage(object):
def __init__(
self,
brickset: 'BrickSet',
set: 'RebrickableSet',
/,
*,
minifigure: 'BrickMinifigure | None' = None,
part: 'BrickPart | None' = None,
):
# Save all objects
self.brickset = brickset
self.set = set
self.minifigure = minifigure
self.part = part
@ -70,12 +71,12 @@ class RebrickableImage(object):
# 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
return current_app.config['PARTS_FOLDER']
if self.minifigure is not None:
return current_app.config['MINIFIGURES_FOLDER'].value
return current_app.config['MINIFIGURES_FOLDER']
return current_app.config['SETS_FOLDER'].value
return current_app.config['SETS_FOLDER']
# Return the id depending on the objects provided
def id(self, /) -> str:
@ -91,7 +92,7 @@ class RebrickableImage(object):
else:
return self.minifigure.fields.fig_num
return self.brickset.fields.set_num
return self.set.fields.set
# Return the path depending on the objects provided
def path(self, /) -> str:
@ -105,24 +106,24 @@ class RebrickableImage(object):
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
return current_app.config['REBRICKABLE_IMAGE_NIL']
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
return current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE']
else:
return self.minifigure.fields.set_img_url
return self.brickset.fields.set_img_url
return self.set.fields.image
# 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
urlparse(current_app.config['REBRICKABLE_IMAGE_NIL']).path
)
)
@ -133,7 +134,7 @@ class RebrickableImage(object):
def nil_minifigure_name() -> str:
filename, _ = os.path.splitext(
os.path.basename(
urlparse(current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE'].value).path # noqa: E501
urlparse(current_app.config['REBRICKABLE_IMAGE_NIL_MINIFIGURE']).path # noqa: E501
)
)
@ -142,7 +143,7 @@ class RebrickableImage(object):
# Return the static URL for an image given a name and folder
@staticmethod
def static_url(name: str, folder_name: str) -> str:
folder: str = current_app.config[folder_name].value
folder: str = current_app.config[folder_name]
# /!\ Everything is saved as .jpg, even if it came from a .png
# not changing this behaviour.

14
bricktracker/rebrickable_minifigures.py
View File

@ -30,18 +30,18 @@ class RebrickableMinifigures(object):
def download(self, /) -> None:
self.socket.auto_progress(
message='Set {number}: loading minifigures from Rebrickable'.format( # noqa: E501
number=self.brickset.fields.set_num,
number=self.brickset.fields.set,
),
increment_total=True,
)
logger.debug('rebrick.lego.get_set_minifigs("{set_num}")'.format(
set_num=self.brickset.fields.set_num,
logger.debug('rebrick.lego.get_set_minifigs("{set}")'.format(
set=self.brickset.fields.set,
))
minifigures = Rebrickable[BrickMinifigure](
'get_set_minifigs',
self.brickset.fields.set_num,
self.brickset.fields.set,
BrickMinifigure,
socket=self.socket,
brickset=self.brickset,
@ -53,7 +53,7 @@ class RebrickableMinifigures(object):
# 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,
number=self.brickset.fields.set,
current=index+1,
total=total,
)
@ -65,13 +65,13 @@ class RebrickableMinifigures(object):
# Grab the image
self.socket.progress(
message='Set {number}: downloading minifigure {current}/{total} image'.format( # noqa: E501
number=self.brickset.fields.set_num,
number=self.brickset.fields.set,
current=index+1,
total=total,
)
)
if not current_app.config['USE_REMOTE_IMAGES'].value:
if not current_app.config['USE_REMOTE_IMAGES']:
RebrickableImage(
self.brickset,
minifigure=minifigure

7
bricktracker/rebrickable_parts.py
View File

@ -29,6 +29,7 @@ class RebrickableParts(object):
socket: 'BrickSocket',
brickset: 'BrickSet',
/,
*,
minifigure: 'BrickMinifigure | None' = None,
):
# Save the socket
@ -43,7 +44,7 @@ class RebrickableParts(object):
self.kind = 'Minifigure'
self.method = 'get_minifig_elements'
else:
self.number = self.brickset.fields.set_num
self.number = self.brickset.fields.set
self.kind = 'Set'
self.method = 'get_set_elements'
@ -76,7 +77,7 @@ class RebrickableParts(object):
for index, part in enumerate(inventory):
# Skip spare parts
if (
current_app.config['SKIP_SPARE_PARTS'].value and
current_app.config['SKIP_SPARE_PARTS'] and
part.fields.is_spare
):
continue
@ -104,7 +105,7 @@ class RebrickableParts(object):
)
)
if not current_app.config['USE_REMOTE_IMAGES'].value:
if not current_app.config['USE_REMOTE_IMAGES']:
RebrickableImage(
self.brickset,
minifigure=self.minifigure,

231
bricktracker/rebrickable_set.py
View File

@ -1,148 +1,135 @@
import logging
from sqlite3 import Row
import traceback
from typing import Any, TYPE_CHECKING
from uuid import uuid4
from flask import current_app
from .exceptions import ErrorException, NotFoundException
from .instructions import BrickInstructions
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
from .record import BrickRecord
from .theme_list import BrickThemeList
if TYPE_CHECKING:
from .socket import BrickSocket
from .theme import BrickTheme
logger = logging.getLogger(__name__)
# A set from Rebrickable
class RebrickableSet(object):
class RebrickableSet(BrickRecord):
socket: 'BrickSocket'
theme: 'BrickTheme'
instructions: list[BrickInstructions]
# Flags
resolve_instructions: bool = True
# Queries
select_query: str = 'rebrickable/set/select'
insert_query: str = 'rebrickable/set/insert'
def __init__(
self,
/,
*,
socket: 'BrickSocket | None' = None,
record: Row | dict[str, Any] | None = None
):
super().__init__()
# Placeholders
self.instructions = []
def __init__(self, socket: 'BrickSocket', /):
# Save the socket
if socket is not None:
self.socket = socket
# Ingest the record if it has one
if record is not None:
self.ingest(record)
# 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,
def download_rebrickable(self, /) -> None:
# Insert the Rebrickable set to the database
rows, _ = self.insert(
commit=False,
no_defer=True,
override_query=RebrickableSet.insert_query
)
# Assign a unique ID to the set
brickset.fields.u_id = str(uuid4())
if rows > 0:
if not current_app.config['USE_REMOTE_IMAGES']:
RebrickableImage(self).download()
# Insert into database
brickset.insert(commit=False)
# Ingest a set
def ingest(self, record: Row | dict[str, Any], /):
super().ingest(record)
if not current_app.config['USE_REMOTE_IMAGES'].value:
RebrickableImage(brickset).download()
# Resolve theme
if not hasattr(self.fields, 'theme_id'):
self.fields.theme_id = 0
# Load the inventory
RebrickableParts(self.socket, brickset).download()
self.theme = BrickThemeList().get(self.fields.theme_id)
# Load the minifigures
RebrickableMinifigures(self.socket, brickset).download()
# Resolve instructions
if self.resolve_instructions:
# Not idead, avoiding cyclic import
from .instructions_list import BrickInstructionsList
# 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,
if self.fields.set is not None:
self.instructions = BrickInstructionsList().get(
self.fields.set
)
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:
) -> bool:
# 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']))
set = RebrickableSet.parse_number(str(data['set']))
self.socket.auto_progress(
message='Set {num}: loading from Rebrickable'.format(
num=set_num,
message='Set {set}: loading from Rebrickable'.format(
set=set,
),
)
logger.debug('rebrick.lego.get_set("{set_num}")'.format(
set_num=set_num,
logger.debug('rebrick.lego.get_set("{set}")'.format(
set=set,
))
brickset = Rebrickable[BrickSet](
Rebrickable[RebrickableSet](
'get_set',
set_num,
BrickSet,
set,
RebrickableSet,
instance=self,
).get()
short = brickset.short()
short['download'] = from_download
self.socket.emit('SET_LOADED', short)
self.socket.emit('SET_LOADED', self.short(
from_download=from_download
))
if not from_download:
self.socket.complete(
message='Set {num}: loaded from Rebrickable'.format(
num=brickset.fields.set_num
message='Set {set}: loaded from Rebrickable'.format(
set=self.fields.set
)
)
return brickset
return True
except Exception as e:
self.socket.fail(
message='Could not load the set from Rebrickable: {error}. Data: {data}'.format( # noqa: E501
@ -154,12 +141,57 @@ class RebrickableSet(object):
if not isinstance(e, (NotFoundException, ErrorException)):
logger.debug(traceback.format_exc())
return None
return False
# Return a short form of the Rebrickable set
def short(self, /, *, from_download: bool = False) -> dict[str, Any]:
return {
'download': from_download,
'image': self.fields.image,
'name': self.fields.name,
'set': self.fields.set,
}
# Compute the url for the set image
def url_for_image(self, /) -> str:
if not current_app.config['USE_REMOTE_IMAGES']:
return RebrickableImage.static_url(
self.fields.set,
'SETS_FOLDER'
)
else:
return self.fields.image
# Compute the url for the rebrickable page
def url_for_rebrickable(self, /) -> str:
if current_app.config['REBRICKABLE_LINKS']:
return self.fields.url
return ''
# Normalize from Rebrickable
@staticmethod
def from_rebrickable(data: dict[str, Any], /, **_) -> dict[str, Any]:
# Extracting version and number
number, _, version = str(data['set_num']).partition('-')
return {
'set': str(data['set_num']),
'number': int(number),
'version': int(version),
'name': str(data['name']),
'year': int(data['year']),
'theme_id': int(data['theme_id']),
'number_of_parts': int(data['num_parts']),
'image': str(data['set_img_url']),
'url': str(data['set_url']),
'last_modified': str(data['last_modified_dt']),
}
# Make sense of the number from the data
@staticmethod
def parse_number(set_num: str, /) -> str:
number, _, version = set_num.partition('-')
def parse_number(set: str, /) -> str:
number, _, version = set.partition('-')
# Making sure both are integers
if version == '':
@ -191,24 +223,3 @@ class RebrickableSet(object):
))
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()

21
bricktracker/rebrickable_set_list.py Normal file
View File

@ -0,0 +1,21 @@
from typing import Self
from .rebrickable_set import RebrickableSet
from .record_list import BrickRecordList
# All the rebrickable sets from the database
class RebrickableSetList(BrickRecordList[RebrickableSet]):
# Queries
select_query: str = 'rebrickable/set/list'
# All the sets
def all(self, /) -> Self:
# Load the sets from the database
for record in self.select():
rebrickable_set = RebrickableSet(record=record)
self.records.append(rebrickable_set)
return self

44
bricktracker/record.py
View File

@ -1,5 +1,5 @@
from sqlite3 import Row
from typing import Any, ItemsView
from typing import Any, ItemsView, Tuple
from .fields import BrickRecordFields
from .sql import BrickSQL
@ -24,33 +24,63 @@ class BrickRecord(object):
# Insert into the database
# If we do not commit immediately, we defer the execute() call
def insert(self, /, commit=True) -> None:
def insert(
self,
/,
*,
commit=True,
no_defer=False,
override_query: str | None = None
) -> Tuple[int, str]:
if override_query:
query = override_query
else:
query = self.insert_query
database = BrickSQL()
rows, q = database.execute(
self.insert_query,
query,
parameters=self.sql_parameters(),
defer=not commit,
defer=not commit and not no_defer,
)
if commit:
database.commit()
return rows, q
# 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:
def select(
self,
/,
*,
override_query: str | None = None,
**context: Any
) -> bool:
if override_query:
query = override_query
else:
query = self.select_query
return BrickSQL().fetchone(
record = BrickSQL().fetchone(
query,
parameters=self.sql_parameters()
parameters=self.sql_parameters(),
**context
)
# Ingest the record
if record is not None:
self.ingest(record)
return True
else:
return False
# Generic SQL parameters from fields
def sql_parameters(self, /) -> dict[str, Any]:
parameters: dict[str, Any] = {}

17
bricktracker/record_list.py
View File

@ -6,10 +6,20 @@ from .sql import BrickSQL
if TYPE_CHECKING:
from .minifigure import BrickMinifigure
from .part import BrickPart
from .rebrickable_set import RebrickableSet
from .set import BrickSet
from .set_checkbox import BrickSetCheckbox
from .wish import BrickWish
T = TypeVar('T', 'BrickSet', 'BrickPart', 'BrickMinifigure', 'BrickWish')
T = TypeVar(
'T',
'BrickSet',
'BrickSetCheckbox',
'BrickPart',
'BrickMinifigure',
'BrickWish',
'RebrickableSet'
)
# SQLite records
@ -32,9 +42,11 @@ class BrickRecordList(Generic[T]):
def select(
self,
/,
*,
override_query: str | None = None,
order: str | None = None,
limit: int | None = None,
**context: Any,
) -> list[Row]:
# Select the query
if override_query:
@ -47,6 +59,7 @@ class BrickRecordList(Generic[T]):
parameters=self.sql_parameters(),
order=order,
limit=limit,
**context
)
# Generic SQL parameters from fields
@ -62,6 +75,6 @@ class BrickRecordList(Generic[T]):
for record in self.records:
yield record
# Make the sets measurable
# Make the list measurable
def __len__(self, /) -> int:
return len(self.records)

23
bricktracker/reload.py Normal file
View File

@ -0,0 +1,23 @@
from .instructions_list import BrickInstructionsList
from .retired_list import BrickRetiredList
from .set_checkbox_list import BrickSetCheckboxList
from .theme_list import BrickThemeList
# Reload everything related to a database after an operation
def reload() -> None:
# Failsafe
try:
# Reload the instructions
BrickInstructionsList(force=True)
# Reload the checkboxes
BrickSetCheckboxList(force=True)
# Reload retired sets
BrickRetiredList(force=True)
# Reload themes
BrickThemeList(force=True)
except Exception:
pass

12
bricktracker/retired_list.py
View File

@ -22,7 +22,7 @@ class BrickRetiredList(object):
size: int | None
exception: Exception | None
def __init__(self, /, force: bool = False):
def __init__(self, /, *, force: bool = False):
# Load sets only if there is none already loaded
retired = getattr(self, 'retired', None)
@ -33,7 +33,7 @@ class BrickRetiredList(object):
# 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
with open(current_app.config['RETIRED_SETS_PATH'], newline='') as themes_file: # noqa: E501
themes_reader = csv.reader(themes_file)
# Ignore the header
@ -44,7 +44,7 @@ class BrickRetiredList(object):
BrickRetiredList.retired[retired.number] = retired
# File stats
stat = os.stat(current_app.config['RETIRED_SETS_PATH'].value)
stat = os.stat(current_app.config['RETIRED_SETS_PATH'])
BrickRetiredList.size = stat.st_size
BrickRetiredList.mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc) # noqa: E501
@ -79,7 +79,7 @@ class BrickRetiredList(object):
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
current_app.config['FILE_DATETIME_FORMAT']
)
else:
return ''
@ -88,7 +88,7 @@ class BrickRetiredList(object):
@staticmethod
def update() -> None:
response = requests.get(
current_app.config['RETIRED_SETS_FILE_URL'].value,
current_app.config['RETIRED_SETS_FILE_URL'],
stream=True,
)
@ -99,7 +99,7 @@ class BrickRetiredList(object):
content = gzip.GzipFile(fileobj=response.raw)
with open(current_app.config['RETIRED_SETS_PATH'].value, 'wb') as f:
with open(current_app.config['RETIRED_SETS_PATH'], 'wb') as f:
copyfileobj(content, f)
logger.info('Retired sets list updated')

267
bricktracker/set.py
View File

@ -1,70 +1,105 @@
from sqlite3 import Row
import logging
import traceback
from typing import Any, Self
from uuid import uuid4
from flask import current_app, url_for
from flask import 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 .rebrickable_image import RebrickableImage
from .record import BrickRecord
from .rebrickable_minifigures import RebrickableMinifigures
from .rebrickable_parts import RebrickableParts
from .rebrickable_set import RebrickableSet
from .set_checkbox import BrickSetCheckbox
from .set_checkbox_list import BrickSetCheckboxList
from .sql import BrickSQL
from .theme_list import BrickThemeList
logger = logging.getLogger(__name__)
# Lego brick set
class BrickSet(BrickRecord):
instructions: list[BrickInstructions]
theme_name: str
class BrickSet(RebrickableSet):
# Queries
select_query: str = 'set/select'
select_query: str = 'set/select/full'
light_query: str = 'set/select/light'
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()
BrickSQL().executescript(
'set/delete/set',
id=self.fields.id
)
# Delete the set
database.execute('set/delete/set', parameters=parameters)
# Import a set into the database
def download(self, data: dict[str, Any], /) -> None:
# Load the set
if not self.load(data, from_download=True):
return
# Delete the minifigures
database.execute(
'minifigure/delete/all_from_set', parameters=parameters)
try:
# Insert into the database
self.socket.auto_progress(
message='Set {number}: inserting into database'.format(
number=self.fields.set
),
increment_total=True,
)
# Delete the parts
database.execute(
'part/delete/all_from_set', parameters=parameters)
# Generate an UUID for self
self.fields.id = str(uuid4())
# Delete missing parts
database.execute('missing/delete/all_from_set', parameters=parameters)
# Insert into database
self.insert(commit=False)
# Commit to the database
database.commit()
# Execute the parent download method
self.download_rebrickable()
# Load the inventory
RebrickableParts(self.socket, self).download()
# Load the minifigures
RebrickableMinifigures(self.socket, self).download()
# Commit the transaction to the database
self.socket.auto_progress(
message='Set {number}: writing to the database'.format(
number=self.fields.set
),
increment_total=True,
)
BrickSQL().commit()
# Info
logger.info('Set {number}: imported (id: {id})'.format(
number=self.fields.set,
id=self.fields.id,
))
# Complete
self.socket.complete(
message='Set {number}: imported (<a href="{url}">Go to the set</a>)'.format( # noqa: E501
number=self.fields.set,
url=self.url()
),
download=True
)
except Exception as e:
self.socket.fail(
message='Error while importing set {number}: {error}'.format(
number=self.fields.set,
error=e,
)
)
logger.debug(traceback.format_exc())
# Insert a Rebrickable set
def insert_rebrickable(self, /) -> None:
self.insert()
# Minifigures
def minifigures(self, /) -> BrickMinifigureList:
@ -74,145 +109,81 @@ class BrickSet(BrickRecord):
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:
# Select a light set (with an id)
def select_light(self, id: str, /) -> Self:
# Save the parameters to the fields
self.fields.u_id = u_id
self.fields.id = id
# Load from database
record = self.select()
if record is None:
if not self.select(override_query=self.light_query):
raise NotFoundException(
'Set with ID {id} was not found in the database'.format(
id=self.fields.u_id,
id=self.fields.id,
),
)
# Ingest the record
self.ingest(record)
return self
# Resolve the theme
self.resolve_theme()
# Select a specific set (with an id)
def select_specific(self, id: str, /) -> Self:
# Save the parameters to the fields
self.fields.id = id
# Check for the instructions
self.resolve_instructions()
# Load from database
if not self.select(
statuses=BrickSetCheckboxList().as_columns(solo=True)
):
raise NotFoundException(
'Set with ID {id} was not found in the database'.format(
id=self.fields.id,
),
)
return self
# Update a checked state
def update_checked(self, name: str, status: bool, /) -> None:
# Update a status
def update_status(
self,
checkbox: BrickSetCheckbox,
status: bool,
/
) -> None:
parameters = self.sql_parameters()
parameters['status'] = status
# Update the checked status
# Update the status
rows, _ = BrickSQL().execute_and_commit(
'set/update_checked',
'set/update/status',
parameters=parameters,
name=name,
name=checkbox.as_column(),
)
if rows != 1:
raise DatabaseException('Could not update the status {status} for set {number}'.format( # noqa: E501
status=name,
number=self.fields.set_num,
raise DatabaseException('Could not update the status "{status}" for set {number} ({id})'.format( # noqa: E501
status=checkbox.fields.name,
number=self.fields.set,
id=self.fields.id,
))
# Self url
def url(self, /) -> str:
return url_for('set.details', id=self.fields.u_id)
return url_for('set.details', id=self.fields.id)
# Deletion url
def url_for_delete(self, /) -> str:
return url_for('set.delete', id=self.fields.u_id)
return url_for('set.delete', id=self.fields.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:
return RebrickableImage.static_url(
self.fields.set_num,
'SETS_FOLDER'
)
else:
return self.fields.set_img_url
return url_for('set.do_delete', id=self.fields.id)
# 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,
id=self.fields.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,
}

142
bricktracker/set_checkbox.py Normal file
View File

@ -0,0 +1,142 @@
from sqlite3 import Row
from typing import Any, Self, Tuple
from uuid import uuid4
from flask import url_for
from .exceptions import DatabaseException, ErrorException, NotFoundException
from .record import BrickRecord
from .sql import BrickSQL
# Lego set checkbox
class BrickSetCheckbox(BrickRecord):
# Queries
select_query: str = 'checkbox/select'
def __init__(
self,
/,
*,
record: Row | dict[str, Any] | None = None,
):
super().__init__()
# Ingest the record if it has one
if record is not None:
self.ingest(record)
# SQL column name
def as_column(self) -> str:
return 'status_{id}'.format(id=self.fields.id)
# HTML dataset name
def as_dataset(self) -> str:
return '{id}'.format(
id=self.as_column().replace('_', '-')
)
# Delete from database
def delete(self) -> None:
BrickSQL().executescript(
'checkbox/delete',
id=self.fields.id,
)
# Grab data from a form
def from_form(self, form: dict[str, str]) -> Self:
name = form.get('name', None)
grid = form.get('grid', None)
if name is None or name == '':
raise ErrorException('Checkbox name cannot be empty')
# Security: eh.
# Prevent self-ownage with accidental quote escape
self.fields.name = name
self.fields.safe_name = self.fields.name.replace("'", "''")
self.fields.displayed_on_grid = grid == 'on'
return self
# Insert into database
def insert(self, **_) -> Tuple[int, str]:
# Generate an ID for the checkbox (with underscores to make it
# column name friendly)
self.fields.id = str(uuid4()).replace('-', '_')
BrickSQL().executescript(
'checkbox/add',
id=self.fields.id,
name=self.fields.safe_name,
displayed_on_grid=self.fields.displayed_on_grid
)
# To accomodate the parent().insert we have overriden
return 0, ''
# Rename the checkbox
def rename(self, /) -> None:
# Update the name
rows, _ = BrickSQL().execute_and_commit(
'checkbox/update/name',
parameters=self.sql_parameters(),
)
if rows != 1:
raise DatabaseException('Could not update the name for checkbox {name} ({id})'.format( # noqa: E501
name=self.fields.name,
id=self.fields.id,
))
# URL to change the status
def status_url(self, id: str) -> str:
return url_for(
'set.update_status',
id=id,
checkbox_id=self.fields.id
)
# Select a specific checkbox (with an id)
def select_specific(self, id: str, /) -> Self:
# Save the parameters to the fields
self.fields.id = id
# Load from database
if not self.select():
raise NotFoundException(
'Checkbox with ID {id} was not found in the database'.format(
id=self.fields.id,
),
)
return self
# Update a status
def update_status(
self,
name: str,
status: bool,
/
) -> None:
if not hasattr(self.fields, name) or name in ['id', 'name']:
raise NotFoundException('{name} is not a field of a checkbox'.format( # noqa: E501
name=name
))
parameters = self.sql_parameters()
parameters['status'] = status
# Update the status
rows, _ = BrickSQL().execute_and_commit(
'checkbox/update/status',
parameters=parameters,
name=name,
)
if rows != 1:
raise DatabaseException('Could not update the status "{status}" for checkbox {name} ({id})'.format( # noqa: E501
status=name,
name=self.fields.name,
id=self.fields.id,
))

74
bricktracker/set_checkbox_list.py Normal file
View File

@ -0,0 +1,74 @@
import logging
from .exceptions import NotFoundException
from .fields import BrickRecordFields
from .record_list import BrickRecordList
from .set_checkbox import BrickSetCheckbox
logger = logging.getLogger(__name__)
# Lego sets checkbox list
class BrickSetCheckboxList(BrickRecordList[BrickSetCheckbox]):
checkboxes: dict[str, BrickSetCheckbox]
# Queries
select_query = 'checkbox/list'
def __init__(self, /, *, force: bool = False):
# Load checkboxes only if there is none already loaded
records = getattr(self, 'records', None)
if records is None or force:
# Don't use super()__init__ as it would mask class variables
self.fields = BrickRecordFields()
logger.info('Loading set checkboxes list')
BrickSetCheckboxList.records = []
BrickSetCheckboxList.checkboxes = {}
# Load the checkboxes from the database
for record in self.select():
checkbox = BrickSetCheckbox(record=record)
BrickSetCheckboxList.records.append(checkbox)
BrickSetCheckboxList.checkboxes[checkbox.fields.id] = checkbox
# Return the checkboxes as columns for a select
def as_columns(
self,
/,
*,
solo: bool = False,
table: str = 'bricktracker_set_statuses'
) -> str:
return ', '.join([
'"{table}"."{column}"'.format(
table=table,
column=record.as_column(),
)
for record
in self.records
if solo or record.fields.displayed_on_grid
])
# Grab a specific checkbox
def get(self, id: str, /) -> BrickSetCheckbox:
if id not in self.checkboxes:
raise NotFoundException(
'Checkbox with ID {id} was not found in the database'.format(
id=self.fields.id,
),
)
return self.checkboxes[id]
# Get the list of checkboxes depending on the context
def list(self, /, *, all: bool = False) -> list[BrickSetCheckbox]:
return [
record
for record
in self.records
if all or record.fields.displayed_on_grid
]

29
bricktracker/set_list.py
View File

@ -3,6 +3,7 @@ from typing import Self
from flask import current_app
from .record_list import BrickRecordList
from .set_checkbox_list import BrickSetCheckboxList
from .set import BrickSet
@ -13,6 +14,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
# Queries
generic_query: str = 'set/list/generic'
light_query: str = 'set/list/light'
missing_minifigure_query: str = 'set/list/missing_minifigure'
missing_part_query: str = 'set/list/missing_part'
select_query: str = 'set/list/all'
@ -26,18 +28,21 @@ class BrickSetList(BrickRecordList[BrickSet]):
self.themes = []
# Store the order for this list
self.order = current_app.config['SETS_DEFAULT_ORDER'].value
self.order = current_app.config['SETS_DEFAULT_ORDER']
# All the sets
def all(self, /) -> Self:
themes = set()
# Load the sets from the database
for record in self.select(order=self.order):
for record in self.select(
order=self.order,
statuses=BrickSetCheckboxList().as_columns()
):
brickset = BrickSet(record=record)
self.records.append(brickset)
themes.add(brickset.theme_name)
themes.add(brickset.theme.name)
# Convert the set into a list and sort it
self.themes = list(themes)
@ -58,14 +63,18 @@ class BrickSetList(BrickRecordList[BrickSet]):
return self
# Last added sets
def last(self, /, limit: int = 6) -> Self:
def last(self, /, *, limit: int = 6) -> Self:
# Randomize
if current_app.config['RANDOM'].value:
if current_app.config['RANDOM']:
order = 'RANDOM()'
else:
order = 'sets.rowid DESC'
order = '"bricktracker_sets"."rowid" DESC'
for record in self.select(order=order, limit=limit):
for record in self.select(
order=order,
limit=limit,
statuses=BrickSetCheckboxList().as_columns()
):
brickset = BrickSet(record=record)
self.records.append(brickset)
@ -76,7 +85,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
def missing_minifigure(
self,
fig_num: str,
/,
/
) -> Self:
# Save the parameters to the fields
self.fields.fig_num = fig_num
@ -98,6 +107,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
part_num: str,
color_id: int,
/,
*,
element_id: int | None = None,
) -> Self:
# Save the parameters to the fields
@ -120,7 +130,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
def using_minifigure(
self,
fig_num: str,
/,
/
) -> Self:
# Save the parameters to the fields
self.fields.fig_num = fig_num
@ -142,6 +152,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
part_num: str,
color_id: int,
/,
*,
element_id: int | None = None,
) -> Self:
# Save the parameters to the fields

21
bricktracker/socket.py
View File

@ -6,7 +6,7 @@ from flask_socketio import SocketIO
from .configuration_list import BrickConfigurationList
from .login import LoginManager
from .rebrickable_set import RebrickableSet
from .set import BrickSet
from .sql import close as sql_close
logger = logging.getLogger(__name__)
@ -56,19 +56,19 @@ class BrickSocket(object):
# Compute the namespace
self.namespace = '/{namespace}'.format(
namespace=app.config['SOCKET_NAMESPACE'].value
namespace=app.config['SOCKET_NAMESPACE']
)
# Inject CORS if a domain is defined
if app.config['DOMAIN_NAME'].value != '':
kwargs['cors_allowed_origins'] = app.config['DOMAIN_NAME'].value
if app.config['DOMAIN_NAME'] != '':
kwargs['cors_allowed_origins'] = app.config['DOMAIN_NAME']
# Instantiate the socket
self.socket = SocketIO(
self.app,
*args,
**kwargs,
path=app.config['SOCKET_PATH'].value,
path=app.config['SOCKET_PATH'],
async_mode='eventlet',
)
@ -98,7 +98,7 @@ class BrickSocket(object):
self.fail(message=str(e))
return
brickset = RebrickableSet(self)
brickset = BrickSet(socket=self)
# Start it in a thread if requested
if self.threaded:
@ -124,7 +124,7 @@ class BrickSocket(object):
self.fail(message=str(e))
return
brickset = RebrickableSet(self)
brickset = BrickSet(socket=self)
# Start it in a thread if requested
if self.threaded:
@ -140,6 +140,7 @@ class BrickSocket(object):
def auto_progress(
self,
/,
*,
message: str | None = None,
increment_total=False,
) -> None:
@ -203,7 +204,7 @@ class BrickSocket(object):
sql_close()
# Update the progress
def progress(self, /, message: str | None = None) -> None:
def progress(self, /, *, message: str | None = None) -> None:
# Save the las message
if message is not None:
self.progress_message = message
@ -218,14 +219,14 @@ class BrickSocket(object):
self.emit('PROGRESS', data)
# Update the progress total only
def update_total(self, total: int, /, add: bool = False) -> None:
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:
def total_progress(self, total: int, /, *, add: bool = False) -> None:
self.update_total(total, add=add)
self.progress()

182
bricktracker/sql.py
View File

@ -1,33 +1,46 @@
import logging
import os
import sqlite3
from typing import Any, Tuple
from .sql_stats import BrickSQLStats
from typing import Any, Final, Tuple
from flask import current_app, g
from jinja2 import Environment, FileSystemLoader
from werkzeug.datastructures import FileStorage
from .exceptions import DatabaseException
from .sql_counter import BrickCounter
from .sql_migration_list import BrickSQLMigrationList
from .sql_stats import BrickSQLStats
from .version import __database_version__
logger = logging.getLogger(__name__)
G_CONNECTION: Final[str] = 'database_connection'
G_ENVIRONMENT: Final[str] = 'database_environment'
G_DEFER: Final[str] = 'database_defer'
G_STATS: Final[str] = 'database_stats'
# SQLite3 client with our extra features
class BrickSQL(object):
connection: sqlite3.Connection
cursor: sqlite3.Cursor
stats: BrickSQLStats
version: int
def __init__(self, /):
def __init__(self, /, *, failsafe: bool = False):
# 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)
connection = getattr(g, G_CONNECTION, None)
# Grab the existing connection if it exists
if database is not None:
self.connection = database
self.stats = getattr(g, 'database_stats', BrickSQLStats())
if connection is not None:
self.connection = connection
self.stats = getattr(g, G_STATS, BrickSQLStats())
# Grab a cursor
self.cursor = self.connection.cursor()
else:
# Instantiate the stats
self.stats = BrickSQLStats()
@ -37,26 +50,54 @@ class BrickSQL(object):
logger.debug('SQLite3: connect')
self.connection = sqlite3.connect(
current_app.config['DATABASE_PATH'].value
current_app.config['DATABASE_PATH']
)
# Setup the row factory to get pseudo-dicts rather than tuples
self.connection.row_factory = sqlite3.Row
# Grab a cursor
self.cursor = self.connection.cursor()
# Grab the version and check
try:
version = self.fetchone('schema/get_version')
if version is None:
raise Exception('version is None')
self.version = version[0]
except Exception as e:
self.version = 0
raise DatabaseException('Could not get the database version: {error}'.format( # noqa: E501
error=str(e)
))
if self.upgrade_too_far():
raise DatabaseException('Your database version ({version}) is too far ahead for this version of the application. Expected at most {required}'.format( # noqa: E501
version=self.version,
required=__database_version__,
))
# 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
setattr(g, G_CONNECTION, self.connection)
setattr(g, G_STATS, self.stats)
# Grab a cursor
self.cursor = self.connection.cursor()
if not failsafe:
if self.upgrade_needed():
raise DatabaseException('Your database need to be upgraded from version {version} to version {required}'.format( # noqa: E501
version=self.version,
required=__database_version__,
))
# Clear the defer stack
def clear_defer(self, /) -> None:
g.database_defer = []
setattr(g, G_DEFER, [])
# Shorthand to commit
def commit(self, /) -> None:
@ -72,6 +113,27 @@ class BrickSQL(object):
logger.debug('SQLite3: commit')
return self.connection.commit()
# Count the database records
def count_records(self) -> list[BrickCounter]:
counters: list[BrickCounter] = []
# Get all tables
for table in self.fetchall('schema/tables'):
counter = BrickCounter(table['name'])
# Failsafe this one
try:
record = self.fetchone('schema/count', table=counter.table)
if record is not None:
counter.count = record['count']
except Exception:
pass
counters.append(counter)
return counters
# Defer a call to execute
def defer(self, query: str, parameters: dict[str, Any], /):
defer = self.get_defer()
@ -82,16 +144,17 @@ class BrickSQL(object):
defer.append((query, parameters))
# Save the defer stack
g.database_defer = defer
setattr(g, G_DEFER, defer)
# Shorthand to execute, returning number of affected rows
def execute(
self,
query: str,
/,
*,
parameters: dict[str, Any] = {},
defer: bool = False,
**context,
**context: Any,
) -> Tuple[int, str]:
# Stats: execute
self.stats.execute += 1
@ -114,7 +177,7 @@ class BrickSQL(object):
return result.rowcount, query
# Shorthand to executescript
def executescript(self, query: str, /, **context) -> None:
def executescript(self, query: str, /, **context: Any) -> None:
# Load the query
query = self.load_query(query, **context)
@ -129,8 +192,9 @@ class BrickSQL(object):
self,
query: str,
/,
*,
parameters: dict[str, Any] = {},
**context,
**context: Any,
) -> Tuple[int, str]:
rows, query = self.execute(query, parameters=parameters, **context)
self.commit()
@ -142,8 +206,9 @@ class BrickSQL(object):
self,
query: str,
/,
*,
parameters: dict[str, Any] = {},
**context,
**context: Any,
) -> list[sqlite3.Row]:
_, query = self.execute(query, parameters=parameters, **context)
@ -163,8 +228,9 @@ class BrickSQL(object):
self,
query: str,
/,
*,
parameters: dict[str, Any] = {},
**context,
**context: Any,
) -> sqlite3.Row | None:
_, query = self.execute(query, parameters=parameters, **context)
@ -182,21 +248,18 @@ class BrickSQL(object):
# 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',
[]
)
defer: list[Tuple[str, dict[str, Any]]] = getattr(g, G_DEFER, [])
return defer
# Load a query by name
def load_query(self, name: str, /, **context) -> str:
def load_query(self, name: str, /, **context: Any) -> str:
# Grab the existing environment if it exists
environment = getattr(g, 'database_loader', None)
environment = getattr(g, G_ENVIRONMENT, None)
# Instantiate Jinja environment for SQL files
if environment is None:
logger.debug('SQLite3: instantiating the Jinja loader')
environment = Environment(
loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'sql/')
@ -204,10 +267,10 @@ class BrickSQL(object):
)
# Save the environment globally for later use
g.database_environment = environment
setattr(g, G_ENVIRONMENT, environment)
# Grab the template
logger.debug('SQLite: loading {name} (context: {context})'.format(
logger.debug('SQLite3: loading {name} (context: {context})'.format(
name=name,
context=context,
))
@ -221,7 +284,8 @@ class BrickSQL(object):
def raw_execute(
self,
query: str,
parameters: dict[str, Any]
parameters: dict[str, Any],
/
) -> sqlite3.Cursor:
logger.debug('SQLite3: execute: {query}'.format(
query=BrickSQL.clean_query(query)
@ -229,6 +293,25 @@ class BrickSQL(object):
return self.cursor.execute(query, parameters)
# Upgrade the database
def upgrade(self) -> None:
if self.upgrade_needed():
for pending in BrickSQLMigrationList().pending(self.version):
logger.info('Applying migration {version}'.format(
version=pending.version)
)
self.executescript(pending.get_query())
self.execute('schema/set_version', version=pending.version)
# Tells whether the database needs upgrade
def upgrade_needed(self) -> bool:
return self.version < __database_version__
# Tells whether the database is too far
def upgrade_too_far(self) -> bool:
return self.version > __database_version__
# Clean the query for debugging
@staticmethod
def clean_query(query: str, /) -> str:
@ -249,7 +332,7 @@ class BrickSQL(object):
# Delete the database
@staticmethod
def delete() -> None:
os.remove(current_app.config['DATABASE_PATH'].value)
os.remove(current_app.config['DATABASE_PATH'])
# Info
logger.info('The database has been deleted')
@ -262,37 +345,10 @@ class BrickSQL(object):
# 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)
file.save(current_app.config['DATABASE_PATH'])
# Info
logger.info('The database has been imported using file {file}'.format(
@ -302,11 +358,11 @@ class BrickSQL(object):
# Close all existing SQLite3 connections
def close() -> None:
database: sqlite3.Connection | None = getattr(g, 'database', None)
connection: sqlite3.Connection | None = getattr(g, G_CONNECTION, None)
if database is not None:
if connection is not None:
logger.debug('SQLite3: close')
database.close()
connection.close()
# Remove the database from the context
delattr(g, 'database')
delattr(g, G_CONNECTION)

16
bricktracker/sql/checkbox/add.sql Normal file
View File

@ -0,0 +1,16 @@
BEGIN TRANSACTION;
ALTER TABLE "bricktracker_set_statuses"
ADD COLUMN "status_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
INSERT INTO "bricktracker_set_checkboxes" (
"id",
"name",
"displayed_on_grid"
) VALUES (
'{{ id }}',
'{{ name }}',
{{ displayed_on_grid }}
);
COMMIT;

7
bricktracker/sql/checkbox/base.sql Normal file
View File

@ -0,0 +1,7 @@
SELECT
"bricktracker_set_checkboxes"."id",
"bricktracker_set_checkboxes"."name",
"bricktracker_set_checkboxes"."displayed_on_grid"
FROM "bricktracker_set_checkboxes"
{% block where %}{% endblock %}

9
bricktracker/sql/checkbox/delete.sql Normal file
View File

@ -0,0 +1,9 @@
BEGIN TRANSACTION;
ALTER TABLE "bricktracker_set_statuses"
DROP COLUMN "status_{{ id }}";
DELETE FROM "bricktracker_set_checkboxes"
WHERE "bricktracker_set_checkboxes"."id" IS NOT DISTINCT FROM '{{ id }}';
COMMIT;

1
bricktracker/sql/checkbox/list.sql Normal file
View File

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

5
bricktracker/sql/checkbox/select.sql Normal file
View File

@ -0,0 +1,5 @@
{% extends 'checkbox/base.sql' %}
{% block where %}
WHERE "bricktracker_set_checkboxes"."id" IS NOT DISTINCT FROM :id
{% endblock %}

3
bricktracker/sql/checkbox/update/name.sql Normal file
View File

@ -0,0 +1,3 @@
UPDATE "bricktracker_set_checkboxes"
SET "name" = :safe_name
WHERE "bricktracker_set_checkboxes"."id" IS NOT DISTINCT FROM :id

3
bricktracker/sql/checkbox/update/status.sql Normal file
View File

@ -0,0 +1,3 @@
UPDATE "bricktracker_set_checkboxes"
SET "{{name}}" = :status
WHERE "bricktracker_set_checkboxes"."id" IS NOT DISTINCT FROM :id

66
bricktracker/sql/migrations/0001.sql Normal file
View File

@ -0,0 +1,66 @@
-- description: Original database initialization
-- FROM sqlite3 app.db .schema > init.sql with extra IF NOT EXISTS, transaction and quotes
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;

13
bricktracker/sql/migrations/0002.sql Normal file
View File

@ -0,0 +1,13 @@
-- description: WAL journal, 'None' fix for missing table
-- Set the journal mode to WAL
PRAGMA journal_mode = WAL;
BEGIN TRANSACTION;
-- Fix a bug where 'None' was inserted in missing instead of NULL
UPDATE "missing"
SET "element_id" = NULL
WHERE "missing"."element_id" = 'None';
COMMIT;

48
bricktracker/sql/migrations/0003.sql Normal file
View File

@ -0,0 +1,48 @@
-- description: Creation of the deduplicated table of Rebrickable sets
BEGIN TRANSACTION;
-- Create a Rebrickable set table: each unique set imported from Rebrickable
CREATE TABLE "rebrickable_sets" (
"set" TEXT NOT NULL,
"number" INTEGER NOT NULL,
"version" INTEGER NOT NULL,
"name" TEXT NOT NULL,
"year" INTEGER NOT NULL,
"theme_id" INTEGER NOT NULL,
"number_of_parts" INTEGER NOT NULL,
"image" TEXT,
"url" TEXT,
"last_modified" TEXT,
PRIMARY KEY("set")
);
-- Insert existing sets into the new table
INSERT INTO "rebrickable_sets" (
"set",
"number",
"version",
"name",
"year",
"theme_id",
"number_of_parts",
"image",
"url",
"last_modified"
)
SELECT
"sets"."set_num",
CAST(SUBSTR("sets"."set_num", 1, INSTR("sets"."set_num", '-') - 1) AS INTEGER),
CAST(SUBSTR("sets"."set_num", INSTR("sets"."set_num", '-') + 1) AS INTEGER),
"sets"."name",
"sets"."year",
"sets"."theme_id",
"sets"."num_parts",
"sets"."set_img_url",
"sets"."set_url",
"sets"."last_modified_dt"
FROM "sets"
GROUP BY
"sets"."set_num";
COMMIT;

25
bricktracker/sql/migrations/0004.sql Normal file
View File

@ -0,0 +1,25 @@
-- description: Migrate the Bricktracker sets
PRAGMA foreign_keys = ON;
BEGIN TRANSACTION;
-- Create a Bricktable set table: with their unique IDs, and a reference to the Rebrickable set
CREATE TABLE "bricktracker_sets" (
"id" TEXT NOT NULL,
"rebrickable_set" TEXT NOT NULL,
PRIMARY KEY("id"),
FOREIGN KEY("rebrickable_set") REFERENCES "rebrickable_sets"("set")
);
-- Insert existing sets into the new table
INSERT INTO "bricktracker_sets" (
"id",
"rebrickable_set"
)
SELECT
"sets"."u_id",
"sets"."set_num"
FROM "sets";
COMMIT;

72
bricktracker/sql/migrations/0005.sql Normal file
View File

@ -0,0 +1,72 @@
-- description: Creation of the configurable set checkboxes
PRAGMA foreign_keys = ON;
BEGIN TRANSACTION;
-- Create a table to define each set checkbox: with an ID, a name and if they should be displayed on the grid cards
CREATE TABLE "bricktracker_set_checkboxes" (
"id" TEXT NOT NULL,
"name" TEXT NOT NULL,
"displayed_on_grid" BOOLEAN NOT NULL DEFAULT 0,
PRIMARY KEY("id")
);
-- Seed our checkbox with the 3 original ones
INSERT INTO "bricktracker_set_checkboxes" (
"id",
"name",
"displayed_on_grid"
) VALUES (
"minifigures_collected",
"Minifigures are collected",
1
);
INSERT INTO "bricktracker_set_checkboxes" (
"id",
"name",
"displayed_on_grid"
) VALUES (
"set_checked",
"Set is checked",
1
);
INSERT INTO "bricktracker_set_checkboxes" (
"id",
"name",
"displayed_on_grid"
) VALUES (
"set_collected",
"Set is collected and boxed",
1
);
-- Create a table for the status of each checkbox: with the 3 first status
CREATE TABLE "bricktracker_set_statuses" (
"bricktracker_set_id" TEXT NOT NULL,
"status_minifigures_collected" BOOLEAN NOT NULL DEFAULT 0,
"status_set_checked" BOOLEAN NOT NULL DEFAULT 0,
"status_set_collected" BOOLEAN NOT NULL DEFAULT 0,
PRIMARY KEY("bricktracker_set_id"),
FOREIGN KEY("bricktracker_set_id") REFERENCES "bricktracker_sets"("id")
);
INSERT INTO "bricktracker_set_statuses" (
"bricktracker_set_id",
"status_minifigures_collected",
"status_set_checked",
"status_set_collected"
)
SELECT
"sets"."u_id",
"sets"."mini_col",
"sets"."set_check",
"sets"."set_col"
FROM "sets";
-- Rename the original table (don't delete it yet?)
ALTER TABLE "sets" RENAME TO "sets_old";
COMMIT;

42
bricktracker/sql/migrations/0006.sql Normal file
View File

@ -0,0 +1,42 @@
-- description: Migrate the whislist to have a Rebrickable sets structure
BEGIN TRANSACTION;
-- Create a Rebrickable wish table: each unique (light) set imported from Rebrickable
CREATE TABLE "bricktracker_wishes" (
"set" TEXT NOT NULL,
"name" TEXT NOT NULL,
"year" INTEGER NOT NULL,
"theme_id" INTEGER NOT NULL,
"number_of_parts" INTEGER NOT NULL,
"image" TEXT,
"url" TEXT,
PRIMARY KEY("set")
);
-- Insert existing wishes into the new table
INSERT INTO "bricktracker_wishes" (
"set",
"name",
"year",
"theme_id",
"number_of_parts",
"image",
"url"
)
SELECT
"wishlist"."set_num",
"wishlist"."name",
"wishlist"."year",
"wishlist"."theme_id",
"wishlist"."num_parts",
"wishlist"."set_img_url",
"wishlist"."set_url"
FROM "wishlist"
GROUP BY
"wishlist"."set_num";
-- Rename the original table (don't delete it yet?)
ALTER TABLE "wishlist" RENAME TO "wishlist_old";
COMMIT;

66
bricktracker/sql/migrations/init.sql
View File

@ -1,66 +0,0 @@
-- 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
);
-- Fix a bug where 'None' was inserted in missing instead of NULL
UPDATE missing
SET element_id = NULL
WHERE element_id = 'None';
COMMIT;

20
bricktracker/sql/minifigure/base/select.sql
View File

@ -1,20 +1,20 @@
SELECT
minifigures.fig_num,
minifigures.set_num,
minifigures.name,
minifigures.quantity,
minifigures.set_img_url,
minifigures.u_id,
"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
NULL AS "total_missing", -- dummy for order: total_missing
{% endblock %}
{% block total_quantity %}
NULL AS total_quantity, -- dummy for order: total_quantity
NULL AS "total_quantity", -- dummy for order: total_quantity
{% endblock %}
{% block total_sets %}
NULL AS total_sets -- dummy for order: total_sets
NULL AS "total_sets" -- dummy for order: total_sets
{% endblock %}
FROM minifigures
FROM "minifigures"
{% block join %}{% endblock %}

2
bricktracker/sql/minifigure/delete/all_from_set.sql
View File

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

14
bricktracker/sql/minifigure/insert.sql
View File

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

24
bricktracker/sql/minifigure/list/all.sql
View File

@ -1,34 +1,34 @@
{% extends 'minifigure/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing_join.total, 0)) AS total_missing,
SUM(IFNULL("missing_join"."total", 0)) AS "total_missing",
{% endblock %}
{% block total_quantity %}
SUM(IFNULL(minifigures.quantity, 0)) AS total_quantity,
SUM(IFNULL("minifigures"."quantity", 0)) AS "total_quantity",
{% endblock %}
{% block total_sets %}
COUNT(minifigures.set_num) AS 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
"missing"."set_num",
"missing"."u_id",
SUM("missing"."quantity") AS total
FROM "missing"
GROUP BY
set_num,
u_id
"missing"."set_num",
"missing"."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
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
"minifigures"."fig_num"
{% endblock %}

4
bricktracker/sql/minifigure/list/from_set.sql
View File

@ -1,6 +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
WHERE "minifigures"."u_id" IS NOT DISTINCT FROM :u_id
AND "minifigures"."set_num" IS NOT DISTINCT FROM :set_num
{% endblock %}

12
bricktracker/sql/minifigure/list/last.sql
View File

@ -1,17 +1,17 @@
{% extends 'minifigure/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing.quantity, 0)) AS 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
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
"minifigures"."fig_num",
"minifigures"."u_id"
{% endblock %}

24
bricktracker/sql/minifigure/list/missing_part.sql
View File

@ -1,30 +1,30 @@
{% extends 'minifigure/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing.quantity, 0)) AS 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
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 where %}
WHERE minifigures.fig_num IN (
WHERE "minifigures"."fig_num" IN (
SELECT
missing.set_num
FROM missing
"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
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
GROUP BY "missing"."set_num"
)
{% endblock %}
{% block group %}
GROUP BY
minifigures.fig_num
"minifigures"."fig_num"
{% endblock %}

18
bricktracker/sql/minifigure/list/using_part.sql
View File

@ -1,24 +1,24 @@
{% extends 'minifigure/base/select.sql' %}
{% block total_quantity %}
SUM(minifigures.quantity) AS total_quantity,
SUM("minifigures"."quantity") AS "total_quantity",
{% endblock %}
{% block where %}
WHERE minifigures.fig_num IN (
WHERE "minifigures"."fig_num" IN (
SELECT
inventory.set_num
FROM inventory
"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
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
GROUP BY "inventory"."set_num"
)
{% endblock %}
{% block group %}
GROUP BY
minifigures.fig_num
"minifigures"."fig_num"
{% endblock %}

28
bricktracker/sql/minifigure/select/generic.sql
View File

@ -1,38 +1,38 @@
{% extends 'minifigure/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing_join.total, 0)) AS total_missing,
SUM(IFNULL("missing_join"."total", 0)) AS "total_missing",
{% endblock %}
{% block total_quantity %}
SUM(IFNULL(minifigures.quantity, 0)) AS total_quantity,
SUM(IFNULL("minifigures"."quantity", 0)) AS "total_quantity",
{% endblock %}
{% block total_sets %}
COUNT(minifigures.set_num) AS 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
"missing"."set_num",
"missing"."u_id",
SUM("missing"."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
"missing"."set_num",
"missing"."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
WHERE "minifigures"."fig_num" IS NOT DISTINCT FROM :fig_num
{% endblock %}
{% block group %}
GROUP BY
minifigures.fig_num
"minifigures"."fig_num"
{% endblock %}

6
bricktracker/sql/minifigure/select/specific.sql
View File

@ -1,7 +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
WHERE "minifigures"."fig_num" IS NOT DISTINCT FROM :fig_num
AND "minifigures"."u_id" IS NOT DISTINCT FROM :u_id
AND "minifigures"."set_num" IS NOT DISTINCT FROM :set_num
{% endblock %}

3
bricktracker/sql/missing/count_none.sql
View File

@ -1,3 +0,0 @@
SELECT count(*) AS count
FROM missing
WHERE element_id = 'None'

2
bricktracker/sql/missing/delete/all_from_set.sql
View File

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

8
bricktracker/sql/missing/delete/from_set.sql
View File

@ -1,4 +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
DELETE FROM "missing"
WHERE "missing"."set_num" IS NOT DISTINCT FROM :set_num
AND "missing"."id" IS NOT DISTINCT FROM :id
AND "missing"."u_id" IS NOT DISTINCT FROM :u_id

18
bricktracker/sql/missing/insert.sql
View File

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

10
bricktracker/sql/missing/update/from_set.sql
View File

@ -1,5 +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
UPDATE "missing"
SET "quantity" = :quantity
WHERE "missing"."set_num" IS NOT DISTINCT FROM :set_num
AND "missing"."id" IS NOT DISTINCT FROM :id
AND "missing"."u_id" IS NOT DISTINCT FROM :u_id

36
bricktracker/sql/part/base/select.sql
View File

@ -1,32 +1,32 @@
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,
"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
NULL AS "total_missing", -- dummy for order: total_missing
{% endblock %}
{% block total_quantity %}
NULL AS total_quantity, -- dummy for order: total_quantity
NULL AS "total_quantity", -- dummy for order: total_quantity
{% endblock %}
{% block total_spare %}
NULL AS total_spare, -- dummy for order: total_spare
NULL AS "total_spare", -- dummy for order: total_spare
{% endblock %}
{% block total_sets %}
NULL AS total_sets, -- dummy for order: total_sets
NULL AS "total_sets", -- dummy for order: total_sets
{% endblock %}
{% block total_minifigures %}
NULL AS total_minifigures -- dummy for order: total_minifigures
NULL AS "total_minifigures" -- dummy for order: total_minifigures
{% endblock %}
FROM inventory
FROM "inventory"
{% block join %}{% endblock %}

2
bricktracker/sql/part/delete/all_from_set.sql
View File

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

24
bricktracker/sql/part/insert.sql
View File

@ -1,16 +1,16 @@
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
"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,

42
bricktracker/sql/part/list/all.sql
View File

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

26
bricktracker/sql/part/list/from_minifigure.sql
View File

@ -2,27 +2,27 @@
{% extends 'part/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing.quantity, 0)) AS 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
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
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
"inventory"."part_num",
"inventory"."name",
"inventory"."color_id",
"inventory"."is_spare",
"inventory"."element_id"
{% endblock %}

20
bricktracker/sql/part/list/from_set.sql
View File

@ -2,20 +2,20 @@
{% extends 'part/base/select.sql' %}
{% block total_missing %}
IFNULL(missing.quantity, 0) AS 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
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
WHERE "inventory"."u_id" IS NOT DISTINCT FROM :u_id
AND "inventory"."set_num" IS NOT DISTINCT FROM :set_num
{% endblock %}

36
bricktracker/sql/part/list/missing.sql
View File

@ -1,36 +1,36 @@
{% extends 'part/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing.quantity, 0)) AS 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,
COUNT("inventory"."u_id") - COUNT("minifigures"."u_id") AS "total_sets",
{% endblock %}
{% block total_minifigures %}
SUM(IFNULL(minifigures.quantity, 0)) AS 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
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
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
"inventory"."part_num",
"inventory"."name",
"inventory"."color_id",
"inventory"."is_spare",
"inventory"."element_id"
{% endblock %}

38
bricktracker/sql/part/select/generic.sql
View File

@ -1,40 +1,40 @@
{% extends 'part/base/select.sql' %}
{% block total_missing %}
SUM(IFNULL(missing.quantity, 0)) AS total_missing,
SUM(IFNULL("missing"."quantity", 0)) AS "total_missing",
{% endblock %}
{% block total_quantity %}
SUM((NOT inventory.is_spare) * inventory.quantity * IFNULL(minifigures.quantity, 1)) AS total_quantity,
SUM((NOT "inventory"."is_spare") * "inventory"."quantity" * IFNULL("minifigures"."quantity", 1)) AS "total_quantity",
{% endblock %}
{% block total_spare %}
SUM(inventory.is_spare * inventory.quantity * IFNULL(minifigures.quantity, 1)) AS total_spare,
SUM("inventory"."is_spare" * "inventory"."quantity" * IFNULL("minifigures"."quantity", 1)) 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
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 "minifigures"
ON "inventory"."set_num" IS NOT DISTINCT FROM "minifigures"."fig_num"
AND "inventory"."u_id" IS NOT DISTINCT FROM "minifigures"."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
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
"inventory"."part_num",
"inventory"."color_id",
"inventory"."element_id"
{% endblock %}

26
bricktracker/sql/part/select/specific.sql
View File

@ -1,24 +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
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
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
"inventory"."set_num",
"inventory"."id",
"inventory"."part_num",
"inventory"."color_id",
"inventory"."element_id",
"inventory"."u_id"
{% endblock %}

23
bricktracker/sql/rebrickable/set/insert.sql Normal file
View File

@ -0,0 +1,23 @@
INSERT OR IGNORE INTO "rebrickable_sets" (
"set",
"number",
"version",
"name",
"year",
"theme_id",
"number_of_parts",
"image",
"url",
"last_modified"
) VALUES (
:set,
:number,
:version,
:name,
:year,
:theme_id,
:number_of_parts,
:image,
:url,
:last_modified
)

11
bricktracker/sql/rebrickable/set/list.sql Normal file
View File

@ -0,0 +1,11 @@
SELECT
"rebrickable_sets"."set",
"rebrickable_sets"."number",
"rebrickable_sets"."version",
"rebrickable_sets"."name",
"rebrickable_sets"."year",
"rebrickable_sets"."theme_id",
"rebrickable_sets"."number_of_parts",
"rebrickable_sets"."image",
"rebrickable_sets"."url"
FROM "rebrickable_sets"

13
bricktracker/sql/rebrickable/set/select.sql Normal file
View File

@ -0,0 +1,13 @@
SELECT
"rebrickable_sets"."set",
"rebrickable_sets"."number",
"rebrickable_sets"."version",
"rebrickable_sets"."name",
"rebrickable_sets"."year",
"rebrickable_sets"."theme_id",
"rebrickable_sets"."number_of_parts",
"rebrickable_sets"."image",
"rebrickable_sets"."url"
FROM "rebrickable_sets"
WHERE "rebrickable_sets"."set" IS NOT DISTINCT FROM :set

4
bricktracker/sql/schema/count.sql
View File

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

19
bricktracker/sql/schema/drop.sql
View File

@ -1,9 +1,18 @@
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;
DROP TABLE IF EXISTS "bricktracker_sets";
DROP TABLE IF EXISTS "bricktracker_set_checkboxes";
DROP TABLE IF EXISTS "bricktracker_set_statuses";
DROP TABLE IF EXISTS "bricktracker_wishes";
DROP TABLE IF EXISTS "inventory";
DROP TABLE IF EXISTS "minifigures";
DROP TABLE IF EXISTS "missing";
DROP TABLE IF EXISTS "rebrickable_sets";
DROP TABLE IF EXISTS "sets";
DROP TABLE IF EXISTS "sets_old";
DROP TABLE IF EXISTS "wishlist";
DROP TABLE IF EXISTS "wishlist_old";
COMMIT;
PRAGMA user_version = 0;

1
bricktracker/sql/schema/get_version.sql Normal file
View File

@ -0,0 +1 @@
PRAGMA user_version

4
bricktracker/sql/schema/is_init.sql
View File

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

1
bricktracker/sql/schema/set_version.sql Normal file
View File

@ -0,0 +1 @@
PRAGMA user_version = {{ version }}

1
bricktracker/sql/schema/tables.sql Normal file
View File

@ -0,0 +1 @@
SELECT "name" FROM "sqlite_master" WHERE type='table' ORDER BY "name" ASC

38
bricktracker/sql/set/base/base.sql Normal file
View File

@ -0,0 +1,38 @@
SELECT
{% block id %}{% endblock %}
"rebrickable_sets"."set",
"rebrickable_sets"."number",
"rebrickable_sets"."version",
"rebrickable_sets"."name",
"rebrickable_sets"."year",
"rebrickable_sets"."theme_id",
"rebrickable_sets"."number_of_parts",
"rebrickable_sets"."image",
"rebrickable_sets"."url",
{% block statuses %}
{% if statuses %}{{ statuses }},{% endif %}
{% endblock %}
{% 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 %}
FROM "bricktracker_sets"
INNER JOIN "rebrickable_sets"
ON "bricktracker_sets"."rebrickable_set" IS NOT DISTINCT FROM "rebrickable_sets"."set"
{% block join %}{% endblock %}
{% block where %}{% endblock %}
{% block group %}{% endblock %}
{% if order %}
ORDER BY {{ order }}
{% endif %}
{% if limit %}
LIMIT {{ limit }}
{% endif %}

42
bricktracker/sql/set/base/full.sql Normal file
View File

@ -0,0 +1,42 @@
{% extends 'set/base/base.sql' %}
{% block id %}
"bricktracker_sets"."id",
{% endblock %}
{% block total_missing %}
IFNULL("missing_join"."total", 0) AS "total_missing",
{% endblock %}
{% block total_quantity %}
IFNULL("minifigures_join"."total", 0) AS "total_minifigures"
{% endblock %}
{% block join %}
{% if statuses %}
LEFT JOIN "bricktracker_set_statuses"
ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "bricktracker_set_statuses"."bricktracker_set_id"
{% endif %}
-- LEFT JOIN + SELECT to avoid messing the total
LEFT JOIN (
SELECT
"missing"."u_id",
SUM("missing"."quantity") AS "total"
FROM "missing"
{% block where_missing %}{% endblock %}
GROUP BY "u_id"
) "missing_join"
ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "missing_join"."u_id"
-- LEFT JOIN + SELECT to avoid messing the total
LEFT JOIN (
SELECT
"minifigures"."u_id",
SUM("minifigures"."quantity") AS "total"
FROM "minifigures"
{% block where_minifigures %}{% endblock %}
GROUP BY "u_id"
) "minifigures_join"
ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "minifigures_join"."u_id"
{% endblock %}

18
bricktracker/sql/set/base/light.sql Normal file
View File

@ -0,0 +1,18 @@
SELECT
"bricktracker_sets"."id",
"bricktracker_sets"."rebrickable_set" AS "set"
FROM "bricktracker_sets"
{% block join %}{% endblock %}
{% block where %}{% endblock %}
{% block group %}{% endblock %}
{% if order %}
ORDER BY {{ order }}
{% endif %}
{% if limit %}
LIMIT {{ limit }}
{% endif %}

52
bricktracker/sql/set/base/select.sql
View File

@ -1,52 +0,0 @@
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 %}

23
bricktracker/sql/set/delete/set.sql
View File

@ -1,2 +1,21 @@
DELETE FROM sets
WHERE u_id IS NOT DISTINCT FROM :u_id
-- A bit unsafe as it does not use a prepared statement but it
-- should not be possible to inject anything through the {{ id }} context
BEGIN TRANSACTION;
DELETE FROM "bricktracker_sets"
WHERE "bricktracker_sets"."id" IS NOT DISTINCT FROM '{{ id }}';
DELETE FROM "bricktracker_set_statuses"
WHERE "bricktracker_set_statuses"."bricktracker_set_id" IS NOT DISTINCT FROM '{{ id }}';
DELETE FROM "minifigures"
WHERE "minifigures"."u_id" IS NOT DISTINCT FROM '{{ id }}';
DELETE FROM "missing"
WHERE "missing"."u_id" IS NOT DISTINCT FROM '{{ id }}';
DELETE FROM "inventory"
WHERE "inventory"."u_id" IS NOT DISTINCT FROM '{{ id }}';
COMMIT;

30
bricktracker/sql/set/insert.sql
View File

@ -1,27 +1,7 @@
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
INSERT OR IGNORE INTO "bricktracker_sets" (
"id",
"rebrickable_set"
) 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
:id,
:set
)

2
bricktracker/sql/set/list/all.sql
View File

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

14
bricktracker/sql/set/list/generic.sql
View File

@ -1,12 +1,6 @@
SELECT
sets.set_num,
sets.name,
sets.year,
sets.theme_id,
sets.num_parts,
sets.set_img_url,
sets.set_url
FROM sets
{% extends 'set/base/base.sql' %}
{% block group %}
GROUP BY
sets.set_num
"bricktracker_sets"."rebrickable_set"
{% endblock %}

12
bricktracker/sql/set/list/missing_minifigure.sql
View File

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

16
bricktracker/sql/set/list/missing_part.sql
View File

@ -1,15 +1,15 @@
{% extends 'set/base/select.sql' %}
{% extends 'set/base/full.sql' %}
{% block where %}
WHERE sets.u_id IN (
WHERE "bricktracker_sets"."id" IN (
SELECT
missing.u_id
FROM missing
"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
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
GROUP BY "missing"."u_id"
)
{% endblock %}

12
bricktracker/sql/set/list/using_minifigure.sql
View File

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

16
bricktracker/sql/set/list/using_part.sql
View File

@ -1,15 +1,15 @@
{% extends 'set/base/select.sql' %}
{% extends 'set/base/full.sql' %}
{% block where %}
WHERE sets.u_id IN (
WHERE "bricktracker_sets"."id" IN (
SELECT
inventory.u_id
FROM inventory
"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
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
GROUP BY "inventory"."u_id"
)
{% endblock %}

13
bricktracker/sql/set/select.sql
View File

@ -1,13 +0,0 @@
{% 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 %}

13
bricktracker/sql/set/select/full.sql Normal file
View File

@ -0,0 +1,13 @@
{% extends 'set/base/full.sql' %}
{% block where_missing %}
WHERE "missing"."u_id" IS NOT DISTINCT FROM :id
{% endblock %}
{% block where_minifigures %}
WHERE "minifigures"."u_id" IS NOT DISTINCT FROM :id
{% endblock %}
{% block where %}
WHERE "bricktracker_sets"."id" IS NOT DISTINCT FROM :id
{% endblock %}

5
bricktracker/sql/set/select/light.sql Normal file
View File

@ -0,0 +1,5 @@
{% extends 'set/base/light.sql' %}
{% block where %}
WHERE "bricktracker_sets"."id" IS NOT DISTINCT FROM :id
{% endblock %}

10
bricktracker/sql/set/update/status.sql Normal file
View File

@ -0,0 +1,10 @@
INSERT INTO "bricktracker_set_statuses" (
"bricktracker_set_id",
"{{name}}"
) VALUES (
:id,
:status
)
ON CONFLICT("bricktracker_set_id")
DO UPDATE SET "{{name}}" = :status
WHERE "bricktracker_set_statuses"."bricktracker_set_id" IS NOT DISTINCT FROM :id

3
bricktracker/sql/set/update_checked.sql
View File

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

19
bricktracker/sql/wish/base/base.sql Normal file
View File

@ -0,0 +1,19 @@
SELECT
"bricktracker_wishes"."set",
"bricktracker_wishes"."name",
"bricktracker_wishes"."year",
"bricktracker_wishes"."theme_id",
"bricktracker_wishes"."number_of_parts",
"bricktracker_wishes"."image",
"bricktracker_wishes"."url"
FROM "bricktracker_wishes"
{% block where %}{% endblock %}
{% if order %}
ORDER BY {{ order }}
{% endif %}
{% if limit %}
LIMIT {{ limit }}
{% endif %}

20
bricktracker/sql/wish/base/select.sql
View File

@ -1,20 +0,0 @@
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 %}

Some files were not shown because too many files have changed in this diff Show More