DataItem is the generic base class for database mapped classes. More...

Inheritance diagram for DataItem:

Collaboration diagram for DataItem:

Public Member Functions
	DataItem ()
	Constructor. More...

	__sleep ()

	fireEvent ($event)
	Fires the specified event to all registered handlers. More...

	joinTransaction ($tx)
	Join the DataItem to the specified DataTransaction. More...

	getTransaction ()
	Retrieves the current DataTransaction. More...

	cast ($class)
	Cast this object to another class. More...

	disablePrimaryKey ()

	enablePrimaryKey ()

	getHiddenFields ()
	Retrieves the list of hidden fields. More...

	populate ($line, $alias=false)
	Populates the object using the supplied associative array (field -> value). More...

	getFields ()
	Retrieve the field type list for this object. More...

	overrideFieldType ($field, $type)
	Override the type for the specified field. More...

	getFieldList ($alias="")
	Returned a comma-separated list of the fields for this object (applying the assigned filter if there is one). More...

	getFieldArray ()
	Return an array of field names for this object filtered by any active filter. More...

	hasField ($field)
	Returns true if this DataItem contains a field with the specified name and that field is not excluded by a filter. More...

	hasRelation ($relation)
	Returns true if this DataItem contains a relation with the specified name. More...

	getPrimaryKey ()
	Retrieves the primary key field name. More...

	getPrimaryKeyList ()
	Retrieves a list of all the primary keys used for an object as an array. More...

	get ($field)
	Retrieve the value for the specified field. More...

	set ($field, $value)
	Set the value of the specified field. More...

	getType ($field)
	Retrieves the data type of the specified field. More...

	getFilter ()
	Returns the filter set on this object. More...

	setFilter ($filter)
	Sets the filter on this object. More...

	getFieldAliases ()
	Retrieve the list of field aliases. More...

	getFieldAnnotations ()
	Retrieve the list of field annotations. More...

	pack ()
	The pack() method is called prior to persisting a DataItem to storage. More...

	unpack ()
	The unpack() method is called after populating a DataItem. More...

	load ($id)
	Load the object with the specified primary key. More...

	old ()
	Retrieves the currently stored state of the DataItem from the database and returns it as a new object. More...

	loadComposite ()
	Creates an outer CompositeDataItem from its base component. More...

	save ()
	Store the object in the database. More...

	select ()
	Select the object from the database, based on the value of the primary key field. More...

	exists ($constraint="")
	Check whether the object exists in the database. More...

	update ()
	Update the row in the database that corresponds to this object. More...

	updateExplicit ($updates, $params=null)
	Executes an explicit update command against the database. More...

	insert ()
	Insert a new row in the database to store this object. More...

	delete ($constraint="")
	Delete the row in the database that corresponds to this object. More...

	deleteAll ()
	Delete all the rows in the database that correspond to this class. More...

	tableExists ()
	Check if the table for this class exists in the database. More...

	duplicate ()
	Persists a duplicate of the DataItem to the database under a new primary key. More...

	distinctValues ($field, $sorted=false, $constraint="")
	Retrieves the distinct values in the database for the specified field across the specified set of records. More...

	fromGET ()
	Automatically populate the object based on parameters in the $_GET collection. More...

	fromPOST ()
	Automatically populate the object based on parameters in the $_POST collection. More...

	fromREQUEST ()
	Automatically populate the object based on parameters in either the $_GET or $_POST collection, depending on the method used to access the page. More...

	fromDataSet ($params)
	Automatically populate the object based on a custom set of parameters (such as a filtered $_POST collection) More...

	compare ($to)
	Compare this object to another object. More...

	copy ($from)
	Copies values from another object, field by field. More...

	cloneFrom ($from)
	Copies values from another object, field by field, excluding the primary key. More...

	cacheLookup ($id)
	Populate the object from the local cache if the object is marked as "cacheLocal". More...

	getRelated ($class, $field="")
	Returns a single item related by the specified foreign key. More...

	getRelatedList ($class, $field="", $orderBy="")
	Returns a list of items that are related to this item. More...

	crossReference ($class, $xref, $orderBy="", $pkField="", $xrefField="")
	Returns a list of items related to this item via a cross-reference table. More...

	queryValue ($func)
	Query the database to calculate an aggregate value. More...

	toXML ($indent=0, $path=null)
	Generates an XML representation of the object. More...

	fromXML ($node)
	Populates the object from the specified XML node. More...

	toJSON ()

	format ($template="", $separator=", ")
	Substitute values for field names in a string, with the fields formatted using their type's default format or according to the formatting template sting passed in. More...

	formatField ($template)

	formatThroughRelation ($template, $separator=", ")

	prettifyFieldName ($field)

	relateTo ($target, $field="")
	Link this object to the specified target by setting corresponding field to the value of the target's primary key. More...

Public Member Functions inherited from AbstractDataItem
	decorate ($name, $value)
	Adds a decoration to the DataItem. More...

	getDecoration ($name)
	Retrieve the value of a decoration on the current DataItem. More...

	setOption ($opt)
	Set a behavior option flag. More...

	clearOptions ($opt)
	Clear the specified behavior option flag. More...

	getConnection ()
	Retrieves a connection to the database. More...

	getIdentityConstraint ()
	Subclasses can override this function to provide additional identity constraints to be used when querying or updating. More...

	populate ($line)
	Populates the object using the supplied associative array (field -> value). More...

	getPrimaryKeyValue ()
	Retrieves the primary key value. More...

	quoteFieldValue ($field, $type=null)
	Returns the properly quoted value of the specified field. More...

	quoteValue ($val, $type)

	formatFieldValue ($field, $template="")

	formatFieldForXML ($field)
	Format field for XML output. More...

	reformatToSQLDate ($date)
	Reformats the specified date to be in a format used by the database. More...

	reformatFromSQLDate ($date)

	fromJSON ($json)
	Populate from the supplied JSON object. More...

	prettifyClassName ($plural=false)

Static Public Member Functions
static	registerEventHandler ($class, $event, $handler)
	Register an event handler for a specific event and DataItem class. More...

Public Attributes
	$_tx = null

	$_pkDisabled = false

Public Attributes inherited from AbstractDataItem
	$filter

	$_options = 0

	$_tx = null
	Tracks the current database transaction for each DataItem. More...

	$_decorations = null

Static Public Attributes
static	$_eventMap = array()

static	$dataTypeRendererMap

Detailed Description

DataItem is the generic base class for database mapped classes.

It provides a compact, consistent API for object persistence in the database.

Definition at line 61 of file data_item.inc.

Member Function Documentation

◆ __sleep()

DataItem::__sleep ( )

Definition at line 133 of file data_item.inc.

      {
           // No need to persist class variables, such as field metadata
           
           $f = array_keys($this->getFields());
           array_push($f, "primary_key", "table", "filter");
           return $f;
      }

◆ cacheLookup()

