DataReaderFactory - The source code for the component with sample code and tutorial (+) finnrasmussen.dk

DataReaderFactory, PHP source code

Den fulde PHP kildekode for DataReaderFactory klassen

<?php
/**
 * @package dto
 * @see HTML_DTO_UTIL_PATH.'/DataReaderFactory.php'
 * @copyright (c) http://Finn-Rasmussen.com
 * @license http://Finn-Rasmussen.com/license/ myPHP License conditions
 * @author http://Finn-Rasmussen.com
 * @version 1.11
 * @since 27-nov-2009
 */

/**
 * The required files
 */
require_once(HTML_DTO_UTIL_PATH.'/DataReader.php');
require_once(HTML_DTO_UTIL_PATH.'/FieldFactory.php');
require_once(HTML_BASIC_UTIL_PATH.'/Message.php');
require_once(HTML_UTIL_COMPONENT_PATH.'/Request.php');
if (defined('HTML_LOG_UTIL_PATH')) {
    require_once(HTML_LOG_UTIL_PATH.'/Log.php');
}
if (defined('HTML_MVC_RESOURCE_PATH')) {
    require_once(HTML_MVC_RESOURCE_PATH.'/Define.php');
}

/**
 * The DataReader Factory is used to return a complete populated 
 * DataReader object, from an array of rows and an array of header meta data information.
 * The rows are sorted by asc/desc by a specific fieldname, which are fetched from the request
 * @see REQUEST_SORT_BY_NAME
 * @see REQUEST_ORDER_BY_NAME
 * <code>
 * Usage:
 *   $default = array();
 *   $header  = array(
 *       'firstname'=>array('fieldName'=>'firstname', 'fieldLen'=>100, 'fieldType'=>'', 'fieldFlags'=>'', 'fieldTable'=>''),
 *       'lastname'=>'array('fieldName'=>'lastname' , 'fieldLen'=>100, 'fieldType'=>'', 'fieldFlags'=>'', 'fieldTable'=>''),
 *   );
 *   $rows = array(
 *       array('firstname'=>'Finn', 'lastname'=>'Rasmussen'),
 *       array('firstname'=>'Zita', 'lastname'=>'Christensen'),
 *   );
 * 
 *   $limit   = ''; // The limit to use for the array
 *   $sort    = true;
 *   $factory = new DataReaderFactory();
 *   $datareader = $factory->newDataReader($rows, $header, $default, $limit, $sort);
 *   print $datareader->getNumRows(); // Use the datareader object
 *   print $datareader->getFieldFlags($name);
 * Or
 *      $datareader = DataReaderFactory::newDataReader($rows, $header, $default, $limit, $sort); 
 *   print $datareader->getNumRows(); // Use the datareader object
 *   print $datareader->getFieldFlags($name);
 * </code>
 * @package dto
 */

class DataReaderFactory {
    /**
     * Constructor
     */
    function __construct() {
    }
    
    /**
     * returns the sequence of elements from the array array as specified by the offset and length parameters. 
     * If offset is non-negative, the sequence will start at that offset in the array. 
     * If offset is negative, the sequence will start that far from the end of the array. 
     * If length is given and is positive, then the sequence will have that many elements in it. 
     * If length is given and is negative then the sequence will stop that many elements from the end of the array. 
     * If it is omitted, then the sequence will have everything from offset up until the end of the array. 
     * 
     * @param  array $rows   The rows to populate the datareader
     * @param  int   $offset The offset
     * @param  int   $length The length
     * @return array The spiced array of rows 
     */
    public static function arraySlice($rows, $offset, $length){
        $output_array = array();
        $preserveKeys = true;
        $output_array = array_slice($rows, $offset, $length, $preserveKeys);
        return $output_array;
    }
    
