classes/XfHtmlReportBuilder.class.php

Go to the documentation of this file.

<?php
/*
 * Xataface HTML Reports Module
 * 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.
 *
 */
require_once dirname(__FILE__).DIRECTORY_SEPARATOR.'simple_html_dom.php';

class XfHtmlReportBuilder {
        
        const COMPILE_ERROR = 501;
        public static $SUMMARY_FUNCTIONS = array('sum','min','max','count');
        
        private $templateContent = null;
        private $records = null;
        private $output = '';
        
        private $context = null;
        
        protected $strict = false;
        
        
        public static function getFields($el){
                $out = array();
                if ( preg_match_all('/\{\$([^\}]+)\}/', $el->outertext, $matches, PREG_SET_ORDER) ){
                        foreach ($matches as $match){
                                $out[] = trim($match[1]);
                        }
                }
                $out = array_unique($out);
                return $out;
        }
        
        public static function getSummaryFields($el){
                $out = array();
                if ( preg_match_all('/\{@([a-zA-Z]+\([^\}]+\))\}/', $el->outertext, $matches, PREG_SET_ORDER) ){
                        foreach ($matches as $match){
                                $out[] = trim($match[1]);
                        }
                }
                $out = array_unique($out);
                return $out;
        
        }
        
        
        public static function printGroupData(&$groupData, $groupFields, $summaryFields, $groupHeaders, $groupFooters, $template, $asTable){
                $header = $groupHeaders[$groupData['level']];
                $footer = $groupFooters[$groupData['level']];
                $gfields = $groupFields[$groupData['level']];
                $sfields = $summaryFields[$groupData['level']];
                if ( !@$groupData['summaryRecord'] ){
                        throw new Exception("No summary record provided.", 2000);
                }
                $headerText = '';
                if ( $header ){
                        $headerText = self::fillReportSingle($groupData['summaryRecord'], $header->innertext);
                }
                $bodyText = '';
                if ( isset($groupData['sections']) ){
                        foreach ($groupData['sections'] as $key=>$section){
                                $bodyText .= self::printGroupData($groupData['sections'][$key], $groupFields, $summaryFields, $groupHeaders, $groupFooters, $template, $asTable);
                                
                        }
                } else if ( isset($groupData['records']) ){
                        $bodyText = self::fillReportMultiple($groupData['records'], $template, false /* no headers */, $asTable);
                }
                $footerText = '';
                if ( $footer ){
                        $footerText = self::fillReportSingle($groupData['summaryRecord'], $footer->innertext);
                }
                return $headerText.$bodyText.$footerText;
        }
        
