/**
* 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'),
* );
*
* $factory = new DataReaderFactory();
* $datareader = $factory->newDataReader($rows,$header,$default);
* print $datareader->getNumRows(); // Use the datareader object
* print $datareader->getFieldFlags($name);
* Or
* $datareader = DataReaderFactory::newDataReader($rows,$header,$default);
* print $datareader->getNumRows(); // Use the datareader object
* print $datareader->getFieldFlags($name);
* </code>
* @package dto
*/
class DataReaderFactory {
/**
* Constructor
*/
function DataReaderFactory() {
}
/**
* 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
*/
function arraySlice($rows, $offset, $length){
$output_array = array();
$phpVersion = substr(PHP_VERSION,0,1);
switch ($phpVersion) {
case 4:
$a = 0;
foreach ($rows as $key => $value) {
if (($a >= $offset) && ($a - $offset < $length)) {
$output_array[$key] = $value;
}
$a++;
}
break;
case 5:
$preserveKeys = true;
$output_array = array_slice($rows, $offset, $length, $preserveKeys);
break;
default:
die('File: '.__FILE__."<br />\r\nLine: ".__LINE__."<br />PHP_VERSION is NOT an recognized $phpVersion[0]\r\n");
break;
}
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:
* $factory = new DataReaderFactory();
* $limitedRows = $factory->limit($rows);
* Or
* $limitedRows = DataReaderFactory::limit($rows);
* </code>
* @static
* @param array $rows The rows to populate the datareader
* @return array The limited array of rows
*/
function limit($rows) {
$limitedRows = array();
if (defined('REQUEST_LIMIT_NAME_SKIP') && defined('REQUEST_LIMIT_NAME_SHOW')) {
$offset = 0 + Request::get(REQUEST_LIMIT_NAME_SKIP);
$length = Request::get(REQUEST_LIMIT_NAME_SHOW, LIMIT_NUMBER_OF_ROWS);
if (is_numeric($offset) && $offset >= 0) {
$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:
* $factory = new DataReaderFactory();
* $sortedRows = $factory->sort($rows);
* Or
* $sortedRows = DataReaderFactory::sort($rows);
* </code>
* @static
* @param array $rows The rows to populate the datareader
* @return array The sorted array of rows
*/
function sort($rows) {
$sortedRows = array();
$finalRows = array();
if (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 {
die('File: '.__FILE__."<br />\r\nLine: ".__LINE__."<br />($no) Row is NOT an array\r\n");
}
}
// 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:
* $factory = new DataReaderFactory();
* $datareader = $factory->newDataReader($rows,$header,$default);
* print $datareader->getNumRows(); // Use the datareader object
* print $datareader->getFieldFlags($name);
* Or
* $datareader = DataReaderFactory::newDataReader($rows,$header,$default);
* 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
* @return DataReader The created and populated datareader object
*/
function newDataReader($rows='', $header='', $default='') {
$limitRows = DataReaderFactory::limit($rows);
$theRows = DataReaderFactory::sort($limitRows);
// 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->setMsg(TEXT_DATA_READER_FACTORY);
// Add each row to the datareader
$datareader->setNumRows(count($rows));
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), Not an array, found row=".$row;
Log::debug(__FILE__,__LINE__,$msg);
Message::add($msg, __FILE__, __LINE__);
}
}
}
}
return $datareader;
}
/**
* Get the html code
* @return String The html code
*/
function getHtml() {
$rows = array();
$datareader = DataReaderFactory::newDataReader($rows);
return $datareader->getHtml();
}
}
?>
HTML source code
Den fulde HTML kildekode for DataReaderFactory klassen
<?
0
?>
Class methods
Her er 'klasse metoderne' for DataReaderFactory klassen:
datareaderfactory
arrayslice
limit
sort
newdatareader
gethtml
Object vars
Her er 'objekt variable' for DataReaderFactory klassen:
