MetaDate.class.php

<?php
# Lifter002: TODO
# Lifter007: TODO
# Lifter003: TODO
# Lifter010: TODO
// +--------------------------------------------------------------------------+
// This file is part of Stud.IP
// MetaDate.class.php
//
// Repräsentiert die Zeit- und Turnusdaten einer Veranstaltung
//
// +--------------------------------------------------------------------------+
// 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 any later version.
// +--------------------------------------------------------------------------+
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
// +--------------------------------------------------------------------------+


/**
 * MetaDate.class.php
 *
 *
 * @author      Till Glöggler <tgloeggl@uos.de>
 * @version     28. Juni 2007
 * @access      protected
 * @package     raumzeit
 */
class MetaDate
{
    var $seminar_id          = '';
    var $seminarStartTime    = 0;
    var $seminarDurationTime = 0;
    var $cycles              = [];
    var $hasDatesTmp         = [];

    /**
     * Constructor
     * @param string $seminar_id
     */
    function __construct($seminar_id = '')
    {
        if ($seminar_id != '') {
            $this->seminar_id = $seminar_id;
            $this->restore();
        }

    }

    /**
     * returns start week (Semesterwoche) for a cycledate
     * for compatibility the first cycledate is chosen if no one is specified
     *
     * @deprecated
     * @param string id of cycledate
     * @return int
     */
    function getStartWoche($metadate_id = null)
    {
        if ($metadate_id) {
            return $this->cycles[$metadate_id]->week_offset;
        } else {
            $first_metadate = $this->getFirstMetadate();
            return $first_metadate ? $first_metadate->week_offset : null;
        }
    }

    /**
     * sets start week (Semesterwoche) for a cycledate
     * for compatibility the first cycledate is chosen if no one is specified
     *
     * @deprecated
     * @param int    $start_woche
     * @param string $metadate_id
     * @return null|Ambigous <NULL, unknown>
     */
    function setStartWoche($start_woche, $metadate_id = null)
    {
        if ($metadate_id) {
            return $this->cycles[$metadate_id]->week_offset = $start_woche;
        } else {
            $first_metadate = $this->getFirstMetadate();
            return $first_metadate ? $first_metadate->week_offset = $start_woche : null;
        }
    }

    /**
     * returns first cycledate
     *
     * @return CycleData
     */
    function getFirstMetadate()
    {
        $cycles = array_keys($this->cycles);
        $first_metadate_id = array_shift($cycles);
        return $first_metadate_id ? $this->cycles[$first_metadate_id] : null;
    }

    /**
     * returns the cycle for a cycledate
     * for compatibility the first cycledate is chosen if no one is specified
     *
     * @deprecated
     * @param string $metadate_id
     * @return int 0,1,2 for weekly, biweekly ...
     */
    function getTurnus($metadate_id = null)
    {
        if ($metadate_id) {
            return $this->cycles[$metadate_id]->cycle;
        } else {
            $first_metadate = $this->getFirstMetadate();
            return $first_metadate ? $first_metadate->cycle : null;
        }
    }

    /**
     * set the cycle for a cycledate
     * for compatibility the first cycledate is chosen if no one is specified
     *
     * @deprecated
     * @param        int 0,1,2 for weekly, biweekly ...
     * @param string $metadate_id
     * @return int
     */
    function setTurnus($turnus, $metadate_id = null)
    {
        if ($metadate_id) {
            return $this->cycles[$metadate_id]->cycle = $turnus;
        } else {
            $first_metadate = $this->getFirstMetadate();
            return $first_metadate ? $first_metadate->cycle = $turnus : null;
        }
    }

    function setSeminarStartTime($start)
    {
        $this->seminarStartTime = $start;
    }

    function setSeminarDurationTime($duration)
    {
        $this->seminarDurationTime = $duration;
    }

    function getSeminarID()
    {
        return $this->seminar_id;
    }

