first

utils/base_model.py

@@ -0,0 +1,9 @@
+from django.db import models
+
+
+class BaseModel(models.Model):
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        abstract = True

utils/custom_permissions.py

@@ -0,0 +1,79 @@
+from rest_framework import permissions
+from utils.get_user_workspace import *
+from utils.get_cuser_role import *
+from apps.shop.models import Order as OrderModel
+from utils.get_cuser_role import get_cuser_role_uuid
+from apps.cuser.models import CuserRole as CuserRoleModel
+
+workspace_group = [
+    'workspace_owner',
+]
+
+workspace_admin_up = [
+    'workspace_owner',
+    'workspace_admin',
+]
+
+workspace_operator_up = [
+    'workspace_owner',
+    'workspace_admin',
+    'workspace_operator',
+]
+
+
+class WorkspaceOwnerPermission(permissions.BasePermission):
+    required_groups = workspace_group
+
+    def has_permission(self, request, view):
+
+        cuser_role_uuid = get_cuser_role_uuid(request)
+        cuser_role = CuserRoleModel.objects.select_related('role_type').get(uuid=cuser_role_uuid)
+        if cuser_role.role_type.role_name_en in self.required_groups:
+            return True
+        else:
+            return False
+
+
+class WorkspaceAdminPermission(permissions.BasePermission):
+    required_groups = workspace_admin_up
+
+    def has_permission(self, request, view):
+
+        cuser_role_uuid = get_cuser_role_uuid(request)
+        cuser_role = CuserRoleModel.objects.select_related('role_type').get(uuid=cuser_role_uuid)
+        if cuser_role.role_type.role_name_en in self.required_groups:
+            return True
+        else:
+            return False
+
+
+class WorkspaceOperatorPermission(permissions.BasePermission):
+    required_groups = workspace_operator_up
+
+    def has_permission(self, request, view):
+
+        cuser_role_uuid = get_cuser_role_uuid(request)
+        cuser_role = CuserRoleModel.objects.select_related('role_type').get(uuid=cuser_role_uuid)
+        if cuser_role.role_type.role_name_en in self.required_groups:
+            return True
+        else:
+            return False
+
+
+class WorkspaceCustomerPermission(permissions.BasePermission):
+    required_groups = [
+        'workspace_owner',
+        'workspace_admin',
+        'workspace_operator',
+        'workspace_customer',
+    ]
+
+    def has_permission(self, request, view):
+        cuser_role_uuid = get_cuser_role_uuid(request)
+        cuser_role = CuserRoleModel.objects.select_related('role_type').get(uuid=cuser_role_uuid)
+        if cuser_role.role_type.role_name_en in self.required_groups:
+            return True
+        else:
+            return False
+
+

utils/get_cuser_role.py

@@ -0,0 +1,15 @@
+from apps.cuser.models import CuserRole as CuserRoleModel
+
+
+def get_cuser_role(request) -> CuserRoleModel:
+    jwt_payload = request.auth.payload
+    cuser_role_uuid = jwt_payload.get('cuser_role_uuid')
+    # use_redis
+    cuser_role = CuserRoleModel.objects.get(uuid=cuser_role_uuid)
+    return cuser_role
+
+
+def get_cuser_role_uuid(request) -> str:
+    jwt_payload = request.auth.payload
+    cuser_role_uuid = jwt_payload.get('cuser_role_uuid')
+    return str(cuser_role_uuid)

utils/get_user_workspace.py

