Merge branch 'main' into issue-3911issue-3911

1 files changed, 1944 insertions, 0 deletions

diff --git a/lib/models/resources/ResourceBooking.php b/lib/models/resources/ResourceBooking.php
new file mode 100644
index 0000000..977cf32
--- /dev/null
+++ b/lib/models/resources/ResourceBooking.php
@@ -0,0 +1,1944 @@
+<?php
+
+/**
+ * ResourceBooking.php - model class for resource bookings
+ *
+ * The ResourceBooking class is responsible for storing
+ * bookings of resources in a specified time range
+ * or a time interval.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * @author      Moritz Strohm <strohm@data-quest.de>
+ * @copyright   2017-2019
+ * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
+ * @category    Stud.IP
+ * @package     resources
+ * @since       4.5
+ *
+ * The repetition_interval column contains a date interval string in a
+ * format that is accepted by the DateInterval class constructor.
+ * Examples for values of the repetition_interval column:
+ * - For an one month interval, the value is "P1M".
+ * - For an interval of two days, the value is "P2D".
+ * See the DateInterval documentation for more examples:
+ * https://secure.php.net/manual/en/class.dateinterval.php
+ *
+ * @property string $id database column
+ * @property string $resource_id database column
+ * @property string $range_id database column
+ * @property string|null $description database column
+ * @property int $begin database column
+ * @property int $end database column
+ * @property int|null $repeat_end database column
+ * @property int $mkdate database column
+ * @property int $chdate database column
+ * @property string|null $internal_comment database column
+ * @property int $preparation_time database column
+ * @property int $booking_type database column
+ * @property string $booking_user_id database column
+ * @property string $repetition_interval database column
+ * @property SimpleORMapCollection|ResourceBookingInterval[] $time_intervals has_many ResourceBookingInterval
+ * @property Resource $resource belongs_to Resource
+ * @property User $assigned_user belongs_to User
+ * @property CourseDate $assigned_course_date belongs_to CourseDate
+ * @property User $booking_user belongs_to User
+ * @property mixed $course_id additional field
+ * @property mixed $room_name additional field
+ * @property-read mixed $real_begin additional field
+ * @property-read mixed $real_begin_dt additional field
+ */
+class ResourceBooking extends SimpleORMap implements PrivacyObject, Studip\Calendar\EventSource
+{
+    const TYPE_NORMAL = 0;
+    const TYPE_RESERVATION = 1;
+    const TYPE_LOCK = 2;
+    const TYPE_PLANNED = 3;
+
+    protected static function configure($config = [])
+    {
+        $config['db_table'] = 'resource_bookings';
+
+        $config['belongs_to']['resource'] = [
+            'class_name' => Resource::class,
+            'foreign_key' => 'resource_id',
+            'assoc_func' => 'find'
+        ];
+        $config['belongs_to']['assigned_user'] = [
+            'class_name' => User::class,
+            'foreign_key' => 'range_id',
+            'assoc_func' => 'find'
+        ];
+        $config['belongs_to']['assigned_course_date'] = [
+            'class_name' => CourseDate::class,
+            'foreign_key' => 'range_id',
+            'assoc_func' => 'find'
+        ];
+        $config['has_many']['time_intervals'] = [
+            'class_name' => ResourceBookingInterval::class,
+            'assoc_foreign_key' => 'booking_id',
+            'on_delete' => 'delete'
+        ];
+        $config['belongs_to']['booking_user'] = [
+            'class_name' => User::class,
+            'foreign_key' => 'booking_user_id',
+            'assoc_func' => 'find'
+        ];
+
+        $config['additional_fields']['course_id'] = ['assigned_course_date', 'range_id'];
+        $config['additional_fields']['room_name'] = ['resource', 'name'];
+
+        $config['additional_fields']['real_begin'] = [
+            'get' => function (ResourceBooking $booking) {
+                return $booking->begin - $booking->preparation_time;
+            }
+        ];
+        $config['additional_fields']['real_begin_dt'] = [
+            'get' => function (ResourceBooking $booking) {
+                $real_begin = new DateTime();
+                $real_begin->setTimestamp($booking->real_begin);
+                return $real_begin;
+            }
+        ];
+
+        $config['registered_callbacks']['after_store'][] = 'updateIntervals';
+        $config['registered_callbacks']['after_store'][] = 'createStoreLogEntry';
+        $config['registered_callbacks']['after_delete'][] = 'sendDeleteNotification';
+        $config['registered_callbacks']['after_delete'][] = 'createDeleteLogEntry';
+
+        //In regard to TIC 6460:
+        //As long as TIC 6460 is not implemented, we must add the validate
+        //method as a callback before storing the object.
+        if (!method_exists('SimpleORMap', 'validate')) {
+            $config['registered_callbacks']['before_store'][] = 'validate';
+        }
+
+        parent::configure($config);
+    }
+
+    private $assigned_user_type;
+
+    public function createStoreLogEntry()
+    {
+        if ($this->isSimpleBooking()) {
+            StudipLog::log(
+                'RES_ASSIGN_SINGLE',
+                $this->resource_id,
+                null,
+                $this->__toString(),
+                null,
+                $GLOBALS['user']->id
+            );
+        } else {
+            StudipLog::log(
+                'RES_ASSIGN_SEM',
+                $this->resource_id,
+                $this->course_id,
+                $this->__toString(),
+                null,
+                $GLOBALS['user']->id
+            );
+        }
+    }
+
+
+    public function createDeleteLogEntry()
+    {
+        if ($this->isSimpleBooking()) {
+            StudipLog::log(
+                'RES_ASSIGN_DEL_SINGLE',
+                $this->resource_id,
+                null,
+                $this->__toString(),
+                null,
+                $GLOBALS['user']->id
+            );
+        } else {
+            StudipLog::log(
+                'RES_ASSIGN_DEL_SEM',
+                $this->resource_id,
+                $this->course_id,
+                $this->__toString(),
+                null,
+                $GLOBALS['user']->id
+            );
+        }
+    }
+
+
+    /**
+     * Internal method that generated the SQL query used in
+     * findByResourceAndTimeRanges and countByResourceAndTimeRanges.
+     *
+     * @see findByResourceAndTimeRanges
+     * @inheritDoc
+     */
+    protected static function buildResourceAndTimeRangesSqlQuery(
+        Resource $resource,
+        $time_ranges = [],
+        $booking_types = [],
+        $excluded_booking_ids = []
+    )
+    {
+        if (!is_array($time_ranges)) {
+            throw new InvalidArgumentException(
+                _('Es wurde keine Liste mit Zeiträumen angegeben!')
+            );
+        }
+
+        //Check the array:
+        foreach ($time_ranges as $time_range) {
+            if ($time_range['begin'] > $time_range['end']) {
+                throw new InvalidArgumentException(
+                    _('Der Startzeitpunkt darf nicht hinter dem Endzeitpunkt liegen!')
+                );
+            }
+
+            if ($time_range['begin'] == $time_range['end']) {
+                throw new InvalidArgumentException(
+                    _('Startzeitpunkt und Endzeitpunkt dürfen nicht identisch sein!')
+                );
+            }
+        }
+
+        $sql_params = [
+            'resource_id' => $resource->id
+        ];
+
+        //First we build the SQL snippet for the case that the $booking_type
+        //variable is set to something different than null.
+        $booking_type_sql = '';
+        if (is_array($booking_types) && count($booking_types)) {
+            $booking_type_sql = ' AND booking_type IN ( :booking_types )';
+            $sql_params['booking_types'] = $booking_types;
+        }
+
+        //Then we build the snippet for excluded booking IDs, if specified.
+        $excluded_booking_ids_sql = '';
+        if (is_array($excluded_booking_ids) && count($excluded_booking_ids)) {
+            $excluded_booking_ids_sql = ' AND resource_booking_intervals.booking_id NOT IN ( :excluded_ids ) ';
+            $sql_params['excluded_ids'] = $excluded_booking_ids;
+        }
+
+        //Now we build the SQL snippet for the time intervals.
+        //These are repeated four times in the query below.
+        //First we use one template ($time_sql_template) and
+        //replace NUMBER with our counting variable $i.
+        //BEGIN and END are replaced below since the columns for
+        //BEGIN and END are different in the four cases where we
+        //repeat the SQL snippet for the time intervals.
+        $time_sql_template = '
+            (resource_booking_intervals.begin < :endNUMBER AND :beginNUMBER < resource_booking_intervals.end)
+            ';
+
+        $time_sql = '';
+        if ($time_ranges) {
+            $time_sql = ' AND (';
+
+            $i = 1;
+            foreach ($time_ranges as $time_range) {
+                if ($i > 1) {
+                    $time_sql .= ' OR ';
+                }
+                $time_sql .= str_replace(
+                    'NUMBER',
+                    $i,
+                    $time_sql_template
+                );
+
+                if ($time_range['begin'] instanceof DateTime) {
+                    $sql_params[('begin' . $i)] = $time_range['begin']->getTimestamp();
+                } else {
+                    $sql_params[('begin' . $i)] = $time_range['begin'];
+                }
+                if ($time_range['end'] instanceof DateTime) {
+                    $sql_params[('end' . $i)] = $time_range['end']->getTimestamp();
+                } else {
+                    $sql_params[('end' . $i)] = $time_range['end'];
+                }
+
+                $i++;
+            }
+
+            $time_sql .= ') ';
+        }
+
+        //Check if the booking has a start and end timestamp set
+        //or if it has repetitions that have a matching timestamp.
+        //This is done in the rest of the SQL query:
+
+        $whole_sql = "resource_bookings.id IN (
+                    SELECT resource_booking_intervals.booking_id FROM resource_booking_intervals WHERE
+                    resource_booking_intervals.resource_id = :resource_id
+                    AND resource_booking_intervals.takes_place = 1"
+                    . $excluded_booking_ids_sql
+                    . $time_sql
+                    . " GROUP BY resource_booking_intervals.booking_id ORDER BY NULL)
+                    $booking_type_sql
+";
+
+        return [
+            'sql' => $whole_sql,
+            'params' => $sql_params
+        ];
+    }
+
+
+    /**
+     * Retrieves all resource booking for the given resource and
+     * time range. By default, all booking are returned.
+     * To get only bookings of a certain type
+     * set the $booking_type parameter.
+     *
+     * @param Resource $resource The resource whose requests shall be retrieved.
+     * @param array $time_ranges An array with time ranges as DateTime objects.
+     *     The array has the following structure:
+     *     [
+     *         [
+     *             'begin' => begin timestamp,
+     *             'end' => end timestamp
+     *         ],
+     *         ...
+     *     ]
+     * @param array $booking_types An optional specification for the
+     *     booking_type column in the database. More than one booking
+     *     type can be specified.
+     *     By default this is set to an empty array which means
+     *     that resource booking are not filtered by the type column.
+     *     The allowed resource booking types are specified in the
+     *     class documentation.
+     *
+     * @param array $excluded_booking_ids An array of strings representing
+     *     resource booking IDs. IDs specified in this array are excluded
+     *     from the search.
+     * @return ResourceBooking[] An array of ResourceRequest objects.
+     *     If no requests can be found, the array is empty.
+     *
+     * @throws InvalidArgumentException, if the time ranges are either not in an
+     *     array matching the format description from above or if one of the
+     *     following conditions is met in one of the time ranges:
+     *     - begin > end
+     *     - begin == end
+     */
+    public static function findByResourceAndTimeRanges(
+        Resource $resource,
+        $time_ranges = [],
+        $booking_types = [],
+        $excluded_booking_ids = []
+    )
+    {
+        //Build the SQL query and the parameter array.
+
+        $sql_data = self::buildResourceAndTimeRangesSqlQuery(
+            $resource,
+            $time_ranges,
+            $booking_types,
+            $excluded_booking_ids
+        );
+
+        //Call findBySql:
+        return self::findBySql($sql_data['sql'], $sql_data['params']);
+    }
+
+
+    /**
+     * Counts all resource bookings for the specified resource and
+     * time range. By default, all bookings are counted.
+     * To count only bookings of a certain type
+     * set the $booking_type parameter.
+     *
+     * @see findByResourceAndTimeRanges
+     * @inheritDoc
+     */
+    public static function countByResourceAndTimeRanges(
+        Resource $resource,
+        $time_ranges = [],
+        $booking_types = [],
+        $excluded_booking_ids = []
+    )
+    {
+        //Build the SQL query and the parameter array.
+
+        $sql_data = self::buildResourceAndTimeRangesSqlQuery(
+            $resource,
+            $time_ranges,
+            $booking_types,
+            $excluded_booking_ids
+        );
+
+        //Call countBySql:
+        return self::countBySql($sql_data['sql'], $sql_data['params']);
+    }
+
+
+    /**
+     * Deletes all resource bookings for the specified resource and
+     * time range. By default, all bookings are counted.
+     * To count only bookings of a certain type
+     * set the $booking_type parameter.
+     *
+     * @see findByResourceAndTimeRanges
+     * @inheritDoc
+     */
+    public static function deleteByResourceAndTimeRanges(
+        Resource $resource,
+        $time_ranges = [],
+        $booking_types = [],
+        $excluded_booking_ids = []
+    )
+    {
+        //Build the SQL query and the parameter array.
+        $sql_data = self::buildResourceAndTimeRangesSqlQuery(
+            $resource,
+            $time_ranges,
+            $booking_types,
+            $excluded_booking_ids
+        );
+
+        //Call deleteBySql:
+        return self::deleteBySql($sql_data['sql'], $sql_data['params']);
+    }
+
+
+    /**
+     * The SimpleORMap::store method is overloaded to allow forced booking
+     * of resource bookings, meaning that all other bookings of the
+     * resource of a booking are deleted when they overlap with this booking.
+     *
+     * @param bool $force_booking Whether booking shall be forced (true)
+     *     or not (false). Defaults to false.
+     * @return bool
+     */
+    public function store($force_booking = false)
+    {
+        if ($force_booking == true) {
+            $this->deleteOverlappingBookings();
+        }
+        $this->deleteOverlappingReservations();
+
+        if (parent::store()) {
+            //Check if the booking is bound to a course date.
+            //If this is the case, check for existing bookings
+            //and delete them, so that there is only one booking
+            //for a course date:
+            $course_date_exists = CourseDate::exists($this->range_id);
+            if ($course_date_exists) {
+                self::deleteBySql(
+                    'range_id = :range_id AND id <> :this_id',
+                    [
+                        'this_id' => $this->id,
+                        'range_id' => $this->range_id
+                    ]
+                );
+            }
+            return true;
+        }
+        return false;
+    }
+
+
+    /**
+     * This validation method is called before storing an object.
+     */
+    public function validate()
+    {
+        if ((!$this->resource_id) || !($this->resource instanceof Resource)) {
+            throw new InvalidArgumentException(
+                _('Es wurde keine Ressource zur Buchung angegeben!')
+            );
+        }
+
+        if (!$this->range_id && !$this->description) {
+            throw new ResourceBookingRangeException(
+                _('Es muss eine Person oder ein Text zur Buchung eingegeben werden!')
+            );
+        }
+
+        if ($this->begin >= $this->end) {
+            throw new InvalidArgumentException(
+                _('Der Startzeitpunkt darf nicht hinter dem Endzeitpunkt liegen!')
+            );
+        }
+
+        if ($this->repetition_interval) {
+            if (!$this->repeat_end) {
+                throw new InvalidArgumentException(
+                    _('Es wurde ein Wiederholungsintervall ohne Begrenzung angegeben!')
+                );
+            }
+            if ($this->real_begin > $this->repeat_end) {
+                throw new InvalidArgumentException(
+                    _('Der Startzeitpunkt darf nicht hinter dem Ende der Wiederholungen liegen!')
+                );
+            }
+        }
+
+        // update the booking user
+        if (!$this->isNew() || !$this->booking_user_id) {
+            $this->booking_user = User::findCurrent();
+        }
+
+        $derived_resource = $this->resource->getDerivedClassInstance();
+
+        // check if the user needs booking rights on the resource
+        if (
+            $this->isFieldDirty('resource_id')
+            || $this->isFieldDirty('repetition_interval')
+            || $this->begin < $this->getPristineValue('begin')
+            || $this->end > $this->getPristineValue('end')
+            || $this->preparation_time > $this->getPristineValue('preparation_time')
+            || $this->repeat_end > $this->getPristineValue('repeat_end')
+        ) {
+
+            //Check if the user has booking rights on the resource.
+            //The user must have either permanent permissions or they have to
+            //have booking rights by a temporary permission in this moment
+            $user_has_booking_rights = $derived_resource->userHasBookingRights(
+                $this->booking_user, $this->begin, $this->end
+            );
+            if (!$user_has_booking_rights) {
+                throw new ResourcePermissionException(
+                    sprintf(
+                        _('Unzureichende Berechtigungen zum Buchen der Ressource %s!'),
+                        $this->resource->name
+                    )
+                );
+            }
+        }
+
+        $time_intervals = $this->calculateTimeIntervals(true);
+        $time_interval_overlaps = [];
+        $existing_deleted_intervals = [];
+        if (!$this->isNew()) {
+            $existing_deleted_intervals = array_filter(
+                $this->getTimeIntervals(),
+                function ($i): bool {
+                    return !$i->takes_place;
+                }
+            );
+        }
+        foreach ($time_intervals as $time_interval) {
+            foreach ($existing_deleted_intervals as $deleted_interval) {
+                if (
+                    $time_interval['begin']->getTimestamp() == $deleted_interval['begin']
+                    && $time_interval['end']->getTimestamp() == $deleted_interval['end']
+                ) {
+                    continue 2;
+                }
+            }
+            $is_locked = $derived_resource->isLocked(
+                $time_interval['begin'],
+                $time_interval['end'],
+                ($this->isNew() ? [] : [$this->id])
+            );
+            if ($is_locked) {
+                if ($time_interval['begin']->format('Ymd') == $time_interval['end']->format('Ymd')) {
+                    $time_interval_overlaps[] = sprintf(
+                        _('Gesperrt im Bereich vom %1$s bis %2$s'),
+                        $time_interval['begin']->format('d.m.Y H:i'),
+                        $time_interval['end']->format('H:i')
+                    );
+                } else {
+                    $time_interval_overlaps[] = sprintf(
+                        _('Gesperrt im Bereich vom %1$s bis zum %2$s'),
+                        $time_interval['begin']->format('d.m.Y H:i'),
+                        $time_interval['end']->format('d.m.Y H:i')
+                    );
+                }
+            } else {
+                $is_assigned = $derived_resource->isAssigned(
+                    $time_interval['begin'],
+                    $time_interval['end'],
+                    ($this->isNew() ? [] : [$this->id])
+                );
+                if ($is_assigned) {
+                    //Find the other booking:
+                    $other_booking = self::findByResourceAndTimeRanges(
+                        $derived_resource,
+                        [$time_interval],
+                        [self::TYPE_NORMAL, self::TYPE_LOCK],
+                        [$this->id]
+                    );
+                    $course = null;
+                    if (
+                        count($other_booking) >= 1
+                        && !empty($other_booking[0]->assigned_course_date->course)
+                    ) {
+                        $course = $other_booking[0]->assigned_course_date->course;
+                    }
+                    if ($time_interval['begin']->format('Ymd') == $time_interval['end']->format('Ymd')) {
+                        if ($course) {
+                            $time_interval_overlaps[] = sprintf(
+                                    _('Gebucht im Bereich vom %1$s bis %2$s durch die Veranstaltung %3$s.'),
+                                    $time_interval['begin']->format('d.m.Y H:i'),
+                                    $time_interval['end']->format('H:i'),
+                                    $course->getFullName()
+                                );
+                        } else {
+                            $time_interval_overlaps[] = sprintf(
+                                _('Gebucht im Bereich vom %1$s bis %2$s'),
+                                $time_interval['begin']->format('d.m.Y H:i'),
+                                $time_interval['end']->format('H:i')
+                            );
+                        }
+                    } else {
+                        if ($course) {
+                            $time_interval_overlaps[] = sprintf(
+                                    _('Gebucht im Bereich vom %1$s bis zum %2$s durch die Veranstaltung %3$s.'),
+                                    $time_interval['begin']->format('d.m.Y H:i'),
+                                    $time_interval['end']->format('d.m.Y H:i'),
+                                    $course->getFullName()
+                                );
+                        } else {
+                            $time_interval_overlaps[] = sprintf(
+                                _('Gebucht im Bereich vom %1$s bis zum %2$s'),
+                                $time_interval['begin']->format('d.m.Y H:i'),
+                                $time_interval['end']->format('d.m.Y H:i')
+                            );
+                        }
+                    }
+                }
+            }
+        }
+        if ($time_interval_overlaps) {
+            throw new ResourceBookingOverlapException(
+                implode(', ', $time_interval_overlaps)
+            );
+        }
+
+        NotificationCenter::postNotification('ResourceBookingWillValidate', $this);
+    }
+
+
+    /**
+     * This method updates the intervals of this resource booking
+     * which are stored in the resource_booking_intervals table.
+     */
+    public function updateIntervals($keep_exceptions = true)
+    {
+        if ($keep_exceptions) {
+            //Delete all intervals with takes_place > 0
+            //and update the time intervals of the exceptions:
+            ResourceBookingInterval::deleteBySql(
+                "booking_id = :booking_id
+                AND
+                takes_place > '0'",
+                [
+                    'booking_id' => $this->id
+                ]
+            );
+
+            //Get all interval exceptions:
+            $exceptions = ResourceBookingInterval::findBySql(
+                "booking_id = :booking_id
+                AND
+                takes_place < '1'",
+                [
+                    'booking_id' => $this->id
+                ]
+            );
+
+            if ($exceptions) {
+                //Now we must compare the time intervals of the booking
+                //with the time intervals of the exceptions.
+                //If there is only a difference in hours we update
+                //the exceptions. Otherwise we delete the exceptions.
+
+                $repetition_interval = $this->getRepetitionInterval();
+                if (!$repetition_interval) {
+                    //No repetition interval also means nothing left to do.
+                    return;
+                }
+
+                $repetition_begin = new DateTime();
+                $repetition_begin->setTimestamp($this->begin - $this->preparation_time);
+                $date_end = new DateTime();
+                $date_end->setTimestamp($this->end);
+                $repetition_end = new DateTime();
+                $repetition_end->setTimestamp($this->repeat_end);
+                $repetition_interval = $this->getRepetitionInterval();
+
+                $duration = $repetition_begin->diff($date_end);
+
+                //Loop over all exceptions and check if they belong to
+                //one of the repetions:
+
+                $obsolete_exception_ids = [];
+                foreach ($exceptions as $exception) {
+                    $exception_begin = new DateTime();
+                    $exception_begin->setTimestamp($exception->begin);
+                    $exception_end = new DateTime();
+                    $exception_end->setTimestamp($exception->end);
+                    $exc_begin_str = $exception_begin->format('Y-m-d');
+                    $exc_end_str = $exception_end->format('Y-m-d');
+
+                    $exception_obsolete = true;
+
+                    $current_repetition = clone $repetition_begin;
+                    while ($current_repetition < $repetition_end) {
+                        $current_end = clone $current_repetition;
+                        $current_end->add($duration);
+
+                        $current_begin_str = $current_repetition->format('Y-m-d');
+                        $current_end_str = $current_end->format('Y-m-d');
+
+                        if ($current_begin_str == $exc_begin_str && $current_end_str == $exc_end_str) {
+                            //We found one exception which needs to be updated.
+                            $exception_obsolete = false;
+                            $exception->begin = $current_repetition->getTimestamp();
+                            $exception->end = $current_end->getTimestamp();
+                            if ($exception->isDirty()) {
+                                $exception->store();
+                            }
+                            //No need to loop the rest of the repetitions:
+                            break;
+                        }
+
+                        $current_repetition->add($repetition_interval);
+                    }
+
+                    if ($exception_obsolete) {
+                        $obsolete_exception_ids[] = $exception->id;
+                    }
+                }
+
+                if ($obsolete_exception_ids) {
+                    ResourceBookingInterval::deleteBySql(
+                        'interval_id IN ( :ids )',
+                        [
+                            'ids' => $obsolete_exception_ids
+                        ]
+                    );
+                }
+            }
+        } else {
+            //We delete all existing intervals for this booking
+            //and re-create them.
+            ResourceBookingInterval::deleteBySql(
+                'booking_id = :booking_id',
+                [
+                    'booking_id' => $this->id
+                ]
+            );
+        }
+
+        ResourceBookingInterval::createFromBooking($this);
+    }
+
+
+    /**
+     * Deletes the ResourceBooking object if there are no
+     * ResourceBookingInterval objects attachted to it.
+     *
+     * @return null|bool If the ResourceBooking object still has
+     *     ResourceBookingInterval objects attachted to it,
+     *     null is returned. Otherwise the return value of the
+     *     SimpleORMap::delete method for the ResourceBooking object
+     *     is returned.
+     */
+    public function deleteIfNoInterval()
+    {
+        $intervals = ResourceBookingInterval::countBySql(
+            'booking_id = :id',
+            [
+                'id' => $this->id
+            ]
+        );
+        if ($intervals == 0) {
+            return $this->delete();
+        }
+
+        return null;
+    }
+
+
+    /**
+     * Deletes all bookings in the time ranges of this resource booking.
+     * Such bookings would prevent saving this booking.
+     *
+     * @return int The amount of deleted bookings.
+     */
+    public function deleteOverlappingBookings()
+    {
+        $end = new DateTime();
+        $end->setTimestamp($this->end);
+        $repetition_end = new DateTime();
+        $repetition_end->setTimestamp($this->repeat_end);
+
+        $deleted_c = 0;
+        if ($this->repetition_interval) {
+            $repetition_interval = $this->getRepetitionInterval();
+
+            if (!$this->repeat_end) {
+                throw new InvalidArgumentException(
+                    _('Es wurde ein Wiederholungsintervall ohne Begrenzung angegeben!')
+                );
+            }
+            if ($this->real_begin > $this->repeat_end) {
+                throw new InvalidArgumentException(
+                    _('Der Startzeitpunkt darf nicht hinter dem Ende der Wiederholungen liegen!')
+                );
+            }
+
+            //Look in each repetition for overlapping bookings and delete them.
+            $current_date = $this->real_begin_dt;
+            while ($current_date <= $repetition_end) {
+                $current_begin = clone $current_date;
+                $current_end = clone $current_date;
+                $current_end->setTime(
+                    intval($end->format('H')),
+                    intval($end->format('i')),
+                    intval($end->format('s'))
+                );
+                $derived_resource = $this->resource->getDerivedClassInstance();
+                if ($derived_resource->userHasPermission($this->booking_user, 'tutor', [$current_begin, $current_end])) {
+                    //Sufficient permissions to delete bookings
+                    //in the time frame.
+                    $delete_sql = 'begin < :end AND end > :begin AND resource_id = :resource_id ';
+                    $sql_params = [
+                        'begin' => $current_begin->getTimestamp(),
+                        'end' => $current_end->getTimestamp(),
+                        'resource_id' => $this->resource->id
+                    ];
+                    if (!$this->isNew()) {
+                        $delete_sql .= 'booking_id <> :booking_id';
+                        $sql_params['booking_id'] = $this->id;
+                    }
+                    $intervals = ResourceBookingInterval::findBySQL(
+                        $delete_sql,
+                        $sql_params
+                    );
+
+                    $affected_bookings = [];
+                    foreach ($intervals as $interval) {
+                        if ($interval->booking instanceof ResourceBooking) {
+                            $affected_bookings[$interval->booking_id] = $interval->booking;
+                        }
+                        $deleted_c += $interval->delete();
+                    }
+
+                    foreach ($affected_bookings as $booking) {
+                        $booking->deleteIfNoInterval();
+                    }
+                }
+                $current_date = $current_date->add($repetition_interval);
+            }
+        } else {
+            $derived_resource = $this->resource->getDerivedClassInstance();
+            if ($derived_resource->userHasPermission($this->booking_user, 'autor', [$this->real_begin_dt, $end])) {
+                $delete_sql = 'begin < :end AND end > :begin AND resource_id = :resource_id ';
+                $sql_params = [
+                    'begin' => $this->real_begin,
+                    'end' => $end->getTimestamp(),
+                    'resource_id' => $this->resource->id
+                ];
+                if (!$this->isNew()) {
+                    $delete_sql .= 'booking_id <> :booking_id';
+                    $sql_params['booking_id'] = $this->id;
+                }
+                $intervals = ResourceBookingInterval::findBySQL(
+                    $delete_sql,
+                    $sql_params
+                );
+                $affected_bookings = [];
+                foreach ($intervals as $interval) {
+                    if ($interval->booking instanceof ResourceBooking) {
+                        $affected_bookings[$interval->booking_id] = $interval->booking;
+                    }
+                    $deleted_c += $interval->delete();
+                }
+
+                foreach ($affected_bookings as $booking) {
+                    $booking->deleteIfNoInterval();
+                }
+            }
+        }
+
+        return $deleted_c;
+    }
+
+
+    /**
+     * Deletes all reservations in the time ranges of this resource booking.
+     *
+     * @return int The amount of deleted reservations.
+     */
+    public function deleteOverlappingReservations()
+    {
+        //Notify all persons who made reservations or who are assigned
+        //to the reservation about the new booking which overwrites
+        //their reservation:
+        $booking_resource = Resource::find($this->resource_id);
+        $booking_user = User::find($this->booking_user_id);
+
+        $deleted_c = 0;
+
+        $template_factory = new Flexi\Factory(
+            $GLOBALS['STUDIP_BASE_PATH'] . '/locale/'
+        );
+
+        $affected_reservations =  ResourceBooking::findByResourceAndTimeRanges(
+            $booking_resource,
+            [
+                [
+                    'begin' => $this->real_begin,
+                    'end' => $this->end,
+                ]
+            ],
+            [self::TYPE_RESERVATION, self::TYPE_PLANNED],
+            [$this->id]
+        );
+        foreach ($affected_reservations as $reservation) {
+            if ($reservation->id == $this->id) {
+                continue;
+            }
+            if ($reservation->assigned_user && (
+                $reservation->range_id != $reservation->booking_user_id
+            )) {
+                //Inform the person who is assigned to the reservation:
+                setTempLanguage($reservation->assigned_user->id);
+                $lang_path = getUserLanguagePath($reservation->assigned_user->id);
+
+                $template = $template_factory->open(
+                    $lang_path . '/LC_MAILS/overbooked_reservation.php'
+                );
+                $template->set_attribute('resource', $booking_resource);
+                $template->set_attribute('reservation', $reservation);
+                $template->set_attribute('booking_user', $booking_user);
+                $mail_text = $template->render();
+
+                Message::send(
+                    User::findCurrent()->id,
+                    [$reservation->assigned_user->username],
+                    _('Reservierung überbucht'),
+                    $mail_text
+                );
+
+                restoreLanguage();
+            }
+            if ($reservation->booking_user) {
+                //Inform the person who made the reservation:
+                setTempLanguage($reservation->booking_user->id);
+                $lang_path = getUserLanguagePath($reservation->booking_user->id);
+
+                $template = $template_factory->open(
+                    $lang_path . '/LC_MAILS/overbooked_reservation.php'
+                );
+                $template->set_attribute('resource', $booking_resource);
+                $template->set_attribute('reservation', $reservation);
+                $template->set_attribute('booking_user', $booking_user);
+                $mail_text = $template->render();
+
+                Message::send(
+                    User::findCurrent()->id,
+                    [$reservation->booking_user->username],
+                    _('Reservierung überbucht'),
+                    $mail_text
+                );
+
+                restoreLanguage();
+            }
+
+            //Delete the reservation:
+            $deleted_c += $reservation->delete();
+        }
+        return $deleted_c;
+    }
+
+
+    /**
+     * Determines whether the resource booking ends on the same timestamp
+     * like the lecture time of one of the defined semesters.
+     *
+     * @return True, if the resource booking ends with a semester,
+     *     false otherwise.
+     */
+    public function endsWithSemester()
+    {
+        return Semester::countBySql(
+            '(beginn <= :begin) AND (ende >= :begin)
+             AND vorles_ende = :repeat_end',
+            [
+                'begin' => $this->begin,
+                'repeat_end' => $this->repeat_end
+            ]
+        ) > 0;
+    }
+
+
+    /**
+     * Check if the specified user is the owner of the booking.
+     *
+     * @param User $user The user whose ownership shall be tested.
+     *
+     * @return bool True, if the specified user is the owner of the booking,
+     *     false otherwise.
+     */
+    public function userIsOwner(User $user)
+    {
+        return $this->booking_user_id == $user->id;
+    }
+
+
+    /**
+     * Determines wheter the booking is read only for a specified user.
+     *
+     * @param User $user The user whose permissions shall be checked.
+     *
+     * @return bool True, if the specified user may only perform reading
+     *     actions on the booking, false otherwise.
+     */
+    public function isReadOnlyForUser(User $user)
+    {
+        if ($this->isSimpleBooking()) {
+            //In case it is a simple booking, one has to be
+            //either resource tutor or the owner of the request.
+            if ($this->userIsOwner($user)) {
+                return false;
+            }
+            //Still no answer? Check, if the user is resource tutor.
+            $derived_resource = $this->resource->getDerivedClassInstance();
+            return !$derived_resource->userHasPermission($user, 'tutor');
+        }
+        //Non-simple bookings (course bookings etc.) are always read-only.
+        return true;
+    }
+
+
+    /**
+     * Determines whether this resource booking has a repetition in the
+     * specified time range.
+     * @param DateTime $begin
+     * @param DateTime $end
+     * @return bool True, if the booking has repetitions in the timeframe
+     * specified by $begin and $end, false otherwise.
+     */
+    public function isRepetitionInTimeframe(DateTime $begin, DateTime $end)
+    {
+        return ResourceBookingInterval::countBySql(
+            'booking_id = :booking_id AND begin < :end AND end > :begin',
+            [
+                'booking_id' => $this->id,
+                'begin' => $begin->getTimestamp(),
+                'end' => $end->getTimestamp()
+            ]
+        ) > 0;
+    }
+
+
+    /**
+     * Returns the DateInterval object according to the set repetition
+     * interval of this resource booking object.
+     *
+     * @return DateInterval|null A DateInterval object or null,
+     *     if this booking has no repetition interval.
+     */
+    public function getRepetitionInterval()
+    {
+        $repetition_interval = null;
+        if ($this->repetition_interval) {
+            try {
+                if ($this->repetition_interval instanceof DateInterval) {
+                    $repetition_interval = $this->repetition_interval;
+                } else {
+                    $repetition_interval = new DateInterval($this->repetition_interval);
+                }
+            } catch (Exception $e) {
+                //Invalid repetition interval string.
+                throw new InvalidArgumentException(
+                    sprintf(
+                        _('Das Wiederholungsintervall ist in einem ungültigen Format (%s)!'),
+                        $this->repetition_interval
+                    )
+                );
+            }
+        }
+        return $repetition_interval;
+    }
+
+
+    public function getRepeatModeString()
+    {
+        $interval = $this->getRepetitionInterval();
+
+        if ($interval->m) {
+            switch ($interval->m) {
+                case 1:  return _('jeden Monat');
+                case 2:  return _('jeden zweiten Monat');
+                case 3:  return _('jeden dritten Monat');
+                case 4:  return _('jeden vierten Monat');
+                case 5:  return _('jeden fünften Monat');
+                case 6:  return _('jeden sechsten Monat');
+                case 7:  return _('jeden siebten Monat');
+                case 8:  return _('jeden achten Monat');
+                case 9:  return _('jeden neunten Monat');
+                case 10: return _('jeden zehnten Monat');
+                case 11: return _('jeden elften Monat');
+            }
+        } elseif (($interval->d % 7) == 0) {
+            $week = round($interval->d / 7);
+            switch ($week) {
+                case 1: return _('jede Woche');
+                case 2: return _('jede zweite Woche');
+                case 3: return _('jede dritte Woche');
+            }
+        } elseif ($interval->d) {
+            if ($interval->d > 1) {
+                return sprintf(
+                    _('jeden %d. Tag'),
+                    $interval->d
+                );
+            } elseif ($interval->d == 1) {
+                return _('jeden Tag');
+            } else {
+                return _('ungültiges Zeitintervall');
+            }
+        }
+    }
+
+    /**
+     * Determines if the resource booking overlaps with another
+     * resource booking.
+     *
+     * @return bool True, if there are other bookings which overlap
+     *     with this one, false otherwise.
+     */
+    public function hasOverlappingBookings()
+    {
+        //Get all intervals of this booking, loop over them
+        //and check if there are other intervals in the same
+        //timeframe for the same resource.
+
+        $intervals = ResourceBookingInterval::findBySql(
+            'booking_id = :booking_id',
+            [
+                'booking_id' => $this->id
+            ]
+        );
+
+        if ($intervals) {
+            foreach ($intervals as $interval) {
+                $count = ResourceBookingInterval::countBySql(
+                    'booking_id <> :booking_id
+                    AND
+                    resource_id = :resource_id
+                    AND takes_place = 1
+                    AND
+                    (
+                        begin < :end AND :begin < end
+                    )',
+                    [
+                        'booking_id' => $this->id,
+                        'resource_id' => $this->resource_id,
+                        'begin' => $interval->begin,
+                        'end' => $interval->end
+                    ]
+                );
+
+                if ($count) {
+                    //We have found an interval which overlaps
+                    //with an interval of this booking.
+                    return true;
+                }
+            }
+        }
+
+        //If this booking has no intervals it means it doesn't have
+        //any time intervals at all. Therefore there can't be any
+        //overlapping bookings.
+        return false;
+    }
+
+    /**
+     * Gets the bookings that overlap with this booking.
+     *
+     * @return array Array of ResourceBooking objects
+     */
+    public function getOverlappingBookings()
+    {
+        //Get all intervals of this booking, loop over them
+        //and check if there are other intervals in the same
+        //timeframe for the same resource. If so, collect the
+        //booking-IDs and get all the bookings.
+
+        $intervals = ResourceBookingInterval::findBybooking_id($this->id);
+
+        if ($intervals) {
+            $db = DBManager::get();
+
+            $get_booking_id_stmt = $db->prepare(
+                'SELECT DISTINCT booking_id
+                FROM resource_booking_intervals
+                WHERE
+                booking_id <> :booking_id
+                AND
+                resource_id = :resource_id
+                AND takes_place = 1
+                AND
+                (
+                    begin < :end AND :begin < end
+                )'
+            );
+            $overlapping_booking_ids = [];
+            foreach ($intervals as $interval) {
+                $get_booking_id_stmt->execute(
+                    [
+                        'booking_id' => $this->id,
+                        'resource_id' => $this->resource_id,
+                        'begin' => $interval->begin,
+                        'end' => $interval->end
+                    ]
+                );
+
+                $overlapping_booking_ids = array_merge(
+                    $overlapping_booking_ids,
+                    $get_booking_id_stmt->fetchAll(
+                        PDO::FETCH_COLUMN,
+                        0
+                    )
+                );
+            }
+
+            if ($overlapping_booking_ids) {
+                $overlapping_booking_ids = array_unique(
+                    $overlapping_booking_ids
+                );
+
+                return ResourceBooking::findMany(
+                    $overlapping_booking_ids
+                );
+            }
+        }
+
+        //If this booking has no intervals it means it doesn't have
+        //any time intervals at all. Therefore there can't be any
+        //overlapping bookings.
+        return false;
+    }
+
+
+    /**
+     * Calculates all time intervals as begin and end timestamps
+     * by looking at the repetition settings, if any.
+     *
+     * @param bool $as_datetime Whether to return the timestamps
+     *     as DateTime objects (true) or not (false). Defaults to false.
+     *
+     * @return array A two-dimensional array with each time interval
+     *     for this booking. The array has the following structure:
+     *     [
+     *         [
+     *             'begin' => Begin timestamp.
+     *             'end' => End timestamp.
+     *         ]
+     *     ]
+     */
+    public function calculateTimeIntervals($as_datetime = false)
+    {
+        $interval_data = [];
+        $booking_begin = new DateTime();
+        $booking_begin->setTimestamp($this->begin);
+        if ($this->preparation_time) {
+            $booking_begin->setTimestamp(
+                $this->begin - $this->preparation_time
+            );
+        }
+        $booking_end = new DateTime();
+        $booking_end->setTimestamp($this->end);
+
+        //use begin and end to create the first interval:
+        $interval_data[] = [
+            'begin' => (
+                $as_datetime
+                ? clone $booking_begin
+                : $booking_begin->getTimestamp()
+            ),
+            'end' => (
+                $as_datetime
+                ? clone $booking_end
+                : $booking_end->getTimestamp()
+            )
+        ];
+
+        if ($this->repeat_end) {
+            //Repetition: we must check which repetition interval has been
+            //selected and then create entries for each repetition.
+            //Repetition starts with the begin date and ends with the
+            //"repeat_end" date.
+            $repetition_end = new DateTime();
+            $repetition_end->setTimestamp($this->repeat_end);
+            //The DateInterval constructor will throw an exception,
+            //if it cannot parse the string stored in $this->repetition_interval.
+            $repetition_interval = $this->getRepetitionInterval();
+
+            if ($repetition_interval instanceof DateInterval) {
+                $duration = $booking_begin->diff($booking_end);
+
+                //Check if end is later than begin to avoid
+                //infinite loops.
+                if ($repetition_end > $booking_begin) {
+                    $current_begin = clone $booking_begin;
+                    $current_begin->add($repetition_interval);
+                    while ($current_begin < $repetition_end) {
+                        $current_end = clone $current_begin;
+                        $current_end->add($duration);
+                        $interval_data[] = [
+                            'begin' => (
+                                $as_datetime
+                                ? clone $current_begin
+                                : $current_begin->getTimestamp()
+                            ),
+                            'end' => (
+                                $as_datetime
+                                ? clone $current_end
+                                : $current_end->getTimestamp()
+                            )
+                        ];
+                        $current_begin->add($repetition_interval);
+                    }
+                } else {
+                    //end timestamp is before begin timestamp:
+                    //return an empty array
+                    return [];
+                }
+            }
+            //Everything went fine.
+        }
+        return $interval_data;
+    }
+
+
+    /**
+     * Retrieves all time intervals for this resource booking.
+     *
+     * @return ResourceBookingInterval[] An array of
+     *     ResourceBookingInterval objects.
+     */
+    public function getTimeIntervals($with_exceptions = true)
+    {
+        if ($with_exceptions) {
+            return ResourceBookingInterval::findBySQL(
+                "booking_id = :booking_id
+                ORDER BY begin ASC, end ASC",
+                [
+                    'booking_id' => $this->id
+                ]
+            );
+        } else {
+            return ResourceBookingInterval::findBySQL(
+                "booking_id = :booking_id AND takes_place = '1'
+                ORDER BY begin ASC, end ASC",
+                [
+                    'booking_id' => $this->id
+                ]
+            );
+        }
+    }
+
+
+    /**
+     * Retrieves all time intervals for this resource booking
+     * in a specified time range.
+     *
+     * @param DateTime $begin The begin of the time range.
+     * @param DateTime $end The end of the time range.
+     *
+     * @return ResourceBookingInterval[] An array of
+     *     ResourceBookingInterval objects.
+     */
+    public function getTimeIntervalsInTimeRange(DateTime $begin, DateTime $end)
+    {
+        if ($begin > $end) {
+            //We don't serve querys with invalid time ranges here.
+            return [];
+        }
+
+        return ResourceBookingInterval::findBySql(
+            'booking_id = :booking_id AND begin < :end AND end > :begin ORDER BY begin, end',
+            [
+                'booking_id' => $this->id,
+                'begin' => $begin->getTimestamp(),
+                'end' => $end->getTimestamp()
+            ]
+        );
+    }
+
+
+    /**
+     * Returns all allocating users: Users who are associated with this booking
+     * through a request or a course date for which this booking has been made
+     * (all allocating users). If no user could be determined but the booking
+     * is bound to a course, the course name is returned instead.
+     *
+     * @deprecated
+     * @param bool $only_names Whether only the names of these users shall be
+     *     returned (true) or user objects shall be returned (false).
+     *
+     * @return string[]|User[] Depending on the value of the $only_names
+     *     parameter a string array or an user object array is returned.
+     *     In case no user can be found, the array is empty.
+     *     In case the parameter $only_names is set to true, the result
+     *     may also contain a course name, if no users can be found but the
+     *     booking is bound to a course.
+     */
+    public function getAssignedUsers($only_names = true)
+    {
+        //The only two cases which shall be handled are that
+        //a booking is assigned to a course or an user.
+        if ($this->getAssignedUserType() === 'course') {
+            //Return all persons associated with that course date.
+            if (count($this->assigned_course_date->dozenten)) {
+                if ($only_names) {
+                    $lecturers = [];
+                    foreach ($this->assigned_course_date->dozenten as $lecturer) {
+                        $lecturers[] = $lecturer->getFullName();
+                    }
+                    return $lecturers;
+                } else {
+                    return $this->assigned_course_date->dozenten;
+                }
+            } else {
+                $lecturers = User::findBySql(
+                    "INNER JOIN seminar_user
+                    USING (user_id)
+                    WHERE
+                    seminar_user.seminar_id = :course_id
+                    AND
+                    seminar_user.status = 'dozent'
+                    ORDER BY nachname ASC, vorname ASC",
+                    [
+                        'course_id' => $this->assigned_course_date->range_id
+                    ]
+                );
+                if (!$lecturers) {
+                    return [];
+                }
+                if ($only_names) {
+                    $names = [];
+                    foreach ($lecturers as $lecturer) {
+                        $names[] = $lecturer->getFullName();
+                    }
+                    return $names;
+                } else {
+                    return $lecturers;
+                }
+            }
+        } elseif ($this->getAssignedUserType() === 'user') {
+            if ($only_names) {
+                return [$this->assigned_user->getFullName()];
+            }
+            return [$this->assigned_user];
+        }
+
+        return [];
+    }
+
+    public function getAssignedUser()
+    {
+        if ($this->getAssignedUserType() === 'course') {
+            return $this->assigned_course_date->course;
+        }
+        if ($this->getAssignedUserType() === 'user') {
+            return $this->assigned_user;
+        }
+    }
+
+    public function getAssignedUserType()
+    {
+        if (isset($this->assigned_user_type)) {
+            return $this->assigned_user_type;
+        }
+        if ($this->assigned_course_date instanceof CourseDate) {
+            return $this->assigned_user_type = 'course';
+        }
+        if ($this->assigned_user instanceof User) {
+            return $this->assigned_user_type = 'user';
+        }
+        return $this->assigned_user_type = 'none';
+    }
+
+    public function getAssignedUserName()
+    {
+        $name = '';
+        if ($this->getAssignedUserType() === 'course') {
+            $name = $this->assigned_course_date->course->getFullName();
+            $name .= ' (' . implode(',', $this->assigned_course_date->course->getMembersWithStatus('dozent', true)->limit(3)->getValue('nachname')) . ')';
+        } elseif ($this->getAssignedUserType() === 'user') {
+            if (get_visibility_by_id($this->assigned_user->id) ||
+                ($this->assigned_user->id == $GLOBALS['user']->id)
+            ) {
+                $name = $this->assigned_user->getFullName();
+                if ($this->description) {
+                    $name .= " \n" . $this->description;
+                }
+            } else {
+                //Check if the current user has at least user permissions
+                //on the resource. In that case, even invisible assigned
+                //users become visible.
+                $resource = $this->resource->getDerivedClassInstance();
+                $current_user = User::findCurrent();
+                if (($resource instanceof Resource) && ($current_user instanceof User)) {
+                    if ($resource->userHasPermission($current_user, 'user')) {
+                        $name = $this->assigned_user->getFullName();
+                        if ($this->description) {
+                            $name .= " \n" . $this->description;
+                        }
+                    }
+                }
+            }
+        } else {
+            $name = $this->description;
+        }
+        return $name;
+    }
+
+
+    /**
+     * Determines whether the booking is a simple booking
+     * that is not bound to course dates or similar Stud.IP objects.
+     */
+    public function isSimpleBooking()
+    {
+        return !($this->getAssignedUserType() === 'course');
+    }
+
+
+    /**
+     * Determins whether the booking has exceptions in repetitions or not.
+     * When the booking is bound to a course via a CourseDate instance,
+     * the exceptions are looked up using the corresponding metadate (if any).
+     * If a metadate exists to the course date and it has cancelled dates
+     * (metadate has CourseExDate instances assigned) then the booking has
+     * exceptions.
+     * If the booking is a simple booking, the exception status is determined
+     * by checking if the booking has ResourceBookingInterval instances
+     * that don't take place assigned to it. This is only checked,
+     * if a repetition interval is set for the booking so that such instances
+     * can exist.
+     *
+     * @return bool True, if the booking has exceptions in the repetition,
+     *     false otherwise.
+     */
+    public function hasExceptions()
+    {
+        if ($this->isSimpleBooking()) {
+            //This is a simple booking: Check the repetition interval:
+            if ($this->repetition_interval) {
+                //A repetition interval exists: Check if booking intervals
+                //exist that don't take place:
+                return ResourceBookingInterval::countBySql(
+                    "booking_id = :booking_id
+                    AND takes_place = '0'",
+                    [
+                        'booking_id' => $this->id
+                    ]
+                ) > 0;
+            } else {
+                return false;
+            }
+        } else {
+            //Check if the course booking has exceptions (via metadate):
+            $metadate = $this->assigned_course_date->cycle;
+            if ($metadate instanceof SeminarCycleDate) {
+                //Check if the metadate has exceptions:
+                return CourseExDate::countBySql(
+                    'metadate_id = :metadate_id',
+                    [
+                        'metadate_id' => $metadate->id
+                    ]
+                ) > 0;
+            } else {
+                //No metadate is assigned to the course booking.
+                return false;
+            }
+        }
+    }
+
+
+    public function __toString()
+    {
+        return date('d.m.Y H:i', $this->begin)
+             . ' - '
+             . date('d.m.Y H:i', $this->end);
+    }
+
+
+    public function getTimeIntervalStrings()
+    {
+        $time_intervals = ResourceBookingInterval::findBySQL(
+            'booking_id = :booking_id ORDER BY begin ASC, end ASC',
+            [
+                'booking_id' => $this->id
+            ]
+        );
+
+        $strings = [];
+        foreach ($time_intervals as $interval) {
+            if (date('Ymd', $interval->begin) == date('Ymd', $interval->end)) {
+                $strings[] = sprintf(
+                    '%1$s %2$s - %3$s',
+                    date('d.m.Y', $interval->begin),
+                    date('H:i', $interval->begin),
+                    date('H:i', $interval->end)
+                );
+            } else {
+                $strings[] = sprintf(
+                    '%1$s - %2$s',
+                    date('d.m.Y H:i', $interval->begin),
+                    date('d.m.Y H:i', $interval->end)
+                );
+            }
+        }
+        return $strings;
+    }
+
+
+    /**
+     * @inheritDoc
+     */
+    public static function exportUserData(StoredUserData $storage)
+    {
+        $user = User::find($storage->user_id);
+        $bookings = self::findBySql(
+            'user_id = :user_id ORDER BY mkdate',
+            [
+                'user_id' => $storage->user_id
+            ]
+        );
+
+        $rows = [];
+        foreach ($bookings as $booking) {
+            $rows[] = $booking->toRawArray();
+        }
+        $storage->addTabularData(
+            _('Buchungen von Ressourcen'),
+            'resource_bookings',
+            $rows,
+            $user
+        );
+    }
+
+
+    public function convertToEventData(array $time_intervals, $user)
+    {
+        $booking_plan_booking_bg =
+            \ColourValue::find('Resources.BookingPlan.Booking.Bg');
+        $booking_plan_booking_fg =
+            \ColourValue::find('Resources.BookingPlan.Booking.Fg');
+        $booking_plan_simple_booking_with_exceptions_bg =
+            ColourValue::find('Resources.BookingPlan.SimpleBookingWithExceptions.Bg');
+        $booking_plan_simple_booking_with_exceptions_fg =
+            ColourValue::find('Resources.BookingPlan.SimpleBookingWithExceptions.Fg');
+        $booking_plan_reservation_bg = \ColourValue::find('Resources.BookingPlan.Reservation.Bg');
+        $booking_plan_reservation_fg = \ColourValue::find('Resources.BookingPlan.Reservation.Fg');
+        $booking_plan_lock_bg = \ColourValue::find('Resources.BookingPlan.Lock.Bg');
+        $booking_plan_lock_fg = \ColourValue::find('Resources.BookingPlan.Lock.Fg');
+        $booking_plan_planned_booking_bg = \ColourValue::find('Resources.BookingPlan.PlannedBooking.Bg');
+        $booking_plan_planned_booking_fg = \ColourValue::find('Resources.BookingPlan.PlannedBooking.Fg');
+        $booking_plan_preparation_bg = \ColourValue::find('Resources.BookingPlan.PreparationTime.Bg');
+        $booking_plan_preparation_fg = \ColourValue::find('Resources.BookingPlan.PreparationTime.Fg');
+        $booking_plan_course_booking_bg = \ColourValue::find('Resources.BookingPlan.CourseBooking.Bg');
+        $booking_plan_course_booking_fg = \ColourValue::find('Resources.BookingPlan.CourseBooking.Fg');
+
+        $colour = $booking_plan_booking_bg->__toString();
+        $text_colour = $booking_plan_booking_fg->__toString();
+        $event_classes = [];
+
+        if ($this->booking_type == self::TYPE_NORMAL) {
+            $event_classes[] = 'resource-booking';
+            //Check if the booking is a course booking:
+            if ($this->getAssignedUserType() === 'course') {
+                //It is a course date.
+                $event_classes[] = 'for-course';
+                $colour = $booking_plan_course_booking_bg->__toString();
+                $text_colour = $booking_plan_course_booking_fg->__toString();
+            }
+        } elseif ($this->booking_type == self::TYPE_RESERVATION) {
+            $event_classes[] = 'resource-reservation';
+            $colour = $booking_plan_reservation_bg->__toString();
+            $text_colour = $booking_plan_reservation_fg->__toString();
+        } elseif ($this->booking_type == self::TYPE_LOCK) {
+            $event_classes[] = 'resource-lock';
+            $colour = $booking_plan_lock_bg->__toString();
+            $text_colour = $booking_plan_lock_fg->__toString();
+        } elseif ($this->booking_type == self::TYPE_PLANNED) {
+            $event_classes[] = 'resource-planned-booking';
+            $colour = $booking_plan_planned_booking_bg->__toString();
+            $text_colour = $booking_plan_planned_booking_fg->__toString();
+        }
+
+        $booking_is_editable = false;
+        if ($user instanceof User) {
+            $booking_is_editable = !$this->isReadOnlyForUser($user);
+        }
+
+        $booking_api_urls = [];
+        $booking_view_urls = [
+            'show' => \URLHelper::getURL(
+                'dispatch.php/resources/booking/index/'
+                . $this->id
+            ),
+        ];
+        if ($booking_is_editable) {
+            $booking_view_urls['edit'] = \URLHelper::getURL(
+                'dispatch.php/resources/booking/edit/'
+                . $this->id
+            );
+        }
+        $events = [];
+
+        foreach ($time_intervals as $interval) {
+            $real_begin = $interval['begin'];
+            if ($this->preparation_time) {
+                $real_begin += $this->preparation_time;
+                $begin = new DateTime();
+                $begin->setTimestamp($interval['begin']);
+                $end = new DateTime();
+                $end->setTimestamp($real_begin);
+                $events[] = new Studip\Calendar\EventData(
+                    $begin,
+                    $end,
+                    _('Rüstzeit'),
+                    ['preparation-time'],
+                    $booking_plan_preparation_fg->__toString(),
+                    $booking_plan_preparation_bg->__toString(),
+                    $booking_is_editable,
+                    'ResourceBookingInterval',
+                    $interval->id,
+                    'ResourceBooking',
+                    $this->id,
+                    'Resource',
+                    $this->resource_id,
+                    $booking_view_urls
+                );
+            }
+
+            $event_title = '';
+            $icon = '';
+
+            if ($user instanceof User) {
+                $derived_resource = $this->resource->getDerivedClassInstance();
+                if ($derived_resource->userHasPermission($user, 'user') && $this->internal_comment) {
+                    $icon = 'chat2';
+                }
+            }
+
+            if (!$this->isSimpleBooking()) {
+                if ($this->assigned_course_date->metadate_id) {
+                    $icon = 'refresh';
+                }
+            } elseif ($this->repeat_end > $this->end) {
+                $icon = 'refresh';
+            }
+
+            if ($this->assigned_course_date instanceof CourseDate) {
+                $course = $this->assigned_course_date->course;
+                if ($course instanceof Course) {
+                    $has_perms = $GLOBALS['perm']->have_studip_perm('user', $course->id, $user->id);
+                    $vis_perms = $GLOBALS['perm']->have_perm(Config::get()->SEM_VISIBILITY_PERM, $user->id);
+                    if ($has_perms || $vis_perms || $course->visible) {
+                        $event_title = $this->getAssignedUserName();
+                    }
+                }
+            } else {
+                $event_title = $this->getAssignedUserName();
+            }
+
+            $interval_api_urls = $booking_api_urls;
+            if ($booking_is_editable) {
+                //A note on the move URL:
+                //When used in a room group booking plan, the interval_id
+                //URL parameter is subject to modification in JavaScript.
+                //(lib/resources.js, method dropEventInRoomGroupBookingPlan)
+                $interval_api_urls = [
+                    'resize' => \URLHelper::getURL(
+                        'dispatch.php/resources/ajax/move_booking/' . $this->id,
+                        [
+                            'quiet' => true,
+                            'interval_id' => $interval->id
+                        ]
+                    ),
+                    'move' => \URLHelper::getURL(
+                        'dispatch.php/resources/ajax/move_booking/' . $this->id,
+                        [
+                            'quiet' => true,
+                            'interval_id' => $interval->id
+                        ]
+                    )
+                ];
+            }
+            $begin = new DateTime();
+            $begin->setTimestamp($real_begin);
+            $end = new DateTime();
+            $end->setTimestamp($interval['end']);
+            $events[] = new Studip\Calendar\EventData(
+                $begin,
+                $end,
+                $event_title,
+                $event_classes,
+                $text_colour,
+                $colour,
+                $booking_is_editable,
+                ResourceBookingInterval::class,
+                $interval->id,
+                ResourceBooking::class,
+                $this->id,
+                Resource::class,
+                $this->resource_id,
+                $booking_view_urls,
+                $interval_api_urls,
+                $icon
+            );
+        }
+
+        return $events;
+    }
+
+
+    public function getAllEventData()
+    {
+        return $this->convertToEventData(
+            $this->getTimeIntervals(false),
+            User::findCurrent()
+        );
+    }
+
+
+    public function getEventDataForTimeRange(DateTime $begin, DateTime $end)
+    {
+
+        return $this->getFilteredEventData(null, null, null, $begin, $end);
+    }
+
+
+    public function getFilteredEventData(
+        $user_id = null,
+        $range_id = null,
+        $range_type = null,
+        $begin = null,
+        $end = null
+    )
+    {
+        $sql = "booking_id = :booking_id AND takes_place = 1 ";
+        $sql_array = [
+            'booking_id' => $this->id
+        ];
+
+        if ($begin && $end) {
+            if ($begin instanceof DateTime) {
+                $begin = $begin->getTimestamp();
+            }
+            if ($end instanceof DateTime) {
+                $end = $end->getTimestamp();
+            }
+            $sql .= "AND begin < :end AND :begin < end";
+            $sql_array['begin'] = $begin;
+            $sql_array['end'] = $end;
+        }
+        $time_intervals = ResourceBookingInterval::findBySQL(
+            $sql,
+            $sql_array
+        );
+
+        $user = null;
+        if ($user_id) {
+            $user = User::find($user_id);
+        } else {
+            $user = User::findCurrent();
+        }
+
+        return $this->convertToEventData($time_intervals, $user);
+    }
+
+    /**
+     * @return string
+     */
+    public function getRepetitionType()
+    {
+        if ($this->getAssignedUserType() === 'course') {
+            if ($this->assigned_course_date->metadate_id) {
+                return 'weekly';
+            } else {
+                return 'single';
+            }
+        } else {
+            $intervall = $this->getRepetitionInterval();
+            if (!$intervall) {
+                return 'single';
+            }
+            if ($intervall->m) {
+                return 'monthly';
+            }
+            if ($intervall->d % 7 === 0) {
+                return 'weekly';
+            }
+            if ($intervall->d) {
+                return 'daily';
+            }
+        }
+
+        return '';
+    }
+
+
+    /**
+     * Sends a notification that the booking has been deleted
+     * to the user that created the booking.
+     */
+    public function sendDeleteNotification()
+    {
+        if ($this->booking_type != self::TYPE_NORMAL) {
+            //We only handle real bookings in this method.
+            return;
+        }
+
+        if ($this->end < time()) {
+            //Bookings that lie in the past can be deleted without
+            //sending notifications.
+            return;
+        }
+
+        $booking_resource = Resource::find($this->resource_id);
+        $booking_user = User::find($this->booking_user_id);
+        $booking_course = null;
+        if ($this->course_id) {
+            $booking_course = Course::find($this->course_id);
+        }
+        if (!$booking_resource || !$booking_user) {
+            //Nothing we can do here.
+            return;
+        }
+        if (User::findCurrent()->id === $booking_user->id) {
+            return;
+        }
+
+        $template_factory = new Flexi\Factory(
+            $GLOBALS['STUDIP_BASE_PATH'] . '/locale/'
+        );
+        setTempLanguage($booking_user->id);
+        $lang_path = getUserLanguagePath($booking_user->id);
+
+        $template = $template_factory->open(
+            $lang_path . '/LC_MAILS/delete_booking_notification.php'
+        );
+        $template->set_attribute('resource', $booking_resource->getDerivedClassInstance());
+        $template->set_attribute('begin', $this->begin);
+        $template->set_attribute('end', $this->end);
+        $template->set_attribute('deleting_user', User::findCurrent());
+        $template->set_attribute('booking_course', $booking_course);
+
+        $mail_text = $template->render();
+
+        Message::send(
+            User::findCurrent()->id,
+            [$booking_user->username],
+            _('Ihre Buchung wurde gelöscht'),
+            $mail_text
+        );
+
+        restoreLanguage();
+    }
+}