class.ilBookingPreferencesManager.php

Go to the documentation of this file.

<?php

/* Copyright (c) 1998-2019 ILIAS open source, Extended GPL, see docs/LICENSE */

class ilBookingPreferencesManager
{
    const BOOKINGS_PER_USER_DEFAULT = 1;

    protected $pool;

    protected $current_time;

    protected $bookings_per_user;

    protected $book_repo;

    public function __construct(
        ilObjBookingPool $pool,
        ilBookingPrefBasedBookGatewayRepository $book_repo,
        int $current_time = null,
        $bookings_per_user = self::BOOKINGS_PER_USER_DEFAULT
    ) {
        $this->current_time = ($current_time > 0)
            ? $current_time
            : time();
        $this->pool = $pool;
        $this->bookings_per_user = $bookings_per_user;
        $this->book_repo = $book_repo;
    }

    public function isGivingPreferencesPossible()
    {
        if ($this->pool->getScheduleType() == ilObjBookingPool::TYPE_NO_SCHEDULE_PREFERENCES &&
            $this->pool->getPreferenceDeadline() > $this->current_time) {
            return true;
        }
        return false;
    }

    public function isPreferenceDeadlineReached()
    {
        if ($this->pool->getScheduleType() == ilObjBookingPool::TYPE_NO_SCHEDULE_PREFERENCES &&
            $this->pool->getPreferenceDeadline() < $this->current_time) {
            return true;
        }
        return false;
    }

    public function storeBookings($preferences, $booking_object_ids = null)
    {
        $bookings = $this->calculateBookings($preferences, $booking_object_ids);
        $this->book_repo->storeBookings($this->pool->getId(), $bookings);
    }

    public function readBookings()
    {
        $booking_object_ids = array_map(function ($i) {
            return $i["booking_object_id"];
        }, ilBookingObject::getList($this->pool->getId()));
        return $this->book_repo->getBookings($booking_object_ids);
    }


    public function calculateBookings(
        ilBookingPreferences $preferences,
        $booking_object_ids = null,
        $availability = null
    ) {
        $preferences = $preferences->getPreferences();

        // we calculate if a) any preferences are given and b) the deadline is reached
        /*if (!is_array($preferences) || count($preferences) == 0) {
            throw new ilBookingCalculationException("No preferences given.");
        }*/
        if (!$this->isPreferenceDeadlineReached()) {
            throw new ilBookingCalculationException("Preference deadline not reached.");
        }

        if ($booking_object_ids == null) {
            $booking_object_ids = array_map(function ($i) {
                return $i["booking_object_id"];
            }, ilBookingObject::getList($this->pool->getId()));
        }

        if ($availability == null) {
            $availability = [];
            foreach ($booking_object_ids as $book_obj_id) {
                $availability[$book_obj_id] = ilBookingReservation::getNumAvailablesNoSchedule($book_obj_id);
            }
        }

        // remove all objects from the preferences
        // that are already not available anymore
        // see bug 30204 (a tutor booked an object already before and made it unavailable)
        foreach ($availability as $book_obj_id => $cnt) {
            if ($cnt == 0) {
                $preferences = $this->removeObjectFromPreferences($book_obj_id, $preferences);
            }
        }

        $bookings = [];

        $end_phase_one = false;

        // phase one: assign lowest popular items to random user
        while (!$end_phase_one) {
            $popularity = $this->calculatePopularity($booking_object_ids, $preferences);

            $low_pop_book_obj_id = $this->getObjectWithLowestPopularity($popularity, $availability);
            if ($low_pop_book_obj_id > 0) {
                $user_ids = $this->getUsersForObject($preferences, $low_pop_book_obj_id);
                if (count($user_ids) > 0) {
                    $user_id = $this->selectRandomEntry($user_ids);
                    $this->addBooking($bookings, $preferences, $availability, $user_id, $low_pop_book_obj_id);
                }
            } else {
                $end_phase_one = true;
            }
        }

        $end_phase_two = false;

        // choose random user from and assign currently rarely assigned objects
        while (!$end_phase_two) {
            $random_user_id = $this->chooseRandomUserFromPreferences($preferences);
            if ($random_user_id > 0) {
                $rare_assigned_book_obj_id = $this->getMinimalAssignedEntryForUser($booking_object_ids, $bookings, $preferences[$random_user_id], $availability);
                if ($rare_assigned_book_obj_id > 0) {
                    $this->addBooking($bookings, $preferences, $availability, $random_user_id, $rare_assigned_book_obj_id);
                } else {
                    $preferences = $this->removeUserFromPreferences($random_user_id, $preferences);
                }
            } else {
                $end_phase_two = true;
            }
        }
        return $bookings;
    }