@@ -0,0 +1,24 @@
+from apps.workspace.models import Workspace as WorkspaceModel
+from apps.cuser.models import CuserRole as CuserRoleModel
+from apps.customer.models import CustomerResponsible as CustomerResponsibleModel, Customer as CustomerModel
+
+def get_user_workspace(request) -> WorkspaceModel:
+    jwt_payload = request.auth.payload
+    cuser_role_uuid = jwt_payload.get('cuser_role_uuid')
+    # use_redis
+    cuser_role = CuserRoleModel.objects.get(uuid=cuser_role_uuid)
+    role_type_name = cuser_role.role_type.role_name_en
+
+    if role_type_name == 'workspace_operator':
+        operator = CustomerResponsibleModel.objects.get(cuser_role=cuser_role)
+        workspace = operator.sys_ws
+        return workspace
+    else:
+        customer = CustomerModel.objects.get(cuser_role=cuser_role)
+        return customer.sys_ws
+
+
+def get_user_workspace_uuid(request) -> str:
+    jwt_payload = request.auth.payload
+    workspace_uuid = jwt_payload.get('workspace_uuid')
+    return str(workspace_uuid)

utils/pagination/__init__.py

@@ -0,0 +1 @@
+from .custom_pagination_style_1 import CustomPagination

utils/pagination/custom_pagination_style_1.py

@@ -0,0 +1,16 @@
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
+
+
+class CustomPagination(PageNumberPagination):
+    def get_paginated_response(self, data):
+        return Response({
+            'links': {
+                'next': self.get_next_link(),
+                'next_page': self.page.next_page_number() if self.page.has_next() else None,
+                'previous': self.get_previous_link(),
+                'previous_page': self.page.previous_page_number() if self.page.has_previous() else None
+            },
+            'count': self.page.paginator.count,
+            'results': data
+        })

utils/tools/__init__.py

@@ -0,0 +1,2 @@
+from .inline_serializer import inline_serializer
+from .inline_model_serializer import inline_model_serializer

utils/tools/inline_model_serializer.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+
+
+def create_model_serializer_class(name, meta_fields, fields=None):
+    if fields:
+        meta = type('Meta', (), {'fields': meta_fields} if meta_fields else {})
+        return type(name, (serializers.ModelSerializer,), {'Meta': meta, **fields})
+    else:
+        meta = type('Meta', (), {'fields': meta_fields} if meta_fields else {})
+        return type(name, (serializers.ModelSerializer,), {'Meta': meta})
+
+
+def inline_model_serializer(*, meta_fields, fields=None, data=None, **kwargs):
+
+    serializer_class = create_model_serializer_class(name="inline_model_serializer", fields=fields, meta_fields=meta_fields)
+
+    if data is not None:
+        return serializer_class(data=data, **kwargs)
+
+    return serializer_class(**kwargs)

utils/tools/inline_serializer.py

@@ -0,0 +1,18 @@
+from rest_framework import serializers
+
+
+def create_serializer_class(name, fields):
+    return type(name, (serializers.Serializer,), fields)
+
+
+def inline_serializer(*, fields, data=None, **kwargs):
+    # Important note if you are using `drf-spectacular`
+    # Please refer to the following issue:
+    # https://github.com/HackSoftware/Django-Styleguide/issues/105#issuecomment-1669468898
+    # Since you might need to use unique names (uuids) for each inline serializer
+    serializer_class = create_serializer_class(name="inline_serializer", fields=fields)
+
+    if data is not None:
+        return serializer_class(data=data, **kwargs)
+
+    return serializer_class(**kwargs)

utils/validations/__init__.py

@@ -0,0 +1 @@
+from .object_validation import *

utils/validations/object_validation.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from django.db.models import Model
+from rest_framework import exceptions
+
+class ObjectValidationABC(ABC):
+    @abstractmethod
+    def is_valid(self, object_id) -> bool:
+        pass
+
+
+class ObjectValidationById(ObjectValidationABC):
+
+    def __init__(self, object_model, request):
+        self.object_model = object_model
+        self.request = request
+
+    def is_valid(self, object_id) -> bool:
+        try:
+            result = self.object_model.objects.get(id=object_id)
+            return result
+        except Exception as exp:
+            message = f'Error Validation object: {exp}'
+            raise exceptions.ValidationError({'error': message})
+
+
+