[PUI] Dashboard refactor

src/backend/InvenTree/InvenTree/api_version.py

@@ -1,13 +1,16 @@
 """InvenTree API version information."""
 
 # InvenTree API version
-INVENTREE_API_VERSION = 272
+INVENTREE_API_VERSION = 273
 
 """Increment this API version number whenever there is a significant change to the API that any clients need to know about."""
 
 
 INVENTREE_API_TEXT = """
 
+v273 - 2024-10-25 : https://github.com/inventree/InvenTree/pull/8278
+    - Allow build order list to be filtered by "outstanding" (alias for "active")
+
 v272 - 2024-10-25 : https://github.com/inventree/InvenTree/pull/8343
     - Adjustments to BuildLine API serializers
 

src/backend/InvenTree/build/api.py

@@ -40,6 +40,9 @@ class Meta:
 
     active = rest_filters.BooleanFilter(label='Build is active', method='filter_active')
 
+    # 'outstanding' is an alias for 'active' here
+    outstanding = rest_filters.BooleanFilter(label='Build is outstanding', method='filter_active')
+
     def filter_active(self, queryset, name, value):
         """Filter the queryset to either include or exclude orders which are active."""
         if str2bool(value):

src/backend/InvenTree/build/test_api.py

@@ -451,6 +451,10 @@ def test_create_delete_output(self):
         # Now, let's delete each build output individually via the API
         outputs = bo.build_outputs.all()
 
+        # Assert that each output is currently in production
+        for output in outputs:
+            self.assertTrue(output.is_building)
+
         delete_url = reverse('api-build-output-delete', kwargs={'pk': 1})
 
         response = self.post(

src/backend/InvenTree/common/models.py

@@ -895,7 +895,9 @@ def run_validator(self, validator):
             except ValidationError as e:
                 raise e
             except Exception:
-                raise ValidationError({'value': _('Invalid value')})
+                raise ValidationError({
+                    'value': _('Value does not pass validation checks')
+                })
 
     def validate_unique(self, exclude=None):
         """Ensure that the key:value pair is unique. In addition to the base validators, this ensures that the 'key' is unique, using a case-insensitive comparison.

src/backend/InvenTree/plugin/base/integration/SettingsMixin.py

@@ -105,3 +105,32 @@ def check_settings(self):
         return PluginSetting.check_all_settings(
             settings_definition=self.settings, plugin=self.plugin_config()
         )
+
+    def get_settings_dict(self) -> dict:
+        """Return a dictionary of all settings for this plugin.
+
+        - For each setting, return <key>: <value> pair.
+        - If the setting is not defined, return the default value (if defined).
+
+        Returns:
+            dict: Dictionary of all settings for this plugin
+        """
+        from plugin.models import PluginSetting
+
+        keys = self.settings.keys()
+
+        settings = PluginSetting.objects.filter(
+            plugin=self.plugin_config(), key__in=keys
+        )
+
+        settings_dict = {}
+
+        for setting in settings:
+            settings_dict[setting.key] = setting.value
+
+        # Add any missing settings
+        for key in keys:
+            if key not in settings_dict:
+                settings_dict[key] = self.settings[key].get('default')
+
+        return settings_dict

src/backend/InvenTree/plugin/base/ui/api.py

@@ -13,47 +13,6 @@
 from plugin import registry
 
 
-class PluginPanelList(APIView):
-    """API endpoint for listing all available plugin panels."""
-
-    permission_classes = [IsAuthenticated]
-    serializer_class = UIPluginSerializers.PluginPanelSerializer
-
-    @extend_schema(
-        responses={200: UIPluginSerializers.PluginPanelSerializer(many=True)}
-    )
-    def get(self, request):
-        """Show available plugin panels."""
-        target_model = request.query_params.get('target_model', None)
-        target_id = request.query_params.get('target_id', None)
-
-        panels = []
-
-        if get_global_setting('ENABLE_PLUGINS_INTERFACE'):
-            # Extract all plugins from the registry which provide custom panels
-            for _plugin in registry.with_mixin('ui', active=True):
-                try:
-                    # Allow plugins to fill this data out
-                    plugin_panels = _plugin.get_ui_panels(
-                        target_model, target_id, request
-                    )
-
-                    if plugin_panels and type(plugin_panels) is list:
-                        for panel in plugin_panels:
-                            panel['plugin'] = _plugin.slug
-
-                            # TODO: Validate each panel before inserting
-                            panels.append(panel)
-                except Exception:
-                    # Custom panels could not load
-                    # Log the error and continue
-                    log_error(f'{_plugin.slug}.get_ui_panels')
-
-        return Response(
-            UIPluginSerializers.PluginPanelSerializer(panels, many=True).data
-        )
-
-
 class PluginUIFeatureList(APIView):
     """API endpoint for listing all available plugin ui features."""
 
