Bloomerp 1.0.0.dev9__tar.gz → 1.0.0.dev11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev9
+Version: 1.0.0.dev11
 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-1.0.0.dev11}/Bloomerp.egg-info/SOURCES.txt

@@ -783,7 +783,6 @@ bloomerp/utils/encryption.py
 bloomerp/utils/filters.py
 bloomerp/utils/model_io.py
 bloomerp/utils/models.py
-bloomerp/utils/object_generator.py
 bloomerp/utils/pdf.py
 bloomerp/utils/realtime.py
 bloomerp/utils/requests.py

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev9
+Version: 1.0.0.dev11
 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-1.0.0.dev11}/bloomerp/forms/auth.py

@@ -54,8 +54,14 @@ class UserSelectionForm(forms.Form):
 # User Creation Form
 # ---------------------------------
 from django.contrib.auth.forms import UserCreationForm
+
+
+def get_user_creation_fields(user_model:type[AbstractBloomerpUser]) -> tuple[str, ...]:
+    ordered_fields = [user_model.USERNAME_FIELD, *getattr(user_model, "REQUIRED_FIELDS", [])]
+    return tuple(dict.fromkeys(ordered_fields))
+
+
 class BloomerpUserCreationForm(UserCreationForm):
     class Meta(UserCreationForm.Meta):
         model = User
-        fields = UserCreationForm.Meta.fields + ('email',)
-
+        fields = get_user_creation_fields(User)

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/services/permission_services.py

@@ -20,7 +20,8 @@ from bloomerp.models.access_control import Policy
 from bloomerp.models.access_control.field_policy import FieldPolicy
 from bloomerp.models.access_control.row_policy import RowPolicy
 from django.contrib.contenttypes.models import ContentType
-from typing import Type
+from django.contrib.auth.models import Permission
+from typing import Literal, Type
 from django.db.models import Q
 from bloomerp.field_types import Lookup
 from django.core.exceptions import FieldDoesNotExist
@@ -46,8 +47,6 @@ class UserPermissionManager:
         self.is_anonymous = not user or user.is_anonymous
         
         self.policies = self.get_user_policies()
-        
-
     
     def get_user_policies(self) -> QuerySet[Policy]:
         """Retrieve all policies associated with the user.
@@ -432,18 +431,22 @@ class UserPermissionManager:
         Returns:
             bool: whether the user has access to the object
         """
+        normalized_permission = str(permission_str or "").strip()
+        if normalized_permission and "_" not in normalized_permission and "." not in normalized_permission:
+            normalized_permission = create_permission_str(object, normalized_permission)
+
         if check_global:
             has_global_permission = self.has_global_permission(
                 object._meta.model,
-                permission_str
+                normalized_permission
             )
         else:
             has_global_permission = True
 
