コード例 #1
0
 public function validateUpdate($payload, sfWebRequest $request = null)
 {
     parent::validateUpdate($payload, $request);
     $params = $this->parsePayload($payload);
     $user = $this->getUser()->getGuardUser();
     if (!$user) {
         throw new sfException('Action requires an auth token.', 401);
     }
     $primaryKey = $request->getParameter('id');
     $episode = EpisodeTable::getInstance()->find($primaryKey);
     if (!$this->getUser()->isSuperAdmin()) {
         $admin = sfGuardUserSubredditMembershipTable::getInstance()->getFirstByUserSubredditAndMemberships($user->getIncremented(), $episode->getSubredditId(), array('admin'));
         $moderator = sfGuardUserSubredditMembershipTable::getInstance()->getFirstByUserSubredditAndMemberships($user->getIncremented(), $episode->getSubredditId(), array('moderator'));
         if (!$admin) {
             if (array_key_exists('episode_assignment_id', $params)) {
                 $assignment = EpisodeAssignmentTable::getInstance()->find($params['episode_assignment_id']);
                 if ($assignment->getSfGuardUserId() != $user->getIncremented()) {
                     throw new sfException('You are not allowed to change the EpisodeAssignment of the Episode!', 403);
                 }
             }
             if (array_key_exists('approved_by', $params) && !$moderator && $params['approved_by'] != $user->getIncremented()) {
                 throw new sfException('You are not allowed to add approval for the Episode!', 403);
             }
         }
     }
 }
コード例 #2
0
 /**
  * Tests whether we can grab an Episode that is due to be released within a
  * specified length of time from now.
  */
 public function testGetOneEpisodeReleasedWithinSeconds()
 {
     // Create Test Subreddit
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 1000));
     $subreddit->setDomain(rand(0, 1000));
     $subreddit->save();
     // Create Test Episode
     $episode = new Episode();
     $episode->setReleaseDate(date('Y-m-d H:i:s', time() + 100));
     $episode->setSubreddit($subreddit);
     $episode->save();
     $another_episode = new Episode();
     $another_episode->setReleaseDate(date('Y-m-d H:i:s', time() + 500));
     $another_episode->setSubreddit($subreddit);
     $another_episode->save();
     $seconds_within = 200;
     // Run table query to grab episode without ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within);
     $this->assertTrue($random_episode instanceof Episode);
     // Run table query to grab episode WITH ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within, $episode->getIncremented());
     $this->assertTrue($random_episode instanceof Episode);
     // Run table query to grab anotherepisode WITH ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within, $another_episode->getIncremented());
     $this->assertFalse($random_episode instanceof Episode);
     // Delete episodes
     $another_episode->delete();
     $episode->delete();
     // Delete subreddit.
     $subreddit->delete();
 }
コード例 #3
0
 public function validateCreate($payload, sfWebRequest $request = null)
 {
     $params = $this->parsePayload($payload);
     $user = $this->getUser()->getGuardUser();
     if (!$user) {
         throw new sfException('Action requires an auth token.', 401);
     }
     $episode = EpisodeTable::getInstance()->find($params['episode_id']);
     $admin = sfGuardUserSubredditMembershipTable::getInstance()->getFirstByUserSubredditAndMemberships($user->getIncremented(), $episode->getSubredditId(), array('admin'));
     if (array_key_exists('sf_guard_user_id', $params) && !$this->getUser()->isSuperAdmin() && !$admin && $params['sf_guard_user_id'] != $user->getIncremented()) {
         throw new sfException('You are not allowed to create an EpisodeAssignment for someone else.', 403);
     }
     if (!array_key_exists('sf_guard_user_id', $params)) {
         $params[] = $user->getIncremented();
     }
     $payload = $this->packagePayload($params);
     unset($this->_payload_array);
     parent::validateCreate($payload, $request);
 }
コード例 #4
0
 public function executeAssign(sfWebRequest $request)
 {
     $auth_key = $this->getUser()->getApiAuthKey();
     $this->forward404Unless($request->getParameter('author_type_id') || $request->getParameter('episode_id'));
     $author_type_id = $request->getParameter('author_type_id');
     $episode_id = $request->getParameter('episode_id');
     $episode = EpisodeTable::getInstance()->find($episode_id);
     $user_id = $this->getUser()->getApiUserId();
     $post_values = array('author_type_id' => $author_type_id, 'episode_id' => $episode_id, 'sf_guard_user_id' => $user_id);
     $result = Api::getInstance()->setUser($auth_key)->post('episodeassignment', $post_values, false);
     $success = $this->checkHttpCode($result, 'post', 'episodeassignment', json_encode($post_values));
     if ($success) {
         $this->getUser()->setFlash('notice', 'Registered for Episode!  You will be notified when it becomes available.');
     }
     $this->redirect('subreddit/signup?domain=' . $episode->getSubreddit()->getDomain());
 }
