1050 lines
31 KiB
PHP
Executable File
1050 lines
31 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* PHPReport
|
|
* Library for generating reports from PHP
|
|
* Copyright (c) 2012 PHPReport
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*
|
|
* @package PHPReport
|
|
* @author Vernes Šiljegović
|
|
* @copyright Copyright (c) 2012 PHPReport
|
|
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
|
* @version 1.1, 2013-01-06
|
|
*/
|
|
|
|
/**
|
|
* PHPExcel
|
|
*
|
|
* @copyright Copyright (c) 2006 - 2011 PHPExcel (http://www.codeplex.com/PHPExcel)
|
|
*/
|
|
require_once 'PHPExcel.php';
|
|
|
|
class PHPReport {
|
|
|
|
//report template
|
|
private $_templateDir;
|
|
private $_template;
|
|
private $_usingTemplate;
|
|
|
|
//internal collections of data
|
|
private $_data=array();
|
|
private $_search=array();
|
|
private $_replace=array();
|
|
private $_group=array();
|
|
private $_lastColumn='A';
|
|
private $_lastRow=1;
|
|
|
|
//parameters
|
|
private $_renderHeading=false;
|
|
private $_useStripRows=false;
|
|
private $_headingText;
|
|
private $_noResultText;
|
|
|
|
//styling
|
|
private $_headerStyleArray = array(
|
|
'font' => array(
|
|
'bold' => true,
|
|
'color' => array(
|
|
'rgb' => 'FFFFFF'
|
|
)
|
|
),
|
|
'fill' => array(
|
|
'type' => PHPExcel_Style_Fill::FILL_SOLID,
|
|
'startcolor' => array(
|
|
'rgb' => '4E5A7A'
|
|
)
|
|
)
|
|
);
|
|
private $_footerStyleArray = array(
|
|
'font' => array(
|
|
'bold' => true,
|
|
),
|
|
'fill' => array(
|
|
'type' => PHPExcel_Style_Fill::FILL_SOLID,
|
|
'startcolor' => array(
|
|
'rgb' => 'E4E8F3',
|
|
)
|
|
)
|
|
);
|
|
private $_headerGroupStyleArray = array(
|
|
'alignment' => array(
|
|
'horizontal' => PHPExcel_Style_Alignment::HORIZONTAL_LEFT
|
|
),
|
|
'font' => array(
|
|
'bold' => true
|
|
),
|
|
'fill' => array(
|
|
'type' => PHPExcel_Style_Fill::FILL_SOLID,
|
|
'startcolor' => array(
|
|
'rgb' => '8DB4E3'
|
|
)
|
|
)
|
|
);
|
|
private $_footerGroupStyleArray = array(
|
|
'font' => array(
|
|
'bold' => true
|
|
),
|
|
'fill' => array(
|
|
'type' => PHPExcel_Style_Fill::FILL_SOLID,
|
|
'startcolor' => array(
|
|
'rgb' => 'C5D9F1'
|
|
)
|
|
)
|
|
);
|
|
private $_noResultStyleArray = array(
|
|
'borders' => array(
|
|
'outline' => array(
|
|
'style' => PHPExcel_Style_Border::BORDER_THIN
|
|
)
|
|
),
|
|
'alignment' => array(
|
|
'horizontal' => PHPExcel_Style_Alignment::HORIZONTAL_CENTER
|
|
),
|
|
'font' => array(
|
|
'bold' => true
|
|
),
|
|
'fill' => array(
|
|
'type' => PHPExcel_Style_Fill::FILL_SOLID,
|
|
'startcolor' => array(
|
|
'rgb' => 'FFEBA5'
|
|
)
|
|
)
|
|
);
|
|
private $_headingStyleArray = array(
|
|
'font' => array(
|
|
'bold' => true,
|
|
'color' => array(
|
|
'rgb' => '4E5A7A'
|
|
),
|
|
'size' => '24'
|
|
),
|
|
'alignment' => array(
|
|
'horizontal' => PHPExcel_Style_Alignment::HORIZONTAL_CENTER
|
|
)
|
|
);
|
|
|
|
//PHPExcel objects
|
|
private $objReader;
|
|
private $objPHPExcel;
|
|
private $objWorksheet;
|
|
private $objWriter;
|
|
|
|
/**
|
|
* Creates new report with some configuration parameters
|
|
* @param array $config
|
|
*/
|
|
public function __construct($config=array())
|
|
{
|
|
$this->setConfig($config);
|
|
$this->init();
|
|
}
|
|
|
|
/**
|
|
* Uses configuration array to adjust report parameters
|
|
* @param array $config
|
|
*/
|
|
public function setConfig($config)
|
|
{
|
|
if(!is_array($config))
|
|
throw new Exception('Unable to use non-array configuration');
|
|
|
|
foreach($config as $key=>$value)
|
|
{
|
|
$_key='_'.$key;
|
|
$this->$_key=$value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes internal objects
|
|
*/
|
|
private function init()
|
|
{
|
|
if($this->_template!='')
|
|
{
|
|
$this->loadTemplate();
|
|
}
|
|
else
|
|
{
|
|
$this->createTemplate();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads Excel file as a template for report
|
|
*/
|
|
public function loadTemplate($template='')
|
|
{
|
|
if($template!='')
|
|
$this->_template=$template;
|
|
|
|
if(!is_file($this->_templateDir.$this->_template))
|
|
throw new Exception('Unable to load template file: '.$this->_templateDir.$this->_template);
|
|
|
|
//identify type of template file
|
|
$inputFileType = PHPExcel_IOFactory::identify($this->_templateDir.$this->_template);
|
|
//TODO: better control of allowed input types
|
|
//load template file into PHPExcel objects
|
|
$this->objReader = PHPExcel_IOFactory::createReader($inputFileType);
|
|
$this->objPHPExcel = $this->objReader->load($this->_templateDir.$this->_template);
|
|
$this->objWorksheet = $this->objPHPExcel->getActiveSheet();
|
|
|
|
$this->_usingTemplate=true;
|
|
}
|
|
|
|
/**
|
|
* Creates PHPExcel object and template for report
|
|
*/
|
|
private function createTemplate()
|
|
{
|
|
$this->objPHPExcel = new PHPExcel();
|
|
$this->objPHPExcel->setActiveSheetIndex(0);
|
|
$this->objWorksheet = $this->objPHPExcel->getActiveSheet();
|
|
//TODO: other parameters
|
|
$this->objWorksheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_PORTRAIT);
|
|
$this->objWorksheet->getPageSetup()->setPaperSize(PHPExcel_Worksheet_PageSetup::PAPERSIZE_A4);
|
|
$this->objWorksheet->getPageSetup()->setHorizontalCentered(true);
|
|
$this->objWorksheet->getPageSetup()->setVerticalCentered(false);
|
|
|
|
$this->_usingTemplate=false;
|
|
}
|
|
|
|
/**
|
|
* Takes an array of all the data for report
|
|
*
|
|
* @param array $dataCollection Associative array with data for report
|
|
* or an array of such arrays
|
|
* id - unique identifier of data group
|
|
* data - Single array of data
|
|
*/
|
|
public function load($dataCollection)
|
|
{
|
|
if(!is_array($dataCollection))
|
|
throw new Exception("Could not load a non-array data!");
|
|
|
|
//clear current data
|
|
$this->clearData();
|
|
|
|
//check if it is a single array of data
|
|
if(isset ($dataCollection['data']))
|
|
{
|
|
$this->addData($dataCollection);
|
|
}
|
|
else
|
|
{
|
|
//it's an array of arrays of data, add all
|
|
foreach($dataCollection as $data)
|
|
$this->addData($data);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Takes an array of all the data for report
|
|
*
|
|
* @param array $data Associative array with two elements
|
|
* id - unique identifier of data group
|
|
* data - Single array of data
|
|
*/
|
|
private function addData($data)
|
|
{
|
|
if(!is_array($data))
|
|
throw new Exception("Could not load a non-array data!");
|
|
if(!isset ($data['id']))
|
|
throw new Exception("Every array of data needs an 'id'!");
|
|
if(!isset ($data['data']))
|
|
throw new Exception("Loaded array needs an element 'data'!");
|
|
|
|
$this->_data[]=$data;
|
|
}
|
|
|
|
/**
|
|
* Clears internal collection of data
|
|
*/
|
|
private function clearData()
|
|
{
|
|
$this->_data=array();
|
|
}
|
|
|
|
/**
|
|
*Creates a new report based on loaded data
|
|
*/
|
|
public function createReport()
|
|
{
|
|
foreach($this->_data as $data)
|
|
{
|
|
//$data must have id and data elements
|
|
//$data may also have config, header, footer, group
|
|
|
|
$id=$data['id'];
|
|
$format=isset($data['format'])?$data['format']:array();
|
|
$config=isset($data['config'])?$data['config']:array();
|
|
$group=isset($data['group'])?$data['group']:array();
|
|
|
|
$configHeader=isset($config['header'])?$config['header']:$config;
|
|
$configData=isset($config['data'])?$config['data']:$config;
|
|
$configFooter=isset($config['footer'])?$config['footer']:$config;
|
|
|
|
$config=array(
|
|
'header'=>$configHeader,
|
|
'data'=>$configData,
|
|
'footer'=>$configFooter
|
|
);
|
|
|
|
//set the group
|
|
$this->_group=$group;
|
|
|
|
$loadCollection=array();
|
|
|
|
$nextRow=$this->objWorksheet->getHighestRow();
|
|
if($nextRow>1)
|
|
$nextRow++;
|
|
$colIndex=-1;
|
|
|
|
//form the header for data
|
|
if(isset($data['header']))
|
|
{
|
|
$headerId='HEADER_'.$id;
|
|
foreach($data['header'] as $k=>$v)
|
|
{
|
|
$colIndex++;
|
|
$tag="{".$headerId.":".$k."}";
|
|
$this->objWorksheet->setCellValueByColumnAndRow($colIndex,$nextRow,$tag);
|
|
if(isset($config['header'][$k]['width']))
|
|
$this->objWorksheet->getColumnDimensionByColumn($colIndex)->setWidth(pixel2unit($config['header'][$k]['width']));
|
|
if(isset($config['header'][$k]['align']))
|
|
$this->objWorksheet->getStyleByColumnAndRow($colIndex,$nextRow)->getAlignment()->setHorizontal($config['header'][$k]['align']);
|
|
}
|
|
|
|
if($colIndex>-1)
|
|
{
|
|
$this->objWorksheet->getStyle(PHPExcel_Cell::stringFromColumnIndex(0).$nextRow.':'.PHPExcel_Cell::stringFromColumnIndex($colIndex).$nextRow)->applyFromArray($this->_headerStyleArray);
|
|
}
|
|
|
|
//add header row to load collection
|
|
$loadCollection[]=array('id'=>$headerId,'data'=>$data['header']);
|
|
|
|
//move to next row for data
|
|
$nextRow++;
|
|
}
|
|
|
|
|
|
//form the data repeating row
|
|
$dataId='DATA_'.$id;
|
|
$colIndex=-1;
|
|
|
|
//form the template row
|
|
if(count($data['data'])>0)
|
|
{
|
|
//we just need first row of data, to see array keys
|
|
$singleDataRow=$data['data'][0];
|
|
foreach($singleDataRow as $k=>$v)
|
|
{
|
|
$colIndex++;
|
|
$tag="{".$dataId.":".$k."}";
|
|
$this->objWorksheet->setCellValueByColumnAndRow($colIndex,$nextRow,$tag);
|
|
if(isset($config['data'][$k]['align']))
|
|
$this->objWorksheet->getStyleByColumnAndRow($colIndex,$nextRow)->getAlignment()->setHorizontal($config['data'][$k]['align']);
|
|
}
|
|
}
|
|
|
|
//add this row to collection for load but with repeating
|
|
$loadCollection[]=array('id'=>$dataId,'data'=>$data['data'],'repeat'=>true,'format'=>$format);
|
|
$this->enableStripRows();
|
|
|
|
//form the footer row for data if needed
|
|
if(isset($data['footer']))
|
|
{
|
|
$footerId='FOOTER_'.$id;
|
|
$colIndex=-1;
|
|
$nextRow++;
|
|
|
|
//formiraj template
|
|
foreach($data['footer'] as $k=>$v)
|
|
{
|
|
$colIndex++;
|
|
$tag="{".$footerId.":".$k."}";
|
|
$this->objWorksheet->setCellValueByColumnAndRow($colIndex,$nextRow,$tag);
|
|
if(isset($config['footer'][$k]['align']))
|
|
$this->objWorksheet->getStyleByColumnAndRow($colIndex,$nextRow)->getAlignment()->setHorizontal($config['footer'][$k]['align']);
|
|
}
|
|
if($colIndex>-1)
|
|
{
|
|
$this->objWorksheet->getStyle(PHPExcel_Cell::stringFromColumnIndex(0).$nextRow.':'.PHPExcel_Cell::stringFromColumnIndex($colIndex).$nextRow)->applyFromArray($this->_footerStyleArray);
|
|
}
|
|
|
|
//add footer row to load collection
|
|
$loadCollection[]=array('id'=>$footerId,'data'=>$data['footer'],'format'=>$format);
|
|
}
|
|
|
|
$this->load($loadCollection);
|
|
$this->generateReport();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates report based on loaded data
|
|
*/
|
|
public function generateReport()
|
|
{
|
|
$this->_lastColumn=$this->objWorksheet->getHighestColumn();//TODO: better detection
|
|
$this->_lastRow=$this->objWorksheet->getHighestRow();
|
|
foreach($this->_data as $data)
|
|
{
|
|
if(isset ($data['repeat']) && $data['repeat']==true)
|
|
{
|
|
//Repeating data
|
|
$foundTags=false;
|
|
$repeatRange='';
|
|
$firstRow='';
|
|
$lastRow='';
|
|
|
|
$firstCol='A';//TODO: better detection
|
|
$lastCol=$this->_lastColumn;
|
|
|
|
//scan the template
|
|
//search for repeating part
|
|
foreach ($this->objWorksheet->getRowIterator() as $row)
|
|
{
|
|
$cellIterator = $row->getCellIterator();
|
|
$rowIndex = $row->getRowIndex();
|
|
//find the repeating range (one or more rows)
|
|
foreach ($cellIterator as $cell)
|
|
{
|
|
$cellval=trim($cell->getValue());
|
|
$column = $cell->getColumn();
|
|
//see if the cell has something for replacing
|
|
if(preg_match_all("/\{".$data['id'].":(\w*|#\+?-?(\d*)?)\}/", $cellval, $matches))
|
|
{
|
|
//this cell has replacement tags
|
|
if(!$foundTags) $foundTags=true;
|
|
//remember the first ant the last row
|
|
if($rowIndex!=$firstRow)
|
|
$lastRow=$rowIndex;
|
|
if($firstRow=='')
|
|
$firstRow=$rowIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
//form the repeating range
|
|
if($foundTags)
|
|
$repeatRange=$firstCol.$firstRow.":".$lastCol.$lastRow;
|
|
|
|
//check if this is the last row
|
|
if($foundTags && $lastRow==$this->_lastRow)
|
|
$data['last']=true;
|
|
|
|
//set initial format data
|
|
if(! isset($data['format']))
|
|
$data['format']=array();
|
|
|
|
//set default step as 1
|
|
if(! isset($data['step']))
|
|
$data['step']=1;
|
|
|
|
//check if data is an array
|
|
if(is_array($data['data']))
|
|
{
|
|
//every element is an array with data for all the columns
|
|
if($foundTags)
|
|
{
|
|
//insert repeating rows, as many as needed
|
|
//check if grouping is defined
|
|
if(count($this->_group))
|
|
$this->generateRepeatingRowsWithGrouping($data, $repeatRange);
|
|
else
|
|
$this->generateRepeatingRows($data, $repeatRange);
|
|
//remove the template rows
|
|
for($i=$firstRow;$i<=$lastRow;$i++)
|
|
{
|
|
$this->objWorksheet->removeRow($firstRow);
|
|
}
|
|
//if there is no data
|
|
if(count($data['data'])==0)
|
|
$this->addNoResultRow($firstRow,$firstCol,$lastCol);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//TODO
|
|
//maybe an SQL query?
|
|
//needs to be database agnostic
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//non-repeating data
|
|
//check for additional formating
|
|
if(! isset($data['format']))
|
|
$data['format']=array();
|
|
|
|
//check if data is an array or mybe a SQL query
|
|
if(is_array($data['data']))
|
|
{
|
|
//array of data
|
|
$this->generateSingleRow($data);
|
|
}
|
|
else
|
|
{
|
|
//TODO
|
|
//maybe an SQL query?
|
|
//needs to be database agnostic
|
|
}
|
|
}
|
|
}
|
|
|
|
//call the replacing function
|
|
$this->searchAndReplace();
|
|
|
|
//generate heading if heading text is set
|
|
if($this->_headingText!='')
|
|
$this->generateHeading();
|
|
|
|
}
|
|
|
|
/**
|
|
* Generates single non-repeating row of data
|
|
* @param array $data
|
|
*/
|
|
private function generateSingleRow(& $data)
|
|
{
|
|
$id=$data['id'];
|
|
$format=$data['format'];
|
|
foreach($data['data'] as $key=>$value)
|
|
{
|
|
$search="{".$id.":".$key."}";
|
|
$this->_search[]=$search;
|
|
|
|
//if it needs formating
|
|
if(isset($format[$key]))
|
|
{
|
|
foreach($format[$key] as $ftype=>$f)
|
|
{
|
|
$value=$this->formatValue($value,$ftype,$f);
|
|
}
|
|
}
|
|
$this->_replace[]=$value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates repeating rows of data with some template range
|
|
* @param array $data
|
|
* @param string $repeatRange
|
|
*/
|
|
private function generateRepeatingRows(& $data, $repeatRange)
|
|
{
|
|
$rowCounter=0;
|
|
$repeatTemplateArray=$this->objWorksheet->rangeToArray($repeatRange,null,true,true,true);
|
|
//insert repeating rows but first check for minimum number of rows
|
|
if(isset($data['minRows']))
|
|
{
|
|
$minRows=(int)$data['minRows'];
|
|
}
|
|
else
|
|
$minRows=0;
|
|
|
|
//is this the last data
|
|
if(isset($data['last']))
|
|
$last=$data['last'];
|
|
else
|
|
$last=false;
|
|
|
|
$templateKeys=array_keys($repeatTemplateArray);
|
|
$lastRowFoundAt=end($templateKeys);
|
|
$firstRowFoundAt=reset($templateKeys);
|
|
$rowsFound=count($repeatTemplateArray);
|
|
|
|
$mergeCells=$this->objWorksheet->getMergeCells();
|
|
$needMerge=array();
|
|
foreach($mergeCells as $mergeCell)
|
|
{
|
|
if($this->isSubrange($mergeCell, $repeatRange))
|
|
{
|
|
//contains merged cells, save for later
|
|
$needMerge[]=$mergeCell;
|
|
}
|
|
}
|
|
|
|
//check if any new rows need to bi inserted
|
|
$dataRows=count($data['data']);
|
|
if($minRows<$dataRows)
|
|
$this->objWorksheet->insertNewRowBefore($lastRowFoundAt+1,$rowsFound * ($dataRows - $minRows));
|
|
|
|
//check all the data
|
|
foreach ($data['data'] as $value)
|
|
{
|
|
$rowCounter++;
|
|
$skip=$rowCounter*$rowsFound;
|
|
$newRowIndex=$firstRowFoundAt+$skip;
|
|
|
|
//copy merge definitions
|
|
foreach($needMerge as $nm)
|
|
{
|
|
$nm=PHPExcel_Cell::rangeBoundaries($nm);
|
|
$newMerge=PHPExcel_Cell::stringFromColumnIndex($nm[0][0]-1).($nm[0][1]+$skip).":".PHPExcel_Cell::stringFromColumnIndex($nm[1][0]-1).($nm[1][1]+$skip);
|
|
|
|
$this->objWorksheet->mergeCells($newMerge);
|
|
}
|
|
|
|
//generate row of data
|
|
$this->generateSingleRepeatingRow($value, $repeatTemplateArray, $rowCounter, $skip, $data['id'], $data['format'], $data['step']);
|
|
}
|
|
//remove merge on template, BUG fix
|
|
foreach($needMerge as $nm)
|
|
{
|
|
$this->objWorksheet->unmergeCells($nm);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates repeating rows of data with some template range but also with grouping
|
|
* @param array $data
|
|
* @param string $repeatRange
|
|
*/
|
|
private function generateRepeatingRowsWithGrouping(& $data, $repeatRange)
|
|
{
|
|
$rowCounter=0;
|
|
$groupCounter=0;
|
|
$footerCount=0;
|
|
$repeatTemplateArray=$this->objWorksheet->rangeToArray($repeatRange,null,true,true,true);
|
|
//insert repeating rows but first check for minimum number of rows
|
|
if(isset($data['minRows']))
|
|
{
|
|
$minRows=(int)$data['minRows'];
|
|
}
|
|
else
|
|
$minRows=0;
|
|
|
|
$templateKeys=array_keys($repeatTemplateArray);
|
|
$lastRowFoundAt=end($templateKeys);
|
|
$firstRowFoundAt=reset($templateKeys);
|
|
$rowsFound=count($repeatTemplateArray);
|
|
|
|
list($rangeStart,$rangeEnd) = PHPExcel_Cell::rangeBoundaries($repeatRange);
|
|
$firstCol=PHPExcel_Cell::stringFromColumnIndex($rangeStart[0]-1);
|
|
$lastCol=PHPExcel_Cell::stringFromColumnIndex($rangeEnd[0]-1);
|
|
|
|
$mergeCells=$this->objWorksheet->getMergeCells();
|
|
$needMerge=array();
|
|
foreach($mergeCells as $mergeCell)
|
|
{
|
|
if($this->isSubrange($mergeCell, $repeatRange))
|
|
{
|
|
//contains merged cells, save for later
|
|
$needMerge[]=$mergeCell;
|
|
}
|
|
}
|
|
|
|
//group array should have header, rows and summary elements
|
|
foreach($this->_group['rows'] as $name=>$rows)
|
|
{
|
|
$groupCounter++;
|
|
$caption=$this->_group['caption'][$name];
|
|
$newRowIndex=$firstRowFoundAt+$rowCounter*$rowsFound+$footerCount*$rowsFound+$groupCounter;
|
|
//insert header for the group
|
|
$this->objWorksheet->insertNewRowBefore($newRowIndex,1);
|
|
$this->objWorksheet->setCellValue($firstCol.$newRowIndex,$caption);
|
|
$this->objWorksheet->mergeCells($firstCol.$newRowIndex.":".$lastCol.$newRowIndex);
|
|
|
|
//add style for the header
|
|
|
|
$this->objWorksheet->getStyle($firstCol.$newRowIndex)->applyFromArray($this->_headerGroupStyleArray);
|
|
|
|
//add data for the group
|
|
foreach ($rows as $row)
|
|
{
|
|
$value=$data['data'][$row];
|
|
$rowCounter++;
|
|
$skip=$rowCounter*$rowsFound+$footerCount*$rowsFound+$groupCounter;
|
|
$newRowIndex=$firstRowFoundAt+$skip;
|
|
|
|
//insert one or more rows if needed
|
|
if($minRows<$rowCounter)
|
|
$this->objWorksheet->insertNewRowBefore($newRowIndex,$rowsFound);
|
|
|
|
//copy merge definitions
|
|
foreach($needMerge as $nm)
|
|
{
|
|
$nm=PHPExcel_Cell::rangeBoundaries($nm);
|
|
$newMerge=PHPExcel_Cell::stringFromColumnIndex($nm[0][0]-1).($nm[0][1]+$skip).":".PHPExcel_Cell::stringFromColumnIndex($nm[1][0]-1).($nm[1][1]+$skip);
|
|
|
|
$this->objWorksheet->mergeCells($newMerge);
|
|
}
|
|
|
|
//generate row of data
|
|
$this->generateSingleRepeatingRow($value, $repeatTemplateArray, $rowCounter, $skip, $data['id'], $data['format'], $data['step']);
|
|
}
|
|
|
|
//include the footer if defined
|
|
if(isset($this->_group['summary']) && isset($this->_group['summary'][$name]))
|
|
{
|
|
$footerCount++;
|
|
$skip=$groupCounter+$rowCounter*$rowsFound+$footerCount*$rowsFound;
|
|
$newRowIndex=$firstRowFoundAt+$skip;
|
|
|
|
$this->objWorksheet->insertNewRowBefore($newRowIndex,$rowsFound);
|
|
$this->generateSingleRepeatingRow($this->_group['summary'][$name], $repeatTemplateArray, '', $skip, $data['id'], $data['format'], $data['step']);
|
|
//add style for the footer
|
|
|
|
$this->objWorksheet->getStyle($firstCol.$newRowIndex.":".$lastCol.$newRowIndex)->applyFromArray($this->_footerGroupStyleArray);
|
|
}
|
|
|
|
//remove merge on template, BUG fix
|
|
foreach($needMerge as $nm)
|
|
{
|
|
$this->objWorksheet->unmergeCells($nm);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates single row for repeating data
|
|
* @param array $value
|
|
* @param array $repeatTemplateArray
|
|
* @param int $rowCounter
|
|
* @param int $skip
|
|
* @param string $id
|
|
* @param array $format
|
|
* @param int $step
|
|
*/
|
|
private function generateSingleRepeatingRow(& $value, & $repeatTemplateArray, $rowCounter, $skip, $id, $format, $step)
|
|
{
|
|
foreach($repeatTemplateArray as $rowKey=>$rowData)
|
|
{
|
|
foreach($rowData as $col=>$tag)
|
|
{
|
|
//$col is like A, B, C, ...
|
|
//$rowKey is like 9,10,11, ...
|
|
//$tag can have many replacement tags, e.g. "{item:item_id} --- {item:item_code}"
|
|
|
|
if(preg_match_all("/\{".$id.":(\w*|#\+?-?(\d*)?)\}/", $tag, $matches))
|
|
{
|
|
$matchTags=$matches[0]; //array with complete tags, e.g. '{item:item_id}'
|
|
$matchKeys=$matches[1]; //array with only the key names, e.g. 'item_id'
|
|
$matchNumber=count($matchTags); //how many replacement tags is there in this cell
|
|
$replaceTags=array();
|
|
$replaceValues=array();
|
|
foreach($matchKeys as $mkey)
|
|
{
|
|
$replaceTags[]="{".$id.":".$mkey."}";
|
|
if(strpos($mkey, "#")===0)
|
|
{
|
|
//this is a counter (optional offset)
|
|
$offset=explode("+", $mkey);
|
|
if(count($offset)>1)
|
|
$offset=$offset[1];
|
|
else
|
|
$offset=0;
|
|
|
|
$rValue=($rowCounter-1)*$step+1+(int)$offset;
|
|
}
|
|
elseif(key_exists($mkey, $value))
|
|
{
|
|
//format if needed
|
|
if(isset($format) && isset($format[$mkey]))
|
|
{
|
|
foreach($format[$mkey] as $ftype=>$f)
|
|
{
|
|
$rValue=$this->formatValue($value[$mkey],$ftype,$f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//without additional formating
|
|
$rValue=$value[$mkey];
|
|
}
|
|
}
|
|
else
|
|
$rValue=$mkey;
|
|
|
|
//add to replace array
|
|
$replaceValues[]=$rValue;
|
|
}
|
|
//replace all the values in this cell
|
|
$tag=str_replace($replaceTags,$replaceValues,$tag);
|
|
}
|
|
$newCellAddress=$col.($rowKey+$skip);
|
|
$this->objWorksheet->setCellValue($newCellAddress,$tag);
|
|
|
|
//copy cell styles
|
|
$xfIndex=$this->objWorksheet->getCell($col.$rowKey)->getXfIndex();
|
|
$this->objWorksheet->getCell($newCellAddress)->setXfIndex($xfIndex);
|
|
|
|
//strip rows if requested
|
|
if($this->_useStripRows && $rowCounter%2)
|
|
{
|
|
$this->objWorksheet->getStyle($newCellAddress)->getFill()->setFillType(PHPExcel_Style_Fill::FILL_SOLID);
|
|
$this->objWorksheet->getStyle($newCellAddress)->getFill()->getStartColor()->setRGB('F2F2F2');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Check and apply various formating
|
|
*/
|
|
/**
|
|
* Applies various formatings
|
|
* Type can be datetime or number
|
|
* @param mixed $value
|
|
* @param string $type
|
|
* @param mixed $format
|
|
*/
|
|
protected function formatValue($value,$type,$format)
|
|
{
|
|
if($type=='datetime')
|
|
{
|
|
//format can only be string
|
|
if(is_string($format))
|
|
$value=date($format, strtotime($value));
|
|
}
|
|
elseif($type=='number')
|
|
{
|
|
//format must be an array
|
|
if(is_array($format))
|
|
{
|
|
//set the defaults
|
|
if(!isset($format['prefix']))
|
|
$format['prefix']='';
|
|
if(!isset($format['decimals']))
|
|
$format['decimals']=0;
|
|
if(!isset($format['decPoint']))
|
|
$format['decPoint']='.';
|
|
if(!isset($format['thousandsSep']))
|
|
$format['thousandsSep']=',';
|
|
if(!isset($format['sufix']))
|
|
$format['sufix']='';
|
|
$value=$format['prefix'].number_format($value,$format['decimals'],$format['decPoint'],$format['thousandsSep']).$format['sufix'];
|
|
}
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Replaces all the cells with real data
|
|
*/
|
|
private function searchAndReplace()
|
|
{
|
|
foreach ($this->objWorksheet->getRowIterator() as $row)
|
|
{
|
|
$cellIterator = $row->getCellIterator();
|
|
foreach ($cellIterator as $cell)
|
|
{
|
|
$cell->setValue(str_replace($this->_search, $this->_replace, $cell->getValue()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adda a row for repeating data when there is no results
|
|
* @param int $rowIndex
|
|
* @param string $colMin
|
|
* @param string $colMax
|
|
*/
|
|
private function addNoResultRow($rowIndex,$colMin,$colMax)
|
|
{
|
|
//insert one row
|
|
$this->objWorksheet->insertNewRowBefore($rowIndex);
|
|
|
|
//merge as required
|
|
$this->objWorksheet->mergeCells($colMin.$rowIndex.":".$colMax.$rowIndex);
|
|
|
|
//insert text
|
|
|
|
$this->objWorksheet->setCellValue($colMin.$rowIndex, $this->_noResultText);
|
|
|
|
$this->objWorksheet->getStyle($colMin.$rowIndex.":".$colMax.$rowIndex)->applyFromArray($this->_noResultStyleArray);
|
|
}
|
|
|
|
/**
|
|
* Generates heading title of the report
|
|
*/
|
|
private function generateHeading()
|
|
{
|
|
//get current dimensions
|
|
$highestRow = $this->objWorksheet->getHighestRow(); // e.g. 10
|
|
$highestColumn = $this->objWorksheet->getHighestColumn(); // e.g 'F'
|
|
|
|
$highestColumnIndex = PHPExcel_Cell::columnIndexFromString($highestColumn);
|
|
|
|
//insert row on top
|
|
$this->objWorksheet->insertNewRowBefore(1,2);
|
|
|
|
//merge cells
|
|
$this->objWorksheet->mergeCells("A1:".$highestColumn."1");
|
|
|
|
//set the text for header
|
|
$this->objWorksheet->setCellValue("A1", $this->_headingText);
|
|
$this->objWorksheet->getStyle('A1')->getAlignment()->setWrapText(true);
|
|
$this->objWorksheet->getRowDimension('1')->setRowHeight(48);
|
|
|
|
//Apply style
|
|
$this->objWorksheet->getStyle("A1")->applyFromArray($this->_headingStyleArray);
|
|
}
|
|
|
|
/**
|
|
* Renders report as specified output file
|
|
* @param string $type
|
|
* @param string $filename
|
|
*/
|
|
public function render($type='html',$filename='')
|
|
{
|
|
//create or generate report
|
|
if($this->_usingTemplate)
|
|
$this->generateReport();
|
|
else
|
|
$this->createReport();
|
|
|
|
if($type=='')
|
|
$type="html";
|
|
|
|
if($filename=='')
|
|
$filename="Report ".date("Y-m-d");
|
|
else
|
|
$filename=strftime($filename);
|
|
//http://strftime.net/
|
|
|
|
|
|
if(strtolower($type)=='html')
|
|
return $this->renderHtml();
|
|
elseif(strtolower($type)=='excel')
|
|
return $this->renderXlsx($filename);
|
|
elseif(strtolower($type)=='excel2003')
|
|
return $this->renderXls($filename);
|
|
elseif(strtolower($type)=='pdf')
|
|
return $this->renderPdf($filename);
|
|
else
|
|
return "Error: unsupported export type!"; //TODO: better error handling
|
|
}
|
|
|
|
/**
|
|
* Renders report as a HTML output
|
|
*/
|
|
private function renderHtml()
|
|
{
|
|
$this->objWriter = new PHPExcel_Writer_HTML($this->objPHPExcel);
|
|
|
|
// Generate HTML
|
|
$html = '';
|
|
$html .= $this->objWriter->generateHTMLHeader(true);
|
|
$html .= $this->objWriter->generateSheetData();
|
|
$html .= $this->objWriter->generateHTMLFooter();
|
|
$html .= '';
|
|
$this->objPHPExcel->disconnectWorkSheets();
|
|
unset($this->objWriter);
|
|
unset($this->objWorksheet);
|
|
unset($this->objReader);
|
|
unset($this->objPHPExcel);
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Renders report as a XLSX file
|
|
*/
|
|
private function renderXlsx($filename)
|
|
{
|
|
header('Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
|
|
header('Content-Disposition: attachment;filename="'.$filename.'.xlsx"');
|
|
header('Cache-Control: max-age=0');
|
|
|
|
$this->objWriter = PHPExcel_IOFactory::createWriter($this->objPHPExcel, 'Excel2007');
|
|
|
|
$this->objWriter->save('php://output');
|
|
unset($this->objWriter);
|
|
unset($this->objWorksheet);
|
|
unset($this->objReader);
|
|
unset($this->objPHPExcel);
|
|
exit();
|
|
}
|
|
|
|
/**
|
|
* Renders report as a XLS file
|
|
*/
|
|
private function renderXls($filename)
|
|
{
|
|
header('Content-Type: application/vnd.ms-excel');
|
|
header('Content-Disposition: attachment;filename="'.$filename.'.xls"');
|
|
header('Cache-Control: max-age=0');
|
|
|
|
$this->objWriter = PHPExcel_IOFactory::createWriter($this->objPHPExcel, 'Excel5');
|
|
|
|
$this->objWriter->save('php://output');
|
|
unset($this->objWriter);
|
|
unset($this->objWorksheet);
|
|
unset($this->objReader);
|
|
unset($this->objPHPExcel);
|
|
exit();
|
|
}
|
|
|
|
/**
|
|
* Renders report as a PDF file
|
|
*/
|
|
private function renderPdf($filename)
|
|
{
|
|
header('Content-Type: application/vnd.pdf');
|
|
header('Content-Disposition: attachment;filename="'.$filename.'.pdf"');
|
|
header('Cache-Control: max-age=0');
|
|
|
|
$this->objWriter = PHPExcel_IOFactory::createWriter($this->objPHPExcel, 'PDF');
|
|
|
|
$this->objWriter->save('php://output');
|
|
exit();
|
|
}
|
|
|
|
/**
|
|
* Helper function for checking subranges of a range
|
|
*/
|
|
public function isSubrange($subRange,$range)
|
|
{
|
|
list($rangeStart,$rangeEnd) = PHPExcel_Cell::rangeBoundaries($range);
|
|
list($subrangeStart,$subrangeEnd) = PHPExcel_Cell::rangeBoundaries($subRange);
|
|
return (($subrangeStart[0]>=$rangeStart[0]) && ($subrangeStart[1]>=$rangeStart[1]) && ($subrangeEnd[0]<=$rangeEnd[0]) && ($subrangeEnd[1]<=$rangeEnd[1]));
|
|
}
|
|
|
|
/**
|
|
* Enabling strip rows
|
|
*/
|
|
function enableStripRows()
|
|
{
|
|
$this->_useStripRows=true;
|
|
}
|
|
|
|
/**
|
|
* Sets title of the report header
|
|
*/
|
|
function setHeading($h)
|
|
{
|
|
$this->_headingText=$h;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* converts pixels to excel units
|
|
* @param float $p
|
|
* @return float
|
|
*/
|
|
function pixel2unit($p)
|
|
{
|
|
return ($p-5)/7;
|
|
}
|