protected function prepareLocale() {
global $conf;
global $language;
$country = isset($conf['site_default_country']) ? trim($conf['site_default_country']) : '';
if ($country === '') {
$country = 'us';
LogHelper::log_warn(t("Default country was not defined. Go to 'Configuration' | 'Regional and language' | 'Regional settings' to set default country"));
}
$localeSubTags = array('language' => $language->language, 'region' => $country);
return Locale::composeLocale($localeSubTags);
}
/**
* This file is part of the Checkbook NYC financial transparency software.
*
* Copyright (C) 2012, 2013 New York City
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* 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/>.
*/
function ContentTypeDatasetSourceAssembler_nodereference(DatasetSourceAssembler $assembler, DataControllerCallContext $callcontext, $parameterNames, $statement, $tableIndex, $supportedField)
{
$tableAlias = $assembler->prepareTableAlias($tableIndex);
$field = $assembler->config->drupal['fields'][$supportedField->original_name];
// preparing referenceable content type
$referenceableContentTypes = array_keys(array_filter($field['referenceable_types']));
if (count($referenceableContentTypes) != 1) {
$message = t("Unsupported configuration for referenced types for '@supportedFieldName' field: [@contentTypes]", array('@supportedFieldName' => $supportedField->name, '@contentTypes' => implode(', ', $referenceableContentTypes)));
LogHelper::log_warn($message);
return;
}
$referenceableContentType = $referenceableContentTypes[0];
$referenceableContentTypeKey = 'nid';
// preparing list of parameters which should be supported by the referenceable content type
// if parameter names are not defined we should return all available parameters
$contentTypeParameterNames = NULL;
if (isset($parameterNames)) {
$parameterNamePrefix = $supportedField->name . '_';
foreach ($parameterNames as $parameterName) {
if (strpos($parameterName, $parameterNamePrefix) === 0) {
$contentTypeParameterName = substr($parameterName, strlen($parameterNamePrefix));
$contentTypeParameterNames[] = $contentTypeParameterName;
}
}
if (!isset($contentTypeParameterNames)) {
return;
}
}
if (isset($contentTypeParameterNames)) {
// we will use the field to link with parent content type
$contentTypeParameterNames[] = $referenceableContentTypeKey;
}
// adding check to prevent recursive/circular references
if ($assembler->registerContentTypeInStack($callcontext, $referenceableContentType)) {
// requesting SQL sections related to the content type
$contentTypeDatasetName = DrupalContentTypeMetaModelLoader::getDatasetName($referenceableContentType);
$contentTypeDataset = $callcontext->metamodel->getDataset($contentTypeDatasetName);
$contentTypeTableAliasPrefix = $assembler->prepareColumnAlias($supportedField->name);
$contentTypeAssembler = new ContentTypeDatasetSourceAssembler($contentTypeDataset->source->assembler->config, $contentTypeTableAliasPrefix);
$contentTypeStatement = $contentTypeAssembler->assemble($callcontext, $contentTypeParameterNames);
// adding condition to join with 'main' statement
$contentTypeTableSection = $contentTypeStatement->tables[0];
$contentTypeTableSection->conditions[] = new JoinConditionSection($referenceableContentTypeKey, new TableColumnConditionSectionValue($tableAlias, $supportedField->column));
// merging with 'main' statement
$statement->merge($contentTypeStatement);
$assembler->unregisterContentTypeFromStack($callcontext, $referenceableContentType);
}
}
public static function getExportColumnName ( $uiMetaDataName, MetaModel $metamodel ) {
if ( trim($uiMetaDataName) == '' ) {
$message = t('Empty columnName discovered');
drupal_set_message($message, 'warning');
LogHelper::log_warn($message);
return $uiMetaDataName;
}
list($elementNameSpace, $name) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($uiMetaDataName);
switch ( $elementNameSpace ) {
case AbstractAttributeUIMetaData::NAME_SPACE:
list($referencedDimensionName, $dimensionColumnName) = ParameterNameHelper::split($name);
list($datasetName, $dimensionName) = ReferencePathHelper::splitReference($referencedDimensionName);
if (isset($datasetName)) {
$adjustedReferencedDimensionName = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $dimensionName);
$name = ParameterNameHelper::assemble($adjustedReferencedDimensionName, $dimensionColumnName);
}
break;
case AbstractMeasureUIMetaData::NAME_SPACE:
list($datasetName, $measureName) = ReferencePathHelper::splitReference($name);
if (isset($datasetName)) {
$name = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $measureName);
}
break;
case FormulaUIMetaData::NAME_SPACE:
list($datasetName, $formulaName) = ReferencePathHelper::splitReference($name);
if (isset($datasetName)) {
$name = ReferencePathHelper::assembleReference(self::getExportDatasetName($datasetName,$metamodel), $formulaName);
}
break;
default:
$message = t('Unsupported UI Meta Data name space: @uiMetaDataName', array('@uiMetaDataName' => $uiMetaDataName));
LogHelper::log_error($message);
throw new UnsupportedOperationException($message);
}
return AbstractDatasetUIMetaDataGenerator::prepareElementUIMetaDataName($elementNameSpace, $name);
}
protected function processReferences(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource) {
$foreignKeyConstraintCount = 0;
$constraintsProperties = $this->loadReferenceConstraintsProperties($callcontext, $datasource);
if (isset($constraintsProperties)) {
$constraintsColumnsPropertyFormatter = new QueryKeyResultFormatter(array(self::CN_TABLE_OWNER, self::CN_OBJECT_NAME), FALSE);
$constraintsColumnsProperties = $constraintsColumnsPropertyFormatter->formatRecords(
$this->loadConstraintColumnsProperties(
$callcontext, $datasource,
array(self::CONSTRAINT_TYPE__PRIMARY_KEY, self::CONSTRAINT_TYPE__REFERENCE)));
foreach ($constraintsProperties as $constraintProperties) {
$tableOwner = $this->adjustOwnerName($constraintProperties[self::CN_TABLE_OWNER]);
// ---------- preparing referring constraint properties
$constraintName = $constraintProperties[self::CN_OBJECT_NAME];
$constraintAccessKey = ArrayHelper::prepareCompositeKey(array($tableOwner, $constraintName));
// for some reason we do not have access to column configuration for referring constraint
if (!isset($constraintsColumnsProperties[$constraintAccessKey])) {
continue;
}
$constraintColumnsProperties = $constraintsColumnsProperties[$constraintAccessKey];
// we do not support composite references yet
if (count($constraintColumnsProperties) > 1) {
continue;
}
// ----------- preparing referenced constraint properties
$refConstraintName = $constraintProperties[self::CN_REFERENCED_OBJECT_NAME];
$refConstraintAccessKey = ArrayHelper::prepareCompositeKey(array($tableOwner, $refConstraintName));
// for some reason we do not have access to column configuration for referenced constraint
if (!isset($constraintsColumnsProperties[$refConstraintAccessKey])) {
continue;
}
$constraintColumnProperties = $constraintColumnsProperties[0];
$tableName = $this->adjustTableName($constraintColumnProperties[self::CN_TABLE_NAME]);
$tableAccessKey = ArrayHelper::prepareCompositeKey(array($tableOwner, $tableName));
if (!isset($callcontext->datasets[$tableAccessKey])) {
continue;
}
$refConstraintColumnProperties = $constraintsColumnsProperties[$refConstraintAccessKey][0];
$refTableName = $this->adjustTableName($refConstraintColumnProperties[self::CN_TABLE_NAME]);
$refTableAccessKey = ArrayHelper::prepareCompositeKey(array($tableOwner, $refTableName));
if (!isset($callcontext->datasets[$refTableAccessKey])) {
continue;
}
$columnName = $this->adjustColumnName($constraintColumnProperties[self::CN_COLUMN_NAME]);
$refColumnName = $this->adjustColumnName($refConstraintColumnProperties[self::CN_COLUMN_NAME]);
if ($tableName == $refTableName) {
LogHelper::log_warn(t(
"Self-reference is not supported yet: @tableName(@columnName)",
array('@tableName' => $tableName, '@columnName' => $columnName)));
continue;
}
$dataset = $callcontext->datasets[$tableAccessKey];
$column = $dataset->findColumn($columnName);
if (!isset($column)) {
continue;
}
$refDataset = $callcontext->datasets[$refTableAccessKey];
$refColumn = $refDataset->findColumn($refColumnName);
if (!isset($refColumn)) {
continue;
}
$logicalApplicationType = ReferencePathHelper::assembleReference($refDataset->name, $refColumnName);
if (isset($column->type->logicalApplicationType)) {
LogHelper::log_warn(t(
"Multi-reference is not supported yet for '@columnName' column from '@tableName' table: [@referenceExisting, @referenceNew]",
array(
'@tableName' => $tableName,
'@columnName' => $columnName,
'@referenceExisting' => $column->type->logicalApplicationType,
'@referenceNew' => $logicalApplicationType)));
continue;
}
$column->type->logicalApplicationType = $logicalApplicationType;
$foreignKeyConstraintCount++;
}
}
LogHelper::log_info(t(
'Processed system meta data about @constraintCount foreign key constraint(s)',
array('@constraintCount' => $foreignKeyConstraintCount)));
}
protected function processConfig ( $export ) {
$metamodel = data_controller_get_metamodel();
// replace report nid with report uuid
foreach ( $export->config->items as $key => $item ) {
if ( $item->type == 'report' ) {
$reportNode = node_load($item->content);
$export->config->items[$key]->content = get_node_field_value($reportNode,'field_report_uuid',0,'value',true);
}
}
// array cast to deal with json decoder creating objects for arrays with missing keys
$export->config->drilldowns = (array) $export->config->drilldowns;
// replace report nid with report uuid
// replace dashboard nid with dashboard uuid
// replace dataset column reference with dataset uuid
$updated_drilldowns = array();
foreach ( $export->config->drilldowns as $drilldown ) {
$reportNode = gd_report_get_by_nid($drilldown->report);
$dashboardNode = gd_dashboard_get_by_nid($drilldown->dashboard);
if ( !$reportNode || !$dashboardNode ) {
$message = t('Skipping corrupt drilldown for node: @nodeId.',array('@nodeId' => $export->id));
drupal_set_message($message, 'warning');
LogHelper::log_warn($message);
} else {
$updated_drilldown = $drilldown;
$updated_drilldown->report = get_node_field_value($reportNode,'field_report_uuid',0,'value',true);
$updated_drilldown->column = DatasetExportHelper::getExportColumnName($drilldown->column,$metamodel);
$updated_drilldown->dashboard = get_node_field_value($dashboardNode,'field_dashboard_uuid',0,'value',true);
$updated_drilldown->id = count($updated_drilldowns);
$updated_drilldowns[] = $updated_drilldown;
}
}
$export->config->drilldowns = $updated_drilldowns;
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $metamodel, array $filters = NULL, $finalAttempt)
{
LogHelper::log_notice(t('Creating Meta Model using Drupal Content Types...'));
$datasetCounter = 0;
$contentTypes = content_types();
if (isset($contentTypes)) {
foreach ($contentTypes as $contentTypeName => $contentType) {
// preparing list of tables which could be supported by our code
$supportedTables = NULL;
foreach ($contentType['fields'] as $field) {
$fieldName = $field['field_name'];
if ($field['multiple'] > 0) {
$message = t('Multiple values are not supported yet: @contentTypeName.@fieldName', array('@contentTypeName' => $contentTypeName, '@fieldName' => $fieldName));
LogHelper::log_warn($message);
continue;
// UnsupportedOperationException
}
// preparing table name where the field is stored
$fieldStorage = $field['db_storage'];
switch ($fieldStorage) {
case CONTENT_DB_STORAGE_PER_CONTENT_TYPE:
$tableName = _content_tablename($field['type_name'], $fieldStorage);
break;
case CONTENT_DB_STORAGE_PER_FIELD:
break;
$tableName = _content_tablename($fieldName, $fieldStorage);
default:
$message = t("Unsupported storage type - '@fieldStorage' for the field: @fieldName", array('@fieldStorage' => $fieldStorage, '@fieldName' => $fieldName));
LogHelper::log_warn($message);
continue;
// UnsupportedOperationException
}
// calculating number of 'visible' suffixes
$visibleSuffixCount = 0;
foreach ($field['columns'] as $columnAttributes) {
if (isset($columnAttributes['views'])) {
if ($columnAttributes['views'] === TRUE) {
$visibleSuffixCount++;
}
} else {
$visibleSuffixCount++;
}
}
// generating fields for all 'visible' suffixes
foreach ($field['columns'] as $columnSuffix => $columnAttributes) {
if (isset($columnAttributes['views']) && $columnAttributes['views'] === FALSE) {
continue;
}
$supportedField = new stdClass();
// required flag
$supportedField->required = $field->required == 1;
// original name of the field
$supportedField->original_name = $fieldName;
// calculating name of database column
$supportedField->column = $fieldName . '_' . $columnSuffix;
// field name
if ($visibleSuffixCount === 1) {
$supportedField->name = $fieldName;
} else {
$supportedField->name = $supportedField->column;
}
if (isset($supportedTables[$tableName]->storage)) {
$previousStorage = $supportedTables[$tableName]->storage;
if ($fieldStorage != $previousStorage) {
$message = t("Inconsistent storage for '@tableName' table([@fieldStorage1, @fieldStorage2]) for the field: @fieldName", array('@tableName' => $tableName, '@fieldName' => $fieldName, '@fieldStorage1' => $previousStorage, '@fieldStorage2' => $fieldStorage));
LogHelper::log_warn($message);
continue;
// IllegalStateException
}
} else {
$supportedTables[$tableName]->storage = $fieldStorage;
}
$supportedTables[$tableName]->supportedFields[$supportedField->name] = $supportedField;
}
}
// preparing dataset source
$datasetSource = new stdClass();
$datasetSource->assembler->type = ContentTypeDatasetSourceAssembler::$DATASET_SOURCE_ASSEMBLER__TYPE;
$datasetSource->assembler->config->drupal = $contentType;
if (isset($supportedTables)) {
$datasetSource->assembler->config->supportedTables = $supportedTables;
}
// preparing & registering dataset
$dataset = new DatasetMetaData();
$dataset->name = $this->getDatasetName($contentTypeName);
$dataset->description = $contentType['description'];
$dataset->datasourceName = AbstractDrupalDataSourceQueryProxy::$DATASOURCE_NAME__DEFAULT;
$dataset->source = $datasetSource;
// FIXME Populate list of columns and mark the dataset as complete
$dataset->registerColumn('nid')->key = TRUE;
$metamodel->registerDataset($dataset);
$datasetCounter++;
}
}
LogHelper::log_info(t('Processed @datasetCount datasets', array('@datasetCount' => $datasetCounter)));
return self::LOAD_STATE__SUCCESSFUL;
}
public static function oci_free_statement($connection, $statement) {
self::checkOCIExtension('oci_free_statement');
$result = @oci_free_statement($statement);
if ($result === FALSE) {
$error = self::oci_error($statement);
LogHelper::log_warn(t(
'Could not free all resources associated with statement or cursor: @error',
array('@error' => t($error['message']))));
}
}
protected function applyPagination($url, AbstractQueryRequest $request) {
if (isset($request->startWith) && ($request->startWith > 0)) {
$url .= ((strpos($url, '?') === FALSE) ? '?' : '&') . "skip=$request->startWith";
}
$limit = $request->limit;
// if keys and limit are not set it could be just a bug. We cannot load all data.
// The database can be huge. We will load limited (preset) number of records
if (!isset($limit)) {
$keys = $this->prepareDocumentIdentifiers($request);
if (!isset($keys)) {
$limit = self::$MAX_LOADED_DOCUMENTS;
LogHelper::log_warn(t(
'Loading maximum @limit records for the request: @datasetName',
array('@limit' => $limit, '@datasetName' => $request->getDatasetName())));
}
}
if (isset($limit)) {
$url .= ((strpos($url, '?') === FALSE) ? '?' : '&') . "limit=$limit";
}
return $url;
}
protected function getQueryFilters () {
$query_filters = array();
foreach ( $this->filters as $f ) {
if ( empty($f->column) || empty($f->name) ) {
LogHelper::log_warn('Missing filter name or column.');
continue;
}
// if a filter is pre-apply, generate an operator for it.
if ( !$f->exposed ) {
// If there is a value, then format it otherwise leave it as null
$value = isset($f->value) ? $this->formatFilterValue($f->value, $this->getColumn($f->column)) : null;
$query_filters[$f->column][] = OperatorFactory::getInstance()->initiateHandler($f->operator,$value);
}
if ( $f->exposed ) {
$requestFilter = FALSE;
// Check for query filters next
if ( !empty($_REQUEST['t']) ) {
foreach ( $_REQUEST['t'] as $dashboardId => $requestFilters ) {
if ($dashboardId == $this->dashboard) {
foreach ($requestFilters as $filterName => $filterParams) {
if ( $f->name == $filterName && is_array($filterParams) ) {
$requestFilter = TRUE;
// If there is a value, then format it otherwise leave it as null
$value = isset($filterParams['v']) ? $this->formatFilterValue($filterParams['v'], $this->getColumn($f->column)) : null;
$query_filters[$f->column][] = OperatorFactory::getInstance()->initiateHandler($filterParams['o'],$value);
}
}
}
}
}
if ( !empty($f->operator) && !$requestFilter) {
// If a filter is exposed and has a default value for it, set it
$value = isset($f->value) ? $this->formatFilterValue($f->value, $this->getColumn($f->column)) : null;
$query_filters[$f->column][] = OperatorFactory::getInstance()->initiateHandler($f->operator,$value);
}
}
}
return $query_filters;
}
protected static function registerFactMeasure(CubeMetaData $cube, ColumnMetaData $column, $functionName, $additivity, $selectedApplicationType = NULL)
{
$measureName = StarSchemaNamingConvention::getFactRelatedMeasureName($column->name, $functionName);
$measure = $cube->registerMeasure($measureName);
$measure->publicName = t($functionName);
$measure->description = t("System generated '@functionName' measure for '@columnName' column", array('@functionName' => $measure->publicName, '@columnName' => $column->publicName));
$measure->used = FALSE;
$expression = FALSE;
if ($column->persistence == FormulaMetaData::PERSISTENCE__CALCULATED) {
if ($column->isUsed()) {
try {
$expressionAssembler = new FormulaExpressionAssembler($cube->factsDataset);
$expression = $expressionAssembler->assemble($column);
$measure->used = TRUE;
} catch (Exception $e) {
$message = t("@functionName measure assembled with errors. @error", array('@functionName' => $functionName, '@error' => $e->getMessage()));
$measure->functionError = $message;
LogHelper::log_warn($message);
}
} else {
$measure->functionError = t("@functionName measure was not assembled for the unused column", array('@functionName' => $functionName));
}
} else {
$formulaExpressionParser = new FormulaExpressionParser(SQLFormulaExpressionHandler::LANGUAGE__SQL);
$expression = $formulaExpressionParser->assemble($column->name);
$measure->used = TRUE;
}
$measure->function = $expression === FALSE ? FALSE : $functionName . '(' . $expression . ')';
$measure->additivity = $additivity;
$measure->type->applicationType = isset($selectedApplicationType) ? $selectedApplicationType : $column->type->applicationType;
$measure->type->scale = $column->type->scale;
}
protected function publishExceptions($abort) {
$originalExceptionCount = $this->exceptionCount;
if (isset($this->exceptionPool)) {
foreach ($this->exceptionPool as $recordNumber => $columnsException) {
foreach ($columnsException as $columnPublicName => $exceptionInfo) {
$message = $exceptionInfo['message'] . t(
' [column: @columnName] [line: @lineNumber]',
array('@columnName' => $columnPublicName, '@lineNumber' => $recordNumber));
LogHelper::log_warn(t(
'@message at @file:@line',
array('@message' => $message, '@file' => $exceptionInfo['file'], '@line' => $exceptionInfo['line'])));
drupal_set_message($message, 'error');
}
}
}
$this->cleanInternalState();
if ($abort && ($originalExceptionCount > 0)) {
throw new DataParserException(t(
'Found %exceptionCount issue(s) while parsing data',
array('%exceptionCount' => $originalExceptionCount)));
}
}
public function parse(AbstractDataProvider $dataProvider, array $dataSubmitters = NULL) {
$skippedRecordCount = 0;
$loadedRecordCount = 0;
$timeStart = microtime(TRUE);
if ($dataProvider->openResource()) {
LogHelper::log_notice(t(
'Parsing @limitRecordCount records. Skipping first @skipRecordCount records (memory usage: @memoryUsed) ...',
array(
'@skipRecordCount' => $this->skipRecordCount,
'@limitRecordCount' => (isset($this->limitRecordCount) ? $this->limitRecordCount : t('all')),
'@memoryUsed' => memory_get_usage())));
try {
if ($this->initializeProcessing($dataSubmitters)) {
// preparing list of columns
$this->prepareMetaData($dataProvider, $dataSubmitters);
$metadataColumnCount = $this->metadata->getColumnCount(FALSE, TRUE);
if ((!isset($this->limitRecordCount) || ($this->limitRecordCount > 0))
&& $this->executeBeforeProcessingRecords($dataSubmitters, $dataProvider)) {
// processing records
$fileProcessedCompletely = FALSE;
while (!isset($this->limitRecordCount) || ($loadedRecordCount < $this->limitRecordCount)) {
$dataProvider->startReading();
$record = $this->parseNextRecord($dataProvider, $dataSubmitters);
// number of loaded columns should match number of columns in meta data
if (isset($record)) {
$attempt = 1;
while (TRUE) {
$recordColumnCount = count($record);
if ($recordColumnCount == $metadataColumnCount) {
break;
}
else {
if ($attempt > self::$MAX_ATTEMPTS_TO_RESOLVE_PARSING_ISSUES) {
$dataProvider->endReading();
LogHelper::log_debug($this->metadata);
LogHelper::log_debug($record);
throw new DataParserException(t(
'Expected to load values for %metadataColumnCount columns. Loaded %loadedColumnCount [line: %lineNumber]',
array('%metadataColumnCount' => $metadataColumnCount, '%loadedColumnCount' => $recordColumnCount, '%lineNumber' => $dataProvider->getCurrentLineNumber())));
}
$dataProvider->rollbackReading();
$dataProvider->startReading();
$record = $this->parseNextRecord($dataProvider, $dataSubmitters, $attempt);
$attempt++;
}
}
}
$dataProvider->endReading();
// checking if we reached the end
if (!isset($record)) {
$fileProcessedCompletely = TRUE;
break;
}
// skipping required number of records
if ($skippedRecordCount < $this->skipRecordCount) {
$skippedRecordCount++;
continue;
}
$this->postProcessColumnValues($record);
// checking if we need to skip processing the record
$recordNumber = $dataProvider->getCurrentLineNumber();
if ($this->executeBeforeRecordSubmitted($dataSubmitters, $recordNumber, $record)) {
$this->submitRecord($dataSubmitters, $recordNumber, $record);
$this->executeAfterRecordSubmitted($dataSubmitters, $recordNumber, $record);
$loadedRecordCount++;
if (($loadedRecordCount % 1000) == 0) {
LogHelper::log_info(t(
'Processed @recordCount records so far (memory usage: @memoryUsed)',
array('@recordCount' => $loadedRecordCount, '@memoryUsed' => memory_get_usage())));
}
}
}
$this->executeAfterProcessingRecords($dataSubmitters, $fileProcessedCompletely);
}
$this->finishProcessing($dataSubmitters);
}
}
catch (DataParserException $e) {
LogHelper::log_warn(t('Place of original exception @file:@line', array('@file' => $e->getFile(), '@line' => $e->getLine())));
try {
$this->abortProcessing($dataSubmitters);
}
catch (Exception $ne) {
// we do not need to rethrow this exception. We need to preserve and rethrow original exception
LogHelper::log_error($ne);
}
try {
$dataProvider->closeResource();
}
catch (Exception $ne) {
// we do not need to rethrow this exception. We need to preserve and rethrow original exception
LogHelper::log_error($ne);
}
throw new IllegalStateException($e->getMessage());
}
catch (Exception $e) {
LogHelper::log_warn(t('Place of original exception @file:@line', array('@file' => $e->getFile(), '@line' => $e->getLine())));
try {
$this->abortProcessing($dataSubmitters);
}
catch (Exception $ne) {
// we do not need to rethrow this exception. We need to preserve and rethrow original exception
LogHelper::log_error($ne);
}
$ise = new IllegalStateException(
ExceptionHelper::getExceptionMessage($e) . t(' [%lineNumber line(s) parsed so far]', array('%lineNumber' => $dataProvider->getCurrentLineNumber())),
0, $e);
try {
$dataProvider->closeResource();
}
catch (Exception $ne) {
// we do not need to rethrow this exception. We need to preserve and rethrow original exception
LogHelper::log_error($ne);
}
throw $ise;
}
$dataProvider->closeResource();
}
LogHelper::log_notice(t(
'Processing @recordCount record(s) took !executionTime',
array('@recordCount' => $loadedRecordCount, '!executionTime' => LogHelper::formatExecutionTime($timeStart))));
return $loadedRecordCount;
}