Initial commit from ZIP

evg-outbo-api/outbo/apps/products/serializers/__init__.py

@@ -0,0 +1,13 @@
+from .photo import PhotoSerializer
+from .blanking import BlankingSerializer
+from .brief_config import BriefConfigSerializer
+from .brief import BriefSerializer
+from .product import ProductSerializer
+from .packaging_type import PackagingTypeSerializer
+from .product_stage import ProductStageSerializer
+from .design_stage_file import (
+    DraftFileSerializer,
+    FirstFinalFileSerializer,
+    PrintingFilesFileSerializer,
+)
+from .design_stage import DraftSerializer, FirstFinalSerializer, PrintingFilesSerializer

evg-outbo-api/outbo/apps/products/serializers/blanking.py

@@ -0,0 +1,19 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import Blanking
+
+
+class BlankingSerializer:
+    class Create(serializers.ModelSerializer):
+        class Meta:
+            model = Blanking
+            fields = ["file"]
+
+    class List(serializers.ModelSerializer):
+        url = serializers.HyperlinkedIdentityField(view_name="products:blanking-detail")
+        filename = serializers.ReadOnlyField()
+        size = serializers.ReadOnlyField()
+
+        class Meta:
+            model = Blanking
+            fields = ["id", "filename", "url", "size"]

evg-outbo-api/outbo/apps/products/serializers/brief.py

