HistoryTool.php

Go to the documentation of this file.

<?php
import('Dataface/AuthenticationTool.php');
class Dataface_HistoryTool {

        var $meta_fields = array(
                'history__id'=>array('Type'=>'int(11)', 'Extra'=>'auto_increment'),
                        'history__language'=> array('Type'=>'varchar(2)'),
                        'history__comments'=> array('Type'=>'text'),
                        'history__user'=>array('Type'=>'varchar(32)'),
                        'history__state'=>array('Type'=>'int(5)'),
                        'history__modified'=>array('Type'=>'datetime')
                        );
                        
        
        
        function logRecord(&$record, $comments='', $lang=null, $state=null){
                $app =& Dataface_Application::getInstance();
                
                if ( !isset($lang) ){
                        $lang = $app->_conf['lang'];
                }
                
                if ( !isset($state) ){
                        $state = 0;
                }
                
                
                $fieldnames = array_keys($record->_table->fields());
                $sql = 'select `'.implode('`,`', $fieldnames).'` from `'.$record->_table->tablename.'` where';
                $keynames = array_keys($record->_table->keys());
                $where_clauses = array();
                foreach ( $keynames as $keyname){
                        $where_clauses[] = '`'.$keyname.'`=\''.addslashes($record->strval($keyname)).'\'';
                }
                $sql .= ' '.implode(' and ', $where_clauses);
                
                if ( @$app->_conf['multilingual_content'] ){
                        $db =& Dataface_DB::getInstance();
                        $sql = $db->translate_query($sql, $lang);
                        $sql = $sql[0];
                }
                
                $auth =& Dataface_AuthenticationTool::getInstance();
                $userRecord =& $auth->getLoggedInUser();
                if ( !isset($userRecord) ){
                        $user = null;
                } else {
                        $user = $auth->getLoggedInUsername();
                }
                
                
                $insertsql = "insert into `".$this->logTableName($record->_table->tablename)."` 
                        (`".implode('`,`', $fieldnames)."`, `history__language`,`history__comments`,`history__user`,`history__state`,`history__modified`) 
                        select *, '".addslashes($lang)."','".addslashes($comments)."','".addslashes($user)."','".addslashes($state)."', NOW() 
                        from (".$sql.") as t";
                
                $res = mysql_query($insertsql, $app->db());
                if ( !$res ){
                        $this->updateHistoryTable($record->_table->tablename);
                        $res = mysql_query($insertsql, $app->db());
                }
                if ( !$res ){
                        echo $insertsql;
                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                }
                
                // Now for the individual fields
                $hid = mysql_insert_id($app->db());
                foreach ($fieldnames as $fieldname){
                        $this->logField($record, $fieldname, $hid);
                }
                
                return $hid;
                
        
        }
        
        function logField(&$record, $fieldname, $history_id){
                $field =& $record->_table->getField($fieldname);
                $s = DIRECTORY_SEPARATOR;
                switch(strtolower($field['Type'])){
                        case 'container':
                                $savepath = $field['savepath'];
                                if ( $savepath{strlen($savepath)-1} != $s ) $savepath.=$s;
                                if ( !$record->val($fieldname) ) break; // there is no file currently stored in this field.
                                if ( !is_readable($savepath.$record->val($fieldname)) ) break; // the file does not exist
                                if ( !file_exists($savepath) || !is_dir($savepath) )
                                        trigger_error(
                                                df_translate(
                                                        'scripts.Dataface.HistoryTool.logField.ERROR_CONTAINER_FIELD_SAVEPATH_MISSING',
                                                        "Field {$fieldname} is a Container field but its corresponding savepath {$savepath} does not exist.  Please create the directory {$savepath} and ensure that it is writable by the web server",
                                                        array('fieldname'=>$fieldname,'savepath'=>$savepath)
                                                        ), E_USER_ERROR);
                                $histpath = $savepath.'.dataface_history'.$s;
                                if ( !file_exists($histpath) ){
                                        $res = mkdir($histpath, 0777);
                                        if ( !$res ) trigger_error(
                                                df_translate(
                                                        'scripts.Dataface.HistoryTool.logField.ERROR_FAILED_TO_MAKE_HISTORY_FOLDER',
                                                        "Failed to make history folder {$histpath} to store the history for container field {$fieldname} in table {$record->_table->tablename}.  It could be a permissions problem.  Please ensure that the {$savepath} directory is writable by the web server.",
                                                        array('histpath'=>$histpath,'fieldname'=>$fieldname,'tablename'=>$record->_table->tablename,'savepath'=>$savepath)
                                                        ), E_USER_ERROR);
                                        
                                }
                                if ( !is_dir($histpath) ){
                                        trigger_error(
                                                df_translate(
                                                        'scripts.Dataface.HistoryTool.logField.ERROR_NOT_A_DIRECTORY',
                                                        "The history path for the field {$fieldname} in table {$record->_table->tablename} is not a directory.  Perhaps a file has been uploaded with the reserved name '.history'.  Please delete this file to allow Dataface's history feature to work properly.",
                                                        array('fieldname'=>$fieldname, 'tablename'=>$record->_table->tablename)
                                                        ), E_USER_ERROR);
                                }
                                if ( !is_writable($histpath) ){
                                        trigger_error("The history folder for field {$fieldname} of table {$record->_table->tablename} is not writable by the web server.  Please make it writable by the web server for Dataface's history feature to work properly.", E_USER_ERROR);
                                }
                                

                                $destpath = $histpath.$history_id;
                                if ( file_exists($destpath) ) { return;}        // the file already exists... just skip it.

                                $srcpath = $savepath.$record->val($fieldname);
                                $res = copy($srcpath,$destpath);

                                break;
                                
                                
                                
                }
        }
        
        
        function logTableName($tablename){
                return $tablename.'__history';
        }
        
