utg-base 1.0.1__tar.gz → 1.1.1__tar.gz

{utg_base-1.0.1 → utg_base-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utg-base
-Version: 1.0.1
+Version: 1.1.1
 Summary: UTG Base Package
 Author: Rovshen
 Author-email: rovshenashirov1619@gmail.com

{utg_base-1.0.1 → utg_base-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "utg-base"
-version = "1.0.1"
+version = "1.1.1"
 description = "UTG Base Package"
 authors = ["Rovshen <rovshenashirov1619@gmail.com>"]
 readme = "README.md"

utg_base-1.1.1/src/utg_base/api/base.py

@@ -0,0 +1,75 @@
+from django.utils import timezone
+from django.utils.translation import activate, get_language
+from rest_framework.request import Request
+from rest_framework.views import APIView
+
+from ..models import JWTUser
+
+
+AVAILABLE_LANGUAGES = ['uz', 'ru', 'crl']
+
+
+class BaseRequest(Request):
+
+    @property
+    def user(self) -> JWTUser:
+        return super(BaseRequest, self).user()
+
+
+class BaseAPIView(APIView):
+    user_id_assign_fields_on_create = []
+    user_id_assign_fields_on_update = []
+    user_id_assign_fields_on_delete = []
+    deleted_at_field = None
+
+    def __init__(self, **kwargs):
+        # Check user_id_assign_fields_on_create
+        assert isinstance(self.user_id_assign_fields_on_create, list), (
+            'Expected iterable user_id_assign_fields_on_create field'
+        )
+
+        # Check user_id_assign_fields_on_update
+        assert isinstance(self.user_id_assign_fields_on_update, list), (
+            'Expected iterable user_id_assign_fields_on_update field'
+        )
+
+        # Check user_id_assign_fields_on_delete
+        assert isinstance(self.user_id_assign_fields_on_delete, list), (
+            'Expected iterable user_id_assign_fields_on_delete field'
+        )
+
+        # Check deleted_at_field
+        assert isinstance(self.deleted_at_field, (str, type(None))), (
+            'Expected str | None deleted_at_field field'
+        )
+        super().__init__(**kwargs)
+        self.request: BaseRequest | None = None
+
+    def perform_create(self, serializer):
+        kws = {}
+        for attr in getattr(self, 'user_id_assign_fields_on_create', []):
+            kws[attr] = self.request.user.id
+        serializer.save(**kws)
+
+    def perform_update(self, serializer):
+        kws = {}
+        for attr in getattr(self, 'user_id_assign_fields_on_update', []):
+            kws[attr] = self.request.user.id
+        serializer.save(**kws)
+
+    def perform_destroy(self, instance):
+        for attr in getattr(self, 'user_id_assign_fields_on_delete', []):
+            setattr(instance, attr, self.request.user.id)
+        if self.deleted_at_field and hasattr(instance, self.deleted_at_field):
+            setattr(instance, self.deleted_at_field, timezone.now())
+        instance.save()
+
+    def update_lang(self):
+        activate(self.get_language())
+
+    def get_language(self):
+        if lang_from_header := self.request.headers.get('accept-language'):
+            if lang_from_header and lang_from_header not in AVAILABLE_LANGUAGES:
+                lang_from_header = 'ru'
+
+        return lang_from_header or get_language()

utg_base-1.1.1/src/utg_base/api/views.py

@@ -0,0 +1,13 @@
+
+from django.db.models import Manager
+from rest_framework import generics
+
+from .base import BaseAPIView
+
+
+class TranslatedListView(generics.ListAPIView, BaseAPIView):
+    manager: Manager
+
+    def get_queryset(self):
+        self.update_lang()
+        return self.manager.all()

utg_base-1.1.1/src/utg_base/models/__init__.py

@@ -0,0 +1 @@
+from .jwt_user import JWTUser

utg_base-1.1.1/src/utg_base/models/jwt_user.py

@@ -0,0 +1,11 @@
+from rest_framework_simplejwt.models import TokenUser
+from rest_framework_simplejwt.tokens import Token
+
+
+class JWTUser(TokenUser):
+
+    def __init__(self, token: "Token"):
+        super().__init__(token)
+        self.phone = self.token.get("phone")
+        self._groups = self.token.get("groups")
+        self.should_cache_requests = self.token.get("should_cache_requests")

utg_base-1.1.1/src/utg_base/references_api/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

utg_base-1.1.1/src/utg_base/references_api/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class ReferencesApiConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'utg_base.references_api'

utg_base-1.1.1/src/utg_base/references_api/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

utg_base-1.1.1/src/utg_base/references_api/urls.py

@@ -0,0 +1,13 @@
+from .utils import get_model_classes, create_view_set, get_basename, get_url_prefix
+from ..api.routers import OptionalSlashRouter
+
+router = OptionalSlashRouter()
+
+for model_class in get_model_classes():
+    router.register(
+        prefix=get_url_prefix(model_class),
+        viewset=create_view_set(model_class),
+        basename=get_basename(model_class)
+    )
+
+urlpatterns = router.urls

utg_base-1.1.1/src/utg_base/references_api/utils.py

@@ -0,0 +1,181 @@
+import importlib
+from urllib.parse import urlparse
+
+import inflect
+from django.conf import settings
+from django.db.models import Model, CharField
+from drf_spectacular.utils import extend_schema, extend_schema_serializer
+from rest_framework import filters
+from rest_framework import viewsets, serializers
+
+from ..api.views import TranslatedListView
+
+serializer_classes = {}
+
+
+def find_model(model_name: str):
+    for model_class in get_model_classes():
+        if get_model_class_name(model_class).lower() == model_name.lower():
+            return model_class
+
+
+def get_api_meta_property(model: Model, property_name: str):
+    if hasattr(model, 'ApiMeta'):
+        if hasattr(model.ApiMeta, property_name):
+            return getattr(model.ApiMeta, property_name)
+
+
+def get_model_class_name(model: Model):
+    return model._meta.object_name
+
+
+def get_model_fields_list(model: Model):
+    return model._meta.get_fields()
+
+
+def get_view_set_name(model: Model):
+    return get_model_class_name(model) + 'ViewSet'
+
+
+def get_basename(model: Model):
+    return 'admin-' + get_plural_form(get_model_class_name(model).lower())
+
+
+def camel_to_snake(name: str):
+    return ''.join(map(lambda c: '-' + c.lower() if c.isupper() else c, name)).removeprefix('-')
+
+
+def get_url_prefix(model: Model):
+    return 'admin/' + get_plural_form(camel_to_snake(get_model_class_name(model))).replace(' ', '-')
+
+
+def get_plural_form(word: str):
+    p = inflect.engine()
+    return p.plural(word)
+
+
+def get_serializer_name(model: Model):
+    return get_model_class_name(model) + 'Serializer'
+
+
+def get_ordering(model: Model):
+    if model._meta.ordering:
+        return model._meta.ordering
+    if hasattr(model, 'created_at'):
+        return ('-created_at',)
+    if hasattr(model, 'id'):
+        return ('id',)
+    return ()
+
+
+def get_model_classes():
+    model_classes = []
+    for model_import_path in settings.REFERENCE_API_MODELS:
+        module_name, class_name = model_import_path.rsplit('.', 1)
+        module = importlib.import_module(module_name)
+        model_classes.append(getattr(module, class_name))
+
+    return model_classes
+
+
+def create_view_set(model: Model):
+    fields_list = get_model_fields_list(model)
+
+    @extend_schema(tags=[get_url_prefix(model)])
+    class ViewSet(viewsets.ModelViewSet, TranslatedListView):
+        http_method_names = get_api_meta_property(model, 'http_method_names') or ['get', 'patch']
+        manager = model.objects.order_by(*get_ordering(model))
+        filter_backends = [filters.SearchFilter]
+        search_fields = (get_api_meta_property(model, 'search_fields') or
+                         [field.name for field in fields_list if isinstance(field, CharField)])
+
+        def get_serializer_class(self):
+            if self.action == 'create':
+                return create_serializer_for_create(model)
+
+            if self.action == 'partial_update':
+                return create_serializer_for_partial_update(model)
+
+            return create_serializer(model)
+
+    return ViewSet
+
+
+def create_serializer_for_create(model: Model):
+    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    class Serializer(serializers.ModelSerializer):
+        class Meta:
+            fields = '__all__'
+
+    Serializer.Meta.model = model
+    return Serializer
+
+
+def create_serializer_for_partial_update(model: Model):
+    fields_list = get_model_fields_list(model)
+
+    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    class Serializer(serializers.ModelSerializer):
+        class Meta:
+            fields = '__all__'
+            read_only_fields = list(
+                {
+                    'created_at',
+                    'updated_at',
+                    'deleted_at',
+                    'created_by',
+                    'updated_by',
+                    'deleted_by',
+                    'code'
+                } & set([field.name for field in fields_list])
+            )
+
+    Serializer.Meta.model = model
+    return Serializer
+
+
+def create_serializer(model: Model, depth=0):
+    if get_model_class_name(model) in serializer_classes:
+        return serializer_classes[get_model_class_name(model)]
+
+    fields_list = get_model_fields_list(model)
+
+    class ImageNameField(serializers.ImageField):
+        def to_representation(self, value):
+            if not value:
+                return None
+            parsed_url = urlparse(value.url)
+            return f'{parsed_url.path}?{parsed_url.query}'
+
+    @extend_schema_serializer(component_name='Admin' + get_serializer_name(model))
+    class Serializer(serializers.ModelSerializer):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            nonlocal model, fields_list
+            for field in fields_list:
+                if field.__class__.__name__.endswith('ImageField') or field.__class__.__name__.endswith('FileField'):
+                    self.fields[field.name] = ImageNameField()
+
+                if field.__class__.__name__.endswith('ForeignKey'):
+                    model_name = field.name
+                    _model = find_model(model_name)
+                    if _model is not None and depth == 0:
+                        self.fields[model_name] = create_serializer(_model, depth + 1)()
+
+        class Meta:
+            fields = '__all__'
+            read_only_fields = list(
+                {
+                    'created_at',
+                    'updated_at',
+                    'deleted_at',
+                    'created_by',
+                    'updated_by',
+                    'deleted_by',
+                    'code'
+                } & set([field.name for field in fields_list])
+            )
+
+    Serializer.Meta.model = model
+    serializer_classes[get_model_class_name(model)] = Serializer
+    return Serializer