@@ -0,0 +1,267 @@
+from outbo.apps.products.models import Brief, Photo, Blanking
+from outbo.apps.products.serializers import (
+    PhotoSerializer,
+    BlankingSerializer,
+    BriefConfigSerializer,
+)
+from rest_framework import serializers
+from rest_framework.exceptions import PermissionDenied
+
+
+class BaseBriefSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Brief
+
+
+class BriefSerializer:
+    class Retrieve(BaseBriefSerializer):
+        photos = PhotoSerializer.List(many=True)
+        blankings = BlankingSerializer.List(many=True)
+        config = BriefConfigSerializer.Retrieve()
+        editable = serializers.SerializerMethodField()
+        acceptable = serializers.SerializerMethodField()
+        publishable = serializers.SerializerMethodField()
+
+        class Meta(BaseBriefSerializer.Meta):
+            fields = [
+                "config",
+                "name_pol",
+                "name_eng",
+                "model_no",
+                "batch_no",
+                "ean",
+                "packaging_type",
+                "main_description",
+                "extra_description",
+                "photos",
+                "blankings",
+                "certificate",
+                "information_signs",
+                "capabilities_icons",
+                "product_icons",
+                "has_description_eng",
+                "has_description_pol",
+                "has_description_por",
+                "has_description_rus",
+                "has_description_spa",
+                "illustration",
+                "cleaning_method",
+                "country_of_origin",
+                "manual",
+                "material",
+                "warning",
+                "arrangement_photo",
+                "packshot",
+                "clipping",
+                "extra_photo",
+                "editable",
+                "acceptable",
+                "publishable",
+                "created_at",
+                "updated_at",
+            ]
+
+        def get_editable(self, brief: Brief):
+            return brief.editable_for_user(user=self.context["request"].user)
+
+        def get_acceptable(self, brief: Brief):
+            return brief.acceptable_for_user(user=self.context["request"].user)
+
+        def get_publishable(self, brief: Brief):
+            return brief.publishable_for_user(user=self.context["request"].user)
+
+    class Publish(BaseBriefSerializer):
+        publish = serializers.BooleanField()
+
+        class Meta(BaseBriefSerializer.Meta):
+            fields = ["publish"]
+
+        def validate(self, attrs):
+            instance: "Brief" = self.instance
+            if not instance.publishable_for_user(user=self.context["request"].user):
+                raise PermissionDenied()
+            return super().validate(attrs)
+
+        def update(self, instance: "Brief", validated_data):
+            members = [m.user for m in instance.product.project.members.all()]
+            current_user = self.context["request"].user
+
+            product = instance.product
+            product.publish_brief_as_user(user=current_user)
+            product.send_action_emails_for_users_passing_test(
+                test=lambda u: u in members and u.is_agency,
+                action_url="https://outbo.pl/projects/{id}/products/{pid}",
+            )
+            product.save()
+            return instance
+
+    class Accept(BaseBriefSerializer):
+        accept = serializers.BooleanField()
+
+        class Meta(BaseBriefSerializer.Meta):
+            fields = ["accept"]
+
+        def validate(self, attrs):
+            instance: "Brief" = self.instance
+            if not instance.acceptable_for_user(user=self.context["request"].user):
+                raise PermissionDenied()
+            return super().validate(attrs)
+
+        def update(self, instance: "Brief", validated_data):
+            current_user = self.context["request"].user
+            product = instance.product
+            if validated_data["accept"] is True:
+                product.accept_brief_as_user(user=current_user)
+            elif validated_data["accept"] is False:
+                product.reject_brief_as_user(user=current_user)
+            product.save()
+            return instance
+
+    class Clone(BaseBriefSerializer):
+        clone_from = serializers.IntegerField()
+
+        class Meta(BaseBriefSerializer.Meta):
+            fields = ["clone_from"]
+
+        def update(self, instance: "Brief", validated_data):
+            clone_from = validated_data.pop("clone_from", None)
+            if clone_from is not None:
+                clone_from = Brief.objects.get(pk=clone_from)
+                clonable_fields = [
+                    "packaging_type",
+                    "main_description",
+                    "extra_description",
+                    "certificate",
+                    "information_signs",
+                    "capabilities_icons",
+                    "product_icons",
+                    "has_description_eng",
+                    "has_description_pol",
+                    "has_description_por",
+                    "has_description_rus",
+                    "has_description_spa",
+                    "illustration",
+                    "cleaning_method",
+                    "country_of_origin",
+                    "manual",
+                    "material",
+                    "warning",
+                    "arrangement_photo",
+                    "packshot",
+                    "clipping",
+                    "extra_photo",
+                ]
+                clonable_config_fields = [
+                    "illustration",
+                    "cleaning_method",
+                    "country_of_origin",
+                    "manual",
+                    "material",
+                    "warning",
+                    "photobrief",
+                    "packshot",
+                    "clipping",
+                    "extra_photo",
+                ]
+                for item in clonable_config_fields:
+                    setattr(instance.config, item, getattr(clone_from.config, item))
+                for item in clonable_fields:
+                    setattr(instance, item, getattr(clone_from, item))
+                instance.config.save()
+                instance.save()
+                return instance
+
+    class Update(BaseBriefSerializer):
+        accept = serializers.BooleanField()
+        clone_from = serializers.IntegerField()
+
+        publish = serializers.BooleanField()
+
+        config = BriefConfigSerializer.Update()
+        photos = PhotoSerializer.Create(many=True)
+        blankings = BlankingSerializer.Create(many=True)
+
+        class Meta(BaseBriefSerializer.Meta):
+            fields = [
+                "clone_from",
+                "accept",
+                "publish",
+                "config",
+                "name_pol",
+                "name_eng",
+                "model_no",
+                "batch_no",
+                "ean",
+                "packaging_type",
+                "main_description",
+                "extra_description",
+                "photos",
+                "blankings",
+                "certificate",
+                "information_signs",
+                "capabilities_icons",
+                "product_icons",
+                "has_description_eng",
+                "has_description_pol",
+                "has_description_por",
+                "has_description_rus",
+                "has_description_spa",
+                "illustration",
+                "cleaning_method",
+                "country_of_origin",
+                "manual",
+                "material",
+                "warning",
+                "arrangement_photo",
+                "packshot",
+                "clipping",
+                "extra_photo",
+            ]
+
+        def update(self, instance: Brief, validated_data):
+            if validated_data.get("clone_from", None) is not None:
+                serializer = BriefSerializer.Clone(
+                    instance=instance, data=validated_data, context=self.context
+                )
+                serializer.is_valid(raise_exception=True)
+                return serializer.update(
+                    instance=instance, validated_data=validated_data
+                )  # NOTE: looks weird
+
+            if validated_data.get("accept", None) is not None:
+                serializer = BriefSerializer.Accept(
+                    instance=instance, data=validated_data, context=self.context
+                )
+                serializer.is_valid(raise_exception=True)
+                return serializer.update(
+                    instance=instance, validated_data=validated_data
+                )  # NOTE: looks weird
+
+            if validated_data.get("publish", None) is not None:
+                serializer = BriefSerializer.Publish(
+                    instance=instance, data=validated_data, context=self.context
+                )
+                serializer.is_valid(raise_exception=True)
+                return serializer.update(
+                    instance=instance, validated_data=validated_data
+                )  # NOTE: looks weird
+
+            config = validated_data.pop("config", None)
+
+            photos = validated_data.pop("photos", [])
+            blankings = validated_data.pop("blankings", [])
+
+            for photo in photos:
+                Photo.objects.create(brief=instance, **photo)
+            for blanking in blankings:
+                Blanking.objects.create(brief=instance, **blanking)
+
+            if config:
+                for (key, value) in config.items():
+                    setattr(instance.config, key, value)
+                instance.config.save()
+
+            result = super().update(instance=instance, validated_data=validated_data)
+            product = result.product
+            product.save()  # bump updated_at
+            return result