    /**
     * internal method to apply cycledate data from assoc array to a given
     * CycleData object. checks the start and endtime and retruns false if wrong
     *
     * @deprecated
     * @param           array assoc, see CycleData, metadate_id must be in $data['cycle_id']
     * @param CycleData $cycle
     * @return boolean
     */
    function setCycleData($data, $cycle)
    {
        $cycle->seminar_id = $this->getSeminarId();
        $cycles = array_keys($this->cycles);
        if ($last_one = array_pop($cycles)) {
            $cycle->sorter = $this->cycles[$last_one]->sorter > 0 ? $this->cycles[$last_one]->sorter + 1 : 0;
        }
        if ($cycle->getDescription() != $data['description']) {
            $cycle->setDescription($data['description']);
        }

        if (isset($data['weekday'])) $cycle->weekday = (int)$data['weekday'];
        if (isset($data['week_offset'])) $cycle->week_offset = (int)$data['week_offset'];
        if (isset($data['cycle'])) $cycle->cycle = (int)$data['cycle'];
        if (isset($data['sws'])) $cycle->sws = $data['sws'];
        if (isset($data['endWeek'])) $cycle->end_offset = (int)$data['endWeek'];
        if (isset($data['day']) && isset($data['start_stunde']) && isset($data['start_minute']) && isset($data['end_stunde']) && isset($data['end_minute'])) {

            if (
                ($data['start_stunde'] > 23) || ($data['start_stunde'] < 0) ||
                ($data['end_stunde'] > 23) || ($data['end_stunde'] < 0) ||
                ($data['start_minute'] > 59) || ($data['start_minute'] < 0) ||
                ($data['end_minute'] > 59) || ($data['end_minute'] < 0)
            ) {
                return FALSE;
            }

            if (mktime((int)$data['start_stunde'], (int)$data['start_minute']) < mktime((int)$data['end_stunde'], (int)$data['end_minute'])) {
                $cycle->setDay($data['day']);
                $cycle->setStart($data['start_stunde'], $data['start_minute']);
                $cycle->setEnd($data['end_stunde'], $data['end_minute']);
                return TRUE;
            }
        }

        return FALSE;
    }


    /**
     * adds a new cycledate, single dates are created if second param is true
     *
     * @param      array assoc, see CycleData, metadate_id must be in $data['cycle_id']
     * @param bool $create_single_dates
     * @return string|boolean metadate_id of created cycle
     */
    function addCycle($data = [], $create_single_dates = true)
    {
        $data['day'] = (int)$data['day'];
        $data['start_stunde'] = (int)$data['start_stunde'];
        $data['start_minute'] = (int)$data['start_minute'];
        $data['end_stunde'] = (int)$data['end_stunde'];
        $data['end_minute'] = (int)$data['end_minute'];

        $cycle = new CycleData();

        if ($this->setCycleData($data, $cycle)) {
            $this->cycles[$cycle->getMetadateID()] = $cycle;
            $this->sortCycleData();
            if ($create_single_dates) $this->createSingleDates($cycle->getMetadateID());
            return $cycle->getMetadateID();
        }
        return FALSE;
    }