    /**
     * Return a new DataReader object populated with data from the rows array and 
     * limited by the request keys 
     * @see REQUEST_LIMIT_NAME_SKIP
     * @see REQUEST_LIMIT_NAME_SHOW
     * <code>
     * Usage:
     *   $rows = array(
     *       array('firstname'=>'Finn', 'lastname'=>'Rasmussen'),
     *       array('firstname'=>'Zita', 'lastname'=>'Christensen'),
     *   );
     *   $limit = 20;
     *   $sort  = true;
     *   
     *   $factory = new DataReaderFactory();
     *   $limitedRows = $factory->limit($rows, $limit, $sort);
     * Or
     *   $limitedRows = DataReaderFactory::limit($rows, $limit, $sort); 
     * </code>
     * @static
     * @param  array   $rows  The rows to populate the datareader
     * @param  int     $limit The limit to use for the array
     * @param  boolean $sort  The data set must be sorted, if true
     * @return array The limited array of rows 
     */
    public static function limit($rows, $limit='', $sort=false) {
        $limitedRows = array();
        // $sort && 
        if (defined('REQUEST_LIMIT_NAME_SKIP') && defined('REQUEST_LIMIT_NAME_SHOW')) {
            $offset = 0 + Request::get(REQUEST_LIMIT_NAME_SKIP);
            if ($offset < 0) {
                $offset = 0;
            }
            if ($limit !== '' && is_numeric($offset) && $offset >= 0) {
                $length   = Request::get(REQUEST_LIMIT_NAME_SHOW, $limit);
                $limitedRows = DataReaderFactory::arraySlice($rows, $offset, $length);
            } else {
                $limitedRows = $rows; // Use the original
            }
        } else {
            $limitedRows = $rows; // Use the original
        }
        return $limitedRows;
    }
    
    /**
     * Return a new DataReader object populated with data from the rows array and sorted by the request key
     * <code>
     * Usage:
     *   // The rows to populate the datareader
     *   $rows = array(
     *       array('firstname'=>'Finn', 'lastname'=>'Rasmussen'),
     *       array('firstname'=>'Zita', 'lastname'=>'Christensen'),
     *   );
     *   $sort    = true;
     *   
     *   $factory = new DataReaderFactory();
     *   $sortedRows = $factory->sort($rows, $sort);
     * Or
     *   $sortedRows = DataReaderFactory::sort($rows, $sort); 
     * </code>
     * @static
     * @param  array   $rows The rows to populate the datareader
     * @param  boolean $sort The data set must be sorted, if true
     * @return array The sorted array of rows 
     */
    public static function sort($rows, $sort=false) {
        $sortedRows = array();
        $finalRows  = array();
        if ($sort && defined('REQUEST_SORT_BY_NAME')) {
            $orderBy = Request::get(REQUEST_ORDER_BY_NAME);
            $sortBy  = Request::get(REQUEST_SORT_BY_NAME);
            if ($orderBy != '') {
                // Loop through the rows and for each row, calculate a new key
                foreach($rows as $no=>$row) {
                    if (is_array($row)) {
                        $newKey = $no;
                        foreach($row as $key=>$value) {
                            if ($key==$orderBy) {
                                $newKey = strtolower($value).$no;
                                break; // End of search for a key
                            }
                        }
                        // Add the current row to the array with a new key
                        $sortedRows[$newKey] = $row;
                    } else {
                        $msg = "DataReaderFactory::sort(rows), ($no) Row is NOT an array, where row=".$row; 
                        Log::fatal($msg, __FILE__, __LINE__);
                        Message::add($msg, __FILE__, __LINE__);
                    }
                }
                
                // OrderBy key ended, now sort rows asc/desc
                switch($sortBy) {
                    case SORT_BY_ASC:
                        ksort($sortedRows);
                        reset($sortedRows);
                        break;
                    case SORT_BY_DESC:
                        krsort($sortedRows);
                        reset($sortedRows);
                        break;
                    default:
                        // Leave array unsorted
                        break;
                }
                // Update the final rows with a new index 
                foreach($sortedRows as $no=>$row) {
                    $finalRows[] = $row;
                }
            } else {
                $finalRows = $rows; // Use the original
            }
        } else {
            $finalRows = $rows; // Use the original
        }
        return $finalRows;
    }
    
