public function testMultipleRowInsert() { $query = SQLInsert::create('"SQLInsertTestBase"'); $query->addRow(array('"Title"' => 'First Object', '"Age"' => 10, '"Description"' => 'First the worst')); $query->addRow(array('"Title"' => 'Second object', '"Age"' => 12)); $sql = $query->sql($parameters); // Only test this case if using the default query builder if (get_class(DB::get_conn()->getQueryBuilder()) === 'SilverStripe\\ORM\\Connect\\DBQueryBuilder') { $this->assertSQLEquals('INSERT INTO "SQLInsertTestBase" ("Title", "Age", "Description") VALUES (?, ?, ?), (?, ?, ?)', $sql); } $this->assertEquals(array('First Object', 10, 'First the worst', 'Second object', 12, null), $parameters); $query->execute(); $this->assertEquals(2, DB::affected_rows()); // Check inserted objects are correct $firstObject = DataObject::get_one('SQLInsertTestBase', array('"Title"' => 'First Object'), false); $this->assertNotEmpty($firstObject); $this->assertEquals($firstObject->Title, 'First Object'); $this->assertEquals($firstObject->Age, 10); $this->assertEquals($firstObject->Description, 'First the worst'); $secondObject = DataObject::get_one('SQLInsertTestBase', array('"Title"' => 'Second object'), false); $this->assertNotEmpty($secondObject); $this->assertEquals($secondObject->Title, 'Second object'); $this->assertEquals($secondObject->Age, 12); $this->assertEmpty($secondObject->Description); }
public function processRecord($record, $columnMap, &$results, $preview = false) { // We match by 'Code', the ID property is confusing the importer if (isset($record['ID'])) { unset($record['ID']); } $objID = parent::processRecord($record, $columnMap, $results, $preview); $group = DataObject::get_by_id($this->objectClass, $objID); // set group hierarchies - we need to do this after all records // are imported to avoid missing "early" references to parents // which are imported later on in the CSV file. if (isset($record['ParentCode']) && $record['ParentCode']) { $parentGroup = DataObject::get_one('SilverStripe\\Security\\Group', array('"Group"."Code"' => $record['ParentCode'])); if ($parentGroup) { $group->ParentID = $parentGroup->ID; $group->write(); } } // set permission codes - these are all additive, meaning // existing permissions arent cleared. if (isset($record['PermissionCodes']) && $record['PermissionCodes']) { foreach (explode(',', $record['PermissionCodes']) as $code) { $p = DataObject::get_one('SilverStripe\\Security\\Permission', array('"Permission"."Code"' => $code, '"Permission"."GroupID"' => $group->ID)); if (!$p) { $p = new Permission(array('Code' => $code)); $p->write(); } $group->Permissions()->add($p); } } return $objID; }
public function testBasicUpdate() { $query = SQLUpdate::create()->setTable('"SQLUpdateTestBase"')->assign('"Description"', 'Description 1a')->addWhere(array('"Title" = ?' => 'Object 1')); $sql = $query->sql($parameters); // Check SQL $this->assertSQLEquals('UPDATE "SQLUpdateTestBase" SET "Description" = ? WHERE ("Title" = ?)', $sql); $this->assertEquals(array('Description 1a', 'Object 1'), $parameters); // Check affected rows $query->execute(); $this->assertEquals(1, DB::affected_rows()); // Check item updated $item = DataObject::get_one('SQLUpdateTestBase', array('"Title"' => 'Object 1')); $this->assertEquals('Description 1a', $item->Description); }
public function testAddToCsvColumnGroupsByCode() { $existinggroup = $this->objFromFixture('SilverStripe\\Security\\Group', 'existinggroup'); $loader = new MemberCsvBulkLoader(); $results = $loader->load($this->getCurrentRelativePath() . '/MemberCsvBulkLoaderTest_withGroups.csv'); $newgroup = DataObject::get_one('SilverStripe\\Security\\Group', array('"Group"."Code"' => 'newgroup')); $this->assertEquals($newgroup->Title, 'newgroup'); $created = $results->Created()->toArray(); $this->assertEquals(1, count($created[0]->Groups()->column('ID'))); $this->assertContains($existinggroup->ID, $created[0]->Groups()->column('ID')); $this->assertEquals(2, count($created[1]->Groups()->column('ID'))); $this->assertContains($existinggroup->ID, $created[1]->Groups()->column('ID')); $this->assertContains($newgroup->ID, $created[1]->Groups()->column('ID')); }
/** * Test {@link Object::add_extension()} has loaded DataExtension statics correctly. */ public function testAddExtensionLoadsStatics() { // Object::add_extension() will load DOD statics directly, so let's try adding a extension on the fly DataExtensionTest_Player::add_extension('DataExtensionTest_PlayerExtension'); // Now that we've just added the extension, we need to rebuild the database $this->resetDBSchema(true); // Create a test record with extended fields, writing to the DB $player = new DataExtensionTest_Player(); $player->setField('Name', 'Joe'); $player->setField('DateBirth', '1990-5-10'); $player->Address = '123 somewhere street'; $player->write(); unset($player); // Pull the record out of the DB and examine the extended fields $player = DataObject::get_one('DataExtensionTest_Player', array('"DataExtensionTest_Player"."Name"' => 'Joe')); $this->assertEquals($player->DateBirth, '1990-05-10'); $this->assertEquals($player->Address, '123 somewhere street'); $this->assertEquals($player->Status, 'Goalie'); }
public function getTeamByTitle($title) { return DataObject::get_one("CsvBulkLoaderTest_Team", array('"CsvBulkLoaderTest_Team"."Title"' => $title)); }
public function getRecord() { if (empty($this->record)) { $this->record = DataObject::get_one('UploadFieldTest_Record', '"Title" = \'Record 1\''); } return $this->record; }
/** * Add default records to database. This function is called whenever the * database is built, after the database tables have all been created. Overload * this to add default records when the database is built, but make sure you * call parent::requireDefaultRecords(). * * @uses DataExtension->requireDefaultRecords() */ public function requireDefaultRecords() { $defaultRecords = $this->stat('default_records'); if (!empty($defaultRecords)) { $hasData = DataObject::get_one($this->class); if (!$hasData) { $className = $this->class; foreach ($defaultRecords as $record) { $obj = $this->model->{$className}->newObject($record); $obj->write(); } DB::alteration_message("Added default records to {$className} table", "created"); } } // Let any extentions make their own database default data $this->extend('requireDefaultRecords', $dummy); }
/** * Get this object's parent, optionally filtered by an SQL clause. If the clause doesn't match the parent, nothing * is returned. * * @param string $filter * @return DataObject */ public function getParent($filter = null) { $parentID = $this->owner->ParentID; if (empty($parentID)) { return null; } $idSQL = $this->owner->getSchema()->sqlColumnForField($this->owner, 'ID'); return DataObject::get_one($this->owner->class, array(array($idSQL => $parentID), $filter)); }
/** * Create a member and group with the given permission code, and log in with it. * Returns the member ID. * * @param string|array $permCode Either a permission, or list of permissions * @return int Member ID */ public function logInWithPermission($permCode = "ADMIN") { if (is_array($permCode)) { $permArray = $permCode; $permCode = implode('.', $permCode); } else { $permArray = array($permCode); } // Check cached member if (isset($this->cache_generatedMembers[$permCode])) { $member = $this->cache_generatedMembers[$permCode]; } else { // Generate group with these permissions $group = Group::create(); $group->Title = "{$permCode} group"; $group->write(); // Create each individual permission foreach ($permArray as $permArrayItem) { $permission = Permission::create(); $permission->Code = $permArrayItem; $permission->write(); $group->Permissions()->add($permission); } $member = DataObject::get_one('SilverStripe\\Security\\Member', array('"Member"."Email"' => "{$permCode}@example.org")); if (!$member) { $member = Member::create(); } $member->FirstName = $permCode; $member->Surname = "User"; $member->Email = "{$permCode}@example.org"; $member->write(); $group->Members()->add($member); $this->cache_generatedMembers[$permCode] = $member; } $member->logIn(); return $member->ID; }
public function testSuccessfulLoginAttempts() { Security::config()->login_recording = true; /* SUCCESSFUL ATTEMPTS ARE LOGGED */ $this->doTestLoginForm('*****@*****.**', '1nitialPassword'); $attempt = DataObject::get_one('SilverStripe\\Security\\LoginAttempt', array('"LoginAttempt"."Email"' => '*****@*****.**')); $member = DataObject::get_one('SilverStripe\\Security\\Member', array('"Member"."Email"' => '*****@*****.**')); $this->assertTrue(is_object($attempt)); $this->assertEquals($attempt->Status, 'Success'); $this->assertEquals($attempt->Email, '*****@*****.**'); $this->assertEquals($attempt->Member()->toMap(), $member->toMap()); }
/** * Adds the member to a group. This will create the group if the given * group code does not return a valid group object. * * @param string $groupcode * @param string $title Title of the group */ public function addToGroupByCode($groupcode, $title = "") { $group = DataObject::get_one('SilverStripe\\Security\\Group', array('"Group"."Code"' => $groupcode)); if ($group) { $this->Groups()->add($group); } else { if (!$title) { $title = $groupcode; } $group = new Group(); $group->Code = $groupcode; $group->Title = $title; $group->write(); $this->Groups()->add($group); } }
public function testRemoveFromGroupByCode() { $grouplessMember = $this->objFromFixture('SilverStripe\\Security\\Member', 'grouplessmember'); $memberlessGroup = $this->objFromFixture('SilverStripe\\Security\\Group', 'memberlessgroup'); $this->assertFalse($grouplessMember->Groups()->exists()); $this->assertFalse($memberlessGroup->Members()->exists()); $grouplessMember->addToGroupByCode('memberless'); $this->assertEquals($memberlessGroup->Members()->Count(), 1); $this->assertEquals($grouplessMember->Groups()->Count(), 1); $grouplessMember->addToGroupByCode('somegroupthatwouldneverexist', 'New Group'); $this->assertEquals($grouplessMember->Groups()->Count(), 2); $group = DataObject::get_one('SilverStripe\\Security\\Group', "\"Code\" = 'somegroupthatwouldneverexist'"); $this->assertNotNull($group); $this->assertEquals($group->Code, 'somegroupthatwouldneverexist'); $this->assertEquals($group->Title, 'New Group'); $grouplessMember->removeFromGroupByCode('memberless'); $this->assertEquals($memberlessGroup->Members()->Count(), 0); $this->assertEquals($grouplessMember->Groups()->Count(), 1); $grouplessMember->removeFromGroupByCode('somegroupthatwouldneverexist'); $this->assertEquals($grouplessMember->Groups()->Count(), 0); }
public function testGetCaseInsensitive() { // Test get_one() with bad case on the classname // Note: This will succeed only if the underlying DB server supports case-insensitive // table names (e.g. such as MySQL, but not SQLite3) if (!DB::get_conn() instanceof MySQLDatabase) { $this->markTestSkipped('MySQL only'); } $subteam1 = DataObject::get_one('dataobjecttest_subteam', array('"DataObjectTest_Team"."Title"' => 'Subteam 1'), true); $this->assertNotEmpty($subteam1); $this->assertEquals($subteam1->Title, "Subteam 1"); }
/** * Tests for the bug #5994 - if you don't execute get_by_id prior to the rename or move, it will fail. */ public function testRenameFolderAndCheckTheFile() { // ID is prefixed in case Folder is subclassed by project/other module. $folder1 = DataObject::get_one('SilverStripe\\Assets\\Folder', array('"File"."ID"' => $this->idFromFixture('SilverStripe\\Assets\\Folder', 'folder1'))); $folder1->Name = 'FileTest-folder1-changed'; $folder1->write(); // Check if the file in the folder moved along $file1 = DataObject::get_by_id('SilverStripe\\Assets\\File', $this->idFromFixture('SilverStripe\\Assets\\File', 'file1-folder1'), false); $this->assertFileExists(AssetStoreTest_SpyStore::getLocalPath($file1)); $this->assertEquals($file1->Filename, 'FileTest-folder1-changed/File1.txt', 'The file DataObject path uses renamed folder'); // File should be located in new folder $this->assertEquals(ASSETS_PATH . '/FolderTest/.protected/FileTest-folder1-changed/55b443b601/File1.txt', AssetStoreTest_SpyStore::getLocalPath($file1)); }