    /**
     * change existing cycledate, changes also corresponding single dates
     *
     * @param array assoc, see CycleData, metadate_id must be in $data['cycle_id']
     * @return number|boolean
     */
    function editCycle($data = [])
    {
        $cycle = $this->cycles[$data['cycle_id']];
        $new_start = mktime((int)$data['start_stunde'], (int)$data['start_minute']);
        $new_end = mktime((int)$data['end_stunde'], (int)$data['end_minute']);
        $old_start = mktime($cycle->getStartStunde(), $cycle->getStartMinute());
        $old_end = mktime($cycle->getEndStunde(), $cycle->getEndMinute());

        if (($new_start >= $old_start) && ($new_end <= $old_end) && ($data['day'] == $cycle->day) && ($data['endWeek'] == $cycle->end_offset)) {
            // Zeitraum wurde verkuerzt, Raumbuchungen bleiben erhalten...
            if ($this->setCycleData($data, $cycle)) {
                $termine = $cycle->getSingleDates();
                foreach ($termine as $key => $val) {
                    $tos = $val->getStartTime();
                    $toe = $val->getEndTime();
                    if ($toe > time()) {
                        $t_start = mktime((int)$data['start_stunde'], (int)$data['start_minute'], 0, date('m', $tos), date('d', $tos), date('Y', $tos));
                        $t_end = mktime((int)$data['end_stunde'], (int)$data['end_minute'], 0, date('m', $toe), date('d', $toe), date('Y', $toe));
                        $termine[$key]->setTime($t_start, $t_end);
                        $termine[$key]->store();
                    } else {
                        unset($termine[$key]);
                    }
                }
                $this->sortCycleData();
            }
            return sizeof($termine);
        } else {
            if ($this->setCycleData($data, $cycle)) {
                // collect all existing themes (issues) for this cycle:
                $issues = [];
                $issue_objects = [];
                $singledate_count = 0;

                // loop through the single dates and look for themes (issues)
                $termine = $cycle->getSingleDates();
                foreach ($termine as $key => $termin) {
                    // get all isues of this date ( zero, one, or more, if the expert view is activated)
                    // and store them at the relative position of this single date
                    $issues[$singledate_count] = $termin->getIssueIDs();
                    $singledate_count++;
                }
                // remove all SingleDates in the future for this CycleData
                $count = CycleDataDB::deleteNewerSingleDates($data['cycle_id'], time());
                // create new SingleDates
                $this->createSingleDates(['metadate_id'         => $cycle->getMetaDateId(),
                                               'startAfterTimeStamp' => time()
                ]);

                // clear all loaded SingleDates so no odd ones remain. The Seminar-Class will load them fresh when needed
                $cycle->termine = NULL;

                // read all new single dates
                $termine = $cycle->getSingleDates();

                // new dates counter
                $new_singledate_count = 0;

                // loop through the single dates and add the themes (issues)
                foreach ($termine as $key => $termin) {
                    // check, if there are issues for this single date
                    if ($issues[$new_singledate_count] != NULL) {
                        // add all issues:
                        foreach ($issues[$new_singledate_count] as $issue_key => $issue_id) {
                            $termin->addIssueID($issue_id);
                            $termin->store();
                        }
                    }
                    unset($issues[$new_singledate_count]);
                    $new_singledate_count++;
                }

                // delete issues, that are not assigned to a single date because of to few dates
                // (only if the schedule expert view is off)
                if (!Config::get()->RESOURCES_ENABLES_EXPERT_SCHEDULE_VIEW) {
                    if ($new_singledate_count < $singledate_count) {
                        for ($i = $new_singledate_count; $i < $singledate_count; $i++) {
                            if ($issues[$i] != NULL) {
                                foreach ($issues[$i] as $issue_id) {
                                    // delete this issue
                                    IssueDB::deleteIssue($issue_id);
                                }
                            }
                        }
                    }
                }
                $this->sortCycleData();
                return $count;
            }
        }
        return FALSE;
    }

    /**
     * completey remove cycledate
     * @see CycleData::delete()
     * @param string $cycle_id
     * @return boolean
     */
    function deleteCycle($cycle_id)
    {
        $this->cycles[$cycle_id]->delete();
        unset ($this->cycles[$cycle_id]);
        return TRUE;
    }

    function deleteSingleDate($cycle_id, $date_id, $filterStart, $filterEnd)
    {
        $this->cycles[$cycle_id]->deleteSingleDate($date_id, $filterStart, $filterEnd);
    }

    function unDeleteSingleDate($cycle_id, $date_id, $filterStart, $filterEnd)
    {
        return $this->cycles[$cycle_id]->unDeleteSingleDate($date_id, $filterStart, $filterEnd);
    }