        public static function getGroupKey(Dataface_Record $record, $fields){
                $out = array();
                foreach ($fields as $f){
                        $out[] = urlencode($f).'='.urlencode($record->val($f));
                }
                return implode('&', $out);
        }
        
        
        public static function fillReportTable($records, $template, $headersAndFooters=true){

                return self::fillReportMultiple($records, $template, $headersAndFooters, true);
        }
        
        
        public static function fillReportMultiple($records, $template, $headersAndFooters=true, $asTable=false){
                if ( !is_array($records) ){
                        throw new Exception("Records must be an array.", 2000);
                }
                if ( is_string($template) ){
                        $el = str_get_html($template);
                } else {
                        $el = $template;
                }
                $groupFields = array();
                $summaryFields = array();
                
                $sectionHeaderEls = $el->find('div.xf-htmlreports-section-header');
                $sectionFooterEls = $el->find('div.xf-htmlreports-section-footer');
                $numLevels = max(count($sectionHeaderEls), count($sectionFooterEls));

                if ( $numLevels > 0 ){
                        if ( !$headersAndFooters ){
                                // Caller doesn't want headers and footers.  We clear them out
                                // then process the remainder of the template.
                                foreach ($sectionHeaderEls as $myel){
                                        $myel->outertext = '';
                                }
                                foreach ($sectionFooterEls as $myel){
                                        $myel->outertext = '';
                                }
                                return self::fillReportMultiple($records, $el->outertext, false, $asTable);
                        }
                        $groupFooters = array();
                        $groupHeaders = array();
                        
                        
                        for ($i=0; $i<$numLevels; $i++){
                                $groupFields[$i] =  $summaryFields[$i] = array();
                                $groupHeaders[$i] = $groupFooters[$i] = null;
                        }
                        
                        for ($i=0; $i<$numLevels; $i++){
                        
                                $j = $numLevels-$i-1;
                                
                                if ( isset($sectionHeaderEls[$i]) ){
                                        $groupFields[$i] = array_merge($groupFields[$i], self::getFields($sectionHeaderEls[$i]));
                                        $summaryFields[$i] = array_merge($summaryFields[$i], self::getSummaryFields($sectionHeaderEls[$i]));
                                        $groupHeaders[$i] = $sectionHeaderEls[$i];
                                } 
                                
                                
                                if ( isset($sectionFooterEls[$j]) ){
                                        $groupFields[$i] = array_merge($groupFields[$j], self::getFields($sectionFooterEls[$j]));
                                        $summaryFields[$i] = array_merge($summaryFields[$j], self::getSummaryFields($sectionFooterEls[$j]));
                                        $groupFooters[$i] = $sectionFooterEls[$j];
                                }
                                
                        }
                        
                        for ( $i=0; $i<$numLevels; $i++){
                                $groupFields[$i] = array_unique($groupFields[$i]);
                                $summaryFields[$i] = array_unique($summaryFields[$i]);
                                
                        }
                        
                        
                        // Now that we have our groupings and summaries we can proceed to
                        // group the records and create summary rows.
                        
        
                        foreach ($records as $record){
                                $node =& $tree;
                                for ( $i=0; $i<$numLevels; $i++){       
                                        $groupKey = self::getGroupKey($record, $groupFields[$i]);
                                        if ( !isset($node[$groupKey]) ){
                                                $node[$groupKey] = array(
                                                        'summaryRecord'=> null,
                                                        'level'=>$i
                                                );
                                                if ( $i<$numLevels-1 ){
                                                        $node[$groupKey]['sections'] = array();
                                                } else {
                                                        $node[$groupKey]['records'] = array();
                                                }
                                        }
                                        
                                        $temp =& $node[$groupKey];
                                        unset($node);
                                        if ( isset($temp['sections']) ){
                                                $node =& $temp['sections'];
                                        } else {
                                                $node =& $temp['records'];
                                        }
                                        unset($temp);
                                        
                                }
                                $node[] = $record;
                                unset($node);
                        }
                        $out = '';
                        foreach (array_keys($tree) as $groupKey){
                                $groupData =& $tree[$groupKey];
                                self::compileGroupData(&$groupData, $groupFields, $summaryFields);
                                $out .= self::printGroupData(&$groupData, $groupFields, $summaryFields, $groupHeaders, $groupFooters, $template, $asTable);
                                
                                
                        }
                
                } else {
                
                        $out = '';
                        
                                
                        
                        if ( !is_array($records) ){
                                throw new Exception("No array of records provided.", 2000);
                        }
                        
                        
                        if ( $asTable ){
                                $fields = self::getFields($el);
                                $rowtemplate = '<tr>';
                                foreach ($fields as $field){
                                        $fielddef = $records[0]->table()->getField($field);
                                        if ( PEAR::isError($fielddef) ) continue;
                                        $rowtemplate .= '<td class="xf-htmlreports-field xf-htmlreports-field-'.str_replace('.','_', $field).'">{$'.$field.'}</td>';
                                } 
                                $rowtemplate .= '</tr>';
                                $template = $rowtemplate;
                                
                                $cols = array();
                                foreach ($fields as $fieldname){
                                        $field = $records[0]->table()->getField($fieldname);
                                        if ( PEAR::isError($field) ) continue;
                                        $label = $field['widget']['label'];
                                        if ( @$field['column'] and @$field['column']['label'] ) $label = $field['column']['label'];
                                        $cols[] = $label;
                                        
                                }
                                
                                $colTemplate = '<tr><th>'.implode('</th><th>', array_map('htmlspecialchars', $cols)).'</th></tr>';
                                $out = '<table><thead>'.$colTemplate.'</thead><tbody>';
                        }
                        
                        foreach ($records as $rec){
                                $out .= self::fillReportSingle($rec, $template);
                        }
                        if ( $asTable ){
                                $out .= '</tbody></table>';
                        }
                }
                return $out;
        
        }
        
        
        public static function isDelegateField(Dataface_Table $table, $fieldname){
                if ( strpos($fieldname, '.') !== false ){
                        list($rel, $fld) = explode('.', $fieldname);
                        $relObj = $table->getRelationship($rel);
                        if ( PEAR::isError($relObj) ) throw new Exception($relObj->getMessage(), $relObj->getCode());
                        $rtable = $relObj->getTable($fld);
                        if ( PEAR::isError($rtable) ) throw new Exception($rtable->getMessage(), $rtable->getCode());
                        return self::isDelegateField($rtable, $fld);
                } else {
                        $flds =& $table->delegateFields(true);
                        return isset($flds[$fieldname]);
                }
        }
        
