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; }