DataItem::cacheLookup ( $id )

Populate the object from the local cache if the object is marked as "cacheLocal".

Reimplemented from AbstractDataItem.

Definition at line 1179 of file data_item.inc.

      {
           if ($this->cacheLocal)
           {
                $cache = get_class($this)."_cache";
                $items = Cache::get($cache);
                if (!is_array($items))
                {
                     $items = IndexedQuery::create(get_class($this), "", $this->primary_key)->execute();
                     Cache::put($cache, $items);
                }
                if (array_key_exists($id, $items))
                {
                     trace("Using local cache $cache for item $id", 5);
                     $this->copy($items[$id]);
                     return true;
                }
           }
           
           return false;
      }    

◆ cast()

DataItem::cast ( $class )

Cast this object to another class.

For simple DataItems this checks that the class is the same as the supplied class and returns a reference if so. If not an exception is thrown.

Parameters

string $class

Returns: instance of the specified class, if compatible

Exceptions

DataItemException

Reimplemented from AbstractDataItem.

Definition at line 219 of file data_item.inc.

      {
           if (get_class($this) != $class)
           {
                throw new DataItemException("Cannot cast ".get_class($this)." to $class.");
           }
           
           return $this;
      }

◆ cloneFrom()

DataItem::cloneFrom ( $from )

Copies values from another object, field by field, excluding the primary key.

This works the same as DataItem::copy(), but should be used in preference when you are wanting to create a duplicate row in the database.

Parameters

object from the object from which data is to be copied

Definition at line 1172 of file data_item.inc.

      {
           $this->copy($from);
           $pk = $this->primary_key;
           unset($this->$pk);
      }

◆ compare()

DataItem::compare ( $to )

Compare this object to another object.

If all the fields match, the method returns true, otherwise false. If a filter is in place on the source object, then only the filtered fields are compared.

Parameters

object $to the object with which to compare this object

Reimplemented from AbstractDataItem.

Definition at line 1127 of file data_item.inc.

      {
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                if ($to->$field != $this->$field)
                {
                     trace("$field '{$this->$field}' != '{$to->$field}'", 3);
                     return false;
                }
           }
           
           return true;
      }

◆ copy()

DataItem::copy ( $from )

Copies values from another object, field by field.

If a filter is in place on the source object, then only the filtered fields are copied.

Parameters

object from the object from which data is to be copied

Reimplemented from AbstractDataItem.

Definition at line 1148 of file data_item.inc.

      {
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                $this->set($field, $from->$field);
           }
           
           if (is_array($this->calculatedFields))
           {
                foreach($this->calculatedFields as $field => $expr)
                {
                     $this->set($field, $from->$field);
                }
           }    
      }

◆ crossReference()

DataItem::crossReference	(	$class,
		$xref,
		$orderBy = `""`,
		$pkField = `""`,
		$xrefField = `""`
	)

Returns a list of items related to this item via a cross-reference table.

The cross-reference table must contain the primary keys of each of the related classes as fields.

Parameters

string	$class	the name of the related class
string	$xref	the name of the cross-reference table
string	$orderBy	(optional) a sort order clause for the results.
string	$pkField	(optional) the field in the cross-reference table that maps to the primary key of the source object.
	string	xrefField (optional) the field in the cross-refence table that maps to the primary key of the cross-referenced objects.

