Dataface/RelatedRecord.php

Go to the documentation of this file.

<?php
/*-------------------------------------------------------------------------------
 * Xataface Web Application Framework
 * Copyright (C) 2005-2008 Web Lite Solutions Corp (shannah@sfu.ca)
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *-------------------------------------------------------------------------------
 */
class Dataface_RelatedRecord {

        var $secureDisplay = true;

        var $vetoSecurity;
        var $_record;
        
        var $_relationshipName;
        
        var $_relationship;
        
        var $_values;
        
        var $_metaDataValues;
        
        var $_absoluteColumnNames;
        
        var $_lockedFields=array();
        var $_records;
        var $_dirtyFlags=array();
        
        var $cache=array();
        
        
        function Dataface_RelatedRecord($record, $relationshipName, $values=null){
                
                if ( !is_a($record, 'Dataface_Record') ){
                        throw new Exception("Error in Dataface_RelatedRecord constructor.  Expected first argument to be of type 'Dataface_Record' but received '".get_class($record)."'.", E_USER_ERROR);
                }
                $this->_record =& $record;
                $this->_relationshipName = $relationshipName;
                $this->_relationship =& $record->_table->getRelationship($relationshipName);
                if ( is_array($values) ){
                        $this->setValues($values);
                        $this->clearFlags();
                }
        }
        
        
        function _initValues(){
                if ( !isset( $this->_values ) ){
                        $fkeys = $this->_relationship->getForeignKeyValues();
                        $this->_values = array();
                        $this->_absoluteColumnNames = array();
                        //$cols = $this->_relationship->_schema['columns'];
                        $cols = $this->_relationship->fields(true); // we will get all fields - even grafted ones.
                        foreach ($cols as $col){
                                list($table, $field) = explode('.', $col);
                                $this->_values[$field] = null;
                                if ( isset($this->_absoluteColumnNames[$field]) and
                                        Dataface_Table::loadTable($this->_relationship->getDomainTable())->hasField($field) ){
                                                $this->_absoluteColumnNames[$field] = $this->_relationship->getDomainTable().'.'.$field;
                                } else {
                                        $this->_absoluteColumnNames[$field] = $col;
                                }
                                
                                
                                /*
                                 * We want to check for locked fields. Locked fields are fields that *must* have a particular
                                 * value for the relationship to remain valid.
                                 */
                                if ( isset( $fkeys[$table][$field]) and is_scalar($fkeys[$table][$field]) and strpos($fkeys[$table][$field],'$') ===0 ){
                                        $this->_lockedFields[$field] = $fkeys[$table][$field];
                                        $this->_values[$field] = $this->_record->parseString($fkeys[$table][$field]);
                                }
                        }
                }
        }
        
        //---------------------------------------------------------------------------------
        //{@
        
        function clearCache(){
                $this->cache = array();
                return $this;
        }
        
        
        function &toRecord($tablename=null){
                if ( isset($this->cache[__FUNCTION__][$tablename]) ){
                        return $this->cache[__FUNCTION__][$tablename];
                }
                if ( !isset($tablename) ){
                        $tablename =  $this->_relationship->getDomainTable();
                        
                        
                } 
                
                $table =& Dataface_Table::loadTable($tablename);
                
                
                $values = array();
                
                
                $absVals = $this->getAbsoluteValues();
                $fieldnames = $this->_relationship->fields(true);
                //foreach ( array_keys($absVals) as $key ){
                foreach ( $fieldnames as $key ){
                        list($currTablename, $columnName) = explode('.', $key);
                        if ( ($currTablename == $tablename or $table->hasField($columnName)) and array_key_exists($key, $absVals)){
                                                                
                                $values[$columnName] = $absVals[$key];
                                
                        } else if ( isset($this->_relationship->_schema['aliases'][$columnName]) /*and 
                                /*$table->hasField($this->_relationship->_schema['aliases'][$columnName])*/ ){
                                $values[$this->_relationship->_schema['aliases'][$columnName]] = $absVals[$key];
                        }
                }
                
                foreach ( $this->_values as $key=>$val ){
                        if ( !isset($values[$key]) and $table->hasField($key) ) $values[$key] = $this->_values[$key];
                }
                
                $record = new Dataface_Record($tablename, $values);
                $record->secureDisplay = $this->secureDisplay;
                foreach (array_keys($values) as $key){

                        if ( $this->isDirty($key) ) $record->setFlag($key);

                }
                $this->cache[__FUNCTION__][$tablename] =& $record;

                return $record;
        }
        
        
        
