add product

apps/shop/services/catalog_records.py

@@ -0,0 +1,33 @@
+from django.core.exceptions import ValidationError as ModelValidationError
+from django.db import DataError, IntegrityError
+from django.shortcuts import get_object_or_404
+from rest_framework import exceptions
+from apps.workspace.models import Workspace
+
+
+def validate_catalog_save(record):
+    try:
+        record.full_clean()
+        record.save()
+    except ModelValidationError as error:
+        raise exceptions.ValidationError(error.message_dict if hasattr(error, 'message_dict') else error.messages)
+    except (DataError, IntegrityError):
+        raise exceptions.ValidationError('داده‌ها با محدودیت‌های دیتابیس سازگار نیستند؛ اطلاعات را تازه کنید.')
+    return record
+
+
+def update_catalog_record(model, serializer_type, workspace_uuid, record_id, values):
+    workspace = get_object_or_404(Workspace.objects.select_for_update(), uuid=workspace_uuid)
+    record = get_object_or_404(model.objects.select_for_update(), pk=record_id, sys_ws=workspace)
+    serializer = serializer_type(record, data=values, partial=True, context={'workspace': workspace})
+    serializer.is_valid(raise_exception=True)
+    for key, value in serializer.validated_data.items():
+        setattr(record, key, value)
+    return validate_catalog_save(record)
+
+
+def delete_catalog_record(model, check, workspace_uuid, record_id):
+    workspace = get_object_or_404(Workspace.objects.select_for_update(), uuid=workspace_uuid)
+    record = get_object_or_404(model.objects.select_for_update(), pk=record_id, sys_ws=workspace)
+    check(record)
+    return record.delete()

apps/shop/services/product.py

@@ -1,55 +1,29 @@
+from django.db import transaction
 from apps.shop.models import Product as ProductModel
-from decimal import Decimal
-from rest_framework import exceptions
+from apps.shop.management_serializers import ProductManagementSerializer
+from apps.workspace.models import Workspace
 
 
-def create_product(name: str, price: Decimal, category: int, acc_code: str = None, attr: str = None, workspace=None) -> ProductModel:
-    try:
-        product_obj = ProductModel()
-        product_obj.name = name
-        product_obj.price = price
-        product_obj.category_id = category
-        if acc_code is not None:
-            product_obj.acc_code = acc_code
-        if attr is not None:
-            product_obj.attr = attr
-        product_obj.sys_ws = workspace
-
-        product_obj.full_clean()
-        product_obj.save()
-
-        return product_obj
-
-    except Exception as exp:
-        message = f'Error Create Product: {exp}'
-        exceptions.ValidationError({'error': message})
+from apps.shop.services.catalog_records import validate_catalog_save, update_catalog_record, delete_catalog_record
 
 
-def update_product(product_id: int, name: str, price: Decimal, category: int, acc_code: str = None, attr: str = None, workspace_uuid: str = None) -> ProductModel:
-    try:
-
-        product_obj = ProductModel.objects.get(id=product_id, sys_ws__uuid=workspace_uuid)
-
-        product_obj.name = name
-        product_obj.price = price
-        product_obj.category_id = category
-        if acc_code is not None:
-            product_obj.acc_code = acc_code
-        if attr is not None:
-            product_obj.attr = attr
-        product_obj.full_clean()
-        product_obj.save()
-
-        return product_obj
-    except Exception as exp:
-        message = f'Error Updating Product: {exp}'
-        raise exceptions.ValidationError({'error': message})
+@transaction.atomic
+def create_product(name, price, category, acc_code=None, attr=None, workspace=None, **fields):
+    Workspace.objects.select_for_update().get(pk=workspace.pk)
+    data = dict(name=name, price=price, category=category, acc_code=acc_code, attr=attr, **fields)
+    serializer = ProductManagementSerializer(data=data, context={'workspace': workspace})
+    serializer.is_valid(raise_exception=True)
+    return validate_catalog_save(ProductModel(sys_ws=workspace, **serializer.validated_data))
 
 
-def delete_product(product_id: int, workspace_uuid: str) -> ProductModel:
-    try:
-        product_obj = ProductModel.objects.get(id=product_id, sys_ws__uuid=workspace_uuid).delete()
-        return product_obj
-    except Exception as exp:
-        message = f'Error Deleting Product: {exp}'
-        raise exceptions.ValidationError({'error': message})
+@transaction.atomic
+def update_product(product_id, name=None, price=None, category=None, acc_code=None, attr=None, workspace_uuid=None, **fields):
+    values = {key: value for key, value in dict(name=name, price=price, category=category, acc_code=acc_code, attr=attr).items() if value is not None}
+    values.update(fields)
+    return update_catalog_record(ProductModel, ProductManagementSerializer, workspace_uuid, product_id, values)
+
+
+@transaction.atomic
+def delete_product(product_id, workspace_uuid):
+    from apps.shop.views.management import ensure_product_deletable
+    return delete_catalog_record(ProductModel, ensure_product_deletable, workspace_uuid, product_id)

