tagger.php

Go to the documentation of this file.

<?php
/*
 * Xataface Tagger Module v 0.1
 * Copyright (C) 2011  Steve Hannah <steve@weblite.ca>
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA  02110-1301, USA.
 *
 */
class modules_tagger {

        private $baseURL = null;
        
        
        function __construct(){
                $app = Dataface_Application::getInstance();
                
                // Register the beforeSave event handler to be called before any records
                // in the system are saved.
                $app->registerEventListener('beforeSave', array($this, 'beforeSave'));
                
                // Register the afterSave event handler to be called after any records
                // are saved.
                $app->registerEventListener('afterSave', array($this, 'afterSave'));
                
                // Register the initTransientField event handler which is called 
                // when transient field data is loaded for the first time.
                $app->registerEventListener('initTransientField', array($this, 'initField'));
                
                // Now work on our dependencies
                $mt = Dataface_ModuleTool::getInstance();
                
                // We require the XataJax module
                // The XataJax module activates and embeds the Javascript and CSS tools
                $mt->loadModule('modules_XataJax', 'modules/XataJax/XataJax.php');
                
                
                // Register the tagger widget with the form tool so that it responds
                // to widget:type=tagger
                import('Dataface/FormTool.php');
                $ft = Dataface_FormTool::getInstance();
                $ft->registerWidgetHandler('tagger', dirname(__FILE__).'/widget.php', 'Dataface_FormTool_tagger');
                
                
        }
        
        
        public function getBaseURL(){
                if ( !isset($this->baseURL) ){
                        $this->baseURL = Dataface_ModuleTool::getInstance()->getModuleURL(__FILE__);
                }
                return $this->baseURL;
        }
        
        


        
        function getLabelColumn($field){
                $labelCol = null;
                if (  @$field['tagger_label']  ){
                        $labelCol = $field['tagger_label'];
                } else {
                        $relationship = @$field['relationship'];
                        if ( !$relationship ){
                                throw new Exception("Label column could not be found for field $field[name] because no relationship was specified.");
                                
                        }
                        $table = Dataface_Table::loadTable($field['tablename']);
                        if ( PEAR::isError($table) ){
                                throw new Exception($table->getMessage());
                        }
                        $relObj = $table->getRelationship($relationship);
                        
                        if ( PEAR::isError($relObj) ){
                                throw new Exception($relObj->getMessage());
                        }
                        $domainTable = Dataface_Table::loadTable($relObj->getDomainTable());
                        if ( PEAR::isError($domainTable) ){
                                throw new Exception($domainTable->getMessage());
                        }
                        $labelCol = $domainTable->guessField(
                                array('varchar'=>10, 'char'=>8, 'enum'=>3, 'text'=>1),
                                array('/name|title|value/'=>10, '/nom/'=>2)
                        );
                        
                }
                
                if ( !$labelCol ){
                        throw new Exception("No label column could be found for the field ".$tfield['name'].".  Please specify a tagger_label directive.");
                        
                }
                return $labelCol;
        }
        
        
        function initField($event){
                
                //print_r($event->field);exit;
                
                if ( $event->field['widget']['type'] == 'tagger' ){
                        //die('here');
                        $relationship = @$event->field['relationship'];
                        if ( !$relationship ){
                                $event->out = null;
                                return;
                        }
                        $rrecs = $event->record->getRelatedRecordObjects($relationship, 'all');
                        $out = array();
                        try {
                                $labelCol = $this->getLabelColumn($event->field);
                                foreach ($rrecs as $rrec){
                                        $drec = $rrec->toRecord();
                                        $out[] = 'xfid://'.$drec->getId().' '.$drec->strval($labelCol);
                                        
                                        unset($drec);
                                }
                                $event->out = implode("\n", $out);
                                return;
                        } catch ( Exception $ex){
                                error_log($ex->getMessage());
                                $event->out = null;
                                return;
                        }
                        
                } 
        }