        function toRecords(){
                $tables =& $this->_relationship->getDestinationTables();
                $out = array();
                foreach ( array_keys($tables) as $index ){
                        $out[] =& $this->toRecord($tables[$index]->tablename);
                }
                return $out;
        }
        
        
        function &getParent(){
                return $this->_record;
        }
        
        
        function testCondition($condition){
                extract($this->strvals());
                return eval('return ('.$condition.');');
        }
        
        
        function getActions($params=array()){
                $params['record'] =& $this;
                return $this->_record->_table->tablename->getActions($params);
        }
        
        
        // @}
        // END OF Utility Methods
        //-------------------------------------------------------------------------------------
        
        
        //-------------------------------------------------------------------------------------
        // @{
        function clearFlags(){
                $this->_dirtyFlags = array();
                return $this;
        }
        
        function setFlag($fieldname){
                $this->_dirtyFlags[$fieldname] = true;
                return $this;
        }
        
        function clearFlag($fieldname){
                unset($this->_dirtyFlags[$fieldname]);
                return $this;
        }
        
        function isDirty($fieldname){
                return ( isset($this->_dirtyFlags[$fieldname]) );
        }
        
        // @}
        // End Transactions
        //---------------------------------------------------------------------------------------
        
        //----------------------------------------------------------------------------------------
        // @{
        
        function setMetaDataValue($key, $value){
                if ( !isset( $this->_metaDataValues ) ) $this->_metaDataValues = array();
                $this->_metaDataValues[$key] = $value;
                return $this;
                
        }
        
        
        function getLength($fieldname){
                if ( strpos($fieldname, '.') !== false ){
                        list($tablename, $fieldname) = explode('.', $fieldname);
                        return $this->getLength($fieldname);
                }
                $key = '__'.$fieldname.'_length';
                if ( isset( $this->_metaDataValues[$key] ) ){
                        return $this->_metaDataValues[$key];
                } else {
                        return strlen($this->getValueAsString($fieldname));
                }       
        }
        
        function setValue($fieldname, $value){
                $this->_initValues();
                
                
                if ( strpos($fieldname,'.') === false ){
                        if ( strpos($fieldname, '__') === 0 ){
                                return $this->setMetaDataValue($fieldname, $value);
                        }
                
                        if ( isset( $this->_lockedFields[$fieldname]) ) return;
                        $val = $this->_record->_table->parse($this->_relationshipName.".".$fieldname, $value);
                        if ( $val != $this->_values[$fieldname] ){
                                $this->_values[$fieldname] = $val;
                                $this->clearCache();
                                $this->setFlag($fieldname);
                        }
                
                } else {
                        
                        list ( $table, $field )  = explode('.', $fieldname);
                        if ( $table != $this->_relationship->getDomainTable() and Dataface_Table::loadTable($this->_relationship->getDomainTable())->hasField($field) ){
                                return PEAR::raiseError("Cannot set duplicate value in relationship.   The field $fieldname is part of the domain table and not part of $table in this relationship.");
                        }
                        return $this->setValue($field, $value);
                }
                        
        }
        
        function setValues($values){
                if ( !is_array($values) ){
                        throw new Exception( "setValues() expects 1st parameter to be an array but received a '".get_class($values)."' ",E_USER_WARNING);
                }
                foreach ( $values as $key=>$value){
                        
                        $this->setValue($key, $value);
                }
        
        }
        
        
        
                
                
