PHP LogHelper::log_info方法代码示例

    public function load(AbstractMetaModel $environment_metamodel, array $filters = NULL) {
        LogHelper::log_notice(t('Loading Environment Meta Model from GovDashboard Content Types ...'));

        // Note we do not apply filters because we do not have any
        // if we want to use the filters we would need to prepare list of data source names
        // but to prepare those name we need to load meta model.
        // but that is what we are trying to do in this code
        // Catch 22
        if (isset($filters)) {
            throw new UnsupportedOperationException(t('Filters are not supported during data source loading'));
        }

        $datamartNodes = gd_datamart_get_datamarts(LOAD_ENTITY);

        // preparing data sources
        foreach ($datamartNodes as $datamartNode) {
            GD_DataMartMetaModelLoaderHelper::prepareDataSource($environment_metamodel, $datamartNode);
        }

        // finalizing the preparation
        foreach($datamartNodes as $datamartNode) {
            $datasource = GD_DataMartMetaModelLoaderHelper::getDataSourceByNodeId($environment_metamodel->datasources, $datamartNode->nid);

            GD_DataMartMetaModelLoaderHelper::finalizeDataSourcePreparation($environment_metamodel, $datasource);
        }

        LogHelper::log_info(t('Processed @datamartCount data mart node(s)', array('@datamartCount' => count($datamartNodes))));
    }

 protected function prepareColumnsMetaDataProperties(DataSourceMetaData $datasource, array $tableNames)
 {
     $datasourceHandler = DataSourceQueryFactory::getInstance()->getHandler($datasource->type);
     $sql = 'SELECT c.relname AS ' . self::PROPERTY__TABLE_NAME . ', ' . '       a.attname AS ' . self::PROPERTY__COLUMN_NAME . ', ' . '       a.attnum AS ' . self::PROPERTY__COLUMN_INDEX . ', ' . '       t.typname AS ' . self::PROPERTY__COLUMN_TYPE . '  FROM pg_class c INNER JOIN pg_namespace ns ON ns.oid = c.relnamespace' . '       INNER JOIN pg_attribute a ON a.attrelid = c.oid' . '       INNER JOIN pg_type t ON t.oid = a.atttypid' . " WHERE c.relname IN ('" . implode("', '", $tableNames) . "')" . "   AND c.relkind IN ('r','v')" . "   AND ns.nspname = '{$datasource->schema}'" . '   AND a.attnum > 0';
     LogHelper::log_info(new StatementLogMessage('metadata.dataset.systemTable', $sql));
     return $datasourceHandler->executeQuery(new DataControllerCallContext(), $datasource, $sql, new PassthroughResultFormatter());
 }

    public function apply ( $patients ) {

        if ( !is_array($patients) ) {
            $patients = array($patients);
        }

        foreach ( $patients as $patient ) {
            \LogHelper::log_info('Applying ReportConfigRemoveColumnConfig treatment to: ' . $patient->reportNodeId);

            $node = node_load($patient->reportNodeId);

            $reportConfigText = get_node_field_value($node, 'field_report_conf', 0, 'value', FALSE);
            $reportConfig = isset($reportConfigText) ? json_decode($reportConfigText) : NULL;
            if (!isset($reportConfig)) {
                \LogHelper::log_info('Report configuration is EMPTY');
                return;
            }

            // check column configs
            if (!empty($reportConfig->columnConfigs)) {
                foreach ($reportConfig->columnConfigs as $key => $value) {
                    if (empty($value->columnId)) {
                        unset($reportConfig->columnConfigs[$key]);
                    }
                }

                $node->field_report_conf[$node->language][0]['value'] = json_encode($reportConfig);
                node_save($node);
            }
        }
    }

    public function load(AbstractMetaModel $environment_metamodel, array $filters = NULL) {
        LogHelper::log_notice(t('Loading Environment Meta Model from settings.php ...'));

        $datasourceCount = 0;

        $configurationDataSources = Environment::getInstance()->getConfigurationSection('Data Sources');
        if (isset($configurationDataSources)) {
            foreach ($configurationDataSources as $namespace => $sourceDataSources) {
                foreach ($sourceDataSources as $datasourceName => $sourceDataSource) {
                    $datasourceName = NameSpaceHelper::resolveNameSpace($namespace, $datasourceName);

                    $datasource = new DataSourceMetaData();
                    $datasource->name = $datasourceName;
                    $datasource->initializeFrom($sourceDataSource);
                    // it is possible that configuration contains 'readonly' property. We need to honor it
                    // ... and only when it is not set we mark the data source as read only
                    if (!isset($datasource->readonly)) {
                        $datasource->readonly = TRUE;
                    }

                    $environment_metamodel->registerDataSource($datasource);

                    $datasourceCount++;
                }
            }
        }

        LogHelper::log_info(t('Processed @datasourceCount data sources', array('@datasourceCount' => $datasourceCount)));
    }

    public function apply ( $patients ) {
        if ( !is_array($patients) ) {
            $patients = array($patients);
        }

        foreach ( $patients as $patient ) {
            \LogHelper::log_info('Applying ReportRepairDataset treatment to: ' . $patient->reportNodeId);

            $reportNode = node_load($patient->reportNodeId);
            $reportConfigText = get_node_field_value($reportNode, 'field_report_conf', 0, 'value', FALSE);

            $reportConfig = isset($reportConfigText) ? json_decode($reportConfigText) : NULL;
            if (!isset($reportConfig)) {
                \LogHelper::log_info('Report configuration is EMPTY');
                continue;
            }

            // check columns
            if (!empty($reportConfig->model->datasets)) {
                $reportNode->field_report_dataset_sysnames[$reportNode->language] = array();
                foreach ($reportConfig->model->datasets as $datasetName) {
                    $reportNode->field_report_dataset_sysnames[$reportNode->language][] = array('value' => $datasetName);
                }
                node_save($reportNode);
            }

        }
    }

 public final function join(JoinController_SourceConfiguration $sourceConfigurationA, JoinController_SourceConfiguration $sourceConfigurationB)
 {
     $timeStart = microtime(TRUE);
     $result = $this->joinSourceConfigurations($sourceConfigurationA, $sourceConfigurationB);
     LogHelper::log_info(t('@className execution time: !executionTime', array('@className' => get_class($this), '!executionTime' => ExecutionPerformanceHelper::formatExecutionTime($timeStart))));
     return $result;
 }

    public function apply ( $patients ) {

        if ( !is_array($patients) ) {
            $patients = array($patients);
        }

        foreach ( $patients as $patient ) {
            \LogHelper::log_info('Applying ReportConfigRemoveFilter treatment to: ' . $patient->reportNodeId);

            $node = node_load($patient->reportNodeId);

            $reportConfigText = get_node_field_value($node, 'field_report_conf', 0, 'value', FALSE);
            $reportConfig = isset($reportConfigText) ? json_decode($reportConfigText) : NULL;
            if (!isset($reportConfig)) {
                \LogHelper::log_info('Report configuration is EMPTY');
                return;
            }

            // check column configs
            if (!empty($reportConfig->model->filters)) {
                $preservedFilters = array();
                foreach ($reportConfig->model->filters as $key => $filter) {
                    if ( $patient->filter != $filter ) {
                        $preservedFilters[] = $filter;
                    }
                }
                $reportConfig->model->filters = $preservedFilters;

                $node->field_report_conf[$node->language][0]['value'] = json_encode($reportConfig);
                node_save($node);
            }
        }
    }

 public function __call($methodName, $args)
 {
     $timeStart = microtime(TRUE);
     $result = call_user_func_array(array($this->instance, $methodName), $args);
     LogHelper::log_info(t('Data Controller execution time for @methodName(): !executionTime', array('@methodName' => $methodName, '!executionTime' => ExecutionPerformanceHelper::formatExecutionTime($timeStart))));
     return $result;
 }

    public function load(AbstractMetaModel $environment_metamodel, array $filters = NULL) {
        LogHelper::log_notice(t('Generating Environment Meta Model for Drupal database connections ...'));

        global $databases;

        $datasourceCount = 0;
        foreach ($databases as $namespace => $connections) {
            foreach ($connections as $datasourceNameOnly => $connection) {
                $datasource = new DataSourceMetaData();
                $datasource->name = NameSpaceHelper::addNameSpace($namespace, $datasourceNameOnly);
                $datasource->markAsPrivate();
                $datasource->readonly = FALSE;
                // setting required properties
                $this->setDataSourceProperty($datasource, $connection, 'type', 'driver');
                // setting other provided properties
                $this->setDataSourceExtensionProperties($datasource, $connection);

                // registering the data source
                $environment_metamodel->registerDataSource($datasource);
                $datasourceCount++;
            }
        }

        // Default database connection is shared because we store common utilities and dimensions there
        $defaultDataSource = $environment_metamodel->getDataSource(self::$DATASOURCE_NAME__DEFAULT);
        $defaultDataSource->shared = TRUE;

        LogHelper::log_info(t('Generated @datasourceCount data sources', array('@datasourceCount' => $datasourceCount)));
    }

    protected function executeManipulationStatementBatch(DataSourceMetaData $datasource, $sqls) {
        $sql = (count($sqls) == 1)
            ? $sqls
            : $this->getExtension('prepareManipulationStatementBatch')->prepare($this, $sqls);

        LogHelper::log_info(new StatementLogMessage('table.DML', $sql));
        return $this->executeStatement($datasource, $sql);
    }

    protected function updateDatasets(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource) {
        $updatedDatasets = NULL;

        // processing meta data for selected datasets
        $columnsProperties = $this->loadColumnsProperties($callcontext, $datasource);
        if (isset($columnsProperties)) {
            foreach ($columnsProperties as $columnProperties) {
                $tableAccessKey = $this->adjustTableName($columnProperties[self::CN_TABLE_NAME]);
                // checking if we need to work with the table
                if (!isset($callcontext->datasets[$tableAccessKey])) {
                    continue;
                }

                $datasets = $callcontext->datasets[$tableAccessKey];

                // invalidating column indexes
                if (!isset($updatedDatasets[$tableAccessKey])) {
                    foreach ($datasets as $dataset) {
                        $dataset->invalidateColumnIndexes();
                    }

                    $updatedDatasets[$tableAccessKey] = TRUE;
                }

                foreach ($datasets as $dataset) {
                    $column = new ColumnMetaData();
                    $column->name = $this->adjustColumnName($columnProperties[self::CN_COLUMN_NAME]);
                    $column->columnIndex = $columnProperties[self::CN_COLUMN_INDEX];
                    // preparing column type
                    $column->type->databaseType = $columnProperties[self::CN_COLUMN_TYPE];
                    $this->generateColumnApplicationType($callcontext, $datasource, $column);

                    // adjusting column properties
                    if (!isset($column->type->applicationType)) {
                        $column->visible = FALSE;
                    }
                    $this->adjustColumnVisibility($callcontext, $column);

                    $dataset->initializeColumnFrom($column);
                }
            }

            // marking all selected datasets as completed
            foreach ($callcontext->datasets as $tableAccessKey => $datasets) {
                if (!isset($updatedDatasets[$tableAccessKey])) {
                    continue;
                }

                foreach ($datasets as $dataset) {
                    $dataset->markAsComplete();
                }
            }
        }

        LogHelper::log_info(t(
            'Processed system meta data about @tableCount table(s) and @columnCount column(s)',
            array('@tableCount' => count($updatedDatasets), '@columnCount' => count($columnsProperties))));
    }

 public function dropDatasetStorage(DataControllerCallContext $callcontext, DropDatasetStorageRequest $request)
 {
     $environment_metamodel = data_controller_get_environment_metamodel();
     $dataset = DatasetTypeHelper::getTableDataset($request->datasetName);
     $datasource = $environment_metamodel->getDataSource($dataset->datasourceName);
     $sql = $this->getExtension('dropTable')->generate($this, $dataset);
     LogHelper::log_info(new StatementLogMessage('table.drop', $sql));
     $this->executeStatement($datasource, $sql);
 }

    protected function executeQuery(DataSourceMetaData $datasource, $operationName, $sql) {
        LogHelper::log_info(new StatementLogMessage("metamodel.system.{$operationName}[{$datasource->type}][{$datasource->name}]", $sql));

        $executionCallContext = new DataControllerCallContext();

        $datasourceQueryHandler = DataSourceQueryFactory::getInstance()->getHandler($datasource->type);

        return $datasourceQueryHandler->executeQuery($executionCallContext, $datasource, $sql);
    }

    public function rollbackTransaction($datasourceName) {
        $environment_metamodel = data_controller_get_environment_metamodel();

        $datasource = $environment_metamodel->getDataSource($datasourceName);

        $sql = $this->getExtension('rollbackTransaction')->generate($this, $datasource);
        LogHelper::log_info(new StatementLogMessage('transaction.rollback', $sql));
        $this->executeStatement($datasource, $sql);
    }

    public function apply ( $patients ) {
        if ( !is_array($patients) ) {
            $patients = array($patients);
        }

        foreach ( $patients as $patient ) {
            \LogHelper::log_info('Applying ReportConfigRemoveColumnLevel treatment to: ' . $patient->reportNodeId);
        }
    }