        public static function extractRecordsFromGroupData(&$groupData){
        
                $out = array();
                if ( isset($groupData['records']) ){
                        return $groupData['records'];
                } else if ( isset($groupData['sections']) ){
                        
                        foreach ($groupdData['sections'] as $key=>$section){
                                $secRecs = self::extractRecordsFromGroupData($groupData['sections'][$key]);
                                foreach ($secRecs as $rec){
                                        $out[] = $rec;
                                }
                        }
                }
                return $out;
        
        }
        
        
        public static function compileGroupData(&$groupData, $groupFields, $summaryFields){
                $gfields = $groupFields[$groupData['level']];
                $sfields = $summaryFields[$groupData['level']];
                
                $records = self::extractRecordsFromGroupData(&$groupData);
                if ( !$records ) return;
                $summaryRecord = new Dataface_Record($records[0]->table()->tablename, array());
                foreach ($gfields as $gf ){
                        $summaryRecord->setValue($gf, $records[0]->val($gf));
                }
                
                
                foreach ($sfields as $opt){
                        $summaryRecord->pouch['summaries'][$opt] = self::evaluateAggregateExpression($records, $opt);
                        
                }
                $groupData['summaryRecord'] = $summaryRecord;
                if ( isset($groupData['sections']) ){
                        foreach (array_keys($groupData['sections']) as $secid){
                                $secGroupData =& $groupData['sections'][$secid];
                                self::compileGroupData($secGroupData, $groupFields, $summaryFields);
                                unset($secGroupData);
                        }
                }
                
                
                
        }
        
        public static function evaluateAggregateExpression(array $records, $expression){
        
                $parsed = self::parseExpression($expression);
                switch ($parsed['opt']){
                
                        case 'sum':
                                $total = 0;
                                if ( !$records ) return $total;
                                if ( $records[0]->table()->isInt($parsed['field']) ){
                                        foreach ($records as $rec){
                                                $total += intval($rec->val($parsed['field']));
                                        }
                                } else {
                                        foreach ($records as $rec){
                                                $total += doubleval($rec->val($parsed['field']));
                                        }
                                }
                                return $total;
                                
                        case 'count':
                                return count($records);
                                
                        case 'max':
                                $max = 0;
                                if ( !$records ) return $max;
                                if ( $records[0]->table()->isInt($parsed['field']) ){
                                        foreach ($records as $rec){
                                                $max = max($max, intval($rec->val($parsed['field'])));
                                        }
                                        return $max;
                                } else if ( $records[0]->table()->isFloat($parsed['field']) ){
                                        foreach ($records as $rec){
                                                $max = max($max, doubleval($rec->val($parsed['field'])));
                                        }
                                        return $max;
                                        
                                } else if ( $records[0]->table()->isDate($parsed['field'])){
                                        foreach ($records as $rec){
                                                $max = max($max, strtotime($record->strval($parsed['field'])));
                                        }
                                        return date('Y-m-d H:i:s', $max);
                                } else {
                                        $max = null;
                                        foreach ($records as $rec){
                                                if ( !isset($max) ){
                                                        $max = $rec->val($parsed['field']);
                                                } else if ( ($currtest = $rec->val($parsed['field'])) > $max ){
                                                        $max = $currtest;
                                                }
                                        }
                                        return $max;
                                }
                                
                                
                        case 'min':
                                $min = null;
                                if ( !$records ) return $min;
                                if ( $records[0]->table()->isInt($parsed['field']) ){
                                        foreach ($records as $rec){
                                                if ( !isset($min)  ){
                                                        $min = intval($rec->val($parsed['field']));
                                                } else {
                                                        $min = min($min, intval($rec->val($parsed['field'])));
                                                }
                                        }
                                        return $min;
                                } else if ( $records[0]->table()->isFloat($parsed['field']) ){
                                        foreach ($records as $rec){
                                                if ( !isset($min) ){
                                                        $min = doubleval($rec->val($parsed['field']));
                                                } else {
                                                        $min = min($min, doubleval($rec->val($parsed['field'])));
                                                }
                                        }
                                        return $min;
                                        
                                } else if ( $records[0]->table()->isDate($parsed['field'])){
                                        foreach ($records as $rec){
                                                if ( !isset($min) ){
                                                        $min = strtotime($record->strval($parsed['field']));
                                                } else {
                                        
                                                        $min = min($min, strtotime($record->strval($parsed['field'])));
                                                }
                                        }
                                        return date('Y-m-d H:i:s', $min);
                                } else {
                                        $min = null;
                                        foreach ($records as $rec){
                                                if ( !isset($min) ){
                                                        $min = $rec->val($parsed['field']);
                                                } else if ( ($currtest = $rec->val($parsed['field'])) > $min ){
                                                        $min = $currtest;
                                                }
                                        }
                                        return $min;
                                }
                        default:
                                throw new Exception("Unrecognized aggregate operator: ".$parsed['opt'], self::COMPILE_ERROR);
                        
                        
                }
        }
        
        
        public static function parseExpression($expression){
                $expression = trim($expression);
                if ( preg_match('/^([a-zA-Z]+)\(([^\)]+)\)$/', $expression, $matches)){
                        return array(
                                'opt'=>trim(strtolower($matches[1])),
                                'field'=>trim($matches[2])
                        );
                } else {
                        throw new Exception("Failed to parse expression '".$expression."'.  It does not match the required pattern.");
                        
                }
        }
        