        function getValue($fieldname){
                $this->_initValues();
                if ( strpos($fieldname,'.') === false ){
                        
                        if ( !array_key_exists( $fieldname,  $this->_values ) ){
                                // The key does not exist as a normal field -- so check if it is a calculated field.
                                $tables = $this->_relationship->getDestinationTables();
                                $dt =& Dataface_Table::loadTable($this->_relationship->getDomainTable());
                                
                                if ( $dt->hasField($fieldname) ){
                                        echo "Domain table has $fieldname";
                                        $tables = array($this->_relationship->getDomainTable());
                                } else {
                                        echo "Domain table doesn't have $fieldname";
                                }       
                                foreach ( array_keys($tables) as $tkey){
                                        if ( $tables[$tkey]->hasField($fieldname) ){
                                                $tempRecord = new Dataface_Record($tables[$tkey]->tablename,$this->getValues());
                                                return $tempRecord->getValue($fieldname);
                                        }
                                }
                                throw new Exception("Attempt to get value for fieldname '$fieldname' that does not exist in related record of relationship '".$this->_relationshipName."'.  Acceptable values include {".implode(', ', array_keys($this->_values))."}.\n<br>", E_USER_ERROR);
                        }

                        return $this->_values[$fieldname];
                        
                } else {
                        list ( $table, $field )  = explode('.', $fieldname);
                        return $this->getValue($field);
                }
        }
        
        function getValueAsString($fieldname){
                $value = $this->getValue($fieldname);

                $parent =& $this->getParent();
                $table =& $parent->_table->getTableTableForField($this->_relationshipName.'.'.$fieldname);
                if ( PEAR::isError($table) ){
                        throw new Exception($table->toString(), E_USER_ERROR);
                }
                $delegate =& $table->getDelegate();
                $rel_fieldname = $fieldname; //$table->relativeFieldName($fieldname);
                if ( $delegate !== null and method_exists( $delegate, $rel_fieldname.'__toString') ){
                        $value = call_user_func( array(&$delegate, $rel_fieldname.'__toString'), $value);
                } else 
                
                
                if ( is_array($value) ){
                        if ( method_exists( $table, $table->getType($fieldname)."_to_string") ){
                                $value = call_user_func( array( &$table, $table->getType($fieldname)."_to_string"), $value );
                        } else {
                                $value = implode(', ', $value);
                        }
                }
                
                
                $evt = new stdClass;
                $evt->table = $table;
                $evt->field =& $table->getField($rel_fieldname);
                $evt->value = $value;
                $evt->type = $table->getType($rel_fieldname);
                $table->app->fireEvent('after_getValueAsString', $evt);
                $value = $evt->value;
                
                return $value;
        
        }
        
        function htmlValue($fieldname){
                $value = $this->getValue($fieldname);
                $parent =& $this->getParent();
                $table =& $parent->_table->getTableTableForField($this->_relationshipName.'.'.$fieldname);
                if ( PEAR::isError($table) ){
                        throw new Exception($table->toString(), E_USER_ERROR);
                }
                $record =& $this->toRecord($table->tablename);
                $htmlval = $record->htmlValue($fieldname);
                return $htmlval;
        }
        
        function getValuesAsStrings($fields=''){
                $keys = is_array($fields) ? $fields : array_keys($this->_values);
                $values = array();
                foreach ($keys as $key){
                        $values[$key] = $this->getValueAsString($key);
                }
                return $values;
        }
        
        
        function strvals($fields=''){
                return $this->getValuesAsStrings($fields);
        }
        
        
        function strval($fieldname, $index=0){
                return $this->getValueAsString($fieldname, $index);
        }
        
        
        function stringValue($fieldname){
                return $this->getValueAsString($fieldname);
        }
        
        function &getValues($columns=null, $excludeNulls=false){
                $this->_initValues();
                return $this->_values;
        }

        function &values($fields = null){
                return $this->getValues($fields);
        }
        
        function &vals($fields = null){
                return $this->getValues($fields);
        }
        
        
        function val($fieldname){
                return $this->getValue($fieldname);
        }
        
        
        
        function getAbsoluteValues($excludeNulls=false, $includeAll=false){
                $absVals = array();
                foreach ( $this->getValues() as $key=>$value){
                        $absVals[ $this->_absoluteColumnNames[$key] ] = $value;
                }
                return $absVals;
                
        
        }
        
