PHP LogHelper::log_warn方法代码示例

    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);
//.........这里部分代码省略.........