protected function registerRecordImpl(array &$records = NULL, $record) {
parent::registerRecordImpl($records, $record);
$value = NULL;
if (isset($this->columnName)) {
$value = isset($record[$this->columnName]) ? $record[$this->columnName] : NULL;
}
else {
$count = count($record);
switch ($count) {
case 0:
// it is the same as NULL
break;
case 1:
$value = reset($record);
break;
default:
throw new IllegalArgumentException(t('Only one column is supported by this result formatter'));
}
}
if (isset($value)) {
if ($this->storage == self::STORAGE__KEY) {
$records[$value] = TRUE;
}
elseif ($this->storage == self::STORAGE__VALUE) {
$records[] = $value;
}
}
return TRUE;
}
protected function registerRecordImpl(array &$records = NULL, $record) {
parent::registerRecordImpl($records, $record);
$recordKey = NULL;
foreach ($this->keyColumnNames as $keyColumnName) {
$recordKey[] = isset($record[$keyColumnName]) ? $record[$keyColumnName] : NULL;
}
$key = ArrayHelper::prepareCompositeKey($recordKey);
if (isset($records[$key])) {
if ($this->isColumnValueUnique) {
throw new IllegalArgumentException(t(
'Found several records for the key: %key',
array('%key' => ArrayHelper::serialize($recordKey, ', ', TRUE, TRUE))));
}
$records[$key][] = $record;
}
else {
if ($this->isColumnValueUnique) {
$records[$key] = $record;
}
else {
$records[$key][] = $record;
}
}
return TRUE;
}
public function formatRecord(array &$records = NULL, $record)
{
$result = parent::formatRecord($records, $record);
if ($result) {
$this->errorUnsupportedChainOfResultFormatters();
}
$object = new stdClass();
foreach ($record as $columnName => $columnValue) {
$index = strpos($columnName, '.');
if ($index === FALSE) {
$object->{$columnName} = $columnValue;
} else {
$properties = explode('.', $columnName);
$obj = $object;
for ($i = 0, $count = count($properties); $i < $count; $i++) {
$property = $properties[$i];
if ($i == $count - 1) {
$obj->{$property} = $columnValue;
} else {
if (!isset($obj->{$property})) {
$obj->{$property} = new stdClass();
}
$obj = $obj->{$property};
}
}
}
}
$records[] = $object;
return TRUE;
}
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 finishImpl(array &$records = NULL) {
parent::finishImpl($records);
if (!isset($records)) {
return;
}
$valueMin = $valueMax = NULL;
// preparing minimum and maximum values
foreach ($records as $record) {
if (!isset($record[$this->valueColumnName])) {
continue;
}
$value = $record[$this->valueColumnName];
$valueMin = MathHelper::min($valueMin, $value);
$valueMax = MathHelper::max($value, $valueMax);
}
$valueRange = $valueMax - $valueMin;
// generating weighted grade
foreach ($records as &$record) {
if (!isset($record[$this->valueColumnName])) {
continue;
}
$value = $record[$this->valueColumnName];
$rank = ($valueRange == 0) ? 1 : ($value - $valueMin) / $valueRange;
$record[$this->memberRankColumnName] = $rank;
}
unset($record);
}
protected function registerRecordImpl(array &$records = NULL, $record) {
parent::registerRecordImpl($records, $record);
if (isset($records)) {
// trying to find a record which could be reused
foreach ($records as &$existingRecord) {
$isRecordMatched = TRUE;
foreach ($this->formattedGroupByColumnNames as $groupByColumnName) {
if (isset($existingRecord[$groupByColumnName])) {
if (isset($record[$groupByColumnName])) {
if ($existingRecord[$groupByColumnName] !== $record[$groupByColumnName]) {
$isRecordMatched = FALSE;
}
}
else {
$isRecordMatched = FALSE;
}
}
elseif (isset($record[$groupByColumnName])) {
$isRecordMatched = FALSE;
}
if (!$isRecordMatched) {
break;
}
}
if ($isRecordMatched) {
$this->setRecordSubjectColumnValues($existingRecord, $record);
return TRUE;
}
}
unset($existingRecord);
}
// preparing new record
$newRecord = NULL;
foreach ($record as $name => $value) {
if ($name === $this->formattedEnumerationColumnName) {
continue;
}
if (isset($this->formattedSubjectColumnNames)) {
if (in_array($name, $this->formattedSubjectColumnNames)) {
continue;
}
}
elseif (!in_array($name, $this->formattedGroupByColumnNames)) {
continue;
}
$newRecord[$name] = $value;
}
$this->setRecordSubjectColumnValues($newRecord, $record);
$records[] = $newRecord;
return TRUE;
}
public function formatPropertyValue($propertyName, $propertyValue)
{
$formattedPropertyValue = parent::formatPropertyValue($propertyName, $propertyValue);
if ((!isset($this->propertyNames) || array_search($propertyName, $this->propertyNames) !== FALSE) && is_string($formattedPropertyValue)) {
$formattedPropertyValue = check_plain($formattedPropertyValue);
}
return $formattedPropertyValue;
}
public function finish(array &$records = NULL) {
if (isset($records)) {
$this->finishImpl($records);
}
if (isset($records) && isset($this->parent)) {
$this->parent->finish($records);
}
}
protected function formatColumnValueImpl($formattedColumnName, $columnValue) {
$formattedColumnValue = parent::formatColumnValueImpl($formattedColumnName, $columnValue);
if ((!isset($this->columnNames) || isset($this->columnNames[$formattedColumnName])) && is_string($formattedColumnValue)) {
$formattedColumnValue = check_plain($formattedColumnValue);
}
return $formattedColumnValue;
}
protected function finishImpl(array &$records = NULL) {
parent::finishImpl($records);
if (!isset($records)) {
return;
}
// first row in a table is list of column names
$columnNames = $this->columnNames;
if (!isset($columnNames)) {
foreach ($this->assembledColumnNames as $columnName => $index) {
$columnNames[$index] = $columnName;
}
}
array_unshift($records, $columnNames);
}
public function __construct($theView, $showHeader = TRUE, ResultFormatter $parent = NULL)
{
parent::__construct($parent);
$this->view = $theView;
$this->header = $showHeader;
}
protected function adjustPropertyName($propertyName)
{
$adjustedPropertyName = parent::adjustPropertyName($propertyName);
return str_replace(ParameterHelper::$COLUMN_NAME_DELIMITER__CODE, ParameterHelper::$COLUMN_NAME_DELIMITER__DATABASE, $adjustedPropertyName);
}
protected function formatColumnNameImpl($columnName) {
$formattedColumnName = parent::formatColumnNameImpl($columnName);
return isset($this->columnMappings[$formattedColumnName]) ? $this->columnMappings[$formattedColumnName] : NULL;
}
protected function adjustPropertyName($propertyName)
{
$adjustedPropertyName = parent::adjustPropertyName($propertyName);
return isset($this->columnMappings[$adjustedPropertyName]) ? $this->columnMappings[$adjustedPropertyName] : NULL;
}