        public static function fillReportSingle(Dataface_Record $record, $template, $strict = false){
                if ( !$record ) throw new Exception("Null record provided.", 2000);
                if ( is_string($template) ){
                        $el = str_get_html($template);
                } else {
                        $el = $template;
                }
                $builder = new XfHtmlReportBuilder();
                if ( $strict ){
                        $builder->strict = true;
                }
                return $builder->fillReport($record, $record, $el, '');
        }
        
        
        public static function validateTemplate(Dataface_Table $table, $template){
                $rec = new Dataface_Record($table->tablename, array());
                self::fillReportSingle($rec, $template, true);
                return true;
        }
        
        
        public function fillReport($root, $record, $el, $basePath=''){
                $oldContext = $this->context;
                $this->context = new stdClass;
                $this->context->root = $root;
                $this->context->record = $record;
                $this->context->el = $el;
                $this->context->basePath = $basePath;
                $this->context->rrec = null;
                
                //$dom = str_get_html($template);
                $rrec = null;
                if ( is_a($record, 'Dataface_RelatedRecord') ){
                        $rrec = $record;
                        $record = $rrec->toRecord();
                        $this->context->rrec = $rrec;
                        $this->context->record = $record;
                }
                $uls = $el->find('ul[relationship]');
                foreach ($uls as $ul){
                        $rel = $ul->relationship;
                        
                        if ( $this->strict ){
                        
                                $relationship = $root->table()->getRelationship($rel);
                                if ( PEAR::isError($relationship) ){
                                        throw new Exception(sprintf(
                                                        'Relationship "%s" does not exist in table "%s" in the ul tag: %s',
                                                        $rel,
                                                        $root->table()->tablename,
                                                        str_replace($ul->innertext,'',$ul->outertext)
                                                ),
                                                self::COMPILE_ERROR
                                        );
                                }
                        }
                        
                        $relatedRecords = $root->getRelatedRecordObjects($rel);
                        $lis = $ul->find('li');
                        
                        $newlis = array();
                        foreach ($relatedRecords as $rrec){
                                foreach ($lis as $li){
                                        $newlis[] = $this->fillReport($root, $rrec, $li, $rel.'.' );
                                }
                        }
                        
                        $ul->innertext = implode("\n", $newlis);
                        
                }
                
                $ols = $el->find('ol[relationship]');
                foreach ($ols as $ol){
                        $rel = $ol->relationship;
                        
                        
                        if ( $this->strict ){
                        
                                $relationship = $root->table()->getRelationship($rel);
                                if ( PEAR::isError($relationship) ){
                                        throw new Exception(sprintf(
                                                        'Relationship "%s" does not exist in table "%s" in the ol tag: %s',
                                                        $rel,
                                                        $root->table()->tablename,
                                                        str_replace($ol->innertext,'',$ol->outertext)
                                                ),
                                                self::COMPILE_ERROR
                                        );
                                }
                        }
                        
                        $relatedRecords = $root->getRelatedRecordObjects($rel);
                        $lis = $ol->find('li');
                        
                        $newlis = array();
                        foreach ($relatedRecords as $rrec){
                                foreach ($lis as $li){
                                        $newlis[] = $this->fillReport($root, $rrec, $li, $rel.'.' );
                                }
                        }
                        
                        $ol->innertext = implode("\n", $newlis);
                        
                }
                
                $tables = $el->find('table[relationship]');
                foreach ($tables as $table){
                        $rel = $table->relationship;
                        
                        if ( $this->strict ){
                        
                                $relationship = $root->table()->getRelationship($rel);
                                if ( PEAR::isError($relationship) ){
                                        throw new Exception(sprintf(
                                                        'Relationship "%s" does not exist in table "%s" in the table tag: %s',
                                                        $rel,
                                                        $root->table()->tablename,
                                                        str_replace($table->innertext,'',$table->outertext)
                                                ),
                                                self::COMPILE_ERROR
                                        );
                                }
                        }
                        
                        $tbody = $table->find('tbody');
                        $relatedRecords = $root->getRelatedRecordObjects($rel);
                        $trs = $tbody[0]->find('tr');
                        
                        $newtrs = array();
                        foreach ($relatedRecords as $rrec){
                                foreach ($trs as $tr){
                                        $newtrs[] = $this->fillReport($root, $rrec, $tr, $rel.'.' );
                                }
                        }
                        
                        $tbody[0]->innertext = implode("\n", $newtrs);
                        
                }
                
                
                $content = $el->outertext;
                $content = preg_replace_callback('#\{\$([a-zA-Z0-9_\.]+)\}#', array($this, '_replace_fields'), $content);
                
                $content = preg_replace_callback('#\{@([a-zA-Z]+\([a-zA-Z0-9_\.]+\))\}#', array($this, '_replace_summary_fields'), $content);
                
                
                $this->context = $oldContext;
                return $content;
                
                
        
        }
        
        
        function _replace_fields($matches){
                //print_r($matches);
                if ( $this->strict ){
                        
                        if ( !$this->context->root->table()->hasField($matches[1]) ){
                                throw new Exception(sprintf(
                                                'Field "%s" does not exist in table "%s" so the macro "%s" cannot be resolved.',
                                                $matches[1],
                                                $this->context->root->table()->tablename,
                                                $matches[0]
                                        ),
                                        self::COMPILE_ERROR
                                );
                        }
                }
                $parts = explode('.', $matches[1]);
                if ( count($parts)>1 and $this->context->rrec ){
                        $rel = $parts[0];
                        $fld = $parts[1];
                        
                        if ( isset($this->context->rrec) and $this->context->rrec->_relationshipName == $rel ){
                                return $this->context->rrec->htmlValue($fld);
                        } else {
                                //echo "Related record: ".$this->context->rrec->_relationshipName;
                        }
                } else {
                        //echo "Getting field ".$parts[0].".";
                        if ( !$this->context->root ){
                                throw new Exception("NO root record to replace fields from.", 2000);
                        }
                        return $this->context->root->htmlValue($matches[1]);
                }
                
                return $matches[0];
        }
        
        
        function _replace_summary_fields($matches){
                //print_r($matches);
                
                //echo "Getting field ".$parts[0].".";
                if ( !$this->context->root ){
                        throw new Exception("NO root record to replace fields from.", 2000);
                }
                if ( isset($this->context->root->pouch['summaries'][$matches[1]]) ){
                        $val = $this->context->root->pouch['summaries'][$matches[1]];
                        $expr = self::parseExpression($matches[1]);
                        $fld = $expr['field'];
                        
                        if ( $this->strict ){
                        
                                if ( !$this->context->root->table()->hasField($fld) ){
                                        throw new Exception(sprintf(
                                                        'Field "%s" does not exist in table "%s" so the summary macro "%s" cannot be resolved.',
                                                        $fld,
                                                        $this->context->root->table()->tablename,
                                                        $matches[0]
                                                ),
                                                self::COMPILE_ERROR
                                        );
                                }
                                
                                if ( !in_array($expr['opt'] , self::$SUMMARY_FUNCTIONS) ){
                                        throw new Exception(sprintf(
                                                        'Summary function "%s" is not supported.  Currently only %s are supported.  (Found in macro "%s").',
                                                        $expr['opt'],
                                                        '"'.implode('", "', self::$SUMMARY_FUNCTIONS).'"',
                                                        $matches[0]
                                                ),
                                                self::COMPILE_ERROR
                                        );
                                        
                                }
                        }
                        if ( self::isDelegateField($this->context->root->table(), $fld) ) return $val;
                        
                        $old = $this->context->root->val($fld);
                        $this->context->root->setValue($fld, $val);
                        $out = $this->context->root->htmlValue($fld);
                        $this->context->root->setValue($fld, $old);
                        return $out;
                }
                //return $this->context->root->htmlValue($parts[0]);
        
        
                return $matches[0];
        }
        
}