@@ -71,24 +30,49 @@ def get(self, request, feature):
             # Extract all plugins from the registry which provide custom ui features
             for _plugin in registry.with_mixin('ui', active=True):
                 # Allow plugins to fill this data out
-                plugin_features = _plugin.get_ui_features(
-                    feature, request.query_params, request
-                )
+
+                try:
+                    plugin_features = _plugin.get_ui_features(
+                        feature, request.query_params, request
+                    )
+                except Exception:
+                    # Custom features could not load for this plugin
+                    # Log the error and continue
+                    log_error(f'{_plugin.slug}.get_ui_features')
+                    continue
 
                 if plugin_features and type(plugin_features) is list:
                     for _feature in plugin_features:
-                        features.append(_feature)
+                        try:
+                            # Ensure that the required fields are present
+                            _feature['plugin_name'] = _plugin.slug
+                            _feature['feature_type'] = str(feature)
+
+                            # Ensure base fields are strings
+                            for field in ['key', 'title', 'description', 'source']:
+                                if field in _feature:
+                                    _feature[field] = str(_feature[field])
 
-        return Response(
-            UIPluginSerializers.PluginUIFeatureSerializer(features, many=True).data
-        )
+                            # Add the feature to the list (serialize)
+                            features.append(
+                                UIPluginSerializers.PluginUIFeatureSerializer(
+                                    _feature, many=False
+                                ).data
+                            )
+
+                        except Exception:
+                            # Custom features could not load
+                            # Log the error and continue
+                            log_error(f'{_plugin.slug}.get_ui_features')
+                            continue
+
+        return Response(features)
 
 
 ui_plugins_api_urls = [
-    path('panels/', PluginPanelList.as_view(), name='api-plugin-panel-list'),
     path(
         'features/<str:feature>/',
         PluginUIFeatureList.as_view(),
         name='api-plugin-ui-feature-list',
-    ),
+    )
 ]

src/backend/InvenTree/plugin/base/ui/mixins.py

@@ -11,43 +11,57 @@
 logger = logging.getLogger('inventree')
 
 
-class CustomPanel(TypedDict):
-    """Type definition for a custom panel.
-
-    Attributes:
-        name: The name of the panel (required, used as a DOM identifier).
-        label: The label of the panel (required, human readable).
-        icon: The icon of the panel (optional, must be a valid icon identifier).
-        content: The content of the panel (optional, raw HTML).
-        context: Optional context data (dict / JSON) which will be passed to the front-end rendering function
-        source: The source of the panel (optional, path to a JavaScript file).
-    """
-
-    name: str
-    label: str
-    icon: str
-    content: str
-    context: dict
-    source: str
-
-
-FeatureType = Literal['template_editor', 'template_preview']
+# List of supported feature types
+FeatureType = Literal[
+    'dashboard',  # Custom dashboard items
+    'panel',  # Custom panels
+    'template_editor',  # Custom template editor
+    'template_preview',  # Custom template preview
+]
 
 
 class UIFeature(TypedDict):
     """Base type definition for a ui feature.
 
     Attributes:
+        key: The key of the feature (required, must be a unique identifier)
+        title: The title of the feature (required, human readable)
+        description: The long-form description of the feature (optional, human readable)
         feature_type: The feature type (required, see documentation for all available types)
         options: Feature options (required, see documentation for all available options for each type)
         source: The source of the feature (required, path to a JavaScript file).
     """
 
+    key: str
+    title: str
+    description: str
     feature_type: FeatureType
     options: dict
     source: str
 
 