evg-outbo-api/outbo/apps/products/serializers/brief_config.py

@@ -0,0 +1,33 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import BriefConfig
+
+
+class _BaseBriefConfigSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = BriefConfig
+        fields = [
+            "illustration",
+            "cleaning_method",
+            "country_of_origin",
+            "manual",
+            "material",
+            "warning",
+            "photobrief",
+            "packshot",
+            "clipping",
+            "extra_photo",
+        ]
+
+
+class BriefConfigSerializer:
+    class Retrieve(_BaseBriefConfigSerializer):
+        class Meta(_BaseBriefConfigSerializer.Meta):
+            fields = _BaseBriefConfigSerializer.Meta.fields + [
+                "created_at",
+                "updated_at",
+            ]
+
+    class Update(_BaseBriefConfigSerializer):
+        class Meta(_BaseBriefConfigSerializer.Meta):
+            pass

evg-outbo-api/outbo/apps/products/serializers/design_stage.py

@@ -0,0 +1,159 @@
+from typing import Union
+
+from rest_framework import serializers
+from rest_framework.exceptions import PermissionDenied
+
+from outbo.apps.products.models import Draft, PrintingFiles, FirstFinal
+from outbo.apps.products.serializers import (
+    DraftFileSerializer,
+    FirstFinalFileSerializer,
+    PrintingFilesFileSerializer,
+)
+
+
+class DesignStageSerializer(serializers.ModelSerializer):
+    class Retrieve(serializers.ModelSerializer):
+        acceptable = serializers.SerializerMethodField()
+        editable = serializers.SerializerMethodField()
+
+        class Meta:
+            fields = ["acceptable", "editable", "files", "created_at", "updated_at"]
+
+        def get_acceptable(self, instance: Union[Draft, FirstFinal, PrintingFiles]):
+            return instance.acceptable_for_user(user=self.context["request"].user)
+
+        def get_editable(self, instance: Union[Draft, FirstFinal, PrintingFiles]):
+            return instance.editable_for_user(user=self.context["request"].user)
+
+    class Accept(serializers.ModelSerializer):
+        accept = serializers.BooleanField()
+
+        class Meta:
+            fields = ["accept"]
+
+    class Update(serializers.ModelSerializer):
+        accept = serializers.BooleanField()
+
+        class Meta:
+            fields = ["accept"]
+
+
+class DraftSerializer:
+    class Retrieve(DesignStageSerializer.Retrieve):
+        files = DraftFileSerializer.Retrieve(many=True)
+
+        class Meta(DesignStageSerializer.Retrieve.Meta):
+            model = Draft
+
+    class Accept(DesignStageSerializer.Accept):
+        class Meta(DesignStageSerializer.Accept.Meta):
+            model = Draft
+
+        def validate(self, attrs):
+            instance: "Draft" = self.instance
+            if not instance.acceptable_for_user(user=self.context["request"].user):
+                raise PermissionDenied()
+            return super().validate(attrs)
+
+        def update(self, instance: "Draft", validated_data):
+            current_user = self.context["request"].user
+            product = instance.product
+            if validated_data["accept"] is True:
+                product.accept_draft_as_user(user=current_user)
+            product.save()
+            return instance
+
+    class Update(DesignStageSerializer.Update):
+        class Meta(DesignStageSerializer.Update.Meta):
+            model = Draft
+
+        def update(self, instance: Draft, validated_data):
+            serializer = DraftSerializer.Accept(
+                instance=instance, data=validated_data, context=self.context
+            )
+            serializer.is_valid(raise_exception=True)
+            return serializer.update(
+                instance=instance, validated_data=validated_data
+            )  # NOTE: looks weird
+
+
+class FirstFinalSerializer:
+    class Retrieve(DesignStageSerializer.Retrieve):
+        files = FirstFinalFileSerializer.Retrieve(many=True)
+
+        class Meta(DesignStageSerializer.Retrieve.Meta):
+            model = FirstFinal
+
+    class Accept(DesignStageSerializer.Accept):
+        class Meta(DesignStageSerializer.Accept.Meta):
+            model = FirstFinal
+
+        def validate(self, attrs):
+            instance: "FirstFinal" = self.instance
+            if not instance.acceptable_for_user(user=self.context["request"].user):
+                raise PermissionDenied()
+            return super().validate(attrs)
+
+        def update(self, instance: "FirstFinal", validated_data):
+            current_user = self.context["request"].user
+            product = instance.product
+            if validated_data["accept"] is True:
+                product.accept_ff_as_user(user=current_user)
+            elif validated_data["accept"] is False:
+                product.reject_ff_as_user(user=current_user)
+            product.save()
+            return instance
+
+    class Update(DesignStageSerializer.Update):
+        class Meta(DesignStageSerializer.Update.Meta):
+            model = FirstFinal
+
+        def update(self, instance: FirstFinal, validated_data):
+            serializer = FirstFinalSerializer.Accept(
+                instance=instance, data=validated_data, context=self.context
+            )
+            serializer.is_valid(raise_exception=True)
+            return serializer.update(
+                instance=instance, validated_data=validated_data
+            )  # NOTE: looks weird
+
+
+class PrintingFilesSerializer:
+    class Retrieve(DesignStageSerializer.Retrieve):
+        files = PrintingFilesFileSerializer.Retrieve(many=True)
+
+        class Meta(DesignStageSerializer.Retrieve.Meta):
+            model = PrintingFiles
+
+    class Accept(DesignStageSerializer.Accept):
+        class Meta(DesignStageSerializer.Accept.Meta):
+            model = PrintingFiles
+
+        def validate(self, attrs):
+            instance: "PrintingFiles" = self.instance
+            if not instance.acceptable_for_user(user=self.context["request"].user):
+                raise PermissionDenied()
+            return super().validate(attrs)
+
+        def update(self, instance: "PrintingFiles", validated_data):
+            current_user = self.context["request"].user
+            product = instance.product
+            if validated_data["accept"] is True:
+                product.accept_pf_as_user(user=current_user)
+            elif validated_data["accept"] is False:
+                product.reject_pf_as_user(user=current_user)
+            product.save()
+            return instance
+
+    class Update(DesignStageSerializer.Update):
+        class Meta(DesignStageSerializer.Update.Meta):
+            model = PrintingFiles
+
+        def update(self, instance: PrintingFiles, validated_data):
+            serializer = PrintingFilesSerializer.Accept(
+                instance=instance, data=validated_data, context=self.context
+            )
+            serializer.is_valid(raise_exception=True)
+            return serializer.update(
+                instance=instance, validated_data=validated_data
+            )  # NOTE: looks weird

