protected function loadFromDirectory(AbstractMetaModel $metamodel, array $filters = NULL, $path, $namespace, $level = 0) {
        $filecount = 0;

        $handle = opendir($path);
        if ($handle !== FALSE) {
            $indent = str_pad('', $level * 4);
            while (($filename = readdir($handle)) !== FALSE) {
                if (is_dir($path . DIRECTORY_SEPARATOR . $filename)) {
                    if ($filename[0] != '.') {
                        $folder = DIRECTORY_SEPARATOR . $filename;

                        $nestedNameSpace = isset($namespace) ? NameSpaceHelper::addNameSpace($namespace, $filename) : $filename;

                        LogHelper::log_debug(t("{$indent}Scanning '@folderName' ...", array('@folderName' => $folder)));
                        $filecount += $this->loadFromDirectory($metamodel, $filters, $path . $folder, $nestedNameSpace, $level + 1);
                    }
                }
                elseif ($this->fileNameEndsWithJson($filename)) {
                    LogHelper::log_debug(t("{$indent}Processing '@filename' ...", array('@filename' => $filename)));

                    $this->loadFromFile($metamodel, $filters, $namespace, $path . DIRECTORY_SEPARATOR, $filename);
                    $filecount++;
                }
            }

            closedir($handle);
        }

        return $filecount;
    }
    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 assembleCacheEntryName($name) {
        $cacheEntryName = $name;
        if (isset($this->prefix)) {
            $cacheEntryName = isset($name) ? NameSpaceHelper::addNameSpace($this->prefix, $name) : $this->prefix;
        }

        return $cacheEntryName;
    }
    protected function getRequestId() {
        $requestId = &drupal_static(__CLASS__ . '::requestId');
        if (!isset($requestId)) {
            $sequenceName = NameSpaceHelper::addNameSpace(get_class($this), 'requestId');
            $requestId = Sequence::getNextSequenceValue($sequenceName);
        }

        return $requestId;
    }
 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;
 }
function testDatasetUploader_registerDatasetStorage($dataset)
{
    $dataController = data_controller_get_instance();
    echo "<h2>Registering dataset</h2>\n";
    $nameSuffix = uniqid();
    $dataset->name = NameSpaceHelper::addNameSpace(DrupalDataSourceHandler::$NAME_SPACE__DEFAULT, $nameSuffix);
    $dataset->source = TABLE_PREFIX . $nameSuffix;
    $dataset->datasourceName = DrupalDataSourceHandler::$DATASOURCE__DEFAULT;
    $dataController->registerDatasetStorage(DrupalDataSourceHandler::$NAME_SPACE__DEFAULT, $dataset);
    $cube = StarSchemaCubeMetaData::initializeFromDataset(DrupalDataSourceHandler::$DATASOURCE__DEFAULT, $dataset);
    $dataController->registerCubeStorage(DrupalDataSourceHandler::$NAME_SPACE__DEFAULT, $cube);
    echo "{$dataset->name}\n";
}
    public function __construct($prefix, DataSourceMetaData $datasource = NULL) {
        LogHelper::log_notice(t('[@cacheType] Initializing PHP extension ...', array('@cacheType' => $this->getCacheType())));

        // taking into account possible datasource's nested name space
        $adjustedPrefix = isset($datasource->nestedNameSpace)
            ? (isset($prefix) ? NameSpaceHelper::addNameSpace($datasource->nestedNameSpace, $prefix) : $datasource->nestedNameSpace)
            : $prefix;
        parent::__construct($adjustedPrefix);

        if ($this->initialize($prefix, $datasource) !== FALSE) {
            $this->checkAccessibility(FALSE);
        }
    }
 public function __construct($prefix, DataSourceMetaData $datasource)
 {
     LogHelper::log_notice(t('[@cacheType] Initializing PHP extension ...', array('@cacheType' => $this->getCacheType())));
     // taking into account possible datasource's nested name space
     $adjustedPrefix = isset($datasource->nestedNameSpace) ? NameSpaceHelper::addNameSpace($prefix, $datasource->nestedNameSpace) : $prefix;
     parent::__construct($adjustedPrefix);
     // the optional datasource can have its own expiration schedule
     if (isset($datasource->entryExpiration)) {
         $this->entryExpiration = $datasource->entryExpiration;
     }
     if ($this->initialize($prefix, $datasource) !== FALSE) {
         $this->checkAccessibility(FALSE);
     }
 }
    protected function getMetaDataStorageProperties(DataControllerCallContext $callcontext, $sourceDatasetName) {
        $metamodel = data_controller_get_metamodel();

        $dataset = $metamodel->getDataset($sourceDatasetName);

        $databaseName = $dataset->source->database;

        $namespace = NameSpaceHelper::getNameSpace($dataset->name);

        $metadataDatasetName = NameSpaceHelper::addNameSpace($namespace, self::$DATASET__METADATA);
        $schemaDocumentId = self::$PROPERTY__DOCUMENT_IDENTIFIER__SCHEMA_TEMPLATE . '@' . $databaseName;

        return array($metadataDatasetName, $schemaDocumentId);
    }
    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)));
    }
    public function flush() {
        if (!isset($this->recordsHolder)) {
            return;
        }

        $datasetName = NameSpaceHelper::addNameSpace(DATASOURCE_NAME__HEALTH_MONITORING, 'hm_trails');

        // generating and assigning primary key
        $identifiers = Sequence::getNextSequenceValues($datasetName, count($this->recordsHolder->records));
        foreach ($this->recordsHolder->records as $index => $recordInstance) {
            $recordInstance->setColumnValue(0, $identifiers[$index]);
        }

        // storing data in the database
        $dataManipulationController = data_controller_dml_get_instance();
        $dataManipulationController->insertDatasetRecordBatch($datasetName, $this->recordsHolder);

        $this->recordsHolder = NULL;
    }