    /**
     * store all changes to cycledates for the course, removed cycles are deleted from database
     * @return int > 0 if changes where made
     */
    function store()
    {
        $old_cycle_dates = [];
        $changed = 0;
        foreach (SeminarCycleDate::findBySeminar($this->seminar_id) as $c) {
            $old_cycle_dates[$c->getId()] = $c;
        }
        $removed = array_diff(array_keys($old_cycle_dates), array_keys($this->cycles));
        foreach ($removed as $one) {
            $changed += $old_cycle_dates[$one]->delete();
        }
        foreach ($this->cycles as $one) {
            $changed += $one->storeCycleDate();
        }
        $this->sortCycleData();
        return $changed;
    }


    /**
     * load all cycledates from database
     */
    function restore()
    {
        $this->cycles = [];
        foreach (SeminarCycleDate::findBySeminar($this->seminar_id) as $c) {
            $this->cycles[$c->getId()] = new CycleData($c);
        }
        $this->sortCycleData();
    }

    function delete($removeSingleDates = TRUE)
    {
        //TODO: Löschen eines MetaDate-Eintrages (CycleData);
    }

    /**
     * sort cycledates by sorter column and date
     */
    function sortCycleData()
    {
        uasort($this->cycles, function ($a, $b) {
            return $a->sorter - $b->sorter
                ?: $a->weekday - $b->weekday
                ?: $a->start_hour - $b->start_hour;
        });
    }

    /**
     * returns cycledates as arrays
     *
     * @param bool $show_invisibles if cycles without dates should
     *                              be in the array, defaults to false
     * @return array assoc of cycledate data arrays
     */
    function getCycleData($show_invisibles = false)
    {
        $ret = [];

        foreach ($this->cycles as $val) {
            if ($val->is_visible || $show_invisibles) {
                $ret[$val->getMetaDateID()] = $val->toArray();
            }
        }
        return $ret;
    }

    /**
     * returns the cycledate objects
     * @return array of CycleData objects
     */
    function getCycles()
    {
        return $this->cycles;
    }

    /**
     * returns an array of SingleDate objects corresponding to the given cycle id
     * use the optional params to specify a timerange
     *
     * @param string a cycle id
     * @param int    unix timestamp
     * @param int    unix timestamp
     * @return array of SingleDate objects
     */
    function getSingleDates($metadate_id, $filterStart = 0, $filterEnd = 0)
    {
        if (!$this->cycles[$metadate_id]->termine) {
            $this->readSingleDates($metadate_id, $filterStart, $filterEnd);
        }

        return $this->cycles[$metadate_id]->termine;
    }

    /**
     * reload SingleDate objects for a given cycle id
     *
     * @param string $metadate_id
     * @param int    $start
     * @param int    $end
     * @return bool
     */
    function readSingleDates($metadate_id, $start = 0, $end = 0)
    {
        return $this->cycles[$metadate_id]->readSingleDates($start, $end);
    }

    /**
     * returns true if a given cycle has at least one date at all or in the given time range
     *
     * @param string $metadate_id
     * @param int $filterStart
     * @param int $filterEnd
     * @return bool
     */
    function hasDates($metadate_id, $filterStart = 0, $filterEnd = 0)
    {
        if (!isset($this->hasDatesTmp[$metadate_id])) {
            $this->hasDatesTmp[$metadate_id] = MetaDateDB::has_dates($metadate_id, $this->getSeminarID(), $filterStart, $filterEnd);
        }

        return $this->hasDatesTmp[$metadate_id];
    }

    /**
     * create single dates for one cycle and all semester and store them in database, deleting obsolete ones
     *
     * @param mixed cycle id (string) or array with 'metadate_id' => string cycle id, 'startAfterTimeStamp' => int timestamp to override semester start
     */
    function createSingleDates($data)
    {
        foreach ($this->getVirtualSingleDates($data) as $semester_id => $dates_for_semester) {
            list($dates, $dates_to_delete) = array_values($dates_for_semester);
            foreach ($dates_to_delete as $d) $d->delete();
            foreach ($dates as $d) {
                if ($d->isUpdate()) continue; //vorhandene Termine nicht speichern wg. chdate
                $d->store();
            }
        }
        //das sollte nicht nötig sein, muss aber erst genauer untersucht werden
        $this->store();
        $this->restore();
    }