-        has_obj_permission = self.get_queryset(object._meta.model, permission_str).filter(
+        has_obj_permission = self.get_queryset(object._meta.model, normalized_permission).filter(
                     id=object.id
                 ).exists()
-        
+
         return (has_global_permission and has_obj_permission)
     
     def get_queryset(self, model_or_content_type:Type[models.Model]|ContentType, permission_str:str) -> QuerySet[models.Model]:
@@ -609,5 +612,223 @@ class UserPermissionManager:
             return normalized_actual != normalized_expected
         return False
     
-    
-        
+    def assign_creator_permission(
+            self, 
+            model: Type[models.Model],
+            field_policy: dict[str|ApplicationField, list[str]|Literal["__all__"]],
+            row_permissions: list[str]|Literal["__all__"],
+            ):
+        """Get or create a reusable "creator" policy for the current user.
+
+        The created policy combines:
+
+        1. field-level permissions from ``field_policy``
+        2. row-level permissions on records where ``created_by == current user``
+        3. matching global permissions so the granted actions can pass global checks
+
+        This is useful when a user should be allowed to work with records they
+        created themselves, while still keeping field-level access more
+        restrictive than row-level access.
+
+        Args:
+            model (Type[models.Model]): the model to give creator permission for
+            field_policy (dict[str|ApplicationField, list[str]|Literal["__all__"]]):
+                Dictionary mapping fields to permission lists.
+
+                Keys can be:
+                - a field name such as ``"age"``
+                - an ``ApplicationField`` instance
+                - ``"__all__"`` to apply the same permissions to all fields
+
+                Values can be:
+                - a list like ``["add", "view"]`` or ``["add_customer"]``
+                - ``"__all__"`` to grant all default model permissions for that
+                  field
+
+                Bare permissions like ``"add"`` are normalized to model
+                codenames like ``"add_customer"``.
+
+            row_permissions (list[str]|Literal["__all__"]):
+                Permissions to grant on rows owned by the current user. These
+                are attached to the implicit creator rule
+                ``created_by == $user``.
+
+                This is independent from ``field_policy``. For example, a user
+                may have row-level ``change`` access to their own records, while
+                still being blocked from changing a specific field.
+
+        Usage:
+        ```python
+        manager.assign_creator_permission(
+            Customer,
+            field_policy={"__all__": "__all__"},
+            row_permissions="__all__",
+        )
+        ```
+
+        Give full field access and full creator row access for the model.
+
+        ```python
+        manager.assign_creator_permission(
+            Customer,
+            field_policy={
+                "first_name": ["add", "view", "change"],
+                "last_name": ["add", "view", "change"],
+                "age": ["add", "view"],
+            },
+            row_permissions=["add", "view", "change"],
+        )
+        ```
+
+        In this example, the user can create and view ``age`` on their own
+        records, but cannot change it later because ``change`` is omitted from
+        the field-level permission list for that field.
+
+        Repeated calls are additive. Existing creator policies for the same
+        user/model are reused and updated instead of duplicated.
+        """
+        if not isinstance(model, type) or not issubclass(model, models.Model):
+            raise TypeError("model must be a Django model class")
+
+        if self.is_anonymous:
+            raise ValueError("Cannot assign creator permissions to an anonymous user")
+
+        content_type = ContentType.objects.get_for_model(model)
+        creator_field = ApplicationField.get_for_model(model).filter(field="created_by").first()
+        if not creator_field:
+            raise ValueError("Model must have a created_by application field")
+
+        def normalize_permissions(permissions_value: list[str] | Literal["__all__"]) -> list[str]:
+            if permissions_value == "__all__":
+                return [
+                    create_permission_str(model, permission)
+                    for permission in model._meta.default_permissions
+                ]
+
+            normalized_permissions = []
+            for permission in permissions_value:
+                permission_value = str(permission or "").strip()
+                if not permission_value:
+                    continue
+
+                if "." in permission_value:
+                    permission_value = permission_value.split(".", 1)[-1]
+                elif "_" not in permission_value:
+                    permission_value = create_permission_str(model, permission_value)
+
+                normalized_permissions.append(permission_value)
+
+            return list(dict.fromkeys(normalized_permissions))
+
+        normalized_row_permissions = normalize_permissions(row_permissions)
+        if not normalized_row_permissions:
+            raise ValueError("At least one row permission must be provided")
+
+        if not isinstance(field_policy, dict) or not field_policy:
+            raise ValueError("field_policy must be a non-empty dictionary")
+
+        normalized_field_policy: dict[str, list[str]] = {}
+
+        for field, permissions in field_policy.items():
+            normalized_field_permissions = normalize_permissions(permissions)
+            if not normalized_field_permissions:
+                continue
+
+            if field == "__all__":
+                field_key = "__all__"
+            elif isinstance(field, ApplicationField):
+                if field.content_type_id != content_type.id:
+                    raise ValueError("All fields must belong to the given model")
+                field_key = str(field.id)
+            else:
+                field_name = str(field or "").strip()
+                if not field_name:
+                    continue
+
+                application_field = ApplicationField.get_for_model(model).filter(field=field_name).first()
+                if not application_field:
+                    raise ValueError(f"Unknown field '{field_name}' for model '{model._meta.model_name}'")
+                field_key = str(application_field.id)
+
+            existing_permissions = normalized_field_policy.get(field_key, [])
+            normalized_field_policy[field_key] = list(
+                dict.fromkeys([*existing_permissions, *normalized_field_permissions])
+            )
+
+        if not normalized_field_policy:
+            raise ValueError("At least one field permission must be provided")
+
+        all_field_permissions = list(
+            dict.fromkeys(
+                permission
+                for permissions in normalized_field_policy.values()
+                for permission in permissions
+            )
+        )
+        all_policy_permissions = list(
+            dict.fromkeys([*normalized_row_permissions, *all_field_permissions])
+        )
+
+        policy_key = f"{content_type.app_label}.{content_type.model}.{self.user.pk}"
+
+        field_policy_obj, _ = FieldPolicy.objects.get_or_create(
+            content_type=content_type,
+            name=f"Creator field policy {policy_key}",
+            defaults={"rule": {}},
+        )
+
+        field_rule = field_policy_obj.rule if isinstance(field_policy_obj.rule, dict) else {}
+        field_rule = dict(field_rule)
+
+        for field_key, permissions in normalized_field_policy.items():
+            existing_permissions = field_rule.get(field_key, [])
+            field_rule[field_key] = list(dict.fromkeys([*existing_permissions, *permissions]))
+
+        if field_policy_obj.rule != field_rule:
+            field_policy_obj.rule = field_rule
+            field_policy_obj.save(update_fields=["rule"])
+
+        row_policy, _ = RowPolicy.objects.get_or_create(
+            content_type=content_type,
+            name=f"Creator row policy {policy_key}",
+        )
+
+        row_rule_definition = {
+            "application_field_id": str(creator_field.id),
+            "operator": Lookup.EQUALS_USER.value.id,
+            "value": "$user",
+        }
+        row_rule = row_policy.rules.filter(rule=row_rule_definition).first()
+        if not row_rule:
+            row_rule = row_policy.rules.create(rule=row_rule_definition)
+        row_rule.add_permissions(normalized_row_permissions)
+
+        policy, _ = Policy.objects.get_or_create(
+            name=f"Creator policy {policy_key}",
+            defaults={
+                "description": f"Creator permissions for {content_type.app_label}.{content_type.model}",
+                "row_policy": row_policy,
+                "field_policy": field_policy_obj,
+            },
+        )
+
+        fields_to_update = []
+        if policy.row_policy_id != row_policy.id:
+            policy.row_policy = row_policy
+            fields_to_update.append("row_policy")
+        if policy.field_policy_id != field_policy_obj.id:
+            policy.field_policy = field_policy_obj
+            fields_to_update.append("field_policy")
+        if fields_to_update:
+            policy.save(update_fields=fields_to_update)
+
+        policy.assign_user(self.user)
+        policy.global_permissions.add(
+            *Permission.objects.filter(
+                content_type=content_type,
+                codename__in=all_policy_permissions,
+            )
+        )
+
+        self.policies = self.get_user_policies()
+        return policy

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/services/sectioned_layout_services.py

@@ -258,57 +258,6 @@ def resolve_detail_layout_rows(
     return rows
 
 
-def resolve_create_layout_rows(
-    *,
-    layout: FieldLayout | dict[str, Any] | None,
-    content_type: ContentType,
-    user,
-    form,
-) -> list[dict[str, Any]]:
-    manager = UserPermissionManager(user)
-    model = content_type.model_class()
-    permission_str = f"add_{model._meta.model_name}"
-
-    normalized = normalize_layout_payload(layout)
-    rows: list[dict[str, Any]] = []
-
-    for row in normalized.rows:
-        resolved_items: list[dict[str, Any]] = []
-        for item in row.items:
-            application_field = ApplicationField.objects.filter(
-                id=item.id,
-                content_type=content_type,
-            ).first()
-            if not application_field:
-                continue
-            if application_field.field not in form.fields:
-                continue
-            if not manager.has_field_permission(application_field, permission_str):
-                continue
-
-            resolved_items.append(
-                {
-                    "id": application_field.pk,
-                    "colspan": clamp_layout_colspan(item.colspan, row.columns),
-                    "application_field": application_field,
-                    **build_crud_layout_field_context(
-                        application_field=application_field,
-                        bound_field=form[application_field.field],
-                    ),
-                }
-            )
-
-        rows.append(
-            {
-                "title": row.title,
-                "columns": row.columns,
-                "items": resolved_items,
-            }
-        )
-
-    return rows
-
-
 def get_layout_widget_attrs(*, widget: forms.Widget) -> dict[str, str]:
     widget_choices = getattr(widget, "get_choices", lambda *_args, **_kwargs: getattr(widget, "choices", []))()
     is_select_widget = isinstance(widget, forms.Select) or bool(widget_choices)

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/services/user_services.py

@@ -114,22 +114,6 @@ def get_data_view_fields(preference: UserListViewPreference, view_type: str = No
     )
 
 
-def clear_user_list_view_preference_cache(user: AbstractBloomerpUser, content_type: ContentType) -> None:
-    """Clears the cached list view preference for a user and content type.
-    
-    Call this function when:
-    - User updates their field preferences
-    - Admin modifies ApplicationField records
-    - Model schema changes
-    
-    Args:
-        user (AbstractBloomerpUser): The user whose cache to clear.
-        content_type (ContentType): The content type to clear cache for.
-    """
-    cache_key = f'list_view_pref:{user.id}:{content_type.id}'
-    cache.delete(cache_key)
-
-
 def get_user_list_view_preference(user: AbstractBloomerpUser, content_type: ContentType) -> UserListViewPreference:
     """Gets the UserListViewPreference for a user and content type, creating a default if none exists.
     

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/urls.py

@@ -1,7 +1,7 @@
+from django.apps import apps
 from django.urls import include, path,  register_converter
 from django.urls import NoReverseMatch
 from django.contrib.auth import views as auth_views
-from django.contrib.contenttypes.models import ContentType
 from rest_framework.response import Response
 from rest_framework.reverse import reverse
 from bloomerp.config.definition import BloomerpConfig
@@ -75,6 +75,46 @@ class PublicApiRootRouter(DefaultRouter):
 register_converter(IntOrUUIDConverter, 'int_or_uuid') # Register the custom URL converter
 drf_router = PublicApiRootRouter()
 
+
+def get_api_models() -> list[type[Model]]:
+    api_models: list[type[Model]] = []
+
+    for model in apps.get_models():
+        if model is Policy:
+            continue
+        if model._meta.abstract or model._meta.proxy:
+            continue
+        api_models.append(model)
+
+    return api_models
+
+
+def register_model_with_admin(model: type[Model]) -> None:
+    try:
+        admin.site.register(model)
+    except AlreadyRegistered:
+        pass
+
+
+def register_model_api(model: type[Model]) -> None:
+    serializer_class = generate_serializer(model)
+    ApiViewSet = generate_model_viewset_class(
+        model=model,
+        serializer=serializer_class,
+        base_viewset=BloomerpModelViewSet
+    )
+
+    config = getattr(model, "bloomerp_config", None)
+    if isinstance(config, BloomerpModelConfig):
+        if not config.should_enable_api_auto_generation():
+            return
+
+    drf_router.register(
+        prefix=model_name_plural_underline(model),
+        viewset=ApiViewSet,
+        basename=model_name_plural_underline(model)
+    )
+
 # Get the config
 bloomerp_config : BloomerpConfig = getattr(settings, "BLOOMERP_CONFIG", None)
 
@@ -88,51 +128,14 @@ urlpatterns = [
     path('logout/',auth_views.LogoutView.as_view(next_page=reverse_lazy('login')), name='logout'),
 ]
 
-# Get the content types
-try:
-    content_types = list(ContentType.objects.all())
-except Exception:
-    # Database might not be ready yet (e.g., during initial migrations)
-    content_types = []
-
-# Loop through all the content types
-for content_type in content_types:
-    if content_type.model_class():
-        model : Model = content_type.model_class()
-        
-        if not model:
-            continue
-
-        if model is Policy:
-            continue
-        
-        try:
-            admin.site.register(model)
-        except AlreadyRegistered:
-            pass
-
-        serializer_class = generate_serializer(model)
-        ApiViewSet = generate_model_viewset_class(
-            model=model,
-            serializer=serializer_class,
-            base_viewset=BloomerpModelViewSet
-        )
+for model in get_api_models():
+    register_model_with_admin(model)
 
-        try:
-            config = getattr(model, "bloomerp_config", None)
-            if isinstance(config, BloomerpModelConfig):
-                if not config.should_enable_api_auto_generation():
-                    continue
-                
-            drf_router.register(
-                prefix = model_name_plural_underline(model), 
-                viewset = ApiViewSet, 
-                basename=model_name_plural_underline(model)
-            )
-            
-        except Exception as e:
-            # Don't fail URL loading if a single model registration errors
-            pass
+    try:
+        register_model_api(model)
+    except Exception:
+        # Don't fail URL loading if a single model registration errors
+        pass
 
 # Register models
 drf_router.register(

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/utils/api.py

@@ -36,7 +36,5 @@ def generate_model_viewset_class(
         'serializer_class': serializer,
         'filterset_class': dynamic_filterset_factory(model)
     })
-
-
-
+    
     return Class

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/bloomerp/views/user/create_user.py

@@ -35,9 +35,6 @@ class UserCreateView(
 
     def get_context_data(self, **kwargs):
         context = super().get_context_data(**kwargs)
-        context["model_name"] = self.model._meta.verbose_name
-        context["model_name_plural"] = self.model._meta.verbose_name_plural
-        context["list_view_url"] = model_name_plural_underline(self.model) + "_list"
         context["model"] = self.model
         return context
 

{bloomerp-1.0.0.dev9 → bloomerp-1.0.0.dev11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Bloomerp"
-version = "1.0.0.dev9"
+version = "1.0.0.dev11"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.12"

bloomerp-1.0.0.dev9/bloomerp/utils/object_generator.py

@@ -1,77 +0,0 @@
-from django.db.models import Model
-import random
-import string
-from datetime import datetime
-
-def random_object_factory(model: Model):
-    '''
-    Function that generates a random object for a particular model.
-    '''
-    try:
-        # Get the fields of the model
-        fields = model._meta.get_fields()
-
-        # Initialize the data dictionary
-        data = {}
-
-        # Loop through the fields
-        for field in fields:
-            if field.get_internal_type() == 'CharField':
-                data[field.name] = ''.join(random.choices(string.ascii_letters, k=10))
-
-            elif field.get_internal_type() == 'IntegerField':
-                data[field.name] = random.randint(1, 100)
-
-            elif field.get_internal_type() == 'DateTimeField':
-                data[field.name] = datetime.now().isoformat()
-
-            elif field.get_internal_type() == 'ForeignKey':
-                if field.one_to_many or field.many_to_many:
-                    continue
-
-                related_model = field.related_model
-                related_instance = related_model.objects.first()
-                if related_instance:
-                    data[field.name] = related_instance
-                else:
-                    raise ValueError(f"No instances found for related model {related_model}")
-
-            elif field.get_internal_type() == 'BooleanField':
-                data[field.name] = random.choice([True, False])
-
-            elif field.get_internal_type() == 'FloatField':
-                data[field.name] = random.uniform(1.0, 100.0)
-
-            elif field.get_internal_type() == 'TextField':
-                data[field.name] = ''.join(random.choices(string.ascii_letters + string.digits, k=50))
-
-            elif field.get_internal_type() == 'EmailField':
-                data[field.name] = ''.join(random.choices(string.ascii_letters, k=5)) + '@example.com'
-
-            elif field.get_internal_type() == 'URLField':
-                data[field.name] = 'https://www.' + ''.join(random.choices(string.ascii_letters, k=5)) + '.com'
-
-            elif field.get_internal_type() == 'DateField':
-                data[field.name] = datetime.now().date().isoformat()
-            
-            elif field.get_internal_type() == 'DecimalField':
-                data[field.name] = random.uniform(1.0, 100.0)
-
-            elif field.get_internal_type() == 'PositiveIntegerField':
-                data[field.name] = random.randint(1, 100)
-
-            elif field.get_internal_type() == 'ManyToManyField':
-                continue  # Handle ManyToManyField after instance creation
-
-        # Create the instance without saving
-
-        instance = model(**data)
-        
-        return instance
-
-    except Exception as e:
-        print(f"An error occurred with field {field}: {e}")
-        return None
-
-
-