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);
}
}
protected function getHandlerClassName($datatype) {
$classname = isset($this->handlerConfigurations[$datatype]['classname']) ? $this->handlerConfigurations[$datatype]['classname'] : NULL;
if (!isset($classname)) {
LogHelper::log_info(t('Supported data types:'));
LogHelper::log_info(isset($this->handlerConfigurations) ? array_keys($this->handlerConfigurations) : NULL);
throw new IllegalArgumentException(t('Unsupported data type: %datatype', array('%datatype' => $datatype)));
}
return $classname;
}
public function apply ( $patients ) {
if ( !is_array($patients) ) {
$patients = array($patients);
}
foreach ( $patients as $patient ) {
\LogHelper::log_info('Applying DeleteReport treatment to: '.$patient->reportNodeId);
node_delete($patient->reportNodeId);
}
}
public function setValues($values, $expiration = NULL)
{
$timeStart = microtime(TRUE);
$errorEntryNames = parent::setValues($values, $expiration);
$entryCount = count($values);
$errorEntryCount = count($errorEntryNames);
$successfulEntryCount = $entryCount - $errorEntryCount;
LogHelper::log_info(t("[@cacheType] Execution time for @successFlag storing of @entryCount entries is !executionTime", array('@cacheType' => $this->getCacheType(), '@entryCount' => $errorEntryCount == 0 ? $entryCount : ($successfulEntryCount == 0 ? $entryCount : "{$successfulEntryCount} out of {$entryCount}"), '!executionTime' => ExecutionPerformanceHelper::formatExecutionTime($timeStart), '@successFlag' => $errorEntryCount == 0 ? 'SUCCESSFUL' : ($successfulEntryCount == 0 ? 'UNSUCCESSFUL' : 'successful'))));
// some errors but also some success
return $errorEntryNames;
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $environment_metamodel, array $filters = NULL, $finalAttempt)
{
LogHelper::log_notice(t('Generating Environment Meta Model for APC cache ...'));
$datasourceCount = 0;
$datasource = new DataSourceMetaData();
$datasource->name = NameSpaceHelper::addNameSpace(APCHandler::$CACHE__TYPE, DefaultCacheFactory::$DATASOURCE_NAME__DEFAULT);
$datasource->type = APCHandler::$CACHE__TYPE;
$environment_metamodel->registerDataSource($datasource);
$datasourceCount++;
LogHelper::log_info(t('Generated @datasourceCount data sources', array('@datasourceCount' => $datasourceCount)));
return self::LOAD_STATE__SUCCESSFUL;
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $environment_metamodel, array $filters = NULL) {
LogHelper::log_notice(t('Generating Environment Meta Model for PHP dataset functionality ...'));
$datasourceCount = 0;
$datasource = new DataSourceMetaData();
$datasource->name = PHPDataSourceHandler::$DATASOURCE_NAME__DEFAULT;
$datasource->type = PHPDataSourceHandler::$DATASOURCE__TYPE;
$environment_metamodel->registerDataSource($datasource);
$datasourceCount++;
LogHelper::log_info(t('Generated @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 DeleteDataset treatment to: '.$patient->datasetNodeId);
// remove columns
$columnNodeIds = gd_column_get_columns_4_dataset($patient->datasetNodeId, LOAD_ENTITY_ID_ONLY, INCLUDE_UNPUBLISHED);
if ( !empty($columnNodeIds) ) {
node_delete_multiple($columnNodeIds);
}
node_delete($patient->datasetNodeId);
}
}
public function load(AbstractMetaModel $environment_metamodel, array $filters = NULL) {
LogHelper::log_notice(t('Generating Environment Meta Model for APC cache ...'));
$datasourceCount = 0;
$datasource = new DataSourceMetaData();
$datasource->name = NameSpaceHelper::addNameSpace(APCHandler::CACHE__TYPE, 'default');
$datasource->type = APCHandler::CACHE__TYPE;
$datasource->category = CacheFactory::$DATASOURCE__CATEGORY;
$datasource->markAsPrivate();
$environment_metamodel->registerDataSource($datasource);
$datasourceCount++;
LogHelper::log_info(t('Generated @datasourceCount data sources', array('@datasourceCount' => $datasourceCount)));
}
private function scanReportConfigs () {
$this->affected = array();
$query = new \EntityFieldQuery();
$query->entityCondition('entity_type', 'node');
$query->propertyCondition('type', NODE_TYPE_REPORT);
$query->propertyCondition('status', NODE_PUBLISHED);
$query->addTag('DANGEROUS_ACCESS_CHECK_OPT_OUT');
$result = $query->execute();
$reportNids = isset($result['node']) ? array_keys($result['node']) : NULL;
$reportNodes = node_load_multiple($reportNids);
foreach ( $reportNodes as $node ) {
\LogHelper::log_info(t('Inspecting report @nid', array('@nid' => $node->nid)));
$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');
continue;
}
// loop through filters
if (!empty($reportConfig->model->filters)) {
foreach ($reportConfig->model->filters as $key => $value) {
$result = $this->detectInvalidFilter($value);
if ($result) {
$patient = array(
'info' => array(
'reportNodeId' => $node->nid,
'reportTitle' => $node->title,
'filter' => $value,
'published' => $node->status,
'configPath' => 'model/filters'
),
'notes' => $result
);
$this->attachTreatment($patient);
$this->affected[] = $patient;
}
}
}
}
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $metamodel, array $filters = NULL, $finalAttempt)
{
$metamodelTypeFolder = $this->getMetaModelFolderName();
$filecount = 0;
$metamodelConfigurations = module_invoke_all('dc_metamodel');
foreach ($metamodelConfigurations as $metamodelConfiguration) {
$path = $metamodelConfiguration['path'] . DIRECTORY_SEPARATOR . $metamodelTypeFolder . DIRECTORY_SEPARATOR . 'metadata';
// initial name space is not defined. It will be based on subfolder name, if any
$namespace = NULL;
$simplifiedPath = PathHelper::simplifyPath($path);
LogHelper::log_info(t("Loading configuration from '@path' ...", array('@path' => $simplifiedPath)));
if (!file_exists($path)) {
throw new IllegalStateException(t('Folder could not be found: @path', array('@path' => $simplifiedPath)));
}
$filecount += $this->loadFromDirectory($metamodel, $filters, $path, $namespace);
}
LogHelper::log_info(t('Processed @filecount files', array('@filecount' => $filecount)));
return self::LOAD_STATE__SUCCESSFUL;
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $environment_metamodel, array $filters = NULL, $finalAttempt)
{
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->system = TRUE;
$datasource->readonly = TRUE;
$datasource->initializeFrom($sourceDataSource);
$environment_metamodel->registerDataSource($datasource);
$datasourceCount++;
}
}
}
LogHelper::log_info(t('Processed @datasourceCount data sources', array('@datasourceCount' => $datasourceCount)));
return self::LOAD_STATE__SUCCESSFUL;
}
protected function generateCubes(SystemTableMetaModelLoaderCallContext $callcontext, AbstractMetaModel $metamodel) {
$cubeCount = 0;
$loaderName = $this->getName();
foreach ($callcontext->logicalDatasets as $tableAccessKey => $logicalDataset) {
$dataset = $callcontext->datasets[$tableAccessKey];
$cubeName = $logicalDataset->name;
$cube = new CubeMetaData();
$cube->name = $cubeName;
$cube->publicName = $logicalDataset->publicName;
$cube->description = $logicalDataset->description;
$cube->factsDatasetName = $dataset->name;
$cube->factsDataset = $dataset;
foreach ($logicalDataset->columns as $logicalColumn) {
StarSchemaCubeMetaData::initializeDimensionFromColumn($metamodel, $cube, $logicalDataset, $logicalColumn->name);
// FIXME fixing dimensions and pointing to physical datasets instead. Remove the following block once we remove support for logical datasets in cubes
// FIXME remove support for $callcontext->logicalDatasetNameMappings property as well
$dimension = $cube->findDimension($logicalColumn->name);
if (isset($dimension) && isset($dimension->datasetName)) {
$dimensionLogicalDatasetName = $dimension->datasetName;
$dimensionTableAccessKey = $callcontext->logicalDatasetNameMappings[$dimensionLogicalDatasetName];
$dimensionDataset = $callcontext->datasets[$dimensionTableAccessKey];
$dimension->datasetName = $dimensionDataset->name;
$dimension->dataset = $dimensionDataset;
}
}
foreach ($logicalDataset->columns as $logicalColumn) {
StarSchemaCubeMetaData::initializeMeasuresFromColumn($cube, $logicalDataset, $logicalColumn->name);
}
StarSchemaCubeMetaData::registerCubeMeasures($cube);
$cube->loaderName = $loaderName;
$cube->markAsComplete();
$metamodel->registerCube($cube);
$cubeCount++;
}
LogHelper::log_info(t('Generated and registered @cubeCount cubes', array('@cubeCount' => $cubeCount)));
}
public function countDatasetRecords(DataControllerCallContext $callcontext, DatasetCountRequest $request) {
$datasetName = $request->getDatasetName();
LogHelper::log_notice(t('Counting script-based dataset records: @datasetName', array('@datasetName' => $datasetName)));
$metamodel = data_controller_get_metamodel();
$dataset = $metamodel->getDataset($datasetName);
$serializer = new DatasetCountUIRequestSerializer();
$parameters = $serializer->serialize($request);
$count = $this->executeScriptFunction($dataset, 'countDatasetRecords', $parameters);
LogHelper::log_info(t('Counted @count record(s)', array('@count' => $count)));
return $count;
}
*/
/**
* Script to send notification emails
*/
require_once DRUPAL_ROOT . '/includes/bootstrap.inc';
drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
//_drush_bootstrap_drupal_full();
try {
$completedJobRequests = QueueUtil::getPendingEmailsInfo();
LogHelper::log_debug($completedJobRequests);
} catch (Exception $claimException) {
LogHelper::log_debug("{$logId}: Error while fetching job from queue: " . $claimException);
return;
}
foreach ($completedJobRequests as $request) {
LogHelper::log_info($request);
try {
global $conf;
$dir = variable_get('file_public_path', 'sites/default/files') . '/' . $conf['check_book']['data_feeds']['output_file_dir'];
$file = $dir . '/' . $request['filename'];
$params = array("download_url" => $file, "download_url_compressed" => $file . '.zip', "expiration_date" => date('d-M-Y', $request['end_time'] + 3600 * 24 * 7), "contact_email" => $request['contact_email'], "tracking_num" => $request['token']);
LogHelper::log_debug($params);
$response = drupal_mail('checkbook_datafeeds', "download_notification", $request['contact_email'], null, $params);
LogHelper::log_debug($response);
if ($response['result']) {
QueueUtil::updateJobRequestEmailStatus($request['rid']);
}
} catch (Exception $claimException) {
LogHelper::log_debug("Error while Sending Email Notification: " . $claimException . $params);
return;
}
public function load(AbstractMetaModelFactory $factory, AbstractMetaModel $metamodel, array $filters = NULL, $finalAttempt)
{
$selectedDataSourceType = $this->selectedDataSourceType();
LogHelper::log_notice(t("Finalizing Dataset Meta Data for '@databaseType' database connections ...", array('@databaseType' => $selectedDataSourceType)));
if ($finalAttempt === FALSE) {
return self::LOAD_STATE__POSTPONED;
}
$finalizedDatasetCount = 0;
$environment_metamodel = data_controller_get_environment_metamodel();
// processing all database connections
foreach ($environment_metamodel->datasources as $datasource) {
if ($datasource->type !== $selectedDataSourceType) {
continue;
}
// selecting datasets which could be processed for the selected connection
$selectedSources = NULL;
foreach ($metamodel->datasets as $dataset) {
// the dataset should belong to the selected data source
if ($dataset->datasourceName !== $datasource->name) {
continue;
}
// the dataset has to be of type table
if (DatasetTypeHelper::detectDatasetSourceType($dataset) !== DatasetTypeHelper::DATASET_SOURCE_TYPE__TABLE) {
continue;
}
// whole dataset meta data was prepared using different method. There is nothing else can be done
if ($dataset->isComplete()) {
continue;
}
$tableName = strtolower($dataset->source);
// invalidating existing column indexes
$dataset->invalidateColumnIndexes();
// there could be several datasets for one table
$selectedSources[$tableName][] = $dataset;
}
if (!isset($selectedSources)) {
continue;
}
$datasourceHandler = DataSourceQueryFactory::getInstance()->getHandler($datasource->type);
$metadataCallback = $datasourceHandler->prepareQueryStatementExecutionCallbackInstance();
// processing meta data for selected datasets
$columnsMetaDataProperties = $this->prepareColumnsMetaDataProperties($datasource, array_keys($selectedSources));
if (isset($columnsMetaDataProperties)) {
foreach ($columnsMetaDataProperties as $columnMetaDataProperties) {
$tableName = strtolower($columnMetaDataProperties[self::PROPERTY__TABLE_NAME]);
$datasets = $selectedSources[$tableName];
foreach ($datasets as $dataset) {
$column = new ColumnMetaData();
$column->name = strtolower($columnMetaDataProperties[self::PROPERTY__COLUMN_NAME]);
$column->columnIndex = $columnMetaDataProperties[self::PROPERTY__COLUMN_INDEX];
// preparing column type
$column->type->databaseType = $columnMetaDataProperties[self::PROPERTY__COLUMN_TYPE];
$column->type->applicationType = $metadataCallback->calculateApplicationDataType($column);
// checking if the column is a system column which should be invisible
if (substr_compare($column->name, DatasetSystemColumnNames::COLUMN_NAME_PREFIX, 0, strlen(DatasetSystemColumnNames::COLUMN_NAME_PREFIX)) === 0) {
$column->visible = FALSE;
}
$dataset->initializeColumnFrom($column);
}
}
}
// marking all selected datasets as completed
foreach ($selectedSources as $datasets) {
foreach ($datasets as $dataset) {
$dataset->markAsComplete();
$finalizedDatasetCount++;
}
}
}
LogHelper::log_info(t('Finalized @datasetCount dataset meta data configurations', array('@datasetCount' => $finalizedDatasetCount)));
return self::LOAD_STATE__SUCCESSFUL;
}
public function findCompletedHandler() {
$this->checkInitiation();
while (TRUE) {
$info = curl_multi_info_read($this->mh);
if ($info === FALSE) {
if ($this->executionState) {
curl_multi_select($this->mh);
do {
$mrc = curl_multi_exec($this->mh, $this->executionState);
}
while ($mrc == CURLM_CALL_MULTI_PERFORM);
if ($mrc != CURLM_OK) {
throw new IllegalStateException(t(
'Multi-thread execution could not be completed successfully: %errorCode',
array('%errorCode' => $mrc)));
}
}
else {
// there is nothing else to process
return FALSE;
}
}
else {
$ch = $info['handle'];
$completedHandler = NULL;
foreach ($this->handlers as $handler) {
if ($handler->ch === $ch) {
$completedHandler = $handler;
break;
}
}
if (!isset($completedHandler)) {
throw new IllegalStateException(t('Could not recognize completed thread'));
}
LogHelper::log_info(t('Completed execution of thread for %resourceId resource', array('%resourceId' => $completedHandler->resourceId)));
if ($info['result'] !== CURLE_OK) {
$error = 'Error message is not provided';
$this->errorResourceExecution($completedHandler->resourceId, $error);
}
return $completedHandler;
}
}
return FALSE;
}