    /**
     * generate single date objects for one cycle and all semester, existing dates are merged in
     *
     * @param mixed cycle id (string) or array with 'metadate_id' => string cycle id, 'startAfterTimeStamp' => int timestamp to override semester start
     * @return array array of arrays, for each semester id  an array of two arrays of SingleDate objects: 'dates' => all new and surviving dates, 'dates_to_delete' => obsolete dates
     */
    function getVirtualSingleDates($data)
    {
        if (is_array($data)) {
            $metadate_id = $data['metadate_id'];
            $startAfterTimeStamp = $data['startAfterTimeStamp'];
        } else {
            $metadate_id = $data;
            $startAfterTimeStamp = 0;
        }

        $ret = [];

        $all_semester = Semester::findAllVisible(false);
        $sem_begin = null;
        $sem_end = null;
        // get the starting-point for creating singleDates for the choosen cycleData
        foreach ($all_semester as $val) {
            if (($this->seminarStartTime >= $val["beginn"]) && ($this->seminarStartTime <= $val["ende"])) {
                $sem_begin = mktime(0, 0, 0, date("n", $val["vorles_beginn"]), date("j", $val["vorles_beginn"]), date("Y", $val["vorles_beginn"]));
            }
        }

        // get the end-point
        if ($this->seminarDurationTime == -1) {
            foreach ($all_semester as $val) {
                $sem_end = $val['vorles_ende'];
            }
        } else {
            $i = 0;
            foreach ($all_semester as $val) {
                $i++;
                $timestamp = $this->seminarDurationTime + $this->seminarStartTime;
                if (($timestamp >= $val['beginn']) && ($timestamp <= $val['ende'])) {
                    $sem_end = $val["vorles_ende"];
                }
            }
        }

        $passed = false;
        foreach ($all_semester as $val) {
            if ($sem_begin <= $val['vorles_beginn']) {
                $passed = true;
            }
            if ($passed && ($sem_end >= $val['vorles_ende']) && ($startAfterTimeStamp <= $val['ende'])) {
                // correction calculation, if the semester does not start on monday
                $dow = date("w", $val['vorles_beginn']);
                if ($dow <= 5)
                    $corr = ($dow - 1) * -1;
                elseif ($dow == 6)
                    $corr = 2;
                elseif ($dow == 0)
                    $corr = 1;
                else
                    $corr = 0;
                $ret[$val['semester_id']] = $this->getVirtualSingleDatesForSemester($metadate_id, $val['vorles_beginn'], $val['vorles_ende'], $startAfterTimeStamp, $corr);
            }
        }

        return $ret;
    }

