feat(minifigures): individual minifigures can now be disabled using env var

.env.sample

@@ -61,6 +61,10 @@
 # Default: 25
 # BK_DEFAULT_TABLE_PER_PAGE=50
 
+# Optional: Maximum length for description text in badges before truncating with ellipsis
+# Default: 15
+# BK_DESCRIPTION_BADGE_MAX_LENGTH=15
+
 # Optional: if set up, will add a CORS allow origin restriction to the socket.
 # Default:
 # Legacy name: DOMAIN_NAME
@@ -118,6 +122,13 @@
 # Default: false
 # BK_HIDE_ALL_MINIFIGURES=true
 
+# Optional: Disable the individual/loose minifigures system. This hides all individual
+# minifigure UI elements and prevents adding new individual minifigures. The routes remain
+# accessible so existing individual minifigures can still be viewed. Users who only track
+# set-based minifigures can use this to simplify the interface. Does not disable the route.
+# Default: false
+# BK_DISABLE_INDIVIDUAL_MINIFIGURES=false
+
 # Optional: Hide the 'Parts' entry from the menu. Does not disable the route.
 # Default: false
 # BK_HIDE_ALL_PARTS=true
@@ -160,12 +171,15 @@
 # BK_HIDE_WISHES=true
 
 # Optional: Change the default order of minifigures. By default ordered by insertion order.
+# Note: Minifigures are queried from a combined view that merges both set-based and individual minifigures.
+# Therefore, column references should use the "combined" table alias.
 # Useful column names for this option are:
-# - "rebrickable_minifigures"."figure": minifigure ID (fig-xxxxx)
-# - "rebrickable_minifigures"."number": minifigure ID as an integer (xxxxx)
-# - "rebrickable_minifigures"."name": minifigure name
-# Default: "rebrickable_minifigures"."name" ASC
-# BK_MINIFIGURES_DEFAULT_ORDER="rebrickable_minifigures"."name" ASC
+# - "combined"."figure": minifigure ID (fig-xxxxx)
+# - "combined"."number": minifigure ID as an integer (xxxxx)
+# - "combined"."name": minifigure name
+# - "combined"."rowid": insertion order (for both set and individual minifigures)
+# Default: "combined"."name" ASC
+# BK_MINIFIGURES_DEFAULT_ORDER="combined"."name" ASC
 
 # Optional: Folder where to store the minifigures images, relative to the '/app/static/' folder
 # Default: minifigs
@@ -178,14 +192,16 @@
 # BK_NO_THREADED_SOCKET=true
 
 # Optional: Change the default order of parts. By default ordered by insertion order.
+# Note: Parts are queried from a combined view that merges both set-based and individual minifigure parts.
+# Some columns use the "combined" table alias for fields from the merged view.
 # Useful column names for this option are:
-# - "bricktracker_parts"."part": part number
-# - "bricktracker_parts"."spare": part is a spare part
+# - "combined"."part": part number
+# - "combined"."spare": part is a spare part (use "combined" not "bricktracker_parts")
 # - "rebrickable_parts"."name": part name
 # - "rebrickable_parts"."color_name": part color name
 # - "total_missing": number of missing parts
-# Default: "rebrickable_parts"."name" ASC, "rebrickable_parts"."color_name" ASC, "bricktracker_parts"."spare" ASC
-# BK_PARTS_DEFAULT_ORDER="total_missing" DESC, "rebrickable_parts"."name"."name" ASC
+# Default: "rebrickable_parts"."name" ASC, "rebrickable_parts"."color_name" ASC, "combined"."spare" ASC
+# BK_PARTS_DEFAULT_ORDER="total_missing" DESC, "rebrickable_parts"."name" ASC
 
 # Optional: Folder where to store the parts images, relative to the '/app/static/' folder
 # Default: parts

.gitignore

@@ -33,3 +33,6 @@ vitepress/
 
 # Local data
 offline/
+TODO.md
+run-local.sh
+test-server.sh

bricktracker/app.py

@@ -29,6 +29,7 @@ from bricktracker.views.error import error_404
 from bricktracker.views.index import index_page
 from bricktracker.views.instructions import instructions_page
 from bricktracker.views.login import login_page
+from bricktracker.views.individual_minifigure import individual_minifigure_page
 from bricktracker.views.minifigure import minifigure_page
 from bricktracker.views.part import part_page
 from bricktracker.views.set import set_page
@@ -80,6 +81,7 @@ def setup_app(app: Flask) -> None:
     app.register_blueprint(index_page)
     app.register_blueprint(instructions_page)
     app.register_blueprint(login_page)
+    app.register_blueprint(individual_minifigure_page)
     app.register_blueprint(minifigure_page)
     app.register_blueprint(part_page)
     app.register_blueprint(set_page)

bricktracker/config.py

