API

class ModerationCommentSerializer(serializers.ModelSerializer):
    comment_url = serializers.SerializerMethodField()
    is_unread = serializers.SerializerMethodField()
    is_modified = serializers.SerializerMethodField()
    last_edit = serializers.SerializerMethodField()
    moderator_feedback = ModeratorCommentFeedbackSerializer(read_only=True)
    num_reports = serializers.SerializerMethodField()
    feedback_api_url = serializers.SerializerMethodField()
    user_name = serializers.SerializerMethodField()
    user_image = serializers.SerializerMethodField()
    user_profile_url = serializers.SerializerMethodField()

    class Meta:
        model = Comment
        fields = [
            "comment",
            "comment_url",
            "feedback_api_url",
            "is_unread",
            "is_blocked",
            "is_moderator_marked",
            "is_modified",
            "last_edit",
            "moderator_feedback",
            "num_reports",
            "pk",
            "user_image",
            "user_name",
            "user_profile_url",
        ]

    def get_comment_url(self, instance):
        return instance.get_absolute_url()

    def get_is_modified(self, comment):
        return comment.modified is not None

    def get_last_edit(self, comment):
        if comment.modified:
            return get_date_display(comment.modified)
        else:
            return get_date_display(comment.created)

    def get_feedback_api_url(self, comment):
        return reverse("moderatorfeedback-list", kwargs={"comment_pk": comment.pk})

    def get_num_reports(self, comment):
        return comment.num_reports

    def get_user_name(self, comment):
        if comment.is_censored or comment.is_removed:
            return _("unknown user")
        return str(comment.creator.username)

    def get_user_image_fallback(self, comment):
        """Load small thumbnail images for default user images."""
        if comment.is_censored or comment.is_removed:
            return None
        try:
            if comment.creator.avatar_fallback:
                return comment.creator.avatar_fallback
        except AttributeError:
            pass
        return None

    def get_user_image(self, comment):
        """Load small thumbnail images for user images."""
        if comment.is_censored or comment.is_removed:
            return None
        try:
            if comment.creator.avatar:
                avatar = get_thumbnailer(comment.creator.avatar)["avatar"]
                return avatar.url
        except AttributeError:
            pass
        return self.get_user_image_fallback(comment)

    def get_user_profile_url(self, comment):
        if comment.is_censored or comment.is_removed:
            return ""
        try:
            return comment.creator.get_absolute_url()
        except AttributeError:
            return ""

    def get_is_unread(self, comment):
        return not comment.is_reviewed

    def update(self, instance, validated_data):
        """Update comment instance without changing comment.modified.

        This is essentially copied from
        rest_framework.serializers.ModelSerializer.update(),
        only difference is ignore_modified=true when saving the instance.
        See also here:
        https://github.com/encode/django-rest-framework/blob/master/rest_framework/serializers.py#L991-L1015
        """
        raise_errors_on_nested_writes("update", self, validated_data)
        info = model_meta.get_field_info(instance)

        # Simply set each attribute on the instance, and then save it.
        # Note that unlike `.create()` we don't need to treat many-to-many
        # relationships as being a special case. During updates we already
        # have an instance pk for the relationships to be associated with.
        m2m_fields = []
        for attr, value in validated_data.items():
            if attr in info.relations and info.relations[attr].to_many:
                m2m_fields.append((attr, value))
            else:
                setattr(instance, attr, value)

        instance.save(ignore_modified=True)

        # Note that many-to-many fields are set after updating instance.
        # Setting m2m fields triggers signals which could potentially change
        # updated instance and we do not want it to collide with .update()
        for attr, value in m2m_fields:
            field = getattr(instance, attr)
            field.set(value)

        return instance

class UserDashboardActivitiesView(UserDashboardBaseMixin):
    template_name = "a4_candy_userdashboard/userdashboard_activities.html"
    menu_item = "overview"

    @property
    def actions(self):
        """Return comment/feedback actions that are  on content the user created.

        Do not return actions on comments for polls and documents to not spam
        initiators.
        """
        user = self.request.user
        comment_actions = (
            Action.objects.filter(
                obj_content_type=ContentType.objects.get_for_model(Comment),
                verb="add",
                target_creator=user,
            )
            .exclude(
                target_content_type__in=[
                    ContentType.objects.get_for_model(Poll),
                    ContentType.objects.get_for_model(Chapter),
                    ContentType.objects.get_for_model(Paragraph),
                ]
            )
            .exclude(
                actor=user,
            )
            .select_related("actor", "project")
            .prefetch_related("obj", "target__creator")
        )

        filtered_comment_actions = [
            action for action in comment_actions if not action.obj.is_blocked
        ]
        feedback_actions = (
            Action.objects.filter(
                obj_content_type=ContentType.objects.get_for_model(
                    ModeratorCommentFeedback
                ),
                obj_comment_creator=user,
            )
            .exclude(actor=user)
            .select_related("project")
            .prefetch_related("obj__comment__creator")
        )

        return sorted(
            filtered_comment_actions + list(feedback_actions),
            key=lambda action: action.timestamp,
            reverse=True,
        )

class UserDashboardBaseMixin(
    LoginRequiredMixin,
    generic.base.ContextMixin,
    generic.base.TemplateResponseMixin,
    generic.base.View,
):
    """
    Adds followed projects and organisations as properties.

    To be used in the user dashboard views, as they all need this info.
    """

    model = User

    def get(self, request):
        response = self.render_to_response(self.get_context_data())
        return response

    @property
    def organisations(self):
        return Organisation.objects.filter(
            project__follow__creator=self.request.user, project__follow__enabled=True
        ).distinct()

    @property
    def projects(self):
        projects = Project.objects.filter(
            follow__creator=self.request.user, follow__enabled=True
        )
        return projects

class UserDashboardOverviewView(UserDashboardBaseMixin):
    template_name = "a4_candy_userdashboard/userdashboard_overview.html"
    menu_item = "overview"

    @property
    def actions(self):
        """Return comment/feedback actions that are  on content the user created.

        Do not return actions on comments for polls and documents to not spam
        initiators.
        """
        user = self.request.user
        comment_actions = (
            Action.objects.filter(
                obj_content_type=ContentType.objects.get_for_model(Comment),
                verb="add",
                target_creator=user,
            )
            .exclude(
                target_content_type__in=[
                    ContentType.objects.get_for_model(Poll),
                    ContentType.objects.get_for_model(Chapter),
                    ContentType.objects.get_for_model(Paragraph),
                ]
            )
            .exclude(actor=user)
            .select_related("actor", "project")
            .prefetch_related("obj", "target__creator")
        )
        filtered_comment_actions = [
            action for action in comment_actions if not action.obj.is_blocked
        ]
        feedback_actions = (
            Action.objects.filter(
                obj_content_type=ContentType.objects.get_for_model(
                    ModeratorCommentFeedback
                ),
                obj_comment_creator=user,
            )
            .exclude(actor=user)
            .select_related("project", "project__organisation")
            .prefetch_related("obj__comment__creator", "obj__comment__content_object")
        )

        return sorted(
            filtered_comment_actions + list(feedback_actions),
            key=lambda action: action.timestamp,
            reverse=True,
        )

    @property
    def projects_carousel(self):
        (
            sorted_active_projects,
            sorted_future_projects,
            sorted_past_projects,
        ) = self.request.user.get_projects_follow_list()
        projects = (
            list(sorted_active_projects)
            + list(sorted_future_projects)
            + list(sorted_past_projects)
        )[:8]

        return projects