/Applications/XAMPP/xamppfiles/htdocs/nanofabrication/modules/calendar/classes/RepeatEvent.class.php

Go to the documentation of this file.

<?php
class modules_calendar_RepeatEvent {

        public static $EX_INVALID_FREQUENCY = 501;
        
        public static $EX_INVALID_REPEAT_ID=502;
        

        private static $REPEAT_TABLE='dataface__calendar_repeats';
        
        private static $module = null;
        
        private $sourceRecord;
        
        private $startDate;
        
        private $expiryDate;
        
        
        private $frequency;
        private $frequencyChanged=false;
        
        private $_isSaved;
        
        private $startAtt;
        
        private $endAtt;
        
        private $repeatAtt;
        
        
        public static function createRepeatTable(){
                $tname = self::$REPEAT_TABLE;
                $sql = "create table if not exists `$tname` (
                        tablename varchar(200) not null,
                        repeat_id int(11) not null,
                        repeat_type enum('Daily','Weekly','Biweekly','Weekdays','Monthly','Yearly') default 'Weekly',
                        repeat_start_date datetime,
                        repeat_expire_date datetime,
                        primary key (tablename,repeat_id)
                        )
                        ";
                        
                return self::query($sql);
                
                
                
                
        }
        
        
        public static function dropRepeatTable(){
                $tname = self::$REPEAT_TABLE;
                $sql = "drop table if exists `$tname`";
                return self::query($sql);
        }
        
        private static function query($sql){
                $res = mysql_query($sql, df_db());
                if ( !$res ){
                        throw new Exception(mysql_error(df_db()));
                }
                return $res;
        }
        
        private static function cleanIdent($val){
                return str_replace('`','',$val);
        }
        
        private static function queryRepeats($sql){
        
                try {
                        return self::query($sql);
                } catch (Exception $ex){
                        self::createRepeatTable();
                        
                }
                return self::query($sql);
        }
        
        public static function getModule(){
                if ( !isset(self::$module) ){
                        self::$module = Dataface_ModuleTool::getInstance()->loadModule('modules_calendar');
                }
                return self::$module;
        }
        
        private function getAtt($name){
                $att = self::getModule()
                        ->loadOntology($this->sourceRecord->table()->tablename)
                        ->getFieldname($name);
                        
                if ( PEAR::isError($att) ){
                        throw new Exception("No start attribute found for table.");
                }
                return $att;
        }
        
        public function getStartAtt(){
                return $this->getAtt('start');
        }
        
        
        public function getEndAtt(){
                return $this->getAtt('end');
        }
        
        public function getRepeatAtt(){
                return $this->getAtt('repeat');
        }
        
        public function getRepeatSeedAtt(){
                return $this->getAtt('repeat_seed');
        }
        
        public function getSourceStart(){
                return $this->sourceRecord->strval($this->getStartAtt());
        }
        
        public function getSourceEnd(){
                return $this->sourceRecord->strval($this->getEndAtt());
        }
        
        public function getRepeatID(){
                return $this->sourceRecord->val($this->getRepeatAtt());
        }
        
        public function __construct(Dataface_Record $source){
                $this->sourceRecord = $source;
                $this->loadRepeatInfo();
        }
        
        
        
        public function loadRepeatInfo(){
                if ( !$this->getRepeatID() ){
                        
                        return;
                }
                $sql = sprintf("select * from `%s` where `tablename`='%s' and `repeat_id`=%d",
                        self::cleanIdent(self::$REPEAT_TABLE),
                        addslashes($this->sourceRecord->table()->tablename),
                        intval($this->getRepeatID())
                );
                $this->_isSaved = false;
                $res = self::queryRepeats($sql);
                
                while ($row = mysql_fetch_assoc($res) ){
                        $this->expiryDate = $row['repeat_expire_date'];
                        $this->frequency = $row['repeat_type'];
                        $this->startDate = $row['repeat_start_date'];
                        $this->_isSaved = true;
                }
                @mysql_free_result($res);
        }
        
        
        public function getDefaultExpiryDifferential(){
                $defaultDiff = '+90 days';
                $settingsField = $this->getModule()->getRepeatSettingsField($this->sourceRecord->table()->tablename);
                if ( $settingsField ){
                        $settingsFieldDef =& $this->sourceRecord->table()->getField($settingsField);
                        if ( isset($settingsFieldDef['widget']['default_expiry']) ){
                                $defaultDiff = $settingsFieldDef['widget']['default_expiry'];
                        }
                }
                return $defaultDiff;
        
        }
        
        public function saveRepeatInfo(){
        
                if ( !$this->frequency ){
                        throw new Exception('Frequency is not set for this repeat.', self::$EX_INVALID_FREQUENCY);
                }
        
                if ( !$this->startDate ){
                        $this->startDate = $this->getSourceStart();
                }
                
                
                
                if ( !$this->expiryDate ){
                        $this->expiryDate = date(
                                'Y-m-d H:i:s'
                                , strtotime(
                                        $this->getDefaultExpiryDifferential()
                                        , strtotime(
                                                $this->getSourceStart()
                                        )
                                )
                        );
                        
                }
                
                $repeatID = $this->getRepeatID();
                if ( !$repeatID ){
                        // The repeat ID hasn't been set yet
                        $seedField = $this->getRepeatSeedAtt();
                        $this->sourceRecord->setValue(
                                $this->getRepeatAtt(),
                                $this->sourceRecord->val($seedField)
                        );
                        $res = $this->sourceRecord->save(null, $secure);
                        if ( PEAR::isError($res) ){
                                throw new Exception($res->getMessage(), $res->getCode());
                        }
                        $repeatID = $this->getRepeatID();
                }
                if ( !isset($repeatID) ){
                        throw new Exception("Could not commit repeat sequence because it doesn't have a valid repeat id.", self::$EX_INVALID_REPEAT_ID);
                        
                }
                
                
        
                $isql = sprintf("insert into `%s` (`tablename`,`repeat_id`,`repeat_type`, `repeat_start_date`, `repeat_expire_date`)
                        values
                                ('%s',%d,'%s','%s','%s')"
                                , self::cleanIdent(self::$REPEAT_TABLE)
                                , addslashes($this->sourceRecord->table()->tablename)
                                , intval($this->getRepeatID())
                                , addslashes($this->frequency)
                                , addslashes($this->startDate)
                                , addslashes($this->expiryDate)
                        );
                $usql = sprintf("update `%s` set
                        `repeat_type`='%s',
                        `repeat_start_date`='%s',
                        `repeat_expire_date`='%s'
                        where
                                `tablename`='%s' and `repeat_id`=%d"
                                , self::cleanIdent(self::$REPEAT_TABLE)
                                , addslashes($this->frequency)
                                , addslashes($this->startDate)
                                , addslashes($this->expiryDate)
                                , addslashes($this->sourceRecord->table()->tablename)
                                , intval($this->getRepeatID())
                        );
                        
                if ( $this->isSaved() ){
                        self::queryRepeats($usql);
                } else {
                        self::queryRepeats($isql);      
                }
                                
        }
        
        public function getRepeatRecords($limit=250, $query=array()){
                
                $query[$this->getRepeatAtt()] = '='.$this->getRepeatID();
                $query['-limit'] = $limit;
                
                if ( !isset($query[$this->getStartAtt()] ) ){
                        $query[$this->getStartAtt()] = '>'.$this->getSourceStart();
                }
                return df_get_records_array($this->sourceRecord->table()->tablename, $query);
        }
        
        
        public function updateRepeats(array $changes, $startDiffSeconds, $endDiffSeconds, $secure=false){
                
                $repeats = $this->getRepeatRecords(999);
                $errors = array();
                $del = $this->sourceRecord->table()->getDelegate();
                
                $beforeUpdateExists = (isset($del) and method_exists($del, 'beforeUpdateRepeat'));
                $afterUpdateExists = (isset($del) and method_exists($del, 'afterUpdateRepeat') );
                $beforeSaveRepeatExists = (isset($del) and method_exists($del, 'beforeSafeRepeat'));
                $afterSaveRepeatExists = (isset($del) and method_exists($del, 'afterSaveRepeat'));
                
                foreach ($repeats as $event){
                        try {
                                $oldStart = $event->strval($this->getStartAtt());
                                $oldEnd = $event->strval($this->getEndAtt());
                                
                                $newStartTime = strtotime('+'.$startDiffSeconds.' seconds', strtotime($oldStart));
                                $newEndTime = strtotime('+'.$endDiffSeconds.' seconds', strtotime($oldEnd));
                                
                                $changes[$this->getStartAtt()] = date('Y-m-d H:i:s', $newStartTime);
                                $changes[$this->getEndAtt()] = date('Y-m-d H:i:s', $newEndTime);
                                
                                $event->setValues($changes);
                                
                                if ( $beforeSaveRepeatExists ){
                                        $del->beforeSaveRepeat($event, $this, $changes);
                                }
                                
                                if ( $beforeUpdateExists ){
                                        $del->beforeUpdateRepeat($event, $this, $changes);
                                        
                                }
                                $res = $event->save(null, $secure);
                                if ( PEAR::isError($res) ){
                                        throw new Exception($res->getMessage(), $res->getCode());
                                        
                                }
                                
                                
                                if ( $afterUpdateExists ){
                                        $del->afterUpdateRepeat($event, $this, $changes);
                                
                                }
                                
                                if ( $afterSaveRepeatExists ){
                                        $del->afterSaveRepeat($event, $this, $changes);
                                }
                                
                        } catch (Exception $ex){
                                $errors[] = $ex;
                        }
                                
                }
                
                return $errors;
                
                
        }
        
        
        public function clearRepeats($secure=false, $query=array()){
                $del = $this->sourceRecord->table()->getDelegate();
                $repeats = $this->getRepeatRecords(999, $query);
                $errors = array();
                $beforeDeleteExists = (isset($del) and method_exists($del, 'beforeDeleteRepeat'));
                $afterDeleteExists = (isset($del) and method_exists($del, 'afterDeleteRepeat'));
                
                foreach ($repeats as $event){
                        try {
                                if ( $beforeDeleteExists ){
                                        
                                        $del->beforeDeleteRepeat($event, $this);
                                                
                                        
                                }
                                        
                                $res = $event->delete($secure);
                                if ( PEAR::isError($res) ){
                                        throw new Exception($res->getMessage(), $res->getCode());
                                }
                                        
                                if ( $afterDeleteExists ){
                                        $res = $del->afterDeleteRepeat($event, $this);
                                        
                                }
                        } catch (Exception $ex){
                                $errors[] = $ex;
                        }
                        
                }
                
                return $errors;
        }
        
        public function fillRepeats($secure=false){
                $del = $this->sourceRecord->table()->getDelegate();
                $errors = array();
                $beforeAddRepeatExists = (isset($del) and method_exists($del, 'beforeAddRepeat'));
                $afterAddRepeatExists = (isset($del) and method_exists($del, 'afterAddRepeat'));
                $beforeSaveRepeatExists = (isset($del) and method_exists($del, 'beforeSafeRepeat'));
                $afterSaveRepeatExists = (isset($del) and method_exists($del, 'afterSaveRepeat'));
                
                
                // Let's get the last existing event in this repeat sequence
                $lastEvent = df_get_record($this->sourceRecord->table()->tablename,
                        array(
                                $this->getRepeatAtt() => $this->getRepeatID(),
                                '-sort' => $this->getStartAtt().' desc'
                        )
                );
                
                if ( !$lastEvent ){
                        throw new Exception("Could not find last event in repeat sequence.  Please check that the source record of this event sequence has a valid repeat id.");
                        
                }
                
                
                /*
                $currTime = strtotime($this->getSourceStart());
                $maxTime = strtotime($this->getExpiryDate());
                $currEnd = strtotime($this->getSourceEnd());
                */
                $currTime = strtotime(
                        date('Y-m-d', 
                                strtotime(
                                        $lastEvent->strval($this->getStartAtt())
                                )
                        )
                        . ' '
                        . date('H:i:s', 
                                strtotime(
                                        $this->getSourceStart()
                                )
                        )
                );
                
                $maxTime = strtotime($this->getExpiryDate());
                $currEnd = strtotime(
                        date('Y-m-d', 
                                strtotime(
                                        $lastEvent->strval($this->getEndAtt())
                                )
                        )
                        . ' '
                        . date('H:i:s', 
                                strtotime(
                                        $this->getSourceEnd()
                                )
                        )
                );
                
                $stepsize = null;
                switch ($this->getFrequency()){
                
                        case 'Daily': $stepsize = '+1 day';break;
                        case 'Weekly': $stepsize = '+1 week';break;
                        case 'Biweekly': $stepsize = '+2 week'; break;
                        case 'Monthly': $stepsize = '+1 month'; break;
                        case 'Yearly': $stepsize = '+1 year'; break;
                        case 'Weekdays':
                                if ( date('N', $currtime) == 5 ){
                                        $stepsize = '+3 day';
                                } else {
                                        $stepsize = '+1 day';
                                }
                                break;
                }
                
                if ( !$stepsize ){
                        throw new Exception("Invalid frequency '".$this->getFrequency()."' in repeat.");
                }
                
                $baseVals = $this->sourceRecord->vals();
                $autoField = $this->sourceRecord->table()->getAutoIncrementField();
                if ( !$autoField ){
                        throw new Exception("Repeat tables require an auto increment field.");
                }
                unset($baseVals[$autoField]);
                
                $errors = array();
                while ( $currTime < $maxTime ){
                        //echo "[Adding $currTime]";
                        try {
                                $currTime = strtotime($stepsize, $currTime);
                                $currEnd = strtotime($stepsize, $currEnd);
                                
                                $event = new Dataface_Record($this->sourceRecord->table()->tablename, array());
                                $event->setValues($baseVals);
                                $event->setValue($this->getStartAtt(), date('Y-m-d H:i:s', $currTime));
                                $event->setValue($this->getEndAtt(), date('Y-m-d H:i:s', $currEnd));
                                
                                if ( $beforeSaveRepeatExists ){
                                        $del->beforeSaveRepeat($event, $this);
                                }
                                
                                if ( $beforeAddRepeatExists ){
                                        $del->beforeAddRepeat($event, $this);
                                }
                                
                                $res = $event->save(null, $secure);
                                if ( PEAR::isError($res) ){
                                        throw new Exception($res->getMessage(), $res->getCode());
                                }
                                
                                if ( $afterAddRepeatExists ){
                                        $del->afterAddRepeat($event, $this);
                                }
                                
                                if ( $afterSaveRepeatExists ){
                                        $del->afterSaveRepeat($event, $this);
                                }
                                
                        } catch (Exception $ex){
                                $errors[] = $ex;
                        }
                        
                        
                        
                        
                        
                }
                
                
                return $errors;
        }
        
        
        
        public function isSaved(){
                if ( !$this->getRepeatID() ) return false;
                if ( !isset($this->_isSaved) ){
                        $this->loadRepeatInfo();
                }
                return $this->_isSaved;
        }
        
        
        
        public function setSourceRecord(Dataface_Record $record){
                $this->expiryDate = null;
                $this->startDate = null;
                $this->frequency = null;
                $this->sourceRecord = $record;
                $this->_isSaved = null;
        }
        
        public function getSourceRecord(){
                return $this->sourceRecord;
        }
        
        public function setFrequency($freq){
                if ( $freq != $this->frequency ){
                        $this->frequency = $freq;
                        $this->frequencyChanged = true;
                }
        }
        
        public function getFrequency(){ return $this->frequency;}
        
        public function setStartDate($date){ $this->startDate = $date;}
        
        public function getStartDate(){ return $this->startDate; }
        
        public function setExpiryDate($d){ $this->expiryDate = $d;}
        
        public function getExpiryDate(){ return $this->expiryDate;}
        
        
        public function commit(array $changes, $startDiffSeconds, $endDiffSeconds, $secure=false ){
                
                
                
        
                $this->saveRepeatInfo();
                $errors = array();
                if ( $this->frequencyChanged ){
                        //If the frequency has changed, we need to clear all of the existing repeat
                        // events and build them anew.
                        $errors = array_merge($errors, $this->clearRepeats($secure));
                        $this->frequencyChanged = false;
                } else {
                        // Let's clear all of the repeats that come after the expiry date
                        $errors = array_merge($errors, $this->clearRepeats($secure, array(
                                $this->getStartAtt()=>'>'.$this->getExpiryDate()
                        )));
                }
                
                // Now let's fill all of the repeats
                $errors = array_merge($errors,$this->fillRepeats($secure));
                
                // Now let's update the repeat records.
                // Will be redundant the first time the repeats are filled, but that's ok
                // we may optimize this later.
                if ( $changes or $startDiffSeconds or $endDiffSeconds ){
                        $errors = array_merge($errors,
                                $this->updateRepeats($changes, $startDiffSeconds, $endDiffSeconds, $secure)
                        );
                }
                
                return $errors;
                
                
        }
        
        
}