+class CustomPanelOptions(TypedDict):
+    """Options type definition for a custom panel.
+
+    Attributes:
+        icon: The icon of the panel (optional, must be a valid icon identifier).
+    """
+
+    icon: str
+
+
+class CustomDashboardItemOptions(TypedDict):
+    """Options type definition for a custom dashboard item.
+
+    Attributes:
+        width: The minimum width of the dashboard item (integer, defaults to 2)
+        height: The minimum height of the dashboard item (integer, defaults to 2)
+    """
+
+    width: int
+    height: int
+
+
 class UserInterfaceMixin:
     """Plugin mixin class which handles injection of custom elements into the front-end interface.
 
@@ -65,48 +79,85 @@ def __init__(self):
         super().__init__()
         self.add_mixin('ui', True, __class__)  # type: ignore
 
+    def get_ui_features(
+        self, feature_type: FeatureType, context: dict, request: Request
+    ) -> list[UIFeature]:
+        """Return a list of custom features to be injected into the UI.
+
+        Arguments:
+            feature_type: The type of feature being requested
+            context: Additional context data provided by the UI (query parameters)
+            request: HTTPRequest object (including user information)
+
+        Returns:
+            list: A list of custom UIFeature dicts to be injected into the UI
+
+        """
+        feature_map = {
+            'dashboard': self.get_ui_dashboard_items,
+            'panel': self.get_ui_panels,
+            'template_editor': self.get_ui_template_editors,
+            'template_preview': self.get_ui_template_previews,
+        }
+
+        if feature_type in feature_map:
+            return feature_map[feature_type](request, context=context)
+        else:
+            logger.warning(f'Invalid feature type: {feature_type}')
+            return []
+
     def get_ui_panels(
-        self, instance_type: str, instance_id: int, request: Request, **kwargs
-    ) -> list[CustomPanel]:
+        self, request: Request, context: dict, **kwargs
+    ) -> list[UIFeature]:
         """Return a list of custom panels to be injected into the UI.
 
         Args:
-            instance_type: The type of object being viewed (e.g. 'part')
-            instance_id: The ID of the object being viewed (e.g. 123)
             request: HTTPRequest object (including user information)
 
         Returns:
             list: A list of custom panels to be injected into the UI
+        """
+        # Default implementation returns an empty list
+        return []
 
-        - The returned list should contain a dict for each custom panel to be injected into the UI:
-        - The following keys can be specified:
-        {
-            'name': 'panel_name',  # The name of the panel (required, must be unique)
-            'label': 'Panel Title',  # The title of the panel (required, human readable)
-            'icon': 'icon-name',  # Icon name (optional, must be a valid icon identifier)
-            'content': '<p>Panel content</p>',  # HTML content to be rendered in the panel (optional)
-            'context': {'key': 'value'},  # Context data to be passed to the front-end rendering function (optional)
-            'source': 'static/plugin/panel.js',  # Path to a JavaScript file to be loaded (optional)
-        }
+    def get_ui_dashboard_items(
+        self, request: Request, context: dict, **kwargs
+    ) -> list[UIFeature]:
+        """Return a list of custom dashboard items to be injected into the UI.
 
-        - Either 'source' or 'content' must be provided
+        Args:
+            request: HTTPRequest object (including user information)
 
+        Returns:
+            list: A list of custom dashboard items to be injected into the UI
         """
         # Default implementation returns an empty list
         return []
 
-    def get_ui_features(
-        self, feature_type: FeatureType, context: dict, request: Request
+    def get_ui_template_editors(
+        self, request: Request, context: dict
     ) -> list[UIFeature]:
-        """Return a list of custom features to be injected into the UI.
+        """Return a list of custom template editors to be injected into the UI.
 
-        Arguments:
-            feature_type: The type of feature being requested
-            context: Additional context data provided by the UI
+        Args:
             request: HTTPRequest object (including user information)
 
         Returns:
-            list: A list of custom UIFeature dicts to be injected into the UI
+            list: A list of custom template editors to be injected into the UI
+        """
+        # Default implementation returns an empty list
+        return []
+
+    def get_ui_template_previews(
+        self, request: Request, context: dict
+    ) -> list[UIFeature]:
+        """Return a list of custom template previews to be injected into the UI.
+
+        Args:
+            request: HTTPRequest object (including user information)
+
+        Returns:
+            list: A list of custom template previews to be injected into the UI
         """
         # Default implementation returns an empty list
         return []