public function testBuildWhereStatement()
{
$condition = new Condition();
$condition->add('testColumn', 11);
$condition2 = new Condition(ConditionInterface::DISJUNCTION);
$condition2->add('testColumn2', ['test', 'test2', 'test3']);
$condition2->add('testColumn3', 'test', ArgumentInterface::NOT_EQUAL);
$condition2->add('testColumn3', 'test', ArgumentInterface::NOTNULL);
$condition2->add('testColumn3 = "test"', '', ArgumentInterface::OWN);
$condition2->add('testColumn', [1, 2], ArgumentInterface::NOT_EQUAL);
$condition->addCondition($condition2);
static::assertEquals('(testColumn = 11) AND ((testColumn2 IN ("test","test2","test3")) OR (testColumn3 != "test") OR (testColumn3 IS NOT NULL) OR (testColumn3 = "test") OR (testColumn NOT IN (1,2)))', $this->sqlBuilder->buildWhereStatement($this->metadata, $condition));
}
/**
* @param array $entityIDs
*
* @return array
*/
protected function applySearch(array $entityIDs)
{
$condition = new Condition(ConditionInterface::DISJUNCTION);
foreach ($this->searchFilter as $searchText) {
foreach (static::$fieldValueColumns as $fieldId => $fieldColumn) {
$condition->addCondition((new Condition())->addArgument(new Argument($fieldColumn, '%' . $searchText . '%', ArgumentInterface::LIKE))->addArgument(new Argument(\samsoncms\api\MaterialField::F_FIELDID, $fieldId)));
}
}
return $this->query->entity(\samsoncms\api\MaterialField::class)->whereCondition($condition)->where(Material::F_PRIMARY, $entityIDs)->fields(Material::F_PRIMARY);
}
/**
* Find additional field database record by Name or ID.
* This is generic method that should be used in nested classes to find its
* records by some its primary key value.
*
* @param QueryInterface $query Query object instance
* @param string $nameOrID Additional field name or identifier
* @param self $return Variable to return found database record
*
*@return bool|null|self Field instance or null if 3rd parameter not passed
*/
public static function byNameOrID(QueryInterface $query, $nameOrID, self &$return = null)
{
// Create id or URL condition
$idOrUrl = new Condition('OR');
$idOrUrl->add('FieldID', $nameOrID)->add('Name', $nameOrID);
// Perform query
$return = $query->entity(get_called_class())->whereCondition($idOrUrl)->first();
// If only one argument is passed - return null, otherwise bool
return func_num_args() > 1 ? $return == null : $return;
}
/**
* Try to find all materials which have fields similar to search strings
*
* @param array $filteredIds Collection of filtered material identifiers
*
* @return bool True if ALL field filtering succeeded or there was no filtering at all otherwise false
*/
protected function applySearchFilter(&$filteredIds = array())
{
/** @var array $fields Variable to store all fields related to set navigation */
$fields = array();
/** @var array $navigationArray Array of set navigation identifiers */
$navigationArray = array();
/** @var array $fieldFilter Array of filtered material identifiers via materialfield table */
$fieldFilter = array();
/** @var array $materialFilter Array of filtered material identifiers via material table */
$materialFilter = array();
// If there are at least one search string
if (!empty($this->search)) {
// Create array containing all navigation identifiers
foreach ($this->navigation as $navigation) {
// Navigation hook for searching action
$navigation = is_array($navigation) ? $navigation : array($navigation);
$navigationArray = array_merge($navigationArray, $navigation);
}
// Get all related fields
$this->query->entity('\\samson\\activerecord\\structurefield')->where('StructureID', $navigationArray)->groupBy('FieldID')->fields('FieldID', $fields);
// Iterate over search strings
foreach ($this->search as $searchString) {
// Try to find search value in materialfield table
$this->query->entity('\\samson\\activerecord\\materialfield')->where('FieldID', $fields)->where('MaterialID', $filteredIds)->where('Value', '%' . $searchString . '%', Relation::LIKE)->where('Active', 1)->groupBy('MaterialID')->fields('MaterialID', $fieldFilter);
// TODO: Add generic support for all native fields or their configuration
// Condition to search in material table by Name and URL
$materialCondition = new Condition('OR');
$materialCondition->add('Name', '%' . $searchString . '%', Relation::LIKE)->add('Url', '%' . $searchString . '%', Relation::LIKE);
// Try to find search value in material table
$this->query->entity('\\samson\\activerecord\\material')->whereCondition($materialCondition)->where('Active', 1);
// If we have not empty collection of filtering identifiers
if (count($filteredIds)) {
$this->query->where('MaterialID', $filteredIds);
}
$materialFilter = $this->query->fields('MaterialID');
// If there are no materials with specified conditions
if (empty($materialFilter) && empty($fieldFilter) && count($materialFilter) != 0 && count($fieldFilter != 0)) {
// Filter applying failed
return false;
} else {
// Otherwise set filtered material identifiers
$filteredIds = array_unique(array_merge($materialFilter, $fieldFilter));
}
}
}
// We have no search collection filters
return true;
}
/**
* Build correct localized field request for retrieving additional fields records.
*
* @param Field[] $fields Collection of additional fields
*
* @return Condition Built condition for query
*/
protected function fieldsCondition($fields)
{
// Group fields by localization
$localizedColumns = array();
$notLocalizedColumns = array();
/** @var Field $field Iterate table columns(fields) */
foreach ($fields as $field) {
if ($field->localized()) {
$localizedColumns[] = $field->id;
} else {
$notLocalizedColumns[] = $field->id;
}
}
// Create field condition
$fieldsCondition = new Condition(ConditionInterface::DISJUNCTION);
// Create localized condition
if (count($localizedColumns)) {
$localizedCondition = new Condition(ConditionInterface::CONJUNCTION);
$localizedCondition->add(Field::F_PRIMARY, $localizedColumns)->add(MaterialField::F_LOCALE, $this->locale);
// Add this condition to condition group
$fieldsCondition->addCondition($localizedCondition);
}
// Create not localized condition
if (count($notLocalizedColumns)) {
$fieldsCondition->add(Field::F_PRIMARY, $notLocalizedColumns);
}
return $fieldsCondition;
}
