protected function formatColumnNameImpl($uiMetaDataName) {
$columnName = NULL;
$formattedUIMetaDataName = parent::formatColumnNameImpl($uiMetaDataName);
list($elementNameSpace, $elementName) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($formattedUIMetaDataName);
switch ($elementNameSpace) {
case AbstractAttributeUIMetaData::NAME_SPACE:
list($dimensionName, $dimensionColumnName) = ParameterNameHelper::split($elementName);
// TODO do we need to check for resource?
list(, $columnName) = ReferencePathHelper::splitReference($dimensionName);
$column = $this->dataset->getColumn($dimensionName);
if ($column->type->getReferencedDatasetName() != NULL) {
// this column should not be used
if (isset($dimensionColumnName) && $column->type->getReferencedColumnName() != $dimensionColumnName) {
$columnName = NULL;
}
}
break;
case AbstractMeasureUIMetaData::NAME_SPACE:
throw new IllegalArgumentException(t('Measures are not supported by this result formatter'));
}
return $columnName;
}
protected function detectParameterKind(AbstractCubeQueryRequest $request, CubeMetaData $cube, $parameterName) {
$metamodel = data_controller_get_metamodel();
list($rootName, $leafName) = ParameterNameHelper::split($parameterName);
list($referencedDatasetName, $referencedRootName) = ReferencePathHelper::splitReference($rootName);
// checking that referenced cube exists
$referencedCube = isset($referencedDatasetName)
? $metamodel->getCubeByDatasetName($referencedDatasetName)
: NULL;
$selectedCube = isset($referencedCube) ? $referencedCube : $cube;
$selectedRequest = isset($referencedCube) ? $request->registerReferencedRequest($referencedCube->name) : $request;
// detecting type of the parameter: dimension or measure
$isDimension = $isMeasure = FALSE;
if (isset($leafName)) {
// if dimension column exists - dimension exists too :)
$isDimension = TRUE;
}
else {
// trying to find a measure
$measure = $selectedCube->findMeasure($referencedRootName);
if (isset($measure)) {
$isMeasure = TRUE;
}
else {
$formula = $request->findFormula($referencedRootName);
if (isset($formula)) {
if (isset($formula->isMeasure) && $formula->isMeasure) {
$isMeasure = TRUE;
}
else {
$isDimension = TRUE;
}
}
}
// trying to find a dimension
$dimension = $selectedCube->findDimension($referencedRootName);
if (isset($dimension)) {
$isDimension = TRUE;
}
}
if ($isDimension && $isMeasure) {
throw new IllegalArgumentException(t(
'The parameter refers to both a dimension and a measure: %parameterName',
array('%parameterName' => $parameterName)));
}
if ($isDimension) {
if (isset($referencedCube)) {
throw new IllegalArgumentException(t('Referenced dimensions are not supported yet'));
}
}
return array($selectedRequest, $isDimension, $isMeasure, $referencedRootName, $leafName);
}
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);
}
public function initiateSortingConfiguration($columnName, $isSortAscending = TRUE) {
list($rootName, $leafName) = ParameterNameHelper::split($columnName);
$isFormula = $this->findFormula($rootName) != NULL;
if (!$isFormula) {
StringDataTypeHandler::checkValueAsWord($rootName);
ReferencePathHelper::checkReference($leafName);
}
return new __AbstractCubeQueryRequest_SortingConfiguration($rootName, $leafName, $isSortAscending);
}
public static function parseUIMetaDataName($defaultDatasetName, $uiMetaDataName, array $options = NULL) {
$parsedUIMetaDataName = NULL;
list($elementNameSpace, $name) = AbstractDatasetUIMetaDataGenerator::splitElementUIMetaDataName($uiMetaDataName);
switch ($elementNameSpace) {
case AbstractAttributeUIMetaData::NAME_SPACE:
$parsedUIMetaDataName = new AttributeParsedUIMetaDataName();
list($parsedUIMetaDataName->name, $parsedUIMetaDataName->columnName) = ParameterNameHelper::split($name);
list($parsedUIMetaDataName->datasetName) = ReferencePathHelper::splitReference($parsedUIMetaDataName->name);
break;
case AbstractMeasureUIMetaData::NAME_SPACE:
$parsedUIMetaDataName = new MeasureParsedUIMetaDataName();
$parsedUIMetaDataName->name = $name;
list($parsedUIMetaDataName->datasetName) = ReferencePathHelper::splitReference($parsedUIMetaDataName->name);
break;
case FormulaUIMetaData::NAME_SPACE:
list($datasetName, $formulaName) = ReferencePathHelper::splitReference($name);
// looking for formula configuration
$selectedFormula = NULL;
if (isset($options[AbstractQueryRequest::OPTION__FORMULA_DEF])) {
$formulas = $options[AbstractQueryRequest::OPTION__FORMULA_DEF];
foreach ($formulas as $formula) {
if ($formula->name == $formulaName) {
$selectedFormula = $formula;
break;
}
}
}
if (!isset($selectedFormula)) {
throw new IllegalStateException(t(
'Undefined formula configuration: %formulaName',
array('%formulaName' => $name)));
}
$parsedUIMetaDataName = isset($selectedFormula->isMeasure) && $selectedFormula->isMeasure
? new FormulaMeasureParsedUIMetaDataName()
: new FormulaAttributeParsedUIMetaDataName();
$parsedUIMetaDataName->name = $name;
$parsedUIMetaDataName->datasetName = $datasetName;
break;
default:
throw new UnsupportedOperationException(t('Unsupported UI Meta Data name space: %uiMetaDataName', array('%uiMetaDataName' => $uiMetaDataName)));
}
if (!isset($parsedUIMetaDataName->datasetName)) {
$parsedUIMetaDataName->datasetName = $defaultDatasetName;
}
return $parsedUIMetaDataName;
}
protected function adjustCubeCountRequestImpl(DataControllerCallContext $callcontext, CubeCountRequest $request) {
list($dimensionName) = ParameterNameHelper::split($this->enumerationColumnName);
// we have to find corresponding dimension in this request
$isDirectionFound = FALSE;
if (isset($request->dimensions)) {
foreach ($request->dimensions as $index => $dimension) {
if ($dimension->name == $dimensionName) {
$isDirectionFound = TRUE;
unset($request->dimensions[$index]);
break;
}
}
}
if (!$isDirectionFound) {
throw new IllegalStateException(t(
'Could not find configuration for %dimensionName dimension in the request',
array('%dimensionName' => $dimensionName)));
}
}