    /**
     * generate single date objects for one cycle and one semester, existing dates are merged in
     *
     * @param string cycle id
     * @param int    timestamp of semester start
     * @param int    timestamp of semester end
     * @param int    alternative timestamp to start from
     * @param int    correction calculation, if the semester does not start on monday (number of days?)
     * @return array returns an array of two arrays of SingleDate objects: 'dates' => all new and surviving dates, 'dates_to_delete' => obsolete dates
     */
    function getVirtualSingleDatesForSemester($metadate_id, $sem_begin, $sem_end, $startAfterTimeStamp, $corr)
    {
        $dates = [];
        $dates_to_delete = [];

        // loads the singledates of the by metadate_id denoted regular time-entry into the object
        $this->readSingleDates($metadate_id);

        // The currently existing singledates for the by metadate_id denoted  regular time-entry
        $existingSingleDates =& $this->cycles[$metadate_id]->getSingleDates();

        $start_woche = $this->cycles[$metadate_id]->week_offset;
        $end_woche = $this->cycles[$metadate_id]->end_offset;

        $turnus = $this->cycles[$metadate_id]->cycle;

        // This variable is used to check if a given singledate shall be created in a bi-weekly seminar.
        if ($start_woche == -1) $start_woche = 0;

        $week = 0;

        // get the first presence date after sem_begin
        $day_of_week = date('l', strtotime('Sunday + ' . $this->cycles[$metadate_id]->day . ' days'));
        $stamp = strtotime('this week ' . $day_of_week, $sem_begin);

        $start_time = mktime(
            (int)$this->cycles[$metadate_id]->start_stunde,     // Hour
            (int)$this->cycles[$metadate_id]->start_minute,     // Minute
            0,                                                  // Second
            date("n", $stamp),                                  // Month
            date("j", $stamp),                                  // Day
            date("Y", $stamp));                                 // Year

        $end_time = mktime(
            (int)$this->cycles[$metadate_id]->end_stunde,       // Hour
            (int)$this->cycles[$metadate_id]->end_minute,       // Minute
            0,                                                  // Second
            date("n", $stamp),                                  // Month
            date("j", $stamp),                                  // Day
            date("Y", $stamp));                                 // Year

        // loop through all possible singledates for this regular time-entry
        do {

            // if dateExists is true, the singledate will not be created. Default is of course to create the singledate
            $dateExists = false;

            // do not create singledates if they are earlier than the semester start
            if ($end_time < $sem_begin) $dateExists = true;

            // do not create singledates, if they are earlier then the chosen start-week
            if ($start_woche > $week || (isset($end_woche) && $week > $end_woche)) $dateExists = true;

            // bi-weekly check
            if ($turnus > 0 && ($week - $start_woche) > 0 && (($week - $start_woche) % ($turnus + 1))) {
                $dateExists = true;
            }

            /*
             * We only create dates, which do not already exist, so we do not overwrite existing dates.
             *
             * Additionally, we delete singledates which are not needed any more (bi-weekly, changed start-week, etc.)
             */
            foreach ($existingSingleDates as $key => $val) {
                // take only the singledate into account, that maps the current timepoint
                if ($start_time > $startAfterTimeStamp && ($val->date == $start_time) && ($val->end_time == $end_time)) {

                    // bi-weekly check
                    if ($turnus > 0 && ($week - $start_woche) > 0 && (($week - $start_woche) % ($turnus + 1))) {
                        $dates_to_delete[$key] = $val;
                        unset($existingSingleDates[$key]);
                    }

                    // delete singledates if they are earlier than the chosen start-week
                    if ($start_woche > $week || (isset($end_woche) && $week > $end_woche)) {
                        $dates_to_delete[$key] = $val;
                        unset($existingSingleDates[$key]);
                    }

                    $dateExists = true;
                    if (isset($existingSingleDates[$key])) {
                        $dates[$key] = $val;
                    }
                }
            }

            if ($start_time < $startAfterTimeStamp) {
                $dateExists = true;
            }

            if (!$dateExists) {

                $termin = new SingleDate(['seminar_id' => $this->seminar_id]);

                $all_holiday = SemesterHoliday::getAll(); // fetch all Holidays
                foreach ($all_holiday as $val2) {
                    if (($val2["beginn"] <= $start_time) && ($start_time <= $val2["ende"])) {
                        $termin->setExTermin(true);
                    }
                }

                //check for calculatable holidays
                if (!$termin->isExTermin()) {
                    $holy_type = holiday($start_time);
                    if ($holy_type["col"] == 3) {
                        $termin->setExTermin(true);
                    }
                }

                // fill the singleDate-Object with data
                $termin->setMetaDateID($metadate_id);
                $termin->setTime($start_time, $end_time);
                $termin->setDateType(1); //best guess

                $dates[$termin->getTerminID()] = $termin;
            }

            //inc the week, create timestamps for the next singledate
            $start_time = strtotime('+1 week', $start_time);
            $end_time = strtotime('+1 week', $end_time);

            $week++;

        } while ($end_time < $sem_end);

        return ['dates' => $dates, 'dates_to_delete' => $dates_to_delete];
    }
}