Definition at line 1286 of file data_item.inc.

      {
           $obj = new $class;
           $xref = new $xref;
           
           if ($orderBy != "")
           {
                foreach($obj->getFields() as $field => $type)
                {
                     $orderBy = preg_replace("/\\b".$field."\\b/i", "a0.$field", $orderBy);
                }
           }
           
           $orderBy = preg_replace("/^\s*WHERE\s+/i", "AND ", $orderBy);
           
           $xt = $xref->table;
           $xp = ($xrefField != "") ? $xrefField : $obj->primary_key;
           
           $pkField = ($pkField != "") ? $pkField : $this->primary_key;
           $pk = $this->primary_key;
           
           $fieldList = $obj->getFieldList("a0");
           
           $query = "SELECT {$fieldList} FROM {$obj->table} a0, $xt x WHERE a0.{$obj->primary_key}=x.{$xp} AND x.{$pkField}={$this->$pk} $orderBy";
           
           trace($query, 3);
           
           try
           {
                $db = $this->getConnection();
                
                $result = $db->prepare($query);
                $result->execute();
                
                $list = array();
                while ($line = $result->fetch())
                {
                     $obj = new $class;
                     $obj->populate($line, "a0");
                     $list[] = $obj;
                }
                
                unset($result);
           }
           catch(PDOException $e)
           {
                $err = "DataItem::crossReference() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           return $list;
      }  

◆ DataItem()

DataItem::DataItem ( )

Constructor.

DataItems can be constructed in three ways:

Empty objects can be constructed by calling the constructor with no arguments
Objects can be instantiated from their primary key by passing in a single value
Objects can be populated from an associative array of field/value pairs [such as those returned from mysql_fetch_assoc()]

Definition at line 97 of file data_item.inc.

      {
           if (func_num_args() > 0)
           {
                $arg = func_get_arg(0);
                
                if (is_array($arg) )
                {
                     if (count($arg) > 1)
                     {
                          $this->populate($arg);
                     }
                     else if (count($arg) > 0)
                     {
                          if (is_array($arg[0]))
                          {
                               $this->populate($arg[0]);
                          }
                          else
                          {
                               $this->load($arg[0]);
                          }
                     }
                }
                else
                {
                     if (func_num_args() > 1)
                     {
                          $this->filter = func_get_arg(1);
                     }
                     
                     $this->load($arg);
                }
           }
      }

◆ delete()

DataItem::delete ( $constraint = "" )

Delete the row in the database that corresponds to this object.

Reimplemented from AbstractDataItem.

Definition at line 888 of file data_item.inc.

      {
           if ($constraint == "")
           {
                $fire = true;
                $pk = $this->primary_key;
                $constraint =  "WHERE $pk={$this->$pk} ".$this->getIdentityConstraint();
           }
           
           $query = "DELETE FROM {$this->table} $constraint";
           
           trace($query, 3);
           
           $db = $this->getConnection();
           
           try
           {
                if ($fire) $this->fireEvent("onPreDelete");
                $db->exec($query);
                if ($fire) $this->fireEvent("onPostDelete");
           }
           catch(PDOException $e)
           {
                $err = "DataItem::delete() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
      }

◆ deleteAll()

DataItem::deleteAll ( )

Delete all the rows in the database that correspond to this class.

Reimplemented from AbstractDataItem.

Definition at line 920 of file data_item.inc.

      {
           //$query = "TRUNCATE TABLE {$this->table}";
           $query = "DELETE FROM {$this->table}; ALTER TABLE {$this->table} AUTO_INCREMENT=1";
           $db = $this->getConnection();
                     
           trace($query, 3);
           
           try
           {
                $db->exec($query);
                $this->fireEvent("onDeleteAll");
           }
           catch(PDOException $e)
           {
                $err = "DataItem::deleteAll() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }    
      }

◆ disablePrimaryKey()

DataItem::disablePrimaryKey ( )

Definition at line 229 of file data_item.inc.

      {
           if (!$this->_disablePK)
           {
                $conn = $this->getConnection();
                $conn->prepare("ALTER TABLE `{$this->table}` DISABLE KEYS")->execute();
                $this->_disablePK = true;
           }              
      }

◆ distinctValues()

DataItem::distinctValues	(	$field,
		$sorted = `false`,
		$constraint = `""`
	)

Retrieves the distinct values in the database for the specified field across the specified set of records.

Parameters

string	$field
boolean	$sorted
string	$constraint

Returns: array

Reimplemented from AbstractDataItem.

Definition at line 1001 of file data_item.inc.

      {
           $query = "SELECT DISTINCT $field from {$this->table} $constraint";
           
           trace($query, 3);
           
           $db = $this->getConnection();
           
           try
           {
                $result = $db->prepare($query);
                $result->execute();
                
                $values = array();
                
                while($line = $result->fetch())
                {
                     $values[] = $line[$field];
                }
                
                if ($sorted)
                {
                     sort($values);
                }
                          
                unset($result);
                
                return $values;
           }
           catch(PDOException $e)
           {
                $err = "DataItem::distinctValues() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           
      }

◆ duplicate()

DataItem::duplicate ( )

Persists a duplicate of the DataItem to the database under a new primary key.

Foreign keys are not updated. Use this as a way to create a quick copy of an existing object, or to import a serialized object into the data store under a new primary key. For utility, the previous value of the primary key is returned.

Returns: int the previous value of the primary key

Definition at line 983 of file data_item.inc.

      {
           $pk = $this->primary_key;
           $old = $this->get($pk);
           
           unset($this->$pk);
           $this->save();
           return $old;
      }

◆ enablePrimaryKey()

DataItem::enablePrimaryKey ( )

Definition at line 239 of file data_item.inc.

      {
           if ($this->_disablePK)
           {
                $conn = $this->getConnection();
                $conn->prepare("ALTER TABLE `{$this->table}` ENABLE KEYS")->execute();
                $this->_disablePK = false;
           }              
      }

◆ exists()

DataItem::exists ( $constraint = "" )

Check whether the object exists in the database.

Reimplemented from AbstractDataItem.

Definition at line 665 of file data_item.inc.

      {
           
           $pk = $this->primary_key;
           
           if (!$constraint)
           {
                if ($this->$pk == "" || $this->$pk == 0) return false;
                $constraint = "WHERE $pk={$this->$pk}";
           }
           
           $query = "SELECT $pk FROM {$this->table} $constraint";
           trace("DataItem::exists() - $query", 3);
           
           $db = $this->getConnection();
           $exists = false;
           
           try
           {
                $result = $db->prepare($query);
                $result->execute();
                
                if ($line = $result->fetch())
                {
                     $exists = true;
                }
                
                unset($result);
           }
           catch(PDOException $e)
           {
                $err = "DataItem::exists() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           
           return $exists;
      }

◆ fireEvent()

DataItem::fireEvent ( $event )

Fires the specified event to all registered handlers.

The firing object is passed as a parameter to all the registered handlers.

Parameters

string $event the event to be fired

Definition at line 169 of file data_item.inc.

      {
           $eventKey = get_class($this)."_{$event}";
           if (!array_key_exists($eventKey, DataItem::$_eventMap))
           {
                return;
           }
           
           trace("===== DataItem event key = $eventKey", 3);
           $handlers = DataItem::$_eventMap[$eventKey];
           
           if (!is_array($handlers)) return;
           foreach($handlers as $handler)
           {
                if (!is_callable($handler))
                {
                     trace(get_class($this)." {$event} handler is invalid", 2);
                }
                else 
                {
                     call_user_func_array($handler, array($this));
                }
           }
      }

◆ format()

DataItem::format	(	$template = `""`,
		$separator = `", "`
	)

Substitute values for field names in a string, with the fields formatted using their type's default format or according to the formatting template sting passed in.

example template string: "{program_name} {start_date} {number_students}"

data type format specifications: The start_date field can have formatting specifications such as "{start_date:long} for long format. For more information on formatting specifications following the colon, check comments in DataTypeRenderer classes.
Default value specification: syntax: {field|alternate} example: {name|N/A}

In the above example "N/A" would be output if the name field is empty or null. This will also work with numeric fields with a value of 0 and booleans with false. Very useful for places where you are linking to a form by name or title.

Inline static method call: syntax: {class::method} example: {MyHelper::getComplicatedOutput} This works the same as passing array(MyHelper, getComplicatedOutput) to a DataListView. It calls the static method getComplicatedOutput() on the MyHelper class, passing the current object in as a parameter. The new inline format means that you can use it as part of more complicated expressions like: "{name} - {MyHelper::getComplicatedOutput}"
Retrieve field value through relations.

Fields can also be retrieved through a relation from the dataitem obj that calls this format function.

Local method calls

Syntax: {method()} Example: {getFullName()}

This format calls the specified method on the object and substitutes the returned value into the output. Parameters cannot be passed.

for example: "{MyRelation.event_name}"

Variables used: $format - stores the pattern inside the braces {} for search & replace substitution in the template string.

$fieldFormat - the requested formatting for the field, if any.

$sub - the value to be substituted or replacement value in the tempalte string.

Reimplemented from AbstractDataItem.

Definition at line 1582 of file data_item.inc.

      {
           if ($template == "") $template = $this->default_format;
           if (is_array($template) && is_callable($template))
           {
                return call_user_func($template, $this);
           }
  
           foreach($this->getFields() as $field => $type)
           {
                $template = str_replace("{".$field."}", $this->formatFieldValue($field), $template);
           }
  
           if (isset($this->calculatedFields))
           {
                foreach($this->calculatedFields as $field => $expr)
                {
                     $template = str_replace("{".$field."}", $this->$field, $template);              
                }
           }
  
           if (isset($this->_decorations))
           {
                foreach($this->_decorations as $field => $value)
                {
                     $template = str_replace("{".$field."}", $value, $template);           
                }
           }
           
           // Allow drill-down through relation functions
           $template = $this->formatThroughRelation($template, $separator);
           
           $template = $this->formatField($template);
           
           // Simple method calls - no parameter passing
           // ??Is this block ever executed??
           
           $matches = array();
           preg_match_all("/\\{([\\w_]+)\\(\\)\\}/", $template, $matches, PREG_SET_ORDER);
           
           foreach($matches as $match)
           {
                $format = $match[0];
                $method =  $match[1];
                
                $value = $this->$method();
                
                $template = str_replace($format, $value, $template);
           }
           
           return $template;
      }

◆ formatField()

DataItem::formatField ( $template )

Definition at line 1643 of file data_item.inc.

      {
           $matches = array();
           
           preg_match_all("/\\{([\\w\\d_]+)(::?|\\^|\\(\\)|\\|)?([^}]*)}/", $template, $matches, PREG_SET_ORDER);
  
           foreach($matches as $match)
           {
                $field = $match[1];
                // JDG 3/12 fix issue with call to function in  DataItem in format like "{getTitle()}" with no separator;
                $separator = ($match[2]) ? $match[2] : ":";
           
                $fieldFormat = $match[3];
                trace("formatField, template $template, field $field, separator $separator and fieldFormat $fieldFormat", 5);
                
                $format = "{".$field.$separator.$fieldFormat."}";
                
                switch($separator)
                {
                case "|":
                     if (!$this->get($field)) 
                     {
                          $sub = $fieldFormat;
                     }
                     else
                     {
                          $sub = $this->formatFieldValue($field);
                     }
                     break;
                     
                case "^":
                     if (!$this->get($field))
                     {
                          $sub = $this->format("{".$fieldFormat."}");
                     }
                     else
                     {
                          $sub = $this->formatFieldValue($field);
                     }
                     break;
                     
                case "::":
                     
                     $sub = call_user_func(array($field, $fieldFormat), $this);
                     break;
                     
                case "()":
                     
                     $sub = $this->$field();
                     break;
                     
                case ":":
                default:
                     $sub = $this->formatFieldValue($field, $fieldFormat);
                }
                
                $template = str_replace($format, $sub, $template);
           }
           return $template;
      }

◆ formatThroughRelation()

DataItem::formatThroughRelation	(	$template,
		$separator = `", "`
	)

Definition at line 1713 of file data_item.inc.

      {
           $matches = array();
           preg_match_all("/\\{([\\w\\d_]+)\\.([\\w\\d_\\.\\(\\)]+)([:\\|\\^])?([^}]*)}/", $template, $matches, PREG_SET_ORDER);
           
           foreach($matches as $match)
           {
                $relation = $match[1];
                $field = $match[2];
                $divider = $match[3];
                if(count($match) == 5 && preg_match("/^where|order/i", $match[4]))
                     $constraint = $match[4];
                elseif(count($match) == 5)
                     $fieldTemplate = $match[4];
  
                trace("function format: formatThroughRelations template $template field $field relation $relation constraint $constraint", 5);
                
                if ($constraint)
                {
                     $relations = $this->$relation($constraint);
                     $format = "{".$relation.".".$field.$divider.$constraint."}";
                }
                elseif($fieldTemplate)
                {
                     $relations = $this->$relation();
                     $format = "{".$relation.".".$field.$divider.$fieldTemplate."}";
                }
                else
                {
                     $relations = $this->$relation();
                     $format = "{".$relation.".".$field."}";
                }
                
                $sub = "";
                
                if (is_array($relations))
                {
                     $formatTemplate = ($fieldTemplate) ? "{".$field .":".$fieldTemplate . "}" : "{".$field."}";
                     $sub = formatItems($relations, $formatTemplate, $separator);
      
                }
                else if ($relations)
                {
                     if ($fieldTemplate) $fieldTemplate = ":{$fieldTemplate}";
                     if ($relations) $sub = $relations->format("{{$field}{$fieldTemplate}}");
                }
                
                trace("format using relations: Replacing {$match[0]} [ $format ] with '$sub'", 5);
                
                $template = str_replace($format, $sub, $template);
           }
           
           return $template;
      }

◆ fromDataSet()

DataItem::fromDataSet ( $params )

Automatically populate the object based on a custom set of parameters (such as a filtered $_POST collection)

Definition at line 1102 of file data_item.inc.

      {
           foreach($this->getFields() as $field => $type)
           {
           if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (array_key_exists($field, $params))
                {
                     $this->$field = $params[$field];
                }
                elseif (!array_key_exists($field, $params) AND ($type == Boolean))
                {
                     $this->$field = 0;
                }
           }
           
           $this->unpack();
      }

◆ fromGET()

DataItem::fromGET ( )

Automatically populate the object based on parameters in the $_GET collection.

Reimplemented from AbstractDataItem.

Definition at line 1042 of file data_item.inc.

      {
           foreach($this->getFields() as $field => $type)
           {
           if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (array_key_exists($field, $_GET))
                {
                     $this->set($field, $_GET[$field]);
                }
           }
           
           $this->unpack();
      }

◆ fromPOST()

DataItem::fromPOST ( )

Automatically populate the object based on parameters in the $_POST collection.

If the key does not exist in $_POST and the type is Boolean, that means that the user unchecked a checkbox and we need to assign 0 to the field.

Reimplemented from AbstractDataItem.

Definition at line 1062 of file data_item.inc.

      {
           foreach($this->getFields() as $field => $type)
           {
           if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (array_key_exists($field, $_POST))
                {
                     $this->set($field, $_POST[$field]);
                }
                elseif (!array_key_exists($field, $_POST) AND ($type == Boolean))
                {
                     $this->$field = 0;
                }
           }
           
           $this->unpack();
      }

◆ fromREQUEST()

DataItem::fromREQUEST ( )

Automatically populate the object based on parameters in either the $_GET or $_POST collection, depending on the method used to access the page.

Reimplemented from AbstractDataItem.

Definition at line 1084 of file data_item.inc.

      {
           switch($_SERVER["REQUEST_METHOD"])
           {
           case "POST":
                $this->fromPOST();
                break;
                
           case "GET":
           default:
                $this->fromGET();
           }
      }

◆ fromXML()

DataItem::fromXML ( $node )

Populates the object from the specified XML node.

Parameters

DOMNode $node

Reimplemented from AbstractDataItem.

Definition at line 1485 of file data_item.inc.

      {
           if ($node->nodeType != XML_ELEMENT_NODE || $node->tagName != get_class($this)) return;
           
           $kids = $node->childNodes;
           $numChildren = $kids->length;
           
           for($i = 0; $i < $numChildren; ++$i)
           {
                $n = $kids->item($i);
                
                if ($n->nodeType != XML_ELEMENT_NODE) continue;
                $field = $n->tagName;
                $this->set($field, $n->nodeValue);
           }
      }

◆ get()

DataItem::get ( $field )

Retrieve the value for the specified field.

Parameters

string $field the field to retrieve

Returns: mixed the value of that field

Reimplemented from AbstractDataItem.

Definition at line 474 of file data_item.inc.

      {
           if (!$field) throw new FakoliException("Cannot access empty field");
           return $this->$field;
      }

◆ getFieldAliases()

DataItem::getFieldAliases ( )

Retrieve the list of field aliases.

Returns: array the alias list for this object

Reimplemented from AbstractDataItem.

Definition at line 523 of file data_item.inc.

      {
           return $this->fieldAliases;
      }

◆ getFieldAnnotations()

DataItem::getFieldAnnotations ( )

Retrieve the list of field annotations.

Returns: array the annotation list for this object

Reimplemented from AbstractDataItem.

Definition at line 532 of file data_item.inc.

      {
           return $this->fieldAnnotations;
      }

◆ getFieldArray()

DataItem::getFieldArray ( )

Return an array of field names for this object filtered by any active filter.

Returns: array

Reimplemented from AbstractDataItem.

Definition at line 415 of file data_item.inc.

      {
           $arr = array();
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                $arr[] = $field;
           }
           
           return $arr;
      }

◆ getFieldList()

DataItem::getFieldList ( $alias = "" )

Returned a comma-separated list of the fields for this object (applying the assigned filter if there is one).

Reimplemented from AbstractDataItem.

Definition at line 361 of file data_item.inc.

      {
           $list = "";
           $first = true;
           
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (!$first) $list .= ", ";
                if ($alias)
                {
                     $list .= "$alias.";
                }
                $list .= "`".$field."`";
                if ($alias)
                {
                     $list .= " as `$alias.$field`";
                }
                $first = false;
           }
           
           if (isset($this->calculatedFields))
           {
                foreach($this->calculatedFields as $field => $expr)
                {
                     if ($this->filter && $this->filter->isExcluded($field)) continue;
                     if (!$first) $list .= ", ";
                     
                     if ($alias)
                     {
                          foreach($this->getFields() as $f => $type)
                          {
                               $expr = preg_replace('/([\s\‍(])('.$f.')\b/', "$1{$alias}.$2", $expr);
                               $expr = preg_replace('/\b'.$this->table.'\.'.$f.'\b/', "{$alias}.{$f}", $expr);
                          }
                     }
                     
                     $list .= $expr . " as `";
                     if ($alias)
                     {
                          $list .= $alias.".";
                     }
                     $list .= $field."`";
                     
                }
           }
           
           return $list;
      }

◆ getFields()

DataItem::getFields ( )

Retrieve the field type list for this object.

Reimplemented from AbstractDataItem.

Definition at line 333 of file data_item.inc.

      {
           if ($this->fields) return $this->fields;
           $class = get_class($this);
           if ($class::$fields) return $class::$fields;
           
           throw new FakoliException("DataItem does not contain any fields");
      }

◆ getFilter()

DataItem::getFilter ( )

Returns the filter set on this object.

Reimplemented from AbstractDataItem.

Definition at line 505 of file data_item.inc.

      {
           return $this->filter;
      }

◆ getHiddenFields()

DataItem::getHiddenFields ( )

Retrieves the list of hidden fields.

These will be automatically hidden in any AutoForm.

Returns: array of names of hidden fields.

Reimplemented from AbstractDataItem.

Definition at line 249 of file data_item.inc.

      {
           return $this->hiddenFields;
      }

◆ getPrimaryKey()

DataItem::getPrimaryKey ( )

Retrieves the primary key field name.

Reimplemented from AbstractDataItem.

Definition at line 455 of file data_item.inc.

      {
           return $this->primary_key;
      }

◆ getPrimaryKeyList()

DataItem::getPrimaryKeyList ( )

Retrieves a list of all the primary keys used for an object as an array.

Returns: array all the primary keys for this object's constituent parts

Reimplemented from AbstractDataItem.

Definition at line 464 of file data_item.inc.

      {
           return array($this->primary_key);
      }

◆ getRelated()

DataItem::getRelated	(	$class,
		$field = `""`
	)

Returns a single item related by the specified foreign key.

The foreign key name must match the primary key name for the specified class.

Use this method to implement one-to-one relations.

Parameters

string	$class	the name of the related class
string	$field	the name of the foreign key defining the relation.

Definition at line 1210 of file data_item.inc.

      {
           $obj = new $class;
           if ($field == "") 
           {
                $field = $obj->primary_key;
                
           }
           
           if (array_key_exists($field, $this->getFields()))
           {
                $pk = $obj->primary_key;
                $val = $this->get($field);
                
                if (!$val) return null;
                
                $obj->$pk = $val;
                
                $cache = "_{$class}_{$field}_{$val}";
                if (isset($this->$cache))
                {
                     $obj->copy($this->$cache);
                }
                else
                {
                     $obj->select();
                     $this->$cache = $obj;
                }              
           }
           else
           {
                $field = $this->primary_key;
                $obj = querySingle($class, "WHERE $field={$this->$field}");      
           }
           return $obj;
      }

◆ getRelatedList()

DataItem::getRelatedList	(	$class,
		$field = `""`,
		$orderBy = `""`
	)

Returns a list of items that are related to this item.

Usually the items will be related by having a foreign key field that matches the primary key on the calling object. However, another field on the calling object can be specified if required. You can also optionally specify a sort order for the results.

Use this field to implement one-to-many relationships.

Parameters

string	$class	the name of the related class
string	$field	(optional) the name of the field defining the relation
string	$orderBy	(optional) a sort order clause for the results

Definition at line 1260 of file data_item.inc.

      {
           $pk = $this->primary_key;
           
           if ($field == "") $field = $pk;
           $value = $this->$field ? $this->$field : $this->$pk;
           $orderBy = preg_replace("/^\s*WHERE\s+/i", "AND ", $orderBy);
           //$this->quoteFieldValue($this->$field, $this->fields[$field])
           $list = query($class, "WHERE $field=$value $orderBy");
           
           return $list;
      }

◆ getTransaction()

DataItem::getTransaction ( )

Retrieves the current DataTransaction.

Reimplemented from AbstractDataItem.

Definition at line 206 of file data_item.inc.

      {
           return $this->_tx;
      }

◆ getType()

DataItem::getType ( $field )

Retrieves the data type of the specified field.

Parameters

$field the field in question

Returns: string the data type of the specified field

Reimplemented from AbstractDataItem.

Definition at line 496 of file data_item.inc.

      {
           $fields = $this->getFields();
           return $fields[$field];
      }

◆ hasField()

DataItem::hasField ( $field )

Returns true if this DataItem contains a field with the specified name and that field is not excluded by a filter.

Parameters

string $field

Returns: true if this field is present and not filtered, false otherwise.

Reimplemented from AbstractDataItem.

Definition at line 434 of file data_item.inc.

      {
           if (!array_key_exists($field, $this->getFields())) return false;
           if ($this->filter && $this->filter->isExcluded($field)) return false;
           return true;
      }

◆ hasRelation()

DataItem::hasRelation ( $relation )

Returns true if this DataItem contains a relation with the specified name.

Parameters

string $relation

Returns: true if this relation is present and not filtered, false otherwise.

Reimplemented from AbstractDataItem.

Definition at line 447 of file data_item.inc.

      {
           return (!array_key_exists($relation, $this->relations)) ? false : true;
      }

◆ insert()

DataItem::insert ( )

Insert a new row in the database to store this object.

Reimplemented from AbstractDataItem.

Definition at line 812 of file data_item.inc.

      {
           $this->pack();
           
           $this->fireEvent("beforeInsert");
           
           $pk = $this->primary_key;
           
           $first = true;
           
           $timestampField = null;
           
           foreach($this->getFields() as $field => $type)
           {
                if ($field == $pk && !$this->_disablePK) continue;
           if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (!isset($this->$field) && $this->getType($field) != Timestamp && $this->getType($field) != Boolean) continue;
                
                if ($type == Timestamp)
                {
                     $timestampField = $field;
                }
                
                if (!$first)
                {
                     $fields .= ", ";
                     $values .= ", ";
                }
                
                $fields .= "`".$field."`";
                $values .= $this->quoteFieldValue($field, $type);
  
                $first = false;
           }
                          
           $query = "INSERT INTO {$this->table} ($fields) values ($values)";
           
           trace("DataItem::insert() - $query", 3);
           
           $success = false;
           
           try
           {              
                $db = $this->getConnection();
                $success = $db->exec($query);
                
                if ($success !== FALSE)
                {
                     $this->$pk = $db->lastInsertId();
                     //AJG - Set the timestamp field value if the insert succeeded
                     if ($timestampField) 
                     {
                          $this->$timestampField = $this->__timestamp;
                          unset($this->__timestamp);
                     }
                     
                     $this->fireEvent("onInsert");
                }
                else
                {
                     $this->$pk = 0;
                     trace("DataItem::insert() failed - $query", 2);
                }
           }    
           catch(PDOException $e)
           {
                $err = "DataItem::insert() failed - ". $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           return $success;                             
      }

◆ joinTransaction()

DataItem::joinTransaction ( $tx )

Join the DataItem to the specified DataTransaction.

Parameters

DataTransaction $tx the transaction to join

Reimplemented from AbstractDataItem.

Definition at line 198 of file data_item.inc.

      {
           $this->_tx = $tx;
      }

◆ load()

DataItem::load ( $id )

Load the object with the specified primary key.

Parameters

int	id the primary key value to instantiate from

Reimplemented from AbstractDataItem.

Definition at line 561 of file data_item.inc.

      {
           if ($this->cacheLookup($id)) return;
            
           $fields = $this->getFieldList();
           $query = "SELECT $fields FROM {$this->table} WHERE {$this->primary_key}=$id ".$this->getIdentityConstraint();
           trace("DataItem::load($id): $query", 3);
           
           $db = $this->getConnection();
           
           try
           {
                $result = $db->prepare($query);
                $result->execute();
                
                if ($line = $result->fetch())
                {
                     $this->populate($line);
                }
                
                unset($result);
           }
           catch(PDOException $e)
           {
                $err = "DataItem::load() failed - ".$e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
      }

◆ loadComposite()

DataItem::loadComposite ( )

Creates an outer CompositeDataItem from its base component.

In order for this method to succeed, the base component table must have a 'composite_class' field that is populated with the class name of the correct CompositeDataItem class.

Returns: CompositeDataItem the containing CompositeDataItem for this base component.

Definition at line 620 of file data_item.inc.

      {
           if (!$this->hasField("composite_class") || !$this->composite_class)
           {
                throw new DataItemException("Cannot create composite from ".get_class($this)." as required composite cannot be determined");
           }
           
           $composite = new $this->composite_class;
           $composite->loadFromBase($this->get($this->getPrimaryKey()));
           
           return $composite;
      }

◆ old()

DataItem::old ( )

Retrieves the currently stored state of the DataItem from the database and returns it as a new object.

This can be used for comparisons when updating a DataItem, for instance to trigger related updates when a field value is changed.

Returns: DataItem a DataItem populated from the database based on the current item's primary key. The returned DataItem has the same filter and DataTransaction as the parent item.

Definition at line 601 of file data_item.inc.

      {
           $pk = $this->getPrimaryKeyValue();
           if (!$pk) return null;
           
           $cl = get_class($this);
           $n = new $cl;
           $n->filter = $this->filter;
           $n->joinTransaction($this->getTransaction());
           $n->load($pk);
           return $n;     
      }

◆ overrideFieldType()

DataItem::overrideFieldType	(	$field,
		$type
	)

Override the type for the specified field.

Parameters

string	$field
string	$type

Definition at line 347 of file data_item.inc.

      {
           if (!is_array($this->fields))
           {
                throw new FakoliException("Cannot override field types for statically defined DataItems");
           }
           
           $this->fields[$field] = $type;
      }

◆ pack()

DataItem::pack ( )

The pack() method is called prior to persisting a DataItem to storage.

It can be used to perform a preprocessing step prior to storage, such as formatting sub-objects into a JSON, XML or other serialized format and storing them in a field.

Definition at line 543 of file data_item.inc.

544 {

545 }

◆ populate()

DataItem::populate	(	$line,
		$alias = `false`
	)

Populates the object using the supplied associative array (field -> value).

Only values that match the definition of the sub-classed object will be copied. Fields that have been excluded by the use of an InclusionFilter or ExclusionFilter will also not be populated.

Parameters

array $line the array of values to populate the object with.

Definition at line 262 of file data_item.inc.

      {
           global $config;
           
           // NOTE - structured for speed, since the general case is no aliasing
           // therefore we want to reduce the number of tests of the alias 
           
           $fields = $this->getFields();
           
      if ($alias)
         {
           $offset = strlen($alias) + 1;
           
           foreach ($line as $field => $value)
              {
                if (!startsWith($field, $alias)) continue;
                $field = substr($field, $offset);
           
                if (!array_key_exists($field, $fields)) continue;
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                
                if (!isset($config["no_charset_conversions"]) || $config["no_charset_conversions"])
                {
                     $this->$field = $value;
                }
                else
                {
                     $this->$field = iconv("UTF-8", "CP1252//IGNORE", $value);
                } 
                }
         }
         else
         {
                foreach ($line as $field => $value)
              {
                if (!array_key_exists($field, $fields)) continue;
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                
                if (!isset($config["no_charset_conversions"]) || $config["no_charset_conversions"])
                {
                     $this->$field = $value;
                }
                else
                {
                     $this->$field = iconv("UTF-8", "CP1252//IGNORE", $value);
                } 
              } 
         }
         
         if (isset($this->calculatedFields))
         {
           foreach($this->calculatedFields as $field => $expr)
           {
                if ($alias) 
                {
                     $this->$field = $line[$alias.".".$field];
                }
                else
                {
                     $this->$field = $line[$field];
                }
           }
         }
         
         $this->unpack();
         $this->fireEvent("onPopulate");
      }

◆ prettifyFieldName()

DataItem::prettifyFieldName ( $field )

Reimplemented from AbstractDataItem.

Definition at line 1769 of file data_item.inc.

      {
           if (isset($this->fieldAliases) && array_key_exists($field, $this->fieldAliases))
           {
                return $this->fieldAliases[$field];
           }
           
           $field = preg_replace("/([a-z])([A-Z0-9])/", "$1 $2", $field);
           $field = str_replace("_", " ", $field);
           $field = ucwords($field);
           
           return $field;
      }

◆ queryValue()

DataItem::queryValue ( $func )

Query the database to calculate an aggregate value.

The database table associated with the instatiated object is used as the source for the data.

Parameters

string	$func	the value or function to retrieve
string	$constraints	optional constraint clause to apply to the query

Definition at line 1346 of file data_item.inc.

      {
           $constraints = "";
           $value = null;
           
           if (func_num_args() > 1)
           {
                $constraints = func_get_arg(1);
                
                if (func_num_args() > 2)
                {
                     $value = func_get_arg(2);
                }
           }
           
           if ($constraints == "") $constraints = "WHERE 1=1"; //TODO - tidy this up some day
           $constraints .= " ".$this->getIdentityConstraint();
           
           $query = "SELECT $func as result FROM {$this->table} $constraints";
           
           trace("DataItem::queryValue: $query", 3);
           try
           {
                $db = $this->getConnection();
                $result = $db->prepare($query);
                $result->execute();
           
                if ($row =$result->fetch())
                {
                     $value = $row['result'];
                }
                
                unset($result);
           }
           catch(PDOException $e)
           {
                $err = "DataItem::queryValue() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           
           return $value;
                
      }

◆ registerEventHandler()

static DataItem::registerEventHandler	(	$class,
		$event,
		$handler
	)

static

Register an event handler for a specific event and DataItem class.

DataItem events are fired by DataItems at various points in the data lifecycle (such as inserting, updating, deleting, etc.)

Parameters

string	$class	the DataItem class to which the event handler is to be attached
string	$event	the name of the event
callable	$handler	the event handler (a callable function)

Definition at line 151 of file data_item.inc.

      {
           $eventKey = "{$class}_{$event}";
           
           if (!array_key_exists($eventKey, DataItem::$_eventMap))
           {
                
                DataItem::$_eventMap[$eventKey]= array();
           }
           
           array_push(DataItem::$_eventMap[$eventKey], $handler);
      }

◆ relateTo()

DataItem::relateTo	(	$target,
		$field = `""`
	)

Link this object to the specified target by setting corresponding field to the value of the target's primary key.

Parameters

DataItem	$target	the DataItem to which the relationship will be created
string	$field	the field to set for the relationship. If not specified, the primary key of the target object is used for the foreign key field name.

Reimplemented from AbstractDataItem.

Definition at line 1791 of file data_item.inc.

      {
           $pk = $target->primary_key;
           
           if (!$field) $field = $pk;
           
           $this->$field = $target->$pk;
      }

◆ save()

DataItem::save ( )

Store the object in the database.

Reimplemented from AbstractDataItem.

Definition at line 636 of file data_item.inc.

      {
          if ($this->cacheLocal)
           {
                Cache::invalidate(get_class($this)."_cache");
           }
  
           if ($this->exists())
      {
           return $this->update();
      }
      else
      {
           return $this->insert();
      }
      }

◆ select()

DataItem::select ( )

Select the object from the database, based on the value of the primary key field.

Reimplemented from AbstractDataItem.

Definition at line 656 of file data_item.inc.

      {
           $pk = $this->primary_key;
           $this->load($this->$pk);
      }

◆ set()

DataItem::set	(	$field,
		$value
	)

Set the value of the specified field.

Parameters

$field	the field to set
$value	the value to which the field is to be set

Reimplemented from AbstractDataItem.

Definition at line 485 of file data_item.inc.

      {
           if (!$field) throw new FakoliException("Cannot access empty field");
           $this->$field = $value;
      }

◆ setFilter()

DataItem::setFilter ( $filter )

Sets the filter on this object.

Parameters

$filter the filter

Reimplemented from AbstractDataItem.

Definition at line 514 of file data_item.inc.

      {
           $this->filter = $filter;
      }    

◆ tableExists()

DataItem::tableExists ( )

Check if the table for this class exists in the database.

Definition at line 944 of file data_item.inc.

      {
           $query = "SHOW TABLES LIKE '{$this->table}'";
           $db = $this->getConnection();
                     
           trace($query, 3);
           
           $exists = false;
           
           try
           {
                $result = $db->prepare($query);
                $result->execute();
                
                if ($line = $result->fetch())
                {
                     $exists = true;
                }
                
                unset($result);
           }
           catch(PDOException $e)
           {
                $err = "DataItem::tableExists() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
  
           return $exists;
      }    

◆ toJSON()

DataItem::toJSON ( )

Definition at line 1502 of file data_item.inc.

      {
           $out = array();
                     
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field))
                {
                     continue;
                }
                
                $val = str_replace("\\'", "'", json_encode((string)$this->get($field)));
                
                $out[] = "\"{$field}\": ".$val;              
           }    
           
           return "{".implode(", ", $out)."}";          
      }

◆ toXML()

DataItem::toXML	(	$indent = `0`,
		$path = `null`
	)

Generates an XML representation of the object.

Filters are honored when determining which fields are included in the XML. Empty fields are not output (note that a string field with value "" is not considered empty).

Reimplemented from AbstractDataItem.

Definition at line 1396 of file data_item.inc.

      {
           trace(get_class($this)."->toXML()", 4);
           
           $xml = str_repeat(" ", $indent) . "<" . get_class($this) . ">\n";
           
           foreach($this->getFields() as $field => $type)
           {
                if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (isset($this->$field))
                {
                     if ($this->$field === "")
                     {
                          $xml .= str_repeat(" ", $indent) . " <$field/>\n";
                     }
                     else
                     {
                          $xml .= str_repeat(" ", $indent) . " <{$field}>".$this->formatFieldForXML($field)."</$field>\n";
                     }
                     
                }              
           }
           
           $path[get_class($this)] = true;
           trace(implode(" > ", array_keys($path)), 4);
           trace("Options: ".$this->_options, 4);
           
           if (($this->_options & SerializeRelations) || 
                ($this->_options & SerializeDirectRelations) && 
                $this->relations)
           {
                if (is_array($this->relations))
                {
                     foreach($this->relations as $rel => $relType)
                     {
                          if (is_array($path) && array_key_exists($relType, $path)) continue;
                               
                          $obj = $this->$rel();
                          if ($obj)
                          {
                               $xml .= str_repeat(" ", $indent) . " <$rel>\n";
                               
                               if (is_array($obj))
                               {
                                    foreach($obj as $item)
                                    {
                                         if ($this->_options & SerializeRelations)
                                         {
                                              $item->setOption(SerializeRelations);
                                         }
                                         
                                         if ($this->_options & ProtectHTML)
                                         {
                                              $item->setOption(ProtectHTML);
                                         }
                                         
                                         $xml .= $item->toXML($indent + 2, $path);
                                    }
                               }
                               else
                               {
                                    if ($this->_options & SerializeRelations)
                                    {
                                         $obj->setOption(SerializeRelations);
                                    }
                               
                                    if ($this->_options & ProtectHTML)
                                    {
                                         $obj->setOption(ProtectHTML);
                                    }
                               
                                    $xml .= $obj->toXML($indent + 2, $path);
                               }
                               
                               $xml .= str_repeat(" ", $indent) . " </$rel>\n";
                          }
                          else
                          {
                               $xml .= str_repeat(" ", $indent) . " <$rel/>\n";
                          }
                     }
                }
           }    
                
           $xml .= str_repeat(" ", $indent) . "</" . get_class($this) . ">\n";
           
           return $xml;
      }

◆ unpack()

DataItem::unpack ( )

The unpack() method is called after populating a DataItem.

It can be used to unpack serialized sub-object representations so they are can be used directly by your application.

Definition at line 552 of file data_item.inc.

553 {

554 }

◆ update()

DataItem::update ( )

Update the row in the database that corresponds to this object.

Reimplemented from AbstractDataItem.

Definition at line 707 of file data_item.inc.

      {
           $this->fireEvent("beforeUpdate");
           $this->pack();
           
           $pk = $this->primary_key;
  
           $query = "UPDATE {$this->table} SET ";
           
           $first = true;
           $found = false;
           
           foreach($this->getFields() as $field => $type)
           {              
                if ($field == $this->primary_key) continue;
           if ($this->filter && $this->filter->isExcluded($field)) continue;
                if (!isset($this->$field) && $this->getType($field) != Timestamp && $this->getType($field) != Boolean) continue;
                
                if (!$first) $query .= ", ";
                
                $first = false;
                $found = true;
                
                $query .= "`$field`=";
                $query .= $this->quoteFieldValue($field, $type);
      }
  
      if (!$found) return true; // No fields to update - bug out quietly
      
           $query .= " WHERE $pk={$this->$pk} ".$this->getIdentityConstraint();
           
           trace("DataItem::update() - $query", 3);
           
           try
           {
                
                $db = $this->getConnection();
                
                $success = $db->exec($query);
                if ($success === FALSE)
                {
                     trace("DataItem::update failed - $query", 2);
                }
                else
                {
                     $this->fireEvent("onUpdate");
                }
           }
           catch(PDOException $e)
           {
                $err = "DataItem::update() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);      
           }
           
           return $success;
      }

◆ updateExplicit()

DataItem::updateExplicit	(	$updates,
		$params = `null`
	)

Executes an explicit update command against the database.

This enables you to perform updates on the object using database functions, allowing for atomic operations, etc. For example, you might make such a call as $obj->updateExplicit("SET count=count+1"); The object is refreshed from the database automatically after the update.

Parameters

string	$updates	the update command to be run
array	$params	optional array for bound parameters

Returns: boolean TRUE if the update was successful, FALSE if not.

Definition at line 775 of file data_item.inc.

      {
           $pk = $this->primary_key;
           
           $query = "UPDATE {$this->table} $updates";
  
           if ($this->get($pk))
           {
                $query .= " WHERE {$pk}=".$this->get($pk);
           }
           
           trace("DataItem::update() - $query", 3);
           
           try
           {
                $db = $this->getConnection();
                $stmt = $db->prepare($query);
                $success = $stmt->execute($params);
                if ($success === FALSE)
                {
                     trace("DataItem::updateExplicit failed - $query", 2);
                }
                if ($this->get($pk)) $this->select();
           }
           catch(PDOException $e)
           {
                $err = "DataItem::updateExplicit() failed - " . $e->getMessage();
                trace($err, 2);
                throw new DataItemException($err);
           }
           
           return $success;
      }

Member Data Documentation

◆ $_eventMap

DataItem::$_eventMap = array()

static

Definition at line 63 of file data_item.inc.

◆ $_pkDisabled

DataItem::$_pkDisabled = false

Definition at line 66 of file data_item.inc.

◆ $_tx

DataItem::$_tx = null

Definition at line 65 of file data_item.inc.

◆ $dataTypeRendererMap

DataItem::$dataTypeRendererMap

static

Initial value:

= array(
          "Boolean"      =>   BooleanTypeRenderer,     
          "Currency"          =>   CurrencyTypeRenderer,
          "Currency3"         =>   CurrencyTypeRenderer,
          "Date"              =>   DateTypeRenderer,
          "DateTime"          =>   DateTimeTypeRenderer,
          "Time"              =>   TimeTypeRenderer,
          "Number"       =>   NumberTypeRenderer, 
          "String"       =>   StringTypeRenderer,
          "Text"              =>   TextTypeRenderer,
          "HTML"              =>   TextTypeRenderer,
          "Timestamp"         =>   TimestampTypeRenderer,
          "Timezone"          =>   TimezoneTypeRenderer,
          "PhoneNumber"  =>   PhoneNumberTypeRenderer,
          "DateOfBirth"  =>   DateTypeRenderer
     )

Definition at line 70 of file data_item.inc.

The documentation for this class was generated from the following file:

C:/code/cms.sonjara.com/framework/data_item.inc

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

◆ __sleep()

◆ cacheLookup()

◆ cast()

◆ cloneFrom()

◆ compare()

◆ copy()

◆ crossReference()

◆ DataItem()

◆ delete()

◆ deleteAll()

◆ disablePrimaryKey()

◆ distinctValues()

◆ duplicate()

◆ enablePrimaryKey()

◆ exists()

◆ fireEvent()

◆ format()

◆ formatField()

◆ formatThroughRelation()

◆ fromDataSet()

◆ fromGET()

◆ fromPOST()

◆ fromREQUEST()

◆ fromXML()

◆ get()

◆ getFieldAliases()

◆ getFieldAnnotations()

◆ getFieldArray()

◆ getFieldList()

◆ getFields()

◆ getFilter()

◆ getHiddenFields()

◆ getPrimaryKey()

◆ getPrimaryKeyList()

◆ getRelated()

◆ getRelatedList()

◆ getTransaction()

◆ getType()

◆ hasField()

◆ hasRelation()

◆ insert()

◆ joinTransaction()

◆ load()

◆ loadComposite()

◆ old()

◆ overrideFieldType()

◆ pack()

◆ populate()

◆ prettifyFieldName()

◆ queryValue()

◆ registerEventHandler()

◆ relateTo()

◆ save()

◆ select()

◆ set()

◆ setFilter()

◆ tableExists()

◆ toJSON()

◆ toXML()

◆ unpack()

◆ update()

◆ updateExplicit()

Member Data Documentation

◆ $_eventMap

◆ $_pkDisabled

◆ $_tx

◆ $dataTypeRendererMap