1184 lines
34 KiB
PHP
1184 lines
34 KiB
PHP
<?php
|
|
/*********************************************************************************
|
|
*
|
|
* TimeTrex is a Workforce Management program developed by
|
|
* TimeTrex Software Inc. Copyright (C) 2003 - 2021 TimeTrex Software Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU Affero General Public License version 3 as published by
|
|
* the Free Software Foundation with the addition of the following permission
|
|
* added to Section 15 as permitted in Section 7(a): FOR ANY PART OF THE COVERED
|
|
* WORK IN WHICH THE COPYRIGHT IS OWNED BY TIMETREX, TIMETREX DISCLAIMS THE
|
|
* WARRANTY OF NON INFRINGEMENT OF THIRD PARTY RIGHTS.
|
|
*
|
|
* This program 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 Affero General Public License for more
|
|
* details.
|
|
*
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License along
|
|
* with this program; if not, see http://www.gnu.org/licenses or write to the Free
|
|
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA.
|
|
*
|
|
*
|
|
* You can contact TimeTrex headquarters at Unit 22 - 2475 Dobbin Rd. Suite
|
|
* #292 West Kelowna, BC V4T 2E9, Canada or at email address info@timetrex.com.
|
|
*
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of this program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU Affero General Public License version 3.
|
|
*
|
|
*
|
|
* In accordance with Section 7(b) of the GNU Affero General Public License
|
|
* version 3, these Appropriate Legal Notices must retain the display of the
|
|
* "Powered by TimeTrex" logo. If the display of the logo is not reasonably
|
|
* feasible for technical reasons, the Appropriate Legal Notices must display
|
|
* the words "Powered by TimeTrex".
|
|
*
|
|
********************************************************************************/
|
|
|
|
|
|
/**
|
|
* @package GovernmentForms
|
|
*/
|
|
class GovernmentForms_Base {
|
|
|
|
public $debug = false;
|
|
public $metadata = null; //Metadata about the form itself, such as the
|
|
public $original_data = null; //Original object data before any record processing has been performed. So we can revert back to a "clean" state at any point.
|
|
public $data = null; //Form data is stored here in an array.
|
|
public $records = []; //Store multiple records here to process on a single form. ie: T4's where two employees can be on a single page.
|
|
public $records_total = []; //Total for all records.
|
|
private $messages = []; //Messages/warnings to user
|
|
|
|
public $class_directory = null;
|
|
|
|
/*
|
|
* XML related variables
|
|
*/
|
|
public $xml_object = null; //Prevent __set() from sticking this into the data property.
|
|
|
|
/*
|
|
* PDF related variables
|
|
*/
|
|
public $pdf_object = null; //Prevent __set() from sticking this into the data property.
|
|
public $template_index = [];
|
|
public $current_template_index = null;
|
|
|
|
public $page_margins = [ 0, 0 ]; //x, y - 43pt = 15mm Absolute margins that affect all drawing and templates.
|
|
public $page_offsets = [ 0, 0 ]; //x, y - Only affects drawing fields within the template.
|
|
public $template_offsets = [ 0, 0 ]; //x, y - Only affects placement of the template on the page.
|
|
|
|
public $temp_page_offsets = [ 0, 0 ]; //x, y - Only affects drawing and is reset based on page_offets above.
|
|
|
|
public $show_background = true; //Shows the PDF background
|
|
public $default_font = 'helvetica';
|
|
|
|
function __construct() {
|
|
$this->temp_page_offsets = $this->page_offsets; //Default temp page offets to whatever page offsets is originally set to.
|
|
|
|
return true;
|
|
}
|
|
|
|
function setDebug( $bool ) {
|
|
$this->debug = $bool;
|
|
}
|
|
|
|
function getDebug() {
|
|
return $this->debug;
|
|
}
|
|
|
|
function setClassDirectory( $dir ) {
|
|
$this->class_directory = $dir;
|
|
}
|
|
|
|
function getClassDirectory() {
|
|
return $this->class_directory;
|
|
}
|
|
|
|
function Output( $type, $clear_records = true ) {
|
|
$this->saveOriginDataState();
|
|
|
|
$this->calculate(); //Run all calculation functions prior to outputting anything.
|
|
switch ( strtolower( $type ) ) {
|
|
case 'pdf':
|
|
$retval = $this->_outputPDF( $type );
|
|
break;
|
|
case 'xml':
|
|
$retval = $this->_outputXML( $type );
|
|
break;
|
|
case 'efile':
|
|
$retval = $this->_outputEFILE( $type );
|
|
break;
|
|
default:
|
|
$retval = false;
|
|
break;
|
|
}
|
|
|
|
if ( $clear_records == true ) {
|
|
$this->clearRecords(); //This also calls revertToOriginalDataState()
|
|
} else {
|
|
$this->revertToOriginalDataState();
|
|
}
|
|
|
|
return $retval;
|
|
}
|
|
|
|
function saveOriginDataState() {
|
|
$this->original_data = $this->data;
|
|
|
|
return true;
|
|
}
|
|
|
|
function revertToOriginalDataState() {
|
|
if ( isset( $this->original_data ) ) {
|
|
if ( !defined( 'UNIT_TEST_MODE' ) || UNIT_TEST_MODE === false ) {
|
|
$this->data = $this->original_data;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function getRecords() {
|
|
return $this->records;
|
|
}
|
|
|
|
function setRecords( $data ) {
|
|
if ( is_array( $data ) ) {
|
|
foreach ( $data as $record ) {
|
|
$this->addRecord( $record ); //Make sure preCalc() is called for each record.
|
|
}
|
|
} else {
|
|
$this->records = $data;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function addRecord( $data ) {
|
|
//Filter functions should only be used for drawing the PDF, they do not modify the actual values themselves.
|
|
//preCalc functions should be used to modify the actual values themselves, prior to drawing on the PDF, as well prior to totalling.
|
|
//This is also important for calculating totals, so we can cap maximum contributions and such and get totals based on those properly.
|
|
//preCalc functions can modify any other value in the record as well.
|
|
if ( is_array( $data ) ) {
|
|
$template_schema = $this->getTemplateSchema();
|
|
if ( is_array( $template_schema ) ) {
|
|
foreach ( $data as $key => $value ) {
|
|
if ( isset( $template_schema[$key]['function']['precalc'] ) ) {
|
|
$filter_function = $template_schema[$key]['function']['precalc'];
|
|
if ( $filter_function != '' ) {
|
|
if ( !is_array( $filter_function ) ) {
|
|
$filter_function = (array)$filter_function;
|
|
}
|
|
|
|
foreach ( $filter_function as $function ) {
|
|
//Call function
|
|
if ( method_exists( $this, $function ) ) {
|
|
$value = $this->$function( $value, $key, $data );
|
|
}
|
|
}
|
|
unset( $function );
|
|
}
|
|
|
|
$data[$key] = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->records[] = $data;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function clearRecords() {
|
|
$this->records = [];
|
|
$this->revertToOriginalDataState();
|
|
}
|
|
|
|
function countRecords() {
|
|
return count( $this->records );
|
|
}
|
|
|
|
//Totals all the values for all the records.
|
|
function sumRecords() {
|
|
//Make sure we handle array elements with letters, so we can properly combine boxes with the same letters.
|
|
$this->records_total = Misc::ArrayAssocSum( $this->records, null, null, true );
|
|
|
|
return true;
|
|
}
|
|
|
|
function getRecordsTotal() {
|
|
return $this->records_total;
|
|
}
|
|
|
|
/**
|
|
* Serializes the object to an array for storing in the DB and later retrieval. Especially important for handling correction reports like W2C.
|
|
* @return false|string
|
|
*/
|
|
function serialize( $clear_records = true ) {
|
|
//Don't include $this->records here, as all the object properties from the records gets put into $this->data
|
|
$retval = [ 'metadata' => [ 'class' => get_class( $this ), 'object_data' => $this->metadata, 'tt_version' => APPLICATION_VERSION ], 'data' => $this->data, 'records' => $this->getRecords() ];
|
|
|
|
if ( $clear_records == true ) {
|
|
$this->clearRecords();
|
|
}
|
|
|
|
//*NOTE: This should not be serialized to JSON here, as we may need to allow other formats, so just return an array.
|
|
return $retval;
|
|
}
|
|
|
|
/**
|
|
* Unserializes a array into the form itself.
|
|
* @return false|string
|
|
*/
|
|
function unserialize( $data ) {
|
|
if ( is_array( $data ) && isset( $data['metadata'] ) ) {
|
|
$this->data = $data['data'];
|
|
$this->setRecords( $data['records'] );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param int $type_id 'note', 'warning', 'error'
|
|
* @param string $message
|
|
* @param array $field_notice_position [ 'page' => 1, 'x' => 0, 'y' => 0 ]
|
|
*/
|
|
function addMessage( $type_id, $message, $field_notice_position = [] ) {
|
|
$this->messages[$type_id][] = [ 'message' => $message, 'field_notice_position' => $field_notice_position ];
|
|
|
|
return true;
|
|
}
|
|
|
|
function getMessages() {
|
|
return $this->messages;
|
|
}
|
|
|
|
function clearMessages() {
|
|
$this->messages = [];
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Math functions
|
|
*
|
|
*/
|
|
function MoneyFormatPretty( $value ) {
|
|
if ( !is_numeric( $value ) ) {
|
|
return false;
|
|
}
|
|
|
|
return number_format( $value, 2, '.', ',' );
|
|
}
|
|
|
|
function MoneyFormat( $value ) {
|
|
if ( !is_numeric( $value ) ) {
|
|
return false;
|
|
}
|
|
|
|
return number_format( $value, 2, '.', '' );
|
|
}
|
|
|
|
function getBeforeDecimal( $float ) {
|
|
$float = $this->MoneyFormat( $float );
|
|
|
|
$float_array = preg_split( '/\./', $float );
|
|
|
|
if ( isset( $float_array[0] ) ) {
|
|
return $float_array[0];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function getAfterDecimal( $float, $format_number = true ) {
|
|
if ( $format_number == true ) {
|
|
$float = $this->MoneyFormat( $float );
|
|
}
|
|
|
|
$float_array = preg_split( '/\./', $float );
|
|
|
|
if ( isset( $float_array[1] ) ) {
|
|
return str_pad( $float_array[1], 2, '0' );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Need to use bcmath for large numbers, especially on 32bit PHP installs.
|
|
* @param $array
|
|
* @return int|string
|
|
*/
|
|
static function arraySum( $array ) {
|
|
$retval = 0;
|
|
foreach ( $array as $value ) {
|
|
$retval = bcadd( $retval, $value );
|
|
}
|
|
|
|
return $retval;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Date functions
|
|
*
|
|
*/
|
|
public function getYear( $epoch = null ) {
|
|
if ( $epoch == null ) {
|
|
$epoch = TTDate::getTime();
|
|
}
|
|
|
|
return date( 'Y', $epoch );
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Formatting functions
|
|
*
|
|
*/
|
|
public function formatSSN( $value ) {
|
|
if ( $value != '' ) {
|
|
$value = substr_replace( $value, '-', 3, 0 );
|
|
$value = substr_replace( $value, '-', 6, 0 );
|
|
|
|
return $value;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public function formatEIN( $value ) {
|
|
if ( $value != '' ) {
|
|
return substr_replace( $value, '-', 2, 0 );
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Validation functions
|
|
*
|
|
*/
|
|
function isNumeric( $value ) {
|
|
if ( is_numeric( $value ) ) {
|
|
return $value;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Filter functions
|
|
*
|
|
*/
|
|
function stripSpaces( $value ) {
|
|
return str_replace( ' ', '', trim( $value ) );
|
|
}
|
|
|
|
function stripNonNumeric( $value ) {
|
|
$retval = preg_replace( '/[^0-9]/', '', $value );
|
|
|
|
return $retval;
|
|
}
|
|
|
|
function stripNonAlphaNumeric( $value ) {
|
|
$retval = preg_replace( '/[^A-Za-z0-9\ ]/', '', $value ); //Don't strip spaces
|
|
|
|
return $retval;
|
|
}
|
|
|
|
function stripNonFloat( $value ) {
|
|
$retval = preg_replace( '/[^-0-9\.]/', '', $value );
|
|
|
|
return $retval;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* EFILE (Fixed Length) Helper functions
|
|
*
|
|
*/
|
|
function removeDecimal( $value ) {
|
|
$retval = str_replace( '.', '', number_format( $value, 2, '.', '' ) );
|
|
|
|
return $retval;
|
|
}
|
|
|
|
function padRecord( $value, $length, $type ) {
|
|
$type = strtolower( $type );
|
|
|
|
//Trim record incase its too long.
|
|
$value = substr( $value, 0, $length );
|
|
|
|
switch ( $type ) {
|
|
case 'n':
|
|
$retval = str_pad( $value, $length, 0, STR_PAD_LEFT );
|
|
break;
|
|
case 'an':
|
|
$retval = str_pad( $value, $length, ' ', STR_PAD_RIGHT );
|
|
break;
|
|
}
|
|
|
|
return $retval;
|
|
}
|
|
|
|
function padLine( $line, $length = false ) {
|
|
if ( $line == '' ) {
|
|
return false;
|
|
}
|
|
|
|
$retval = str_pad( $line, ( $length == false ) ? strlen( $line ) : $length, ' ', STR_PAD_RIGHT );
|
|
|
|
return $retval . "\r\n";
|
|
}
|
|
|
|
/*
|
|
*
|
|
* XML helper functions
|
|
*
|
|
*/
|
|
function setXMLObject( &$obj ) {
|
|
$this->xml_object = $obj;
|
|
|
|
return true;
|
|
}
|
|
|
|
function getXMLObject() {
|
|
return $this->xml_object;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* PDF helper functions
|
|
*
|
|
*/
|
|
function setPDFObject( &$obj ) {
|
|
$this->pdf_object = $obj;
|
|
|
|
return true;
|
|
}
|
|
|
|
function getPDFObject() {
|
|
return $this->pdf_object;
|
|
}
|
|
|
|
function setShowBackground( $bool ) {
|
|
$this->show_background = $bool;
|
|
|
|
return true;
|
|
}
|
|
|
|
function getShowBackground() {
|
|
return $this->show_background;
|
|
}
|
|
|
|
function setPageMargins( $x, $y ) {
|
|
$this->page_margins = [ $x, $y ];
|
|
|
|
return true;
|
|
}
|
|
|
|
function getPageMargins( $type = null ) {
|
|
switch ( strtolower( $type ) ) {
|
|
case 'x':
|
|
return $this->page_margins[0];
|
|
break;
|
|
case 'y':
|
|
return $this->page_margins[1];
|
|
break;
|
|
default:
|
|
return $this->page_margins;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function getCurrentPage() {
|
|
return $this->getPDFObject()->getPage();
|
|
}
|
|
|
|
function setTempPageOffsets( $x, $y ) {
|
|
$this->temp_page_offsets = [ $x, $y ];
|
|
|
|
return true;
|
|
}
|
|
|
|
function getTempPageOffsets( $type = null ) {
|
|
switch ( strtolower( $type ) ) {
|
|
case 'x':
|
|
return $this->temp_page_offsets[0];
|
|
break;
|
|
case 'y':
|
|
return $this->temp_page_offsets[1];
|
|
break;
|
|
default:
|
|
return $this->temp_page_offsets;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function setPageOffsets( $x, $y ) {
|
|
$this->page_offsets = [ $x, $y ];
|
|
|
|
$this->setTempPageOffsets( $x, $y ); //Update temp page offsets each time this is called.
|
|
|
|
return true;
|
|
}
|
|
|
|
function getPageOffsets( $type = null ) {
|
|
switch ( strtolower( $type ) ) {
|
|
case 'x':
|
|
return $this->page_offsets[0];
|
|
break;
|
|
case 'y':
|
|
return $this->page_offsets[1];
|
|
break;
|
|
default:
|
|
return $this->page_offsets;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function setTemplateOffsets( $x, $y ) {
|
|
$this->template_offsets = [ $x, $y ];
|
|
|
|
return true;
|
|
}
|
|
|
|
function getTemplateOffsets( $type = null ) {
|
|
switch ( strtolower( $type ) ) {
|
|
case 'x':
|
|
return $this->template_offsets[0];
|
|
break;
|
|
case 'y':
|
|
return $this->template_offsets[1];
|
|
break;
|
|
default:
|
|
return $this->template_offsets;
|
|
break;
|
|
}
|
|
}
|
|
|
|
function getTemplateDirectory() {
|
|
$dir = $this->getClassDirectory() . DIRECTORY_SEPARATOR . 'templates';
|
|
|
|
return $dir;
|
|
}
|
|
|
|
function getSchemaSpecificCoordinates( $schema, $key, $sub_key1 = null ) {
|
|
|
|
unset( $schema['function'] );
|
|
|
|
if ( $sub_key1 !== null ) {
|
|
if ( isset( $schema['coordinates'][$key][$sub_key1] ) ) {
|
|
return [ 'coordinates' => $schema['coordinates'][$key][$sub_key1] ];
|
|
}
|
|
} else {
|
|
if ( isset( $schema['coordinates'][$key] ) ) {
|
|
return [ 'coordinates' => $schema['coordinates'][$key], 'font' => ( isset( $schema['font'] ) ) ? $schema['font'] : [] ];
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//This gives the same affect of adding a new page on the next time Draw() is called.
|
|
//Can be used when multiple records are processed for a single form.
|
|
function resetTemplatePage() {
|
|
$this->current_template_index = null;
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw all digits before the decimal in the first location, and after the decimal in the second location.
|
|
function drawSplitDecimalFloat( $value, $schema ) {
|
|
if ( $value != 0 || isset( $schema['draw_zero_value'] ) && $schema['draw_zero_value'] == true ) {
|
|
$this->Draw( $this->getBeforeDecimal( $value ), $this->getSchemaSpecificCoordinates( $schema, 0 ) );
|
|
$this->Draw( $this->getAfterDecimal( $value ), $this->getSchemaSpecificCoordinates( $schema, 1 ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw each char/digit one at a time in different locations.
|
|
function drawChars( $value, $schema ) {
|
|
$value = (string)$value; //convert integer to string.
|
|
$max = strlen( $value );
|
|
for ( $i = 0; $i < $max; $i++ ) {
|
|
$this->Draw( $value[$i], $this->getSchemaSpecificCoordinates( $schema, $i ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
// Draw the same data at different locations
|
|
// value should be string
|
|
function drawPiecemeal( $value, $schema ) {
|
|
unset( $schema['function'] );
|
|
foreach ( $schema['coordinates'] as $key => $coordinates ) {
|
|
if ( is_array( $coordinates ) ) {
|
|
if ( isset( $schema['font'] ) ) {
|
|
$this->Draw( $value, [ 'coordinates' => $coordinates, 'font' => $schema['font'] ] );
|
|
} else {
|
|
$this->Draw( $value, [ 'coordinates' => $coordinates ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw each element of an array at different locations.
|
|
//Value must be an array.
|
|
function drawSegments( $value, $schema ) {
|
|
|
|
if ( is_array( $value ) ) {
|
|
$i = 0;
|
|
foreach ( $value as $segment ) {
|
|
$this->Draw( $segment, $this->getSchemaSpecificCoordinates( $schema, $i ) );
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw an normal values in a grid.
|
|
function drawNormalGrid( $value, $schema ) {
|
|
if ( !is_array( $value ) ) {
|
|
$value = (array)$value;
|
|
}
|
|
|
|
foreach ( $value as $key => $tmp_value ) {
|
|
|
|
if ( $tmp_value !== false ) {
|
|
//var_dump($tmp_value, $schema['coordinates'][$key] );
|
|
|
|
//$this->Draw( $this->getBeforeDecimal( $value ), array('coordinates' => $schema['coordinates'][$key][0] ) );
|
|
//var_dump( $this->getSchemaSpecificCoordinates( $schema, $key, 0 ) );
|
|
//$this->Draw( $this->getBeforeDecimal( $value ), $this->getSchemaSpecificCoordinates( $schema, $key, 0 ) );
|
|
|
|
if ( is_array( $tmp_value ) ) {
|
|
|
|
foreach ( $tmp_value as $value ) {
|
|
$this->drawNormal( $value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
} else {
|
|
$this->drawNormal( $tmp_value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
//$this->Draw( $tmp_value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw an split decimal values in a grid.
|
|
function drawSplitDecimalFloatGrid( $value, $schema ) {
|
|
if ( !is_array( $value ) ) {
|
|
$value = (array)$value;
|
|
}
|
|
|
|
foreach ( $value as $key => $tmp_value ) {
|
|
|
|
if ( $tmp_value !== false ) {
|
|
//var_dump($tmp_value, $schema['coordinates'][$key] );
|
|
|
|
//$this->Draw( $this->getBeforeDecimal( $value ), array('coordinates' => $schema['coordinates'][$key][0] ) );
|
|
//var_dump( $this->getSchemaSpecificCoordinates( $schema, $key, 0 ) );
|
|
//$this->Draw( $this->getBeforeDecimal( $value ), $this->getSchemaSpecificCoordinates( $schema, $key, 0 ) );
|
|
|
|
if ( is_array( $tmp_value ) ) {
|
|
|
|
foreach ( $tmp_value as $value ) {
|
|
$this->drawSplitDecimalFloat( $value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
} else {
|
|
$this->drawSplitDecimalFloat( $tmp_value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
//$this->Draw( $tmp_value, $this->getSchemaSpecificCoordinates( $schema, $key ) );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draw an X in each of the specified locations
|
|
//$value must be an array.
|
|
function drawCheckBox( $value, $schema ) {
|
|
$char = 'x';
|
|
|
|
if ( !is_array( $value ) ) {
|
|
$value = (array)$value;
|
|
}
|
|
|
|
foreach ( $value as $tmp_value ) {
|
|
//Skip any false values.
|
|
if ( $tmp_value === false ) {
|
|
continue;
|
|
}
|
|
|
|
if ( is_string( $tmp_value ) ) {
|
|
$tmp_value = strtolower( $tmp_value );
|
|
}
|
|
|
|
if ( is_bool( $tmp_value ) && $tmp_value == true ) {
|
|
$tmp_value = 0;
|
|
}
|
|
|
|
$this->Draw( $char, $this->getSchemaSpecificCoordinates( $schema, $tmp_value ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function drawNormal( $value, $schema ) {
|
|
if ( $value !== false ) { //If value is FALSE don't draw anything, this prevents a blank cell from being drawn overtop of other text.
|
|
unset( $schema['function'] ); //Strip off the function element to prevent infinite loop
|
|
$this->Draw( $value, $schema );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function drawGrid( $value, $schema ) {
|
|
|
|
unset( $schema['function'] );
|
|
|
|
if ( isset( $schema['grid'] ) ) {
|
|
$grid = $schema['grid'];
|
|
}
|
|
|
|
if ( is_array( $value ) ) {
|
|
|
|
if ( isset( $grid ) && is_array( $grid ) ) {
|
|
|
|
$top_left_x = $x = $grid['top_left_x'];
|
|
$top_left_y = $y = $grid['top_left_y'];
|
|
$h = $grid['h'];
|
|
$w = $grid['w'];
|
|
$step_x = $grid['step_x'];
|
|
$step_y = $grid['step_y'];
|
|
$col = $grid['column'];
|
|
|
|
$i = 1;
|
|
foreach ( $value as $val ) {
|
|
|
|
$coordinates = [
|
|
'x' => $x,
|
|
'y' => $y,
|
|
'h' => $h,
|
|
'w' => $w,
|
|
];
|
|
|
|
$schema['coordinates'] = array_merge( $schema['coordinates'], $coordinates );
|
|
|
|
$this->Draw( $val, $schema );
|
|
|
|
if ( $i > 0 && $i % $col == 0 ) {
|
|
$x = $top_left_x;
|
|
$y += $step_y;
|
|
} else {
|
|
$x += $step_x;
|
|
}
|
|
$i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
function drawMessageFieldNotice( $pdf, $i, $messages_arr ) {
|
|
if ( !isset( $messages_arr['field_notice_position']['x'] ) ) {
|
|
$messages_arr['field_notice_position']['x'] = 10;
|
|
}
|
|
if ( !isset( $messages_arr['field_notice_position']['y'] ) ) {
|
|
$messages_arr['field_notice_position']['y'] = 10;
|
|
}
|
|
if ( !isset( $messages_arr['field_notice_position']['w'] ) ) {
|
|
$messages_arr['field_notice_position']['w'] = 20;
|
|
}
|
|
if ( !isset( $messages_arr['field_notice_position']['h'] ) ) {
|
|
$messages_arr['field_notice_position']['h'] = 15;
|
|
}
|
|
if ( !isset( $messages_arr['field_notice_position']['page'] ) ) {
|
|
$messages_arr['field_notice_position']['page'] = 1;
|
|
}
|
|
|
|
$current_page = $pdf->getPage();
|
|
$current_x = $pdf->getX();
|
|
$current_y = $pdf->getY();
|
|
|
|
$pdf->setPage( $messages_arr['field_notice_position']['page'] );
|
|
|
|
$pdf->SetFont( '', 'B', 10 );
|
|
$pdf->setXY( ( $messages_arr['field_notice_position']['x'] + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), ( $messages_arr['field_notice_position']['y'] + $this->getTempPageOffsets( 'y' ) + $this->getPageMargins( 'y' ) ) );
|
|
$pdf->Cell( $messages_arr['field_notice_position']['w'], $messages_arr['field_notice_position']['h'], '['. $i .']', 0 );
|
|
|
|
$pdf->setPage( $current_page );
|
|
$pdf->setXY( $current_x, $current_y );
|
|
|
|
return true;
|
|
}
|
|
|
|
//Draws messages, warnings and errors.
|
|
function drawMessages() {
|
|
$messages = $this->getMessages();
|
|
if ( is_array( $messages ) && !empty( $messages ) ) {
|
|
$pdf = $this->getPDFObject();
|
|
|
|
$pdf->AddPage();
|
|
|
|
$current_page = $pdf->getPage();
|
|
|
|
$pdf->setTextColor( 255, 0, 0 );
|
|
|
|
$cell_width = 570;
|
|
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), ( 20 + $this->getTempPageOffsets( 'y' ) + $this->getPageMargins( 'y' ) ) );
|
|
|
|
$i = 'A'; //Subscript to reference each message. Should be letters rather than numbers so they don't get mixed up when printed on the form.
|
|
if ( isset( $messages['error'] ) ) {
|
|
$pdf->SetFont( '', 'B', 32 );
|
|
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->Cell( $cell_width, 10, TTi18n::getText( 'ERROR' ), 0, 1, 'C', 1, false, 1 );
|
|
|
|
$pdf->SetFont( '', '', 12 );
|
|
|
|
foreach ( $messages['error'] as $message_arr ) {
|
|
$message = $i .'. '. $message_arr['message'];
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->MultiCell( $cell_width, $pdf->getNumLines( $message, $cell_width ), $message, 0, 'L' );
|
|
|
|
if ( isset( $message_arr['field_notice_position'] ) && is_array( $message_arr['field_notice_position'] ) ) {
|
|
$this->drawMessageFieldNotice( $pdf, $i, $message_arr );
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
|
|
$pdf->Ln();
|
|
}
|
|
|
|
if ( isset( $messages['warning'] ) ) {
|
|
$pdf->SetFont( '', 'B', 32 );
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->Cell( $cell_width, 10, TTi18n::getText( 'WARNING' ), 0, 1, 'C', 1, false, 1 );
|
|
|
|
$pdf->SetFont( '', '', 12 );
|
|
foreach ( $messages['warning'] as $message_arr ) {
|
|
$message = $i .'. '. $message_arr['message'];
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->MultiCell( $cell_width, $pdf->getNumLines( $message, $cell_width ), $message, 0, 'L' );
|
|
|
|
if ( isset( $message_arr['field_notice_position'] ) && is_array( $message_arr['field_notice_position'] ) ) {
|
|
$this->drawMessageFieldNotice( $pdf, $i, $message_arr );
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
|
|
$pdf->Ln();
|
|
}
|
|
|
|
if ( isset( $messages['note'] ) ) {
|
|
$pdf->setTextColor( 0, 0, 0 );
|
|
|
|
$pdf->SetFont( '', 'B', 32 );
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->Cell( $cell_width, 10, TTi18n::getText( 'NOTE' ), 0, 1, 'C', 1, false, 1 );
|
|
|
|
$pdf->SetFont( '', '', 12 );
|
|
foreach ( $messages['note'] as $message_arr ) {
|
|
$message = $i .'. '. $message_arr['message'];
|
|
$pdf->setXY( ( 20 + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), $pdf->getY() );
|
|
$pdf->MultiCell( $cell_width, $pdf->getNumLines( $message, $cell_width ), $message, 0, 'L' );
|
|
|
|
if ( isset( $message_arr['field_notice_position'] ) && is_array( $message_arr['field_notice_position'] ) ) {
|
|
$this->drawMessageFieldNotice( $pdf, $i, $message_arr );
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
}
|
|
|
|
$pdf->setPage( $current_page );
|
|
|
|
$pdf->movePage( $current_page, 1 ); //Move messages page to the beginning now that its been generated.
|
|
|
|
//Clear messages after they are drawn, so more can be added for the next page/employee?
|
|
$this->clearMessages();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function addPage( $schema = null ) {
|
|
$pdf = $this->getPDFObject();
|
|
|
|
$pdf->AddPage();
|
|
if ( $this->getShowBackground() == true && isset( $this->template_index[$schema['template_page']] ) ) {
|
|
if ( isset( $schema['combine_templates'] ) && is_array( $schema['combine_templates'] ) ) {
|
|
$template_schema = $this->getTemplateSchema();
|
|
|
|
//Handle combining multiple template together with a X,Y offset.
|
|
foreach ( $schema['combine_templates'] as $combine_template ) {
|
|
//Debug::text('Combining Template Pages... Template: '. $combine_template['template_page'] .' Y: '. $combine_template['y'], __FILE__, __LINE__, __METHOD__, 10);
|
|
$pdf->useTemplate( $this->template_index[$combine_template['template_page']], ( $combine_template['x'] + $this->getTemplateOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), ( $combine_template['y'] + $this->getTemplateOffsets( 'y' ) + $this->getPageMargins( 'y' ) ) );
|
|
|
|
$this->setTempPageOffsets( ( $combine_template['x'] + $this->getPageOffsets( 'x' ) ), ( $combine_template['y'] + $this->getPageOffsets( 'y' ) ) );
|
|
$this->current_template_index = $combine_template['template_page'];
|
|
|
|
//For things like W2 instruction templates at the bottom half of the page, allow the initPage() function to be disabled for the template.
|
|
if ( !isset( $combine_template['init'] ) || ( isset( $combine_template['init'] ) && $combine_template['init'] == true ) ) {
|
|
$this->initPage( $template_schema );
|
|
}
|
|
}
|
|
unset( $combine_templates );
|
|
$this->setTempPageOffsets( $this->getPageOffsets( 'x' ), $this->getPageOffsets( 'y' ) ); //Reset page offsets after each template is initialized.
|
|
} else {
|
|
$pdf->useTemplate( $this->template_index[$schema['template_page']], ( $this->getTemplateOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), ( $this->getTemplateOffsets( 'y' ) + $this->getPageMargins( 'y' ) ) );
|
|
}
|
|
}
|
|
$this->current_template_index = $schema['template_page'];
|
|
|
|
return true;
|
|
}
|
|
|
|
function initPage( $template_schema ) {
|
|
if ( is_array( $template_schema ) ) {
|
|
foreach ( $template_schema as $field => $init_schema ) {
|
|
if ( is_numeric( $field ) ) {
|
|
//Debug::text(' Initializing Template Page... Field: '. $field, __FILE__, __LINE__, __METHOD__, 10);
|
|
$this->Draw( $this->$field, $init_schema );
|
|
}
|
|
}
|
|
unset( $template_schema, $field, $init_schema );
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//Run all calculate functions on their own.
|
|
// This separates calculating values from the drawing process, so we can easily pull out calculated values before anything is drawn, as other forms may need that data.
|
|
function calculate() {
|
|
//Get location map, start looping over each variable and drawing
|
|
$template_schema = ( method_exists( $this, 'getTemplateSchema') ) ? $this->getTemplateSchema() : false;
|
|
if ( is_array( $template_schema ) ) {
|
|
foreach ( $template_schema as $field => $schema ) {
|
|
//If custom function is defined, pass off to that immediate.
|
|
//Else, try the generic drawing method.
|
|
if ( isset( $schema['function']['calc'] ) ) {
|
|
if ( !is_array( $schema['function']['calc'] ) ) {
|
|
$schema['function']['calc'] = (array)$schema['function']['calc'];
|
|
}
|
|
foreach ( $schema['function']['calc'] as $function ) {
|
|
if ( method_exists( $this, $function ) ) {
|
|
if ( !isset( $template_schema[$field]['value'] ) ) {
|
|
//$template_schema[$field]['value'] = ( isset( $this->{$field} ) ? $this->{$field} : null ); //This passes in the field value, which the calculate function can get on its own without a problem.
|
|
$template_schema[$field]['value'] = null;
|
|
}
|
|
$template_schema[$field]['value'] = $this->$function( $template_schema[$field]['value'], $schema );
|
|
}
|
|
}
|
|
unset( $function );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Generic draw function that works strictly off the coordinate map.
|
|
//It checks for a variable specific function before running though, so we can handle more complex
|
|
//drawing functionality.
|
|
function Draw( $value, $schema ) {
|
|
if ( !is_array( $schema ) ) {
|
|
return false;
|
|
}
|
|
|
|
//If its set, use the static value from the schema.
|
|
if ( isset( $schema['value'] ) ) {
|
|
$value = $schema['value'];
|
|
unset( $schema['value'] );
|
|
}
|
|
|
|
//If custom function is defined, pass off to that immediate.
|
|
//Else, try the generic drawing method.
|
|
if ( isset( $schema['function']['draw'] ) ) {
|
|
if ( !is_array( $schema['function']['draw'] ) ) {
|
|
$schema['function']['draw'] = (array)$schema['function']['draw'];
|
|
}
|
|
foreach ( $schema['function']['draw'] as $function ) {
|
|
if ( method_exists( $this, $function ) ) {
|
|
$value = $this->$function( $value, $schema );
|
|
}
|
|
}
|
|
unset( $function );
|
|
|
|
return $value;
|
|
}
|
|
|
|
$pdf = $this->getPDFObject();
|
|
|
|
//Make sure we don't load the same template more than once.
|
|
if ( isset( $schema['template_page'] ) && $schema['template_page'] != $this->current_template_index ) {
|
|
//Debug::text('Adding new page: '. $schema .' Template Page: '. $schema['template_page'], __FILE__, __LINE__, __METHOD__, 10);
|
|
$this->addPage( $schema );
|
|
} else {
|
|
//Debug::text('Skipping template... Value: '. $value, __FILE__, __LINE__, __METHOD__, 10);
|
|
}
|
|
|
|
//If only_template_page is set, then only draw when we are on that template.
|
|
if ( isset( $schema['only_template_page'] ) && ( ( is_array( $schema['only_template_page'] ) && !in_array( $this->current_template_index, $schema['only_template_page'] ) ) || ( !is_array( $schema['only_template_page'] ) && $schema['only_template_page'] != $this->current_template_index ) ) ) {
|
|
//Debug::text('Skipping template based on filter... Value: '. $value, __FILE__, __LINE__, __METHOD__, 10);
|
|
return false;
|
|
}
|
|
|
|
//on_background flag forces that item to only be shown if the background is as well.
|
|
//This has to go below any addPage() call, otherwise pages won't be added if the first cell is only to be shown on the background.
|
|
if ( isset( $schema['on_background'] ) && $schema['on_background'] == true && $this->getShowBackground() == false ) {
|
|
return false;
|
|
}
|
|
|
|
if ( isset( $schema['font'] ) ) {
|
|
if ( !isset( $schema['font']['font'] ) ) {
|
|
$schema['font']['font'] = $this->default_font;
|
|
}
|
|
if ( !isset( $schema['font']['type'] ) ) {
|
|
$schema['font']['type'] = '';
|
|
}
|
|
if ( !isset( $schema['font']['size'] ) ) {
|
|
$schema['font']['size'] = 8;
|
|
}
|
|
|
|
$pdf->SetFont( $schema['font']['font'], $schema['font']['type'], $schema['font']['size'] );
|
|
} else {
|
|
$pdf->SetFont( $this->default_font, '', 8 );
|
|
}
|
|
|
|
if ( isset( $schema['coordinates'] ) ) {
|
|
$coordinates = $schema['coordinates'];
|
|
//var_dump( Debug::BackTrace() );
|
|
|
|
if ( isset( $coordinates['text_color'] ) && is_array( $coordinates['text_color'] ) ) {
|
|
$pdf->setTextColor( $coordinates['text_color'][0], $coordinates['text_color'][1], $coordinates['text_color'][2] );
|
|
} else {
|
|
$pdf->setTextColor( 0, 0, 0 ); //Black text.
|
|
}
|
|
|
|
if ( isset( $coordinates['fill_color'] ) && is_array( $coordinates['fill_color'] ) ) {
|
|
$pdf->setFillColor( $coordinates['fill_color'][0], $coordinates['fill_color'][1], $coordinates['fill_color'][2] );
|
|
$coordinates['fill'] = 1;
|
|
} else {
|
|
$pdf->setFillColor( 255, 255, 255 ); //White
|
|
$coordinates['fill'] = 0;
|
|
}
|
|
|
|
$pdf->setXY( ( $coordinates['x'] + $this->getTempPageOffsets( 'x' ) + $this->getPageMargins( 'x' ) ), ( $coordinates['y'] + $this->getTempPageOffsets( 'y' ) + $this->getPageMargins( 'y' ) ) );
|
|
|
|
if ( $this->getDebug() == true ) {
|
|
$pdf->setDrawColor( 0, 0, 255 );
|
|
$coordinates['border'] = 1;
|
|
} else {
|
|
if ( !isset( $coordinates['border'] ) ) {
|
|
$coordinates['border'] = 0;
|
|
}
|
|
}
|
|
|
|
if ( isset( $schema['multicell'] ) && $schema['multicell'] == true ) {
|
|
//Debug::text('Drawing MultiCell... Value: '. $value, __FILE__, __LINE__, __METHOD__, 10);
|
|
$pdf->MultiCell( $coordinates['w'], $coordinates['h'], $value, $coordinates['border'], strtoupper( $coordinates['halign'] ), $coordinates['fill'] );
|
|
} else {
|
|
//Debug::text('Drawing Cell... Value: '. $value, __FILE__, __LINE__, __METHOD__, 10);
|
|
$pdf->Cell( $coordinates['w'], $coordinates['h'], $value, $coordinates['border'], 0, strtoupper( $coordinates['halign'] ), $coordinates['fill'], false, 1 );
|
|
}
|
|
unset( $coordinates );
|
|
} else {
|
|
Debug::text( 'NOT Drawing Cell... Value: ' . $value, __FILE__, __LINE__, __METHOD__, 10 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//Make sure we pass *ALL* data to this function, as it will overwrite existing data, but if one record has a field and another one doesn't,
|
|
//we need to send blank fields so the data is overwritten correctly.
|
|
function arrayToObject( $array ) {
|
|
if ( is_array( $array ) ) {
|
|
foreach ( $array as $key => $value ) {
|
|
$this->$key = $value;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Magic functions.
|
|
*
|
|
*/
|
|
function __set( $name, $value ) {
|
|
$template_schema = ( method_exists( $this, 'getTemplateSchema') ) ? $this->getTemplateSchema() : false;
|
|
if ( is_array( $template_schema ) && isset( $template_schema[$name]['function']['prefilter'] ) ) {
|
|
$filter_function = $template_schema[$name]['function']['prefilter'];
|
|
if ( $filter_function != '' ) {
|
|
if ( !is_array( $filter_function ) ) {
|
|
$filter_function = (array)$filter_function;
|
|
}
|
|
|
|
foreach ( $filter_function as $function ) {
|
|
//Call function
|
|
if ( method_exists( $this, $function ) ) {
|
|
$value = $this->$function( $value );
|
|
|
|
if ( $value === false ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
unset( $function );
|
|
}
|
|
}
|
|
|
|
$this->data[$name] = $value;
|
|
|
|
return true;
|
|
}
|
|
|
|
function __get( $name ) {
|
|
if ( isset( $this->data[$name] ) ) {
|
|
return $this->data[$name];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public function __isset( $name ) {
|
|
return isset( $this->data[$name] );
|
|
}
|
|
|
|
public function __unset( $name ) {
|
|
unset( $this->data[$name] );
|
|
}
|
|
}
|
|
|
|
?>
|