evg-outbo-api/outbo/apps/products/serializers/design_stage_file.py

@@ -0,0 +1,150 @@
+from typing import TYPE_CHECKING
+
+from rest_framework import serializers
+
+from outbo.apps.products.models import DraftFile, FirstFinalFile, PrintingFilesFile
+
+if TYPE_CHECKING:
+    from outbo.apps.authentication.models import User
+
+
+class DesignStageFileSerializer:
+    class Retrieve(serializers.ModelSerializer):
+        class Meta:
+            fields = [
+                "id",
+                "url",
+                "filename",
+                "size",
+                "version",
+                "description",
+                "created_by",
+                "created_at",
+                "updated_at",
+                "opened_by",
+            ]
+
+        filename = serializers.ReadOnlyField()
+        size = serializers.ReadOnlyField()
+
+    class Create(serializers.ModelSerializer):
+        class Meta:
+            fields = ["file", "description"]
+
+        def save(self, **kwargs):
+            created_by = self.context["request"].user
+            kwargs["created_by"] = created_by
+            return super().save(**kwargs)
+
+
+class BaseDraftFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = DraftFile
+
+
+class BaseFirstFinalFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = FirstFinalFile
+
+
+class BasePrintingFilesFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PrintingFilesFile
+
+
+class DraftFileSerializer:
+    class Retrieve(DesignStageFileSerializer.Retrieve):
+        class Meta(
+            DesignStageFileSerializer.Retrieve.Meta, BaseDraftFileSerializer.Meta
+        ):
+            pass
+
+        url = serializers.HyperlinkedIdentityField(
+            view_name="products:draftfile-detail"
+        )
+
+    class Create(DesignStageFileSerializer.Create):
+        class Meta(DesignStageFileSerializer.Create.Meta, BaseDraftFileSerializer.Meta):
+            pass
+
+        def create(self, validated_data):
+            current_user: "User" = self.context["request"].user
+            result: DraftFile = super().create(validated_data)
+
+            draft = result.draft
+            draft.save()
+
+            product = draft.product
+            product.publish_draft_file_as_user(user=current_user)
+
+            product.save()
+            product.project.save()
+
+            return result
+
+
+class FirstFinalFileSerializer:
+    class Retrieve(DesignStageFileSerializer.Retrieve):
+        class Meta(
+            DesignStageFileSerializer.Retrieve.Meta, BaseFirstFinalFileSerializer.Meta
+        ):
+            pass
+
+        url = serializers.HyperlinkedIdentityField(
+            view_name="products:firstfinalfile-detail"
+        )
+
+    class Create(DesignStageFileSerializer.Create):
+        class Meta(
+            DesignStageFileSerializer.Create.Meta, BaseFirstFinalFileSerializer.Meta
+        ):
+            pass
+
+        def create(self, validated_data):
+            current_user = self.context["request"].user
+            result: DraftFile = super().create(validated_data)
+
+            ff = result.first_final
+            ff.save()
+
+            product = ff.product
+            product.publish_ff_file_as_user(user=current_user)
+
+            product.save()
+            product.project.save()
+
+            return result
+
+
+class PrintingFilesFileSerializer:
+    class Retrieve(DesignStageFileSerializer.Retrieve):
+        class Meta(
+            DesignStageFileSerializer.Retrieve.Meta,
+            BasePrintingFilesFileSerializer.Meta,
+        ):
+            pass
+
+        url = serializers.HyperlinkedIdentityField(
+            view_name="products:printingfilesfile-detail"
+        )
+
+    class Create(DesignStageFileSerializer.Create):
+        class Meta(
+            DesignStageFileSerializer.Create.Meta, BasePrintingFilesFileSerializer.Meta
+        ):
+            pass
+
+        def create(self, validated_data):
+            current_user = self.context["request"].user
+            result: PrintingFilesFile = super().create(validated_data)
+
+            pf = result.printing_files
+            pf.save()
+
+            product = pf.product
+            product.publish_pf_file_as_user(user=current_user)
+
+            product.save()
+            product.project.save()
+
+            return result

