protected function adjustParameters(AbstractDataQueryControllerRequest $request) {
if (isset($request->parameters)) {
if (is_array($request->parameters) && ArrayHelper::isIndexed($request->parameters)) {
foreach ($request->parameters as $index => $compositeParameter) {
$request->parameters[$index] = $this->adjustCompositeParameter($compositeParameter);
}
}
else {
$request->parameters = $this->adjustCompositeParameter($request->parameters);
}
}
}
public function addCompositeQueryValues($compositeQuery) {
if (!isset($compositeQuery)) {
return;
}
$isIndexedArray = ArrayHelper::isIndexed($compositeQuery);
if ($isIndexedArray && (count($compositeQuery) === 1)) {
$compositeQuery = $compositeQuery[0];
$isIndexedArray = FALSE;
}
if ($isIndexedArray) {
foreach ($compositeQuery as $query) {
$this->addCompositeQueryValues($query);
}
}
else {
$index = count($this->queries);
foreach ($compositeQuery as $name => $value) {
$this->addQueryValues($index, $name, $value);
}
}
}
public static function parseParameters(array $parameters = NULL) {
if (!isset($parameters)) {
return NULL;
}
$adjustedParameters = NULL;
foreach ($parameters as $parameterIndex => $parameterProperties) {
if (!is_array($parameterProperties)) {
$parameterProperties = array($parameterProperties);
}
$isParameterPropertyDetected = FALSE;
$parameterName = NULL;
if (is_int($parameterIndex)) {
if (!isset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__COLUMN_NAME])) {
throw new IllegalArgumentException(t(
'Could not find corresponding column name for the parameter: %parameterIndex',
array('%parameterIndex' => $parameterIndex)));
}
$parameterName = $parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__COLUMN_NAME];
unset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__COLUMN_NAME]);
$isParameterPropertyDetected = TRUE;
}
else {
$parameterName = $parameterIndex;
}
$operatorName = NULL;
if (isset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_NAME])) {
$operatorName = $parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_NAME];
unset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_NAME]);
$isParameterPropertyDetected = TRUE;
}
else {
$operatorName = EqualOperatorHandler::OPERATOR__NAME;
}
$parameterValues = NULL;
if (isset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_VALUE])) {
$parameterValues = $parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_VALUE];
unset($parameterProperties[DataQueryControllerUIParameterNames::PARAMETER__OPERATOR_VALUE]);
$isParameterPropertyDetected = TRUE;
}
if (!$isParameterPropertyDetected) {
$parameterValues = $parameterProperties;
// marking that all properties are processed in the variable
$parameterProperties = NULL;
}
// some properties are left and we do not know what to do with them
if (count($parameterProperties) > 0) {
throw new IllegalArgumentException(t(
'Unsupported keys for parameter definition: %unsupportedKeys',
array('%unsupportedKeys' => implode(', ', array_keys($parameterProperties)))));
}
$operatorValues = NULL;
if (isset($parameterValues)) {
if (ArrayHelper::isIndexed($parameterValues)) {
$operatorValues = $parameterValues;
}
else {
// named operator value parameters are provided
// we need to order the values in the same order as the parameters defined for the operator
$operatorMetaData = OperatorFactory::getInstance()->getOperatorMetaData($operatorName);
$operatorParameterMetaDatas = $operatorMetaData->getParameters();
if (isset($operatorParameterMetaDatas)) {
foreach ($operatorParameterMetaDatas as $operatorParameterMetaData) {
$name = $operatorParameterMetaData->name;
$value = NULL;
if (isset($parameterValues[$name])) {
$value = $parameterValues[$name];
unset($parameterValues[$name]);
}
$operatorValues[] = $value;
}
}
// some named parameters are not recognized
if (count($parameterValues) > 0) {
throw new IllegalArgumentException(t(
'Unsupported keys for parameter value definition: %unsupportedKeys',
array('%unsupportedKeys' => implode(', ', array_keys($parameterValues)))));
}
}
}
$operator = OperatorFactory::getInstance()->initiateHandler($operatorName, $operatorValues);
if (isset($adjustedParameters[$parameterName])) {
$previousOperator = $adjustedParameters[$parameterName];
if (is_array($previousOperator)) {
$adjustedParameters[$parameterName][] = $operator;
}
else {
$adjustedParameters[$parameterName] = array($previousOperator, $operator);
}
}
else {
$adjustedParameters[$parameterName] = $operator;
}
}
return $adjustedParameters;
}
public static function mergeWith(&$instance, $source, $mergeCompositeProperty = FALSE, $existingPropertyRule = self::EXISTING_PROPERTY_RULE__ERROR_IF_PRESENT) {
if (isset($source)) {
if (is_object($source) || is_array($source)) {
$isPropertyIndexed = ArrayHelper::isIndexed($source);
foreach ($source as $name => $value) {
$value = StringHelper::trim($value);
$mergedValue = self::getPropertyValue($instance, $name);
if (is_object($value) || is_array($value)) {
if ($mergeCompositeProperty) {
self::mergeWith($mergedValue, $value, TRUE, $existingPropertyRule);
}
}
else {
if (isset($mergedValue) && isset($value)) {
if (($mergedValue != $value)) {
switch ($existingPropertyRule) {
case self::EXISTING_PROPERTY_RULE__SKIP_IF_PRESENT:
break;
case self::EXISTING_PROPERTY_RULE__OVERRIDE_IF_PRESENT:
$mergedValue = $value;
break;
default:
LogHelper::log_error(t(
"'@propertyName' property already contains value: @existingPropertyValue. Merge cannot be performed with new value: @newPropertyValue",
array('@propertyName' => $name, '@existingPropertyValue' => $mergedValue, '@newPropertyValue' => $value)));
throw new UnsupportedOperationException(t(
'%propertyName property already contains value. Merge cannot be performed',
array('%propertyName' => $name)));
}
}
}
else {
$mergedValue = $value;
}
}
if (!isset($instance)) {
$instance = $isPropertyIndexed ? array() : new stdClass();
}
if ($isPropertyIndexed) {
$instance[$name] = $mergedValue;
}
else {
$instance->$name = $mergedValue;
}
}
}
else {
if (isset($instance)) {
if (($instance != $source)) {
switch ($existingPropertyRule) {
case self::EXISTING_PROPERTY_RULE__SKIP_IF_PRESENT:
break;
case self::EXISTING_PROPERTY_RULE__OVERRIDE_IF_PRESENT:
$instance = $source;
break;
default:
LogHelper::log_error(t(
"The instance already contains value: @existingPropertyValue. Assignment cannot be performed with new value: @newPropertyValue",
array('@existingPropertyValue' => $instance, '@newPropertyValue' => $source)));
throw new UnsupportedOperationException(t('The instance already contains value. Assignment cannot be performed'));
}
}
}
else {
$instance = $source;
}
}
}
return $instance;
}
