FilterGroup is a container of Filters that are based on the same attribute.
For selector attribute values, the Filters are generated automatically.
/**
* @param mixed $data
* @param string $contentEncoding
*/
public function LoadFromData($data, $contentEncoding)
{
$this->items = array();
$this->operator = intval($data->operator);
foreach ($data->items as $itemData) {
$item = null;
if (intval($itemData->type) == FilterItemType::Condition) {
$item = new FilterCondition();
} else {
if (intval($itemData->type) == FilterItemType::Group) {
$item = new FilterGroup();
}
}
$item->LoadFromData($itemData, $contentEncoding);
$this->AddItem($item);
}
}
/**
* @verbatim
* Helper method that installs filter groups based on
* the given XML node which represents a <filterGroups>
* element.
* @endverbatim
* @param $filterGroupsNode XMLNode
*/
function installFilterGroups($filterGroupsNode)
{
// Install filter groups.
$filterGroupDao = DAORegistry::getDAO('FilterGroupDAO');
/* @var $filterGroupDao FilterGroupDAO */
import('lib.pkp.classes.filter.FilterGroup');
foreach ($filterGroupsNode->getChildren() as $filterGroupNode) {
/* @var $filterGroupNode XMLNode */
$filterGroupSymbolic = $filterGroupNode->getAttribute('symbolic');
// Make sure that the filter group has not been
// installed before to guarantee idempotence.
$existingFilterGroup =& $filterGroupDao->getObjectBySymbolic($filterGroupSymbolic);
if (!is_null($existingFilterGroup)) {
continue;
}
// Instantiate and configure the filter group.
$filterGroup = new FilterGroup();
$filterGroup->setSymbolic($filterGroupSymbolic);
$filterGroup->setDisplayName($filterGroupNode->getAttribute('displayName'));
$filterGroup->setDescription($filterGroupNode->getAttribute('description'));
$filterGroup->setInputType($filterGroupNode->getAttribute('inputType'));
$filterGroup->setOutputType($filterGroupNode->getAttribute('outputType'));
// Install the filter group.
$installedGroupId = $filterGroupDao->insertObject($filterGroup);
assert(is_integer($installedGroupId));
unset($filterGroup);
}
}
/**
* @covers FilterGroupDAO
*/
public function testFilterGroupCrud()
{
$filterGroupDao = DAORegistry::getDAO('FilterGroupDAO');
/* @var $filterGroupDao FilterGroupDAO */
// Instantiate a test filter group object.
$testFilterGroup = new FilterGroup();
$testFilterGroup->setSymbolic('some-symbol');
$testFilterGroup->setDisplayName('translation.key.displayName');
$testFilterGroup->setDescription('translation.key.description');
$testFilterGroup->setInputType('primitive::string');
$testFilterGroup->setOutputType('primitive::integer');
// Insert filter group instance.
$filterGroupId = $filterGroupDao->insertObject($testFilterGroup, 9999);
self::assertTrue(is_numeric($filterGroupId));
self::assertTrue($filterGroupId > 0);
// Retrieve filter group instance by id.
$filterGroupById =& $filterGroupDao->getObjectById($filterGroupId);
self::assertEquals($testFilterGroup, $filterGroupById);
// Update filter group instance.
$testFilterGroup->setSymbolic('some-other-symbol');
$testFilterGroup->setDisplayName('translation.key.otherDisplayName');
$testFilterGroup->setDescription('translation.key.otherDescription');
$testFilterGroup->setInputType('primitive::integer');
$testFilterGroup->setOutputType('primitive::string');
$filterGroupDao->updateObject($testFilterGroup);
$filterGroupAfterUpdate =& $filterGroupDao->getObject($testFilterGroup);
self::assertEquals($testFilterGroup, $filterGroupAfterUpdate);
// Retrieve filter group instance by symbolic name.
$filterGroupBySymbolic =& $filterGroupDao->getObjectBySymbolic('some-other-symbol');
self::assertEquals($testFilterGroup, $filterGroupAfterUpdate);
// Delete filter group instance.
$filterGroupDao->deleteObjectById($filterGroupId);
self::assertNull($filterGroupDao->getObjectById($filterGroupId));
}
/**
* @covers FilterHelper
*/
public function testCompareFilters()
{
$filterHelper = new FilterHelper();
import('lib.pkp.classes.filter.FilterGroup');
$someGroup = new FilterGroup();
$someGroup->setInputType('primitive::string');
$someGroup->setOutputType('primitive::string');
import('lib.pkp.classes.filter.PersistableFilter');
$filterA = new PersistableFilter($someGroup);
$filterBSettings = array('some-key' => 'some-value');
$filterBSubfilters = array();
self::assertFalse($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
import('lib.pkp.classes.filter.FilterSetting');
$filterA->addSetting(new FilterSetting('some-key', null, null));
self::assertFalse($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterA->setData('some-key', 'some-value');
self::assertTrue($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterA = new CompositeFilter($someGroup);
$filterBSettings = array();
$filterBSubfilter = new CompositeFilter($someGroup);
$filterBSubfilter->setSeq(1);
$filterBSubfilters = array($filterBSubfilter);
self::assertFalse($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterASubfilter = new OtherCompositeFilter($someGroup);
$filterA->addFilter($filterASubfilter);
self::assertFalse($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterA = new CompositeFilter($someGroup);
$filterASubfilter = new CompositeFilter($someGroup);
$filterA->addFilter($filterASubfilter);
self::assertTrue($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterBSubfilter->addSetting(new FilterSetting('some-key', null, null));
$filterASubfilter->addSetting(new FilterSetting('some-key', null, null));
$filterBSubfilter->setData('some-key', 'some-value');
self::assertFalse($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
$filterASubfilter->setData('some-key', 'some-value');
self::assertTrue($filterHelper->compareFilters($filterA, $filterBSettings, $filterBSubfilters));
}
protected function setUp()
{
parent::setUp();
// Create a test filter group.
$someGroup = new FilterGroup();
$someGroup->setSymbolic('test-filter-group');
$someGroup->setDisplayName('some.test.filter.group.display');
$someGroup->setDescription('some.test.filter.group.description');
$someGroup->setInputType('primitive::string');
$someGroup->setOutputType('primitive::string');
$filterGroupDao = DAORegistry::getDAO('FilterGroupDAO');
/* @var $filterGroupDao FilterGroupDAO */
self::assertTrue(is_integer($filterGroupId = $filterGroupDao->insertObject($someGroup)));
}
protected function setUp()
{
// Clean up from earlier tests.
$filterDao = DAORegistry::getDAO('FilterDAO');
/* @var $filterDao FilterDAO */
$filterGroupDao = DAORegistry::getDAO('FilterGroupDAO');
/* @var $filterGroupDao FilterGroupDAO */
foreach ($filterDao->getObjectsByGroup('test-filter-group', 9999) as $filter) {
$filterDao->deleteObject($filter);
}
$filterGroupDao->deleteObjectBySymbolic('test-filter-group');
// Create a test filter group.
$someGroup = new FilterGroup();
$someGroup->setSymbolic('test-filter-group');
$someGroup->setDisplayName('some.test.filter.group.display');
$someGroup->setDescription('some.test.filter.group.description');
$someGroup->setInputType('primitive::string');
$someGroup->setOutputType('primitive::string');
self::assertTrue(is_integer($filterGroupId = $filterGroupDao->insertObject($someGroup)));
}
/**
* Internal function to return a filter group
* object from a row.
*
* @param $row array
* @return FilterGroup
*/
function &_fromRow(&$row)
{
// Instantiate the filter group.
$filterGroup = new FilterGroup();
// Configure the filter group.
$filterGroup->setId((int) $row['filter_group_id']);
$filterGroup->setSymbolic($row['symbolic']);
$filterGroup->setDisplayName($row['display_name']);
$filterGroup->setDescription($row['description']);
$filterGroup->setInputType($row['input_type']);
$filterGroup->setOutputType($row['output_type']);
return $filterGroup;
}
/**
* There are certain generic filters (e.g. CompositeFilters)
* that sometimes need to be persisted and sometimes are
* instantiated and used in code only.
*
* As we don't have multiple inheritance in PHP we'll have
* to use the more general filter type (PersistableFilter) as
* the base class of these "hybrid" filters.
*
* This means that we carry around some structure (e.g. filter
* groups) that do only make sense when a filter is actually
* being persisted and otherwise create unnecessary code.
*
* We provide this helper function to instantiate a temporary
* filter group on the fly with only an input and an output type
* which takes away at least some of the cruft.
*
* @param $inputType string
* @param $outputType string
*/
function tempGroup($inputType, $outputType)
{
$temporaryGroup = new FilterGroup();
$temporaryGroup->setSymbolic(FILTER_GROUP_TEMPORARY_ONLY);
$temporaryGroup->setInputType($inputType);
$temporaryGroup->setOutputType($outputType);
return $temporaryGroup;
}
public function getFilterSet()
{
if ($this->filterSetCache) {
return $this->filterSetCache;
}
Classloader::import('application.model.filter.Filter');
Classloader::import('application.model.filter.SelectorFilter');
// get filter groups
$groups = $this->getFilterGroupArray();
$ids = array();
$specFields = array();
$filterGroups = array();
foreach ($groups as $group) {
if (in_array($group['SpecField']['type'], array(SpecField::TYPE_NUMBERS_SELECTOR, SpecField::TYPE_TEXT_SELECTOR))) {
$specFields[] = $group['SpecField']['ID'];
$filterGroups[$group['SpecField']['ID']] = $group['ID'];
$ids[] = $group['ID'];
} else {
$ids[] = $group['ID'];
}
}
$ret = array();
if ($ids) {
// get specification simple value filters
$filterCond = new INCond(new ARFieldHandle('Filter', 'filterGroupID'), $ids);
$filterFilter = new ARSelectFilter();
$filterFilter->setCondition($filterCond);
$filterFilter->setOrder(new ARFieldHandle('Filter', 'filterGroupID'));
$filterFilter->setOrder(new ARFieldHandle('Filter', 'position'));
$valueFilters = ActiveRecord::getRecordSet('Filter', $filterFilter, array('FilterGroup', 'SpecField'));
foreach ($valueFilters as $filter) {
$ret[] = $filter;
}
}
// get specification selector value filters
if ($specFields) {
$selectFilter = new ARSelectFilter();
$selectFilter->setCondition(new INCond(new ARFieldHandle('SpecFieldValue', 'specFieldID'), $specFields));
$selectFilter->setOrder(new ARFieldHandle('SpecFieldValue', 'specFieldID'));
$selectFilter->setOrder(new ARFieldHandle('SpecFieldValue', 'position'));
$specFieldValues = ActiveRecord::getRecordSet('SpecFieldValue', $selectFilter);
foreach ($specFieldValues as $value) {
$ret[] = new SelectorFilter($value, FilterGroup::getInstanceByID($filterGroups[$value->specField->get()->getID()]));
}
}
$this->filterSetCache = $ret;
return $ret;
}
/**
* Pops the newest Filter from each of <tt>queries</tt>,
* grouping each popped Filter into one new FilterGroup.
* Adds that new FilterGroup as the newest Filter in this
* Query.
* <p>
* The FilterGroup's logic will be determined by <tt>op</tt>.
* @param string op operator name
* @param array Array of Query filter criteria
* @return obj queries Query object
*/
protected function popFilters($op, array $queries)
{
$group = new FilterGroup();
$group->op($op);
foreach ($queries as $query) {
if (!$query->rowFilters) {
//check to ensure nly filters are combined
throw new Exception("Operator " . $op . " can be used only to combine row filters");
return false;
} else {
$group->add(array_pop($query->rowFilters));
}
}
$this->add($group);
return $this;
}
/**
* @param mixed $data
*/
public function LoadFromData($data)
{
$this->items = array();
$this->operator = intval($data->operator);
foreach ($data->items as $itemData) {
$item = null;
if (intval($itemData->type) == 2) {
$item = new FilterCondition();
} else {
if (intval($itemData->type) == 1) {
$item = new FilterGroup();
}
}
$item->LoadFromData($itemData);
$this->AddItem($item);
}
}
/**
* Sort filter groups
*
* @role sort
*
* @return JSONResponse Status
*/
public function sort()
{
foreach ($this->request->get($this->request->get('target'), array()) as $position => $key) {
if (!empty($key)) {
$group = FilterGroup::getInstanceByID((int) $key);
$group->setFieldValue('position', (int) $position);
$group->save();
}
}
return new JSONResponse(false, 'success');
}
private function getFiltersByGroup($array, FilterGroup $group)
{
$res = array();
foreach ($array as $index => $filter) {
if ($filter instanceof SpecificationFilterInterface) {
if ($filter->getFilterGroup()->getID() === $group->getID()) {
$res[$index] = $filter;
}
}
}
return $res;
}
public function FilterMenu()
{
$vars = array("FilterGroups" => FilterGroup::get());
return $this->owner->renderWith("FilterMenu", $vars);
}
public function actionIndex()
{
$filterGroups = FilterGroup::model()->findAll();
$this->render('index', array('filterGroups' => $filterGroups));
}