        function beforeSave($params){
                $record = $params[0];
                if ( $record ){
                        
                        foreach ($record->_table->fields(false, true, true) as $fld){
                        
                                // Go through all fields in the table to see if any of them
                                // are tagger widgets.... we collect them all and record
                                if ( @$fld['relationship'] and @$fld['widget']['type'] == 'tagger' and $record->valueChanged($fld['name']) ){
                                        // Only mark the field for handling if the widget:type=tagger
                                        // and a relationship is specified and the value has changed.
                                        if ( !@$record->pouch['tagger__fields'] ){
                                                $record->pouch['tagger__fields'] = array();
                                        }
                                        
                                        // We store the fields in the record pouch so that we can access them'
                                        // in the afterSave handler
                                        $record->pouch['tagger__fields'][] = $fld['name'];
                                }
                        }
                }
        }
        
        
        function afterSave($params){
                $record = $params[0];
                $io = $params[1];
                
                // The tagger__fields array was populated in the beforeSave handler
                // with the fields that have changed - and use the tagger widget.
                if ( @$record->pouch['tagger__fields'] ){
                        foreach ($record->pouch['tagger__fields'] as $f){
                                $tfield =& $record->_table->getField($f);
                                
                                $val = $record->val($f);
                                
                                $relationship = $record->_table->getRelationship($tfield['relationship']);
                                $domainTable = Dataface_Table::loadTable($relationship->getDomainTable());
                                if ( PEAR::isError($domainTable) ){
                                        return $domainTable;
                                }
                                
                                $tval = explode("\n", $val);
                                
                                
                                
                                // Load existing records in the relationship
                                $texisting =& $record->getRelatedRecordObjects($tfield['relationship'], 'all');
                                if ( !is_array($texisting) or PEAR::isError($texisting) ){
                                        error_log('Failed to get related records for record '.$record->getId().' in its relationship '.$tfield['relationship']);
                                        unset($tval);
                                        unset($orderCol);
                                        unset($tval_new);
                                        unset($torder);
                                        unset($trelationship);
                                        unset($tval_existing);
                                        unset($relationship);
                                        unset($domainTable);
                                        continue;
                                }
                                //$texistingIds = array();
                                $texistingLabels = array();
                                $labelMap = array();
                                $labelCol = $this->getLabelColumn($tfield);
                                
                                if ( !$labelCol ){
                                        throw new Exception("No label column could be found for the field ".$tfield['name'].".  Please specify a tagger_label directive.");
                                        
                                }
                                
                                
                                foreach ($texisting as $terec){
                                        $drec = $terec->toRecord();
                                        $texistingLabels[$drec->getId()] = trim($terec->val($labelCol));
                                        $labelMap[$drec->getId()] = $terec;
                                        unset($drec);
                                        
                                }
                                
                                $del = $record->_table->getDelegate();
                                $addMethod = $f.'__addTag';
                                
                                
                                
                                // Load currently checked records
                                
                                // Now we have existing ids in $texistingIds
                                // and checked ids in $tcheckedIds
                                
                                // See which records we need to have removed
                                $texistingLabels = array_map('trim', $texistingLabels);
                                $tval = array_map('trim', $tval);
                                $temp = array();
                                foreach ($tval as $k=>$v){
                                        if ( preg_match('/^xfid:\/\/([^ ]+) (.*)$/', $v, $matches) ){
                                                $temp[$matches[1]] = $matches[2];
                                        } else {
                                                
                                                $drec = df_get_record($domainTable->tablename, array($labelCol=>'='.$v));
                                                if ( !$drec ){
                                                        // the record isn't created yet.. so let's create it
                                                        if ( isset($del) and method_exists($del, $addMethod) ){
                                                                $drec = $del->$addMethod($record, $tid);
                                                        } else {
                                                                $drec = new Dataface_Record($domainTable->tablename, array());
                                                                $drec->setValue($labelCol, $v);
                                                        }
                                                        if ( !$record->checkPermission('add new related record', array(
                                                                'relationship' => $tfield['relationship']
                                                        ))){
                                                                $res = PEAR::raiseError("Failed to add tag '$val' because you don't have permission to add new related records to this relationship.");
                                                                
                                                        } else {
                                                                $res = $drec->save();
                                                        }
                                                        
                                                        if ( PEAR::isError($res) ){
                                                                return PEAR::raiseError('Failed save tags for field "'.$tfield['widget']['label'].'" because the tag "'.$v.'" could not be saved.  The error while trying to save the tag was: '.$res->getMessage(), DATAFACE_E_NOTICE);
                                                                
                                                        }
                                                }
                                                $temp[$drec->getId()] = $v;
                                                
                                                unset($drec);
                                        }
                                }
                                $tval = $temp;
                                
                                
                                $existingIds = array_keys($texistingLabels);
                                $newIds = array_keys($tval);
                                
                                $tremoves = array_diff($existingIds, $newIds);
                                $tadds = array_diff($newIds, $existingIds);
                                
                                //$tremoves = array(); //array_diff($texistingLabels, $tval);
                                //$tadds = array();     //array_diff($tval, $texistingLabels);
                                
                                
                                
                                foreach ($tremoves as $tid){
                                        $trec = $labelMap[$tid];
                                        $res = $io->removeRelatedRecord($trec, false, $secure);
                                        if ( PEAR::isError($res) ) return $res;
                                        unset($trec);
                                }
                                
                                
                                foreach ($tadds as $tid){
                                        $drec = df_get_record_by_id($tid);
                                        if ( !$drec ){
                                                
                                                return PEAR::raiseError('Failed to add tag '.$tid.' because it could not be found.');
                                                
                                        }
                                
                                        //$trecvals = $checkedId2ValsMap[$tid];
                                        $trec = new Dataface_RelatedRecord($record, $tfield['relationship'], $drec->vals());
                                        
                                        $res = $io->addExistingRelatedRecord($trec, $secure);
                                        if ( PEAR::isError($res) ) return $res;
                                        unset($drec, $trec);
                                }
                                
                                unset($tadds);
                                unset($tremoves);
                                unset($tcheckedIds, $tcheckedId2ValsMap);
                                unset($tcheckedRecords);
                                unset($tchecked);
                                unset($texistingIds);
                                unset($texisting);
                                        
                        }
                        
                        unset($record->pouch['tagger__fields']);
                }
        }
        