        function getForeignKeyValues($sql = null){
                if ( !isset($sql) ) $sql_index = 0;
                else $sql_index = $sql;
                if ( isset($this->cache[__FUNCTION__][$sql_index]) ){
                        return $this->cache[__FUNCTION__][$sql_index];
                }
                $fkeys = $this->_relationship->getForeignKeyValues();
                $absVals = $this->getAbsoluteValues(true);
        
                $out = $this->_relationship->getForeignKeyValues($absVals, $sql, $this->getParent());
                $this->cache[__FUNCTION__][$sql_index] = $out;
                return $out;
                
        }
        
        
        
        
        function display($fieldname){
                if ( isset($this->cache[__FUNCTION__][$fieldname]) ){
                        return $this->cache[__FUNCTION__][$fieldname];
                }
                $parent =& $this->getParent();
                $table =& $parent->_table->getTableTableForField($this->_relationshipName.'.'.$fieldname);
                if (PEAR::isError($table) ){
                        throw new Exception("Error loading table while displaying $fieldname because ".$table->getMessage(), E_USER_ERROR);
                        
                }
                
                
                if ( !$table->isBlob($fieldname) ){
                        $record =& $this->toRecord($table->tablename);
                        if ( $this->secureDisplay and $this->checkPermission('view', array('field'=>$fieldname)) ){
                                //echo "HERE";
                                $oldSecure = $record->secureDisplay;
                                $record->secureDisplay = false;
                                $out = $record->display($fieldname);
                                $record->secureDisplay = $oldSecure;
                        } else {
                                $out = $record->display($fieldname);
                        }
                        
                        $this->cache[__FUNCTION__][$fieldname] = $out;
                        return $out;
                        
                } else {
                        $keys = array_keys($table->keys());
                        $qstr = '';
                        foreach ($keys as $key){
                                $qstr .= "&$key"."=".$this->strval($key);
                        }
                        $out = DATAFACE_SITE_HREF."?-action=getBlob&-table=".$table->tablename."&-field=$fieldname$qstr";
                        $this->cache[__FUNCTION__][$fieldname] = $out;
                        return $out;
                }
                                
                                
        }
        
        function preview($fieldname, $index=0, $maxlength=255){
                if ( isset($this->cache[__FUNCTION__][$fieldname][$index][$maxlength]) ){
                        return $this->cache[__FUNCTION__][$fieldname][$index][$maxlength];
                }
                $strval = strip_tags($this->display($fieldname,$index));
                $out = substr($strval, 0, $maxlength);
                if ( strlen($strval)>$maxlength) {
                        $out .= '...';
                }
                $this->cache[__FUNCTION__][$fieldname][$index][$maxlength] = $out;
                return $out;
        }
        
        function printValue($fieldname){
                return $this->display($fieldname);
        }
        
        function printval($fieldname){
                return $this->display($fieldname);
        }
        
        function q($fieldname){
                return $this->display($fieldname);
        }
        
        function qq($fieldname){
                $parent =& $this->getParent();
                $table =& $parent->_table->getTableTableForField($this->_relationshipName.'.'.$fieldname);
                if ( PEAR::isError($table) ){
                        throw new Exception($table->toString(), E_USER_ERROR);
                }
                if ( !$table->isBlob($fieldname) ){
                        return htmlspecialchars($this->q($fieldname, $index));
                } else {
                        return $this->display($fieldname, $index);
                }
        }
        
        
        // @}
        // End Accessing Field Data
        //-------------------------------------------------------------------------------------------
        
        
        //-------------------------------------------------------------------------------------------
        // @{
        function getId(){
                if ( isset($this->cache[__FUNCTION__]) ){
                        return $this->cache[__FUNCTION__];
                }
                $parentid = $this->_record->getId();
                list($tablename, $querystr) = explode('?',$parentid);
                $id = $tablename.'/'.$this->_relationshipName.'?'.$querystr;
                $keys = array_keys($this->_relationship->keys());
                $params = array();
                foreach ($keys as $key){
                        $params[] = urlencode($this->_relationshipName.'::'.$key).'='.urlencode($this->strval($key));
                }
                $out = $id.'&'.implode('&',$params);
                $this->cache[__FUNCTION__] = $out;
                return $out;
        }
        
        
        function getTitle(){
                $record =& $this->toRecord();
                return $record->getTitle();
        }
         
         
         
