Bloomerp 1.0.0.dev7__tar.gz → 1.0.0.dev9__tar.gz

{bloomerp-1.0.0.dev7 → bloomerp-1.0.0.dev9}/Bloomerp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev7
+Version: 1.0.0.dev9
 Summary: Bloomerp is an open-source Business Management Software framework that lets you create fully functional business management applications just by defining your Django database models.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{bloomerp-1.0.0.dev7 → bloomerp-1.0.0.dev9}/Bloomerp.egg-info/SOURCES.txt

@@ -10,7 +10,6 @@ bloomerp/__init__.py
 bloomerp/admin.py
 bloomerp/apps.py
 bloomerp/cli.py
-bloomerp/config.py
 bloomerp/consumers.py
 bloomerp/context_processors.py
 bloomerp/field_types.py
@@ -66,6 +65,10 @@ bloomerp/components/workspaces/render_workspace_tile.py
 bloomerp/components/workspaces/save_workspace_layout.py
 bloomerp/components/workspaces/share_workspace.py
 bloomerp/components/workspaces/sidebar.py
+bloomerp/config/__init__.py
+bloomerp/config/definition.py
+bloomerp/config/settings.py
+bloomerp/config/validator.py
 bloomerp/form_fields/__init__.py
 bloomerp/form_fields/icon_field.py
 bloomerp/forms/auth.py
@@ -79,6 +82,7 @@ bloomerp/forms/widgets.py
 bloomerp/forms/workspaces.py
 bloomerp/management/commands/get_urls.py
 bloomerp/management/commands/save_application_fields.py
+bloomerp/management/commands/validate_bloomerp.py
 bloomerp/migrations/0001_initial.py
 bloomerp/migrations/0002_rowpolicyrulepermission_and_more.py
 bloomerp/migrations/0003_alter_applicationfield_options.py
@@ -113,6 +117,7 @@ bloomerp/models/__init__.py
 bloomerp/models/activity_log.py
 bloomerp/models/application_field.py
 bloomerp/models/base_bloomerp_model.py
+bloomerp/models/definition.py
 bloomerp/models/mixins.py
 bloomerp/models/access_control/__init__.py
 bloomerp/models/access_control/field_policy.py
@@ -744,12 +749,9 @@ bloomerp/templates/tailwind/layout/radioselect_inline.html
 bloomerp/templates/tailwind/layout/row.html
 bloomerp/templates/tailwind/layout/select.html
 bloomerp/templates/tailwind/layout/select_option.html
-bloomerp/templates/user_views/bloomerp_detail_view_preference_view.html
 bloomerp/templates/user_views/inbox_view.html
-bloomerp/templates/user_views/list_view_preference_view.html
 bloomerp/templates/user_views/new_password_done_view.html
 bloomerp/templates/user_views/new_password_view.html
-bloomerp/templates/user_views/notification_list_view.html
 bloomerp/templates/user_views/notification_setting_view.html
 bloomerp/templates/user_views/snippets/user_content_type_selection_snippet.html
 bloomerp/templates/utils/blank_form.html
@@ -776,7 +778,6 @@ bloomerp/templatetags/bloomerp.py
 bloomerp/templatetags/bloomerp_ui.py
 bloomerp/templatetags/globals.py
 bloomerp/utils/api.py
-bloomerp/utils/config.py
 bloomerp/utils/document_templates.py
 bloomerp/utils/encryption.py
 bloomerp/utils/filters.py