        private function formRequiresTagger(&$form){
                
                if ( @$form['elements'] and is_array($form['elements']) ){
                        foreach ($form['elements'] as $e ){
                                if ( @$e['field']['widget']['type'] == 'tagger' ){
                                        return true;
                                }
                        }
                }
                
                if ( @$form['sections'] and is_array($form['sections']) ){
                        foreach ($form['sections'] as $s ){
                                if ( $s['elements'] and is_array($s['elements']) ){
                                        foreach ($s['elements'] as $e ){
                                                if ( @$e['field']['widget']['type'] == 'tagger' ){
                                                        return true;
                                                }
                                        }
                                }
                        }
                }
                
                return false;
                
        }
        
        function block__after_form_open_tag($params=array()){
        
                $form = $params['form'];
                if ( !$this->formRequiresTagger($form) ){
                        return null;
                }
                
                $jt = Dataface_JavascriptTool::getInstance();
                $jt->addPath(dirname(__FILE__).'/js', $this->getBaseURL().'/js');
                
                $ct = Dataface_CSSTool::getInstance();
                $ct->addPath(dirname(__FILE__).'/css', $this->getBaseURL().'/css');
                
                // Add our javascript
                $jt->import('xataface/widgets/tagger.js');
                
        }
        
        function getTagCloudFields($fields){
                $out = array();
                foreach ($fields as $k=>$f){
                        if ( @$f['tag_cloud'] ){
                                $out[$k] =& $f;
                        }
                        unset($f);
                }
                return $out;
        }
        
        
        function drawTransientTagCloud($field){
                $table = Dataface_Table::loadTable($field['tablename']);
                $relationship = $table->getRelationship($field['relationship']);
                try {
                        $labelCol = $this->getLabelColumn($field);
                } catch (Exception $ex){
                        return;
                }
                
                $sql = $relationship->getSQL();
                
                $frompos = strpos(strtolower($sql), ' from ');
                //echo "Frompos $frompos";
                $select = 'select count(*) as num, `'.$labelCol.'`';
                $newsql = $select.' '.substr($sql, $frompos);
                $newsql = preg_replace('/`([^`]+)` ?= ?\'\$[^\']+\'/', '`$1` is not null', $newsql);
                $newsql .= ' group by `'.$labelCol.'` limit 50';
                //echo $newsql;
                $res = mysql_query($newsql, df_db());
                if ( !$res ) throw new Exception(mysql_error(df_db()));
                $jt = Dataface_JavascriptTool::getInstance();
                $jt->addPath(dirname(__FILE__).'/js', $this->getBaseURL().'/js');
                
                $ct = Dataface_CSSTool::getInstance();
                $ct->addPath(dirname(__FILE__).'/css', $this->getBaseURL().'/css');
                
                // Add our javascript
                $jt->import('tagcloud.js');
                
                echo '<div class="xf-tagcloud">';
                echo '<h2>'.htmlspecialchars($field['widget']['label']).'</h2>';
                echo '<ul>';
                while ($row = mysql_fetch_row($res) ){
                        $link = df_absolute_url(DATAFACE_SITE_HREF.'?-action=list&-table='.$field['tablename'].'&'
                                .urlencode($field['relationship'].'/'.$labelCol).'='.urlencode('='.$row[1]));
                        
                
                        echo '<li data-xf-frequency="'.$row[0].'"><a href="'.htmlspecialchars($link).'">'.htmlspecialchars($row[1]).'</a></li>';
                }
                echo '</ul>
                
                </div>';
                
                //echo '['.$sql.']';
        
        }
        
        function drawScalarTagCloud($field){}
        
        
        function drawTagCloud($field){
                if ( @$field['transient'] and @$field['relationship'] ){
                        $this->drawTransientTagCloud($field);
                } else if (!@$field['transient'] ){
                        $this->drawScalarTagCloud($field);
                }
                
        }
        
        function block__after_left_column(){
                
                $app = Dataface_Application::getInstance();
                $query = $app->getQuery();
                $table = Dataface_Table::loadTable($query['-table']);
                $fields = $this->getTagCloudFields($table->fields(false,true,true));
                
                
                foreach ($fields as $k=>$v){
                        $this->drawTagCloud($v);
                }
                
        }
}