Source for file datetimefield.php

Documentation is available at datetimefield.php

  1. <?php
  2. /**
  3. * a textfield designed for date-time data
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage FormsLibrary
  11. */
  12.  
  13. /** Load ancillary functions */
  14. require_once 'inc/typeinfo.php';
  15. checkValidInclude();
  16.  
  17. /** parent object */
  18. require_once 'field.php';
  19. /** type checking and data manipulation */
  20. require_once 'inc/typeinfo.php';
  21. /** contains a timefield object */
  22. require_once 'timefield.php';
  23. /** contains a timefield object */
  24. require_once 'datefield.php';
  25. /** date storage types */
  26. require_once 'inc/date.php';
  27. /** timeslot manipulation and validation object */
  28. require_once 'inc/bookings/timeslotrule.php';
  29.  
  30. /**
  31. * a textfield designed for date-time data
  32. *
  33. * @package    Bumblebee
  34. * @subpackage FormsLibrary
  35. */
  36. class DateTimeField extends Field {
  37.   /** @var SimpleTime time part of the field  */
  38.   var $time;
  39.   /** @var boolean   time part is editable  */
  40.   var $timeeditable;
  41.   /** @var SimpleDate date part of the field  */
  42.   var $date;
  43.   /** @var boolean   date part is editable  */
  44.   var $dateeditable;
  45.   /** @var array     list of possible choices for the day  */
  46.   var $list;
  47.  
  48.   /** @var integer   current representation of the time part (TF_* defines in TimeField class  */
  49.   var $representation;
  50.   /** @var integer   manually specified representation of the time part (TF_* defines in TimeField class  */
  51.   var $_manualRepresentation = TF_AUTO;
  52.  
  53.     /**
  54.   *  Create a new datetimefield object
  55.   *
  56.   * @param string $name   the name of the field (db name, and html field name
  57.   * @param string $longname  long name to be used in the label of the field in display
  58.   * @param string $description  used in the html title or longdesc for the field
  59.   */
  60. function DateTimeField($name, $longname='', $description='') {
  61.     parent::Field($name, $longname, $description);
  62.     //$this->DEBUG=10;
  63.     $this->time = new TimeField($name.'-time', $longname, $description);
  64.     $this->time->isStart = true;
  65.     $this->date = new DateField($name.'-date', $longname, $description);
  66.   }
  67.  
  68.   function displayInTable($cols=3) {
  69.     $errorclass = ($this->isValid ? '' : "class='inputerror'");
  70.     $t = "<tr $errorclass><td>$this->longname</td>\n"
  71.         ."<td title='$this->description'>";
  72.     if ($this->editable && ! $this->hidden) {
  73.       $t .= $this->selectable();
  74.     } else {
  75.       if (!$this->hidden) $t .= xssqw($this->getValue());
  76.       $t .= $this->hidden();
  77.     }
  78.     if ($this->duplicateName) {
  79.       $t .= "<input type='hidden' name='$this->duplicateName' "
  80.              ."value='".xssqw($this->value)."' />";
  81.     }
  82.     $t .= "</td>\n";
  83.     for ($i=0; $i<$cols-2; $i++) {
  84.       $t .= '<td></td>';
  85.     }
  86.     $t .= '</tr>';
  87.     return $t;
  88.   }
  89.  
  90.   function selectable() {
  91.     //preDump($this->time);
  92.     //echo "Assembling date-time field\ndate";
  93.     $t  = $this->date->getdisplay();
  94.     $t .= ' ';
  95.     //echo "Assembling date-time field\ntime";
  96.     $t .= $this->time->getdisplay();
  97.     return $t;
  98.   }
  99.  
  100.   function hidden() {
  101.     return $this->date->hidden() .' '. $this->time->hidden();
  102.   }
  103.  
  104.   /**
  105.   * calculate the correct values for the separate (and possibly not editable!) parts of the field
  106.   */
  107.   function calcDateTimeParts() {
  108.     $val = ($this->getValue() == '') ? 0 : $this->getValue();
  109.     #echo "datetime=$val\n";
  110.     $this->time->setDateTime($val);
  111.     $this->date->setDate($val);
  112.     $this->value = $this->date->value .' '. $this->time->value;
  113.   }
  114.  
  115.   /**
  116.   * overload the parent's value as we need to do some magic in here
  117.   */
  118.   function set($value) {
  119.     #echo "V=$value\n";
  120.     parent::set($value);
  121.     $this->calcDateTimeParts();
  122.   }
  123.  
  124.   /**
  125.   * overload the parent's update method so that local calculations can be performed
  126.   *
  127.   * @param array $data html_name => value pairs
  128.   *
  129.   * @return boolean the value was updated
  130.   */
  131.   function update($data) {
  132.     $datechanged = $this->date->update($data);
  133.     $timechanged = $this->time->update($data);
  134.     if ($datechanged || $timechanged) {
  135.       $this->log('DateTimeField::update');
  136.       $data[$this->namebase.$this->name] = $this->date->value .' '. $this->time->value;
  137.       parent::update($data);
  138. //       $this->calcDateTimeParts();
  139.     }
  140.     return $this->changed;
  141.   }
  142.  
  143.   /**
  144.   * associate a TimeSlotRule for validation of the times that we are using
  145.   *
  146.   * @param TimeSlotRule $list a TimeSlotRule
  147.   */
  148.   function setSlots($list) {
  149.     $this->list = $list;
  150.     $this->time->setSlots($list);
  151.     $this->calcDateTimeParts();
  152.   }
  153.  
  154.   /**
  155.   * set the appropriate date that we are refering to for the timeslot rule validation
  156.   *
  157.   * @param string $date passed to the TimeSlotRule
  158.    */
  159.   function setSlotStart($date) {
  160.     $this->time->setSlotStart($date);
  161.   }
  162.  
  163.   /**
  164.   * pass on any flags about the representation that we should use to our members
  165.   *
  166.   * @param integer $flag (TF_* types from class TimeField constants)
  167.   */
  168.   function setManualRepresentation($flag) {
  169.     $this->_manualRepresentation = $flag;
  170.     $this->time->setManualRepresentation($flag);
  171.   }
  172.  
  173.   /**
  174.   *  isValid test (extend Field::isValid), looking at the individual parts of the field
  175.   */
  176.   function isValid() {
  177.     parent::isValid();
  178.     $this->isValid = $this->isValid && $this->date->isValid() && $this->time->isValid();
  179.     return $this->isValid;
  180.   }
  181.  
  182.   /**
  183.   * Set the date and time parts of the field and mark them as editable
  184.   *
  185.   * @param SimpleDate  $date  new date part of the field
  186.   * @param SimpleTime  $time  new time part of the field
  187.   */
  188.   function setEditableOutput($date, $time) {
  189.     $this->dateeditable = $date;
  190.     $this->date->editableOutput = $date;
  191.     $this->timeeditable = $time;
  192.     $this->time->editableOutput = $time;
  193.   }
  194.  
  195.   /**
  196.   * return a SQL-injection-cleansed string that can be used in an SQL
  197.   * UPDATE or INSERT statement. i.e. "name='Stuart'".
  198.   *
  199.   * @return string  in SQL assignable form
  200.   */
  201.   function sqlSetStr($name='', $force=false) {
  202.     if (empty($name)) {
  203.       $name = $this->name;
  204.     }
  205.     if (! $this->sqlHidden) {
  206.       $date = new SimpleDate($this->getValue());
  207.       return $name .'='. qw($date->dateTimeString());
  208.     } else {
  209.       return '';
  210.     }
  211.   }
  212.  
  213.  
  214.  
  215. } // class DateTimeField
  216.  
  217.  
  218. ?>

Documentation generated on Tue, 06 Mar 2007 10:01:15 +0000 by phpDocumentor 1.3.0