コード例 #5
0
 public function advanceEpisodeAssignments()
 {
     $subreddit_first_deadlines = array();
     $subreddit_deadline_rules = array();
     // We establish the pool of emails we'll be sending.
     // First to those who pass their deadline
     $passed_deadline_assignments = array();
     // And to the new episode assignments that are reassigned
     $newly_assigned_assignments = array();
     // Now we can start on the assignments that are misassigned
     $assignments = EpisodeAssignmentTable::getInstance()->getMisassignedEpisodes();
     $episodes = new Doctrine_Collection('Episode');
     $e = -1;
     for ($i = 0; $i < count($assignments); $i++) {
         $passed_deadline_assignments[] = $assignments[$i];
         $assignments[$i]->setMissedDeadline(true);
         $episodes[++$e] = $assignments[$i]->getEpisode();
         // Clean up the Episode for any new user to use.
         $episodes[$e]->setEpisodeAssignmentId(null);
         $audio_file = $episodes[$e]->getAudioFile();
         $nice_filename = $episodes[$e]->getNiceFilename();
         $graphic_file = $episodes[$e]->getGraphicFile();
         $episodes[$e]->setAudioFile(null);
         $episodes[$e]->setNiceFilename(null);
         $episodes[$e]->setGraphicFile(null);
         $episodes[$e]->setIsNsfw(false);
         $episodes[$e]->setTitle(null);
         $episodes[$e]->setDescription(null);
         $episodes[$e]->setIsSubmitted(false);
         $episodes[$e]->setSubmittedAt(null);
         $episodes[$e]->setFileIsRemote(null);
         $episodes[$e]->setRemoteUrl(null);
         $episodes[$e]->setRedditPostUrl(null);
     }
     $episodes->save();
     $assignments->save();
     /* Now we make sure that all assignments past deadline are marked as
      * such.  If the assignment is here, however, then it hasn't ever
      * actually BEEN assigned and isn't added to the list of emails to send
      * out. */
     $assignments = EpisodeAssignmentTable::getInstance()->getUnmarkedEpisodesThatMissedDeadlines();
     for ($i = 0; $i < count($assignments); $i++) {
         $assignments[$i]->setMissedDeadline(true);
     }
     $assignments->save();
     /* Now all episodes are cleared and we need to see if they need to be
      * reassigned to an existing asignment. */
     /* Returns assignments closest to the front for each unassigned episode,
      * in order of closeness. */
     $assignments = EpisodeAssignmentTable::getInstance()->getEpisodesPossiblyNeedingAssignment();
     $subreddit_ids = EpisodeAssignmentTable::getInstance()->getSubrbedditsOfEpisodesPossiblyNeedingAssignment();
     $deadlines = DeadlineTable::getInstance()->getDeadlinesForGivenSubreddits($subreddit_ids);
     $subreddit_first_authortypes = array();
     $subreddit_deadline_rules = array();
     $begun = false;
     $prev_subreddit_id = null;
     foreach ($deadlines as $deadline) {
         $subreddit_id = $deadline['subreddit_id'];
         if ($prev_subreddit_id != $subreddit_id && $begun) {
             $begun = false;
             $prev_subreddit_id = $subreddit_id;
         }
         if (!$begun) {
             $subreddit_deadline_rules[$subreddit_id] = array($deadline['author_type_id'] => $deadline['seconds']);
             $subreddit_first_authortypes[$subreddit_id] = $deadline['author_type_id'];
             $begun = true;
         } else {
             $author_type_id = $deadline['author_type_id'];
             $subreddit_deadline_rules[$subreddit_id][$author_type_id] = $deadline['seconds'];
         }
     }
     $episodes_affected = array();
     // Things used from assignment: episode_id, epsiode, author_type_id, id, sf_guard_user_id
     // Things used from episode: subreddit_id, surbeddit, release_date,
     // Things used from subreddit: getFirstDeadlineId(), getDeadlineRules()
     foreach ($assignments as $assignment) {
         if (!in_array($assignment['episode_id'], $episodes_affected)) {
             /* Ignore all subsequent assignments for an episode after the
              * first!  We should only be dealing with assignments that have
              * not missed their deadlines! */
             $episodes_affected[] = $assignment['episode_id'];
             $assign_to_episode = false;
             $subreddit_id = $assignment['subreddit_id'];
             $subreddit = SubredditTable::getInstance()->find($subreddit_id);
             /* If the *first* assignment is in the first spot, then assign
              * it. */
             $deadline_rules = $subreddit_deadline_rules[$subreddit_id];
             $author_type_id = $assignment['author_type_id'];
             if ($author_type_id == $subreddit_first_authortypes[$subreddit_id]) {
                 $assign_to_episode = true;
             } else {
                 /* Otherwise, check if we are past the deadline for the
                  * previous deadline. */
                 /*$previous_author_type_id = DeadlineTable::getInstance()
                   ->getFirstAuthorTypeIdBySubredditWhereDeadlineIsGreaterThan(
                   $deadline_rules[$author_type_id],
                   $subreddit_id);*/
                 $inverse_deadline_rules = array_reverse($deadline_rules, true);
                 $previous_author_type_id = null;
                 foreach ($inverse_deadline_rules as $author_type => $seconds) {
                     if ($seconds > $deadline_rules[$author_type_id]) {
                         $previous_author_type_id = $author_type;
                         break;
                     }
                 }
                 $past_deadline_for_previous = strtotime($assignment['release_date']) - $deadline_rules[$previous_author_type_id] <= time();
                 if ($past_deadline_for_previous) {
                     $assign_to_episode = true;
                 }
             }
             if ($assign_to_episode) {
                 $saved_episode = EpisodeTable::getInstance()->find($assignment['episode_id']);
                 $saved_episode->setEpisodeAssignmentId($assignment['id']);
                 $saved_episode->save();
                 $newly_assigned_assignments[] = $assignment;
             }
         }
     }
     // We send the emails for the current deadline we're checking.
     foreach ($passed_deadline_assignments as $assignment) {
         $this->sendEmailAboutPassedDeadline($assignment['sf_guard_user_id'], $assignment['episode_id']);
     }
     foreach ($newly_assigned_assignments as $assignment) {
         $release_date = strtotime($assignment['release_date']);
         $author_type_id = $assignment['author_type_id'];
         $seconds = $deadline_rules[$author_type_id];
         $deadline = $release_date - $seconds;
         $this->sendEmailAboutNewAssignment($assignment['sf_guard_user_id'], $assignment['episode_id'], $deadline);
     }
 }
