Source for file class.NOCHFREI.php

Documentation is available at class.NOCHFREI.php

  1. <?php
  2. error_reporting(E_ALL);
  3.  
  4. /**
  5.  * Stellt die Verbindung zur Datenbank 'nochfrei' her.
  6.  *
  7.  * Stellt Methoden zum Auslesen und schreiben in diese Datenbank zur Verfügung
  8.  *
  9.  * @author Kay Koch, <kay.koch@gmx.de>
  10.  * @package src
  11.  * @subpackage foundation_tables
  12.  */
  13.  
  14. if (0 > version_compare(PHP_VERSION, '5')) {
  15.    die('This file was generated for PHP 5');
  16. }
  17.  
  18. /**
  19.  * Basisklasse aller Klassen mit Datenbankzugriff.
  20.  *
  21.  * stellt Methoden und Objekte zur Fehlermeldung und zum Datenbankzugriff zur
  22.  *
  23.  * @author Kay Koch
  24.  * @since 1.12.04
  25.  * @version 1.1
  26.  */
  27. require_once ('src/foundation/tables/class.PARENTTABLES.php');
  28.  
  29. /* user defined includes */
  30. // section -64--88-122--2-f41e9:1009a89d5b2:-7fd9-includes begin
  31. // section -64--88-122--2-f41e9:1009a89d5b2:-7fd9-includes end
  32.  
  33. /* user defined constants */
  34. // section -64--88-122--2-f41e9:1009a89d5b2:-7fd9-constants begin
  35. // section -64--88-122--2-f41e9:1009a89d5b2:-7fd9-constants end
  36.  
  37. /**
  38.  * Stellt die Verbindung zur Datenbank 'nochfrei' her.
  39.  *
  40.  * Stellt Methoden zum Auslesen und schreiben in diese Datenbank zur Verfügung
  41.  *
  42.  * @access public
  43.  * @author Kay Koch, <kay.koch@gmx.de>
  44.  * @package src
  45.  * @subpackage foundation_tables
  46.  */
  47. class src_foundation_tables_NOCHFREI extends src_foundation_tables_PARENTTABLES {
  48.    // --- ATTRIBUTES ---
  49.  
  50.    
  51.    /**
  52.     * Beinhaltet den Datenbanknamen (nochfrei)
  53.     *
  54.     * @access protected
  55.     * @var string 
  56.     */
  57.    protected $dbTableName = 'nochfrei';
  58.  
  59.    // --- OPERATIONS ---
  60.  
  61.    
  62.    /**
  63.     * liefert ein 2-D Array mit freien Plätzen an allen Tagen die sich
  64.     * in der Datenbank befinden
  65.     *
  66.     * Im ersten Feld befinden sich die freien Plätze pro Tag. Index der
  67.     * Felder ist das Datum im SQL-Format.
  68.     * Im zweiten Feld befindeten sich die zum Tag passende maximale Anzahl an
  69.     * Plätzen. Index auch hier das Datum.
  70.     *
  71.     * @access public
  72.     * @author Kay Koch, <kay.koch@gmx.de>
  73.     * @param date 
  74.     * @return array 
  75.     */
  76.    public function getUsedPerDay($datum = null) {
  77.       $returnValue = array ();
  78.  
  79.       // section -64--88-122--2-f41e9:1009a89d5b2:-7fd5 begin
  80.       try {
  81.          if (!$this->getSea())
  82.             throw new Exception(4);
  83.          // auslesen aller freien Plätze des aktuellen Sees (und eventuell des angegebenen Tages)
  84.          $sql = "SELECT datum, sumTag FROM  $this->dbTableName  WHERE see_id= '" . $this->getSea()->see_id . "'";
  85.          if ($datum != null) // Daten für bestimmten Tag auslesen
  86.             $sql .= " AND datum ='$datum' LIMIT 1";
  87.          else // Daten für die für diesen See geltende Anmeldefrist auslesen
  88.             $sql .= " AND datum > SUBDATE('" . $this->getFlags()->lastBackupDate . "', INTERVAL 6 DAY) AND datum <= ADDDATE('" . $this->getFlags()->lastBackupDate . "', INTERVAL '" . $this->getSea()->wochenImVorraus . "'*7+1 DAY) ";
  89.          $tblNochfrei = $this->select($sql, true);
  90.          // alle Tage durchlaufen
  91.          foreach ($tblNochfrei as $rowNochfrei) {
  92.             // Die zum Datum gehörende maximale Anzahl wird geladen
  93.             $this->oMaxfrei->setParams($this->getSea()->see_id, $rowNochfrei['datum']);
  94.             $rowMaxfrei = $this->oMaxfrei->getRow();
  95.             // speichern der Restplätze
  96.             $returnValue['rest'][$rowNochfrei['datum']] = $rowNochfrei['sumTag'];
  97.             // speichern der maximalen Plätze
  98.             $returnValue['max'][$rowNochfrei['datum']] = $rowMaxfrei['sumTag'];
  99.          }
  100.       } catch (Exception $e) {
  101.          src_tools_ERROR :: setError($e, __METHOD__);
  102.       }
  103.       // section -64--88-122--2-f41e9:1009a89d5b2:-7fd5 end
  104.  
  105.       return (array) $returnValue;
  106.    }
  107.  
  108.    /**
  109.     * liefert ein 2-D Array mit freien Plätzen am gewählten Tag
  110.     *
  111.     * Im ersten Feld befinden sich die freien Plätze pro Stunde. Index der
  112.     * Felder ist die Stunde (hh:mm).
  113.     * Im zweiten Feld befindeten sich die zur Stunde passende maximale Anzahl
  114.     * freien Plätzen. Index auch hier die Stunde.
  115.     *
  116.     * @access public
  117.     * @author Kay Koch, <kay.koch@gmx.de>
  118.     * @param date 
  119.     * @param string 
  120.     * @return array 
  121.     */
  122.    public function getUsedPerHour($datum, $stunde = '*') {
  123.       $returnValue = array ();
  124.  
  125.       // section -64--88-122--2-f41e9:1009a89d5b2:-7f4b begin
  126.       try {
  127.          if (!parent :: getSea())
  128.             throw new Exception(4);
  129.          if (!$datum)
  130.             throw new Exception(4);
  131.          // Anführungsstriche für * verboten, ansonsten ein muss
  132.          $stunde = ($stunde = "*") ? $stunde : "'$stunde'";
  133.          // auslesen aller freien Plätze des aktuellen Sees (alle Stunden) am ausgewählten Tag
  134.          $sql = "SELECT $stunde FROM  $this->dbTableName  WHERE (see_id=" . $this->getSea()->see_id . " AND datum='$datum') LIMIT 1";
  135.          $returnValue = $this->checkAllowedTimeRange($this->select($sql, false), $this->getSea()->see_id, $datum);
  136.       } catch (Exception $e) {
  137.          src_tools_ERROR :: setError($e, __METHOD__);
  138.       }
  139.       // section -64--88-122--2-f41e9:1009a89d5b2:-7f4b end
  140.  
  141.       return (array) $returnValue;
  142.    }
  143.  
  144.    /**
  145.     * Veranlasst die Updates
  146.     *
  147.     * Löscht die Datenbank'nochfrei'.
  148.     * Erstellt neue Datensätze mit der max. Anzahl an freien Plätzen
  149.     *
  150.     * Der frühste und späteste Anmeldetermin wird ausgelesen und für ALLE Seen
  151.     * verwandt.
  152.     * Die Tabelle wird mit den entsprechenden Werten gefüllt.
  153.     * Zusätzlich werden 21 Tage vorher und 14 Tage nachher leere Termine eingefügt
  154.     *
  155.     * @access public
  156.     * @author Kay Koch, <kay.koch@gmx.de>
  157.     * @param int 
  158.     * @param int 
  159.     * @return boolean 
  160.     */
  161.    public function insertNewEntries() {
  162.       $returnValue = (bool) false;
  163.       // section -64--88-122--2-933bcb:100f60e4e57:-7fee begin
  164.       try {
  165.          // Alle alten Termine löschen
  166.          $this->truncate("TRUNCATE TABLE `$this->dbTableName`");
  167.          #$this->truncate("TRUNCATE TABLE `blockaden`");
  168.          $this->truncate("TRUNCATE TABLE `archiv`");
  169.          $this->truncate("TRUNCATE TABLE `buchungen`");
  170.          #$this->truncate("TRUNCATE TABLE `nachttermine`");
  171.          $tableMaxFrei = $this->oMaxfrei->getRow();
  172.          $arrSeen = parent :: $oSeen->all;
  173.          $minDate = "2200-01-01";
  174.          $maxDate = "2000-01-01";
  175.          $arrFeiertage = src_tools_TIME :: getFeiertage();
  176.          // erstes und letztes Datum herausfinden
  177.          foreach ($arrSeen as $see_id => $oSee) {
  178.             $minDate = ($oSee->saisonStart < $minDate) ? $oSee->saisonStart : $minDate; // niedriegstes Datum
  179.             $maxDate = ($oSee->saisonEnde > $maxDate) ? $oSee->saisonEnde : $maxDate; // höchstes Datum
  180.          }
  181.          // zusätzliche Tage am Ende hinzufügen
  182.          $maxDateAdd = src_tools_TIME :: addDays2SQL($maxDate, "21");
  183.          // alle Seen durchlaufen
  184.          foreach ($arrSeen as $see_id => $oSee) {
  185.             // Starttermin zum Einfügen ist drei Wochen vor erstem Datum
  186.             $aktDay = src_tools_TIME :: addDays2SQL($minDate, "-21");
  187.             // 14 Tage vor Beginn mit 0 füllen
  188.             while ($aktDay < $oSee->saisonStart) {
  189.                $sql = "INSERT INTO `$this->dbTableName` (`see_id`,`datum`) VALUES('$see_id','$aktDay');";
  190.                $aktDay = src_tools_TIME :: addDays2SQL($aktDay, "1");
  191.                $this->insert($sql);
  192.             }
  193.             // Tauchzeit mit entsprechenden Werten füllen
  194.             while ($aktDay < $oSee->saisonEnde) {
  195.                $aktWeekDay = (in_array($aktDay, $arrFeiertage)) ? 7 : src_tools_TIME :: sqlT2realT($aktDay, "%w");
  196.                $insertArray = $tableMaxFrei[$see_id][$aktWeekDay];
  197.                $insertArray['wochentag'] = $aktDay;
  198.                $insertString = "('" . join("','", $insertArray) . "')";
  199.                $sql = "INSERT INTO `$this->dbTableName` VALUES $insertString;";
  200.                $aktDay = src_tools_TIME :: addDays2SQL($aktDay, "1");
  201.                $this->insert($sql);
  202.             }
  203.             // bis 14 Tage nach Ende mit 0 füllen
  204.             while ($aktDay < $maxDateAdd) {
  205.                $sql = "INSERT INTO `$this->dbTableName` (`see_id`,`datum`) VALUES('$see_id','$aktDay');";
  206.                $aktDay = src_tools_TIME :: addDays2SQL($aktDay, "1");
  207.                $this->insert($sql);
  208.             }
  209.          }
  210.          // Beginn der Tauchsaison eintragen
  211.          $oFlags = new src_foundation_tables_FLAGS;
  212.          $oFlags->setSaisonDates($minDate, $maxDate);
  213.          src_tools_CACHE :: clearCache();
  214.          $this->saveCalendarFile($see_id);
  215.          $returnValue = true;
  216.       } catch (Exception $e) {
  217.          src_tools_ERROR :: setError($e, __METHOD__);
  218.       }
  219.       // section -64--88-122--2-933bcb:100f60e4e57:-7fee end
  220.  
  221.       return (bool) $returnValue;
  222.    }
  223.  
  224.    /**
  225.     * veringert freie Plätze um übergebenen Wert am übergebenen Tag zur
  226.     * Stunde
  227.     *
  228.     * @access public
  229.     * @author Kay Koch, <kay.koch@gmx.de>
  230.     * @param int 
  231.     * @param date 
  232.     * @param time 
  233.     * @param int 
  234.     * @return int 
  235.     */
  236.    public function decrease($see_id, $datum = null, $stunde = null, $anzahl = 0) {
  237.       $returnValue = (int) 0;
  238.  
  239.       // section -64--88-122--2-933bcb:100f60e4e57:-7faf begin
  240.       $setAdd = ($stunde == "00:00") ? "" : ", `$stunde` = `$stunde`- $anzahl ";
  241.       $sql = "UPDATE " . $this->dbTableName . "  SET `sumTag` = `sumTag`-$anzahl $setAdd WHERE see_id=$see_id AND datum='$datum' LIMIT 1";
  242.       $returnValue = $this->update($sql);
  243.       src_tools_CACHE :: clearCache($see_id);
  244.       $this->saveCalendarFile($see_id);
  245.       // section -64--88-122--2-933bcb:100f60e4e57:-7faf end
  246.  
  247.       return (int) $returnValue;
  248.    }
  249.  
  250.    /**
  251.     * erhöht die Anzal der freie Plätze wenn die Buchung nicht abgeholt wurde
  252.     *
  253.     * @access public
  254.     * @author Kay Koch, <kay.koch@gmx.de>
  255.     * @param int 
  256.     * @param date 
  257.     * @param time 
  258.     * @param int 
  259.     * @return int 
  260.     */
  261.    public function increase($see_id, $datum, $stunde, $anzahl) {
  262.       $returnValue = (int) 0;
  263.  
  264.       // section -64--88-122--2-1328c7a:10297cab611:-7ffe begin
  265.       if ($anzahl != 0) {
  266.          $setAdd = ($stunde == "00:00") ? "" : ", `$stunde` = `$stunde`+'$anzahl' ";
  267.          $sql = "UPDATE " . $this->dbTableName . "  SET `sumTag` = `sumTag`+'$anzahl' $setAdd WHERE see_id='$see_id' AND datum='$datum' LIMIT 1";
  268.          $returnValue = $this->update($sql);
  269.       } else
  270.          $returnValue = true;
  271.       src_tools_CACHE :: clearCache($see_id);
  272.       $this->saveCalendarFile($see_id);
  273.       // section -64--88-122--2-1328c7a:10297cab611:-7ffe end
  274.  
  275.       return (int) $returnValue;
  276.    }
  277.  
  278.    /**
  279.     * überprüft und liefert ein Array mit den freien Plätzen die sich innerhalb
  280.     * erlaubten Tauchbereiches befinden
  281.     *
  282.     * [0]: freie Plätze
  283.     * [1]: maximale Anzahl
  284.     *
  285.     * @access private
  286.     * @author Kay Koch, <kay.koch@gmx.de>
  287.     * @param array 
  288.     * @param int 
  289.     * @param date 
  290.     * @return array 
  291.     */
  292.    private function checkAllowedTimeRange($rowPlaces, $see_id, $datum) {
  293.       $returnValue = array ();
  294.  
  295.       // section -64--88-122--2--264ee0f5:103e4c700eb:-7fc8 begin
  296.       // alle maximalen Plätze für einen Tag und einem See
  297.       $this->oMaxfrei->setParams($see_id, $datum);
  298.       $rowMaxPlaces = $this->oMaxfrei->getRow();
  299.       $startTime = $this->getSea()->getStartTime($datum); // erste angezeigte Uhrzeit
  300.  
  301.       $oNightdive = new src_foundation_tables_NACHTTERMINE();
  302.       $oNightdive->setParams($see_id, $datum);
  303.       if ($oNightdive->isNightDive()) { // ist ein Nachtauchgang
  304.          $endTime = $oNightdive->getChangedEnd(); // Endzeit bei Nachttauchgang
  305.          $rowMaxPlaces = array_merge($rowMaxPlaces, $oNightdive->getMaxNightPlaces()); // maximale Anzahl
  306.       } else {
  307.          $endTime = $this->getSea()->getEndTime($datum); // letzte angezeigt Uhrzeit
  308.       }
  309.       foreach ($rowPlaces as $hour => $places) { // durchlaufen aller Werte
  310.          if ($hour >= $startTime AND $hour <= $endTime) { // erlaubte Uhrzeit
  311.             $returnValue['rest'][$hour] = $places; // RestPlätze
  312.             $returnValue['max'][$hour] = $rowMaxPlaces[$hour]; // maximale Plätze
  313.          }
  314.       }
  315.       // section -64--88-122--2--264ee0f5:103e4c700eb:-7fc8 end
  316.  
  317.       return (array) $returnValue;
  318.    }
  319.  
  320.    /**
  321.     * Konstruktor
  322.     *
  323.     * erstellt ein Objekt der Klasse MAXFREI
  324.     *
  325.     * @access public
  326.     * @author Kay Koch, <kay.koch@gmx.de>
  327.     * @return void 
  328.     */
  329.    public function __construct() {
  330.       // section -64--88-122--2--264ee0f5:103e4c700eb:-7fc3 begin
  331.       $this->oMaxfrei = new src_foundation_tables_MAXFREI();
  332.       // section -64--88-122--2--264ee0f5:103e4c700eb:-7fc3 end
  333.    }
  334.  
  335.    /**
  336.     * liefert alte Einträge
  337.     *
  338.     * @access public
  339.     * @author Kay Koch, <kay.koch@gmx.de>
  340.     * @param int 
  341.     * @return array 
  342.     */
  343.    public function getOLdEntries($see_id = "") {
  344.       $returnValue = array ();
  345.  
  346.       // section -64--88-122--2--6176e79b:103fa06a375:-7fb8 begin
  347.       // lädt alle alten Einträge bis zum nächsten Update (heute + $intervall)
  348.       $weekLimit = $this->getFlags()->getWhereWeekLimit();
  349.       $seeLimit = (!empty ($see_id)) ? "AND `see_id`='$see_id'" : "";
  350.       $sql = "SELECT * FROM " . $this->dbTableName . $weekLimit . " " . $seeLimit . "  ORDER by see_id,datum ASC";
  351.       $returnValue = $this->select($sql, true, "see_id", "datum");
  352.       // section -64--88-122--2--6176e79b:103fa06a375:-7fb8 end
  353.  
  354.       return (array) $returnValue;
  355.    }
  356.  
  357.    /**
  358.     * löscht freie Plätze eines Sees
  359.     *
  360.     * @access public
  361.     * @author Kay Koch, <kay.koch@gmx.de>
  362.     * @param int 
  363.     * @return boolean 
  364.     */
  365.    public function deleteEntriesFromSea($see_id) {
  366.       $returnValue = (bool) false;
  367.  
  368.       // section -64--88-122--2-7189e523:104671b0211:-7fea begin
  369.       // löscht alle Einträge eines Sees
  370.       $sql = "DELETE FROM  $this->dbTableName  WHERE  `see_id` = $see_id";
  371.       if ($this->delete($sql))
  372.          $returnValue = true;
  373.       src_tools_CACHE :: clearCache($see_id);
  374.       $this->saveCalendarFile($see_id);
  375.       // section -64--88-122--2-7189e523:104671b0211:-7fea end
  376.  
  377.       return (bool) $returnValue;
  378.    }
  379.    /**
  380.     *
  381.     * Reduziert die freien Plätze aufgrund von Blokaden
  382.     *
  383.     * @author kaykoch
  384.     * @access public
  385.     * @since 1 - 25.02.2007
  386.     * @param array $data Blockadedaten
  387.     * @return boolean Bestäigung
  388.     *
  389.     */
  390.    public function blockDates($data, $reset = false) {
  391.       $returnValue = false;
  392.       if ($data['ganzerTag'])
  393.          $this->blockDay($data, $reset);
  394.       else
  395.          $this->blockHour($data, $reset);
  396.       src_tools_CACHE :: clearCache($data['see_id']);
  397.       $this->saveCalendarFile($data['see_id']);
  398.       return $returnValue;
  399.    }
  400.    /**
  401.     *
  402.     * blockHour
  403.     *
  404.     * @author kaykoch
  405.     * @access private
  406.     * @since 1 - 02.03.2007
  407.     * @param array $data Daten
  408.     * @return boolean 
  409.     *
  410.     */
  411.    private function blockHour($data, $reset) {
  412.       $returnValue = false;
  413.       $sql = "UPDATE " . $this->dbTableName . "  Set ";
  414.       $nrTime = (int) substr($data['stunde'], 0, 3); // Beginn der Blockade als Int
  415.       $anzahl = ($reset) ? $data['anzahl'] : -1 * $data['anzahl']; // positive Anzahl beim Reset
  416.       //
  417.       for ($i = 0; $i < $data['anzahlStunden']; $i++) {
  418.          $hour = src_tools_TIME :: formatHour($nrTime, $i);
  419.          $sql .= " `sumTag` = `sumTag` + '$anzahl', `$hour` = `$hour` + '$anzahl',";
  420.       }
  421.       $sql = substr($sql, 0, -1); // letztes Komma löschen
  422.       $sql .= $this->getwiederholungSQL($data);
  423.       $returnValue = $this->update($sql);
  424.       return $returnValue;
  425.    }
  426.    /**
  427.     *
  428.     * blockHour
  429.     *
  430.     * @author kaykoch
  431.     * @access private
  432.     * @since 1 - 02.03.2007
  433.     * @param array $data Daten
  434.     * @return boolean 
  435.     *
  436.     */
  437.    private function blockDay($data, $reset) {
  438.       $returnValue = false;
  439.       $this->oMaxfrei->setParams($data['see_id'], $data['datum']);
  440.       $tableMaxFrei = $this->oMaxfrei->getRow();
  441.       unset ($tableMaxFrei['see_id']);
  442.       unset ($tableMaxFrei['wochentag']);
  443.       $sql = "UPDATE `$this->dbTableName`  Set ";
  444.       foreach ($tableMaxFrei as $key => $value) {
  445.          if ($reset)
  446.             $sql .= " `$key` = '$value',";
  447.          else
  448.             $sql .= " `$key` = '0',";
  449.       }
  450.       $sql = substr($sql, 0, -1); // letztes Komma löschen
  451.       $sql .= $this->getwiederholungSQL($data);
  452.       $returnValue = $this->update($sql);
  453.       return $returnValue;
  454.    }
  455.  
  456.    /**
  457.     *
  458.     * erstellt einen String mit WHERE-Klausel
  459.     * abhängig von der art der Wiederholung, Datum und see_id wird der
  460.     * passende WHERE... Sql-Anhang zurückgeliefert
  461.     *
  462.     * @author kaykoch
  463.     * @access public
  464.     * @since 1 - 02.03.2007
  465.     * @param array $data Daten
  466.     * @return string 
  467.     *
  468.     */
  469.    public function getwiederholungSQL($data) {
  470.       $returnValue = " WHERE `see_id` = '" . $data['see_id'] . "'";
  471.       switch ($data['wiederholung']) {
  472.          case 0 : // einmalig
  473.             $returnValue .= " AND `datum` = '" . $data['datum'] . "';";
  474.             break;
  475.          case 1 : // wöchentlich
  476.             $returnValue .= " AND `datum` >= '" . $data['datum'] . "' AND DAYOFWEEK(`datum`) = DAYOFWEEK('" . $data['datum'] . "');";
  477.             break;
  478.          case 2 : // Anzahl Tage
  479.             $returnValue .= " AND `datum` >= '" . $data['datum'] . "' AND `datum` < ADDDATE('" . $data['datum'] . "', INTERVAL " . $data['anzahlWiederholung'] . " DAY);";
  480.             break;
  481.       }
  482.       return $returnValue;
  483.    }
  484.    /**
  485.     *
  486.     * liefert ein 2-D-Array mit den augenblicklichen Werten und den Maximalen
  487.     *
  488.     * @author kaykoch
  489.     * @access public
  490.     * @since 1 - 27.02.2007
  491.     * @param integer $see_id SeeID
  492.     * @param integer $datum Datum
  493.     * @return array $returnValue
  494.     *
  495.     */
  496.    public function getEntry($see_id, $datum) {
  497.       $returnValue = "";
  498.       $sql = "SELECT * FROM " . $this->dbTableName . " WHERE `see_id` ='$see_id' AND `datum`='$datum' LIMIT 1";
  499.       $returnValue = $this->select($sql);
  500.       $this->oMaxfrei->setParams($see_id, $datum);
  501.       $returnValue[] = $this->oMaxfrei->getRow();
  502.       return $returnValue;
  503.    }
  504.  
  505.    /**
  506.     * aktualisiert die Tabelle mit übergebenen Daten
  507.     *
  508.     *
  509.     * @author kaykoch
  510.     * @access public
  511.     * @since 1.1 - 27.02.2007
  512.     * @param array $data neue Einträge
  513.     * @return boolean $returnValue
  514.     *
  515.     */
  516.    public function updateEntry($data) {
  517.       $returnValue = "false";
  518.       $tmp = $data;
  519.       unset ($tmp['see_id']);
  520.       unset ($tmp['datum']);
  521.       $tmp['sumTag'] = array_sum($tmp);
  522.       $sql = "UPDATE " . $this->dbTableName . "  Set ";
  523.       foreach ($tmp as $key => $value) {
  524.          $sql .= " `$key` = '$value',";
  525.       }
  526.       $sql = substr($sql, 0, -1); // letztes Komma löschen
  527.       $sql .= " WHERE `see_id` = '" . $data['see_id'] . " ' AND `datum` = '" . $data['datum'] . "' LIMIT 1;";
  528.       $returnValue = $this->update($sql);
  529.       src_tools_CACHE :: clearCache($data['see_id']);
  530.       $this->saveCalendarFile($data['see_id']);
  531.       return $returnValue;
  532.    }
  533.  
  534.    /**
  535.     * erstellt ein Kalenderfile im ics-Format
  536.     * Die Datei wird im infos-ordner unter dem Namen
  537.     * "kalender_seename.ics" abgespeichert
  538.     *
  539.     * @author kaykoch
  540.     * @access public
  541.     * @since 1 - 11.03.2007
  542.     * @param int see_id id des Sees
  543.     * @return boolean $returnValue
  544.     *
  545.     */
  546.    public function saveCalendarFile($see_id = "") {
  547.       $i = 1;
  548.       foreach ($this->getOLdEntries($see_id) as $see_id => $arrDates) {
  549.          $content = "BEGIN:VCALENDAR\nCALSCALE:GREGORIAN\nPRODID:-//Ximian//NONSGML Evolution Calendar//EN\nVERSION:2.0\n";
  550.          $oSee = parent :: $oSeen->getSeen($see_id);
  551.          if ($oSee->buchbarProTag) {
  552.             $rowTpl = src_tools_TEMPLATE :: getTemplate("calendar_day");
  553.             foreach ($arrDates as $arrDate) {
  554.                $icsDatum1 = src_tools_TIME :: sqlT2realT($arrDate['datum'], "%Y%m%d");
  555.                $icsDatum2 = src_tools_TIME :: sqlT2realT(src_tools_TIME :: addDays2SQL($arrDate['datum'], 1), "%Y%m%d");
  556.                $content .= sprintf($rowTpl, $i++, $icsDatum1, $icsDatum2, $arrDate['sumTag']);
  557.             }
  558.          } else {
  559.             $rowTpl = src_tools_TEMPLATE :: getTemplate("calendar_hour");
  560.             foreach ($arrDates as $arrDate) {
  561.                $icsDatum = src_tools_TIME :: sqlT2realT($arrDate['datum'], "%Y%m%dT");
  562.                $startTime = $oSee->getStartTime($arrDate['datum']);
  563.                $endTime = $oSee->getEndTime($arrDate['datum']);
  564.                foreach ($arrDate as $hour => $places) {
  565.                   if (src_tools_CHECK :: checkHour($hour) AND $hour >= $startTime AND $hour <= $endTime) {
  566.                      $icsStunde1 = substr($hour, 0, 2) . "0000";
  567.                      $icsStunde2 = sprintf('%02d', (int) $hour +1) . "0000";
  568.                      $content .= sprintf($rowTpl, $i++, $icsDatum . $icsStunde1, $icsDatum . $icsStunde2, $places);
  569.                   }
  570.                }
  571.  
  572.             }
  573.          }
  574.          $content .= "END:VCALENDAR";
  575.          src_tools_MULTI :: saveFile($content, src_tools_MULTI :: cleanUmlaute("infos/kalender_" . $oSee->name) . ".ics");
  576.       }
  577.    }
  578.  
  579.    /**
  580.     * liest alle Blockaden und Nachttermine neu in die Nochfrei/Buchungen ein
  581.     *
  582.     * @author kaykoch
  583.     * @access public
  584.     * @since 1 - 11.03.2007
  585.     * @return boolean $returnValue
  586.     *
  587.     */
  588.    public function insertSpecials() {
  589.       $oNTG = new src_foundation_tables_NACHTTERMINE();
  590.       $arrNTGS = $oNTG->getRow();
  591.       foreach ($arrNTGS as $arrData) {
  592.          foreach ($arrData as $data) {
  593.             $ft = (int) "21"; // erste Uhrzeit für NTGs
  594.             $lt = (int) substr($data['uhrzeitEnde'], 0, 3); // letzte Uhrzeit für NTGs
  595.             $sub = 1;
  596.             for ($h = $ft; $h <= $lt; $h++) {
  597.                if (!$this->increase($data['see_id'], $data['datum'], $h . ":00", $sub * $data[$h . ":00"]))
  598.                   die("NTG");
  599.             }
  600.          }
  601.       }
  602.       $oBlock = new src_foundation_tables_BLOCKADEN();
  603.       $oBuchungen = new src_foundation_tables_BUCHUNGEN();
  604.       $oVereine = new src_foundation_tables_VEREINE();
  605.       $arrBlocks = $oBlock->getRowByID();
  606.       foreach ($arrBlocks as $data) {
  607.          $oVereine->setParams($data['verein_nr']);
  608.          $data['name'] = (!empty ($data['info'])) ? $oVereine->name . ", " . $data['info'] : $oVereine->name;
  609.          $this->blockDates($data);
  610.          $oBuchungen->blockDates($data);
  611.       }
  612.  
  613.    }
  614. } /* end of class src_foundation_tables_NOCHFREI */
  615. ?>

Documentation generated on Sat, 24 Mar 2007 09:59:43 +0100 by phpDocumentor 1.3.1