from django.db import models from django.contrib.auth.models import User from rest_framework import serializers from django.utils import timezone from backend.models.tools import PendingModeration from django.conf import settings from django.contrib.contenttypes.models import ContentType from .myModel import MyModel class MyModelSerializer(serializers.ModelSerializer): moderated_on = serializers.DateTimeField( format="%Y-%m-%d %H:%M:%S", read_only=True) updated_on = serializers.DateTimeField( format="%Y-%m-%d %H:%M:%S", read_only=True) moderated_by = serializers.CharField(read_only=True) updated_by = serializers.CharField(read_only=True) updated_by_username = serializers.SerializerMethodField(read_only=True) def get_updated_by_username(self, obj): if obj.updated_by: return obj.updated_by.username else: return None class Meta: model = MyModel def moderation_required(self): user = self.context['request'].user request = self.context['request'] if user.is_staff: return False if settings.MODERATION_ACTIVATED: if request.method in ['POST', 'PUT']: # should be always the case if is_member('Moderator', request.user): return False else: return True return False def set_model_attr_no_moder(self, moderated_and_updated): user = self.context['request'].user now = timezone.now() self.validated_data['moderated_by'] = user self.validated_data['moderated_on'] = now if moderated_and_updated: self.validated_data['updated_by'] = user self.validated_data['updated_on'] = now def clean_validated_data(self): self.validated_data['moderated_by'] = None self.validated_data['moderated_on'] = None self.validated_data['updated_by'] = None self.validated_data['updated_on'] = None def get_pending_models(self): ct = ContentType.objects.get_for_model(self.Meta.model) return PendingModeration.objects.filter( content_type=ct, object_id=self.instance.pk) def save(self, **kwargs): self.clean_validated_data() if self.moderation_required(): print("Modération requise") user = self.set_model_attr_for_moder() if self.instance is None: # we need to create the main model self.instance = super( MyModelSerializer, self).save(**kwargs) objs_pending_db = self.get_pending_models() user = self.context['request'].user self.clean_validated_data() # Make that it is done... if len(objs_pending_db) > 0: pending_instance = objs_pending_db[0] pending_instance.updated_on = timezone.now() pending_instance.updated_by = user pending_instance.new_object = self.validated_data else: pending_instance = PendingModeration( referenced_object=self.instance, updated_by=user, updated_on=timezone.now(), new_object=self.validated_data ) pending_instance.save() return self.instance else: print("Pas besoin de modération") moderated_and_updated = True if self.instance is None: self.set_model_attr_no_moder(moderated_and_updated) return super(MyModelSerializer, self).save(**kwargs) else: # We check if we don't have any moderation pending objs_pending_db = self.get_pending_models() if len(objs_pending_db) > 0: obj_pending_db = objs_pending_db[0] self.clean_validated_data() # Make that it is done... if obj_pending_db.new_object == self.validated_data: moderated_and_updated = False self.validated_data['updated_by'] = obj_pending_db.updated_by self.validated_data['updated_on'] = obj_pending_db.updated_on objs_pending_db.delete() self.set_model_attr_no_moder(moderated_and_updated) return super(MyModelSerializer, self).save(**kwargs) # class MyModelVersionnedSerializer(MyModelSerializer): # def save(self, **kwargs): # user = self.set_model_attr() # # Create a revision for the update or creation # with reversion.create_revision(): # super(MyModelVersionnedSerializer, self).save(**kwargs) # reversion.set_user(user) # # Signal save to perform concat of revisions # new_revision_saved.send(sender=self.__class__, obj=self.instance)