path: root/app/controllers/resources/admin.php

<?php

/**
 * admin.php - contains Resources_AdminController
 *
 * 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>
 * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
 * @copyright   2018
 * @category    Stud.IP
 * @since       TODO
 */


/**
 * Resources_AdminController contains actions
 * for the global resource administration.
 */
class Resources_AdminController extends AuthenticatedController
{
    public function before_filter(&$action, &$args)
    {
        parent::before_filter($action, $args);

        $this->sidebar = Sidebar::get();
        $this->current_user = User::findCurrent();
        if (!ResourceManager::userHasGlobalPermission($this->current_user, 'admin')
            && !$GLOBALS['perm']->have_perm('root')) {
            throw new AccessDeniedException();
        }
    }

    public function permissions_action($resource_id = null)
    {
        if (Navigation::hasItem('/resources/admin/permissions')) {
            Navigation::activateItem('/resources/admin/permissions');
        }

        //The relayed controller needs a resource object or the flag
        //that global permissions shall be edited.
        //Furthermore it needs the attribute resource_id.
        if ($resource_id == 'global') {
            $this->edit_global_permissions = true;
        } else {
            $this->resource = Resource::find($resource_id);
            if (!$this->resource) {
                PageLayout::postError(
                    _('Die angegebene Ressource wurde nicht gefunden!')
                );
                return;
            }
            if (!$this->resource->userHasPermission($this->current_user, 'admin')
                && !$GLOBALS['perm']->have_perm('root')) {
                throw new AccessDeniedException();
            }
        }
        $this->resource_id = $resource_id;
        $response          = $this->relay('resources/resource/permissions/' . $resource_id);

        //We must replace all paths directing to the original controller
        //with the path to this controller so that the click on the "save"
        //button in the relayed controller links to this controller.
        $this->other_controllers_html = str_replace(
            'dispatch.php/resources/resource/permissions',
            'dispatch.php/resources/admin/permissions',
            $response->body
        );
    }


    public function global_locks_action()
    {
        if (Navigation::hasItem('/resources/admin/global_locks')) {
            Navigation::activateItem('/resources/admin/global_locks');
        }

        PageLayout::setTitle(
            _('Globale Sperren verwalten')
        );

        $actions = new ActionsWidget();
        $actions->addLink(
            _('Sperrung hinzufügen'),
            $this->url_for('resources/global_locks/add'),
            Icon::create('add'),
            [
                'data-dialog' => 'size=auto'
            ]
        );
        $this->sidebar->addWidget($actions);

        $this->locks = GlobalResourceLock::findBySql('1 ORDER BY begin, end');
    }


    public function user_permissions_action()
    {
        if (Navigation::hasItem('/resources/admin/user_permissions')) {
            Navigation::activateItem('/resources/admin/user_permissions');
        }

        PageLayout::setTitle(
            _('Berechtigungs-Übersicht')
        );

        $user_search = new SearchWidget(
            $this->url_for('resources/admin/user_permissions')
        );
        $user_search->addNeedle(
            _('Suche nach einer Person'),
            'user_id',
            _('Name oder Nutzername der Person'),
            new PermissionSearch('user'),
            'function(){jQuery(this).closest("form").submit();}'
        );

        $this->sidebar->addWidget($user_search);
        $this->last_activity_date = null;
        $user_id    = Request::get('user_id');
        $this->user = User::find($user_id);
        if ($this->user) {
            PageLayout::setTitle(
                sprintf(
                    _('Berechtigungen für %s'),
                    $this->user->getFullName()
                ) . sprintf(
                    ' (%1$s) (%2$s)',
                    $this->user->username,
                    $this->user->perms
                )
            );

            //get the permissions of that user:

            $this->global_permission = ResourcePermission::findOneBySql(
                "user_id = :user_id AND resource_id = 'global'",
                [
                    'user_id' => $this->user->id
                ]
            );

            $this->permissions = ResourcePermission::findBySql(
                'INNER JOIN resources
                ON resource_permissions.resource_id = resources.id
                WHERE
                user_id = :user_id
                ORDER BY resources.name ASC, resource_permissions.mkdate ASC',
                [
                    'user_id' => $this->user->id
                ]
            );

            $this->temporary_permissions = ResourceTemporaryPermission::findBySql(
                'INNER JOIN resources
                ON resource_temporary_permissions.resource_id = resources.id
                WHERE
                user_id = :user_id
                ORDER BY resources.name ASC, resource_temporary_permissions.mkdate ASC',
                [
                    'user_id' => $this->user->id
                ]
            );

            //Get last activity:
            $this->now = new DateTime();

            $this->last_activity = ResourceManager::getUserInactivityInterval(
                $this->user,
                $this->now
            );

            if ($this->last_activity instanceof DateInterval) {
                //Calculate the date of the last inactivity:
                $last_activity_date = $this->now->sub($this->last_activity);
                $this->last_activity_date = $last_activity_date->format('d.m.Y H:i');
            }
        } else {
            //No user selected. Show a list of all users that have
            //at least one permission in the room management system.
            if ($user_id) {
                //User-ID specified, but no user could be found.
                PageLayout::postError(
                    _('Die angegebene Person wurde nicht gefunden!')
                );
            }

            $this->users = User::findBySql(
                '`user_id` IN (
                    SELECT `user_id`
                    FROM `resource_permissions`
                    UNION
                    SELECT `user_id`
                    FROM `resource_temporary_permissions`
                )
                ORDER BY `nachname` ASC, `vorname` ASC'
            );
            if (!$this->users) {
                //No user found.
                PageLayout::postInfo(
                    _('Es gibt keine Personen mit Berechtigungen in der Raumverwaltung!')
                );
            }
        }
    }

    public function booking_log_action($user_id = null, $resource_id = null)
    {
        $this->show_all_records = Request::get('show_all_records');

        $this->user = User::find($user_id);
        if (!$this->user) {
            PageLayout::postError(
                _('Die angegebene Person wurde nicht gefunden!')
            );
            return;
        }

        $this->resource = null;
        if ($resource_id) {
            $this->resource = Resource::find($resource_id);
            if (!$this->resource) {
                PageLayout::postError(
                    _('Die angegebene Ressource wurde nicht gefunden!')
                );
                return;
            }

            $this->resource = $this->resource->getDerivedClassInstance();
        }

        //Get bookings:

        $this->bookings = null;
        if ($this->resource) {
            $this->bookings = ResourceBooking::findBySql(
                ':user_id IN (range_id, booking_user_id) AND resource_id = :resource_id '
                . (!$this->show_all_records
                    ? 'AND begin > (UNIX_TIMESTAMP() - 86400) '
                    : ''
                ) . 'ORDER BY begin ASC, end ASC',
                [
                    'user_id'     => $this->user->id,
                    'resource_id' => $this->resource->id
                ]
            );
        } else {
            $this->bookings = ResourceBooking::findBySql(
                ':user_id IN (range_id, booking_user_id) '
                . (!$this->show_all_records
                    ? 'AND begin > (UNIX_TIMESTAMP() - 86400) '
                    : ''
                ) . 'ORDER BY begin ASC, end ASC',
                [
                    'user_id' => $this->user->id
                ]
            );
        }
    }

    public function categories_action()
    {
        if (!ResourceManager::userHasGlobalPermission($this->current_user, 'admin')) {
            throw new AccessDeniedException();
        }

        PageLayout::setTitle(
            _('Kategorien verwalten')
        );

        if (Navigation::hasItem('/resources/admin/categories')) {
            Navigation::activateItem('/resources/admin/categories');
        }

        $actions = new ActionsWidget();
        $actions->addLink(
            _('Neue Kategorie'),
            URLHelper::getURL(
                'dispatch.php/resources/category/add'
            ),
            Icon::create('add'),
            ['data-dialog' => 'size=auto;reload-on-close']
        );

        $this->sidebar->addWidget($actions);

        $this->categories = ResourceCategory::findAll();

        if (!$this->categories) {
            PageLayout::postInfo(
                _('Es wurden keine Kategorien gefunden!')
            );
        }
    }

    public function properties_action()
    {
        if (Navigation::hasItem('/resources/admin/properties')) {
            Navigation::activateItem('/resources/admin/properties');
        }

        PageLayout::setTitle(
            _('Eigenschaften verwalten')
        );

        $actions = new ActionsWidget();
        $actions->addLink(
            _('Eigenschaft hinzufügen'),
            $this->url_for('resources/property/add'),
            Icon::create('add'),
            [
                'data-dialog' => 'size=auto'
            ]
        );

        $this->sidebar->addWidget($actions);


        //Get all properties:
        $this->properties = ResourcePropertyDefinition::findBySql(
            'TRUE
            GROUP BY property_id
            ORDER BY name ASC, type ASC, mkdate ASC'
        );

        //Get the categories where the properties are used.
        $this->categories = [];
        if (is_array($this->properties)) {
            $db = DBManager::get();

            $stmt = $db->prepare(
                "SELECT DISTINCT rc.name AS name
                FROM resource_category_properties rcp
                INNER JOIN resource_categories rc
                ON rcp.category_id = rc.id
                WHERE
                rcp.property_id = :property_id
                ORDER BY name ASC"
            );

            foreach ($this->properties as $property) {
                $stmt->execute(
                    [
                        'property_id' => $property->id
                    ]
                );

                $this->categories[$property->id] = $stmt->fetchAll(
                    PDO::FETCH_COLUMN,
                    0
                );
            }
        }
    }


    public function property_groups_action()
    {
        if (Navigation::hasItem('/resources/admin/property_groups')) {
            Navigation::activateItem('/resources/admin/property_groups');
        }

        PageLayout::setTitle(_('Eigenschaftsgruppen verwalten'));

        $this->new_group_name = '';
        $this->property_move = [];

        if (Request::submitted('save')) {
            CSRFProtection::verifyUnsafeRequest();

            //Fields from the first table:
            $this->selected_groups           = Request::getArray('selected_groups');
            $this->selected_group_properties = Request::getArray('selected_group_properties');
            //Fields from the second table:
            $this->new_group_name      = Request::get('new_group_name');
            $this->selected_properties = Request::getArray('selected_properties');
            $this->property_move       = Request::getArray('property_move');
            $this->group_position      = Request::getArray('group_position');
            $this->edited_group_names  = Request::getArray('edited_group_names');
            $this->property_position   = Request::getArray('property_position');

            $property_object_cache = [];
            $group_object_cache    = [];

            //Process fields from the first table:
            if ($this->selected_group_properties) {
                foreach ($this->selected_group_properties as $group_properties) {
                    foreach ($group_properties as $property_id) {
                        $property = ResourcePropertyDefinition::find($property_id);
                        if (!$property) {
                            //Invalid / non-existant property.
                            continue;
                        }
                        $property_object_cache[$property->id] = $property;
                        $property->property_group_id          = '';
                        $property->property_group_pos         = '0';
                    }
                }
            }
            if ($this->selected_groups) {
                ResourcePropertyGroup::deleteBySql(
                    'id IN ( :group_ids )',
                    [
                        'group_ids' => $this->selected_groups
                    ]
                );
            }

            //Process fields from the second table:
            if ($this->new_group_name) {
                $group           = new ResourcePropertyGroup();
                $group->name     = $this->new_group_name;
                $group->position = '0';
                if ($group->store()) {
                    PageLayout::postSuccess(
                        sprintf(
                            _('Die neue Eigenschaftsgruppe mit dem Namen %s wurde angelegt!'),
                            htmlReady($group->name)
                        )
                    );
                    $this->new_group_name = '';
                } else {
                    PageLayout::postError(
                        sprintf(
                            _('Fehler beim Anlegen der Eigenschaftsgruppe %s!'),
                            htmlReady($group->name)
                        )
                    );
                }

                if ($this->selected_properties) {
                    foreach ($this->selected_properties as $property_id) {
                        $property = ResourcePropertyDefinition::find($property_id);
                        if (!$property) {
                            //Invalid / non-existing property.
                            continue;
                        }

                        $property_object_cache[$property->id] = $property;

                        $property->property_group_id = $group->id;
                        if ($property->property_group_pos == '') {
                            $property->property_group_pos = '0';
                        }
                    }
                }
            }

            if ($this->property_move) {
                //At least one property is selected for moving into another
                //property group.
                foreach ($this->property_move as $property_id => $group_id) {
                    $property = $property_object_cache[$property_id] ?? null;
                    if (!$property) {
                        $property = ResourcePropertyDefinition::find($property_id);
                    }
                    if (!$property) {
                        continue;
                    }
                    $property_object_cache[$property->id] = $property;

                    if ($group_id) {
                        $group = $group_object_cache[$group_id];
                        if (!$group) {
                            $group = ResourcePropertyGroup::find($group_id);
                        }
                        if (!$group) {
                            continue;
                        }
                        $group_object_cache[$group->id] = $group;

                        $property->property_group_id = $group->id;
                        if ($property->property_group_pos == '') {
                            $property->property_group_pos = '0';
                        }
                    }
                }
            }

            if ($this->group_position) {
                foreach ($this->group_position as $group_id => $position) {
                    $group = $group_object_cache[$group_id] ?? null;
                    if (!$group) {
                        $group = ResourcePropertyGroup::find($group_id);
                    }
                    if (!$group) {
                        //Invalid / non-existing group.
                        continue;
                    }
                    $group_object_cache[$group_id] = $group;

                    $group->position = $position;
                }
            }

            if ($this->edited_group_names) {
                foreach ($this->edited_group_names as $group_id => $new_name) {
                    $group = $group_object_cache[$group_id];
                    if (!$group) {
                        $group = ResourcePropertyGroup::find($group_id);
                    }
                    if (!$group) {
                        //Invalid / non-existing group.
                        continue;
                    }
                    $group_object_cache[$group_id] = $group;
                    if ($group->name != $new_name) {
                        $group->name = $new_name;
                    }
                }
            }

            if ($this->property_position) {
                foreach ($this->property_position as $property_id => $position) {
                    $property = $property_object_cache[$property_id];
                    if (!$property) {
                        $property = ResourcePropertyDefinition::find($property_id);
                    }
                    if (!$property) {
                        continue;
                    }
                    $property_object_cache[$property->id] = $property;

                    //Make sure the position is a number:
                    $position = intval($position);

                    $property->property_group_pos = $position;
                }
            }

            foreach ($group_object_cache as $group) {
                if ($group->isDirty()) {
                    $group->store();
                }
            }

            foreach ($property_object_cache as $property) {
                if ($property->isDirty()) {
                    $property->store();
                }
            }
        }

        $this->property_groups = ResourcePropertyGroup::findBySql(
            'TRUE ORDER BY position, name ASC'
        );

        $this->ungrouped_properties = ResourcePropertyDefinition::findBySql(
            "property_group_id IS NULL OR property_group_id = ''
            ORDER BY name ASC, type ASC"
        );
    }


    protected function deleteSeparableRoomsById($separable_room_ids = [])
    {
        if (!is_array($separable_room_ids)) {
            return;
        }

        if (count($separable_room_ids) == 1) {
            //Only one separable room to delete.
            $separable_room = SeparableRoom::find($separable_room_ids[0]);

            if ($separable_room) {
                if ($separable_room->delete()) {
                    PageLayout::postSuccess(
                        sprintf(
                            _('Der teilbare Raum %s wurde gelöscht!'),
                            htmlReady($separable_room->name)
                        )
                    );
                } else {
                    PageLayout::postError(
                        sprintf(
                            _('Fehler beim Löschen des teilbaren Raumes %s!'),
                            htmlReady($separable_room->name)
                        )
                    );
                }
            } else {
                PageLayout::postError(
                    _('Der gewählte teilbare Raum wurde nicht gefunden!')
                );
            }
        } else {
            //More than one separable room to delete.

            $errors          = [];
            $rooms_not_found = 0;
            foreach ($separable_room_ids as $separable_room_id) {
                $separable_room = SeparableRoom::find($separable_room_id);

                if ($separable_room) {
                    if (!$separable_room->delete()) {
                        $errors[] = sprintf(
                            _('Fehler beim Löschen des teilbaren Raumes %s!'),
                            htmlReady($separable_room->name)
                        );
                    }
                } else {
                    $rooms_not_found++;
                }
            }

            if ($rooms_not_found > 0) {
                //Add an error message on top of the other error messages.
                array_unshift(
                    $errors,
                    sprintf(
                        _('%d teilbare Räume wurden nicht gefunden!'),
                        $rooms_not_found
                    )
                );
            }

            if ($errors) {
                PageLayout::postError(
                    ngettext(
                        'Der folgende Fehler trat beim Löschen mehrerer teilbarer Räume auf:',
                        'Die folgenden Fehler traten beim Löschen mehrerer teilbarer Räume auf:',
                        count($errors)
                    ),
                    $errors
                );
            }
        }
    }


    protected function deleteSeparableRoomPartsById($room_part_ids = [])
    {
        if (!is_array($room_part_ids)) {
            return;
        }

        if (count($room_part_ids) == 1) {
            $separable_room_part = SeparableRoomPart::find(
                explode('_', $room_part_ids[0])
            );
            if ($separable_room_part) {
                $room           = $separable_room_part->room;
                $separable_room = $separable_room_part->separable_room;
                if ($separable_room_part->delete()) {
                    //Check if the separable room as any parts left:
                    if ($separable_room) {
                        if (count($separable_room->parts) == 0) {
                            $separable_room->delete();
                        }
                    }
                    PageLayout::postSuccess(
                        sprintf(
                            _('Der Raum %1$s wurde aus dem teilbaren Raum %2$s gelöscht!'),
                            ($room ? htmlReady($room->name) : _('unbekannt')),
                            ($separable_room ? htmlReady($separable_room->name) : _('unbekannt'))
                        )
                    );
                } else {
                    PageLayout::postError(
                        sprintf(
                            _('Fehler beim Löschen des Raumes %1$s aus dem teilbaren Raum %2$s!'),
                            ($room ? htmlReady($room->name) : _('unbekannt')),
                            ($separable_room ? htmlReady($separable_room->name) : _('unbekannt'))
                        )
                    );
                }
            } else {
                PageLayout::postError(
                    _('Der gewählte Raumteil wurde nicht gefunden!')
                );
            }
        } else {
            $errors          = [];
            $parts_not_found = 0;
            foreach ($room_part_ids as $room_part_id) {
                $separable_room_part = SeparableRoomPart::find(
                    explode('_', $room_part_id)
                );

                if ($separable_room_part) {
                    $room           = $separable_room_part->room;
                    $separable_room = $separable_room_part->separable_room;
                    if ($separable_room_part->delete()) {
                        //Check if the separable room as any parts left.
                        if ($separable_room) {
                            if (count($separable_room->parts) == 0) {
                                //There are no parts left in the separable room
                                //so that it can be deleted, too.
                                $separable_room->delete();
                            }
                        }
                        PageLayout::postSuccess(
                            sprintf(
                                _('Der Raum %1$s wurde aus dem teilbaren Raum %2$s gelöscht!'),
                                ($room ? htmlReady($room->name) : _('unbekannt')),
                                ($separable_room ? htmlReady($separable_room->name) : _('unbekannt'))
                            )
                        );
                    } else {
                        PageLayout::postError(
                            sprintf(
                                _('Fehler beim Löschen des Raumes %1$s aus dem teilbaren Raum %2$s!'),
                                ($room ? htmlReady($room->name) : _('unbekannt')),
                                ($separable_room ? htmlReady($separable_room->name) : _('unbekannt'))
                            )
                        );
                    }
                } else {
                    $parts_not_found++;
                }
            }

            if ($parts_not_found > 0) {
                //Add an error message on top of the other error messages.
                array_unshift(
                    $errors,
                    sprintf(
                        _('%d Raumteile wurden nicht gefunden!'),
                        $parts_not_found
                    )
                );
            }

            if ($errors) {
                PageLayout::postError(
                    ngettext(
                        'Der folgende Fehler trat beim Löschen mehrerer Raumteile auf:',
                        'Die folgenden Fehler traten beim Löschen mehrerer Raumeteile auf:',
                        count($errors)
                    ),
                    $errors
                );
            }
        }
    }


    public function separable_rooms_action()
    {
        if (Navigation::hasItem('/resources/admin/separable_rooms')) {
            Navigation::activateItem('/resources/admin/separable_rooms');
        }

        PageLayout::setTitle(
            _('Teilbare Räume verwalten')
        );

        $this->separable_room_name = '';

        $db = DBManager::get();

        $this->buildings   = [];
        $this->building    = null;
        $this->building_id = Request::get('building_id');

        if ($this->building_id) {
            $this->building = Building::find($this->building_id);
        } else {
            $this->buildings = Building::findAll();
        }

        if (Request::submitted('create_separable_room')) {
            CSRFProtection::verifyUnsafeRequest();

            $selected_single_room_ids  = Request::getArray('selected_single_rooms');
            $this->separable_room_name = Request::get('separable_room_name');

            $resources = Resource::findMany($selected_single_room_ids);

            //Check if all IDs represent rooms:
            $all_rooms = [];
            foreach ($resources as $resource) {
                $resource = $resource->getDerivedClassInstance();
                if ($resource instanceof Room) {
                    $all_rooms[] = $resource;
                }
            }

            if (count($all_rooms) != count($resources)) {
                PageLayout::postError(
                    sprintf(
                        _('Teilbare Räume dürfen nur aus Raum-Objekten bestehen! %d ausgewählte Objekte sind keine Räume!'),
                        count($resources) - count($all_rooms)
                    )
                );
                return;
            }

            //Check if the rooms are already part of other separable rooms:

            $separable_room_part_ids_stmt = $db->prepare(
                'SELECT room_id FROM separable_room_parts
                INNER JOIN separable_rooms
                ON separable_room_parts.separable_room_id = separable_rooms.id
                WHERE separable_rooms.building_id = :building_id'
            );

            $separable_room_part_ids_stmt->execute(
                [
                    'building_id' => $this->building_id,
                ]
            );

            $separable_room_part_ids = $separable_room_part_ids_stmt->fetchAll(
                PDO::FETCH_COLUMN,
                0
            );

            $rooms = [];
            if ($separable_room_part_ids) {
                //There are other separable rooms.
                foreach ($all_rooms as $room) {
                    if (!in_array($room->id, $separable_room_part_ids)) {
                        //The room is not part of another separable room.
                        //We can add it to the final list of rooms
                        //that will be included in the new separable room.
                        $rooms[] = $room;
                    }
                }
            } else {
                //No separable rooms exist: All rooms can be added to
                //a new separable room.
                $rooms = $all_rooms;
            }

            //Now we create a separable room:
            try {
                $separable_room = SeparableRoom::createFromRooms(
                    $this->building_id,
                    $rooms,
                    $this->separable_room_name
                );
                //Reset the separable room name:
                $this->separable_room_name = '';
            } catch (SeparableRoomException $e) {
                //Show a warning for the exception when not all
                //rooms could be added to the separable room:
                PageLayout::postWarning(
                    _('Der teilbare Raum konnte nicht korrekt gespeichert werden!'),
                    [$e->getMessage()]
                );
                return;
            } catch (Exception $e) {
                PageLayout::postError(
                    $e->getMessage()
                );
                return;
            }
        }

        if (Request::submitted('add_room_part')) {
            CSRFProtection::verifyUnsafeRequest();

            $selected_single_room_ids = Request::getArray('selected_single_rooms');

            $resources = Resource::findMany($selected_single_room_ids);

            //Check if all IDs represent rooms:
            $all_rooms = [];
            foreach ($resources as $resource) {
                $resource = $resource->getDerivedClassInstance();
                if ($resource instanceof Room) {
                    $all_rooms[] = $resource;
                }
            }

            if (count($all_rooms) != count($resources)) {
                PageLayout::postError(
                    sprintf(
                        _('Teilbare Räume dürfen nur aus Raum-Objekten bestehen! %d ausgewählte Objekte sind keine Räume!'),
                        count($resources) - count($all_rooms)
                    )
                );
                return;
            }

            //Check if the rooms are already part of other separable rooms:
            $separable_room_part_ids_stmt = $db->prepare(
                'SELECT room_id FROM separable_room_parts
                INNER JOIN separable_rooms
                ON separable_room_parts.separable_room_id = separable_rooms.id
                WHERE separable_rooms.building_id = :building_id'
            );

            $separable_room_part_ids_stmt->execute(
                [
                    'building_id' => $this->building_id,
                ]
            );

            $separable_room_part_ids = $separable_room_part_ids_stmt->fetchAll(
                PDO::FETCH_COLUMN,
                0
            );

            $rooms = [];
            if ($separable_room_part_ids) {
                //There are other separable rooms.
                foreach ($all_rooms as $room) {
                    if (!in_array($room->id, $separable_room_part_ids)) {
                        //The room is not part of another separable room.
                        //We can add it to the final list of rooms
                        //that will be included in the new separable room.
                        $rooms[] = $room;
                    }
                }
            }

            //Get the selected separable room:
            $separable_room_id = Request::get('separable_room_id');
            if ($separable_room_id) {
                $separable_room = SeparableRoom::find($separable_room_id);
                if ($separable_room) {
                    foreach ($rooms as $room) {
                        $separable_room_part = SeparableRoomPart::findOneBySql(
                            'separable_room_id = :separable_room_id
                            AND room_id = :room_id',
                            [
                                'separable_room_id' => $separable_room_id,
                                'room_id'           => $room->id
                            ]
                        );
                        if ($separable_room_part) {
                            PageLayout::postInfo(
                                sprintf(
                                    _('Der Raum %1$s ist bereits Teil des teilbaren Raumes %2$s!'),
                                    htmlReady($room->name),
                                    htmlReady($separable_room->name)
                                )
                            );
                        } else {
                            $separable_room_part                    = new SeparableRoomPart();
                            $separable_room_part->separable_room_id = $separable_room_id;
                            $separable_room_part->room_id           = $room->id;
                            if (!$separable_room_part->store()) {
                                PageLayout::postError(
                                    sprintf(
                                        _('Fehler beim Zuordnen des Raumteiles %1$s zum teilbaren Raum %2$s!'),
                                        htmlReady($room->name),
                                        htmlReady($separable_room->name)
                                    )
                                );
                            }
                        }
                    }
                } else {
                    PageLayout::postError(
                        _('Der gewählte teilbare Raum wurde nicht gefunden!')
                    );
                }
            } else {
                PageLayout::postError(
                    _('Es wurde kein teilbarer Raum ausgewählt!')
                );
            }
        }

        if (Request::submitted('delete_separable_room')) {
            CSRFProtection::verifyUnsafeRequest();

            $delete_separable_room_array = Request::getArray('delete_separable_room');
            $separable_room_id           = array_keys($delete_separable_room_array)[0];
            $this->deleteSeparableRoomsById([$separable_room_id]);
        }

        if (Request::submitted('bulk_delete_separable_rooms')) {
            CSRFProtection::verifyUnsafeRequest();

            $separable_room_ids = Request::getArray('selected_separable_rooms');
            $this->deleteSeparableRoomsById($separable_room_ids);
        }

        if (Request::submitted('delete_room_part')) {
            CSRFProtection::verifyUnsafeRequest();

            $delete_room_part_array = Request::getArray('delete_room_part');
            $room_part_id           = array_keys($delete_room_part_array)[0];
            $this->deleteSeparableRoomPartsById([$room_part_id]);
        }

        if (Request::submitted('bulk_delete_room_parts')) {
            CSRFProtection::verifyUnsafeRequest();

            $room_part_ids = Request::getArray('selected_room_parts');
            $this->deleteSeparableRoomPartsById($room_part_ids);
        }

        //The following code is responsible for displaying rooms
        //and separable rooms:
        if ($this->building_id) {
            //Load all rooms for that building:
            $this->rooms = Room::findByBuilding($this->building_id);

            $this->separable_rooms = SeparableRoom::findBySql(
                'building_id = :building_id',
                [
                    'building_id' => $this->building_id
                ]
            );

            $separable_room_part_ids_stmt = $db->prepare(
                'SELECT room_id FROM separable_room_parts
                INNER JOIN separable_rooms
                ON separable_room_parts.separable_room_id = separable_rooms.id
                WHERE separable_rooms.building_id = :building_id'
            );

            $separable_room_part_ids_stmt->execute(
                [
                    'building_id' => $this->building_id,
                ]
            );

            $separable_room_part_ids = $separable_room_part_ids_stmt->fetchAll(
                PDO::FETCH_COLUMN,
                0
            );

            if ($separable_room_part_ids) {
                $rooms              = $this->building->rooms;
                $this->single_rooms = [];
                foreach ($rooms as $room) {
                    if (!in_array($room->id, $separable_room_part_ids)) {
                        $this->single_rooms[] = $room;
                    }
                }
            } else {
                $this->single_rooms = $this->building->rooms;
            }
        }
    }


    public function configuration_action()
    {
        if (Navigation::hasItem('/resources/admin/configuration')) {
            Navigation::activateItem('/resources/admin/configuration');
        }

        PageLayout::setTitle(
            _('Konfigurationsoptionen')
        );

        $this->config = Config::get();

        $this->resources_booking_plan_start_hour =
            $this->config->RESOURCES_BOOKING_PLAN_START_HOUR;
        $this->resources_booking_plan_end_hour   =
            $this->config->RESOURCES_BOOKING_PLAN_END_HOUR;

        $this->bookingtypes = [
            0 => _('Buchung'),
            1 => _('Reservierung'),
            2 => _('Sperrbuchung'),
            3 => _('geplante Buchung')
        ];

        if (Request::submitted('save')) {

            //Get colors:
            $colours = Request::getArray('colours');

            //Validate:
            CSRFProtection::verifyUnsafeRequest();

            $this->resources_booking_plan_start_hour = Request::get('resources_booking_plan_start_hour');
            $this->resources_booking_plan_end_hour   = Request::get('resources_booking_plan_end_hour');
            //Adjust format of booking plan start and end hours:
            //Add another zero in front of the string, if the hour contains
            //of just one digit.
            if (preg_match('/^[0-9]\:/', $this->resources_booking_plan_start_hour)) {
                $this->resources_booking_plan_start_hour = '0'
                    . $this->resources_booking_plan_start_hour;
            }
            if (preg_match('/^[0-9]\:/', $this->resources_booking_plan_end_hour)) {
                $this->resources_booking_plan_end_hour = '0'
                    . $this->resources_booking_plan_end_hour;
            }

            //Check format of booking plan start and end hours:
            $hour_regex = '/^(([01][0-9])|(2[0-3]))\:[0-5][0-9]$/';
            if (!preg_match($hour_regex, $this->resources_booking_plan_start_hour)) {
                PageLayout::postError(
                    _('Die Startuhrzeit für den Belegungsplan ist im falschen Format!')
                );
                return;
            }
            if (!preg_match($hour_regex, $this->resources_booking_plan_end_hour)) {
                PageLayout::postError(
                    _('Die Enduhrzeit für den Belegungsplan ist im falschen Format!')
                );
                return;
            }
            //Check the time value:
            $begin = strtotime($this->resources_booking_plan_start_hour);
            $end   = strtotime($this->resources_booking_plan_end_hour);
            if ($begin >= $end) {
                PageLayout::postError(
                    _('Die Startuhrzeit für den Belegungsplan darf nicht hinter der Enduhrzeit liegen!')
                );
                return;
            }


            //Store colors:

            foreach ($colours as $colour_id => $value) {
                //Validate value:
                if (!preg_match('/#([0-9A-Fa-f]{2}){3}/', $value)) {
                    PageLayout::postError(
                        sprintf(
                            _('Der Farbwert für %s ist ungültig!'),
                            htmlReady($colour_id)
                        )
                    );
                    return;
                }

                //We don't want to create new colors here so we only
                //modify colors that exist.

                $colour = ColourValue::find($colour_id);
                if ($colour) {
                    //Strip the first character from $value since we don't need
                    //the '#'-character in the database. Furthermore we add 'ff'
                    //to the end of the string to make the color intransparent.
                    $colour->value = mb_strtolower(substr($value, 1)) . 'ff';

                    if ($colour->isDirty()) {
                        if (!$colour->store()) {
                            PageLayout::postError(
                                sprintf(
                                    _('Fehler beim Speichern des Farbwertes für %s!'),
                                    htmlReady($colour_id)
                                )
                            );
                            return;
                        }
                    }
                }
            }

            //Store config values:
            $this->config->store(
                'RESOURCES_ENABLE',
                (bool)Request::get('resources_enable')
            );
            $this->config->store(
                'RESOURCES_ALLOW_ROOM_PROPERTY_REQUESTS',
                (bool)Request::get('resources_allow_room_property_requests')
            );

            $this->config->store(
                'RESOURCES_ALLOW_ROOM_REQUESTS',
                (bool)Request::get('resources_allow_room_requests')
            );

            $this->config->store(
                'RESOURCES_DIRECT_ROOM_REQUESTS_ONLY',
                (bool)Request::get('resources_direct_room_requests_only')
            );

            $this->config->store(
                'RESOURCES_ALLOW_SINGLE_ASSIGN_PERCENTAGE',
                Request::int('resources_allow_single_assign_percentage')
            );

            $this->config->store(
                'RESOURCES_ALLOW_SINGLE_DATE_GROUPING',
                Request::int('resources_allow_single_date_grouping')
            );

            $this->config->store(
                'RESOURCES_MAP_SERVICE_URL',
                Request::get('resources_map_service_url')
            );

            $this->config->store(
                'RESOURCES_MAX_PREPARATION_TIME',
                Request::get('resources_max_preparation_time')
            );
            $this->config->store(
                'RESOURCES_MIN_BOOKING_TIME',
                Request::get('resources_min_booking_time')
            );
            $this->config->store(
                'RESOURCES_DISPLAY_CURRENT_REQUESTS_IN_OVERVIEW',
                Request::get('resources_display_current_requests_in_overview')
            );

            $this->config->store(
                'RESOURCES_BOOKING_PLAN_START_HOUR',
                $this->resources_booking_plan_start_hour
            );
            $this->config->store(
                'RESOURCES_BOOKING_PLAN_END_HOUR',
                $this->resources_booking_plan_end_hour
            );
            $this->config->store(
                'RESOURCES_ADDITIONAL_TEXT_ROOM_EXPORT',
                Studip\Markup::purifyHtml(Request::get('additional_text'))
            );

            $this->config->store(
                'RESOURCES_EXPORT_BOOKINGTYPES_DEFAULT',
                Request::intArray('export_booking_types')
            );

            PageLayout::postSuccess(
                _('Die Konfigurationsoptionen wurden gespeichert!')
            );
        }

        $this->colours = ColourValue::findBySql(
            "colour_id LIKE 'Resources%'
           ORDER BY colour_id ASC"
        );

        $this->export_bookingtypes_default = $this->config->RESOURCES_EXPORT_BOOKINGTYPES_DEFAULT;
    }

    /**
     * This action is called from the resource permission overview page.
     * It is designed to be only called via HTTP POST.
     */
    public function delete_permissions_action()
    {
        CSRFProtection::verifyUnsafeRequest();
        $type = Request::get('permission_type');
        if (!$type) {
            return;
        }
        if ($type === 'permanent' || $type === 'temporary') {
            $user_id = Request::option('user_id');
            $resource_ids = Request::optionArray('resource_ids');
            $deleted = 0;
            if ($type === 'permanent') {
                $deleted = ResourcePermission::deleteBySQL(
                    '`user_id` = :user_id AND `resource_id` IN ( :resource_ids )',
                    [
                        'user_id' => $user_id,
                        'resource_ids' => $resource_ids
                    ]
                );
            } elseif ($type === 'temporary') {
                $deleted = ResourceTemporaryPermission::deleteBySQL(
                    '`user_id` = :user_id AND `resource_id` IN ( :resource_ids )',
                    [
                        'user_id' => $user_id,
                        'resource_ids' => $resource_ids
                    ]
                );
            }
            if ($deleted > 0) {
                PageLayout::postSuccess(sprintf(
                    ngettext(
                        '%u Berechtigung wurde gelöscht.',
                        '%u Berechtigungen wurden gelöscht.',
                        $deleted
                    ),
                    $deleted
                ));
            }
            $this->redirect('resources/admin/user_permissions', ['user_id' => $user_id]);
        } elseif ($type === 'all_from_users') {
            $user_ids = Request::optionArray('user_ids');
            $deleted = ResourcePermission::deleteBySql(
                '`user_id` IN ( :user_ids )',
                ['user_ids' => $user_ids]
            );
            $deleted += ResourceTemporaryPermission::deleteBySql(
                '`user_id` IN ( :user_ids )',
                ['user_ids' => $user_ids]
            );
            if ($deleted > 0) {
                PageLayout::postSuccess(sprintf(
                    ngettext(
                        'Die Berechtigungen von einer Person wurden gelöscht.',
                        'Die Berechtigungen von %u Personen wurden gelöscht.',
                        count($user_ids)
                    ),
                    count($user_ids)
                ));
            }
            $this->redirect('resources/admin/user_permissions');
        }
    }
}