apps/shop/services/product_category.py

@@ -1,40 +1,29 @@
+from django.db import transaction
 from apps.shop.models import ProductCategory as ProductCategoryModel
-from rest_framework import exceptions
+from apps.shop.management_serializers import CategoryManagementSerializer
+from apps.workspace.models import Workspace
 
 
-def create_product_category(name: str, parent: int = None, workspace=None) -> ProductCategoryModel:
-    try:
-        product_category_obj = ProductCategoryModel(name=name, sys_ws=workspace)
-
-        if parent is not None:
-            product_category_obj.parent_id = parent
-
-        product_category_obj.full_clean()
-        product_category_obj.save()
-
-        return product_category_obj
-
-    except Exception as exp:
-        message = f'Error Create ProductCategory: {exp}'
-        exceptions.ValidationError({'error': message})
+from apps.shop.services.catalog_records import validate_catalog_save, update_catalog_record, delete_catalog_record
 
 
-def update_product_category(category_id: int, name: str, workspace_uuid: str) -> ProductCategoryModel:
-    try:
-        product_category_obj = ProductCategoryModel.objects.get(id=category_id, sys_ws__uuid=workspace_uuid)
-        product_category_obj.name = name
-        product_category_obj.full_clean()
-        product_category_obj.save()
-        return product_category_obj
-    except Exception as exp:
-        message = f'Error Updating ProductCategory: {exp}'
-        raise exceptions.ValidationError({'error': message})
+@transaction.atomic
+def create_product_category(name, parent=None, workspace=None, **fields):
+    Workspace.objects.select_for_update().get(pk=workspace.pk)
+    serializer = CategoryManagementSerializer(data=dict(name=name, parent=parent, **fields), context={'workspace': workspace})
+    serializer.is_valid(raise_exception=True)
+    return validate_catalog_save(ProductCategoryModel(sys_ws=workspace, **serializer.validated_data))
 
 
-def delete_product_category(category_id: int, workspace_uuid: str) -> ProductCategoryModel:
-    try:
-        product_category_obj = ProductCategoryModel.objects.get(id=category_id, sys_ws__uuid=workspace_uuid).delete()
-        return product_category_obj
-    except Exception as exp:
-        message = f'Error Deleting ProductCategory: {exp}'
-        raise exceptions.ValidationError({'error': message})
+@transaction.atomic
+def update_product_category(category_id, name=None, workspace_uuid=None, **fields):
+    values = dict(fields)
+    if name is not None:
+        values['name'] = name
+    return update_catalog_record(ProductCategoryModel, CategoryManagementSerializer, workspace_uuid, category_id, values)
+
+
+@transaction.atomic
+def delete_product_category(category_id, workspace_uuid):
+    from apps.shop.views.management import ensure_category_deletable
+    return delete_catalog_record(ProductCategoryModel, ensure_category_deletable, workspace_uuid, category_id)