{bloomerp-1.0.0.dev7 → bloomerp-1.0.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev7
+Version: 1.0.0.dev9
 Summary: Bloomerp is an open-source Business Management Software framework that lets you create fully functional business management applications just by defining your Django database models.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

bloomerp-1.0.0.dev9/bloomerp/apps.py

@@ -0,0 +1,45 @@
+import os
+import sys
+
+from django.apps import AppConfig
+from colorama import Fore, Style
+
+
+class BloomerpApp(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "bloomerp"
+
+    def _should_run_startup_validation(self) -> bool:
+        if len(sys.argv) > 1 and sys.argv[1] == "validate_bloomerp":
+            return False
+        if len(sys.argv) > 1 and sys.argv[1] == "runserver":
+            return os.environ.get("RUN_MAIN") == "true"
+        return True
+
+    def ready(self) -> None:
+        from django.core.exceptions import ImproperlyConfigured
+        from django.db.utils import OperationalError, ProgrammingError
+        from bloomerp.config.validator import validate_runtime_configuration
+        from bloomerp.signals.automations import setup_automation_signals
+        from bloomerp.modules.definition import module_registry
+
+        try:
+            setup_automation_signals()
+        except (OperationalError, ProgrammingError):
+            # Database may not be ready during migrations.
+            pass
+
+        # Refresh the module registry
+        module_registry.refresh()
+
+        if not self._should_run_startup_validation():
+            return
+
+        validation_result = validate_runtime_configuration(include_error_logs=False)
+        if validation_result.has_errors():
+            header = f"\n{Fore.RED}{Style.BRIGHT}Bloomerp configuration validation failed:{Style.RESET_ALL}"
+            error_messages = "\n".join(validation_result.error_messages(styled=True))
+            raise ImproperlyConfigured(
+                f"{header}\n"
+                f"{error_messages}"
+            )

bloomerp-1.0.0.dev9/bloomerp/config/definition.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+class BloomerpConfig(BaseModel):
+    """
+    Configuration class to be set on the settings. This contains all the necessary configurable settings for bloomerp.
+
+    Settings are:
+    - **auto_generate_api_endpoints** : whether to automatically generate API endpoints for all models. If True, API endpoints will be generated for all models in the application. If False, no API endpoints will be generated. If None, API endpoints will be generated for all models that do not have a custom API endpoint defined. Note that this can be overridden on a per model basis by setting the `auto_generate_api_endpoint` attribute on the model's configuration.
+    - **vite_dev_server_url**: the URL of the Vite development server. This is used for hot module replacement (HMR) during development. The default value is 'http://localhost:5173'. This setting is only used if BLOOMERP_VITE_DEV_SERVER_URL is not set in the settings.
+
+    Usage (in settings.py)
+    ```python
+    from bloomerp.config.definition import BloomerpConfig
+
+    bloomerp_config = BloomerpConfig(
+        ...
+    )
+    ```
+    """
+
+    auto_generate_api_endpoints : bool = True
+
+    vite_dev_server_url : Optional[str] = 'http://localhost:5173'
+    
+
+
+

bloomerp-1.0.0.dev7/bloomerp/config.py → bloomerp-1.0.0.dev9/bloomerp/config/settings.py

@@ -17,4 +17,3 @@ BLOOMERP_MIDDLEWARE = [
 ]
 
 BLOOMERP_USER_MODEL = "bloomerp.User"
-

bloomerp-1.0.0.dev9/bloomerp/config/validator.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+import logging
+import inspect
+from typing import Iterable, Type
+
+from colorama import Fore, Style, init as colorama_init
+from django.apps import apps
+from django.conf import LazySettings, settings
+from django.db.models import Model
+from tenacity import retry_if_not_exception_message
+
+from bloomerp.config.definition import BloomerpConfig
+from bloomerp.models.base_bloomerp_model import BloomerpModel
+from bloomerp.models.definition import BloomerpModelConfig
+from bloomerp.modules.definition import module_registry
+
+logger = logging.getLogger(__name__)
+colorama_init(autoreset=True)
+
+
+class ValidationType(str, Enum):
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+
+
+@dataclass(frozen=True)
+class ValidatorResponse:
+    validation_type: ValidationType
+    code: str
+    message: str
+    hint: str = ""
+    subject: str = ""
+
+
+@dataclass
+class ValidationSectionResult:
+    title: str
+    description: str
+    responses: list[ValidatorResponse] = field(default_factory=list)
+
+    def has_errors(self) -> bool:
+        return any(
+            response.validation_type == ValidationType.ERROR
+            for response in self.responses
+        )
+
+    def has_warnings(self) -> bool:
+        return any(
+            response.validation_type == ValidationType.WARNING
+            for response in self.responses
+        )
+
+
+@dataclass
+class ValidationResult:
+    sections: list[ValidationSectionResult] = field(default_factory=list)
+
+    def add_section(self, section: ValidationSectionResult) -> None:
+        self.sections.append(section)
+
+    def has_errors(self) -> bool:
+        return any(
+            section.has_errors()
+            for section in self.sections
+        )
+
+    def has_warnings(self) -> bool:
+        return any(
+            section.has_warnings()
+            for section in self.sections
+        )
+
+    def error_messages(self, styled: bool = False) -> list[str]:
+        messages: list[str] = []
+        for section in self.sections:
+            error_responses = [
+                response
+                for response in section.responses
+                if response.validation_type == ValidationType.ERROR
+            ]
+            if not error_responses:
+                continue
+            error_section = ValidationSectionResult(
+                title=section.title,
+                description=section.description,
+                responses=error_responses,
+            )
+            messages.append(
+                (
+                    format_styled_validation_section(error_section)
+                    if styled
+                    else format_validation_section(error_section)
+                )
+            )
+        return messages
+
+
+class BloomerpConfigurationValidator:
+    """Validate the bloomerp runtime configuration without producing side effects."""
+    bloomerp_config_attr = "bloomerp_config"
+
+    def __init__(
+        self,
+        settings: LazySettings,
+        models: list[Type[Model]] | None = None,
+    ) -> None:
+        self.settings = settings
+        self.models = models if models is not None else list(apps.get_models())
+
+    @classmethod
+    def from_runtime(cls) -> "BloomerpConfigurationValidator":
+        return cls(settings=settings, models=list(apps.get_models()))
+
+    def validate_settings(self) -> list[ValidatorResponse]:
+        """Checks core Django and BloomERP settings."""
+        responses: list[ValidatorResponse] = []
+
+        if not getattr(self.settings, "BLOOMERP_CONFIG", None):
+            responses.append(
+                ValidatorResponse(
+                    validation_type=ValidationType.ERROR,
+                    code="settings.missing_bloomerp_config",
+                    message="BLOOMERP_CONFIG setting is not set.",
+                    hint=(
+                        "Set BLOOMERP_CONFIG to a valid BloomerpConfig instance to customize "
+                        "BloomERP behavior, or set it to None to silence this warning if default "
+                        "behavior is fine."
+                    ),
+                    subject="BLOOMERP_CONFIG",
+                )
+            )
+        else:
+            bloomerp_config = self.settings.BLOOMERP_CONFIG
+            if not isinstance(bloomerp_config, BloomerpConfig):
+                responses.append(
+                    ValidatorResponse(
+                        validation_type=ValidationType.ERROR,
+                        code="settings.invalid_bloomerp_config",
+                        message="BLOOMERP_CONFIG setting is not an instance of BloomerpConfig.",
+                        hint=(
+                            "Ensure BLOOMERP_CONFIG is set to a valid BloomerpConfig instance, or set it to None for default behavior."
+                        ),
+                        subject="BLOOMERP_CONFIG",
+                    )
+                )
+        
+        return responses
+
+    def validate_models(self) -> list[ValidatorResponse]:
+        """Checks project model configuration and BloomERP inheritance rules."""
+        responses: list[ValidatorResponse] = []
+
+        for model_class in self.models:
+            subject = f"model {model_class._meta.label}"
+
+            if model_class._meta.abstract:
+                continue
+            
+            app_module = model_class.__module__
+            if app_module.startswith("django."):
+                continue
+
+            if model_class._meta.app_label == "bloomerp":
+                continue
+            
+            if not issubclass(model_class, BloomerpModel):
+                responses.append(
+                    ValidatorResponse(
+                        validation_type=ValidationType.WARNING,
+                        code="models.not_bloomerp_model",
+                        message=(
+                            f"Model '{model_class._meta.label}' does not inherit from "
+                            "BloomerpModel."
+                        ),
+                        hint=(
+                            "This may be fine for third-party apps, but BloomERP models "
+                            "should usually inherit from BloomerpModel."
+                        ),
+                        subject=subject,
+                    )
+                )
+
+            # Check for bloomerp_config attribute and validate its type if present
+            if not hasattr(model_class, self.bloomerp_config_attr):
+                responses.append(
+                    ValidatorResponse(
+                        validation_type=ValidationType.WARNING,
+                        code="models.missing_bloomerp_config",
+                        message=(
+                            f"Model '{model_class._meta.label}' does not have a "
+                            "bloomerp_config attribute."
+                        ),
+                        hint=(
+                            "Add a bloomerp_config attribute set to a BloomerpModelConfig "
+                            "instance to customize behavior, or add an empty bloomerp_config "
+                            "attribute to silence this warning if default behavior is fine."
+                        ),
+                        subject=subject,
+                    )
+                )
+            else:
+                config = getattr(model_class, self.bloomerp_config_attr)
+                if not isinstance(config, BloomerpModelConfig):
+                    responses.append(
+                        ValidatorResponse(
+                            validation_type=ValidationType.ERROR,
+                            code="models.invalid_bloomerp_config",
+                            message=(
+                                f"Model '{model_class._meta.label}' has a bloomerp_config "
+                                "attribute that is not an instance of BloomerpModelConfig. Please remove this attribute for " \
+                                "default behavior, or set it to a valid BloomerpModelConfig instance."
+                            ),
+                            hint=(
+                                "Ensure bloomerp_config is either removed or set to a valid BloomerpModelConfig instance."
+                            ),
+                            subject=subject,
+                        )
+                    )
+
+        
+        return responses
+
+    def validate_modules(self) -> list[ValidatorResponse]:
+        """Checks whether the BloomERP module registry contains loaded modules."""
+        responses: list[ValidatorResponse] = []
+
+        if not module_registry.get_all():
+            responses.append(
+                ValidatorResponse(
+                    validation_type=ValidationType.WARNING,
+                    code="modules.registry_empty",
+                    message="The BloomERP module registry is empty.",
+                    hint="Ensure module definitions are imported and module_registry.refresh() runs at startup.",
+                    subject="module_registry",
+                )
+            )
+
+        return responses
+
+    def validate(self) -> ValidationResult:
+        result = ValidationResult()
+
+        for method_name, method in inspect.getmembers(self, predicate=callable):
+            if method_name in {"validate", "validate_all"}:
+                continue
+            if not method_name.startswith("validate_"):
+                continue
+
+            description = inspect.getdoc(method) or "No validator description provided."
+            title = method_name.replace("validate_", "").replace("_", " ").title()
+            responses = list(method())
+            result.add_section(
+                ValidationSectionResult(
+                    title=title,
+                    description=description,
+                    responses=responses,
+                )
+            )
+
+        return result
+
+
+def format_validation_message(response: ValidatorResponse) -> str:
+    message = f"[{response.code}] {response.message}"
+    if response.subject:
+        message += f" | subject={response.subject}"
+    if response.hint:
+        message += f" | hint={response.hint}"
+    return message
+
+
+def format_styled_validation_message(response: ValidatorResponse) -> str:
+    if response.validation_type == ValidationType.ERROR:
+        color = Fore.RED
+        label = "ERROR"
+    elif response.validation_type == ValidationType.WARNING:
+        color = Fore.YELLOW
+        label = "WARNING"
+    else:
+        color = Fore.CYAN
+        label = "INFO"
+
+    lines = [
+        f"{color}{Style.BRIGHT}BloomERP {label}{Style.RESET_ALL} [{response.code}]",
+        f"  {response.message}",
+    ]
+    if response.subject:
+        lines.append(f"  subject: {response.subject}")
+    if response.hint:
+        lines.append(f"  hint: {response.hint}")
+    return "\n".join(lines)
+
+
+def format_styled_validation_section(section: ValidationSectionResult) -> str:
+    lines = [
+        f"\n{Fore.BLUE}{Style.BRIGHT}{section.title}{Style.RESET_ALL}",
+        f"{Style.DIM}{section.description}{Style.RESET_ALL}",
+    ]
+
+    if not section.responses:
+        lines.append(f"{Fore.GREEN}{Style.BRIGHT}OKAY{Style.RESET_ALL}")
+        return "\n".join(lines)
+
+    if not section.has_errors() and not section.has_warnings():
+        lines.append(f"{Fore.GREEN}{Style.BRIGHT}OKAY{Style.RESET_ALL}")
+        return "\n".join(lines)
+
+    for response in section.responses:
+        lines.append(format_styled_validation_message(response))
+
+    return "\n".join(lines)
+
+
+def format_validation_section(section: ValidationSectionResult) -> str:
+    lines = [section.title, section.description]
+
+    if not section.responses:
+        lines.append("OKAY")
+        return "\n".join(lines)
+
+    if not section.has_errors() and not section.has_warnings():
+        lines.append("OKAY")
+        return "\n".join(lines)
+
+    for response in section.responses:
+        lines.append(format_validation_message(response))
+
+    return "\n".join(lines)
+
+
+def log_validation_result(result: ValidationResult, *, include_errors: bool = True) -> None:
+    for section in result.sections:
+        if section.has_errors() and not include_errors:
+            continue
+        formatted = format_styled_validation_section(section)
+        if section.has_errors():
+            logger.error("\n%s", formatted)
+        elif section.has_warnings():
+            logger.warning("\n%s", formatted)
+        else:
+            logger.info("\n%s", formatted)
+
+
+def validate_runtime_configuration(*, include_error_logs: bool = True) -> ValidationResult:
+    result = BloomerpConfigurationValidator.from_runtime().validate()
+    log_validation_result(result, include_errors=include_error_logs)
+    return result

{bloomerp-1.0.0.dev7 → bloomerp-1.0.0.dev9}/bloomerp/context_processors.py

@@ -8,7 +8,7 @@ def debug_mode(request: HttpRequest) -> dict:
     """
     return {
         'DEBUG': settings.DEBUG,
-        'BLOOMERP_VITE_DEV_SERVER_URL': settings.BLOOMERP_SETTINGS.get('VITE_DEV_SERVER_URL', 'http://localhost:5173').rstrip('/'),
+        'BLOOMERP_VITE_DEV_SERVER_URL': getattr(getattr(settings, "BLOOMERP_CONFIG", None), "vite_dev_server_url", 'http://localhost:5173').rstrip('/'),
     }
     
 def htmx_main_content_div(request: HttpRequest) -> dict:

bloomerp-1.0.0.dev9/bloomerp/management/commands/validate_bloomerp.py

@@ -0,0 +1,25 @@
+from django.core.management.base import BaseCommand
+
+from bloomerp.config.validator import (
+    BloomerpConfigurationValidator,
+    format_styled_validation_section,
+)
+
+
+class Command(BaseCommand):
+    help = "Validate the BloomERP configuration."
+
+    def handle(self, *args, **options):
+        validator = BloomerpConfigurationValidator.from_runtime()
+        result = validator.validate()
+
+        if not result.sections:
+            self.stdout.write(self.style.SUCCESS("No BloomERP validation issues found."))
+            return
+
+        for section in result.sections:
+            self.stdout.write(format_styled_validation_section(section))
+
+        if result.has_errors():
+            self.stderr.write(self.style.ERROR("BloomERP validation failed."))
+            raise SystemExit(1)

bloomerp-1.0.0.dev9/bloomerp/models/definition.py

@@ -0,0 +1,91 @@
+from typing import Literal, Optional
+from bloomerp.config.definition import BloomerpConfig
+from bloomerp.models.base_bloomerp_model import FieldLayout
+from pydantic import BaseModel, Field
+from django.conf import settings
+
+class ApiFilterRule(BaseModel):
+    field: str
+    operator: str = "exact"
+    value: str | int | float | bool | None = None
+
+
+class PublicAccessRule(BaseModel):
+    actions: list[Literal["list", "read"]] = Field(
+        default_factory=lambda: ["list", "read"]
+    )
+    fields: list[str] | Literal["__all__"] = "__all__"
+    filters: list[ApiFilterRule] = Field(default_factory=list)
+
+
+class ApiSettings(BaseModel):
+    """
+    Configures how Bloomerp API's are set up.
+
+    Settings are:
+        - enable_auto_generation: defines whether API endpoints are autogenerated for this model. Defaults to False
+        - public_access: defines read/list exceptions for public API access
+    """
+
+    enable_auto_generation: bool = False
+    public_access: list[PublicAccessRule] = Field(default_factory=list)
+
+    def get_public_access_rules(self, action: str) -> list[PublicAccessRule]:
+        normalized_action = str(action or "").strip().lower()
+        return [
+            rule
+            for rule in self.public_access
+            if normalized_action in rule.actions
+        ]
+
+    def has_public_access(self) -> bool:
+        return len(self.public_access) > 0
+
+
+class BloomerpModelConfig(BaseModel):
+    """
+    Used to define certain bloomerp related meta data on a model. 
+
+    Settings are:
+        - modules: a list of modules to which this model belongs.
+        - layout: a layout object defining how the default CRUD layout for users is.
+
+    Usage
+    ```python
+    from bloomerp.models.definition import BloomerpModelConfig
+
+    class Lorum(BloomerpModel):
+        bloomerp_config = BloomerpModelConfig(
+            ...
+        )
+    ``` 
+    """
+
+    modules: Optional[list[str]] = None
+
+    layout: Optional[FieldLayout] = None
+
+    allow_string_search: bool = True
+
+    is_internal: bool = False
+
+    api_settings: Optional[ApiSettings] = None
+
+    def get_public_access_rules(self, action: str) -> list[PublicAccessRule]:
+        if self.api_settings is None:
+            return []
+        return self.api_settings.get_public_access_rules(action)
+
+    def has_public_access(self) -> bool:
+        if self.api_settings is None:
+            return False
+        return self.api_settings.has_public_access()
+
+    def should_enable_api_auto_generation(self) -> bool:
+        bloomerp_config : BloomerpConfig = getattr(settings, "BLOOMERP_CONFIG")
+
+        if self.api_settings is None:
+            # In this case, use the global setting to determine whether to auto generate API endpoints
+            return bloomerp_config.auto_generate_api_endpoints
+        
+        return self.api_settings.enable_auto_generation