public function testFiltersMatchingRows()
{
$filter = new \Rhubarb\Stem\Filters\Equals("Forename", "Tom");
$this->list->filter($filter);
$this->assertCount(1, $this->list);
$this->assertEquals("Thumb", $this->list[0]->Surname);
}
public function testBetweenNumbers()
{
$this->list->filter(new Between("FavouriteNumber", 10, 20));
$this->assertCount(2, $this->list);
$this->assertEquals("John", $this->list[0]->Forename);
$this->assertEquals("Mary", $this->list[1]->Forename);
}
public function testFiltersOnOtherColumn()
{
$filter = new \Rhubarb\Stem\Filters\LessThan("Forename", "@{Surname}", true);
$this->list->filter($filter);
$this->assertCount(1, $this->list);
$this->assertEquals("Morris", $this->list[0]->Surname);
}
public function testFiltersAlpha()
{
$filter = new \Rhubarb\Stem\Filters\GreaterThan("Forename", "Mary", true);
$this->list->filter($filter);
$this->assertCount(2, $this->list);
$filter = new \Rhubarb\Stem\Filters\GreaterThan("Forename", "Mary", false);
$this->list->filter($filter);
$this->assertCount(1, $this->list);
$this->assertContains("Tom", $this->list[0]->Forename);
}
public function testFiltersCaseSensitive()
{
$filter = new \Rhubarb\Stem\Filters\Contains("Forename", "Jo", true);
$this->list->filter($filter);
$this->assertCount(1, $this->list);
$this->assertContains("John", $this->list[0]->Forename);
$filter = new \Rhubarb\Stem\Filters\Contains("Forename", "oH", true);
$this->list->filter($filter);
$this->assertCount(0, $this->list);
}
public function testFiltersCaseSensitive()
{
$filter = new \Rhubarb\Stem\Filters\EndsWith("Forename", "ry", true);
$this->list->filter($filter);
$this->assertCount(1, $this->list);
$this->assertContains("Mary", $this->list[0]->Forename);
$filter = new \Rhubarb\Stem\Filters\EndsWith("Forename", "RY", true);
$this->list->filter($filter);
$this->assertCount(0, $this->list);
}
public function testFilters()
{
$filter = new \Rhubarb\Stem\Filters\OneOf("Forename", ["Cuthbert", "Dibble", "Grub", "Pugh"]);
$this->list->filter($filter);
$this->assertCount(5, $this->list);
$this->assertContains("Pugh", $this->list[0]->Forename);
$filter = new \Rhubarb\Stem\Filters\OneOf("Forename", ["Cuthbert", "Dibble", "Grub"]);
$this->list->filter($filter);
$this->assertCount(3, $this->list);
$this->assertContains("Cuthbert", $this->list[0]->Forename);
}
function testFiltersWithGroupedGroup()
{
$filterGroup1 = new \Rhubarb\Stem\Filters\Group("And");
$filterGroup1->addFilters(new \Rhubarb\Stem\Filters\Contains("Forename", "Jo", true), new \Rhubarb\Stem\Filters\Contains("Surname", "Jo", true));
$filterGroup2 = new \Rhubarb\Stem\Filters\Group("Or");
$filterGroup2->addFilters(new \Rhubarb\Stem\Filters\Contains("Surname", "Luc", true), new \Rhubarb\Stem\Filters\LessThan("DateOfBirth", "1980-01-01", true));
$filterGroup = new \Rhubarb\Stem\Filters\Group("Or");
$filterGroup->addFilters($filterGroup1, $filterGroup2);
$notGroup = $filterGroup->getInvertedFilter();
$this->list->filter($notGroup);
$this->assertCount(1, $this->list);
$this->assertContains("Smithe", $this->list[0]->Surname);
}
public function testCanFilterOnRelatedModelProperties()
{
$gcd = new Company();
$gcd->CompanyName = "GCD";
$gcd->save();
$widgetCo = new Company();
$widgetCo->CompanyName = "Widgets";
$widgetCo->save();
$example = new User();
$example->Username = "******";
$widgetCo->Users->Append($example);
$example = new User();
$example->Username = "******";
$gcd->Users->Append($example);
$example = new User();
$example->Username = "******";
$widgetCo->Users->Append($example);
$example = new User();
$example->Username = "******";
$gcd->Users->Append($example);
$list = new Collection("Rhubarb\\Stem\\Tests\\Fixtures\\User");
$list->filter(new Equals("Company.CompanyName", "GCD"));
$this->assertCount(2, $list);
$this->assertEquals("b", $list[0]->Username);
$this->assertEquals("d", $list[1]->Username);
}
public function testDataListFetchesObjects()
{
MySql::executeStatement("TRUNCATE TABLE tblCompany");
$company = new Company();
$company->CompanyName = "GCD";
$company->save();
$company = new Company();
$company->CompanyName = "Unit Design";
$company->save();
$company = new Company();
$company->CompanyName = "Goats Boats";
$company->save();
$list = new Collection("\\Rhubarb\\Stem\\Tests\\Fixtures\\Company");
$this->assertCount(3, $list);
$repository = $company->getRepository();
$repository->clearObjectCache();
$list = new Collection("\\Rhubarb\\Stem\\Tests\\Fixtures\\Company");
$this->assertCount(3, $list);
$this->assertEquals("Unit Design", $list[1]->CompanyName);
$filter = new Equals("CompanyName", "Unit Design");
$list = new Collection("\\Rhubarb\\Stem\\Tests\\Fixtures\\Company");
$list->filter($filter);
$this->assertCount(1, $list);
$this->assertEquals("Unit Design", $list[0]->CompanyName);
$filter = new Equals("CompanyIDSquared", $company->CompanyID * $company->CompanyID);
$list = new Collection("\\Rhubarb\\Stem\\Tests\\Fixtures\\Company");
$list->filter($filter);
$this->assertCount(1, $list);
$this->assertEquals("Goats Boats", $list[0]->CompanyName);
}
public function testSumIsCalculatedOnRepository()
{
$examples = new Collection("Company");
list($sumTotal) = $examples->calculateAggregates([new MySqlSum("Balance")]);
$this->assertEquals(6, $sumTotal);
$lastStatement = MySql::getPreviousStatement(false);
$this->assertContains("SUM( `Balance` ) AS `SumOfBalance`", $lastStatement);
$examples = new Collection("Company");
$examples->filter(new GreaterThan("Balance", 1));
list($sumTotal) = $examples->calculateAggregates(new MySqlSum("Balance"));
$this->assertEquals(5, $sumTotal);
$lastStatement = MySql::getPreviousStatement(false);
$this->assertContains("SUM( `Balance` ) AS `SumOfBalance`", $lastStatement);
$this->assertContains("WHERE `tblCompany`.`Balance` > ", $lastStatement);
}
function testXOR()
{
$filterOne = new \Rhubarb\Stem\Filters\Contains("Forename", "Jo", true);
$filterTwo = new \Rhubarb\Stem\Filters\Contains("Surname", "Jo", true);
$filterAnd = new \Rhubarb\Stem\Filters\Group("And");
$filterAnd->addFilters($filterOne, $filterTwo);
$filterOr = new \Rhubarb\Stem\Filters\Group("Or");
$filterOr->addFilters($filterOne, $filterTwo);
$filterNotAnd = new \Rhubarb\Stem\Filters\Not($filterAnd);
$filterXor = new \Rhubarb\Stem\Filters\Group("And");
$filterXor->addFilters($filterNotAnd, $filterOr);
$this->list->filter($filterXor);
$this->assertCount(2, $this->list);
$this->assertContains("Luc", $this->list[0]->Surname);
}
protected function getCurrentlyAvailableSelectionItems()
{
if ($this->Phrase == "") {
return [];
}
$class = $this->modelClassName;
$list = new Collection($class);
$filter = $this->getCollectionFilter($this->Phrase);
$list->filter($filter);
$results = [];
foreach ($list as $item) {
$result = $this->makeItem($item->getUniqueIdentifier(), $item->getLabel(), $this->getDataForItem($item));
$results[] = $result;
}
return $results;
}
public function login($username, $password)
{
// We don't allow spaces around our usernames and passwords
$username = trim($username);
$password = trim($password);
if ($username == "") {
throw new LoginFailedException();
}
$list = new Collection($this->modelClassName);
$list->filter(new Equals($this->usernameColumnName, $username));
if (!sizeof($list)) {
throw new LoginFailedException();
}
$hashProvider = HashProvider::getHashProvider();
// There should only be one user matching the username. It would be possible to support
// unique *combinations* of username and password but it's a potential security issue and
// could trip us up when supporting the project.
if (sizeof($list) > 1) {
throw new LoginFailedException();
}
$user = $list[0];
$this->checkUserIsPermitted($user);
// Test the password matches.
$userPasswordHash = $user[$this->passwordColumnName];
if ($hashProvider->compareHash($password, $userPasswordHash)) {
// Matching login - but is it enabled?
if ($this->isModelActive($user)) {
$this->LoggedIn = true;
$this->LoggedInUserIdentifier = $user->getUniqueIdentifier();
$this->storeSession();
return true;
} else {
throw new LoginDisabledException();
}
}
throw new LoginFailedException();
}
/**
* Returns the Collection of models matching the given filter.
*
* @param Filter $filter
* @return Collection
*/
public static function find(Filter $filter = null)
{
$modelClass = get_called_class();
$collections = new Collection($modelClass);
if ($filter !== null) {
$collections->filter($filter);
}
return $collections;
}
public function fetchFor(Model $relatedTo)
{
$targetModel = SolutionSchema::getModel($this->targetModelName);
$sourceValue = $relatedTo[$this->getSourceColumnName()];
$targetColumnName = $this->getTargetColumnName();
if ($targetColumnName == $targetModel->UniqueIdentifierColumnName) {
if ($sourceValue === null) {
return null;
}
try {
return SolutionSchema::getModel($this->targetModelName, $sourceValue);
} catch (RecordNotFoundException $er) {
return null;
}
} else {
$collection = new Collection($this->targetModelName);
$collection->filter(new Equals($targetColumnName, $sourceValue));
if (sizeof($collection) > 0) {
return $collection[0];
}
}
return null;
}
public function testIsNullFilter()
{
MySql::executeStatement("TRUNCATE TABLE tblCompany");
$company = new \Rhubarb\Stem\Tests\Fixtures\Company();
$company->CompanyName = "GCD";
$company->save();
$companies = new Collection('Rhubarb\\Stem\\Tests\\Fixtures\\Company');
$companies->filter(new Equals("CompanyName", null));
$this->assertEquals(0, $companies->count());
$companies = new Collection('Rhubarb\\Stem\\Tests\\Fixtures\\Company');
$companies->filter(new Equals("ProjectCount", null));
$this->assertEquals(1, $companies->count());
}
public function testEmptyCandidatesArray()
{
$filter = new InArray("Surname", []);
$this->list->filter($filter);
$this->assertCount(0, $this->list);
}
