<?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 Modules\SystemJobQueue
 */
class SystemJobQueueFactory extends Factory {
	protected $table = 'system_job_queue';

	public $user_obj = null;
	public $background_process_obj = null;

	/**
	 * @param $name
	 * @param array $parent
	 * @return array|bool|null
	 */
	function _getFactoryOptions( $name, $parent = null ) {
		$retval = null;
		switch ( $name ) {
			case 'status':
				//If these are changed, also change SystemJobQueueListFactory->getBatchStatus()
				$retval = [
						10 => TTi18n::gettext( 'Pending' ),
						20 => TTi18n::gettext( 'Running' ),
						50 => TTi18n::gettext( 'Failed' ),
						100 => TTi18n::gettext( 'Completed' ),
				];
				break;
			case 'columns':
				$retval = [
						'-1202-name'           => TTi18n::gettext( 'Name' ),
						'-1230-priority'       => TTi18n::gettext( 'Priority' ),
						'-2010-effective_date' => TTi18n::gettext( 'Date' ),
				];
				break;
			case 'list_columns':
				$retval = Misc::arrayIntersectByKey( $this->getOptions( 'default_display_columns' ), Misc::trimSortPrefix( $this->getOptions( 'columns' ) ) );
				break;
			case 'default_display_columns': //Columns that are displayed by default.
				$retval = [
						'name',
						'priority',
						'effective_date',
				];
				break;
		}

		return $retval;
	}

	/**
	 * @param $data
	 * @return array
	 */
	function _getVariableToFunctionMap( $data ) {
		$variable_function_map = [
				'id'                => 'ID',
				'batch_id'          => 'Batch',
				'status_id'         => 'Status',
				'priority'          => 'Priority',
				'name'              => 'Name',
				'user_id'           => 'User',
				'effective_date'    => 'EffectiveDate',
				'created_date'      => 'CreatedDate',
				'run_date'          => 'RunDate',
				'completed_date'    => 'CompletedDate',
				'retry_attempt'     => 'RetryAttempt',
				'retry_max_attempt' => 'RetryMaxAttempt',
				'class'             => 'Class',
				'method'            => 'Method',
				'arguments'         => 'Arguments',
				'extra_data'        => 'ExtraData',
				'return_data'       => 'ReturnData',
		];

		return $variable_function_map;
	}