evg-outbo-api/outbo/apps/products/serializers/packaging_type.py

@@ -0,0 +1,10 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import PackagingType
+
+
+class PackagingTypeSerializer:
+    class List(serializers.ModelSerializer):
+        class Meta:
+            model = PackagingType
+            fields = ["id", "name"]

evg-outbo-api/outbo/apps/products/serializers/photo.py

@@ -0,0 +1,22 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import Photo
+
+
+class PhotoSerializer:
+    class Create(serializers.ModelSerializer):
+        class Meta:
+            model = Photo
+            fields = ["file"]
+
+    class List(serializers.ModelSerializer):
+        filename = serializers.ReadOnlyField()
+        url = serializers.HyperlinkedIdentityField(view_name="products:photo-detail")
+
+        class Meta:
+            model = Photo
+            fields = [
+                "id",
+                "url",
+                "filename",
+            ]

evg-outbo-api/outbo/apps/products/serializers/product.py

@@ -0,0 +1,47 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import Product
+
+
+class BaseProductSerializer(serializers.ModelSerializer):
+    brief = serializers.HyperlinkedRelatedField(
+        view_name="products:brief-detail", read_only=True
+    )
+
+    draft = serializers.HyperlinkedRelatedField(
+        view_name="products:draft-detail", read_only=True
+    )
+    first_final = serializers.HyperlinkedRelatedField(
+        view_name="products:firstfinal-detail", read_only=True
+    )
+    printing_files = serializers.HyperlinkedRelatedField(
+        view_name="products:printingfiles-detail", read_only=True
+    )
+    photo_brief = serializers.HyperlinkedRelatedField(
+        view_name="photobriefing:brief-detail", read_only=True
+    )
+    display_name = serializers.ReadOnlyField()
+
+    class Meta:
+        model = Product
+        fields = [
+            "display_name",
+            "project",
+            "stage",
+            "brief",
+            "draft",
+            "first_final",
+            "printing_files",
+            "photo_brief",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class ProductSerializer:
+    class Retrieve(BaseProductSerializer):
+        pass
+
+    class List(BaseProductSerializer):
+        class Meta(BaseProductSerializer.Meta):
+            fields = ["id"] + BaseProductSerializer.Meta.fields

evg-outbo-api/outbo/apps/products/serializers/product_stage.py

@@ -0,0 +1,16 @@
+from rest_framework import serializers
+
+from outbo.apps.products.models import ProductStage
+
+
+class ProductStageSerializer:
+    class List(serializers.ModelSerializer):
+        class Meta:
+            model = ProductStage
+            fields = [
+                "id",
+                "label",
+                "group",
+                "description",
+                "next_action",
+            ]