    /**
     * Return a new DataReader object populated with data from the rows array
     * <code>
     * Usage:
     *   // The rows to populate the datareader
     *   $rows = array(
     *       array('firstname'=>'Finn', 'lastname'=>'Rasmussen'),
     *       array('firstname'=>'Zita', 'lastname'=>'Christensen'),
     *   );
     *   $header  = ''; // The header meta data
     *   $default = ''; // The default meta data array
     *   $limit   = 10; // The limit to use for the array
     *   $sort    = true;
     *   
     *   $factory = new DataReaderFactory();
     *   $datareader = $factory->newDataReader($rows, $header, $default, $limit, $sort);
     *   print $datareader->getNumRows(); // Use the datareader object
     *   print $datareader->getFieldFlags($name);
     * Or
     *   $datareader = DataReaderFactory::newDataReader($rows, $header, $default, $limit, $sort); 
     *   print $datareader->getNumRows(); // Use the datareader object
     *   print $datareader->getFieldFlags($name);
     * </code>
     * @static
     * @param  array   $rows    The rows to populate the datareader
     * @param  array   $header  The header meta data
     * @param  array   $default The default meta data array
     * @param  int     $limit   The limit to use for the array
     * @param  boolean $sort    The data set must be sorted, if true
     * @return DataReader       The created and populated datareader object 
     */
    public static function newDataReader($rows='', $header='', $default='', $limit='', $sort=false) {
        $limitRows = DataReaderFactory::limit($rows, $limit, $sort);
        $theRows   = DataReaderFactory::sort($limitRows, $sort);
        
        // Get the meta data
        $field = FieldFactory::newField($theRows, $header, $default);
        
        // Assume that the query went well
        $rc = true;
        $datareader = new DataReader();
        $datareader->setRc($rc);
        $datareader->setSort($sort);
        
        $datareader->setMsg(TEXT_DATA_READER_FACTORY);
        
        // Add each row to the datareader
        $datareader->setNumRows(count($theRows));
        foreach($theRows as $no=>$row) {
            $datareader->add($no, $row);
            if ($no === 0) {
                $datareader->setNumFields(count($row));
                if (is_array($row)) {
                    foreach($row as $key=>$value) {
                        $datareader->addFieldName ($key, $field->getFieldName ($key));
                        $datareader->addFieldLen  ($key, $field->getFieldLen  ($key));
                        $datareader->addFieldType ($key, $field->getFieldType ($key));
                        $datareader->addFieldFlags($key, $field->getFieldFlags($key));
                        $datareader->addFieldTable($key, $field->getFieldTable($key));
                    }
                } else {
                    if ($row != '') {
                        $msg = "DataReaderFactory::newDataReader(rows, header, default, limit, sort), Not an array, found row=".$row; 
                        Log::debug($msg, __FILE__, __LINE__);
                        Message::add($msg, __FILE__, __LINE__);
                    }
                }
            }
        }
        return $datareader;
    }
    
    /**
     * Get the html code
     * @return String The html code
     */
    function getHtml() {
        $rows = array(
             array('firstname'=>'Finn', 'lastname'=>'Rasmussen'),
             array('firstname'=>'Zita', 'lastname'=>'Christensen'),
        );
        $header  = ''; // The header meta data
        $default = ''; // The default meta data array
        $limit   = 10; // The limit to use for the array
        $sort    = true;
        $datareader = DataReaderFactory::newDataReader($rows, $header, $default, $limit, $sort);
        return $datareader->getHtml();
    }
}
?>
DataReaderFactory.php

DataReaderFactory, Sample code, tutorial

DataReaderFactory, Sådan vises komponenten

DataReaderFactory, PHP source code

DataReaderFactory, HTML source code

DataReaderFactory, Class methods

DataReaderFactory, Object vars