	/**
	 * @return bool|mixed
	 */
	function getBatch() {
		return $this->getGenericDataValue( 'batch_id' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setBatch( $value ) {
		$value = TTUUID::castUUID( $value );

		return $this->setGenericDataValue( 'batch_id', $value );
	}

	/**
	 * @return int
	 */
	function getStatus() {
		return $this->getGenericDataValue( 'status_id' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setStatus( $value ) {
		$value = (int)$value;

		return $this->setGenericDataValue( 'status_id', $value );
	}

	/**
	 * @return int
	 */
	function getPriority() {
		return $this->getGenericDataValue( 'priority' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setPriority( $value ) {
		// 25=Real-Time (user waiting on it)
		// 50=Normal
		// 120=Background batch job.
		$value = (int)$value;

		return $this->setGenericDataValue( 'priority', $value );
	}

	/**
	 * @return int
	 */
	function getName() {
		return $this->getGenericDataValue( 'name' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setName( $value ) {
		$value = trim( $value );

		return $this->setGenericDataValue( 'name', $value );
	}

	/**
	 * @return object|bool
	 */
	function getUserObject() {
		return $this->getGenericObject( 'UserListFactory', $this->getUser(), 'user_obj' );
	}

	/**
	 * @return bool|mixed
	 */
	function getUser() {
		return $this->getGenericDataValue( 'user_id' );
	}

	/**
	 * @param string $value UUID
	 * @return bool
	 */
	function setUser( $value ) {
		$value = TTUUID::castUUID( $value );

		return $this->setGenericDataValue( 'user_id', $value );
	}

	/**
	 * @return int
	 */
	function getEffectiveDate( $raw = false ) {
		$value = $this->getGenericDataValue( 'effective_date' );
		if ( $value !== false ) {
			if ( $raw === true ) {
				return $value;
			} else {
				return TTDate::strtotime( $value );
			}
		}

		return false;
	}

	/**
	 * @param $epoch
	 * @return bool
	 */
	function setEffectiveDate( $value ) {
		return $this->setGenericDataValue( 'effective_date', $value );
	}

	/**
	 * @return int
	 */
	function getQueuedDate( $raw = false ) {
		$value = $this->getGenericDataValue( 'queued_date' );
		if ( $value !== false ) {
			if ( $raw === true ) {
				return $value;
			} else {
				return TTDate::strtotime( $value );
			}
		}

		return false;
	}

	/**
	 * @param $epoch
	 * @return bool
	 */
	function setQueuedDate( $value = null ) {
		//This needs to support millisecond resolution, so we were forced to use integer datatypes instead of timestamp in the DB due to ADODB having difficulty with it.
		return $this->setGenericDataValue( 'queued_date', $value );
	}

	/**
	 * @return int
	 */
	function getRunDate( $raw = false ) {
		$value = $this->getGenericDataValue( 'run_date' );
		if ( $value !== false ) {
			if ( $raw === true ) {
				return $value;
			} else {
				return TTDate::strtotime( $value );
			}
		}

		return false;
	}

	/**
	 * @param $epoch
	 * @return bool
	 */
	function setRunDate( $value ) {
		//This needs to support millisecond resolution, so we were forced to use integer datatypes instead of timestamp in the DB due to ADODB having difficulty with it.
		return $this->setGenericDataValue( 'run_date', $value );
	}

	/**
	 * @return int
	 */
	function getCompletedDate( $raw = false ) {
		$value = $this->getGenericDataValue( 'completed_date' );
		if ( $value !== false ) {
			if ( $raw === true ) {
				return $value;
			} else {
				return TTDate::strtotime( $value );
			}
		}

		return false;
	}

	/**
	 * @param $epoch
	 * @return bool
	 */
	function setCompletedDate( $value ) {
		//This needs to support millisecond resolution, so we were forced to use integer datatypes instead of timestamp in the DB due to ADODB having difficulty with it.
		return $this->setGenericDataValue( 'completed_date', $value );
	}

	/**
	 * @return int
	 */
	function getRetryAttempt() {
		return $this->getGenericDataValue( 'retry_attempt' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setRetryAttempt( $value ) {
		$value = (int)$value;

		return $this->setGenericDataValue( 'retry_attempt', $value );
	}

	/**
	 * @return int
	 */
	function getRetryMaxAttempt() {
		return $this->getGenericDataValue( 'retry_max_attempt' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setRetryMaxAttempt( $value ) {
		$value = (int)$value;

		return $this->setGenericDataValue( 'retry_max_attempt', $value );
	}

	/**
	 * @return int
	 */
	function getClass() {
		return $this->getGenericDataValue( 'class' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setClass( $value ) {
		$value = trim( $value );

		return $this->setGenericDataValue( 'class', $value );
	}

	/**
	 * @return int
	 */
	function getMethod() {
		return $this->getGenericDataValue( 'method' );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setMethod( $value ) {
		$value = trim( $value );

		return $this->setGenericDataValue( 'method', $value );
	}

	/**
	 * @return int
	 */
	function getExtraData() {
		return json_decode( $this->getGenericDataValue( 'extra_data' ), true );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setExtraData( $value ) {
		return $this->setGenericDataValue( 'extra_data', json_encode( $value ) );
	}

	/**
	 * @return int
	 */
	function getArguments() {
		return json_decode( $this->getGenericDataValue( 'arguments' ), true );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setArguments( $value ) {
		return $this->setGenericDataValue( 'arguments', json_encode( $value ) );
	}

	/**
	 * @return int
	 */
	function getReturnData() {
		return json_decode( $this->getGenericDataValue( 'return_data' ), true );
	}

	/**
	 * @param $value
	 * @return bool
	 */
	function setReturnData( $value ) {
		return $this->setGenericDataValue( 'return_data', json_encode( $value ) );
	}

	/**
	 * @param bool $ignore_warning
	 * @return bool
	 */
	function Validate( $ignore_warning = true ) {
		//
		// BELOW: Validation code moved from set*() functions.
		//

		if ( $this->getDeleted() == false ) {
			if ( $this->getUser() != TTUUID::getZeroID() ) {
				$ulf = TTnew( 'UserListFactory' ); /** @var UserListFactory $ulf */
				$this->Validator->isResultSetWithRows( 'user',
													   $ulf->getByID( $this->getUser() ),
													   TTi18n::gettext( 'Invalid Employee' )
				);
			}

			if ( $this->getName() != '' ) {
				$this->Validator->isLength( 'name',
											$this->getName(),
											TTi18n::gettext( 'Name is invalid' ),
											1, 200
				);
			}

			// Status
			if ( $this->getStatus() != '' ) {
				$this->Validator->inArrayKey( 'status',
											  $this->getStatus(),
											  TTi18n::gettext( 'Incorrect Status' ),
											  $this->getOptions( 'status' )
				);
			}

			// Priority
			$this->Validator->isGreaterThan( 'priority',
											 $this->getPriority(),
											 TTi18n::gettext( 'Priority must be 1 or higher' ),
											 1
			);
			if ( $this->Validator->isError( 'priority' ) == false ) {
				$this->Validator->isLessThan( 'priority',
											  $this->getPriority(),
											  TTi18n::gettext( 'Priority must be less than 128' ),
											  128
				);
			}

			// Effective Date (must always be specified)
			$this->Validator->isDate( 'effective_date',
									  $this->getEffectiveDate(),
									  TTi18n::gettext( 'Invalid effective date' )
			);
		}

		return true;
	}

	/**
	 * @return bool
	 */
	function preValidate() {
		if ( $this->getStatus() == '' ) {
			$this->setStatus( 10 ); //Pending
		}

		if ( $this->getPriority() == '' ) {
			$this->setPriority( 50 ); //Middle priority
		}

		if ( $this->getQueuedDate() == '' ) {
			$this->setQueuedDate( microtime( true ) );
		}

		if ( $this->getRetryAttempt() == '' ) {
			$this->getRetryAttempt( 0 );
		}

		if ( $this->getRetryMaxAttempt() == '' ) {
			$this->getRetryMaxAttempt( 0 );
		}

		return true;
	}

	function postSave() {
		$this->notifyWorkers(); //Send PostgreSQL notify out to workers.

		return true;
	}

	/**
	 * @param $data
	 * @return bool
	 */
	function setObjectFromArray( $data ) {
		if ( is_array( $data ) ) {
			$variable_function_map = $this->getVariableToFunctionMap();
			foreach ( $variable_function_map as $key => $function ) {
				if ( isset( $data[$key] ) ) {

					$function = 'set' . $function;
					switch ( $key ) {
						default:
							if ( method_exists( $this, $function ) ) {
								$this->$function( $data[$key] );
							}
							break;
					}
				}
			}

			//$this->setCreatedAndUpdatedColumns( $data );

			return true;
		}

		return false;
	}

	/**
	 * @param null $include_columns
	 * @return array
	 */
	function getObjectAsArray( $include_columns = null ) {
		$data = [];
		$variable_function_map = $this->getVariableToFunctionMap();
		if ( is_array( $variable_function_map ) ) {
			foreach ( $variable_function_map as $variable => $function_stub ) {
				if ( $include_columns == null || ( isset( $include_columns[$variable] ) && $include_columns[$variable] == true ) ) {

					$function = 'get' . $function_stub;
					switch ( $variable ) {
						case 'effective_date':
							if ( method_exists( $this, $function ) ) {
								$data[$variable] = TTDate::getAPIDate( 'DATE+TIME', $this->$function() );
							}
							break;
						default:
							if ( method_exists( $this, $function ) ) {
								$data[$variable] = $this->$function();
							}
							break;
					}
				}
			}
			//$this->getCreatedAndUpdatedColumns( $data, $include_columns );
		}

		return $data;
	}

	/**
	 * @return bool
	 */
	function getDeleted() {
		return false;
	}

	/**
	 * @param $bool
	 * @return bool
	 */
	function setDeleted( $bool ) {
		return false;
	}

	/**
	 * @return bool
	 */
	function getCreatedDate() {
		return false;
	}

	/**
	 * @param int $epoch EPOCH
	 * @return bool
	 */
	function setCreatedDate( $epoch = null ) {
		return false;
	}

	/**
	 * @return bool
	 */
	function getCreatedBy() {
		return false;
	}

	/**
	 * @param string $id UUID
	 * @return bool
	 */
	function setCreatedBy( $id = null ) {
		return false;
	}

	/**
	 * @return bool
	 */
	function getUpdatedDate() {
		return false;
	}

	/**
	 * @param int $epoch EPOCH
	 * @return bool
	 */
	function setUpdatedDate( $epoch = null ) {
		return false;
	}

	/**
	 * @return bool
	 */
	function getUpdatedBy() {
		return false;
	}

	/**
	 * @param string $id UUID
	 * @return bool
	 */
	function setUpdatedBy( $id = null ) {
		return false;
	}


	/**
	 * @return bool
	 */
	function getDeletedDate() {
		return false;
	}

	/**
	 * @param int $epoch EPOCH
	 * @return bool
	 */
	function setDeletedDate( $epoch = null ) {
		return false;
	}

	/**
	 * @return bool
	 */
	function getDeletedBy() {
		return false;
	}

	/**
	 * @param string $id UUID
	 * @return bool
	 */
	function setDeletedBy( $id = null ) {
		return false;
	}

	function notifyWorkers( $payload = null ) {
		global $db;

		//For each unique payload, a new event gets sent. This can cause a backlog of events that the workers are waiting on.
		return $db->Execute( 'NOTIFY "system_job_queue", \''. $payload .'\'');
	}

	function getBackgroundProcessObject() {
		if ( is_object( $this->background_process_obj ) ) {
			 return $this->background_process_obj;
		} else {
			$bp = new BackgroundProcess();
			$bp->setMaxProcesses( $this->getMaxProcesses() );

			global $config_vars;

			//Allow specifying a separate directory to store QueueWorker lock files in that might be more performant than the regular cache directory. (ie: not a network share)
			if ( isset( $config_vars['cache']['queue_worker_dir'] ) && $config_vars['cache']['queue_worker_dir'] != '' ) {
				$lock_file_dir = $config_vars['cache']['queue_worker_dir'];
			} else {
				$lock_file_dir = $config_vars['cache']['dir'];
			}
			$bp->setLockFileDirectory( $lock_file_dir );

			$bp->setLockFilePrefix( 'SystemQueueWorker' );

			$this->background_process_obj = $bp;

			return $this->background_process_obj;
		}
	}

	function getMaxProcesses() {
		global $config_vars;
		if ( !isset( $config_vars['other']['max_processes'] ) ) {
			$config_vars['other']['max_processes'] = 2;
		}

		return $config_vars['other']['max_processes'];
	}

	function getRunningWorkerProcesses( $check_pids = false ) {
		$bp = $this->getBackgroundProcessObject();
		$lock_files = $bp->getLockFiles();
		$current_processes = $bp->getCurrentProcesses( $lock_files );

		//If more than process is running and flag is set, lets check that the PID in each lock file is in fact running.
		//  This will help catch cases where the process crashed and the stale lock file still exists.
		if ( $current_processes > 0 && $check_pids == true ) {
			$lock_files = $bp->purgeLockFiles( $lock_files, $check_pids );
			$current_processes = $bp->getCurrentProcesses( $lock_files );
		}

		Debug::text( '  Current Running Worker Processes: ' . $current_processes, __FILE__, __LINE__, __METHOD__, 10 );
		return $current_processes;
	}

	function startWorkerProcess( $worker_script ) {
		global $config_vars;

		$bp = $this->getBackgroundProcessObject();

		//Execute self to generate each report in its own process.
		$command = '"' . $config_vars['path']['php_cli'] . '" "' . $worker_script . '" "#lock_file#"';
		Debug::text( '  Spawning new QueueWorker process: Command: ' . $command, __FILE__, __LINE__, __METHOD__, 10 );
		$retval = $bp->run( $command, true ); //If max processes reached, just exit immediately.
		if ( $retval !== true ) {
			Debug::text( '  NOTICE: Unable to start new background process... Max processes or Lock file perhaps?', __FILE__, __LINE__, __METHOD__, 10 );
		}

		return $retval;
	}

	function lock() {
		global $db;
		Debug::Text( '  Locking Job: ID: ' . $this->getId() .' Class: '. $this->getClass() .' Method: '. $this->getMethod(), __FILE__, __LINE__, __METHOD__, 10 );
		$query = 'UPDATE system_job_queue SET status_id = 20, run_date = '. microtime( true ) .' WHERE id = '. $this->db->qstr( $this->getId() ) .'';
		return $db->Execute( $query ); //Make sure we commit the transaction outside of this function, but immediately after its run.
	}

	function run() {
		global $current_user, $current_user_prefs, $current_company; //Set global variables so its easy to access this data within the job queue runner function itself.
		Debug::Text( '  Running Job: ID: ' . $this->getId() .' Class: '. $this->getClass() .' Method: '. $this->getMethod() .' Effective Date: '. TTDate::getDate( 'DATE+TIME', $this->getEffectiveDate() ) .' User: '. $this->getUser() .' Current User: '. ( ( isset( $current_user ) && is_object( $current_user ) ) ? $current_user->getId() : 'NONE' ), __FILE__, __LINE__, __METHOD__, 10 );

		// $current_user, $current_user_prefs are unset at the bottom of this function as well.
		$current_user = $current_user_prefs = $current_company = null;  //Make sure user/preferences don't get carried over into another job. They are unset at the bottom of this function as well. -- unset() doesn't work on global variables.

		//Quick way to clear all memory cache.
		// This is needed prior to each job running, as this could be done in a long running process, and any cached data from minutes or hours ago wouldn't have been refreshed if it was cleared in another process.
		// We don't want to disable memory cache completely though, as this can be helpful within resource heavy jobs themselves.
		// Essentially this will cause similar caching behavior as normal short running web requests do. Cache is initialized fresh before each one.
		// **NOTE: This is done at the end of the job to free up memory too.
		$this->cache->_memoryCachingArray = [];
		$this->cache->_memoryCachingCounter = 0;

		//Whenever a job is assigned to a user, be sure to apply user preferences.
		if ( TTUUID::isUUID( $this->getUser() ) && $this->getUser() != TTUUID::getZeroID() ) {
			$ulf = TTnew('UserListFactory');
			$ulf->getById( $this->getUser() );
			if ( $ulf->getRecordCount() > 0 ) {
				$current_user = $ulf->getCurrent();

				$current_user_prefs = $current_user->getUserPreferenceObject();
				if ( is_object( $current_user_prefs ) ) {
					$current_user_prefs->setDateTimePreferences();
					TTi18n::setLanguage( $current_user_prefs->getLanguage() );
				}

				TTi18n::setCountry( $current_user->getCountry() );
				TTi18n::setLocale(); //Sets master locale
			} else {
				Debug::Text( '    ERROR: User does not exist! ID: '. $this->getUser(), __FILE__, __LINE__, __METHOD__, 10 );
			}
			unset( $ulf );
		} else {
			//Force default timezone and user preferences, otherwise they could get corrupted between job runs.
			TTDate::setTimeZone();
			TTDate::setDateFormat( 'd-M-y' );
			TTDate::setTimeFormat( 'g:i A' );
			TTDate::setTimeUnitFormat( 10 );
			TTi18n::setLanguage( 'en' );
			TTi18n::chooseBestLocale();
		}

		//$this->StartTransaction();  //Leave transaction handling to the child function itself.

		//Extra data must be set *before* the job is run.
		//$extra_data = $this->getExtraData();
		//if ( isset( $extra_data['api_message_id'] ) && $extra_data['api_message_id'] != '' ) {
		//	SystemJobQueue::setAPIMessageID( $extra_data['api_message_id'] );
		//}
		//
		//if ( isset( $extra_data['user_generic_status_batch_id'] ) && $extra_data['user_generic_status_batch_id'] != '' ) {
		//	SystemJobQueue::setUserGenericStatusBatchID( $extra_data['user_generic_status_batch_id'] );
		//} else if ( $this->getBatch() != '' ) {
		//	SystemJobQueue::setUserGenericStatusBatchID( $this->getBatch() );
		//}
		SystemJobQueue::setUserGenericStatusBatchID( $this->getBatch() );
		Debug::Text( '    Batch ID: '. $this->getBatch() .' Running as Current User: '. ( ( isset( $current_user ) && is_object( $current_user ) ) ? $current_user->getId() : 'NONE' ), __FILE__, __LINE__, __METHOD__, 10 );

		global $db;

		try {
			if ( !( class_exists( $this->getClass() ) && method_exists( $this->getClass(), $this->getMethod() ) ) )  {
				throw new Exception( 'ERROR: Class or Method does not exist: Class: ' . $this->getClass() .' Method: '. $this->getMethod() .' Job Queue ID: '. $this->getId() );
			}

			$retval = call_user_func_array( [ $this->getClass(), $this->getMethod() ], (array)$this->getArguments() );
			Debug::Arr( $retval, '    Return Data: ', __FILE__, __LINE__, __METHOD__, 10 );

			$query = 'UPDATE system_job_queue SET status_id = 100, completed_date = '. microtime( true ) .', return_data = '. $this->db->qstr( json_encode( $retval ) ) .' WHERE id = '. $this->db->qstr( $this->getId() ) .'';
			$retval = $db->Execute( $query ); //Make sure we commit the transaction outside of this function, but immediately after its run.
		} catch ( Exception $e ) {
			Debug::Text( '    ERROR: Job triggered exception: '. $e->getMessage(), __FILE__, __LINE__, __METHOD__, 10 );

			//Exception triggered, set job as failed.
			$query = 'UPDATE system_job_queue SET status_id = 50, completed_date = '. microtime( true ) .', return_data = '. $this->db->qstr( json_encode( $e->getMessage() ) )  .' WHERE id = '. $this->db->qstr( $this->getId() ) .'';
			$retval = $db->Execute( $query ); //Make sure we commit the transaction outside of this function, but immediately after its run.
		}

		//Clean-up any variables that should never be carried over to the next job.
		$current_user = $current_user_prefs = $current_company = null; //Make sure user/preferences don't get carried over into another job. -- unset() doesn't work on global variables.

		//$this->CommitTransaction(); //Leave transaction handling to the child function itself.

		// **NOTE: This is done at the start of each job too. See that for more comments.
		$this->cache->_memoryCachingArray = [];
		$this->cache->_memoryCachingCounter = 0;

		return $retval;

	}
}