Initial commit from ZIP

This commit is contained in:
kusz committed 2024-11-27 13:18:16 +01:00
commit 378d4692a9
454 files changed
+40367

No files matched your search

@@ -0,0 +1,5 @@
from .brief_item_photo import BriefItemPhotoSerializer
from .brief_item import BriefItemSerializer
from .brief_item_choice import BriefItemChoiceSerializer
from .brief import BriefSerializer
from .category import CategorySerializer
+159
View File
@@ -0,0 +1,159 @@
from typing import TYPE_CHECKING
from rest_framework import serializers
from rest_framework.exceptions import PermissionDenied
from outbo.apps.photobriefing.enums import ChoiceRole
from outbo.apps.photobriefing.models import Brief, BriefItemChoice
from outbo.apps.photobriefing.rules import can_complete_brief, can_publish_brief
from outbo.apps.photobriefing.serializers import (
BriefItemSerializer,
BriefItemChoiceSerializer,
)
if TYPE_CHECKING:
from outbo.apps.authentication.models import User
class BaseBriefSerializer(serializers.ModelSerializer):
class Meta:
model = Brief
def get_editable(self, instance: Brief):
current_user = self.context["request"].user
return instance.editable_for_user(user=current_user)
def get_acceptable(self, instance: Brief):
current_user = self.context["request"].user
return instance.acceptable_for_user(user=current_user)
def get_publishable(self, instance: Brief):
current_user = self.context["request"].user
return instance.publishable_for_user(user=current_user)
def get_completable(self, instance: Brief):
current_user = self.context["request"].user
return instance.completable_for_user(user=current_user)
class BriefSerializer:
class Retrieve(BaseBriefSerializer):
items = BriefItemSerializer.List(many=True)
choices = BriefItemChoiceSerializer.List(many=True)
editable = serializers.SerializerMethodField()
acceptable = serializers.SerializerMethodField()
publishable = serializers.SerializerMethodField()
completable = serializers.SerializerMethodField()
class Meta(BaseBriefSerializer.Meta):
fields = [
"stage",
"session_date",
"concept_description",
"items",
"choices",
"created_at",
"updated_at",
"editable",
"acceptable",
"publishable",
"completable",
]
class Update(BaseBriefSerializer):
publish = serializers.BooleanField()
complete = serializers.BooleanField()
choice = BriefItemChoiceSerializer.Update(partial=False)
items = BriefItemSerializer.Create(many=True)
class Meta(BaseBriefSerializer.Meta):
fields = [
"session_date",
"concept_description",
"items",
"choice",
"publish",
"complete",
]
def update(self, instance, validated_data):
if validated_data.get("choice", None) is not None:
serializer = BriefSerializer.ChoiceUpdate(context=self.context)
return serializer.update(instance, {"choice": validated_data["choice"]})
if validated_data.get("publish", None) is not None:
serializer = BriefSerializer.Publish(context=self.context)
return serializer.update(
instance, {"publish": validated_data["publish"]}
)
if validated_data.get("complete", None) is not None:
serializer = BriefSerializer.Complete(context=self.context)
return serializer.update(
instance, {"complete": validated_data["complete"]}
)
items = validated_data.pop("items", None)
if items:
for item in items:
item["brief"] = instance
BriefItemSerializer.Create(context=self.context).create(item)
return super().update(instance=instance, validated_data=validated_data)
class Publish(BaseBriefSerializer):
publish = serializers.BooleanField()
class Meta(BaseBriefSerializer.Meta):
fields = ["publish"]
def update(self, instance, validated_data):
publish = validated_data["publish"]
current_user = self.context["request"].user
if not can_publish_brief.test(current_user, instance):
raise PermissionDenied()
if publish:
instance.publish_as_user(user=current_user)
instance.save()
return instance
class Complete(BaseBriefSerializer):
complete = serializers.BooleanField()
class Meta(BaseBriefSerializer.Meta):
fields = ["complete"]
def update(self, instance: Brief, validated_data):
complete = validated_data["complete"]
current_user = self.context["request"].user
if not can_complete_brief.test(current_user, instance):
raise PermissionDenied()
if complete:
instance.complete_as_user(user=current_user)
instance.save()
return instance
class ChoiceUpdate(BaseBriefSerializer):
choice = BriefItemChoiceSerializer.Update()
class Meta(BaseBriefSerializer.Meta):
fields = ["choice"]
def update(self, instance, validated_data):
choice = validated_data["choice"]
current_user: "User" = self.context["request"].user
if current_user.is_supplier:
role = ChoiceRole.SUPPLIER
elif current_user.is_client:
role = ChoiceRole.CLIENT
else:
raise NotImplemented
current_choice, _ = BriefItemChoice.objects.get_or_create(
defaults={"item": choice["item"]},
brief=instance,
category=choice["category"],
role=role,
)
if current_choice.item != choice["item"]:
current_choice.item = choice["item"]
current_choice.save()
return instance
@@ -0,0 +1,38 @@
from rest_framework import serializers
from outbo.apps.photobriefing.models import BriefItem
from outbo.apps.photobriefing.serializers import BriefItemPhotoSerializer
class BaseBriefItemSerializer(serializers.ModelSerializer):
class Meta:
model = BriefItem
class BriefItemSerializer:
class List(BaseBriefItemSerializer):
photos = BriefItemPhotoSerializer.List(many=True)
class Meta(BaseBriefItemSerializer.Meta):
fields = ["id", "category", "title", "description", "photos"]
class Create(BaseBriefItemSerializer):
photos = BriefItemPhotoSerializer.Create(many=True)
class Meta(BaseBriefItemSerializer.Meta):
fields = ["category", "title", "description", "photos"]
def create(self, validated_data):
photos = validated_data.pop("photos", None)
instance = super().create(validated_data)
if photos is not None:
for photo in photos:
photo["item"] = instance
BriefItemPhotoSerializer.Create().create(photo)
return instance
class AfterCreate(BaseBriefItemSerializer):
photos = BriefItemPhotoSerializer.List(many=True)
class Meta(BaseBriefItemSerializer.Meta):
fields = ["id", "category", "title", "description", "photos"]
@@ -0,0 +1,30 @@
from rest_framework import serializers
from outbo.apps.photobriefing.enums import ChoiceRole
from outbo.apps.photobriefing.models import BriefItemChoice
class BaseBriefItemChoiceSerializer(serializers.ModelSerializer):
class Meta:
model = BriefItemChoice
class BriefItemChoiceSerializer:
class List(BaseBriefItemChoiceSerializer):
role = serializers.SerializerMethodField()
class Meta(BaseBriefItemChoiceSerializer.Meta):
fields = ["category", "item", "role"]
def get_role(self, instance):
role = eval(instance.role) # TODO: eval is evil
if role is ChoiceRole.SUPPLIER:
return "supplier"
if role is ChoiceRole.CLIENT:
return "client"
raise NotImplementedError
class Update(BaseBriefItemChoiceSerializer):
class Meta:
model = BriefItemChoice
fields = ["category", "item"]
@@ -0,0 +1,23 @@
from rest_framework import serializers
from outbo.apps.photobriefing.models import BriefItemPhoto
class BaseBriefItemPhotoSerializer(serializers.ModelSerializer):
class Meta:
model = BriefItemPhoto
class BriefItemPhotoSerializer:
class Create(BaseBriefItemPhotoSerializer):
class Meta(BaseBriefItemPhotoSerializer.Meta):
fields = ["file"]
class List(BaseBriefItemPhotoSerializer):
url = serializers.HyperlinkedIdentityField(
view_name="photobriefing:briefitemphoto-detail", read_only=True
)
filename = serializers.ReadOnlyField()
class Meta(BaseBriefItemPhotoSerializer.Meta):
fields = ["url", "filename"]
@@ -0,0 +1,10 @@
from rest_framework import serializers
from outbo.apps.photobriefing.models import Category
class CategorySerializer:
class List(serializers.ModelSerializer):
class Meta:
model = Category
fields = ["label", "description"]