@@ -17,6 +17,8 @@ CONFIG: Final[list[dict[str, Any]]] = [
     {'n': 'DATABASE_TIMESTAMP_FORMAT', 'd': '%Y-%m-%d-%H-%M-%S'},
     {'n': 'DEBUG', 'c': bool},
     {'n': 'DEFAULT_TABLE_PER_PAGE', 'd': 25, 'c': int},
+    {'n': 'DESCRIPTION_BADGE_MAX_LENGTH', 'd': 15, 'c': int},
+    {'n': 'DISABLE_INDIVIDUAL_MINIFIGURES', 'c': bool},
     {'n': 'DOMAIN_NAME', 'e': 'DOMAIN_NAME', 'd': ''},
     {'n': 'FILE_DATETIME_FORMAT', 'd': '%d/%m/%Y, %H:%M:%S'},
     {'n': 'HOST', 'd': '0.0.0.0'},
@@ -39,7 +41,7 @@ CONFIG: Final[list[dict[str, Any]]] = [
     {'n': 'HIDE_TABLE_MISSING_PARTS', 'c': bool},
     {'n': 'HIDE_TABLE_CHECKED_PARTS', 'c': bool},
     {'n': 'HIDE_WISHES', 'c': bool},
-    {'n': 'MINIFIGURES_DEFAULT_ORDER', 'd': '"rebrickable_minifigures"."name" ASC'},  # noqa: E501
+    {'n': 'MINIFIGURES_DEFAULT_ORDER', 'd': '"combined"."name" ASC'},  # noqa: E501
     {'n': 'MINIFIGURES_FOLDER', 'd': 'minifigures', 's': True},
     {'n': 'MINIFIGURES_PAGINATION_SIZE_DESKTOP', 'd': 10, 'c': int},
     {'n': 'MINIFIGURES_PAGINATION_SIZE_MOBILE', 'd': 5, 'c': int},
@@ -47,7 +49,7 @@ CONFIG: Final[list[dict[str, Any]]] = [
     {'n': 'NO_THREADED_SOCKET', 'c': bool},
     {'n': 'PARTS_SERVER_SIDE_PAGINATION', 'c': bool},
     {'n': 'SETS_SERVER_SIDE_PAGINATION', 'c': bool},
-    {'n': 'PARTS_DEFAULT_ORDER', 'd': '"rebrickable_parts"."name" ASC, "rebrickable_parts"."color_name" ASC, "bricktracker_parts"."spare" ASC'},  # noqa: E501
+    {'n': 'PARTS_DEFAULT_ORDER', 'd': '"rebrickable_parts"."name" ASC, "rebrickable_parts"."color_name" ASC, "combined"."spare" ASC'},  # noqa: E501
     {'n': 'PARTS_FOLDER', 'd': 'parts', 's': True},
     {'n': 'PARTS_PAGINATION_SIZE_DESKTOP', 'd': 10, 'c': int},
     {'n': 'PARTS_PAGINATION_SIZE_MOBILE', 'd': 5, 'c': int},

bricktracker/config_manager.py

@@ -10,6 +10,7 @@ logger = logging.getLogger(__name__)
 LIVE_CHANGEABLE_VARS: Final[List[str]] = [
     'BK_BRICKLINK_LINKS',
     'BK_DEFAULT_TABLE_PER_PAGE',
+    'BK_DESCRIPTION_BADGE_MAX_LENGTH',
     'BK_INDEPENDENT_ACCORDIONS',
     'BK_HIDE_ADD_SET',
     'BK_HIDE_ADD_BULK_SET',
@@ -83,6 +84,7 @@ RESTART_REQUIRED_VARS: Final[List[str]] = [
     'BK_AUTHENTICATION_KEY',
     'BK_DATABASE_PATH',
     'BK_DEBUG',
+    'BK_DISABLE_INDIVIDUAL_MINIFIGURES',
     'BK_DOMAIN_NAME',
     'BK_HOST',
     'BK_PORT',
@@ -173,7 +175,7 @@ class ConfigManager:
             else:
                 return []
         # Integer variables (pagination sizes, delays, etc.) - Check BEFORE boolean check
-        if any(keyword in var_name.lower() for keyword in ['_size', '_page', 'delay', 'min_', 'per_page', 'page_size']):
+        if any(keyword in var_name.lower() for keyword in ['_size', '_page', 'delay', 'min_', 'per_page', 'page_size', '_length']):
             try:
                 return int(value)
             except (ValueError, TypeError):

bricktracker/individual_minifigure.py

@@ -0,0 +1,492 @@
+import logging
+import traceback
+from typing import Any, Self, TYPE_CHECKING
+from uuid import uuid4
+
+from flask import current_app, url_for
+
+from .exceptions import NotFoundException, DatabaseException, ErrorException
+from .parser import parse_minifig
+from .rebrickable import Rebrickable
+from .rebrickable_minifigure import RebrickableMinifigure
+from .set_owner_list import BrickSetOwnerList
+from .set_purchase_location_list import BrickSetPurchaseLocationList
+from .set_storage_list import BrickSetStorageList
+from .set_tag_list import BrickSetTagList
+from .sql import BrickSQL
+
+if TYPE_CHECKING:
+    from .socket import BrickSocket
+
+logger = logging.getLogger(__name__)
+
+
+# Individual minifigure (not associated with a set)
+class IndividualMinifigure(RebrickableMinifigure):
+    # Queries
+    select_query: str = 'individual_minifigure/select/by_id'
+    light_query: str = 'individual_minifigure/select/light'
+    insert_query: str = 'individual_minifigure/insert'
+
+    # Delete a individual minifigure
+    def delete(self, /) -> None:
+        BrickSQL().executescript(
+            'individual_minifigure/delete/individual_minifigure',
+            id=self.fields.id
+        )
+
+    # Import a individual minifigure into the database
+    def download(self, socket: 'BrickSocket', data: dict[str, Any], /) -> bool:
+        # Load the minifigure
+        if not self.load(socket, data, from_download=True):
+            return False
+
+        try:
+            # Insert into the database
+            socket.auto_progress(
+                message='Minifigure {figure}: inserting into database'.format(
+                    figure=self.fields.figure
+                ),
+                increment_total=True,
+            )
+
+            # Generate an UUID for self
+            self.fields.id = str(uuid4())
+
+            # Save the storage
+            storage = BrickSetStorageList.get(
+                data.get('storage', ''),
+                allow_none=True
+            )
+            self.fields.storage = storage.fields.id if storage else None
+
+            # Save the purchase location
+            purchase_location = BrickSetPurchaseLocationList.get(
+                data.get('purchase_location', ''),
+                allow_none=True
+            )
+            self.fields.purchase_location = purchase_location.fields.id if purchase_location else None
+
+            # Save quantity and description
+            self.fields.quantity = int(data.get('quantity', 1))
+            self.fields.description = data.get('description', '')
+
+            # IMPORTANT: Insert rebrickable minifigure FIRST
+            # bricktracker_individual_minifigures has FK to rebrickable_minifigures
+            self.insert_rebrickable_loose()
+
+            # Now insert into bricktracker_individual_minifigures
+            # Use no_defer=True to ensure the insert happens before we insert parts
+            # (parts have a foreign key constraint on this id)
+            self.insert(commit=False, no_defer=True)
+
+            # Save the owners
+            owners: list[str] = list(data.get('owners', []))
+            for id in owners:
+                owner = BrickSetOwnerList.get(id)
+                owner.update_individual_minifigure_state(self, state=True)
+
+            # Save the tags
+            tags: list[str] = list(data.get('tags', []))
+            for id in tags:
+                tag = BrickSetTagList.get(id)
+                tag.update_individual_minifigure_state(self, state=True)
+
+            # Load the parts (elements) for this minifigure
+            if not self.download_parts(socket):
+                return False
+
+            # Commit the transaction to the database
+            socket.auto_progress(
+                message='Minifigure {figure}: writing to the database'.format(
+                    figure=self.fields.figure
+                ),
+                increment_total=True,
+            )
+
+            BrickSQL().commit()
+
+            # Info
+            logger.info('Minifigure {figure}: imported (id: {id})'.format(
+                figure=self.fields.figure,
+                id=self.fields.id,
+            ))
+
+            # Complete
+            socket.complete(
+                message='Minifigure {figure}: imported (<a href="{url}">Go to the minifigure</a>)'.format(
+                    figure=self.fields.figure,
+                    url=self.url()
+                ),
+                download=True
+            )
+
+        except Exception as e:
+            socket.fail(
+                message='Error while importing minifigure {figure}: {error}'.format(
+                    figure=self.fields.figure,
+                    error=e,
+                )
+            )
+
+            logger.debug(traceback.format_exc())
+
+            return False
+
+        return True
+
+    # Download parts (elements) for this individual minifigure
+    def download_parts(self, socket: 'BrickSocket', /) -> bool:
+        """Download minifigure parts using get_minifig_elements()"""
+        try:
+            # Check if we have cached parts data from load()
+            if hasattr(self, '_cached_parts_response'):
+                response = self._cached_parts_response
+                logger.debug('Using cached parts data from load()')
+            else:
+                # Need to fetch parts data
+                socket.auto_progress(
+                    message='Minifigure {figure}: loading parts from Rebrickable'.format(
+                        figure=self.fields.figure
+                    ),
+                    increment_total=True,
+                )
+
+                logger.debug('rebrick.lego.get_minifig_elements("{figure}")'.format(
+                    figure=self.fields.figure,
+                ))
+
+                # Load parts data from Rebrickable API
+                import json
+                from rebrick import lego
+
+                parameters = {
+                    'api_key': current_app.config['REBRICKABLE_API_KEY'],
+                    'page_size': current_app.config['REBRICKABLE_PAGE_SIZE'],
+                }
+
+                response = json.loads(lego.get_minifig_elements(
+                    self.fields.figure,
+                    **parameters
+                ).read())
+
+            socket.auto_progress(
+                message='Minifigure {figure}: saving parts to database'.format(
+                    figure=self.fields.figure
+                ),
+            )
+
+            # Insert each part into individual_minifigure_parts table
+            from .rebrickable_part import RebrickablePart
+
+            if 'results' in response:
+                logger.debug(f'Processing {len(response["results"])} parts for minifigure {self.fields.figure}')
+
+                for idx, result in enumerate(response['results']):
+                    part_num = result['part']['part_num']
+                    color_id = result['color']['id']
+
+                    logger.debug(
+                        f'Part {idx+1}/{len(response["results"])}: {part_num} '
+                        f'(color: {color_id}, quantity: {result["quantity"]})'
+                    )
+
+                    # Insert rebrickable part data first
+                    part_data = RebrickablePart.from_rebrickable(result)
+                    logger.debug(f'Rebrickable part data keys: {list(part_data.keys())}')
+
+                    # Insert into rebrickable_parts if not exists
+                    BrickSQL().execute(
+                        'rebrickable/part/insert',
+                        parameters=part_data,
+                        commit=False,
+                    )
+
+                    # Download part image if not using remote images
+                    if not current_app.config['USE_REMOTE_IMAGES']:
+                        # Create a RebrickablePart instance for image download
+                        from .set import BrickSet
+                        try:
+                            part_instance = RebrickablePart(record=part_data)
+                            from .rebrickable_image import RebrickableImage
+                            RebrickableImage(
+                                BrickSet(),  # Dummy set
+                                minifigure=self,
+                                part=part_instance,
+                            ).download()
+                        except Exception as e:
+                            logger.warning(
+                                f'Could not download image for part {part_num}: {e}'
+                            )
+
+                    # Insert into bricktracker_individual_minifigure_parts
+                    individual_part_params = {
+                        'id': self.fields.id,
+                        'part': part_num,
+                        'color': color_id,
+                        'spare': result.get('is_spare', False),
+                        'quantity': result['quantity'],
+                        'element': result.get('element_id'),
+                        'rebrickable_inventory': result['id'],
+                    }
+                    logger.debug(f'Individual part params: {individual_part_params}')
+
+                    BrickSQL().execute(
+                        'individual_minifigure/part/insert',
+                        parameters=individual_part_params,
+                        commit=False,
+                    )
+
+                logger.debug(f'Successfully inserted all {len(response["results"])} parts')
+            else:
+                logger.warning(f'No results in parts response for minifigure {self.fields.figure}')
+
+            # Clean up cached data
+            if hasattr(self, '_cached_parts_response'):
+                delattr(self, '_cached_parts_response')
+
+            return True
+
+        except Exception as e:
+            socket.fail(
+                message='Error loading parts for minifigure {figure}: {error}'.format(
+                    figure=self.fields.figure,
+                    error=e,
+                )
+            )
+            logger.debug(traceback.format_exc())
+            return False
+
+    # Insert the individual minifigure from Rebrickable
+    def insert_rebrickable_loose(self, /) -> None:
+        """Insert rebrickable minifigure data (without set association)"""
+        # Insert the Rebrickable minifigure to the database
+        # Note: We override the parent's insert_rebrickable since we don't have a brickset
+        from .rebrickable_image import RebrickableImage
+
+        # Explicitly build parameters for rebrickable_minifigures insert
+        params = {
+            'figure': self.fields.figure,
+            'number': self.fields.number,
+            'name': self.fields.name,
+            'image': self.fields.image,
+            'number_of_parts': self.fields.number_of_parts,
+        }
+
+        BrickSQL().execute(
+            RebrickableMinifigure.insert_query,
+            parameters=params,
+            commit=False,
+        )
+
+        # Download image locally if not using remote images
+        if not current_app.config['USE_REMOTE_IMAGES']:
+            # Create a dummy BrickSet for RebrickableImage
+            # RebrickableImage checks minifigure first before set, so this works
+            from .set import BrickSet
+            try:
+                RebrickableImage(
+                    BrickSet(),  # Dummy set - not used since minifigure takes priority
+                    minifigure=self,
+                ).download()
+                logger.debug(f'Downloaded image for individual minifigure {self.fields.figure}')
+            except Exception as e:
+                logger.warning(
+                    f'Could not download image for individual minifigure {self.fields.figure}: {e}'
+                )
+
+    # Load the minifigure from Rebrickable
+    def load(
+        self,
+        socket: 'BrickSocket',
+        data: dict[str, Any],
+        /,
+        *,
+        from_download=False,
+    ) -> bool:
+        # Reset the progress
+        socket.progress_count = 0
+        socket.progress_total = 2
+
+        try:
+            # Check if individual minifigures are disabled
+            from flask import current_app
+            if current_app.config.get('DISABLE_INDIVIDUAL_MINIFIGURES', False):
+                raise ErrorException(
+                    'Individual minifigures system is disabled. '
+                    'Only set-based minifigures can be added.'
+                )
+
+            socket.auto_progress(message='Parsing minifigure number')
+            figure = parse_minifig(str(data['figure']))
+
+            socket.auto_progress(
+                message='Minifigure {figure}: loading from Rebrickable'.format(
+                    figure=figure,
+                ),
+            )
+
+            logger.debug('rebrick.lego.get_minifig_elements("{figure}")'.format(
+                figure=figure,
+            ))
+
+            # Load from Rebrickable using get_minifig_elements
+            # This gives us both minifigure info and parts in one call
+            import json
+            from rebrick import lego
+
+            parameters = {
+                'api_key': current_app.config['REBRICKABLE_API_KEY'],
+                'page_size': current_app.config['REBRICKABLE_PAGE_SIZE'],
+            }
+
+            response = json.loads(lego.get_minifig_elements(
+                figure,
+                **parameters
+            ).read())
+
+            # Extract minifigure info from the first part's metadata
+            if 'results' in response and len(response['results']) > 0:
+                first_part = response['results'][0]
+
+                # Build minifigure data from the response
+                self.fields.figure = first_part['set_num']
+                self.fields.number_of_parts = response['count']
+
+                # We need to fetch the proper name and image from get_minifig()
+                # This is a small additional call but gives us the proper minifigure data
+                try:
+                    # get_minifig() only needs api_key, not page_size
+                    minifig_params = {
+                        'api_key': current_app.config['REBRICKABLE_API_KEY']
+                    }
+                    minifig_response = json.loads(lego.get_minifig(
+                        figure,
+                        **minifig_params
+                    ).read())
+                    self.fields.name = minifig_response.get('name', f"Minifigure {figure}")
+
+                    # Use the minifig image from get_minifig() - this is the assembled minifig
+                    self.fields.image = minifig_response.get('set_img_url')
+
+                    # Extract number from figure (e.g., fig-005997 -> 5997)
+                    try:
+                        self.fields.number = int(figure.split('-')[1])
+                    except:
+                        self.fields.number = 0
+
+                except Exception as e:
+                    logger.warning(f'Could not fetch minifigure name: {e}')
+                    self.fields.name = f"Minifigure {figure}"
+                    # Try to extract number anyway
+                    try:
+                        self.fields.number = int(figure.split('-')[1])
+                    except:
+                        self.fields.number = 0
+
+                    # Fallback: try to extract image from first part with element_id
+                    self.fields.image = None
+                    for result in response['results']:
+                        if result.get('element_id') and result['part'].get('part_img_url'):
+                            self.fields.image = result['part']['part_img_url']
+                            break
+
+                # Store the parts data for later use in download
+                self._cached_parts_response = response
+            else:
+                raise NotFoundException(f'Minifigure {figure} has no parts in Rebrickable')
+
+            socket.emit('MINIFIGURE_LOADED', self.short(
+                from_download=from_download
+            ))
+
+            if not from_download:
+                socket.complete(
+                    message='Minifigure {figure}: loaded from Rebrickable'.format(
+                        figure=self.fields.figure
+                    )
+                )
+
+            return True
+
+        except Exception as e:
+            # Check if this is the "disabled" error - if so, show cleaner message
+            error_msg = str(e)
+            if 'Individual minifigures system is disabled' in error_msg:
+                socket.fail(message=error_msg)
+            else:
+                socket.fail(
+                    message='Could not load the minifigure from Rebrickable: {error}. Data: {data}'.format(
+                        error=error_msg,
+                        data=data,
+                    )
+                )
+
+            if not isinstance(e, (NotFoundException, ErrorException)):
+                logger.debug(traceback.format_exc())
+
+        return False
+
+    # Return a short form of the minifigure
+    def short(self, /, *, from_download: bool = False) -> dict[str, Any]:
+        return {
+            'download': from_download,
+            'image': self.url_for_image(),
+            'name': self.fields.name,
+            'figure': self.fields.figure,
+        }
+
+    # Select a individual minifigure by ID
+    def select_by_id(self, id: str, /) -> Self:
+        # Save the ID parameter
+        self.fields.id = id
+
+        # Import status list here to get metadata columns
+        from .set_status_list import BrickSetStatusList
+
+        # Pass metadata columns to the query with correct table names for individual minifigures
+        context = {
+            'owners': ', ' + BrickSetOwnerList.as_columns(table='bricktracker_individual_minifigure_owners') if BrickSetOwnerList.list() else '',
+            'statuses': ', ' + BrickSetStatusList.as_columns(table='bricktracker_individual_minifigure_statuses', all=True) if BrickSetStatusList.list(all=True) else '',
+            'tags': ', ' + BrickSetTagList.as_columns(table='bricktracker_individual_minifigure_tags') if BrickSetTagList.list() else '',
+        }
+
+        if not self.select(**context):
+            raise NotFoundException(
+                'Individual minifigure with ID {id} was not found in the database'.format(
+                    id=id,
+                ),
+            )
+
+        return self
+
+    # URL to this individual minifigure instance
+    def url(self, /) -> str:
+        return url_for('individual_minifigure.details', id=self.fields.id)
+
+    # URL for updating quantity
+    def url_for_quantity(self, /) -> str:
+        return url_for('individual_minifigure.update_quantity', id=self.fields.id)
+
+    # URL for updating description
+    def url_for_description(self, /) -> str:
+        return url_for('individual_minifigure.update_description', id=self.fields.id)
+
+    # Parts
+    def generic_parts(self, /):
+        from .part_list import BrickPartList
+        return BrickPartList().from_individual_minifigure(self)
+
+    # Override from_rebrickable to handle minifigure data
+    @staticmethod
+    def from_rebrickable(data: dict[str, Any], /, **_) -> dict[str, Any]:
+        # Extracting number
+        number = int(str(data['set_num'])[5:])
+
+        return {
+            'figure': str(data['set_num']),
+            'number': int(number),
+            'name': str(data['set_name']),
+            'image': data.get('set_img_url'),
+            'number_of_parts': int(data.get('num_parts', 0)),
+        }

bricktracker/individual_minifigure_list.py

@@ -0,0 +1,77 @@
+import logging
+from typing import Self
+
+from .individual_minifigure import IndividualMinifigure
+from .record_list import BrickRecordList
+
+logger = logging.getLogger(__name__)
+
+
+# Individual minifigures list
+class IndividualMinifigureList(BrickRecordList[IndividualMinifigure]):
+    # Queries
+    instances_by_figure_query: str = 'individual_minifigure/select/instances_by_figure'
+    using_storage_query: str = 'individual_minifigure/list/using_storage'
+    without_storage_query: str = 'individual_minifigure/list/without_storage'
+
+    def __init__(self, /):
+        super().__init__()
+
+    # Load all individual instances of a specific minifigure figure
+    def instances_by_figure(self, figure: str, /) -> Self:
+        # Save the figure parameter
+        self.fields.figure = figure
+
+        # Import metadata lists to get columns
+        from .set_owner_list import BrickSetOwnerList
+        from .set_status_list import BrickSetStatusList
+        from .set_tag_list import BrickSetTagList
+
+        # Prepare context with metadata columns
+        context = {
+            'owners': BrickSetOwnerList.as_columns(table='bricktracker_individual_minifigure_owners') if BrickSetOwnerList.list() else 'NULL AS "no_owners"',
+            'statuses': BrickSetStatusList.as_columns(table='bricktracker_individual_minifigure_statuses', all=True) if BrickSetStatusList.list(all=True) else 'NULL AS "no_statuses"',
+            'tags': BrickSetTagList.as_columns(table='bricktracker_individual_minifigure_tags') if BrickSetTagList.list() else 'NULL AS "no_tags"',
+        }
+
+        # Load the instances from the database
+        self.list(override_query=self.instances_by_figure_query, **context)
+
+        return self
+
+    # Load all individual minifigures using a specific storage
+    def using_storage(self, storage: 'BrickSetStorage', /) -> Self:
+        # Save the storage parameter
+        self.fields.storage = storage.fields.id
+
+        # Load the minifigures from the database
+        self.list(override_query=self.using_storage_query)
+
+        return self
+
+    # Load all individual minifigures without storage
+    def without_storage(self, /) -> Self:
+        # Load minifigures with no storage
+        self.list(override_query=self.without_storage_query)
+
+        return self
+
+    # Base individual minifigure list
+    def list(
+        self,
+        /,
+        *,
+        override_query: str | None = None,
+        order: str | None = None,
+        limit: int | None = None,
+        **context,
+    ) -> None:
+        # Load the individual minifigures from the database
+        for record in super().select(
+            override_query=override_query,
+            order=order,
+            limit=limit,
+            **context
+        ):
+            individual_minifigure = IndividualMinifigure(record=record)
+            self.records.append(individual_minifigure)

bricktracker/metadata.py

@@ -9,6 +9,7 @@ from .exceptions import DatabaseException, ErrorException, NotFoundException
 from .record import BrickRecord
 from .sql import BrickSQL
 if TYPE_CHECKING:
+    from .individual_minifigure import IndividualMinifigure
     from .set import BrickSet
 
 logger = logging.getLogger(__name__)
@@ -18,16 +19,20 @@ logger = logging.getLogger(__name__)
 class BrickMetadata(BrickRecord):
     kind: str
 
-    # Set state endpoint
-    set_state_endpoint: str
+    # Endpoints (optional, not all metadata types use all of these)
+    set_state_endpoint: str = ''
+    individual_minifigure_state_endpoint: str = ''
+    individual_minifigure_value_endpoint: str = ''
 
     # Queries
     delete_query: str
     insert_query: str
     select_query: str
     update_field_query: str
-    update_set_state_query: str
-    update_set_value_query: str
+    update_set_state_query: str = ''
+    update_set_value_query: str = ''
+    update_individual_minifigure_state_query: str = ''
+    update_individual_minifigure_value_query: str = ''
 
     def __init__(
         self,
@@ -106,6 +111,21 @@ class BrickMetadata(BrickRecord):
             metadata_id=self.fields.id
         )
 
+    # URL to change the selected state of this metadata item for an individual minifigure
+    def url_for_individual_minifigure_state(self, id: str, /) -> str:
+        return url_for(
+            self.individual_minifigure_state_endpoint,
+            id=id,
+            metadata_id=self.fields.id
+        )
+
+    # URL to change the value for an individual minifigure
+    def url_for_individual_minifigure_value(self, id: str, /) -> str:
+        return url_for(
+            self.individual_minifigure_value_endpoint,
+            id=id
+        )
+
     # Select a specific metadata (with an id)
     def select_specific(self, id: str, /) -> Self:
         # Save the parameters to the fields
@@ -216,6 +236,65 @@ class BrickMetadata(BrickRecord):
 
         return state
 
+    # Check if this metadata has a specific individual minifigure
+    def has_individual_minifigure(
+        self,
+        individual_minifigure: 'IndividualMinifigure',
+        /,
+    ) -> bool:
+        """Check if this owner/tag/status is assigned to a individual minifigure"""
+        # Determine the table name based on metadata type
+        table_name = f'bricktracker_individual_minifigure_{self.kind}s'
+        column_name = f'{self.kind}_{self.fields.id}'
+
+        # Query to check if the relationship exists using raw SQL
+        sql = BrickSQL()
+        query = f'SELECT COUNT(*) as count FROM "{table_name}" WHERE "id" = ? AND "{column_name}" = 1'
+        result = sql.cursor.execute(query, (individual_minifigure.fields.id,)).fetchone()
+
+        return result and result['count'] > 0
+
+    # Update the selected state of this metadata item for a individual minifigure
+    def update_individual_minifigure_state(
+        self,
+        individual_minifigure: 'IndividualMinifigure',
+        /,
+        *,
+        json: Any | None = None,
+        state: Any | None = None
+    ) -> Any:
+        if state is None and json is not None:
+            state = json.get('value', False)
+
+        parameters = self.sql_parameters()
+        parameters['id'] = individual_minifigure.fields.id
+        parameters['state'] = state
+
+        rows, _ = BrickSQL().execute_and_commit(
+            self.update_individual_minifigure_state_query,
+            parameters=parameters,
+            name=self.as_column(),
+        )
+
+        if rows != 1:
+            raise DatabaseException('Could not update the {kind} "{name}" state for individual minifigure {figure} ({id})'.format(
+                kind=self.kind,
+                name=self.fields.name,
+                figure=individual_minifigure.fields.figure,
+                id=individual_minifigure.fields.id,
+            ))
+
+        # Info
+        logger.info('{kind} "{name}" state changed to "{state}" for individual minifigure {figure} ({id})'.format(
+            kind=self.kind,
+            name=self.fields.name,
+            state=state,
+            figure=individual_minifigure.fields.figure,
+            id=individual_minifigure.fields.id,
+        ))
+
+        return state
+
     # Update the selected value of this metadata item for a set
     def update_set_value(
         self,

bricktracker/metadata_list.py

@@ -39,9 +39,10 @@ class BrickMetadataList(BrickRecordList[T]):
     # Queries
     select_query: str
 
-    # Set endpoints
-    set_state_endpoint: str
-    set_value_endpoint: str
+    # List-specific endpoints (for operations on the list itself)
+    set_state_endpoint: str = ''
+    set_value_endpoint: str = ''
+    individual_minifigure_value_endpoint: str = ''
 
     def __init__(
         self,
@@ -99,12 +100,15 @@ class BrickMetadataList(BrickRecordList[T]):
 
     # Return the items as columns for a select
     @classmethod
-    def as_columns(cls, /, **kwargs) -> str:
+    def as_columns(cls, /, table: str | None = None, **kwargs) -> str:
         new = cls.new()
 
+        # Use provided table name or default to class table
+        table_name = table if table is not None else cls.table
+
         return ', '.join([
             '"{table}"."{column}"'.format(
-                table=cls.table,
+                table=table_name,
                 column=record.as_column(),
             )
             for record
@@ -184,3 +188,11 @@ class BrickMetadataList(BrickRecordList[T]):
             cls.set_value_endpoint,
             id=id,
         )
+
+    # URL to change the selected value of this metadata item for an individual minifigure
+    @classmethod
+    def url_for_individual_minifigure_value(cls, id: str, /) -> str:
+        return url_for(
+            cls.individual_minifigure_value_endpoint,
+            id=id,
+        )

bricktracker/minifigure_list.py

@@ -76,12 +76,13 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
 
         # Field mapping for sorting
         field_mapping = {
-            'name': '"rebrickable_minifigures"."name"',
-            'parts': '"rebrickable_minifigures"."number_of_parts"',
+            'name': '"combined"."name"',
+            'parts': '"combined"."number_of_parts"',
             'quantity': '"total_quantity"',
             'missing': '"total_missing"',
             'damaged': '"total_damaged"',
-            'sets': '"total_sets"'
+            'sets': '"total_sets"',
+            'individual': '"total_individual"'
         }
 
         # Use the base pagination method
@@ -112,7 +113,7 @@ class BrickMinifigureList(BrickRecordList[BrickMinifigure]):
         if current_app.config['RANDOM']:
             order = 'RANDOM()'
         else:
-            order = '"bricktracker_minifigures"."rowid" DESC'
+            order = '"combined"."rowid" DESC'
 
         self.list(override_query=self.last_query, order=order, limit=limit)
 

bricktracker/parser.py

@@ -35,3 +35,28 @@ def parse_set(set: str, /) -> str:
         ))
 
     return '{number}-{version}'.format(number=number, version=version)
+
+
+# Make sense of string supposed to contain a minifigure ID
+def parse_minifig(figure: str, /) -> str:
+    # Minifigure format is typically fig-XXXXXX
+    # We'll accept with or without the 'fig-' prefix
+    figure = figure.strip()
+
+    if not figure.startswith('fig-'):
+        # Try to add the prefix if it's just numbers
+        if figure.isdigit():
+            figure = 'fig-{figure}'.format(figure=figure.zfill(6))
+        else:
+            raise ErrorException('Minifigure "{figure}" must start with "fig-"'.format(
+                figure=figure,
+            ))
+
+    # Validate format: fig-XXXXXX where X can be digits or letters
+    parts = figure.split('-')
+    if len(parts) != 2 or parts[0] != 'fig':
+        raise ErrorException('Invalid minifigure format "{figure}". Expected format: fig-XXXXXX'.format(
+            figure=figure,
+        ))
+
+    return figure

bricktracker/part.py

@@ -181,7 +181,18 @@ class BrickPart(RebrickablePart):
 
     # Compute the url for updating checked state
     def url_for_checked(self, /) -> str:
-        # Different URL for a minifigure part
+        # Check if this is an individual minifigure (has minifigure with id field, no brickset)
+        if self.minifigure is not None and hasattr(self.minifigure.fields, 'id') and self.brickset is None:
+            # Individual minifigure part
+            return url_for(
+                'individual_minifigure.checked_part',
+                id=self.minifigure.fields.id,
+                part=self.fields.part,
+                color=self.fields.color,
+                spare=self.fields.spare,
+            )
+
+        # Set-based part (with or without minifigure)
         if self.minifigure is not None:
             figure = self.minifigure.fields.figure
         else:
@@ -228,7 +239,19 @@ class BrickPart(RebrickablePart):
 
     # Compute the url for problematic part
     def url_for_problem(self, problem: str, /) -> str:
-        # Different URL for a minifigure part
+        # Check if this is an individual minifigure (has minifigure with id field, no brickset)
+        if self.minifigure is not None and hasattr(self.minifigure.fields, 'id') and self.brickset is None:
+            # Individual minifigure part
+            return url_for(
+                'individual_minifigure.problem_part',
+                id=self.minifigure.fields.id,
+                part=self.fields.part,
+                color=self.fields.color,
+                spare=self.fields.spare,
+                problem=problem,
+            )
+
+        # Set-based part (with or without minifigure)
         if self.minifigure is not None:
             figure = self.minifigure.fields.figure
         else:
@@ -243,3 +266,82 @@ class BrickPart(RebrickablePart):
             spare=self.fields.spare,
             problem=problem,
         )
+
+    # Select a specific part from an individual minifigure
+    def select_specific_individual_minifigure(
+        self,
+        minifigure: 'BrickMinifigure',
+        part: str,
+        color: int,
+        spare: int,
+        /,
+    ) -> Self:
+        # Save the parameters to the fields
+        self.minifigure = minifigure
+        self.fields.id = minifigure.fields.id
+        self.fields.part = part
+        self.fields.color = color
+        self.fields.spare = spare
+
+        if not self.select(override_query='individual_minifigure/part/select/specific'):
+            raise NotFoundException(
+                'Part {part} with color {color} (spare: {spare}) from individual minifigure {figure} ({id}) was not found in the database'.format(
+                    part=self.fields.part,
+                    color=self.fields.color,
+                    spare=self.fields.spare,
+                    figure=self.minifigure.fields.figure,
+                    id=self.minifigure.fields.id,
+                ),
+            )
+
+        return self
+
+    # Update a problematic part for individual minifigure
+    def update_problem_individual_minifigure(self, problem: str, json: Any | None, /) -> int:
+        amount: str | int = json.get('value', '')  # type: ignore
+
+        # We need a positive integer
+        try:
+            if amount == '':
+                amount = 0
+
+            amount = int(amount)
+
+            if amount < 0:
+                amount = 0
+        except Exception:
+            raise ErrorException('"{amount}" is not a valid integer'.format(
+                amount=amount
+            ))
+
+        if amount < 0:
+            raise ErrorException('Cannot set a negative amount')
+
+        setattr(self.fields, problem, amount)
+
+        BrickSQL().execute_and_commit(
+            'individual_minifigure/part/update/{problem}'.format(problem=problem),
+            parameters=self.sql_parameters()
+        )
+
+        return amount
+
+    # Update checked state for individual minifigure part
+    def update_checked_individual_minifigure(self, json: Any | None, /) -> bool:
+        # Handle both direct 'checked' key and changer.js 'value' key format
+        if json:
+            checked = json.get('checked', json.get('value', False))
+        else:
+            checked = False
+
+        checked = bool(checked)
+
+        # Update the field
+        self.fields.checked = checked
+
+        BrickSQL().execute_and_commit(
+            'individual_minifigure/part/update/checked',
+            parameters=self.sql_parameters()
+        )
+
+        return checked

bricktracker/part_list.py

@@ -25,6 +25,7 @@ class BrickPartList(BrickRecordList[BrickPart]):
     all_query: str = 'part/list/all'
     all_by_owner_query: str = 'part/list/all_by_owner'
     different_color_query = 'part/list/with_different_color'
+    individual_minifigure_query: str = 'individual_minifigure/part/list/from_instance'
     last_query: str = 'part/list/last'
     minifigure_query: str = 'part/list/from_minifigure'
     problem_query: str = 'part/list/problem'
@@ -212,6 +213,20 @@ class BrickPartList(BrickRecordList[BrickPart]):
 
         return self
 
+    # Load parts from an individual minifigure instance
+    def from_individual_minifigure(
+        self,
+        minifigure: 'BrickMinifigure',
+        /,
+    ) -> Self:
+        # Save the minifigure
+        self.minifigure = minifigure
+
+        # Load the parts from the database using the instance-specific query
+        self.list(override_query=self.individual_minifigure_query)
+
+        return self
+
     # Load generic parts from a print
     def from_print(
         self,
@@ -306,9 +321,11 @@ class BrickPartList(BrickRecordList[BrickPart]):
     def sql_parameters(self, /) -> dict[str, Any]:
         parameters: dict[str, Any] = super().sql_parameters()
 
-        # Set id
+        # Set id - prioritize brickset, then check minifigure
         if self.brickset is not None:
             parameters['id'] = self.brickset.fields.id
+        elif self.minifigure is not None and hasattr(self.minifigure.fields, 'id'):
+            parameters['id'] = self.minifigure.fields.id
 
         # Use the minifigure number if present,
         if self.minifigure is not None:

bricktracker/set_list.py

@@ -36,6 +36,7 @@ class BrickSetList(BrickRecordList[BrickSet]):
     using_minifigure_query: str = 'set/list/using_minifigure'
     using_part_query: str = 'set/list/using_part'
     using_storage_query: str = 'set/list/using_storage'
+    without_storage_query: str = 'set/list/without_storage'
 
     def __init__(self, /):
         super().__init__()
@@ -670,10 +671,17 @@ class BrickSetList(BrickRecordList[BrickSet]):
 
         return self
 
+    def without_storage(self, /) -> Self:
+        # Load sets with no storage
+        self.list(override_query=self.without_storage_query)
+
+        return self
+
 
 # Helper to build the metadata lists
 def set_metadata_lists(
-    as_class: bool = False
+    as_class: bool = False,
+    hardcoded_statuses_only: bool = False
 ) -> dict[
     str,
     Union[
@@ -685,9 +693,20 @@ def set_metadata_lists(
         list[BrickSetTag]
     ]
 ]:
+    # Get all statuses
+    all_statuses = BrickSetStatusList.list(all=True)
+
+    # Filter to only hardcoded statuses if requested (for individual minifigures)
+    if hardcoded_statuses_only:
+        hardcoded_status_ids = ['minifigures_collected', 'set_checked', 'set_collected']
+        statuses = [s for s in all_statuses if s.fields.id in hardcoded_status_ids]
+    else:
+        statuses = all_statuses
+
     return {
         'brickset_owners': BrickSetOwnerList.list(),
         'brickset_purchase_locations': BrickSetPurchaseLocationList.list(as_class=as_class),  # noqa: E501
+        'brickset_statuses': statuses,
         'brickset_storages': BrickSetStorageList.list(as_class=as_class),
         'brickset_tags': BrickSetTagList.list(),
     }

bricktracker/set_owner.py

@@ -5,8 +5,9 @@ from .metadata import BrickMetadata
 class BrickSetOwner(BrickMetadata):
     kind: str = 'owner'
 
-    # Set state endpoint
+    # Endpoints
     set_state_endpoint: str = 'set.update_owner'
+    individual_minifigure_state_endpoint: str = 'individual_minifigure.update_owner'
 
     # Queries
     delete_query: str = 'set/metadata/owner/delete'
@@ -14,3 +15,4 @@ class BrickSetOwner(BrickMetadata):
     select_query: str = 'set/metadata/owner/select'
     update_field_query: str = 'set/metadata/owner/update/field'
     update_set_state_query: str = 'set/metadata/owner/update/state'
+    update_individual_minifigure_state_query: str = 'individual_minifigure/metadata/owner/update/state'

bricktracker/set_owner_list.py

@@ -15,6 +15,9 @@ class BrickSetOwnerList(BrickMetadataList[BrickSetOwner]):
     # Queries
     select_query = 'set/metadata/owner/list'
 
+    # Endpoints
+    set_state_endpoint: str = 'set.update_owner'
+
     # Instantiate the list with the proper class
     @classmethod
     def new(cls, /, *, force: bool = False) -> Self:

bricktracker/set_purchase_location.py

@@ -5,9 +5,13 @@ from .metadata import BrickMetadata
 class BrickSetPurchaseLocation(BrickMetadata):
     kind: str = 'purchase location'
 
+    # Endpoints
+    individual_minifigure_value_endpoint: str = 'individual_minifigure.update_purchase_location'
+
     # Queries
     delete_query: str = 'set/metadata/purchase_location/delete'
     insert_query: str = 'set/metadata/purchase_location/insert'
     select_query: str = 'set/metadata/purchase_location/select'
     update_field_query: str = 'set/metadata/purchase_location/update/field'
     update_set_value_query: str = 'set/metadata/purchase_location/update/value'
+    update_individual_minifigure_value_query: str = 'individual_minifigure/metadata/purchase_location/update/value'

bricktracker/set_purchase_location_list.py

@@ -22,6 +22,9 @@ class BrickSetPurchaseLocationList(
     # Set value endpoint
     set_value_endpoint: str = 'set.update_purchase_location'
 
+    # Individual minifigure value endpoint
+    individual_minifigure_value_endpoint: str = 'individual_minifigure.update_purchase_location'
+
     # Load all purchase locations
     @classmethod
     def all(cls, /) -> Self:

bricktracker/set_status.py

@@ -7,8 +7,9 @@ from .metadata import BrickMetadata
 class BrickSetStatus(BrickMetadata):
     kind: str = 'status'
 
-    # Set state endpoint
+    # Endpoints
     set_state_endpoint: str = 'set.update_status'
+    individual_minifigure_state_endpoint: str = 'individual_minifigure.update_status'
 
     # Queries
     delete_query: str = 'set/metadata/status/delete'
@@ -16,6 +17,7 @@ class BrickSetStatus(BrickMetadata):
     select_query: str = 'set/metadata/status/select'
     update_field_query: str = 'set/metadata/status/update/field'
     update_set_state_query: str = 'set/metadata/status/update/state'
+    update_individual_minifigure_state_query: str = 'individual_minifigure/metadata/status/update/state'
 
     # Grab data from a form
     def from_form(self, form: dict[str, str], /) -> Self:

bricktracker/set_status_list.py

@@ -15,6 +15,9 @@ class BrickSetStatusList(BrickMetadataList[BrickSetStatus]):
     # Queries
     select_query = 'set/metadata/status/list'
 
+    # Endpoints
+    set_state_endpoint: str = 'set.update_status'
+
     # Filter the list of set status
     def filter(self, all: bool = False) -> list[BrickSetStatus]:
         return [

bricktracker/set_storage.py

@@ -7,12 +7,16 @@ from flask import url_for
 class BrickSetStorage(BrickMetadata):
     kind: str = 'storage'
 
+    # Endpoints
+    individual_minifigure_value_endpoint: str = 'individual_minifigure.update_storage'
+
     # Queries
     delete_query: str = 'set/metadata/storage/delete'
     insert_query: str = 'set/metadata/storage/insert'
     select_query: str = 'set/metadata/storage/select'
     update_field_query: str = 'set/metadata/storage/update/field'
     update_set_value_query: str = 'set/metadata/storage/update/value'
+    update_individual_minifigure_value_query: str = 'individual_minifigure/metadata/storage/update/value'
 
     # Self url
     def url(self, /) -> str:

bricktracker/set_storage_list.py

@@ -20,6 +20,9 @@ class BrickSetStorageList(BrickMetadataList[BrickSetStorage]):
     # Set value endpoint
     set_value_endpoint: str = 'set.update_storage'
 
+    # Individual minifigure value endpoint
+    individual_minifigure_value_endpoint: str = 'individual_minifigure.update_storage'
+
     # Load all storages
     @classmethod
     def all(cls, /) -> Self:

bricktracker/set_tag.py

@@ -5,8 +5,9 @@ from .metadata import BrickMetadata
 class BrickSetTag(BrickMetadata):
     kind: str = 'tag'
 
-    # Set state endpoint
+    # Endpoints
     set_state_endpoint: str = 'set.update_tag'
+    individual_minifigure_state_endpoint: str = 'individual_minifigure.update_tag'
 
     # Queries
     delete_query: str = 'set/metadata/tag/delete'
@@ -14,3 +15,4 @@ class BrickSetTag(BrickMetadata):
     select_query: str = 'set/metadata/tag/select'
     update_field_query: str = 'set/metadata/tag/update/field'
     update_set_state_query: str = 'set/metadata/tag/update/state'
+    update_individual_minifigure_state_query: str = 'individual_minifigure/metadata/tag/update/state'

bricktracker/set_tag_list.py

@@ -15,6 +15,9 @@ class BrickSetTagList(BrickMetadataList[BrickSetTag]):
     # Queries
     select_query: str = 'set/metadata/tag/list'
 
+    # Endpoints
+    set_state_endpoint: str = 'set.update_tag'
+
     # Instantiate the list with the proper class
     @classmethod
     def new(cls, /, *, force: bool = False) -> Self:

bricktracker/socket.py

@@ -22,9 +22,12 @@ MESSAGES: Final[dict[str, str]] = {
     'DOWNLOAD_INSTRUCTIONS': 'download_instructions',
     'DOWNLOAD_PEERON_PAGES': 'download_peeron_pages',
     'FAIL': 'fail',
+    'IMPORT_MINIFIGURE': 'import_minifigure',
     'IMPORT_SET': 'import_set',
+    'LOAD_MINIFIGURE': 'load_minifigure',
     'LOAD_PEERON_PAGES': 'load_peeron_pages',
     'LOAD_SET': 'load_set',
+    'MINIFIGURE_LOADED': 'minifigure_loaded',
     'PROGRESS': 'progress',
     'SET_LOADED': 'set_loaded',
 }
@@ -207,6 +210,27 @@ class BrickSocket(object):
 
             BrickSet().load(self, data)
 
+        @self.socket.on(MESSAGES['IMPORT_MINIFIGURE'], namespace=self.namespace)
+        @rebrickable_socket(self)
+        def import_minifigure(data: dict[str, Any], /) -> None:
+            logger.debug('Socket: IMPORT_MINIFIGURE={data} (from: {fr})'.format(
+                data=data,
+                fr=request.sid,  # type: ignore
+            ))
+
+            from .individual_minifigure import IndividualMinifigure
+            IndividualMinifigure().download(self, data)
+
+        @self.socket.on(MESSAGES['LOAD_MINIFIGURE'], namespace=self.namespace)
+        def load_minifigure(data: dict[str, Any], /) -> None:
+            logger.debug('Socket: LOAD_MINIFIGURE={data} (from: {fr})'.format(
+                data=data,
+                fr=request.sid,  # type: ignore
+            ))
+
+            from .individual_minifigure import IndividualMinifigure
+            IndividualMinifigure().load(self, data)
+
     # Update the progress auto-incrementing
     def auto_progress(
         self,

bricktracker/sql/individual_minifigure/delete/loose_minifigure.sql

@@ -0,0 +1,19 @@
+-- Delete individual minifigure parts
+DELETE FROM "bricktracker_individual_minifigure_parts"
+WHERE "id" = :id;
+
+-- Delete individual minifigure owners
+DELETE FROM "bricktracker_individual_minifigure_owners"
+WHERE "id" = :id;
+
+-- Delete individual minifigure tags
+DELETE FROM "bricktracker_individual_minifigure_tags"
+WHERE "id" = :id;
+
+-- Delete individual minifigure statuses
+DELETE FROM "bricktracker_individual_minifigure_statuses"
+WHERE "id" = :id;
+
+-- Delete the individual minifigure itself
+DELETE FROM "bricktracker_individual_minifigures"
+WHERE "id" = :id;

bricktracker/sql/individual_minifigure/insert.sql

@@ -0,0 +1,15 @@
+INSERT OR IGNORE INTO "bricktracker_individual_minifigures" (
+    "id",
+    "figure",
+    "quantity",
+    "description",
+    "storage",
+    "purchase_location"
+) VALUES (
+    :id,
+    :figure,
+    :quantity,
+    :description,
+    :storage,
+    :purchase_location
+)

bricktracker/sql/individual_minifigure/list/using_storage.sql

@@ -0,0 +1,48 @@
+-- Get all individual minifigure instances for a specific storage location
+SELECT
+    "bricktracker_individual_minifigures"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigures"."quantity",
+    "bricktracker_individual_minifigures"."description",
+    "bricktracker_individual_minifigures"."storage",
+    "bricktracker_individual_minifigures"."purchase_location",
+    "rebrickable_minifigures"."number",
+    "rebrickable_minifigures"."name",
+    "rebrickable_minifigures"."image",
+    "rebrickable_minifigures"."number_of_parts",
+    "storage_meta"."name" AS "storage_name",
+    "purchase_meta"."name" AS "purchase_location_name",
+    IFNULL("problem_join"."total_missing", 0) AS "total_missing",
+    IFNULL("problem_join"."total_damaged", 0) AS "total_damaged"
+FROM "bricktracker_individual_minifigures"
+
+INNER JOIN "rebrickable_minifigures"
+ON "bricktracker_individual_minifigures"."figure" = "rebrickable_minifigures"."figure"
+
+LEFT JOIN "bricktracker_metadata_storages" AS "storage_meta"
+ON "bricktracker_individual_minifigures"."storage" = "storage_meta"."id"
+
+LEFT JOIN "bricktracker_metadata_purchase_locations" AS "purchase_meta"
+ON "bricktracker_individual_minifigures"."purchase_location" = "purchase_meta"."id"
+
+LEFT JOIN (
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    GROUP BY "bricktracker_individual_minifigure_parts"."id"
+) "problem_join"
+ON "bricktracker_individual_minifigures"."id" = "problem_join"."id"
+
+WHERE "bricktracker_individual_minifigures"."storage" IS NOT DISTINCT FROM :storage
+
+{% if order %}
+ORDER BY {{ order }}
+{% else %}
+ORDER BY "bricktracker_individual_minifigures"."rowid" DESC
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/individual_minifigure/list/without_storage.sql

@@ -0,0 +1,48 @@
+-- Get all individual minifigure instances without storage
+SELECT
+    "bricktracker_individual_minifigures"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigures"."quantity",
+    "bricktracker_individual_minifigures"."description",
+    "bricktracker_individual_minifigures"."storage",
+    "bricktracker_individual_minifigures"."purchase_location",
+    "rebrickable_minifigures"."number",
+    "rebrickable_minifigures"."name",
+    "rebrickable_minifigures"."image",
+    "rebrickable_minifigures"."number_of_parts",
+    "storage_meta"."name" AS "storage_name",
+    "purchase_meta"."name" AS "purchase_location_name",
+    IFNULL("problem_join"."total_missing", 0) AS "total_missing",
+    IFNULL("problem_join"."total_damaged", 0) AS "total_damaged"
+FROM "bricktracker_individual_minifigures"
+
+INNER JOIN "rebrickable_minifigures"
+ON "bricktracker_individual_minifigures"."figure" = "rebrickable_minifigures"."figure"
+
+LEFT JOIN "bricktracker_metadata_storages" AS "storage_meta"
+ON "bricktracker_individual_minifigures"."storage" = "storage_meta"."id"
+
+LEFT JOIN "bricktracker_metadata_purchase_locations" AS "purchase_meta"
+ON "bricktracker_individual_minifigures"."purchase_location" = "purchase_meta"."id"
+
+LEFT JOIN (
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    GROUP BY "bricktracker_individual_minifigure_parts"."id"
+) "problem_join"
+ON "bricktracker_individual_minifigures"."id" = "problem_join"."id"
+
+WHERE "bricktracker_individual_minifigures"."storage" IS NULL
+
+{% if order %}
+ORDER BY {{ order }}
+{% else %}
+ORDER BY "bricktracker_individual_minifigures"."rowid" DESC
+{% endif %}
+
+{% if limit %}
+LIMIT {{ limit }}
+{% endif %}

bricktracker/sql/individual_minifigure/metadata/owner/update/state.sql

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

bricktracker/sql/individual_minifigure/metadata/status/update/state.sql

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

bricktracker/sql/individual_minifigure/metadata/tag/update/state.sql

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

bricktracker/sql/individual_minifigure/part/insert.sql

@@ -0,0 +1,23 @@
+INSERT OR IGNORE INTO "bricktracker_individual_minifigure_parts" (
+    "id",
+    "part",
+    "color",
+    "spare",
+    "quantity",
+    "element",
+    "rebrickable_inventory",
+    "missing",
+    "damaged",
+    "checked"
+) VALUES (
+    :id,
+    :part,
+    :color,
+    :spare,
+    :quantity,
+    :element,
+    :rebrickable_inventory,
+    0,
+    0,
+    0
+)

bricktracker/sql/individual_minifigure/part/list/from_instance.sql

@@ -0,0 +1,38 @@
+-- Query parts for a specific individual minifigure instance
+SELECT
+    "bricktracker_individual_minifigure_parts"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigure_parts"."part",
+    "bricktracker_individual_minifigure_parts"."color",
+    "bricktracker_individual_minifigure_parts"."spare",
+    "bricktracker_individual_minifigure_parts"."quantity",
+    "bricktracker_individual_minifigure_parts"."element",
+    "bricktracker_individual_minifigure_parts"."missing" AS "total_missing",
+    "bricktracker_individual_minifigure_parts"."damaged" AS "total_damaged",
+    "bricktracker_individual_minifigure_parts"."checked",
+    "rebrickable_parts"."color_name",
+    "rebrickable_parts"."color_rgb",
+    "rebrickable_parts"."color_transparent",
+    "rebrickable_parts"."bricklink_color_id",
+    "rebrickable_parts"."bricklink_color_name",
+    "rebrickable_parts"."bricklink_part_num",
+    "rebrickable_parts"."name",
+    "rebrickable_parts"."image",
+    "rebrickable_parts"."image_id",
+    "rebrickable_parts"."url",
+    "rebrickable_parts"."print",
+    NULL AS "total_quantity",
+    NULL AS "total_spare",
+    NULL AS "total_sets",
+    NULL AS "total_minifigures"
+FROM "bricktracker_individual_minifigure_parts"
+INNER JOIN "bricktracker_individual_minifigures"
+ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+INNER JOIN "rebrickable_parts"
+ON "bricktracker_individual_minifigure_parts"."part" = "rebrickable_parts"."part"
+AND "bricktracker_individual_minifigure_parts"."color" = "rebrickable_parts"."color_id"
+WHERE "bricktracker_individual_minifigure_parts"."id" IS NOT DISTINCT FROM :id
+
+{% if order %}
+ORDER BY {{ order | replace('"combined"', '"bricktracker_individual_minifigure_parts"') | replace('"bricktracker_parts"', '"bricktracker_individual_minifigure_parts"') }}
+{% endif %}

bricktracker/sql/individual_minifigure/part/select/specific.sql

@@ -0,0 +1,33 @@
+-- Select a specific part from an individual minifigure instance
+SELECT
+    "bricktracker_individual_minifigure_parts"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigure_parts"."part",
+    "bricktracker_individual_minifigure_parts"."color",
+    "bricktracker_individual_minifigure_parts"."spare",
+    "bricktracker_individual_minifigure_parts"."quantity",
+    "bricktracker_individual_minifigure_parts"."element",
+    "bricktracker_individual_minifigure_parts"."missing",
+    "bricktracker_individual_minifigure_parts"."damaged",
+    "bricktracker_individual_minifigure_parts"."checked",
+    "rebrickable_parts"."color_name",
+    "rebrickable_parts"."color_rgb",
+    "rebrickable_parts"."color_transparent",
+    "rebrickable_parts"."bricklink_color_id",
+    "rebrickable_parts"."bricklink_color_name",
+    "rebrickable_parts"."bricklink_part_num",
+    "rebrickable_parts"."name",
+    "rebrickable_parts"."image",
+    "rebrickable_parts"."image_id",
+    "rebrickable_parts"."url",
+    "rebrickable_parts"."print"
+FROM "bricktracker_individual_minifigure_parts"
+INNER JOIN "bricktracker_individual_minifigures"
+ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+INNER JOIN "rebrickable_parts"
+ON "bricktracker_individual_minifigure_parts"."part" = "rebrickable_parts"."part"
+AND "bricktracker_individual_minifigure_parts"."color" = "rebrickable_parts"."color_id"
+WHERE "bricktracker_individual_minifigure_parts"."id" IS NOT DISTINCT FROM :id
+AND "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+AND "bricktracker_individual_minifigure_parts"."spare" IS NOT DISTINCT FROM :spare

bricktracker/sql/individual_minifigure/part/update/checked.sql

@@ -0,0 +1,6 @@
+UPDATE "bricktracker_individual_minifigure_parts"
+SET "checked" = :checked
+WHERE "bricktracker_individual_minifigure_parts"."id" IS NOT DISTINCT FROM :id
+AND "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+AND "bricktracker_individual_minifigure_parts"."spare" IS NOT DISTINCT FROM :spare

bricktracker/sql/individual_minifigure/part/update/damaged.sql

@@ -0,0 +1,6 @@
+UPDATE "bricktracker_individual_minifigure_parts"
+SET "damaged" = :damaged
+WHERE "bricktracker_individual_minifigure_parts"."id" IS NOT DISTINCT FROM :id
+AND "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+AND "bricktracker_individual_minifigure_parts"."spare" IS NOT DISTINCT FROM :spare

bricktracker/sql/individual_minifigure/part/update/missing.sql

@@ -0,0 +1,6 @@
+UPDATE "bricktracker_individual_minifigure_parts"
+SET "missing" = :missing
+WHERE "bricktracker_individual_minifigure_parts"."id" IS NOT DISTINCT FROM :id
+AND "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+AND "bricktracker_individual_minifigure_parts"."spare" IS NOT DISTINCT FROM :spare

bricktracker/sql/individual_minifigure/select/by_id.sql

@@ -0,0 +1,35 @@
+-- Get a specific individual minifigure instance by ID
+SELECT
+    "bricktracker_individual_minifigures"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigures"."quantity",
+    "bricktracker_individual_minifigures"."description",
+    "bricktracker_individual_minifigures"."storage",
+    "bricktracker_individual_minifigures"."purchase_location",
+    "rebrickable_minifigures"."number",
+    "rebrickable_minifigures"."name",
+    "rebrickable_minifigures"."image",
+    "rebrickable_minifigures"."number_of_parts",
+    "storage_meta"."name" AS "storage_name",
+    "purchase_meta"."name" AS "purchase_location_name"{{ owners }}{{ statuses }}{{ tags }}
+FROM "bricktracker_individual_minifigures"
+
+INNER JOIN "rebrickable_minifigures"
+ON "bricktracker_individual_minifigures"."figure" = "rebrickable_minifigures"."figure"
+
+LEFT JOIN "bricktracker_metadata_storages" AS "storage_meta"
+ON "bricktracker_individual_minifigures"."storage" = "storage_meta"."id"
+
+LEFT JOIN "bricktracker_metadata_purchase_locations" AS "purchase_meta"
+ON "bricktracker_individual_minifigures"."purchase_location" = "purchase_meta"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_owners"
+ON "bricktracker_individual_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigure_owners"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_statuses"
+ON "bricktracker_individual_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigure_statuses"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_tags"
+ON "bricktracker_individual_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigure_tags"."id"
+
+WHERE "bricktracker_individual_minifigures"."id" = :id

bricktracker/sql/individual_minifigure/select/instances_by_figure.sql

@@ -0,0 +1,52 @@
+-- Get all individual minifigure instances for a specific figure
+SELECT
+    "bricktracker_individual_minifigures"."id",
+    "bricktracker_individual_minifigures"."figure",
+    "bricktracker_individual_minifigures"."quantity",
+    "bricktracker_individual_minifigures"."description",
+    "bricktracker_individual_minifigures"."storage",
+    "bricktracker_individual_minifigures"."purchase_location",
+    "rebrickable_minifigures"."number",
+    "rebrickable_minifigures"."name",
+    "rebrickable_minifigures"."image",
+    "rebrickable_minifigures"."number_of_parts",
+    "storage_meta"."name" AS "storage_name",
+    "purchase_meta"."name" AS "purchase_location_name",
+    {{ owners }},
+    {{ statuses }},
+    {{ tags }},
+    IFNULL("problem_join"."total_missing", 0) AS "total_missing",
+    IFNULL("problem_join"."total_damaged", 0) AS "total_damaged"
+FROM "bricktracker_individual_minifigures"
+
+INNER JOIN "rebrickable_minifigures"
+ON "bricktracker_individual_minifigures"."figure" = "rebrickable_minifigures"."figure"
+
+LEFT JOIN "bricktracker_metadata_storages" AS "storage_meta"
+ON "bricktracker_individual_minifigures"."storage" = "storage_meta"."id"
+
+LEFT JOIN "bricktracker_metadata_purchase_locations" AS "purchase_meta"
+ON "bricktracker_individual_minifigures"."purchase_location" = "purchase_meta"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_owners"
+ON "bricktracker_individual_minifigures"."id" = "bricktracker_individual_minifigure_owners"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_statuses"
+ON "bricktracker_individual_minifigures"."id" = "bricktracker_individual_minifigure_statuses"."id"
+
+LEFT JOIN "bricktracker_individual_minifigure_tags"
+ON "bricktracker_individual_minifigures"."id" = "bricktracker_individual_minifigure_tags"."id"
+
+LEFT JOIN (
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    GROUP BY "bricktracker_individual_minifigure_parts"."id"
+) "problem_join"
+ON "bricktracker_individual_minifigures"."id" = "problem_join"."id"
+
+WHERE "bricktracker_individual_minifigures"."figure" = :figure
+
+ORDER BY "bricktracker_individual_minifigures"."rowid" DESC

bricktracker/sql/individual_minifigure/update.sql

@@ -0,0 +1,7 @@
+UPDATE "bricktracker_individual_minifigures"
+SET
+    "quantity" = :quantity,
+    "description" = :description,
+    "storage" = :storage,
+    "purchase_location" = :purchase_location
+WHERE "id" = :id

bricktracker/sql/migrations/0020.sql

@@ -0,0 +1,132 @@
+-- Migration 0020: Add individual minifigures and individual parts tables
+
+-- Individual minifigures table - tracks individual minifigures not associated with sets
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_minifigures" (
+    "id" TEXT NOT NULL,
+    "figure" TEXT NOT NULL,
+    "quantity" INTEGER NOT NULL DEFAULT 1,
+    "description" TEXT,
+    "storage" TEXT, -- Storage bin location
+    "purchase_date" REAL, -- Purchase date
+    "purchase_location" TEXT, -- Purchase location
+    "purchase_price" REAL, -- Purchase price
+    PRIMARY KEY("id"),
+    FOREIGN KEY("figure") REFERENCES "rebrickable_minifigures"("figure"),
+    FOREIGN KEY("storage") REFERENCES "bricktracker_metadata_storages"("id"),
+    FOREIGN KEY("purchase_location") REFERENCES "bricktracker_metadata_purchase_locations"("id")
+);
+
+-- Individual minifigure statuses
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_minifigure_statuses" (
+    "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("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_minifigures"("id")
+);
+
+-- Individual minifigure owners
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_minifigure_owners" (
+    "id" TEXT NOT NULL,
+    PRIMARY KEY("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_minifigures"("id")
+);
+
+-- Individual minifigure tags
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_minifigure_tags" (
+    "id" TEXT NOT NULL,
+    PRIMARY KEY("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_minifigures"("id")
+);
+
+-- Parts table for individual minifigures - tracks constituent parts
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_minifigure_parts" (
+    "id" TEXT NOT NULL,
+    "part" TEXT NOT NULL,
+    "color" INTEGER NOT NULL,
+    "spare" BOOLEAN NOT NULL,
+    "quantity" INTEGER NOT NULL,
+    "element" INTEGER,
+    "rebrickable_inventory" INTEGER NOT NULL,
+    "missing" INTEGER NOT NULL DEFAULT 0,
+    "damaged" INTEGER NOT NULL DEFAULT 0,
+    "checked" BOOLEAN DEFAULT 0,
+    PRIMARY KEY("id", "part", "color", "spare"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_minifigures"("id"),
+    FOREIGN KEY("part", "color") REFERENCES "rebrickable_parts"("part", "color_id")
+);
+
+-- Individual parts table - tracks individual parts not associated with sets
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_parts" (
+    "id" TEXT NOT NULL,
+    "part" TEXT NOT NULL,
+    "color" INTEGER NOT NULL,
+    "quantity" INTEGER NOT NULL DEFAULT 1,
+    "description" TEXT,
+    "storage" TEXT, -- Storage bin location
+    "purchase_date" REAL, -- Purchase date
+    "purchase_location" TEXT, -- Purchase location
+    "purchase_price" REAL, -- Purchase price
+    PRIMARY KEY("id"),
+    FOREIGN KEY("part", "color") REFERENCES "rebrickable_parts"("part", "color_id"),
+    FOREIGN KEY("storage") REFERENCES "bricktracker_metadata_storages"("id"),
+    FOREIGN KEY("purchase_location") REFERENCES "bricktracker_metadata_purchase_locations"("id")
+);
+
+-- Individual part owners
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_part_owners" (
+    "id" TEXT NOT NULL,
+    PRIMARY KEY("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_parts"("id")
+);
+
+-- Individual part tags
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_part_tags" (
+    "id" TEXT NOT NULL,
+    PRIMARY KEY("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_parts"("id")
+);
+
+-- Individual part statuses
+CREATE TABLE IF NOT EXISTS "bricktracker_individual_part_statuses" (
+    "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("id"),
+    FOREIGN KEY("id") REFERENCES "bricktracker_individual_parts"("id")
+);
+
+-- Indexes for individual minifigures
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigures_figure
+ON bricktracker_individual_minifigures(figure);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigures_storage
+ON bricktracker_individual_minifigures(storage);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigures_purchase_location
+ON bricktracker_individual_minifigures(purchase_location);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigures_purchase_date
+ON bricktracker_individual_minifigures(purchase_date);
+
+-- Indexes for individual minifigure parts
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigure_parts_id_missing_damaged
+ON bricktracker_individual_minifigure_parts(id, missing, damaged);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_minifigure_parts_part_color
+ON bricktracker_individual_minifigure_parts(part, color);
+
+-- Indexes for individual parts
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_parts_part_color
+ON bricktracker_individual_parts(part, color);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_parts_storage
+ON bricktracker_individual_parts(storage);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_parts_purchase_location
+ON bricktracker_individual_parts(purchase_location);
+
+CREATE INDEX IF NOT EXISTS idx_bricktracker_individual_parts_purchase_date
+ON bricktracker_individual_parts(purchase_date);

bricktracker/sql/migrations/0021.sql

@@ -0,0 +1,23 @@
+-- Migration 0021: Add existing owner/tag columns to individual minifigure and individual part metadata tables
+
+-- Add owner columns to individual minifigure owners table
+ALTER TABLE "bricktracker_individual_minifigure_owners"
+ADD COLUMN "owner_32479d0a_cd3c_43c6_aa16_b3f378915b13" BOOLEAN NOT NULL DEFAULT 0;
+
+ALTER TABLE "bricktracker_individual_minifigure_owners"
+ADD COLUMN "owner_2f07518d_40e1_4279_b0d0_aa339f195cbf" BOOLEAN NOT NULL DEFAULT 0;
+
+-- Add tag columns to individual minifigure tags table
+ALTER TABLE "bricktracker_individual_minifigure_tags"
+ADD COLUMN "tag_b1b5c316_5caf_4b82_a085_ac4c7ab9b8db" BOOLEAN NOT NULL DEFAULT 0;
+
+-- Add owner columns to individual part owners table
+ALTER TABLE "bricktracker_individual_part_owners"
+ADD COLUMN "owner_32479d0a_cd3c_43c6_aa16_b3f378915b13" BOOLEAN NOT NULL DEFAULT 0;
+
+ALTER TABLE "bricktracker_individual_part_owners"
+ADD COLUMN "owner_2f07518d_40e1_4279_b0d0_aa339f195cbf" BOOLEAN NOT NULL DEFAULT 0;
+
+-- Add tag columns to individual part tags table
+ALTER TABLE "bricktracker_individual_part_tags"
+ADD COLUMN "tag_b1b5c316_5caf_4b82_a085_ac4c7ab9b8db" BOOLEAN NOT NULL DEFAULT 0;

bricktracker/sql/minifigure/base/base.sql

@@ -1,10 +1,11 @@
+-- Combined query for both set-based and individual minifigures
 SELECT
-    "bricktracker_minifigures"."quantity",
-    "rebrickable_minifigures"."figure",
-    "rebrickable_minifigures"."number",
-    "rebrickable_minifigures"."number_of_parts",
-    "rebrickable_minifigures"."name",
-    "rebrickable_minifigures"."image",
+    "combined"."quantity",
+    "combined"."figure",
+    "combined"."number",
+    "combined"."number_of_parts",
+    "combined"."name",
+    "combined"."image",
     {% block total_missing %}
     NULL AS "total_missing", -- dummy for order: total_missing
     {% endblock %}
@@ -15,12 +16,44 @@ SELECT
     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 "bricktracker_minifigures"
+    {% block total_individual %}
+    NULL AS "total_individual" -- dummy for order: total_individual
+    {% endblock %}
+FROM (
+    -- Set-based minifigures
+    SELECT
+        "bricktracker_minifigures"."id",
+        "bricktracker_minifigures"."quantity",
+        "rebrickable_minifigures"."figure",
+        "rebrickable_minifigures"."number",
+        "rebrickable_minifigures"."number_of_parts",
+        "rebrickable_minifigures"."name",
+        "rebrickable_minifigures"."image",
+        "bricktracker_minifigures"."rowid" AS "rowid",
+        'set' AS "source_type"
+    FROM "bricktracker_minifigures"
+    INNER JOIN "rebrickable_minifigures"
+    ON "bricktracker_minifigures"."figure" IS NOT DISTINCT FROM "rebrickable_minifigures"."figure"
 
-INNER JOIN "rebrickable_minifigures"
-ON "bricktracker_minifigures"."figure" IS NOT DISTINCT FROM "rebrickable_minifigures"."figure"
+    UNION ALL
+
+    -- Individual minifigures
+    SELECT
+        "bricktracker_individual_minifigures"."id",
+        "bricktracker_individual_minifigures"."quantity",
+        "rebrickable_minifigures"."figure",
+        "rebrickable_minifigures"."number",
+        "rebrickable_minifigures"."number_of_parts",
+        "rebrickable_minifigures"."name",
+        "rebrickable_minifigures"."image",
+        "bricktracker_individual_minifigures"."rowid" AS "rowid",
+        'individual' AS "source_type"
+    FROM "bricktracker_individual_minifigures"
+    INNER JOIN "rebrickable_minifigures"
+    ON "bricktracker_individual_minifigures"."figure" IS NOT DISTINCT FROM "rebrickable_minifigures"."figure"
+) AS "combined"
 
 {% block join %}{% endblock %}
 

bricktracker/sql/minifigure/list/all.sql

@@ -9,16 +9,22 @@ SUM(IFNULL("problem_join"."total_damaged", 0)) AS "total_damaged",
 {% endblock %}
 
 {% block total_quantity %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_quantity",
+SUM(IFNULL("combined"."quantity", 0)) AS "total_quantity",
 {% endblock %}
 
 {% block total_sets %}
-IFNULL(COUNT("bricktracker_minifigures"."id"), 0) AS "total_sets"
+SUM(CASE WHEN "combined"."source_type" = 'set' THEN 1 ELSE 0 END) AS "total_sets",
+{% endblock %}
+
+{% block total_individual %}
+SUM(CASE WHEN "combined"."source_type" = 'individual' THEN 1 ELSE 0 END) AS "total_individual"
 {% endblock %}
 
 {% block join %}
 -- LEFT JOIN + SELECT to avoid messing the total
+-- Combine parts from both set-based and individual minifigures
 LEFT JOIN (
+    -- Set-based minifigure parts
     SELECT
         "bricktracker_parts"."id",
         "bricktracker_parts"."figure",
@@ -29,18 +35,33 @@ LEFT JOIN (
     GROUP BY
         "bricktracker_parts"."id",
         "bricktracker_parts"."figure"
+
+    UNION ALL
+
+    -- Individual minifigure parts
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "combined"."figure",
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures" ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+    INNER JOIN "rebrickable_minifigures" AS "combined" ON "bricktracker_individual_minifigures"."figure" = "combined"."figure"
+    GROUP BY
+        "bricktracker_individual_minifigure_parts"."id",
+        "combined"."figure"
 ) "problem_join"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "problem_join"."id"
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "problem_join"."figure"
+ON "combined"."id" IS NOT DISTINCT FROM "problem_join"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "problem_join"."figure"
 {% endblock %}
 
 {% block where %}
 {% if search_query %}
-WHERE (LOWER("rebrickable_minifigures"."name") LIKE LOWER('%{{ search_query }}%'))
+WHERE (LOWER("combined"."name") LIKE LOWER('%{{ search_query }}%'))
 {% endif %}
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/list/all_by_owner.sql

@@ -10,31 +10,53 @@ SUM(IFNULL("problem_join"."total_damaged", 0)) AS "total_damaged",
 
 {% block total_quantity %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_minifigures"."quantity", 0) ELSE 0 END) AS "total_quantity",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("combined"."quantity", 0)
+    WHEN "combined"."source_type" = 'individual' AND "individual_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("combined"."quantity", 0)
+    ELSE 0
+END) AS "total_quantity",
 {% else %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_quantity",
+SUM(IFNULL("combined"."quantity", 0)) AS "total_quantity",
 {% endif %}
 {% endblock %}
 
 {% block total_sets %}
 {% if owner_id and owner_id != 'all' %}
-COUNT(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_minifigures"."id" ELSE NULL END) AS "total_sets"
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "set_owners"."owner_{{ owner_id }}" = 1 THEN 1
+    ELSE 0
+END) AS "total_sets",
 {% else %}
-COUNT("bricktracker_minifigures"."id") AS "total_sets"
+SUM(CASE WHEN "combined"."source_type" = 'set' THEN 1 ELSE 0 END) AS "total_sets",
+{% endif %}
+{% endblock %}
+
+{% block total_individual %}
+{% if owner_id and owner_id != 'all' %}
+SUM(CASE
+    WHEN "combined"."source_type" = 'individual' AND "individual_owners"."owner_{{ owner_id }}" = 1 THEN 1
+    ELSE 0
+END) AS "total_individual"
+{% else %}
+SUM(CASE WHEN "combined"."source_type" = 'individual' THEN 1 ELSE 0 END) AS "total_individual"
 {% endif %}
 {% endblock %}
 
 {% block join %}
--- Join with sets to get owner information
-INNER JOIN "bricktracker_sets"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_sets"."id"
+-- Join with set owners for set-based minifigures
+LEFT JOIN "bricktracker_sets"
+ON "combined"."id" = "bricktracker_sets"."id" AND "combined"."source_type" = 'set'
 
--- Left join with set owners (using dynamic columns)
-LEFT JOIN "bricktracker_set_owners"
-ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "bricktracker_set_owners"."id"
+LEFT JOIN "bricktracker_set_owners" AS "set_owners"
+ON "bricktracker_sets"."id" = "set_owners"."id"
+
+-- Join with individual minifigure owners for individual minifigures
+LEFT JOIN "bricktracker_individual_minifigure_owners" AS "individual_owners"
+ON "combined"."id" = "individual_owners"."id" AND "combined"."source_type" = 'individual'
 
 -- LEFT JOIN + SELECT to avoid messing the total
 LEFT JOIN (
+    -- Set-based minifigure parts
     SELECT
         "bricktracker_parts"."id",
         "bricktracker_parts"."figure",
@@ -47,25 +69,47 @@ LEFT JOIN (
         {% endif %}
     FROM "bricktracker_parts"
     INNER JOIN "bricktracker_sets" AS "parts_sets"
-    ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "parts_sets"."id"
+    ON "bricktracker_parts"."id" = "parts_sets"."id"
     LEFT JOIN "bricktracker_set_owners" AS "owner_parts"
-    ON "parts_sets"."id" IS NOT DISTINCT FROM "owner_parts"."id"
+    ON "parts_sets"."id" = "owner_parts"."id"
     WHERE "bricktracker_parts"."figure" IS NOT NULL
     GROUP BY
         "bricktracker_parts"."id",
         "bricktracker_parts"."figure"
+
+    UNION ALL
+
+    -- Individual minifigure parts
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        {% if owner_id and owner_id != 'all' %}
+        SUM(CASE WHEN "owner_individual"."owner_{{ owner_id }}" = 1 THEN "bricktracker_individual_minifigure_parts"."missing" ELSE 0 END) AS "total_missing",
+        SUM(CASE WHEN "owner_individual"."owner_{{ owner_id }}" = 1 THEN "bricktracker_individual_minifigure_parts"."damaged" ELSE 0 END) AS "total_damaged"
+        {% else %}
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+        {% endif %}
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+    LEFT JOIN "bricktracker_individual_minifigure_owners" AS "owner_individual"
+    ON "bricktracker_individual_minifigures"."id" = "owner_individual"."id"
+    GROUP BY
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure"
 ) "problem_join"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "problem_join"."id"
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "problem_join"."figure"
+ON "combined"."id" = "problem_join"."id"
+AND "combined"."figure" = "problem_join"."figure"
 {% endblock %}
 
 {% block where %}
 {% set conditions = [] %}
 {% if owner_id and owner_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_set_owners"."owner_' ~ owner_id ~ '" = 1') %}
+  {% set _ = conditions.append('(("combined"."source_type" = \'set\' AND "set_owners"."owner_' ~ owner_id ~ '" = 1) OR ("combined"."source_type" = \'individual\' AND "individual_owners"."owner_' ~ owner_id ~ '" = 1))') %}
 {% endif %}
 {% if search_query %}
-  {% set _ = conditions.append('(LOWER("rebrickable_minifigures"."name") LIKE LOWER(\'%' ~ search_query ~ '%\'))') %}
+  {% set _ = conditions.append('(LOWER("combined"."name") LIKE LOWER(\'%' ~ search_query ~ '%\'))') %}
 {% endif %}
 {% if conditions %}
 WHERE {{ conditions | join(' AND ') }}
@@ -74,5 +118,5 @@ WHERE {{ conditions | join(' AND ') }}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/list/damaged_part.sql

@@ -1,28 +1,59 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block total_damaged %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("parts_combined"."damaged") AS "total_damaged",
 {% endblock %}
 
 {% block join %}
-LEFT JOIN "bricktracker_parts"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_parts"."id"
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "bricktracker_parts"."figure"
+-- Join with parts from both set-based and individual minifigures
+LEFT JOIN (
+    SELECT
+        "bricktracker_parts"."id",
+        "bricktracker_parts"."figure",
+        "bricktracker_parts"."damaged"
+    FROM "bricktracker_parts"
+
+    UNION ALL
+
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigure_parts"."damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+) AS "parts_combined"
+ON "combined"."id" IS NOT DISTINCT FROM "parts_combined"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "parts_combined"."figure"
 {% endblock %}
 
 {% block where %}
-WHERE "rebrickable_minifigures"."figure" IN (
-    SELECT "bricktracker_parts"."figure"
-    FROM "bricktracker_parts"
-    WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
-    AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
-    AND "bricktracker_parts"."figure" IS NOT NULL
-    AND "bricktracker_parts"."damaged" > 0
-    GROUP BY "bricktracker_parts"."figure"
+WHERE "combined"."figure" IN (
+    -- Find figures with damaged parts from both sources
+    SELECT "figure"
+    FROM (
+        SELECT "bricktracker_parts"."figure"
+        FROM "bricktracker_parts"
+        WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
+        AND "bricktracker_parts"."figure" IS NOT NULL
+        AND "bricktracker_parts"."damaged" > 0
+
+        UNION
+
+        SELECT "bricktracker_individual_minifigures"."figure"
+        FROM "bricktracker_individual_minifigure_parts"
+        INNER JOIN "bricktracker_individual_minifigures"
+        ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+        WHERE "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+        AND "bricktracker_individual_minifigure_parts"."damaged" > 0
+    ) AS "damaged_figures"
+    GROUP BY "figure"
 )
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/list/from_set.sql

@@ -1,5 +1,5 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block where %}
-WHERE "bricktracker_minifigures"."id" IS NOT DISTINCT FROM :id
+WHERE "combined"."id" IS NOT DISTINCT FROM :id AND "combined"."source_type" = 'set'
 {% endblock %}

bricktracker/sql/minifigure/list/last.sql

@@ -1,21 +1,40 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block total_missing %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("parts_combined"."missing") AS "total_missing",
 {% endblock %}
 
 {% block total_damaged %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("parts_combined"."damaged") AS "total_damaged",
 {% endblock %}
 
 {% block join %}
-LEFT JOIN "bricktracker_parts"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_parts"."id"
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "bricktracker_parts"."figure"
+-- Join with parts from both set-based and individual minifigures
+LEFT JOIN (
+    SELECT
+        "bricktracker_parts"."id",
+        "bricktracker_parts"."figure",
+        "bricktracker_parts"."missing",
+        "bricktracker_parts"."damaged"
+    FROM "bricktracker_parts"
+
+    UNION ALL
+
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigure_parts"."missing",
+        "bricktracker_individual_minifigure_parts"."damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+) AS "parts_combined"
+ON "combined"."id" IS NOT DISTINCT FROM "parts_combined"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "parts_combined"."figure"
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure",
-    "bricktracker_minifigures"."id"
+    "combined"."figure",
+    "combined"."id"
 {% endblock %}

bricktracker/sql/minifigure/list/missing_part.sql

@@ -1,28 +1,59 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block total_missing %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("parts_combined"."missing") AS "total_missing",
 {% endblock %}
 
 {% block join %}
-LEFT JOIN "bricktracker_parts"
-ON "bricktracker_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_parts"."id"
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "bricktracker_parts"."figure"
+-- Join with parts from both set-based and individual minifigures
+LEFT JOIN (
+    SELECT
+        "bricktracker_parts"."id",
+        "bricktracker_parts"."figure",
+        "bricktracker_parts"."missing"
+    FROM "bricktracker_parts"
+
+    UNION ALL
+
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigure_parts"."missing"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+) AS "parts_combined"
+ON "combined"."id" IS NOT DISTINCT FROM "parts_combined"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "parts_combined"."figure"
 {% endblock %}
 
 {% block where %}
-WHERE "rebrickable_minifigures"."figure" IN (
-    SELECT "bricktracker_parts"."figure"
-    FROM "bricktracker_parts"
-    WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
-    AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
-    AND "bricktracker_parts"."figure" IS NOT NULL
-    AND "bricktracker_parts"."missing" > 0
-    GROUP BY "bricktracker_parts"."figure"
+WHERE "combined"."figure" IN (
+    -- Find figures with missing parts from both sources
+    SELECT "figure"
+    FROM (
+        SELECT "bricktracker_parts"."figure"
+        FROM "bricktracker_parts"
+        WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
+        AND "bricktracker_parts"."figure" IS NOT NULL
+        AND "bricktracker_parts"."missing" > 0
+
+        UNION
+
+        SELECT "bricktracker_individual_minifigures"."figure"
+        FROM "bricktracker_individual_minifigure_parts"
+        INNER JOIN "bricktracker_individual_minifigures"
+        ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+        WHERE "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+        AND "bricktracker_individual_minifigure_parts"."missing" > 0
+    ) AS "missing_figures"
+    GROUP BY "figure"
 )
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/list/using_part.sql

@@ -1,21 +1,34 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block total_quantity %}
-SUM("bricktracker_minifigures"."quantity") AS "total_quantity",
+SUM("combined"."quantity") AS "total_quantity",
 {% endblock %}
 
 {% block where %}
-WHERE "rebrickable_minifigures"."figure" IN (
-    SELECT "bricktracker_parts"."figure"
-    FROM "bricktracker_parts"
-    WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
-    AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
-    AND "bricktracker_parts"."figure" IS NOT NULL
-    GROUP BY "bricktracker_parts"."figure"
+WHERE "combined"."figure" IN (
+    -- Find figures from both set-based and individual minifigure parts
+    SELECT "figure"
+    FROM (
+        SELECT "bricktracker_parts"."figure"
+        FROM "bricktracker_parts"
+        WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
+        AND "bricktracker_parts"."figure" IS NOT NULL
+
+        UNION
+
+        SELECT "bricktracker_individual_minifigures"."figure"
+        FROM "bricktracker_individual_minifigure_parts"
+        INNER JOIN "bricktracker_individual_minifigures"
+        ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+        WHERE "bricktracker_individual_minifigure_parts"."part" IS NOT DISTINCT FROM :part
+        AND "bricktracker_individual_minifigure_parts"."color" IS NOT DISTINCT FROM :color
+    ) AS "parts_figures"
+    GROUP BY "figure"
 )
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/select/generic.sql

@@ -9,16 +9,22 @@ IFNULL("problem_join"."total_damaged", 0) AS "total_damaged",
 {% endblock %}
 
 {% block total_quantity %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_quantity",
+SUM(IFNULL("combined"."quantity", 0)) AS "total_quantity",
 {% endblock %}
 
 {% block total_sets %}
-IFNULL(COUNT(DISTINCT "bricktracker_minifigures"."id"), 0) AS "total_sets"
+IFNULL(COUNT(DISTINCT "combined"."id"), 0) AS "total_sets",
+{% endblock %}
+
+{% block total_individual %}
+IFNULL(COUNT(DISTINCT "combined"."id"), 0) AS "total_individual"
 {% endblock %}
 
 {% block join %}
 -- LEFT JOIN + SELECT to avoid messing the total
+-- Combine parts from both set-based and individual minifigures
 LEFT JOIN (
+    -- Set-based minifigure parts
     SELECT
         "bricktracker_parts"."figure",
         SUM("bricktracker_parts"."missing") AS "total_missing",
@@ -26,15 +32,27 @@ LEFT JOIN (
     FROM "bricktracker_parts"
     WHERE "bricktracker_parts"."figure" IS NOT DISTINCT FROM :figure
     GROUP BY "bricktracker_parts"."figure"
+
+    UNION ALL
+
+    -- Individual minifigure parts
+    SELECT
+        "bricktracker_individual_minifigures"."figure",
+        SUM("bricktracker_individual_minifigure_parts"."missing") AS "total_missing",
+        SUM("bricktracker_individual_minifigure_parts"."damaged") AS "total_damaged"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures" ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+    WHERE "bricktracker_individual_minifigures"."figure" IS NOT DISTINCT FROM :figure
+    GROUP BY "bricktracker_individual_minifigures"."figure"
 ) "problem_join"
-ON "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM "problem_join"."figure"
+ON "combined"."figure" IS NOT DISTINCT FROM "problem_join"."figure"
 {% endblock %}
 
 {% block where %}
-WHERE "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM :figure
+WHERE "combined"."figure" IS NOT DISTINCT FROM :figure
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "rebrickable_minifigures"."figure"
+    "combined"."figure"
 {% endblock %}

bricktracker/sql/minifigure/select/specific.sql

@@ -1,6 +1,7 @@
 {% extends 'minifigure/base/base.sql' %}
 
 {% block where %}
-WHERE "bricktracker_minifigures"."id" IS NOT DISTINCT FROM :id
-AND "rebrickable_minifigures"."figure" IS NOT DISTINCT FROM :figure
+WHERE "combined"."id" IS NOT DISTINCT FROM :id
+AND "combined"."figure" IS NOT DISTINCT FROM :figure
+AND "combined"."source_type" = 'set'
 {% endblock %}

bricktracker/sql/part/base/base.sql

@@ -1,17 +1,14 @@
 SELECT
-    "bricktracker_parts"."id",
-    "bricktracker_parts"."figure",
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare",
-    "bricktracker_parts"."quantity",
-    "bricktracker_parts"."element",
-    --"bricktracker_parts"."rebrickable_inventory",
-    "bricktracker_parts"."missing",
-    "bricktracker_parts"."damaged",
-    "bricktracker_parts"."checked",
-    --"rebrickable_parts"."part",
-    --"rebrickable_parts"."color_id",
+    "combined"."id",
+    "combined"."figure",
+    "combined"."part",
+    "combined"."color",
+    "combined"."spare",
+    "combined"."quantity",
+    "combined"."element",
+    "combined"."missing",
+    "combined"."damaged",
+    "combined"."checked",
     "rebrickable_parts"."color_name",
     "rebrickable_parts"."color_rgb",
     "rebrickable_parts"."color_transparent",
@@ -19,7 +16,6 @@ SELECT
     "rebrickable_parts"."bricklink_color_name",
     "rebrickable_parts"."bricklink_part_num",
     "rebrickable_parts"."name",
-    --"rebrickable_parts"."category",
     "rebrickable_parts"."image",
     "rebrickable_parts"."image_id",
     "rebrickable_parts"."url",
@@ -42,11 +38,45 @@ SELECT
     {% block total_minifigures %}
     NULL AS "total_minifigures" -- dummy for order: total_minifigures
     {% endblock %}
-FROM "bricktracker_parts"
+FROM (
+    -- Parts from set-based minifigures
+    SELECT
+        "bricktracker_parts"."id",
+        "bricktracker_parts"."figure",
+        "bricktracker_parts"."part",
+        "bricktracker_parts"."color",
+        "bricktracker_parts"."spare",
+        "bricktracker_parts"."quantity",
+        "bricktracker_parts"."element",
+        "bricktracker_parts"."missing",
+        "bricktracker_parts"."damaged",
+        "bricktracker_parts"."checked",
+        'set' AS "source_type"
+    FROM "bricktracker_parts"
+
+    UNION ALL
+
+    -- Parts from individual minifigures
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigure_parts"."part",
+        "bricktracker_individual_minifigure_parts"."color",
+        "bricktracker_individual_minifigure_parts"."spare",
+        "bricktracker_individual_minifigure_parts"."quantity",
+        "bricktracker_individual_minifigure_parts"."element",
+        "bricktracker_individual_minifigure_parts"."missing",
+        "bricktracker_individual_minifigure_parts"."damaged",
+        "bricktracker_individual_minifigure_parts"."checked",
+        'individual' AS "source_type"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+) AS "combined"
 
 INNER JOIN "rebrickable_parts"
-ON "bricktracker_parts"."part" IS NOT DISTINCT FROM "rebrickable_parts"."part"
-AND "bricktracker_parts"."color" IS NOT DISTINCT FROM "rebrickable_parts"."color_id"
+ON "combined"."part" IS NOT DISTINCT FROM "rebrickable_parts"."part"
+AND "combined"."color" IS NOT DISTINCT FROM "rebrickable_parts"."color_id"
 
 {% block join %}{% endblock %}
 

bricktracker/sql/part/list/all.sql

@@ -1,42 +1,57 @@
 {% extends 'part/base/base.sql' %}
 
 {% block total_missing %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("combined"."missing") AS "total_missing",
 {% endblock %}
 
 {% block total_damaged %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("combined"."damaged") AS "total_damaged",
 {% endblock %}
 
 {% block total_quantity %}
-SUM("bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)) AS "total_quantity",
+SUM("combined"."quantity" * IFNULL("minifigure_quantities"."quantity", 1)) AS "total_quantity",
 {% endblock %}
 
 {% block total_sets %}
-IFNULL(COUNT(DISTINCT "bricktracker_parts"."id"), 0) AS "total_sets",
+IFNULL(COUNT(DISTINCT "combined"."id"), 0) AS "total_sets",
 {% endblock %}
 
 {% block total_minifigures %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_minifigures"
+SUM(IFNULL("minifigure_quantities"."quantity", 0)) AS "total_minifigures"
 {% endblock %}
 
 {% block join %}
-LEFT JOIN "bricktracker_minifigures"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+-- Join to get minifigure quantities from both set-based and individual minifigures
+LEFT JOIN (
+    SELECT
+        "bricktracker_minifigures"."id",
+        "bricktracker_minifigures"."figure",
+        "bricktracker_minifigures"."quantity"
+    FROM "bricktracker_minifigures"
+
+    UNION ALL
+
+    SELECT
+        "bricktracker_individual_minifigures"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigures"."quantity"
+    FROM "bricktracker_individual_minifigures"
+) AS "minifigure_quantities"
+ON "combined"."id" IS NOT DISTINCT FROM "minifigure_quantities"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "minifigure_quantities"."figure"
 {% endblock %}
 
 {% block where %}
 {% set conditions = [] %}
 {% if color_id and color_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_parts"."color" = ' ~ color_id) %}
+  {% set _ = conditions.append('"combined"."color" = ' ~ color_id) %}
 {% endif %}
 {% if search_query %}
-  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("bricktracker_parts"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
+  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("combined"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
   {% set _ = conditions.append(search_condition) %}
 {% endif %}
 {% if skip_spare_parts %}
-  {% set _ = conditions.append('"bricktracker_parts"."spare" = 0') %}
+  {% set _ = conditions.append('"combined"."spare" = 0') %}
 {% endif %}
 {% if conditions %}
 WHERE {{ conditions | join(' AND ') }}
@@ -45,7 +60,7 @@ WHERE {{ conditions | join(' AND ') }}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare"
+    "combined"."part",
+    "combined"."color",
+    "combined"."spare"
 {% endblock %}

bricktracker/sql/part/list/all_by_owner.sql

@@ -2,73 +2,113 @@
 
 {% block total_missing %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."missing" ELSE 0 END) AS "total_missing",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."missing"
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."missing"
+    ELSE 0
+END) AS "total_missing",
 {% else %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("combined"."missing") AS "total_missing",
 {% endif %}
 {% endblock %}
 
 {% block total_damaged %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."damaged" ELSE 0 END) AS "total_damaged",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."damaged"
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."damaged"
+    ELSE 0
+END) AS "total_damaged",
 {% else %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("combined"."damaged") AS "total_damaged",
 {% endif %}
 {% endblock %}
 
 {% block total_quantity %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1) ELSE 0 END) AS "total_quantity",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."quantity"
+    ELSE 0
+END) AS "total_quantity",
 {% else %}
-SUM("bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)) AS "total_quantity",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' THEN "combined"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)
+    ELSE "combined"."quantity"
+END) AS "total_quantity",
 {% endif %}
 {% endblock %}
 
 {% block total_sets %}
 {% if owner_id and owner_id != 'all' %}
-COUNT(DISTINCT CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."id" ELSE NULL END) AS "total_sets",
+COUNT(DISTINCT CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."id"
+    ELSE NULL
+END) AS "total_sets",
 {% else %}
-COUNT(DISTINCT "bricktracker_parts"."id") AS "total_sets",
+COUNT(DISTINCT CASE WHEN "combined"."source_type" = 'set' THEN "combined"."id" ELSE NULL END) AS "total_sets",
 {% endif %}
 {% endblock %}
 
 {% block total_minifigures %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_minifigures"."quantity", 0) ELSE 0 END) AS "total_minifigures"
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_minifigures"."quantity", 0)
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN 1
+    ELSE 0
+END) AS "total_minifigures"
 {% else %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_minifigures"
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' THEN IFNULL("bricktracker_minifigures"."quantity", 0)
+    WHEN "combined"."source_type" = 'individual' THEN 1
+    ELSE 0
+END) AS "total_minifigures"
 {% endif %}
 {% endblock %}
 
 {% block join %}
--- Join with sets to get owner information
-INNER JOIN "bricktracker_sets"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_sets"."id"
+-- Left join with sets (for set-based parts)
+LEFT JOIN "bricktracker_sets"
+ON "combined"."source_type" = 'set'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_sets"."id"
 
 -- Left join with set owners (using dynamic columns)
 LEFT JOIN "bricktracker_set_owners"
-ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "bricktracker_set_owners"."id"
+ON "combined"."source_type" = 'set'
+AND "bricktracker_sets"."id" IS NOT DISTINCT FROM "bricktracker_set_owners"."id"
 
--- Left join with minifigures
+-- Left join with set-based minifigures
 LEFT JOIN "bricktracker_minifigures"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+ON "combined"."source_type" = 'set'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+
+-- Left join with individual minifigures (for individual parts)
+LEFT JOIN "bricktracker_individual_minifigures"
+ON "combined"."source_type" = 'individual'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigures"."id"
+
+-- Left join with individual minifigure owners (using dynamic columns)
+LEFT JOIN "bricktracker_individual_minifigure_owners"
+ON "combined"."source_type" = 'individual'
+AND "bricktracker_individual_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigure_owners"."id"
 {% endblock %}
 
 {% block where %}
 {% set conditions = [] %}
 {% if owner_id and owner_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_set_owners"."owner_' ~ owner_id ~ '" = 1') %}
+  {% set owner_condition = '(("combined"."source_type" = \'set\' AND "bricktracker_set_owners"."owner_' ~ owner_id ~ '" = 1) OR ("combined"."source_type" = \'individual\' AND "bricktracker_individual_minifigure_owners"."owner_' ~ owner_id ~ '" = 1))' %}
+  {% set _ = conditions.append(owner_condition) %}
 {% endif %}
 {% if color_id and color_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_parts"."color" = ' ~ color_id) %}
+  {% set _ = conditions.append('"combined"."color" = ' ~ color_id) %}
 {% endif %}
 {% if search_query %}
-  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("bricktracker_parts"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
+  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("combined"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
   {% set _ = conditions.append(search_condition) %}
 {% endif %}
 {% if skip_spare_parts %}
-  {% set _ = conditions.append('"bricktracker_parts"."spare" = 0') %}
+  {% set _ = conditions.append('"combined"."spare" = 0') %}
 {% endif %}
 {% if conditions %}
 WHERE {{ conditions | join(' AND ') }}
@@ -77,7 +117,7 @@ WHERE {{ conditions | join(' AND ') }}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare"
+    "combined"."part",
+    "combined"."color",
+    "combined"."spare"
 {% endblock %}

bricktracker/sql/part/list/from_minifigure.sql

@@ -1,21 +1,88 @@
+-- Query parts from both set-based and individual minifigures
+SELECT
+    "parts_combined"."id",
+    "parts_combined"."figure",
+    "parts_combined"."part",
+    "parts_combined"."color",
+    "parts_combined"."spare",
+    SUM("parts_combined"."quantity") AS "quantity",
+    "parts_combined"."element",
+    SUM("parts_combined"."missing") AS "total_missing",
+    SUM("parts_combined"."damaged") AS "total_damaged",
+    MAX("parts_combined"."checked") AS "checked",
+    "rebrickable_parts"."color_name",
+    "rebrickable_parts"."color_rgb",
+    "rebrickable_parts"."color_transparent",
+    "rebrickable_parts"."bricklink_color_id",
+    "rebrickable_parts"."bricklink_color_name",
+    "rebrickable_parts"."bricklink_part_num",
+    "rebrickable_parts"."name",
+    "rebrickable_parts"."image",
+    "rebrickable_parts"."image_id",
+    "rebrickable_parts"."url",
+    "rebrickable_parts"."print",
+    NULL AS "total_quantity",
+    NULL AS "total_spare",
+    NULL AS "total_sets",
+    NULL AS "total_minifigures"
+FROM (
+    -- Set-based minifigure parts
+    SELECT
+        "bricktracker_parts"."id",
+        "bricktracker_parts"."figure",
+        "bricktracker_parts"."part",
+        "bricktracker_parts"."color",
+        "bricktracker_parts"."spare",
+        "bricktracker_parts"."quantity",
+        "bricktracker_parts"."element",
+        "bricktracker_parts"."missing",
+        "bricktracker_parts"."damaged",
+        "bricktracker_parts"."checked"
+    FROM "bricktracker_parts"
+    WHERE "bricktracker_parts"."figure" IS NOT DISTINCT FROM :figure
 
-{% extends 'part/base/base.sql' %}
+    UNION ALL
 
-{% block total_missing %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
-{% endblock %}
+    -- Individual minifigure parts
+    SELECT
+        "bricktracker_individual_minifigure_parts"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigure_parts"."part",
+        "bricktracker_individual_minifigure_parts"."color",
+        "bricktracker_individual_minifigure_parts"."spare",
+        "bricktracker_individual_minifigure_parts"."quantity",
+        "bricktracker_individual_minifigure_parts"."element",
+        "bricktracker_individual_minifigure_parts"."missing",
+        "bricktracker_individual_minifigure_parts"."damaged",
+        "bricktracker_individual_minifigure_parts"."checked"
+    FROM "bricktracker_individual_minifigure_parts"
+    INNER JOIN "bricktracker_individual_minifigures"
+    ON "bricktracker_individual_minifigure_parts"."id" = "bricktracker_individual_minifigures"."id"
+    WHERE "bricktracker_individual_minifigures"."figure" IS NOT DISTINCT FROM :figure
+) AS "parts_combined"
 
-{% block total_damaged %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
-{% endblock %}
+INNER JOIN "rebrickable_parts"
+ON "parts_combined"."part" = "rebrickable_parts"."part"
+AND "parts_combined"."color" = "rebrickable_parts"."color_id"
 
-{% block where %}
-WHERE "bricktracker_parts"."figure" IS NOT DISTINCT FROM :figure
-{% endblock %}
-
-{% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare"
-{% endblock %}
+    "parts_combined"."part",
+    "parts_combined"."color",
+    "parts_combined"."spare",
+    "parts_combined"."element",
+    "rebrickable_parts"."color_name",
+    "rebrickable_parts"."color_rgb",
+    "rebrickable_parts"."color_transparent",
+    "rebrickable_parts"."bricklink_color_id",
+    "rebrickable_parts"."bricklink_color_name",
+    "rebrickable_parts"."bricklink_part_num",
+    "rebrickable_parts"."name",
+    "rebrickable_parts"."image",
+    "rebrickable_parts"."image_id",
+    "rebrickable_parts"."url",
+    "rebrickable_parts"."print"
+
+{% if order %}
+-- Replace combined/bricktracker_parts references with parts_combined for this query
+ORDER BY {{ order | replace('"combined"', '"parts_combined"') | replace('"bricktracker_parts"', '"parts_combined"') }}
+{% endif %}

bricktracker/sql/part/list/from_print.sql

@@ -7,12 +7,12 @@
 
 {% block where %}
 WHERE "rebrickable_parts"."print" IS NOT DISTINCT FROM :print
-AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
-AND "bricktracker_parts"."part" IS DISTINCT FROM :part
+AND "combined"."color" IS NOT DISTINCT FROM :color
+AND "combined"."part" IS DISTINCT FROM :part
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color"
+    "combined"."part",
+    "combined"."color"
 {% endblock %}

bricktracker/sql/part/list/problem.sql

@@ -2,82 +2,121 @@
 
 {% block total_missing %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."missing" ELSE 0 END) AS "total_missing",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."missing"
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."missing"
+    ELSE 0
+END) AS "total_missing",
 {% else %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("combined"."missing") AS "total_missing",
 {% endif %}
 {% endblock %}
 
 {% block total_damaged %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."damaged" ELSE 0 END) AS "total_damaged",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."damaged"
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."damaged"
+    ELSE 0
+END) AS "total_damaged",
 {% else %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("combined"."damaged") AS "total_damaged",
 {% endif %}
 {% endblock %}
 
 {% block total_quantity %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1) ELSE 0 END) AS "total_quantity",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."quantity" * IFNULL("bricktracker_individual_minifigures"."quantity", 1)
+    ELSE 0
+END) AS "total_quantity",
 {% else %}
-SUM("bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)) AS "total_quantity",
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' THEN "combined"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)
+    WHEN "combined"."source_type" = 'individual' THEN "combined"."quantity" * IFNULL("bricktracker_individual_minifigures"."quantity", 1)
+    ELSE "combined"."quantity"
+END) AS "total_quantity",
 {% endif %}
 {% endblock %}
 
 {% block total_sets %}
 {% if owner_id and owner_id != 'all' %}
-COUNT(DISTINCT CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "bricktracker_parts"."id" ELSE NULL END) AS "total_sets",
+COUNT(DISTINCT CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN "combined"."id"
+    ELSE NULL
+END) AS "total_sets",
 {% else %}
-COUNT(DISTINCT "bricktracker_parts"."id") AS "total_sets",
+COUNT(DISTINCT CASE WHEN "combined"."source_type" = 'set' THEN "combined"."id" ELSE NULL END) AS "total_sets",
 {% endif %}
 {% endblock %}
 
 {% block total_minifigures %}
 {% if owner_id and owner_id != 'all' %}
-SUM(CASE WHEN "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_minifigures"."quantity", 0) ELSE 0 END) AS "total_minifigures"
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' AND "bricktracker_set_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_minifigures"."quantity", 0)
+    WHEN "combined"."source_type" = 'individual' AND "bricktracker_individual_minifigure_owners"."owner_{{ owner_id }}" = 1 THEN IFNULL("bricktracker_individual_minifigures"."quantity", 0)
+    ELSE 0
+END) AS "total_minifigures"
 {% else %}
-SUM(IFNULL("bricktracker_minifigures"."quantity", 0)) AS "total_minifigures"
+SUM(CASE
+    WHEN "combined"."source_type" = 'set' THEN IFNULL("bricktracker_minifigures"."quantity", 0)
+    WHEN "combined"."source_type" = 'individual' THEN IFNULL("bricktracker_individual_minifigures"."quantity", 0)
+    ELSE 0
+END) AS "total_minifigures"
 {% endif %}
 {% endblock %}
 
 {% block join %}
--- Join with sets to get owner information
-INNER JOIN "bricktracker_sets"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_sets"."id"
+-- Left join with sets for set-based parts
+LEFT JOIN "bricktracker_sets"
+ON "combined"."source_type" = 'set'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_sets"."id"
 
 -- Left join with set owners (using dynamic columns)
 LEFT JOIN "bricktracker_set_owners"
 ON "bricktracker_sets"."id" IS NOT DISTINCT FROM "bricktracker_set_owners"."id"
 
--- Left join with minifigures
+-- Left join with set-based minifigures
 LEFT JOIN "bricktracker_minifigures"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+ON "combined"."source_type" = 'set'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+
+-- Left join with individual minifigures
+LEFT JOIN "bricktracker_individual_minifigures"
+ON "combined"."source_type" = 'individual'
+AND "combined"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigures"."id"
+
+-- Left join with individual minifigure owners
+LEFT JOIN "bricktracker_individual_minifigure_owners"
+ON "bricktracker_individual_minifigures"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigure_owners"."id"
 {% endblock %}
 
 {% block where %}
 {% set conditions = [] %}
 -- Always filter for problematic parts
-{% set _ = conditions.append('("bricktracker_parts"."missing" > 0 OR "bricktracker_parts"."damaged" > 0)') %}
+{% set _ = conditions.append('("combined"."missing" > 0 OR "combined"."damaged" > 0)') %}
 {% if owner_id and owner_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_set_owners"."owner_' ~ owner_id ~ '" = 1') %}
+  {% set owner_condition = '(("combined"."source_type" = \'set\' AND "bricktracker_set_owners"."owner_' ~ owner_id ~ '" = 1) OR ("combined"."source_type" = \'individual\' AND "bricktracker_individual_minifigure_owners"."owner_' ~ owner_id ~ '" = 1))' %}
+  {% set _ = conditions.append(owner_condition) %}
 {% endif %}
 {% if color_id and color_id != 'all' %}
-  {% set _ = conditions.append('"bricktracker_parts"."color" = ' ~ color_id) %}
+  {% set _ = conditions.append('"combined"."color" = ' ~ color_id) %}
 {% endif %}
 {% if search_query %}
-  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("bricktracker_parts"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
+  {% set search_condition = '(LOWER("rebrickable_parts"."name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("rebrickable_parts"."color_name") LIKE LOWER(\'%' ~ search_query ~ '%\') OR LOWER("combined"."part") LIKE LOWER(\'%' ~ search_query ~ '%\'))' %}
   {% set _ = conditions.append(search_condition) %}
 {% endif %}
 {% if skip_spare_parts %}
-  {% set _ = conditions.append('"bricktracker_parts"."spare" = 0') %}
+  {% set _ = conditions.append('"combined"."spare" = 0') %}
 {% endif %}
 WHERE {{ conditions | join(' AND ') }}
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare"
+    "combined"."part",
+    "combined"."color",
+    "combined"."spare"
 {% endblock %}

bricktracker/sql/part/list/specific.sql

@@ -2,14 +2,14 @@
 {% extends 'part/base/base.sql' %}
 
 {% block total_missing %}
-IFNULL("bricktracker_parts"."missing", 0) AS "total_missing",
+IFNULL("combined"."missing", 0) AS "total_missing",
 {% endblock %}
 
 {% block total_damaged %}
-IFNULL("bricktracker_parts"."damaged", 0) AS "total_damaged",
+IFNULL("combined"."damaged", 0) AS "total_damaged",
 {% endblock %}
 
 {% block where %}
-WHERE "bricktracker_parts"."id" IS NOT DISTINCT FROM :id
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM :figure
+WHERE "combined"."id" IS NOT DISTINCT FROM :id
+AND "combined"."figure" IS NOT DISTINCT FROM :figure
 {% endblock %}

bricktracker/sql/part/list/with_different_color.sql

@@ -6,12 +6,12 @@
 {% block total_damaged %}{% endblock %}
 
 {% block where %}
-WHERE "bricktracker_parts"."color" IS DISTINCT FROM :color
-AND "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
+WHERE "combined"."color" IS DISTINCT FROM :color
+AND "combined"."part" IS NOT DISTINCT FROM :part
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color"
+    "combined"."part",
+    "combined"."color"
 {% endblock %}

bricktracker/sql/part/select/generic.sql

@@ -1,34 +1,51 @@
 {% extends 'part/base/base.sql' %}
 
 {% block total_missing %}
-SUM("bricktracker_parts"."missing") AS "total_missing",
+SUM("combined"."missing") AS "total_missing",
 {% endblock %}
 
 {% block total_damaged %}
-SUM("bricktracker_parts"."damaged") AS "total_damaged",
+SUM("combined"."damaged") AS "total_damaged",
 {% endblock %}
 
 {% block total_quantity %}
-SUM((NOT "bricktracker_parts"."spare") * "bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)) AS "total_quantity",
+SUM((NOT "combined"."spare") * "combined"."quantity" * IFNULL("minifigure_quantities"."quantity", 1)) AS "total_quantity",
 {% endblock %}
 
 {% block total_spare %}
-SUM("bricktracker_parts"."spare" * "bricktracker_parts"."quantity" * IFNULL("bricktracker_minifigures"."quantity", 1)) AS "total_spare",
+SUM("combined"."spare" * "combined"."quantity" * IFNULL("minifigure_quantities"."quantity", 1)) AS "total_spare",
 {% endblock %}
 
 {% block join %}
-LEFT JOIN "bricktracker_minifigures"
-ON "bricktracker_parts"."id" IS NOT DISTINCT FROM "bricktracker_minifigures"."id"
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM "bricktracker_minifigures"."figure"
+-- Join to get minifigure quantities from both set-based and individual minifigures
+LEFT JOIN (
+    -- Set-based minifigure quantities
+    SELECT
+        "bricktracker_minifigures"."id",
+        "bricktracker_minifigures"."figure",
+        "bricktracker_minifigures"."quantity"
+    FROM "bricktracker_minifigures"
+
+    UNION ALL
+
+    -- Individual minifigure quantities
+    SELECT
+        "bricktracker_individual_minifigures"."id",
+        "bricktracker_individual_minifigures"."figure",
+        "bricktracker_individual_minifigures"."quantity"
+    FROM "bricktracker_individual_minifigures"
+) AS "minifigure_quantities"
+ON "combined"."id" IS NOT DISTINCT FROM "minifigure_quantities"."id"
+AND "combined"."figure" IS NOT DISTINCT FROM "minifigure_quantities"."figure"
 {% endblock %}
 
 {% block where %}
-WHERE "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
-AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
+WHERE "combined"."part" IS NOT DISTINCT FROM :part
+AND "combined"."color" IS NOT DISTINCT FROM :color
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color"
+    "combined"."part",
+    "combined"."color"
 {% endblock %}

bricktracker/sql/part/select/specific.sql

@@ -1,18 +1,18 @@
 {% extends 'part/base/base.sql' %}
 
 {% block where %}
-WHERE "bricktracker_parts"."id" IS NOT DISTINCT FROM :id
-AND "bricktracker_parts"."figure" IS NOT DISTINCT FROM :figure
-AND "bricktracker_parts"."part" IS NOT DISTINCT FROM :part
-AND "bricktracker_parts"."color" IS NOT DISTINCT FROM :color
-AND "bricktracker_parts"."spare" IS NOT DISTINCT FROM :spare
+WHERE "combined"."id" IS NOT DISTINCT FROM :id
+AND "combined"."figure" IS NOT DISTINCT FROM :figure
+AND "combined"."part" IS NOT DISTINCT FROM :part
+AND "combined"."color" IS NOT DISTINCT FROM :color
+AND "combined"."spare" IS NOT DISTINCT FROM :spare
 {% endblock %}
 
 {% block group %}
 GROUP BY
-    "bricktracker_parts"."id",
-    "bricktracker_parts"."figure",
-    "bricktracker_parts"."part",
-    "bricktracker_parts"."color",
-    "bricktracker_parts"."spare"
+    "combined"."id",
+    "combined"."figure",
+    "combined"."part",
+    "combined"."color",
+    "combined"."spare"
 {% endblock %}

bricktracker/sql/set/list/without_storage.sql

@@ -0,0 +1,5 @@
+{% extends 'set/base/full.sql' %}
+
+{% block where %}
+WHERE "bricktracker_sets"."storage" IS NULL
+{% endblock %}

bricktracker/sql/set/metadata/owner/insert.sql

@@ -7,6 +7,14 @@ ADD COLUMN "owner_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
 ALTER TABLE "bricktracker_wish_owners"
 ADD COLUMN "owner_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
 
+-- Also inject into individual minifigures
+ALTER TABLE "bricktracker_individual_minifigure_owners"
+ADD COLUMN "owner_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
+
+-- Also inject into individual parts
+ALTER TABLE "bricktracker_individual_part_owners"
+ADD COLUMN "owner_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
+
 INSERT INTO "bricktracker_metadata_owners" (
     "id",
     "name"

bricktracker/sql/set/metadata/storage/all.sql

@@ -1,12 +1,16 @@
 {% extends 'set/metadata/storage/base.sql' %}
 
 {% block total_sets %}
-IFNULL(COUNT("bricktracker_sets"."id"), 0) AS "total_sets"
+IFNULL(COUNT(DISTINCT "bricktracker_sets"."id"), 0) AS "total_sets",
+IFNULL(COUNT(DISTINCT "bricktracker_individual_minifigures"."id"), 0) AS "total_individual_minifigures"
 {% endblock %}
 
 {% block join %}
 LEFT JOIN "bricktracker_sets"
 ON "bricktracker_metadata_storages"."id" IS NOT DISTINCT FROM "bricktracker_sets"."storage"
+
+LEFT JOIN "bricktracker_individual_minifigures"
+ON "bricktracker_metadata_storages"."id" IS NOT DISTINCT FROM "bricktracker_individual_minifigures"."storage"
 {% endblock %}
 
 {% block group %}

bricktracker/sql/set/metadata/tag/insert.sql

@@ -3,6 +3,14 @@ BEGIN TRANSACTION;
 ALTER TABLE "bricktracker_set_tags"
 ADD COLUMN "tag_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
 
+-- Also inject into individual minifigures
+ALTER TABLE "bricktracker_individual_minifigure_tags"
+ADD COLUMN "tag_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
+
+-- Also inject into individual parts
+ALTER TABLE "bricktracker_individual_part_tags"
+ADD COLUMN "tag_{{ id }}" BOOLEAN NOT NULL DEFAULT 0;
+
 INSERT INTO "bricktracker_metadata_tags" (
     "id",
     "name"

bricktracker/version.py

@@ -1,4 +1,4 @@
 from typing import Final
 
 __version__: Final[str] = '1.3.0'
-__database_version__: Final[int] = 19
+__database_version__: Final[int] = 21

bricktracker/views/index.py

@@ -2,7 +2,6 @@ from flask import Blueprint, render_template
 
 from .exceptions import exception_handler
 from ..minifigure_list import BrickMinifigureList
-from ..set_status_list import BrickSetStatusList
 from ..set_list import BrickSetList, set_metadata_lists
 
 index_page = Blueprint('index', __name__)
@@ -15,7 +14,6 @@ def index() -> str:
     return render_template(
         'index.html',
         brickset_collection=BrickSetList().last(),
-        brickset_statuses=BrickSetStatusList.list(),
         minifigure_collection=BrickMinifigureList().last(),
         **set_metadata_lists(as_class=True)
     )

bricktracker/views/individual_minifigure.py

@@ -0,0 +1,281 @@
+import logging
+
+from flask import Blueprint, jsonify, redirect, render_template, request, url_for, Response
+from flask_login import login_required
+
+from .exceptions import exception_handler
+from ..individual_minifigure import IndividualMinifigure
+from ..part import BrickPart
+from ..set_list import set_metadata_lists
+from ..set_owner_list import BrickSetOwnerList
+from ..set_tag_list import BrickSetTagList
+from ..set_storage_list import BrickSetStorageList
+from ..set_purchase_location_list import BrickSetPurchaseLocationList
+from ..sql import BrickSQL
+
+logger = logging.getLogger(__name__)
+
+individual_minifigure_page = Blueprint('individual_minifigure', __name__, url_prefix='/individual-minifigures')
+
+
+# Individual minifigure instance details/edit
+@individual_minifigure_page.route('/<id>')
+@exception_handler(__file__)
+def details(*, id: str) -> str:
+    item = IndividualMinifigure().select_by_id(id)
+
+    return render_template(
+        'individual_minifigure/details.html',
+        item=item,
+        **set_metadata_lists(as_class=True)
+    )
+
+
+# Update individual minifigure instance
+@individual_minifigure_page.route('/<id>/update', methods=['POST'])
+@exception_handler(__file__)
+def update(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+
+    # Update basic fields
+    item.fields.quantity = int(request.form.get('quantity', 1))
+    item.fields.description = request.form.get('description', '')
+    item.fields.storage = request.form.get('storage') or None
+    item.fields.purchase_location = request.form.get('purchase_location') or None
+
+    # Update the individual minifigure
+    from ..sql import BrickSQL
+    BrickSQL().execute(
+        'individual_minifigure/update',
+        parameters={
+            'id': item.fields.id,
+            'quantity': item.fields.quantity,
+            'description': item.fields.description,
+            'storage': item.fields.storage,
+            'purchase_location': item.fields.purchase_location,
+        },
+        commit=False,
+    )
+
+    # Update owners
+    owners = request.form.getlist('owners')
+    for owner in BrickSetOwnerList.list():
+        owner.update_individual_minifigure_state(item, state=(owner.fields.id in owners))
+
+    # Update tags
+    tags = request.form.getlist('tags')
+    for tag in BrickSetTagList.list():
+        tag.update_individual_minifigure_state(item, state=(tag.fields.id in tags))
+
+    BrickSQL().commit()
+
+    return redirect(url_for('individual_minifigure.details', id=id))
+
+
+# Update quantity
+@individual_minifigure_page.route('/<id>/update/quantity', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_quantity(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    item.fields.quantity = int(request.json.get('value', 1))
+
+    BrickSQL().execute_and_commit(
+        'individual_minifigure/update',
+        parameters={
+            'id': item.fields.id,
+            'quantity': item.fields.quantity,
+            'description': item.fields.description,
+            'storage': item.fields.storage,
+            'purchase_location': item.fields.purchase_location,
+        }
+    )
+
+    return jsonify({'success': True})
+
+
+# Update description
+@individual_minifigure_page.route('/<id>/update/description', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_description(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    item.fields.description = request.json.get('value', '')
+
+    BrickSQL().execute_and_commit(
+        'individual_minifigure/update',
+        parameters={
+            'id': item.fields.id,
+            'quantity': item.fields.quantity,
+            'description': item.fields.description,
+            'storage': item.fields.storage,
+            'purchase_location': item.fields.purchase_location,
+        }
+    )
+
+    return jsonify({'success': True})
+
+
+# Update owner
+@individual_minifigure_page.route('/<id>/update/owner/<metadata_id>', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_owner(*, id: str, metadata_id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    owner = BrickSetOwnerList.get(metadata_id)
+    owner.update_individual_minifigure_state(item, json=request.json)
+
+    return jsonify({'success': True})
+
+
+# Update tag
+@individual_minifigure_page.route('/<id>/update/tag/<metadata_id>', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_tag(*, id: str, metadata_id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    tag = BrickSetTagList.get(metadata_id)
+    tag.update_individual_minifigure_state(item, json=request.json)
+
+    return jsonify({'success': True})
+
+
+# Update status
+@individual_minifigure_page.route('/<id>/update/status/<metadata_id>', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_status(*, id: str, metadata_id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    from ..set_status_list import BrickSetStatusList
+    status = BrickSetStatusList.get(metadata_id)
+    status.update_individual_minifigure_state(item, json=request.json)
+
+    return jsonify({'success': True})
+
+
+# Update storage
+@individual_minifigure_page.route('/<id>/update/storage', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_storage(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    storage_id = request.json.get('value')
+
+    BrickSQL().execute_and_commit(
+        'individual_minifigure/update',
+        parameters={
+            'id': item.fields.id,
+            'quantity': item.fields.quantity,
+            'description': item.fields.description,
+            'storage': storage_id if storage_id else None,
+            'purchase_location': item.fields.purchase_location,
+        }
+    )
+
+    return jsonify({'success': True})
+
+
+# Update purchase location
+@individual_minifigure_page.route('/<id>/update/purchase_location', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def update_purchase_location(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    location_id = request.json.get('value')
+
+    BrickSQL().execute_and_commit(
+        'individual_minifigure/update',
+        parameters={
+            'id': item.fields.id,
+            'quantity': item.fields.quantity,
+            'description': item.fields.description,
+            'storage': item.fields.storage,
+            'purchase_location': location_id if location_id else None,
+        }
+    )
+
+    return jsonify({'success': True})
+
+
+# Update problematic pieces of an individual minifigure
+@individual_minifigure_page.route('/<id>/parts/<part>/<int:color>/<int:spare>/<problem>', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def problem_part(
+    *,
+    id: str,
+    part: str,
+    color: int,
+    spare: int,
+    problem: str,
+) -> Response:
+    minifigure = IndividualMinifigure().select_by_id(id)
+
+    brickpart = BrickPart().select_specific_individual_minifigure(
+        minifigure,
+        part,
+        color,
+        spare,
+    )
+
+    amount = brickpart.update_problem_individual_minifigure(problem, request.json)
+
+    # Info
+    logger.info('Individual minifigure {figure} ({id}): updated part ({part} color: {color}, spare: {spare}) {problem} count to {amount}'.format(
+        figure=minifigure.fields.figure,
+        id=minifigure.fields.id,
+        part=brickpart.fields.part,
+        color=brickpart.fields.color,
+        spare=brickpart.fields.spare,
+        problem=problem,
+        amount=amount
+    ))
+
+    return jsonify({problem: amount})
+
+
+# Update checked state of parts
+@individual_minifigure_page.route('/<id>/parts/<part>/<int:color>/<int:spare>/checked', methods=['POST'])
+@login_required
+@exception_handler(__file__, json=True)
+def checked_part(
+    *,
+    id: str,
+    part: str,
+    color: int,
+    spare: int,
+) -> Response:
+    minifigure = IndividualMinifigure().select_by_id(id)
+
+    brickpart = BrickPart().select_specific_individual_minifigure(
+        minifigure,
+        part,
+        color,
+        spare,
+    )
+
+    checked = brickpart.update_checked_individual_minifigure(request.json)
+
+    # Info
+    logger.info('Individual minifigure {figure} ({id}): updated part ({part} color: {color}, spare: {spare}) checked state to {checked}'.format(
+        figure=minifigure.fields.figure,
+        id=minifigure.fields.id,
+        part=brickpart.fields.part,
+        color=brickpart.fields.color,
+        spare=brickpart.fields.spare,
+        checked=checked
+    ))
+
+    return jsonify({'checked': checked})
+
+
+# Delete individual minifigure instance
+@individual_minifigure_page.route('/<id>/delete', methods=['POST'])
+@login_required
+@exception_handler(__file__)
+def delete(*, id: str):
+    item = IndividualMinifigure().select_by_id(id)
+    figure = item.fields.figure
+    item.delete()
+
+    return redirect(url_for('minifigure.details', figure=figure))

bricktracker/views/minifigure.py

@@ -3,6 +3,7 @@ from flask import Blueprint, current_app, render_template, request
 from .exceptions import exception_handler
 from ..minifigure import BrickMinifigure
 from ..minifigure_list import BrickMinifigureList
+from ..individual_minifigure_list import IndividualMinifigureList
 from ..pagination_helper import get_pagination_config, build_pagination_context, get_request_params
 from ..set_list import BrickSetList, set_metadata_lists
 from ..set_owner_list import BrickSetOwnerList
@@ -72,5 +73,6 @@ def details(*, figure: str) -> str:
         using=BrickSetList().using_minifigure(figure),
         missing=BrickSetList().missing_minifigure(figure),
         damaged=BrickSetList().damaged_minifigure(figure),
+        individual_instances=IndividualMinifigureList().instances_by_figure(figure),
         **set_metadata_lists(as_class=True)
     )

bricktracker/views/set.py

@@ -285,7 +285,6 @@ def details(*, id: str) -> str:
             item=item,
             all_instances=same_set_instances,
             open_instructions=request.args.get('open_instructions'),
-            brickset_statuses=BrickSetStatusList.list(all=True),
             **set_metadata_lists(as_class=True)
         )
     else:
@@ -294,7 +293,6 @@ def details(*, id: str) -> str:
             'set.html',
             item=item,
             open_instructions=request.args.get('open_instructions'),
-            brickset_statuses=BrickSetStatusList.list(all=True),
             **set_metadata_lists(as_class=True)
         )
 

bricktracker/views/storage.py

@@ -1,9 +1,11 @@
 from flask import Blueprint, render_template
 
 from .exceptions import exception_handler
+from ..individual_minifigure_list import IndividualMinifigureList
 from ..set_list import BrickSetList, set_metadata_lists
 from ..set_storage import BrickSetStorage
 from ..set_storage_list import BrickSetStorageList
+from ..sql import BrickSQL
 
 storage_page = Blueprint('storage', __name__, url_prefix='/storages')
 
@@ -12,9 +14,48 @@ storage_page = Blueprint('storage', __name__, url_prefix='/storages')
 @storage_page.route('/', methods=['GET'])
 @exception_handler(__file__)
 def list() -> str:
+    # Get counts of items with no storage
+    sql = BrickSQL()
+
+    # Count sets with no storage
+    sets_no_storage_query = 'SELECT COUNT(*) FROM "bricktracker_sets" WHERE "storage" IS NULL'
+    sql.cursor.execute(sets_no_storage_query)
+    sets_no_storage = sql.cursor.fetchone()[0]
+
+    # Count individual minifigures with no storage
+    minifigs_no_storage_query = 'SELECT COUNT(*) FROM "bricktracker_individual_minifigures" WHERE "storage" IS NULL'
+    sql.cursor.execute(minifigs_no_storage_query)
+    minifigs_no_storage = sql.cursor.fetchone()[0]
+
     return render_template(
         'storages.html',
         table_collection=BrickSetStorageList.all(),
+        sets_no_storage=sets_no_storage,
+        minifigs_no_storage=minifigs_no_storage,
+    )
+
+
+# Storage details - no storage
+@storage_page.route('/no_storage/details')
+@exception_handler(__file__)
+def no_storage_details() -> str:
+    # Create a mock storage object for "no storage"
+    from ..record import BrickRecord
+
+    no_storage = BrickRecord()
+    no_storage.fields.id = None
+    no_storage.fields.name = 'Not in a storage location'
+
+    # Get sets and individual minifigures with no storage
+    sets = BrickSetList().without_storage()
+    individual_minifigures = IndividualMinifigureList().without_storage()
+
+    return render_template(
+        'storage.html',
+        item=no_storage,
+        sets=sets,
+        individual_minifigures=individual_minifigures,
+        **set_metadata_lists(as_class=True)
     )
 
 
@@ -28,5 +69,6 @@ def details(*, id: str) -> str:
         'storage.html',
         item=storage,
         sets=BrickSetList().using_storage(storage),
+        individual_minifigures=IndividualMinifigureList().using_storage(storage),
         **set_metadata_lists(as_class=True)
     )

compose.local.yaml

@@ -20,3 +20,4 @@ services:
       BK_RETIRED_SETS_PATH: /local/retired_sets.csv
       BK_SETS_FOLDER: sets
       BK_THEMES_PATH: /local/themes.csv
+    env_file: .env

run-local.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -a
+source .env
+set +a
+
+gunicorn --bind "0.0.0.0:3334" "wsgi:application" --worker-class "gevent" --workers 1 --reload "$@"

static/scripts/add.js

@@ -0,0 +1,80 @@
+// Add page - handles both sets and individual minifigures
+document.addEventListener("DOMContentLoaded", () => {
+  // Get template data from data attributes
+  const addContainer = document.getElementById('add-set');
+  if (!addContainer) return;
+
+  // Read data from data attributes
+  const templateData = {
+    path: addContainer.dataset.path,
+    namespace: addContainer.dataset.namespace,
+    messages: {
+      COMPLETE: addContainer.dataset.msgComplete,
+      FAIL: addContainer.dataset.msgFail,
+      IMPORT_SET: addContainer.dataset.msgImportSet,
+      LOAD_SET: addContainer.dataset.msgLoadSet,
+      PROGRESS: addContainer.dataset.msgProgress,
+      SET_LOADED: addContainer.dataset.msgSetLoaded,
+      IMPORT_MINIFIGURE: addContainer.dataset.msgImportMinifigure,
+      LOAD_MINIFIGURE: addContainer.dataset.msgLoadMinifigure,
+      MINIFIGURE_LOADED: addContainer.dataset.msgMinifigureLoaded,
+    }
+  };
+
+  // Default: create set socket
+  const setSocket = new BrickSetSocket(
+    'add',
+    templateData.path,
+    templateData.namespace,
+    {
+      COMPLETE: templateData.messages.COMPLETE,
+      FAIL: templateData.messages.FAIL,
+      IMPORT_SET: templateData.messages.IMPORT_SET,
+      LOAD_SET: templateData.messages.LOAD_SET,
+      PROGRESS: templateData.messages.PROGRESS,
+      SET_LOADED: templateData.messages.SET_LOADED,
+    },
+    false,
+    false
+  );
+
+  // Override the execute method to check for minifigures
+  const originalExecute = setSocket.execute.bind(setSocket);
+  let minifigSocket = null;
+
+  setSocket.execute = function() {
+    const inputValue = document.getElementById('add-set').value.trim();
+
+    if (inputValue.startsWith('fig-') || inputValue.match(/^fig\d/i)) {
+      // It's a minifigure - create minifig socket if needed and execute when ready
+      if (!minifigSocket) {
+        minifigSocket = new BrickMinifigureSocket(
+          'add',
+          templateData.path,
+          templateData.namespace,
+          {
+            COMPLETE: templateData.messages.COMPLETE,
+            FAIL: templateData.messages.FAIL,
+            IMPORT_MINIFIGURE: templateData.messages.IMPORT_MINIFIGURE,
+            LOAD_MINIFIGURE: templateData.messages.LOAD_MINIFIGURE,
+            MINIFIGURE_LOADED: templateData.messages.MINIFIGURE_LOADED,
+            PROGRESS: templateData.messages.PROGRESS,
+          }
+        );
+
+        // Wait for socket to connect before executing
+        const checkConnection = setInterval(() => {
+          if (minifigSocket.socket && minifigSocket.socket.connected) {
+            clearInterval(checkConnection);
+            minifigSocket.execute();
+          }
+        }, 100);
+      } else {
+        minifigSocket.execute();
+      }
+    } else {
+      // It's a set - use original execute
+      originalExecute();
+    }
+  };
+});

static/scripts/changer.js

@@ -25,6 +25,7 @@ class BrickChanger {
                 switch (this.html_type) {
                     case "checkbox":
                     case "text":
+                    case "number":
                         listener = "change";
                     break;
 
@@ -33,6 +34,11 @@ class BrickChanger {
                 }
             break;
 
+            case "TEXTAREA":
+                this.html_type = "textarea";
+                listener = "change";
+            break;
+
             case "SELECT":
                 this.html_type = "select";
                 listener = "change";
@@ -130,6 +136,8 @@ class BrickChanger {
                 break;
 
                 case "text":
+                case "number":
+                case "textarea":
                 case "select":
                     value = this.html_element.value;
                 break;
@@ -185,10 +193,16 @@ class BrickChanger {
 
 // Helper to setup the changer
 const setup_changers = () => document.querySelectorAll("*[data-changer-id]").forEach(
-    el => new BrickChanger(
-        el.dataset.changerPrefix,
-        el.dataset.changerId,
-        el.dataset.changerUrl,
-        el.dataset.changerParent
-    )
+    el => {
+        try {
+            new BrickChanger(
+                el.dataset.changerPrefix,
+                el.dataset.changerId,
+                el.dataset.changerUrl,
+                el.dataset.changerParent
+            );
+        } catch (error) {
+            console.error('Error setting up changer for element:', el, 'Error:', error);
+        }
+    }
 );

static/scripts/socket/minifigure.js

@@ -0,0 +1,258 @@
+// Minifigure Socket class
+class BrickMinifigureSocket extends BrickSocket {
+    constructor(id, path, namespace, messages) {
+        super(id, path, namespace, messages, false);
+
+        // Listeners
+        this.add_listener = undefined;
+        this.input_listener = undefined;
+        this.confirm_listener = undefined;
+
+        // Form elements (built based on the initial id)
+        this.html_button = document.getElementById(id);
+        this.html_input = document.getElementById(`${id}-set`);
+        this.html_no_confim = document.getElementById(`${id}-no-confirm`);
+        this.html_owners = document.getElementById(`${id}-owners`);
+        this.html_purchase_location = document.getElementById(`${id}-purchase-location`);
+        this.html_storage = document.getElementById(`${id}-storage`);
+        this.html_tags = document.getElementById(`${id}-tags`);
+
+        // Card elements
+        this.html_card = document.getElementById(`${id}-card`);
+        this.html_card_set = document.getElementById(`${id}-card-set`);
+        this.html_card_name = document.getElementById(`${id}-card-name`);
+        this.html_card_image_container = document.getElementById(`${id}-card-image-container`);
+        this.html_card_image = document.getElementById(`${id}-card-image`);
+        this.html_card_footer = document.getElementById(`${id}-card-footer`);
+        this.html_card_confirm = document.getElementById(`${id}-card-confirm`);
+        this.html_card_dismiss = document.getElementById(`${id}-card-dismiss`);
+
+        if (this.html_button) {
+            this.add_listener = this.html_button.addEventListener("click", ((bricksocket) => (e) => {
+                bricksocket.execute();
+            })(this));
+
+            this.input_listener = this.html_input.addEventListener("keyup", ((bricksocket) => (e) => {
+                if (e.key === 'Enter') {
+                    bricksocket.execute();
+                }
+            })(this))
+        }
+
+        if (this.html_card_dismiss && this.html_card) {
+            this.html_card_dismiss.addEventListener("click", ((card) => (e) => {
+                card.classList.add("d-none");
+            })(this.html_card));
+        }
+
+        // Setup the socket
+        this.setup();
+    }
+
+    // Clear form
+    clear() {
+        super.clear();
+
+        if (this.html_card) {
+            this.html_card.classList.add("d-none");
+        }
+
+        if (this.html_card_footer) {
+            this.html_card_footer.classList.add("d-none");
+
+            if (this.html_card_confirm) {
+                this.html_card_footer.classList.add("d-none");
+            }
+        }
+    }
+
+    // Execute the action
+    execute() {
+        if (!this.disabled && this.socket !== undefined && this.socket.connected) {
+            this.toggle(false);
+
+            if (this.html_no_confim && this.html_no_confim.checked) {
+                this.import_minifigure(true);
+            } else {
+                this.load_minifigure();
+            }
+        }
+    }
+
+    // Import a minifigure
+    import_minifigure(no_confirm, figure) {
+        if (this.html_input) {
+            if (no_confirm) {
+                this.clear();
+            } else {
+                this.clear_status();
+            }
+
+            // Grab the owners
+            const owners = [];
+            if (this.html_owners) {
+                this.html_owners.querySelectorAll('input').forEach(input => {
+                    if (input.checked) {
+                        owners.push(input.value);
+                    }
+                });
+            }
+
+            // Grab the purchase location
+            let purchase_location = null;
+            if (this.html_purchase_location) {
+                purchase_location = this.html_purchase_location.value;
+            }
+
+            // Grab the storage
+            let storage = null;
+            if (this.html_storage) {
+                storage = this.html_storage.value;
+            }
+
+            // Grab the tags
+            const tags = [];
+            if (this.html_tags) {
+                this.html_tags.querySelectorAll('input').forEach(input => {
+                    if (input.checked) {
+                        tags.push(input.value);
+                    }
+                });
+            }
+
+            this.spinner(true);
+
+            if (this.html_progress_bar) {
+                this.html_progress_bar.scrollIntoView();
+            }
+
+            this.socket.emit(this.messages.IMPORT_MINIFIGURE, {
+                figure: (figure !== undefined) ? figure : this.html_input.value,
+                owners: owners,
+                purchase_location: purchase_location,
+                storage: storage,
+                tags: tags,
+                quantity: 1
+            });
+        } else {
+            this.fail("Could not find the input field for the minifigure number");
+        }
+    }
+
+    // Load a minifigure
+    load_minifigure() {
+        if (this.html_input) {
+            // Reset the progress
+            this.clear()
+            this.spinner(true);
+
+            this.socket.emit(this.messages.LOAD_MINIFIGURE, {
+                figure: this.html_input.value
+            });
+        } else {
+            this.fail("Could not find the input field for the minifigure number");
+        }
+    }
+
+    // Minifigure is loaded
+    minifigure_loaded(data) {
+        if (this.html_card) {
+            this.html_card.classList.remove("d-none");
+
+            if (this.html_card_set) {
+                this.html_card_set.textContent = data["figure"];
+            }
+
+            if (this.html_card_name) {
+                this.html_card_name.textContent = data["name"];
+            }
+
+            if (this.html_card_image_container) {
+                this.html_card_image_container.setAttribute("style", `background-image: url(${data["image"]})`);
+            }
+
+            if (this.html_card_image) {
+                this.html_card_image.setAttribute("src", data["image"]);
+                this.html_card_image.setAttribute("alt", data["figure"]);
+            }
+
+            if (this.html_card_footer) {
+                this.html_card_footer.classList.add("d-none");
+
+                if (!data.download) {
+                    this.html_card_footer.classList.remove("d-none");
+
+                    if (this.html_card_confirm) {
+                        if (this.confirm_listener !== undefined) {
+                            this.html_card_confirm.removeEventListener("click", this.confirm_listener);
+                        }
+
+                        this.confirm_listener = ((bricksocket, figure) => (e) => {
+                            if (!bricksocket.disabled) {
+                                bricksocket.toggle(false);
+                                bricksocket.import_minifigure(false, figure);
+                            }
+                        })(this, data["figure"]);
+
+                        this.html_card_confirm.addEventListener("click", this.confirm_listener);
+
+                        this.html_card_confirm.scrollIntoView();
+                    }
+                }
+            }
+        }
+    }
+
+    // Setup the actual socket
+    setup() {
+        super.setup();
+
+        if (this.socket !== undefined) {
+            // Minifigure loaded
+            this.socket.on(this.messages.MINIFIGURE_LOADED, ((bricksocket) => (data) => {
+                bricksocket.minifigure_loaded(data);
+            })(this));
+        }
+    }
+
+    // Toggle clicking on the button, or sending events
+    toggle(enabled) {
+        super.toggle(enabled);
+
+        if (this.html_button) {
+            this.html_button.disabled = !enabled;
+        }
+
+        if (this.html_input) {
+            this.html_input.disabled = !enabled;
+        }
+
+        if (this.html_no_confim) {
+            this.html_no_confim.disabled = !enabled;
+        }
+
+        if (this.html_owners) {
+            this.html_owners.querySelectorAll('input').forEach(input => input.disabled = !enabled);
+        }
+
+        if (this.html_purchase_location) {
+            this.html_purchase_location.disabled = !enabled;
+        }
+
+        if (this.html_storage) {
+            this.html_storage.disabled = !enabled;
+        }
+
+        if (this.html_tags) {
+            this.html_tags.querySelectorAll('input').forEach(input => input.disabled = !enabled);
+        }
+
+        if (this.html_card_confirm) {
+            this.html_card_confirm.disabled = !enabled;
+        }
+
+        if (this.html_card_dismiss) {
+            this.html_card_dismiss.disabled = !enabled;
+        }
+    }
+}

static/scripts/socket/set.js

@@ -181,14 +181,31 @@ class BrickSetSocket extends BrickSocket {
                 this.html_progress_bar.scrollIntoView();
             }
 
-            this.socket.emit(this.messages.IMPORT_SET, {
-                set: (set !== undefined) ? set : this.html_input.value,
-                owners: owners,
-                purchase_location: purchase_location,
-                storage: storage,
-                tags: tags,
-                refresh: this.refresh
-            });
+            // Determine if this is a set or minifigure
+            const itemValue = (set !== undefined) ? set : this.html_input.value;
+            const isMinifigure = itemValue.trim().startsWith('fig-') || itemValue.trim().match(/^fig\d/i);
+
+            if (isMinifigure) {
+                // Emit minifigure import message
+                this.socket.emit(this.messages.IMPORT_MINIFIGURE, {
+                    figure: itemValue,
+                    owners: owners,
+                    purchase_location: purchase_location,
+                    storage: storage,
+                    tags: tags,
+                    quantity: 1
+                });
+            } else {
+                // Emit set import message
+                this.socket.emit(this.messages.IMPORT_SET, {
+                    set: itemValue,
+                    owners: owners,
+                    purchase_location: purchase_location,
+                    storage: storage,
+                    tags: tags,
+                    refresh: this.refresh
+                });
+            }
         } else {
             this.fail("Could not find the input field for the set number");
         }

static/styles.css

@@ -180,3 +180,19 @@
     pointer-events: none;
 }/* Duplicate filter support */
 .duplicate-filter-hidden { display: none !important; }
+
+/* Remove spinner arrows from number inputs */
+input[type="number"]::-webkit-inner-spin-button,
+input[type="number"]::-webkit-outer-spin-button {
+    -webkit-appearance: none;
+    margin: 0;
+}
+
+input[type="number"] {
+    -moz-appearance: textfield;
+}
+
+/* Remove resize handle from textareas */
+textarea {
+    resize: none;
+}

templates/add.html

@@ -26,8 +26,20 @@
             <div id="add-complete"></div>
           {% endif %}
           <div class="mb-3">
-            <label for="add-set" class="form-label">{% if not bulk %}Set number (only one){% else %}List of sets (separated by a comma){% endif %}</label>
-            <input type="text" class="form-control" id="add-set" placeholder="{% if not bulk %}107-1 or 1642-1 or ...{% else %}107-1, 1642-1, ...{% endif %}">
+            <label for="add-set" class="form-label">{% if not bulk %}{% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}Set or Minifigure number (only one){% else %}Set number (only one){% endif %}{% else %}List of sets (separated by a comma){% endif %}</label>
+            <input type="text" class="form-control" id="add-set" placeholder="{% if not bulk %}{% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}107-1 or fig-001234 or ...{% else %}107-1 or ...{% endif %}{% else %}107-1, 1642-1, ...{% endif %}"
+              data-path="{{ path }}"
+              data-namespace="{{ namespace }}"
+              data-msg-complete="{{ messages['COMPLETE'] }}"
+              data-msg-fail="{{ messages['FAIL'] }}"
+              data-msg-import-set="{{ messages['IMPORT_SET'] }}"
+              data-msg-load-set="{{ messages['LOAD_SET'] }}"
+              data-msg-progress="{{ messages['PROGRESS'] }}"
+              data-msg-set-loaded="{{ messages['SET_LOADED'] }}"
+              data-msg-import-minifigure="{{ messages['IMPORT_MINIFIGURE'] }}"
+              data-msg-load-minifigure="{{ messages['LOAD_MINIFIGURE'] }}"
+              data-msg-minifigure-loaded="{{ messages['MINIFIGURE_LOADED'] }}">
+            <div class="form-text">Sets: use format like 107-1{% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}. Minifigures: use format like fig-001234{% endif %}</div>
           </div>
           <div class="form-check">
             <input type="checkbox" class="form-check-input" id="add-no-confirm" {% if bulk %}checked disabled{% endif %}>
@@ -141,7 +153,9 @@
     </div>
   </div>
 </div>
+{% if bulk %}
 {% with id='add', bulk=bulk %}
   {% include 'set/socket.html' %}
 {% endwith %}
+{% endif %}
 {% endblock %}

templates/admin/configuration.html

@@ -472,6 +472,14 @@
           <h6 class="fw-bold text-primary border-bottom pb-1 mb-3 mt-4">Advanced Settings</h6>
 
           <div class="row g-3">
+            <div class="col-md-6">
+              <label for="BK_DESCRIPTION_BADGE_MAX_LENGTH" class="form-label">
+                BK_DESCRIPTION_BADGE_MAX_LENGTH {{ config_badges('BK_DESCRIPTION_BADGE_MAX_LENGTH') }}
+                <div class="text-muted small">Maximum length for description text in badges before truncating with ellipsis</div>
+              </label>
+              <input type="number" class="form-control config-number" id="BK_DESCRIPTION_BADGE_MAX_LENGTH" data-var="BK_DESCRIPTION_BADGE_MAX_LENGTH" min="5" max="200">
+            </div>
+
             <div class="col-md-6">
               <label for="BK_PEERON_DOWNLOAD_DELAY" class="form-label">
                 BK_PEERON_DOWNLOAD_DELAY {{ config_badges('BK_PEERON_DOWNLOAD_DELAY') }}
@@ -748,6 +756,15 @@
                 </label>
               </div>
             </div>
+            <div class="col-md-6">
+              <div class="form-check form-switch">
+                <input class="form-check-input config-static-toggle" type="checkbox" id="static-BK_DISABLE_INDIVIDUAL_MINIFIGURES" data-var="BK_DISABLE_INDIVIDUAL_MINIFIGURES">
+                <label class="form-check-label" for="static-BK_DISABLE_INDIVIDUAL_MINIFIGURES">
+                  BK_DISABLE_INDIVIDUAL_MINIFIGURES {{ config_badges('BK_DISABLE_INDIVIDUAL_MINIFIGURES') }}
+                  <div class="text-muted small">Completely disable individual/loose minifigures system</div>
+                </label>
+              </div>
+            </div>
             <div class="col-md-6">
               <label for="static-BK_DOMAIN_NAME" class="form-label">
                 BK_DOMAIN_NAME {{ config_badges('BK_DOMAIN_NAME') }}

templates/base.html

@@ -92,7 +92,11 @@
     <script src="{{ url_for('static', filename='scripts/socket/socket.js') }}"></script>
     <script src="{{ url_for('static', filename='scripts/socket/instructions.js') }}"></script>
     <script src="{{ url_for('static', filename='scripts/socket/set.js') }}"></script>
+    <script src="{{ url_for('static', filename='scripts/socket/minifigure.js') }}"></script>
     <script src="{{ url_for('static', filename='scripts/table.js') }}"></script>
+    {% if request.endpoint == 'add.add' %}
+    <script src="{{ url_for('static', filename='scripts/add.js') }}"></script>
+    {% endif %}
     {% if request.endpoint == 'minifigure.list' %}
     <script src="{{ url_for('static', filename='scripts/minifigures.js') }}"></script>
     {% endif %}

templates/individual_minifigure/card.html

@@ -0,0 +1,40 @@
+{% import 'macro/badge.html' as badge %}
+{% import 'macro/card.html' as card %}
+{% import 'macro/form.html' as form %}
+
+<div class="card mb-3 flex-fill">
+  {{ card.header(item, item.fields.name, solo=false, identifier=item.fields.figure, icon='user-line') }}
+  {{ card.image(item, solo=false, last=false, caption=item.fields.name, alt=item.fields.figure, medium=false) }}
+  <div class="card-body border-bottom p-1">
+    {{ badge.quantity(item.fields.quantity, solo=false, last=false) }}
+    {{ badge.parts(item.fields.number_of_parts, solo=false, last=false) }}
+    {{ badge.total_missing(item.fields.total_missing, solo=false, last=false) }}
+    {{ badge.total_damaged(item.fields.total_damaged, solo=false, last=false) }}
+    {% for owner in brickset_owners %}
+      {{ badge.owner(item, owner, solo=false, last=false) }}
+    {% endfor %}
+    {% for tag in brickset_tags %}
+      {{ badge.tag(item, tag, solo=false, last=false) }}
+    {% endfor %}
+    {% if item.fields.storage %}
+      {{ badge.storage(item, brickset_storages, solo=false, last=false) }}
+    {% endif %}
+    {% if item.fields.purchase_location %}
+      {{ badge.purchase_location(item, brickset_purchase_locations, solo=false, last=false) }}
+    {% endif %}
+    {% if item.fields.description %}
+      <span class="badge text-bg-light text-dark text-wrap" data-bs-toggle="tooltip" title="{{ item.fields.description }}">
+        <i class="ri-file-text-line"></i> {{ item.fields.description[:config['DESCRIPTION_BADGE_MAX_LENGTH']] }}{% if item.fields.description | length > config['DESCRIPTION_BADGE_MAX_LENGTH'] %}...{% endif %}
+      </span>
+    {% endif %}
+  </div>
+  {% if brickset_statuses | length %}
+    <ul class="list-group list-group-flush card-check border-bottom-0">
+      {% for status in brickset_statuses %}
+        <li class="d-flex list-group-item p-1 text-nowrap">
+          {{ form.checkbox(status.fields.name, item.fields.id, status.as_dataset(), status.url_for_individual_minifigure_state(item.fields.id), item.fields[status.as_column()]) }}
+        </li>
+      {% endfor %}
+    </ul>
+  {% endif %}
+</div>

templates/individual_minifigure/details.html

@@ -0,0 +1,69 @@
+{% extends 'base.html' %}
+{% import 'macro/accordion.html' as accordion %}
+{% import 'macro/form.html' as form %}
+
+{% block title %} - Individual Minifigure {{ item.fields.name }}{% endblock %}
+
+{% block main %}
+<div class="container">
+  <div class="row">
+    <div class="col-12">
+      <div class="card mb-3">
+        <div class="card-header d-flex justify-content-between align-items-center">
+          <h5 class="mb-0">
+            <i class="ri-user-line"></i> {{ item.fields.name }}
+            <span class="badge text-bg-secondary fw-normal"><i class="ri-hashtag"></i> {{ item.fields.figure }}</span>
+          </h5>
+          <div>
+            <a href="{{ url_for('minifigure.details', figure=item.fields.figure) }}" class="btn btn-sm btn-secondary">
+              <i class="ri-arrow-left-line"></i> Back to {{ item.fields.figure }}
+            </a>
+          </div>
+        </div>
+        <div class="card-img border-bottom" style="background-image: url({{ item.url_for_image() }})">
+          <a data-lightbox data-caption="{{ item.fields.name }}" href="{{ item.url_for_image() }}" target="_blank">
+            <img class="card-medium-img" src="{{ item.url_for_image() }}" alt="{{ item.fields.figure }}" loading="lazy">
+          </a>
+        </div>
+        <div class="accordion accordion-flush border-top" id="individual-minifigure-details-{{ item.fields.id }}">
+          {{ accordion.header('Quantity', 'accordion-quantity-' ~ item.fields.id, 'individual-minifigure-details-' ~ item.fields.id, icon='functions') }}
+            {{ form.input('Quantity', item.fields.id, 'quantity', item.url_for_quantity(), item.fields.quantity, icon='functions', type='number') }}
+          {{ accordion.footer() }}
+          {{ accordion.header('Description', 'accordion-description-' ~ item.fields.id, 'individual-minifigure-details-' ~ item.fields.id, icon='file-text-line') }}
+            {{ form.input('Description', item.fields.id, 'description', item.url_for_description(), item.fields.description or '', icon='file-text-line', textarea=true) }}
+          {{ accordion.footer() }}
+          {{ accordion.table(item.generic_parts(), 'Parts', 'accordion-parts-' ~ item.fields.id, 'individual-minifigure-details-' ~ item.fields.id, 'part/table.html', icon='shapes-line', alt=item.fields.figure) }}
+          {% include 'individual_minifigure/management.html' %}
+          {% if g.login.is_authenticated() %}
+            {{ accordion.header('Danger zone', 'accordion-danger-zone-' ~ item.fields.id, 'individual-minifigure-details-' ~ item.fields.id, danger=true, class='text-end') }}
+              <a href="{{ url_for('individual_minifigure.delete', id=item.fields.id) }}" class="btn btn-danger" role="button" data-bs-toggle="modal" data-bs-target="#deleteModal"><i class="ri-close-line"></i> Delete this individual minifigure instance</a>
+            {{ accordion.footer() }}
+          {% endif %}
+        </div>
+        <div class="card-footer"></div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- Delete Confirmation Modal -->
+<div class="modal fade" id="deleteModal" tabindex="-1" aria-labelledby="deleteModalLabel" aria-hidden="true">
+  <div class="modal-dialog">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h5 class="modal-title" id="deleteModalLabel">Confirm Delete</h5>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body">
+        Are you sure you want to delete this individual minifigure instance? This action cannot be undone.
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancel</button>
+        <form method="POST" action="{{ url_for('individual_minifigure.delete', id=item.fields.id) }}">
+          <button type="submit" class="btn btn-danger">Delete</button>
+        </form>
+      </div>
+    </div>
+  </div>
+</div>
+{% endblock %}

templates/individual_minifigure/management.html

@@ -0,0 +1,71 @@
+{% import 'macro/accordion.html' as accordion %}
+{% import 'macro/form.html' as form %}
+
+{% if g.login.is_authenticated() %}
+  {{ accordion.header('Management', 'accordion-management-' ~ item.fields.id, 'individual-minifigure-details-' ~ item.fields.id, icon='settings-4-line', class='p-0') }}
+    {{ accordion.header('Owners', 'accordion-owners-' ~ item.fields.id, 'accordion-management-' ~ item.fields.id, icon='group-line', class='p-0') }}
+      <ul class="list-group list-group-flush">
+      {% if brickset_owners | length %}
+        {% for owner in brickset_owners %}
+          <li class="d-flex list-group-item list-group-item-action text-nowrap">{{ form.checkbox(owner.fields.name, item.fields.id, owner.as_dataset(), owner.url_for_individual_minifigure_state(item.fields.id), item.fields[owner.as_column()]) }}</li>
+        {% endfor %}
+      {% else %}
+        <li class="list-group-item list-group-item-action text-center"><i class="ri-error-warning-line"></i> No owner found.</li>
+        {% endif %}
+      </ul>
+      <div class="list-group list-group-flush border-top">
+        <a class="list-group-item list-group-item-action" href="{{ url_for('admin.admin', open_owner=true) }}"><i class="ri-settings-4-line"></i> Manage the minifigure owners</a>
+      </div>
+    {{ accordion.footer() }}
+    {{ accordion.header('Storage', 'accordion-storage-' ~ item.fields.id, 'accordion-management-' ~ item.fields.id, icon='archive-2-line') }}
+      {% if brickset_storages | length %}
+      {{ form.select('Storage', item.fields.id, brickset_storages.as_prefix(), brickset_storages.url_for_individual_minifigure_value(item.fields.id), item.fields.storage, brickset_storages, icon='building-line') }}
+      {% else %}
+        <p class="text-center"><i class="ri-error-warning-line"></i> No storage found.</p>
+      {% endif %}
+      <hr>
+      <a href="{{ url_for('admin.admin', open_storage=true) }}" class="btn btn-primary" role="button"><i class="ri-settings-4-line"></i> Manage the storages</a>
+    {{ accordion.footer() }}
+    {{ accordion.header('Purchase', 'accordion-purchase-' ~ item.fields.id, 'accordion-management-' ~ item.fields.id, icon='wallet-3-line') }}
+      <div class="row row-cols-lg-auto g-1 justify-content-start align-items-center pb-2">
+        <div class="col-12 flex-grow-1">
+          {% if brickset_purchase_locations | length %}
+            {{ form.select('Location', item.fields.id, brickset_purchase_locations.as_prefix(), brickset_purchase_locations.url_for_individual_minifigure_value(item.fields.id), item.fields.purchase_location, brickset_purchase_locations, icon='building-line') }}
+          {% else %}
+            <i class="ri-error-warning-line"></i> No purchase location found.
+          {% endif %}
+        </div>
+      </div>
+      <hr>
+      <a href="{{ url_for('admin.admin', open_purchase_location=true) }}" class="btn btn-primary" role="button"><i class="ri-settings-4-line"></i> Manage the purchase locations</a>
+    {{ accordion.footer() }}
+    {{ accordion.header('Statuses', 'accordion-statuses-' ~ item.fields.id, 'accordion-management-' ~ item.fields.id, icon='checkbox-line', class='p-0') }}
+      <ul class="list-group list-group-flush">
+      {% if brickset_statuses | length %}
+        {% for status in brickset_statuses %}
+          <li class="d-flex list-group-item list-group-item-action text-nowrap">{{ form.checkbox(status.fields.name, item.fields.id, status.as_dataset(), status.url_for_individual_minifigure_state(item.fields.id), item.fields[status.as_column()]) }}</li>
+        {% endfor %}
+      {% else %}
+        <li class="list-group-item list-group-item-action text-center"><i class="ri-error-warning-line"></i> No status found.</li>
+        {% endif %}
+      </ul>
+      <div class="list-group list-group-flush border-top">
+        <a class="list-group-item list-group-item-action" href="{{ url_for('admin.admin', open_status=true) }}"><i class="ri-settings-4-line"></i> Manage the statuses</a>
+      </div>
+    {{ accordion.footer() }}
+    {{ accordion.header('Tags', 'accordion-tags-' ~ item.fields.id, 'accordion-management-' ~ item.fields.id, icon='price-tag-2-line', class='p-0') }}
+      <ul class="list-group list-group-flush">
+      {% if brickset_tags | length %}
+        {% for tag in brickset_tags %}
+          <li class="d-flex list-group-item list-group-item-action text-nowrap">{{ form.checkbox(tag.fields.name, item.fields.id, tag.as_dataset(), tag.url_for_individual_minifigure_state(item.fields.id), item.fields[tag.as_column()]) }}</li>
+        {% endfor %}
+      {% else %}
+        <li class="list-group-item list-group-item-action text-center"><i class="ri-error-warning-line"></i> No tag found.</li>
+        {% endif %}
+      </ul>
+      <div class="list-group list-group-flush border-top">
+        <a class="list-group-item list-group-item-action" href="{{ url_for('admin.admin', open_tag=true) }}"><i class="ri-settings-4-line"></i> Manage the tags</a>
+      </div>
+    {{ accordion.footer() }}
+  {{ accordion.footer() }}
+{% endif %}

templates/macro/badge.html

@@ -207,6 +207,10 @@
   {{ badge(check=sets, solo=solo, last=last, color='secondary', icon='hashtag', collapsible='Sets:', text=sets, alt='Sets') }}
 {% endmacro %}
 
+{% macro total_individual_minifigures(minifigures, solo=false, last=false) %}
+  {{ badge(check=minifigures, solo=solo, last=last, color='info', icon='user-line', collapsible='Individual Minifigures:', text=minifigures, alt='Individual Minifigures') }}
+{% endmacro %}
+
 {% macro total_spare(spare, solo=false, last=false) %}
   {{ badge(check=spare, solo=solo, last=last, color='warning', icon='loop-left-line', collapsible='Spare:', text=spare, alt='Spare') }}
 {% endmacro %}

templates/macro/form.html

@@ -16,14 +16,23 @@
   {% endif %}
 {% endmacro %}
 
-{% macro input(name, id, prefix, url, value, all=none, read_only=none, icon=none, suffix=none, date=false) %}
+{% macro input(name, id, prefix, url, value, all=none, read_only=none, icon=none, suffix=none, date=false, type=none, textarea=false) %}
   {% if all or read_only %}
     {{ value }}
   {% else %}
     <label class="visually-hidden" for="{{ prefix }}-{{ id }}">{{ name }}</label>
     <div class="input-group">
       {% if icon %}<span class="input-group-text px-1"><i class="ri-{{ icon }} me-1"></i><span class="ms-1 d-none d-md-inline"> {{ name }}</span></span>{% endif %}
-      <input class="form-control form-control-sm flex-shrink-1 px-1" type="text" id="{{ prefix }}-{{ id }}" value="{% if value %}{{ value }}{% endif %}"
+      {% if textarea %}
+      <textarea class="form-control form-control-sm flex-shrink-1 px-1" id="{{ prefix }}-{{ id }}"
+      {% if g.login.is_authenticated() %}
+        data-changer-id="{{ id }}" data-changer-prefix="{{ prefix }}" data-changer-url="{{ url }}"
+      {% else %}
+        disabled
+      {% endif %}
+        autocomplete="off" rows="3">{% if value %}{{ value }}{% endif %}</textarea>
+      {% else %}
+      <input class="form-control form-control-sm flex-shrink-1 px-1" type="{% if type %}{{ type }}{% else %}text{% endif %}" id="{{ prefix }}-{{ id }}" value="{% if value %}{{ value }}{% endif %}"
       {% if g.login.is_authenticated() %}
         data-changer-id="{{ id }}" data-changer-prefix="{{ prefix }}" data-changer-url="{{ url }}"
         {% if date %}data-changer-date="true"{% endif %}
@@ -31,6 +40,7 @@
         disabled
       {% endif %}
         autocomplete="off">
+      {% endif %}
       {% if suffix %}<span class="input-group-text d-none d-md-inline px-1">{{ suffix }}</span>{% endif %}
       {% if g.login.is_authenticated() %}
         <span id="status-{{ prefix }}-{{ id }}" class="input-group-text ri-save-line px-1"></span>

templates/macro/table.html

@@ -1,4 +1,4 @@
-{% macro header(image=true, color=false, parts=false, quantity=false, missing=true, missing_parts=false, damaged=true, damaged_parts=false, sets=false, minifigures=false, checked=false, hamburger_menu=false, accordion_id='') %}
+{% macro header(image=true, color=false, parts=false, quantity=false, missing=true, missing_parts=false, damaged=true, damaged_parts=false, sets=false, individual=false, minifigures=false, checked=false, hamburger_menu=false, accordion_id='') %}
   <thead>
     <tr>
       {% if image %}
@@ -23,6 +23,9 @@
       {% if sets %}
         <th data-table-number="true" scope="col"><i class="ri-hashtag fw-normal"></i> Sets</th>
       {% endif %}
+      {% if individual %}
+        <th data-table-number="true" scope="col"><i class="ri-package-line fw-normal"></i> Individual</th>
+      {% endif %}
       {% if minifigures %}
         <th data-table-number="true" scope="col"><i class="ri-group-line fw-normal"></i> Minifigures</th>
       {% endif %}

templates/minifigure/card.html

@@ -23,6 +23,11 @@
     <div class="accordion accordion-flush" id="minifigure-details">
       {{ accordion.table(item.generic_parts(), 'Parts', item.fields.figure, 'minifigure-details', 'part/table.html', icon='shapes-line', alt=item.fields.figure, read_only=read_only)}}
       {{ accordion.cards(using, 'Sets using this minifigure', 'using-inventory', 'minifigure-details', 'set/card.html', icon='hashtag') }}
+      {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+        {% if individual_instances is defined and individual_instances | length > 0 %}
+          {{ accordion.cards(individual_instances, 'Individual minifigure instances', 'individual-instances', 'minifigure-details', 'individual_minifigure/card.html', icon='package-line') }}
+        {% endif %}
+      {% endif %}
       {{ accordion.cards(missing, 'Sets missing parts for this minifigure', 'missing-inventory', 'minifigure-details', 'set/card.html', icon='question-line') }}
       {{ accordion.cards(damaged, 'Sets with damaged parts for this minifigure', 'damaged-inventory', 'minifigure-details', 'set/card.html', icon='error-warning-line') }}
     </div>

templates/minifigure/sort.html

@@ -18,6 +18,10 @@
       {% endif %}
       <button id="sort-sets" type="button" class="btn btn-outline-primary mb-2"
         data-sort-attribute="sets" data-sort-desc="true"><i class="ri-hashtag"></i><span class="d-none d-xl-inline"> Sets</span></button>
+      {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+      <button id="sort-individual" type="button" class="btn btn-outline-primary mb-2"
+        data-sort-attribute="individual" data-sort-desc="true"><i class="ri-package-line"></i><span class="d-none d-xl-inline"> Individual</span></button>
+      {% endif %}
       <button id="sort-clear" type="button" class="btn btn-outline-dark mb-2"
         data-sort-clear="true"><i class="ri-close-circle-line"></i><span class="d-none d-xl-inline"> Clear</span></button>
     </div>

templates/minifigure/table_body.html

@@ -17,6 +17,9 @@
     <td data-sort="{{ minifigure.fields.total_damaged }}">{{ minifigure.fields.total_damaged }}</td>
     {% endif %}
     <td data-sort="{{ minifigure.fields.total_sets }}">{{ minifigure.fields.total_sets }}</td>
+    {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+    <td data-sort="{{ minifigure.fields.total_individual }}">{{ minifigure.fields.total_individual }}</td>
+    {% endif %}
   </tr>
   {% endfor %}
 </tbody>

templates/minifigures.html

@@ -33,7 +33,7 @@
   <!-- PAGINATION MODE -->
   <div class="table-responsive-sm">
     <table data-table="false" class="table table-striped align-middle mb-0" id="minifigures">
-      {{ table.header(parts=true, quantity=true, missing=true, damaged=true, sets=true, minifigures=false) }}
+      {{ table.header(parts=true, quantity=true, missing=true, damaged=true, sets=true, individual=(not config['DISABLE_INDIVIDUAL_MINIFIGURES']), minifigures=false) }}
       {% include 'minifigure/table_body.html' %}
     </table>
   </div>
@@ -148,7 +148,7 @@
   <!-- ORIGINAL MODE - Single page with client-side search -->
   <div class="table-responsive-sm">
     <table data-table="true" class="table table-striped align-middle {% if not all %}sortable mb-0{% endif %}" id="minifigures">
-      {{ table.header(parts=true, quantity=true, missing=true, damaged=true, sets=true, minifigures=false) }}
+      {{ table.header(parts=true, quantity=true, missing=true, damaged=true, sets=true, individual=(not config['DISABLE_INDIVIDUAL_MINIFIGURES']), minifigures=false) }}
       <tbody>
         {% for minifigure in table_collection %}
         <tr>
@@ -166,6 +166,7 @@
           <td data-sort="{{ minifigure.fields.total_damaged }}">{{ minifigure.fields.total_damaged }}</td>
           {% endif %}
           <td data-sort="{{ minifigure.fields.total_sets }}">{{ minifigure.fields.total_sets }}</td>
+          <td data-sort="{{ minifigure.fields.total_individual }}">{{ minifigure.fields.total_individual }}</td>
         </tr>
         {% endfor %}
       </tbody>

templates/set/socket.html

@@ -8,6 +8,7 @@
         COMPLETE: '{{ messages['COMPLETE'] }}',
         FAIL: '{{ messages['FAIL'] }}',
         IMPORT_SET: '{{ messages['IMPORT_SET'] }}',
+        IMPORT_MINIFIGURE: '{{ messages['IMPORT_MINIFIGURE'] }}',
         LOAD_SET: '{{ messages['LOAD_SET'] }}',
         PROGRESS: '{{ messages['PROGRESS'] }}',
         SET_LOADED: '{{ messages['SET_LOADED'] }}',

templates/storage/card.html

@@ -5,11 +5,17 @@
 <div class="card mb-3 flex-fill {% if solo %}card-solo{% endif %}">
   {{ card.header(item, item.fields.name, solo=solo, icon='archive-2-line') }}
   <div class="card-body border-bottom-0 {% if not solo %}p-1{% endif %}">
-    {{ badge.total_sets(sets | length, solo=solo, last=last) }}
+    {{ badge.total_sets(sets | length, solo=solo, last=(config['DISABLE_INDIVIDUAL_MINIFIGURES'] or last)) }}
+    {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+      {{ badge.total_individual_minifigures(individual_minifigures | length, solo=solo, last=last) }}
+    {% endif %}
   </div>
   {% if solo %}
     <div class="accordion accordion-flush border-top" id="storage-details">
       {{ accordion.cards(sets, 'Sets', 'sets-stored', 'storage-details', 'set/card.html', expanded=true, icon='hashtag') }}
+      {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+        {{ accordion.cards(individual_minifigures, 'Individual Minifigures', 'individual-minifigures-stored', 'storage-details', 'individual_minifigure/card.html', icon='user-line') }}
+      {% endif %}
     </div>
     <div class="card-footer"></div>
   {% endif %}

templates/storage/table.html

@@ -3,14 +3,28 @@
 
 <div class="table-responsive-sm">
   <table data-table="true" class="table table-striped align-middle" id="storage">
-    {{ table.header(image=false, missing=false, damaged=false, sets=true) }}
+    {{ table.header(image=false, missing=false, damaged=false, sets=true, individual=(not config['DISABLE_INDIVIDUAL_MINIFIGURES'])) }}
     <tbody>
       {% for item in table_collection %}
       <tr>
         <td data-sort="{{ item.fields.name }}"><a class="text-reset" href="{{ item.url() }}">{{ item.fields.name }}</a></td>
         <td>{{ item.fields.total_sets }}</td>
+        {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+          <td>{{ item.fields.total_individual_minifigures }}</td>
+        {% endif %}
       </tr>
       {% endfor %}
+      {% if sets_no_storage is defined and minifigs_no_storage is defined %}
+      {% if sets_no_storage > 0 or minifigs_no_storage > 0 %}
+      <tr class="table-warning">
+        <td data-sort="zzz-not-in-storage"><a class="text-reset" href="{{ url_for('storage.no_storage_details') }}"><em>Not in a storage location</em></a></td>
+        <td>{{ sets_no_storage }}</td>
+        {% if not config['DISABLE_INDIVIDUAL_MINIFIGURES'] %}
+          <td>{{ minifigs_no_storage }}</td>
+        {% endif %}
+      </tr>
+      {% endif %}
+      {% endif %}
     </tbody>
   </table>
 </div>