        // @}
        // END Metadata
        //--------------------------------------------------------------------------------------------  
        
        // @{
        function validate( $fieldname, $value, &$params){
                if ( strpos($fieldname, '.') !== false ){
                        list($relname, $fieldname) = explode('.', $fieldname);
                        return $this->validate($fieldname, $value, $params);
                }
                
                if ( !is_array($params) ){
                        $params = array('message'=> &$params);
                }
                $table =& $this->_relationship->getTable($fieldname);
                if (PEAR::isError($table) ){
                        error_log($table->toString().implode("\n", $table->getBacktrace()));
                        throw new Exception("Failed to get table for field $fieldname.  See error log for details", E_USER_ERROR);
                        
                } else if (!$table ){
                        throw new Exception("Could not load table for field $fieldname .", E_USER_ERROR);
                }
                $field =& $table->getField($fieldname);
                
                if ( $field['widget']['type'] == 'file' and @$field['validators']['required'] and is_array($value) and $this->getLength($fieldname) == 0 and !is_uploaded_file(@$value['tmp_name'])){
                        // This bit of validation operates on the upload values assuming the file was just uploaded as a form.  It assumes
                        // that $value is of the form
                        $params['message'] = "$fieldname is a required field.";
                        return false;
                }
        
                $res = $table->validate($fieldname, $value, $params);
                if ( $res ){
                        $delegate =& $table->getDelegate();
                        if ( $delegate !== null and method_exists($delegate, $fieldname."__validate") ){
                                /*
                                 *
                                 * The delegate defines a custom validation method for this field.  Use it.
                                 *
                                 */
                                $methodname = $fieldname."__validate";
                                $res = $delegate->$methodname($this,$value,$params);
                                //$res = call_user_func(array(&$delegate, $fieldname."__validate"), $this, $value, $params);
                        }
                }
                return $res;
                
        }
        
        // @}
        // END Form Validation
        //--------------------------------------------------------------------------------------------
        
        // @{
        function save($lang=null, $secure=false){
                $recs =& $this->toRecords();
                
                foreach (array_keys($recs) as $i){

                        $res = $recs[$i]->save($lang, $secure);
                        if ( PEAR::isError($res) ) return $res;
                }
        }
        
        // @}
        // End Saving
        //----------------------------------------------------------------------------------------------
        
        //----------------------------------------------------------------------------------------------
        // @{
        function getPermissions($params=array()){
        
                // 1. Get the permissions for the particular field
                if ( isset($params['field']) ){
                        if ( strpos($params['field'],'.') !== false ){
                                list($junk,$fieldname) = explode('.', $params['field']);
                        } else {
                                $fieldname = $params['field'];
                        }
                        $t =& $this->_relationship->getTable($fieldname);
                        $rec = $this->toRecord($t->tablename);
                        
                        
                        $perms = $rec->getPermissions(array('field'=>$fieldname, 'nobubble'=>1));
                        if ( !$perms ) $perms = array();
                        
                        
                        $rfperms = $this->_record->getPermissions(array('relationship'=>$this->_relationshipName, 'field'=>$fieldname, 'nobubble'=>1));
                        //echo "RFPerms: ";print_r($rfperms);
                        if ( $rfperms ){
                                foreach ($rfperms as $k=>$v){
                                        $perms[$k] = $v;
                                }
                        }
                
                        //print_r($perms);
                        return $perms;
                } else {
                        $perms = array();
                        foreach ( $this->toRecords() as $record){
                                $rperms = $record->getPermissions(array());
                                if ( $perms ){
                                        $perms = array_intersect_assoc($perms, $rperms);
                                        
                                } else {
                                        $perms = $rperms;
                                }
                                
                        }
                        return $perms;
                        
                }
        }
        
        function checkPermission($perm, $params=array()){
                $perms = $this->getPermissions($params);
                return @$perms[$perm]?1:0;
                
        }
        
        
        // @}
        // End Permissions
        //----------------------------------------------------------------------------------------------
        
        
        
        
        
        
        



}