        function updateHistoryTable($tablename){
                $app =& Dataface_Application::getInstance();
                $name = $this->logTableName($tablename);
                
                //first check to see if the table exists
                if ( mysql_num_rows(mysql_query("show tables like '".$name."'", $app->db())) == 0 ){
                        $this->createHistoryTable($tablename);
                }
                
                $res = mysql_query("show columns from `".$this->logTableName($tablename)."`", $app->db());
                if ( !$res ) trigger_error(mysql_error($app->db()), E_USER_ERROR);
                $history_fields = array();
                while ( $row = mysql_fetch_assoc($res) ){
                        $history_fields[$row['Field']] = $row;
                }
                @mysql_free_result($res);
                
                $table =& Dataface_Table::loadTable($tablename);
                $fieldnames = array_keys($table->fields());
                
                foreach ($fieldnames as $fieldname){
                        if ( !isset($history_fields[$fieldname]) ){
                                $field =& $table->getField($fieldname);
                                $type = (( strcasecmp($field['Type'],'container') === 0 ) ? 'varchar(64)' : $field['Type'] );
                                $sql = "alter table `".$name."` add column `".$fieldname."` {$type} DEFAULT NULL";
                                $res = mysql_query($sql, $app->db());
                                if ( !$res ){
                                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                                }
                                unset($field);
                        }
                }
                
                $meta_fields = $this->meta_fields;
                        
                foreach ( array_keys($meta_fields) as $fieldname){
                        if ( !isset($history_fields[$fieldname]) ){
                                $sql = "alter table `".$name."` add column `".$fieldname."` ".$history_fields[$fieldname]['Type'].' '.@$history_fields[$fieldname]['Extra'];
                                $res = mysql_query($sql, $app->db());
                                if ( !$res ){
                                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                                }
                                
                        }
                }
                
        }
        
        
        function createHistoryTable($tablename){
                $app =& Dataface_Application::getInstance();
                $sql = "create table `".$this->logTableName($tablename)."` (
                        `history__id` int(11) auto_increment NOT NULL,
                        `history__language` varchar(2) DEFAULT NULL,
                        `history__comments` text default null,
                        `history__user` varchar(32) default null,
                        `history__state` int(5) default 0,
                        `history__modified` datetime,";
                
                $table =& Dataface_Table::loadTable($tablename);
                $res = df_q("SHOW TABLE STATUS LIKE '".addslashes($tablename)."'");
                $status = mysql_fetch_assoc($res);
                $charset = substr($status['Collation'],0, strpos($status['Collation'],'_'));
                $collation = $status['Collation'];
                $fieldnames = array_keys($table->fields());
                $fielddefs = array();
                foreach ( $fieldnames as $fieldname){
                        $field =& $table->getField($fieldname);
                        $type = (( strcasecmp($field['Type'],'container') === 0 ) ? 'varchar(64)' : $field['Type'] );
                        $fielddefs[] = "`".$fieldname."` ".$type;
                        unset($field);
                }
                
                $sql .= implode(",\n",$fielddefs);
                $sql .= ",
                        PRIMARY KEY (`history__id`),
                        KEY prikeys using hash (`".implode('`,`', array_keys($table->keys()))."`),
                        KEY datekeys using btree (`history__modified`)) ".(@$status['Engine'] ? "ENGINE=".$status['Engine']:'')." ".($charset ? "DEFAULT CHARSET=".$charset.($collation ? " COLLATE $collation":''):'');
                