コード例 #6
0
 protected function deriveReleaseDate($parameters)
 {
     $episode_id = $parameters['episode_id'];
     $episode = EpisodeTable::getInstance()->find($episode_id);
     if (!$episode) {
         throw new sfException('Cannot find Episode identified by ' . $episode_id);
     }
     return date('l, F j, Y \\a\\t g:ia', strtotime($episode->getReleaseDate()));
 }
コード例 #7
0
 /**
  * Verifies if the current time is still before the Subreddit Deadline for
  * the AuthorType of the EpisodeAssignment.
  * 
  * If an AuthorType id is given, then the check is against the Subreddit
  * Deadline for that AuthorTyope.
  *
  * @param int $author_type_id  The id for a given AuthorType (optional)
  * @return bool                Whether the current time is within the 
  *                              Subreddit Deadline.
  */
 public function isBeforeDeadlineForAuthorType($author_type_id = null)
 {
     if (is_null($author_type_id)) {
         $author_type_id = $this->getAuthorTypeId();
     }
     if ($this->getMissedDeadline()) {
         return false;
     }
     $deadline_seconds = Doctrine::getTable('Deadline')->getSecondsByAuthorAndSubreddit($author_type_id, $this->getEpisode()->getSubredditId());
     $release_date = strtotime(EpisodeTable::getInstance()->getCurrentReleaseDate($this->getEpisodeId()));
     $now_and_deadline = time() + $deadline_seconds;
     if ($now_and_deadline > $release_date && !$this->getMissedDeadline()) {
         $this->setMissedDeadline(true);
     }
     return $now_and_deadline < $release_date;
 }
コード例 #8
0
 protected function validateEpisodeForImageUpload($id, $filename)
 {
     if (is_null($this->getUser()->getAttribute('valid_episode', null))) {
         // Base value is false
         $this->getUser()->setAttribute('valid_episode', false);
         $episode = EpisodeTable::getInstance()->find($id);
         if ($episode) {
             if ($this->getUser()->getApiUserId() == $episode->getEpisodeAssignment()->getSfGuardUserId() && !$episode->getIsApproved()) {
                 $valid_episode = true;
                 $this->getUser()->setAttribute('valid_episode', true);
                 $this->getUser()->setAttribute('valid_episode_id', $id);
                 $this->getUser()->setAttribute('valid_episode_user_id', $episode->getEpisodeAssignment()->getSfGuardUserId());
                 $this->getUser()->setAttribute('valid_episode_image_file_hash', $this->generateFilenameHashForImage($filename));
                 $episode->setGraphicFile($this->generateFilenameHashForImage($filename));
                 $episode->setSkipBackup(true);
                 $episode->save();
             }
         }
     }
     return $this->getUser()->getAttribute('valid_episode', false);
 }
コード例 #9
0
 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);
             }
         }
     }
 }