/**
* Tests saving a sfGuardUserSubredditMembership that identifies a User as
* "blocked" for a particular Subreddit. When this occurs, all existing
* future EpisodeAssignments should be deleted because blocked users cannot
* participate with the Subreddit.
*/
public function testSavingBlockedUser()
{
// Establish fake Subreddit
$subreddit = new Subreddit();
$subreddit->setName(rand(0, 1000));
$subreddit->setDomain(rand(0, 1000));
$subreddit->save();
// Establish User
$user = new sfGuardUser();
$user->setEmailAddress(rand(0, 100000));
$user->setUsername(rand(0, 10000));
$user->setIsValidated(1);
$user->save();
$user_id = $user->getIncremented();
$this->assertNotEquals(0, $user_id);
// Establish Episode for Subreddit
$episode = new Episode();
$episode->setSubreddit($subreddit);
$episode->setReleaseDate(date('Y-m-d H:i:s', time() + 34000));
$episode->save();
$author_type = AuthorTypeTable::getInstance()->findOneBy('type', 'squid');
$deadline = new Deadline();
$deadline->setSubreddit($subreddit);
$deadline->setAuthorType($author_type);
$deadline->setSeconds(0);
$deadline->save();
$episode_assignment = new EpisodeAssignment();
$episode_assignment->setSfGuardUser($user);
$episode_assignment->setEpisode($episode);
$episode_assignment->setAuthorType($author_type);
$episode_assignment->save();
$number_of_episodes = EpisodeAssignmentTable::getInstance()->createQuery()->select('COUNT(EpisodeAssignment.id)')->leftJoin('Episode')->where('subreddit_id = ?', $subreddit->getIncremented())->andWhere('EpisodeAssignment.sf_guard_user_id = ?', $user_id)->andWhere('Episode.release_date > NOW()')->groupBy('EpisodeAssignment.id')->count();
$this->assertEquals(1, $number_of_episodes);
// Establish User Membership as Blocked
$blocked = MembershipTable::getInstance()->findOneBy('type', 'blocked');
$user_membership = new sfGuardUserSubredditMembership();
$user_membership->setSubreddit($subreddit);
$user_membership->setSfGuardUser($user);
$user_membership->setMembership($blocked);
// Save Membership
$user_membership->save();
// Asert that User has zero Episodes
$number_of_episodes = EpisodeAssignmentTable::getInstance()->createQuery()->select('COUNT(EpisodeAssignment.id)')->leftJoin('Episode')->where('subreddit_id = ?', $subreddit->getIncremented())->andWhere('EpisodeAssignment.sf_guard_user_id = ?', $user_id)->andWhere('Episode.release_date > NOW()')->groupBy('EpisodeAssignment.id');
$sql = $number_of_episodes->getSqlQuery();
$number_of_episodes = $number_of_episodes->count();
$this->assertTrue(0 == $number_of_episodes, $sql . "\n" . $subreddit->getIncremented() . "\n" . $user_id);
// Remove User Membership
$user_membership->delete();
// Delete User
$user->delete();
// Delete Episode
$episode->delete();
// Delete Deadline
$deadline->delete();
// Delete Subreddit
$subreddit->delete();
}
protected function execute($arguments = array(), $options = array())
{
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'])->getConnection();
$quiet = (bool) $options['quiet'];
$domain = $arguments['domain'];
if (!$quiet) {
echo "Creating deadlines...";
}
$subreddit = SubredditTable::getInstance()->findOneBy('domain', $domain);
/* @var $subreddit Subreddit */
if (!$subreddit) {
return new sfException("Cannot find subreddit by the domain name {$domain}.", 404);
}
if (count($subreddit->getDeadlines())) {
return new sfException("Subreddit has deadlines already.");
}
$authortype_one = AuthorTypeTable::getInstance()->findOneBy('type', 'first_place');
$authortype_two = AuthorTypeTable::getInstance()->findOneBy('type', 'second_place');
$authortype_three = AuthorTypeTable::getInstance()->findOneBy('type', 'third_place');
$authortype_four = AuthorTypeTable::getInstance()->findOneBy('type', 'sudden_death');
$deadlines = new Doctrine_Collection('Deadline');
$deadlines[0] = new Deadline();
$deadlines[0]->setAuthorType($authortype_one);
$deadlines[0]->setSubreddit($subreddit);
$deadlines[0]->setSeconds(259200);
$deadlines[1] = new Deadline();
$deadlines[1]->setAuthorType($authortype_two);
$deadlines[1]->setSubreddit($subreddit);
$deadlines[1]->setSeconds(172800);
$deadlines[2] = new Deadline();
$deadlines[2]->setAuthorType($authortype_three);
$deadlines[2]->setSubreddit($subreddit);
$deadlines[2]->setSeconds(86400);
$deadlines[3] = new Deadline();
$deadlines[3]->setAuthorType($authortype_four);
$deadlines[3]->setSubreddit($subreddit);
$deadlines[3]->setSeconds(0);
$deadlines->save();
if (!$quiet) {
echo "\nFinished.\n";
}
}
/**
* We've combined the process for preventing saving with a specific call for
* deletion to aid in handling errors and dealing with unsaved objects.
* This tests whether the exception is thrown
*/
public function testdeleteWithException()
{
$subreddit = new Subreddit();
$subreddit->setName(rand(0, 10000));
$subreddit->setDomain(rand(0, 10000));
$subreddit->save();
$user = new sfGuardUser();
$user->setUsername(rand(0, 10000));
$user->setEmailAddress(rand(0, 10000));
$user->setIsValidated(1);
$user->save();
$first = AuthorTypeTable::getInstance()->findOneByType('squid');
$episode = new Episode();
$episode->setReleaseDate(date('Y-m-d H:i:s', time() + 100000));
$episode->setSubreddit($subreddit);
$episode->save();
$deadline = new Deadline();
$deadline->setSubreddit($subreddit);
$deadline->setAuthorType($first);
$deadline->setSeconds(0);
$deadline->save();
$assignment = new EpisodeAssignment();
$assignment->setSfGuardUser($user);
$assignment->setEpisode($episode);
$assignment->setAuthorType($first);
$assignment->save();
// Delete with exception
$exception_thrown = false;
$exception_code = 987654321;
try {
$assignment->deleteWithException("Test exception", $exception_code);
} catch (sfException $exception) {
$this->assertEquals($exception_code, $exception->getCode());
unset($exception);
$exception_thrown = true;
}
$this->assertTrue($exception_thrown);
// Delete the rest of the objects
$episode->delete();
$user->delete();
$subreddit->delete();
}
/**
* We set up the following situation:
* We have three users, each of different AuthorTypes, who have
* EpisodeAssignments with the Episode in question. The deadline for the
* first user has passed, but the deadline for the second has not. The
* third user is in an AuthorType that should prevent creating an
* AuthorType for the Episode before the second user's deadline passes, even
* though that User is an admin.
*
* The second user (the one who is able to submit their episode) is a
* moderator, but she should not be able to approve her own episode.
*/
public function setUp()
{
ProjectConfiguration::registerAws();
$original_filename = '1234567890abcde.mp3';
$this->episode_filename = 'abcde0123456789.mp3';
$this->unapproved_file_location = sfConfig::get('sf_data_dir') . '/temp/';
if (!copy($this->unapproved_file_location . $original_filename, $this->unapproved_file_location . $this->episode_filename)) {
echo "failed to copy {$this->unapproved_file_location}{$original_filename}...\n";
}
$this->aws = new AmazonS3();
$this->subreddit = new Subreddit();
$this->subreddit->setName(rand(0, 1000));
$this->subreddit->setDomain(rand(0, 1000));
$this->subreddit->save();
$first = AuthorTypeTable::getInstance()->findOneByType('squid');
$understudy = AuthorTypeTable::getInstance()->findOneByType('shark');
$dark_horse = AuthorTypeTable::getInstance()->findOneByType('blue_whale');
$this->first_deadline = new Deadline();
$this->first_deadline->setAuthorType($first);
$this->first_deadline->setSeconds(1000);
$this->first_deadline->setSubreddit($this->subreddit);
$this->first_deadline->save();
$this->second_deadline = new Deadline();
$this->second_deadline->setAuthorType($understudy);
$this->second_deadline->setSeconds(500);
$this->second_deadline->setSubreddit($this->subreddit);
$this->second_deadline->save();
$this->third_deadline = new Deadline();
$this->third_deadline->setAuthorType($dark_horse);
$this->third_deadline->setSeconds(100);
$this->third_deadline->setSubreddit($this->subreddit);
$this->third_deadline->save();
$this->user = new sfGuardUser();
$this->user->setEmailAddress(rand(0, 1000));
$this->user->setUsername(rand(0, 1000));
$this->user->setIsValidated(1);
$this->user->save();
$this->after_deadline_user = new sfGuardUser();
$this->after_deadline_user->setEmailAddress(rand(0, 1000));
$this->after_deadline_user->setUsername(rand(0, 1000));
$this->after_deadline_user->setIsValidated(1);
$this->after_deadline_user->save();
$this->dark_horse_user = new sfGuardUser();
$this->dark_horse_user->setEmailAddress(rand(0, 1000));
$this->dark_horse_user->setUsername(rand(0, 1000));
$this->dark_horse_user->setIsValidated(1);
$this->dark_horse_user->save();
$this->approver = new sfGuardUser();
$this->approver->setEmailAddress(rand(0, 1000));
$this->approver->setUsername(rand(0, 1000));
$this->approver->setIsValidated(1);
$this->approver->save();
$moderator = MembershipTable::getInstance()->findOnebyType('moderator');
$admin = MembershipTable::getInstance()->findOnebyType('admin');
$member = MembershipTable::getInstance()->findOnebyType('user');
$this->first_membership = new sfGuardUserSubredditMembership();
$this->first_membership->setMembership($member);
$this->first_membership->setSubreddit($this->subreddit);
$this->first_membership->setSfGuardUser($this->after_deadline_user);
$this->first_membership->save();
$this->second_membership = new sfGuardUserSubredditMembership();
$this->second_membership->setMembership($moderator);
$this->second_membership->setSubreddit($this->subreddit);
$this->second_membership->setSfGuardUser($this->user);
$this->second_membership->save();
$this->third_membership = new sfGuardUserSubredditMembership();
$this->third_membership->setMembership($admin);
$this->third_membership->setSubreddit($this->subreddit);
$this->third_membership->setSfGuardUser($this->dark_horse_user);
$this->third_membership->save();
$this->fourth_membership = new sfGuardUserSubredditMembership();
$this->fourth_membership->setMembership($moderator);
$this->fourth_membership->setSubreddit($this->subreddit);
$this->fourth_membership->setSfGuardUser($this->approver);
$this->fourth_membership->save();
$this->episode = new Episode();
$this->episode->setReleaseDate(date('Y-m-d H:i:s', time() + 20000));
$this->episode->setAudioFile($this->episode_filename);
$this->episode->setNiceFilename('14. We Will Rock You.mp3');
//$this->episode->setSfGuardUserId($this->user);
$this->episode->setDescription('This is a test.');
$this->episode->setTitle('Test Episode');
$this->episode->setIsNsfw(false);
$this->episode->setSubreddit($this->subreddit);
$this->episode->save();
$this->first_ep_assignment = new EpisodeAssignment();
$this->first_ep_assignment->setEpisodeId($this->episode->getIncremented());
$this->first_ep_assignment->setAuthorType($first);
$this->first_ep_assignment->setSfGuardUser($this->after_deadline_user);
$this->first_ep_assignment->save();
$this->second_ep_assignment = new EpisodeAssignment();
$this->second_ep_assignment->setEpisodeId($this->episode->getIncremented());
$this->second_ep_assignment->setAuthorType($understudy);
$this->second_ep_assignment->setSfGuardUser($this->user);
$this->second_ep_assignment->save();
$this->third_ep_assignment = new EpisodeAssignment();
$this->third_ep_assignment->setEpisodeId($this->episode->getIncremented());
$this->third_ep_assignment->setAuthorType($dark_horse);
$this->third_ep_assignment->setSfGuardUser($this->dark_horse_user);
try {
$this->third_ep_assignment->save();
} catch (sfException $exception) {
unset($exception);
}
$this->episode->setReleaseDate(date('Y-m-d H:i:s', time() + 750));
$this->episode->save();
}
/**
* This tests whether the
* EpisodeAssignmentTable::getFirstByUserAuthorTypeAndSubreddit() function
* retrieves the correct EpisodeAssignment for a particular User in a
* Subreddit based on the AuthorType used in the EpisodeAssignment. Users
* can sign up for one Episode per AuthorType in each Subreddit, which means
* future Episodes (sicne we don't want the existence of past episode to
* disqualify Users from ever signing up again).
*/
public function testGetFirstByUserAuthorTypeAndSubreddit()
{
// Create two episode assignments: one for a past Episode, one for a future
$subreddit = new Subreddit();
$subreddit->setName(rand(0, 10000));
$subreddit->setDomain(rand(0, 10000));
$subreddit->save();
$user = new sfGuardUser();
$user->setUsername(rand(0, 10000));
$user->setEmailAddress(rand(0, 10000));
$user->setisValidated(1);
$user->save();
$first = AuthorTypeTable::getInstance()->findOneBy('type', 'squid');
$understudy = AuthorTypeTable::getInstance()->findOneBy('type', 'shark');
$this->assertTrue($first instanceof AuthorType);
$this->assertNotEquals(null, $first->getIncremented());
$this->assertTrue($understudy instanceof AuthorType);
$this->assertNotEquals(null, $understudy->getIncremented());
$deadline_one = new Deadline();
$deadline_one->setSeconds(100);
$deadline_one->setAuthorType($first);
$deadline_one->setSubreddit($subreddit);
$deadline_one->save();
$deadline_two = new Deadline();
$deadline_two->setSeconds(0);
$deadline_two->setAuthorType($understudy);
$deadline_two->setSubreddit($subreddit);
$deadline_two->save();
$episode_one = new Episode();
$episode_one->setReleaseDate(date('Y-m-d H:i:s', time() + 200000));
$episode_one->setSubreddit($subreddit);
$episode_one->save();
$episode_two = new Episode();
$episode_two->setReleaseDate(date('Y-m-d H:i:s', time() + 100000));
$episode_two->setSubreddit($subreddit);
$episode_two->save();
$episode_three = new Episode();
$episode_three->setReleaseDate(date('Y-m-d H:i:s', time() + 300000));
$episode_three->setSubreddit($subreddit);
$episode_three->save();
$assignment_one = new EpisodeAssignment();
$assignment_one->setEpisode($episode_one);
$assignment_one->setSfGuardUser($user);
$assignment_one->setAuthorType($first);
$assignment_one->save();
$assignment_two = new EpisodeAssignment();
$assignment_two->setEpisode($episode_two);
$assignment_two->setSfGuardUser($user);
$assignment_two->setAuthorType($understudy);
$assignment_two->save();
/* There should only be one Episode Assignment for future episodes per
* authortype per subreddit, so saving the third assignment should fail
* --- this is covered more in EpisodeAssignmentTest.phop
*/
$exception_thrown = false;
$assignment_three = new EpisodeAssignment();
$assignment_three->setEpisode($episode_three);
$assignment_three->setSfGuardUser($user);
$assignment_three->setAuthorType($first);
try {
$assignment_three->save();
} catch (Exception $exception) {
$exception_thrown = true;
$this->assertEquals(102, $exception->getCode());
unset($exception);
}
$this->assertTrue($exception_thrown);
/* Since we can trust that only one assignment per authortype per user
* per subreddit exists for future episodes (based on the failure to
* save $assignment_three), we check now to ensure that the
* getFirstByUserAuthorTypeAndSubreddit() function returns a valid
* EpisodeAssignment.
*/
$test_one = EpisodeAssignmentTable::getInstance()->getFirstByUserAuthorTypeAndSubreddit($assignment_one->getAuthorTypeId(), $assignment_one->getSfGuardUserId(), $assignment_one->getEpisode()->getSubredditId());
$test_two = EpisodeAssignmentTable::getInstance()->getFirstByUserAuthorTypeAndSubreddit($assignment_two->getAuthorTypeId(), $assignment_two->getSfGuardUserId(), $assignment_two->getEpisode()->getSubredditId());
$this->assertEquals($test_one->getIncremented(), $assignment_one->getIncremented());
$this->assertEquals($test_two->getIncremented(), $assignment_two->getIncremented());
$assignment_one->delete();
$assignment_two->delete();
$episode_one->delete();
$episode_two->delete();
$episode_three->delete();
$deadline_one->delete();
$deadline_two->delete();
$user->delete();
$subreddit->delete();
}
/**
* applies the changes made to this object into database
* this method is smart enough to know if any changes are made
* and whether to use INSERT or UPDATE statement
*
* this method also saves the related components
*
* Before creating a new EpisodeAssignment, this function verifies the
* following rules:
*
* 101) Blocked users should not be able to sign up for an Episode. Throws
* an sfException upon this failure.
*
* 102) Only one sfGuardUser can sign up for one Episode with the same
* AuthorType for each Application period. Throws an sfException upon
* this failure.
*
* 103) An sfGuardUser can only sign up for the same Episode with one
* AuthorType. Throws an sfException upon this failure.
*
* 104) The EpisodeAssignment must be within the deadline for the
* AuthorType. Throws an sfException upon this failure.
*
* 105) If the current AuthorType is flagged to be unavailable before the
* previous AuthorType has passed its Deadline by its Application
* record for the Subreddit and this previous Deadline has not passed,
* then the object will not be saved. Throws an sfException upon this
* failure.
*
* 106) The user attached to the EpisodeAssignment must be validated.
*
* @see Doctrine_Record::save()
* @throws sfException
*
* @param Doctrine_Connection $conn optional connection parameter
* @throws Exception if record is not valid and validation is active
* @return void
*/
public function save(Doctrine_Connection $conn = null)
{
/* If an EpisodeAssignment already exists we don't care about it. */
if ($this->isNew()) {
/* Blocked users should not be able to sign up for an Episode.
*/
if (!$this->isAMember()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has not yet joined the Subreddit.", 101);
}
/* Blocked users should not be able to sign up for an Episode.
*/
if ($this->hasBlockedUser()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has a blocked Membership within Subreddit.", 101);
}
/* If the Subreddit doesn't allow pending users to post, then we fail if the user is a pending member of the Subreddit. */
if ($this->subredditBlocksPendingUsers()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has a pending Membership within Subreddit.", 101);
}
/* Only one sfGuardUser can sign up for one Episode with the same
* AuthorType for each Application period.
*/
if ($this->hasExistingUserAuthorTypeAssignment()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has already registered with AuthorType " . $this->getAuthorType() . " within Subreddit.", 102);
}
/* Only one sfGuardUser can sign up for one Episode with the same
* AuthorType for each Application period.
*/
if ($this->hasExistingAssignmentOnOtherEpisode()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has already registered with AuthorType " . $this->getAuthorType() . " within Subreddit.", 103);
}
/* The EpisodeAssignment must be within the deadline for the
* AuthorType.
*/
if (!$this->isBeforeDeadlineForAuthorType()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because the deadline has already passed for " . "AuthorType " . $this->getAuthorType() . " within " . "Subreddit.", 104);
}
/* Even if the deadline has not yet passed, we may only sign up an
* AuthorType if the AuthorType is allowed to register before the
* previous AuthorType (meaning the AuthorType with the next-longest
* deadline). The next few checks are for this purpose.
*/
$deadline_seconds = Doctrine::getTable('Deadline')->getSecondsByAuthorAndSubreddit($this->getAuthorTypeId(), $this->getEpisode()->getSubredditId());
if ($deadline_seconds === false) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because the deadline doesn't exist for AuthorType " . $this->getAuthorType() . " within Subreddit.", 107);
}
/* Check to see if there *is* a previous AuthorType by Deadline
* length.
*/
if ($previous_author_type_id = DeadlineTable::getInstance()->getFirstAuthorTypeIdBySubredditWhereDeadlineIsGreaterThan($deadline_seconds, $this->getEpisode()->getSubredditId())) {
/* If a previous AuthorType exists, we need to see if the
* current AuthorType is restricted until that previous
* uthorType is expired. If it *is* restricted, then we need to
* see if the previous AuthorType has yet expired. If the
* previous AuthorType is still beyond its Deadline for the
* Episode (and has not expired) then we cannot allow the
* current EpisodeAssignment to be saved.
*/
if (DeadlineTable::getInstance()->getIfDeadlineRestrictedByAuthorTypeAndSubreddit($this->getAuthorTypeId(), $this->getEpisode()->getSubredditId()) && $this->isBeforeDeadlineForAuthorType($previous_author_type_id)) {
$prev_author_type = AuthorTypeTable::getInstance()->find($previous_author_type_id);
$this->deleteWithException("Cannot create " . "EpisodeAssignment because the deadline has " . "not yet passed for the previous AuthorType " . $prev_author_type . " within Subreddit.", 105);
}
}
if (!$this->hasVerifiedUser()) {
$this->deleteWithException("Cannot create EpisodeAssignment " . "because User " . $this->getSfGuardUser()->getUsername() . " has not validated their Reddit username yet.", 106);
}
$isNew = true;
} else {
$isNew = false;
}
/* If the obejct is not new or has passed all rules for saving, we pass
* it on to the parent save function.
*/
$this->setIdHashIfNotSet();
parent::save($conn);
if ($isNew) {
/* Now that we have a new EpisodeAssignment that has passed all
* rules, let's set it to be valid if it belongs to the first
* Deadline and send an email to the user about it.
*/
$subreddit = SubredditTable::getInstance()->find($this->getEpisode()->getSubredditId());
$deadline = DeadlineTable::getInstance()->find($subreddit->getFirstDeadlineId());
if ($deadline) {
if ($this->getAuthorTypeId() == $deadline->getAuthorTypeId()) {
$episode = $this->getEpisode();
$episode->setEpisodeAssignmentId($this->getIncremented());
$episode->save();
$release_date = strtotime($episode->getReleaseDate());
$seconds = $deadline->getSeconds();
$deadline = $release_date - $seconds;
$subreddit->sendEmailAboutNewAssignment($this->getSfGuardUserId(), $this->getEpisodeId(), $deadline);
}
}
}
}
protected function execute($arguments = array(), $options = array())
{
// initialize the database connection
$databaseManager = new sfDatabaseManager($this->configuration);
$connection = $databaseManager->getDatabase($options['connection'])->getConnection();
$quiet = (bool) $options['quiet'];
// add your code here
$num_subreddits = 1000;
$num_deadlines = 5;
$num_users = 3000;
$create_episodes_attempt = 3;
echo " Creating AuthorTypes...";
$authortypes = new Doctrine_Collection('AuthorType');
for ($i = 0; $i < $num_deadlines; $i++) {
$exists = AuthorTypeTable::getInstance()->findOneBy('type', $i);
if ($exists) {
$authortypes[$i] = $exists;
} else {
$authortypes[$i] = new AuthorType();
}
$authortypes[$i]->setType($i);
$authortypes[$i]->setDescription($i);
if (!$quiet) {
echo $authortypes[$i]->getType() . ' ';
}
}
$authortypes->save();
/*echo "\n Creating Subreddits...";
$subreddits = new Doctrine_Collection('Subreddit');
$x = 0;
for ($i = 0; $i < $num_subreddits; $i++) {
$exists = SubredditTable::getInstance()->findOneBy('name', $i);
if ($exists) {
if (!$quiet)
echo $exists->getName() . ' ';
continue;
}
$subreddits[$x] = new Subreddit();
$subreddits[$x]->setName($i);
$subreddits[$x]->setDomain($i);
$subreddits[$x]->setEpisodeScheduleCronFormatted('0 0 * * *');
$subreddits[$x]->setCreateNewEpisodesCronFormatted('0 0 1 * *');
if (!$quiet)
echo $subreddits[$x]->getName() . ' ';
$x++;
}
if ($x)
$subreddits->save();
echo "\n Creating Deadlines...";
$deadlines = new Doctrine_Collection('Deadline');
$x = 0;
for ($i = 0; $i < $num_subreddits; $i++) {
$subreddit = SubredditTable::getInstance()->findOneBy('name', $i);
$deadlines = $subreddit->getDeadlines();
if (!$quiet)
echo $subreddit->getName() . ' ';
if (count($deadlines) == 0) {
for ($j = 0; $j < $num_deadlines; $j++) {
$deadlines[$x] = new Deadline();
$deadlines[$x]->setAuthorType($authortypes[$j]);
$deadlines[$x]->setSubreddit($subreddit);
$deadlines[$x]->setSeconds((24 / $num_deadlines) * $j);
$x++;
}
}
}
if ($x)
$deadlines->save();
unset($deadlines);
echo "\n Creating fake users for signup...";
$users = new Doctrine_collection("sfGuardUser");
$x = 0;
for ($i = 0; $i < $num_users; $i++) {
$exists = sfGuardUserTable::getInstance()->findOneBy('username', $i);
if ($exists) {
$users[$x] = $exists;
continue;
} else {
$users[$x] = new sfGuardUser();
}
$users[$x]->setUsername($i);
$users[$x]->setEmailAddress($i);
$users[$x]->setIsValidated(1);
if (!$quiet)
echo $users[$x]->getUsername() . ' ';
$x++;
}
$users->save();
echo "Joining to subreddits...";
$memberships = new Doctrine_Collection('sfGuardUserSubredditMembership');
$x = 0;
$member = MembershipTable::getInstance()->findOneBy('type', 'member');
foreach($users as $user)
{
echo $user->getUsername() .' ';
foreach($subreddits as $subreddit)
{
$exists = sfGuardUserSubredditMembershipTable::getInstance()->getFirstByUserSubredditAndMemberships($user->getIncremented(), $subreddit->getIncremented(), array('member'));
if ($exists)
{
continue;
}
$memberships[$x] = new sfGuardUserSubredditMembership();
$memberships[$x]->setSfGuardUserId($user->getIncremented());
$memberships[$x]->setSubredditId($subreddit->getIncremented());
$memberships[$x]->setMembershipId($member->getIncremented());
}
}
if ($x)
$memberships->save();
echo "\n Analyizing which need Episodes...";
$subreddits = Doctrine::getTable('Subreddit')
->getSubredditsNeedingEpisodeGeneration();
foreach ($subreddits as $subreddit) {
if (!$quiet)
echo $subreddit->getName() . ' ';
$episodes = $subreddit->collectGeneratedEpisodes();
if (!$quiet)
echo ' Generated...';
$episodes->save();
if (!$quiet)
echo " Saved!\n";
}*/
echo "\n Randomly having users attempt to sign up for Episodes...";
$assignments = new Doctrine_Collection('EpisodeAssignment');
$x = 0;
for ($i = 0; $i < $num_users; $i++) {
$user = sfGuardUserTable::getInstance()->findOneBy('username', $i);
echo $user->getUsername();
for ($j = 0; $j < $create_episodes_attempt; $j++) {
$episode = EpisodeTable::getInstance()->getRandomUnassignedFutureEpisode();
if (!$episode) {
continue;
}
$assignments[$x] = new EpisodeAssignment();
$assignments[$x]->setEpisodeId($episode->getIncremented());
$assignments[$x]->setSfGuardUserId($user->getIncremented());
$assignments[$x]->setAuthorType($authortypes[$j]);
try {
$assignments[$x]->save();
} catch (Exception $e) {
unset($e);
}
}
}
}
/**
* Tests for success at creating the object.
*/
public function testCreate()
{
$t = AuthorTypeTable::getInstance();
$this->assertTrue($t instanceof Doctrine_Table);
}