    protected function addBooking(&$bookings, &$preferences, &$availability, $user_id, $book_obj_id)
    {
        $bookings[$user_id][] = $book_obj_id;
        $availability[$book_obj_id]--;
        if (count($bookings[$user_id]) >= $this->bookings_per_user) {
            $preferences = $this->removeUserFromPreferences($user_id, $preferences);
        } else {
            $preferences = $this->removePreference($user_id, $book_obj_id, $preferences);
        }
        if ($availability[$book_obj_id] <= 0) {
            $preferences = $this->removeObjectFromPreferences($book_obj_id, $preferences);
        }
    }

    
    protected function selectRandomEntry($items)
    {
        $nr = rand(0, count($items) - 1);
        return $items[$nr];
    }
    
    
    protected function getUsersForObject($preferences, $sel_obj_id)
    {
        $user_ids = [];
        foreach ($preferences as $user_id => $obj_ids) {
            foreach ($obj_ids as $obj_id) {
                if ($obj_id == $sel_obj_id) {
                    $user_ids[] = $user_id;
                }
            }
        }
        return $user_ids;
    }
    
    
    protected function calculatePopularity(array $booking_object_ids, array $preferences)
    {
        $popularity = [];
        foreach ($booking_object_ids as $book_obj_id) {
            $popularity[$book_obj_id] = 0;
        }
        foreach ($preferences as $user_id => $bobj_ids) {
            foreach ($bobj_ids as $bobj_id) {
                $popularity[$bobj_id] += 1;
            }
        }

        return $popularity;
    }


    protected function getObjectWithLowestPopularity($popularity, $availability)
    {
        asort($popularity, SORT_NUMERIC);
        foreach ($popularity as $obj_id => $pop) {
            if ($pop > 0 && $availability[$obj_id] > 0) {
                return (int) $obj_id;
            }
        }
        return 0;
    }

    protected function removePreference($user_id, $obj_id, $preferences)
    {
        if (is_array($preferences[$user_id])) {
            $preferences[$user_id] = array_filter($preferences[$user_id], function ($i) use ($obj_id) {
                return ($i != $obj_id);
            });
        }
        return $preferences;
    }

    protected function removeObjectFromPreferences($obj_id, $preferences)
    {
        $new_preferences = [];
        foreach ($preferences as $user_id => $obj_ids) {
            $new_preferences[$user_id] = array_filter($preferences[$user_id], function ($i) use ($obj_id) {
                return ($i != $obj_id);
            });
        }
        return $new_preferences;
    }

    protected function removeUserFromPreferences($user_id, $preferences)
    {
        if (is_array($preferences[$user_id])) {
            unset($preferences[$user_id]);
        }
        return $preferences;
    }

    protected function chooseRandomUserFromPreferences($preferences)
    {
        $user_ids = array_keys($preferences);
        return $this->selectRandomEntry($user_ids);
    }

    protected function getMinimalAssignedEntryForUser($booking_object_ids, $bookings, $user_preferences, $availability)
    {
        // count the assignments per object
        $count_assignments = [];
        foreach ($booking_object_ids as $obj_id) {
            $count_assignments[$obj_id] = 0;
        }
        foreach ($bookings as $user => $obj_ids) {
            foreach ($obj_ids as $obj_id) {
                $count_assignments[$obj_id]++;
            }
        }

        // sort the objects by number of assignments, return the first one being found in the user preferences
        asort($count_assignments, SORT_NUMERIC);
        foreach ($count_assignments as $obj_id => $cnt) {
            // if no preferences left for user, even assign object outside preferences
            // otherwise choose object from preferences
            if ((count($user_preferences) == 0 || in_array($obj_id, $user_preferences))
                && $availability[$obj_id] > 0) {
                return (int) $obj_id;
            }
        }
        return 0;
    }

    public function hasRun() : bool
    {
        return $this->book_repo->hasRun($this->pool->getId());
    }

    public function resetRun() : void
    {
        $this->book_repo->resetRun($this->pool->getId());
    }
}