absences.py

import graphene
from datetime import datetime

from aleksis.apps.kolego.models import Absence

from .documentation import DocumentationType
from ..models import Documentation, ParticipationStatus

class LessonsForPersonType(graphene.ObjectType):
    id = graphene.ID()  # noqa
    lessons = graphene.List(DocumentationType)

class AbsencesBatchCreateMutation(graphene.Mutation):
    class Arguments:
        persons = graphene.List(graphene.ID)
        start = graphene.Date(),
        end = graphene.Date(),
        comment  = graphene.String(),
        reason = graphene.ID()

    ok = graphene.Boolean()

    @classmethod
    def mutate(cls, root, info, persons, start, end, comment, reason):  # noqa
        # TODO: Check permissions for ParticipationStatus & KolegoAbsence
        #       See MR 356

        # DocumentationBatchCreateOrUpdateMutation.create_or_update
        # at least already checks permissions.

        for person in persons:
            # Get all documentations for this person between start & end
            docs, dummies = Documentation.get_documentations_for_person(
                person,
                datetime.combine(start, datetime.min.time()),
                datetime.combine(end, datetime.max.time()),
            )

            # Create doc for dummies that are already in the past
            future = false
            for dummy in dummies:
                lesson_event, dummy_start, dummy_end = Documentation.parse_dummy(dummy.id)

                if dummy_start < datetime.now():
                    # In the past -> Create a Documentation
                    docs.append(
                        Documentation.create_from_lesson_event(
                            info.context.user,
                            lesson_event,
                            dummy_start,
                            dummy_end,
                        )
                    )
                else:
                    future = true

            # Create a ParticipationStatus for each documentation
            for doc in docs:
                # Set person & absence_reason directly from id
                ParticipationStatus.objects.create(
                    person_id=person,
                    related_documentation=doc,
                    absence_reason_id=reason,
                )

            # If there are still dummy documentations in the future
            # create a Kolego Absence
            if future:
                # TODO: Are date_start & date_end from CalendarEvent enough
                #       or more needed?
                # Set reason & person directly from id
                Absence.objects.create(
                    date_start=datetime.now().date(),
                    date_end=end,
                    reason_id=reason,
                    person_id=person,
                    comment=comment,
                )

        # Return ok=True if everything went well.
        return AbsencesBatchCreateMutation(ok=True)