Beispiel #12
0
 protected function assembleCacheEntryName($name)
 {
     return isset($this->prefix) ? NameSpaceHelper::addNameSpace($this->prefix, $name) : $name;
 }
 public function getLocalCacheHandler($prefix)
 {
     $handlerKey = NameSpaceHelper::addNameSpace($prefix, InMemoryCacheHandler::$CACHE__TYPE);
     if (isset($this->handlerInstances[$handlerKey])) {
         $handler = $this->handlerInstances[$handlerKey];
     } else {
         $handler = $this->initializeLocalCache($prefix);
         $this->handlerInstances[$handlerKey] = $handler;
     }
     return $handler;
 }
 public static function prepareElementUIMetaDataName($namespace, $name) {
     return NameSpaceHelper::addNameSpace($namespace, $name);
 }
 public function assembleResourceName($resourceType, $name) {
     return NameSpaceHelper::addNameSpace($resourceType, $name);
 }
    public function getLocalCacheHandler($prefix) {
        $handlerKey = isset($prefix) ? $prefix : (get_class($this) . '.local');
        $handlerKey = NameSpaceHelper::addNameSpace($handlerKey, InMemoryCacheHandler::CACHE__TYPE);

        if (isset($this->handlers[$handlerKey])) {
            $handler = $this->handlers[$handlerKey];
        }
        else {
            $handler = $this->initializeLocalCache($prefix);
            $this->handlers[$handlerKey] = $handler;
        }

        return $handler;
    }
    protected function populateDatasets() {
        $metamodel = data_controller_get_metamodel();

        $namespaceParts = explode(NameSpaceHelper::NAME_SPACE_SEPARATOR, DATASOURCE_NAME__TEST);
        $path = realpath(drupal_get_path('module', 'gd_test'))
            . DIRECTORY_SEPARATOR . '_db'
            . DIRECTORY_SEPARATOR . 'data'
            . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $namespaceParts);

        $handle = opendir($path);
        if ($handle !== FALSE) {
            while (($name = readdir($handle)) !== FALSE) {
                if ($name[0] == '.') {
                    continue;
                }

                $fullname = $path . DIRECTORY_SEPARATOR . $name;

                if (!is_dir($fullname)) {
                    continue;
                }

                $datasetName = NameSpaceHelper::addNameSpace(DATASOURCE_NAME__TEST, $name);
                $dataset = $metamodel->findDataset($datasetName);
                if (!isset($dataset)) {
                    continue;
                }

                $folderName = $fullname;
                $this->populateDataset($dataset, $folderName);
            }
            closedir($handle);
        }
    }
    protected function processConfig ( &$config ) {
        //  TODO Services casts everything to array not objects
        $config = (object) $config;
        $config->model = (object) $config->model;
        $metamodel = data_controller_get_metamodel();
        if ( !empty($config->model->datasets) ) {
            foreach ( $config->model->datasets as $key => $datasetIdentifier ) {
                $dataset = GD_DatasetMetaModelLoaderHelper::findDatasetByUUID($this->datasets,$datasetIdentifier);
                if (!isset($dataset)) {
                    $datasetName = NameSpaceHelper::addNameSpace(gd_datasource_get_active(), $datasetIdentifier);
                    $dataset = $metamodel->getDataset($datasetName);
                }
                $config->model->datasets[$key] = $dataset->name;
            }
        }

        // update columns
        if ( !empty($config->model->columns) ) {
            foreach ( $config->model->columns as $key => $value ) {
                $config->model->columns[$key] = DatasetImportHelper::getNewColumnName($value,$this->datasets);
            }
        }

        // update column configs
        if ( !empty($config->columnConfigs) ) {
            foreach ( $config->columnConfigs as $key => $value ) {
                $config->columnConfigs[$key]->columnId = DatasetImportHelper::getNewColumnName($value->columnId,$this->datasets);
            }
        }

        // update column orders
        if ( !empty($config->model->columnOrder) ) {
            foreach ( $config->model->columnOrder as $key => $value ) {
                $config->model->columnOrder[$key] = DatasetImportHelper::getNewColumnName($value,$this->datasets);
            }
        }

        // update column sorts
        if ( !empty($config->model->orderBy) ) {
            foreach ( $config->model->orderBy as $key => $value ) {
                $config->model->orderBy[$key]->column = DatasetImportHelper::getNewColumnName($value->column,$this->datasets);
            }
        }

        // update filters
        if ( !empty($config->model->filters) ) {
            foreach ( $config->model->filters as $key => $value ) {
                $config->model->filters[$key]->column = DatasetImportHelper::getNewColumnName($value->column,$this->datasets);
            }
        }

        // update visual series
        if ( !empty($config->visual->series) ) {
            $newSeries = array();
            foreach ( $config->visual->series as $key => $value ) {
                $newSeries[DatasetImportHelper::getNewColumnName($key,$this->datasets)] = $value;
            }
            $config->visual->series = $newSeries;
        }

        // update traffic column
        if ( !empty($config->visual->trafficColumn) ) {
            $config->visual->trafficColumn = DatasetImportHelper::getNewColumnName($config->visual->trafficColumn,$this->datasets);
        }

        // update color column
        if ( !empty($config->visual->useColumnDataForColor) ) {
            $config->visual->useColumnDataForColor = DatasetImportHelper::getNewColumnName($config->visual->useColumnDataForColor,$this->datasets);
        }

        // update traffic columns
        if ( !empty($config->visual->traffic) ) {
            $newTraffic = array();
            foreach ( $config->visual->traffic as $key => $value ) {
                $newName = DatasetImportHelper::getNewColumnName($key,$this->datasets);
                $value->trafficColumn = $newName;
                $newTraffic[$newName] = $value;
            }
            $config->visual->traffic = $newTraffic;
        }
    }
    public static function prepareDataset(MetaModel $metamodel, $datasetNode, array $datasetColumnNodes = NULL, DataSourceMetaData $datasource) {
        $dataset = new DatasetMetaData();
        $dataset->name = get_node_field_value($datasetNode, 'field_dataset_sysname', 0, 'value', TRUE);
        $dataset->publicName = $datasetNode->title;

        // preparing the dataset alternative names (aliases)
        $aliasIndex = 0;
        while (($alias = get_node_field_value($datasetNode, 'field_dataset_alias', $aliasIndex)) != NULL) {
            $dataset->aliases[] = $alias;

            $aliasIndex++;
        }

        $dataset->description = get_node_field_value($datasetNode, 'field_dataset_desc');

        $dataset->datasourceName = $datasource->name;

        // preparing source configuration properties
        $dataset->sourceType = get_node_field_value($datasetNode, 'field_dataset_source_type', 0, 'value', TRUE);
        $dataset->source = get_node_field_value($datasetNode, 'field_dataset_source', 0, 'value', TRUE);
        // preparing source properties as an associative array
        $dataset->configuration = get_node_field_object_value($datasetNode, 'field_dataset_source_properties');

        // dataset system properties
        $dataset->uuid = get_node_field_value($datasetNode, 'field_dataset_uuid', 0, 'value', TRUE);
        $dataset->nid = $datasetNode->nid;

        // preparing dataset columns
        if (isset($datasetColumnNodes)) {
            foreach ($datasetColumnNodes as $columnNode) {
                $column = $dataset->initiateColumn();
                $column->used = $columnNode->status == NODE_PUBLISHED;

                $column->name = get_node_field_value($columnNode, 'field_column_sysname', 0, 'value', TRUE);
                $column->publicName = $columnNode->title;
                $column->description = get_node_field_value($columnNode, 'field_column_desc');
                $column->key = get_node_field_boolean_value($columnNode, 'field_column_key');

                // column data type
                $column->type->applicationType = get_node_field_value($columnNode, 'field_column_datatype', 0, 'value', $column->used);
                if (isset($column->type->applicationType) && ($column->type->getReferencedDatasetName() == NULL)) {
                    $column->type->logicalApplicationType = NameSpaceHelper::addNameSpace(NAME_SPACE__STAR_SCHEMA, $column->type->applicationType);
                }
                $format = get_node_field_object_value($columnNode, 'field_column_format');
                if (isset($format->scale)) {
                    $column->type->scale = $format->scale;
                }

                $column->columnIndex = get_node_field_int_value($columnNode, 'field_column_index', 0, 'value', TRUE);
                $column->source = get_node_field_value($columnNode, 'field_column_source');
                $column->persistence = get_node_field_int_value($columnNode, 'field_column_persistence', 0, 'value', TRUE);

                // attribute system properties
                $column->nid = $columnNode->nid;

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

        // marking that the dataset object contains complete meta data
        $dataset->markAsComplete();

        $metamodel->registerDataset($dataset);

        return $dataset;
    }
    protected function generateDatasets(SystemTableMetaModelLoaderCallContext $callcontext, DataSourceMetaData $datasource) {
        $columnsProperties = $this->loadColumnsProperties($callcontext, $datasource);
        if (isset($columnsProperties)) {
            foreach ($columnsProperties as $columnProperties) {
                $tableOwner = $this->adjustOwnerName($columnProperties[self::CN_TABLE_OWNER]);

                $originalTableName = $columnProperties[self::CN_TABLE_NAME];
                $tableName = $this->adjustTableName($originalTableName);
                if (!$this->isTableSupported($callcontext, $tableName)) {
                    continue;
                }

                $tableAccessKey = ArrayHelper::prepareCompositeKey(array($tableOwner, $tableName));

                // checking if we can process the column name
                $originalColumnName = $columnProperties[self::CN_COLUMN_NAME];
                $columnName = $this->adjustColumnName($originalColumnName);
                $generatedColumnName = $this->nameGenerator->generate($columnName);
                // this column cannot be supported by the system
                if ($columnName != $generatedColumnName) {
                    LogHelper::log_warn(t(
                        "Unsupported column name from '@tableName' table: @columnName",
                        array('@tableName' => $originalTableName, '@columnName' => $originalColumnName)));
                    continue;
                }

                // preparing new dataset
                if (!isset($callcontext->datasets[$tableAccessKey])) {
                    $source =  TableReferenceHelper::assembleTableReference($tableOwner, $tableName);

                    $dataset = new DatasetMetaData();
                    $dataset->name = NameSpaceHelper::addNameSpace($datasource->name, $this->nameGenerator->generate($tableName));
                    $dataset->publicName = $this->generateTablePublicName($originalTableName);
                    $dataset->datasourceName = $datasource->name;
                    $dataset->source = $source;
                    $dataset->markAsPrivate();

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

                // adding new column to the dataset
                $column = $dataset->initiateColumn();
                $column->name = $columnName;
                $column->publicName = $this->generateColumnPublicName($originalColumnName);
                $column->persistence = ColumnMetaData::PERSISTENCE__STORAGE_CREATED;
                $column->columnIndex = $columnProperties[self::CN_COLUMN_INDEX];
                $column->type->databaseType = $columnProperties[self::CN_COLUMN_TYPE];
                if (isset($columnProperties[self::CN_COLUMN_TYPE_LENGTH])) {
                    $column->type->length = $columnProperties[self::CN_COLUMN_TYPE_LENGTH];
                }
                if (isset($columnProperties[self::CN_COLUMN_TYPE_PRECISION])) {
                    $column->type->precision = $columnProperties[self::CN_COLUMN_TYPE_PRECISION];
                }
                if (isset($columnProperties[self::CN_COLUMN_TYPE_SCALE])) {
                    $column->type->scale = $columnProperties[self::CN_COLUMN_TYPE_SCALE];
                }
                $this->generateColumnApplicationType($callcontext, $datasource, $column);

                // adjusting column properties
                if (!isset($column->type->applicationType)) {
                    $column->visible = FALSE;
                    LogHelper::log_warn(t(
                        "Data type is not supported for '@columnName' column from '@tableName' table: @databaseDataType",
                        array(
                            '@tableName' => $originalTableName,
                            '@columnName' => $originalColumnName,
                            '@databaseDataType' => $column->type->databaseType)));
                }
                $this->adjustColumnVisibility($callcontext, $column);

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

        LogHelper::log_info(t(
            'Processed system meta data about @tableCount table(s) and @columnCount column(s)',
            array('@tableCount' => count($callcontext->datasets), '@columnCount' => count($columnsProperties))));
    }
 public static function getDatasetName($contentTypeName)
 {
     // FIXME cache it somewhere
     list($namespace) = NameSpaceHelper::splitAlias(AbstractDrupalDataSourceQueryProxy::$DATASOURCE_NAME__DEFAULT);
     return NameSpaceHelper::addNameSpace($namespace, self::$DATASET__PREFIX . $contentTypeName);
 }