                $res = mysql_query($sql, $app->db());
                if ( !$res ){
                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                }
        }
        
        
        function getDiffs($tablename, $id1, $id2=null, $fieldname=null ){
                import('Text/Diff.php');
                import('Text/Diff/Renderer/inline.php');
                $htablename = $tablename.'__history';
                if ( !Dataface_Table::tableExists($htablename) )
                        return PEAR::raiseError(
                                df_translate('scripts.Dataface.HistoryTool.getDiffs.ERROR_HISTORY_TABLE_DOES_NOT_EXIST',
                                "History table for '{$tablename}' does not exist, so we cannot obtain changes for records of that table.",
                                array('tablename'=>$tablename)
                                ), DATAFACE_E_ERROR);
                
                $rec1 = df_get_record($htablename, array('history__id'=>$id1));
                
                if ( !isset($id2) ){
                        // The 2nd id wasn't provided so we assume we want to know the diffs 
                        // against the current state of the record.
                        $table =& Dataface_Table::loadTable($tablename);
                        $query = $rec1->strvals(array_keys($table->keys()));
                        $io = new Dataface_IO($tablename);
                        $io->lang = $rec1->val('history__language');
                        $rec2 = new Dataface_Record($tablename, array());
                        $io->read($query, $rec2);
                } else {
                        $rec2 = df_get_record($htablename, array('history__id'=>$id2));
                }
                
                $vals1 = $rec1->strvals();
                $vals2 = $rec2->strvals();
                
                $vals_diff = array();
                $renderer = new Text_Diff_Renderer_inline();
                foreach ($vals2 as $key=>$val ){
                        $diff = new Text_Diff(explode("\n", @$vals1[$key]), explode("\n", $val));
                        
                        $vals_diff[$key] = $renderer->render($diff);
                }
                
                $diff_rec = new Dataface_Record($htablename, $vals_diff);
                if ( isset($fieldname) ) return $diff_rec->val($fieldname);
                return $diff_rec;
                
                
        }
        
        
        function getDiffsByDate(&$record, $date1, $date2=null, $lang=null, $fieldname=null){
                if ( !isset($date2) ) $date2 = date('Y-m-d H:i:s');
                $time1 = strtotime($date1);
                $time2 = strtotime($date2);
                if ( $time1 > $time2 ){
                        $temp = $date2;
                        $date2 = $date1;
                        $date1 = $temp;
                }
                $app =& Dataface_Application::getInstance();
                if ( !isset($lang) )  $lang = $app->_conf['lang'];
                $htablename = $record->_table->tablename.'__history';
                if ( !Dataface_Table::tableExists($htablename) ) 
                        return PEAR::raiseError(
                                df_translate('scripts.Dataface.HistoryTool.getDiffs.ERROR_HISTORY_TABLE_DOES_NOT_EXIST',
                                "History table for '{$tablename}' does not exist, so we cannot obtain changes for records of that table.",
                                array('tablename'=>$tablename)
                                ), DATAFACE_E_ERROR);
                $clauses = array();
                $keyvals = $record->strvals(array_keys($record->_table->keys()));
                foreach ($keyvals as $key=>$val){
                        $clauses[] = "`{$key}`='".addslashes($val)."'";
                }
                $clauses[] = "`history__language`='".addslashes($lang)."'";
                
                $sql = "select `history__id` from `{$htablename}` where ".implode(' and ',$clauses);
                $sql1 = $sql . " and `history__modified` <= '".addslashes($date1)."' order by `history__modified` desc limit 1";
                $sql2 = $sql . " and `history__modified` <= '".addslashes($date2)."' order by `history__modified` desc limit 1";
                
                $res2 = mysql_query($sql2, $app->db());
                if ( !$res2 ){
                        //echo $sql2;
                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                }
                if ( mysql_num_rows($res2) == 0 ){
                        if (isset($fieldname) ) return '';
                        else return new Dataface_Record($htablename, array());
                } 
                list($id2) = mysql_fetch_row($res2);
                @mysql_free_result($res2);
                
                $res1 = mysql_query($sql1, $app->db());
                if ( !$res1 ){
                        //echo $sql1;
                        trigger_error(mysql_error($app->db()), E_USER_ERROR);
                }
                if ( mysql_num_rows($res1) == 0 ){
                        $rec = df_get_record($htablename, array('history__id'=>$id2));
                        if ( !isset($rec) ) 
                                trigger_error(
                                        df_translate(
                                                'scripts.Dataface.HistoryTool.getDiffsByDate.ERROR_FAILED_TO_LOAD_HISTORY_RECORD',
                                                "Failed to load history record with id {$id2}",
                                                array('id'=>$id2)
                                                ), DATAFACE_E_ERROR);
                        if ( isset($fieldname) ) return $rec->val($fieldname);
                        return $rec;
                }
                list($id1) = mysql_fetch_row($res1);
                @mysql_free_result($res1);
                $out = $this->getDiffs($record->_table->tablename, $id1, $id2, $fieldname);
                return $out;
                
        }
        
        
        function restore(&$record, $id, $fieldname=null, $secure=false){
                $app =& Dataface_Application::getInstance();
                if ( isset($fieldname) ) $fieldnames = array($fieldname);
                else $fieldnames = array_keys($record->_table->fields());
                if ( $secure ){
                        $tmp = array();
                        foreach ($fieldnames as $k=>$f){
                                $fld = $record->table()->getField($f);
                                if ( @$fld['encryption'] ) continue;
                                if ( $record->checkPermission('edit', array('field'=>$f)) ){
                                        $tmp[] = $f;
                                }
                        }
                        $fieldnames = $tmp;
                }
                $htablename = $record->_table->tablename.'__history';
                $res = mysql_query("select `".implode('`,`', $fieldnames)."`,`history__language` from `{$htablename}` where `history__id`='".addslashes($id)."'", $app->db());
                if ( !$res ) trigger_error(mysql_error($app->db()), E_USER_ERROR);
                if ( mysql_num_rows($res) == 0 ) 
                        return PEAR::raiseError(
                                df_translate(
                                        'scripts.Dataface.HistoryTool.restore.ERROR_NO_SUCH_RECORD',
                                        "Could not restore record with id {$id} in table {$htablename} because no such record exists.  Perhaps the history was cleaned out.",
                                        array('id'=>$id, 'tablename'=>$htablename)
                                        ), DATAFACE_E_ERROR);
                $vals = mysql_fetch_assoc($res);
                @mysql_free_result($res);
                $old_record = new Dataface_Record($record->_table->tablename, $record->getValues());
                $lang = $vals['history__language'];
                unset($vals['history__language']);
                if ( isset($fieldname) ){
                        $record->setValue($fieldname, $vals[$fieldname]);
                } else {
                        $record->setValues($vals);
                }
                $record->save($lang, $secure);
                foreach ($fieldnames as $fld){
                        $this->restoreField($record,$old_record, $id, $fld);
                }
                return true;
                
        }
        
        function restoreField(&$record, &$old_record, $id, $fieldname){
                $app =& Dataface_Application::getInstance();
                $htablename = $record->_table->tablename.'__history';
                $field =& $record->_table->getField($fieldname);
                switch (strtolower($field['Type'])){
                        case 'container': 
                                $savepath = $field['savepath'];
                                if ( $savepath{strlen($savepath)-1} != '/' ) $savepath .= '/';
                                
                                if ( $old_record->val($fieldname) ){
                                        // we need to delete the existing file
                                        $filepath = $savepath.basename($old_record->val($fieldname));
                                        if ( file_exists($filepath) ) unlink($filepath);
                                }
                                
                                $hsavepath = $savepath.'.dataface_history/'.$id;
                                if ( !file_exists($hsavepath) || !is_readable($hsavepath) ) return false;
                                $filename = basename($record->val($fieldname));
                                $filepath = $savepath.'/'.$filename;
                                while ( file_exists($filepath) ){
                                        $filepath = $savepath.'/'.strval(rand(0,10000)).'_'.$filename;
                                }
                                return copy($hsavepath, $filepath);
                                
                }
                
        }
        
        function restoreToDate(&$record, $date, $lang=null, $fieldname=null){
                $app =& Dataface_Application::getInstance();
                $id = $this->getPreviousVersion($record, $date, $lang, $fieldname, true);
                return $this->restore($record, $id, $fieldname);
                /*
                $sql = "select * from `{$record->_table->_tablename}__history}` where `history__id` = '{$id}' limit 1";
                
                $res = mysql_query($sql, $app->db());
                if ( !$res ) trigger_error(mysql_error($app->db()), E_USER_ERROR);
                if ( mysql_num_rows($res) == 0 ){
                        return PEAR::raiseError("Attempt to restore record \"{$record->getTitle()}\" to nonexistent history record with id '{$id}'", DATAFACE_E_ERROR);
                }
                $row = mysql_fetch_assoc($res);
                @mysql_free_result($res);
                $old_record = new Dataface_Record($record->_table->tablename, $record->getValues());
                $record->setValues($row);
                $res = $record->save($lang);
                foreach ($fieldnames as $fld){
                        $this->restoreField($record, $old_record, $id, $fld);
                }
                
                return $res;
                */
                
        
        }
        
        function getPreviousVersion(&$record, $date, $lang=null, $fieldname=null, $idonly=false){
                $app =& Dataface_Application::getInstance();
                if ( !isset($lang) )  $lang = $app->_conf['lang'];
                $htablename = $record->_table->tablename.'__history';
                if ( !Dataface_Table::tableExists($htablename) ) 
                        return PEAR::raiseError(
                                df_translate(
                                        'scripts.Dataface.HistoryTool.getDiffs.ERROR_HISTORY_TABLE_DOES_NOT_EXIST',
                                        "History table for '{$record->_table->tablename}' does not exist, so we cannot obtain changes for records of that table.",
                                        array('tablename'=>$record->_table->tablename)
                                        ), DATAFACE_E_ERROR);
                $clauses = array();
                $keyvals = $record->strvals(array_keys($record->_table->keys()));
                foreach ($keyvals as $key=>$val){
                        $clauses[] = "`{$key}`='".addslashes($val)."'";
                }
                $clauses[] = "`history__language`='".addslashes($lang)."'";
                
                $sql = "select `history__id` from `{$htablename}` where ".implode(' and ',$clauses)."
                                and `history__modified` <= '".addslashes($date)."' order by `history__modified` desc limit 1";
                
                $res = mysql_query($sql, $app->db());
                if ( !$res ) trigger_error(mysql_error($app->db()), E_USER_ERROR);
                if ( mysql_num_rows($res) == 0 ){
                        return null;
                } 
                list($id) = mysql_fetch_row($res);
                @mysql_free_result($res);
                if ( $idonly ) return $id;
                $out = $this->getRecordById($record->_table->tablename, $id);
                
                if ( isset($fieldname) ) return $out->val($fieldname);
                return $out;
                
                
        
        }
        
        function getRecordById($tablename, $id){
                $htablename = $tablename.'__history';
                if ( !Dataface_Table::tableExists($htablename) ) 
                        return PEAR::raiseError(
                                df_translate(
                                        'scripts.Dataface.HistoryTool.getDiffs.ERROR_HISTORY_TABLE_DOES_NOT_EXIST',
                                        "History table for '{$tablename}' does not exist, so we cannot obtain changes for records of that table.",
                                        array('tablename'=>$tablename)
                                        ), DATAFACE_E_ERROR);
                
                $rec = df_get_record($htablename, array('history__id'=>$id));
                return $rec;
        }
        
        
        function getHistoryLog(&$record, $lang=null, $limit=100){
                $app =& Dataface_Application::getInstance();
                $history_tablename = $record->_table->tablename.'__history';
                if ( !Dataface_Table::tableExists($history_tablename) ) return array();
                $keys = $record->strvals(array_keys($record->_table->keys()));
                $clauses = array();
                foreach ( $keys as $key=>$val){
                        $clauses[] = "`{$key}`='".addslashes($val)."'";
                }
                if ( isset($lang) ) $clauses[] = "`history__language`  = '".addslashes($lang)."'";
                $where = implode(' and ', $clauses);
                if ( isset($limit) ) $limit = "LIMIT $limit";
                else $limit = '';
                
                $sql = "select `".implode('`,`', array_keys($this->meta_fields))."` from `{$history_tablename}` where {$where} order by `history__modified` desc {$limit}";
                //echo $sql;
                $res = mysql_query($sql, $app->db());
                if ( !$res ) trigger_error(mysql_error($app->db()), E_USER_ERROR);
                $out = array();
                while ( $row = mysql_fetch_assoc($res) ) $out[] = $row;
                @mysql_free_result($res);
                return $out;
                
                
                
                
        }
        
        
        function findMatchingSnapshots($record, $query, $idsOnly=true){
                $app =& Dataface_Application::getInstance();
                $htablename = $record->_table->tablename.'__history';
                if ( !Dataface_Table::tableExists($htablename) ) return array();
                $keys = $record->strvals(array_keys($record->_table->keys()));
                foreach ($keys as $key=>$val){
                        $query[$key] = '='.$val;
                }
                if ( $idsOnly ){
                        $qbuilder = new Dataface_QueryBuilder($htablename, $query);
                        $sql = $qbuilder->select(array('history__id'), $query);
                        $res = mysql_query($sql, df_db());
                        $ids = array();
                        while ( $row = mysql_fetch_row($res) ) $ids[] = $row[0];
                        @mysql_free_result($res);
                        return $ids;
                } else {
                        return df_get_records_array($htablename, $query);
                }
                
        }
        
        
        
        

}