root/trunk/apps/main/modules/sfGuardAuth/actions/actions.class.php

<?php
require_once dirname(__FILE__).'/../lib/BasesfGuardAuthActions.class.php';
/**
 * sfGuardAuth plugin overriden actions
 *
 * @package    symfony
 * @subpackage plugin
 */
class sfGuardAuthActions extends BasesfGuardAuthActions
{

  public function executeActivate(sfWebRequest $request)
  {
    /*
     * $this->user and $this->activation has been set in validateActivate()
     */
    $this->user->setIsActive(true);
    $this->user->save();
    $this->activation->delete();
    $this->purgePersonRelatedCache($this->user);
    try
    {
      $this->getUser()->setFlash('notice', $this->__('Your account has been activated. You can now log in using the username and password you provided at registration time.'));
      $this->getUser()->setAttribute('redirect_after_login', '@user_profile');
      $this->redirect('@sf_guard_signin');
    }
    catch (sfStopException $e)
    {
      throw $e;
    }
    catch (Exception $e)
    {
      $request->setError('errors', $this->__('Unable to activate your account'));
      sfContext::getInstance()->getLogger()->err('Blocking error at account activation time: '.$e->getMessage());
      return sfView::SUCCESS;
    }
  }
  
  public function executeChangePassword(sfWebRequest $request)
  {
    if ($request->isMethod('post'))
    {
      $user = $this->getUser()->getGuardUser();
      $password = $request->getParameter('new_password');
      $user->setPassword($password);
      $user->save();
      $this->getUser()->setFlash('notice', $this->__('Your password has been changed'));
      $this->redirect('@user_profile');
    }
  }
  
  public function executeDeleteAvatar(sfWebRequest $request)
  {
    $user = $this->getUser()->getGuardUser();
    if (!$user || !$user->getAvatarPath())
    {
      return sfView::NONE;
    }
    $basedir = sfConfig::get('sf_upload_dir').DIRECTORY_SEPARATOR.sfConfig::get('app_people_upload_dir', 'people');
    if (!ImagesTools::deleteImagesFromFormatParameters($user->getAvatarPath(), $basedir, sfConfig::get('app_people_formats')))
    {
      $user->setAvatarPath(null);
      $user->save();
      $this->purgePersonRelatedCache($user);
      return $this->renderText($this->__('Picture deleted'));
    }
    else
    {
      sfContext::getInstance()->getLogger()->err('Unable to remove user avatar');
      return $this->renderText($this->__('Picture deletion failed'));
    }
  }
  
  public function executeForgotPassword(sfWebRequest $request)
  {
    if ($request->isMethod('post'))
    {
      $password = substr(md5(rand(100000, 999999)), 0, 8);
      $email = $request->getParameter('email');
      $user = sfGuardUserPeer::retrieveByEmail($email);
      $this->forward404Unless($user, sprintf('User not with email "%s" found', $email));
      $user->setPassword($password);
      $user->save();
      
      $request->setAttribute('user', $user);
      $request->setAttribute('password', $password);
      $mailSent = $this->sendSwiftSmtpPlainMail('mail', 'forgotPassword',
                                                $user->getEmail(),
                                                $this->__('Your new requested password'));
      if (!$mailSent)
      {
        $request->setError('errors', $this->__('We were not able to send you an email. Please try again later.'));
        return sfView::SUCCESS;
      }
      $this->getUser()->setFlash('notice', $this->__('A new password has been emailed to %email%',
                                          array('%email%' => $email)));
      $this->redirect('@sf_guard_signin');
    }
  }

  public function executeProfile(sfWebRequest $request)
  {
    $this->embedGoogleJavascriptApi();
    
    $this->user = $this->getUser()->getGuardUser();

    if ($request->getMethod() != sfRequest::POST)
    {
      return sfView::SUCCESS;
    }
    
    $profile = $request->getParameter('profile', array());
    
    # 1. Boolean values
    if (!isset($profile['allow_contact']))
    {
      $profile['allow_contact'] = false;
    }
    if (!isset($profile['allow_localization']))
    {
      $profile['allow_localization'] = false;
    }
    if (!isset($profile['is_for_hire']))
    {
      $profile['is_for_hire'] = false;
    }
    
    # 2. Dates
    if (!$profile['birthdate'])
    {
      unset($profile['birthdate']);
    }
    if (!$profile['php_at'])
    {
      unset($profile['php_at']);
    }
    if (!$profile['symfony_at'])
    {
      unset($profile['symfony_at']);
    }
    
    try
    {
      $thumb = ImagesTools::createThumbs (
        'profile[avatar_path]', 
        sfConfig::get('sf_upload_dir').DIRECTORY_SEPARATOR.sfConfig::get('app_people_upload_dir', 'people'),
        md5($this->user->getUsername()).'.jpg',
        sfConfig::get('app_people_formats')
      );
      if ($thumb)
      {
        $profile['avatar_path'] = $thumb;
      }
      $this->user->fromArray($profile, BasePeer::TYPE_FIELDNAME);
      $localization = $this->user->getLocalization();
      if ($profile['latitude'] && $profile['longitude'])
      {
        $localization->setLatitude($profile['latitude']);
        $localization->setLongitude($profile['longitude']);
        $localization->save();
        unset($profile['latitude']);
        unset($profile['longitude']);
      }
      else
      {
        $this->user->updateLocalization();
      }
      $this->user->save();
      $this->purgePersonRelatedCache($this->user);
      $this->getUser()->setFlash('notice', $this->__('Your profile has been updated'));
      $this->redirect('@user_profile');
    }
    catch (sfStopException $e)
    {
      throw $e;
    }
    catch (Exception $e)
    {
      $request->setError('errors', $this->__('Unable to save your profile'));
      sfContext::getInstance()->getLogger()->err('Blocking error at profile save time: '.$e->getMessage());
      return sfView::SUCCESS;
    }
  }

  public function executeSkills(sfWebRequest $request)
  {
    $this->user = $this->getUser()->getGuardUser();
    $this->user_skills = $this->user->getSkills();
    $this->skill_tags = sfConfig::get('app_people_skill_tags', array());
    asort($this->skill_tags);
    if ($request->isMethod('post'))
    {
      $user_skills = $request->getParameter('skills', array());
      $this->user->removeAllTags();
      $this->user->save();
      foreach ($user_skills as $skill)
      {
        if (!in_array($skill, $this->skill_tags))
        {
          $this->logMessage(sprintf('Skill "%s" is not an allowed one (submitted by user "%s")',
                                    $skill, $this->user->getUsername()));
          continue;
        }
        $this->user->addTag($skill);
      }
      $this->user->save();
      $this->getUser()->setFlash('notice', $this->__('Your skills have been updated'));
      $this->redirect('@user_profile_skills');
    }
  }
  
  public function handleErrorProfile()
  {
    $this->embedGoogleJavascriptApi();
    $this->user = $this->getUser()->getGuardUser();
    return sfView::SUCCESS;
  }
  
  public function handleErrorForgotPassword()
  {
    return sfView::SUCCESS;
  }
  
  public function executeRegister(sfWebRequest $request)
  {
    if ($this->getUser()->isAuthenticated())
    {
      $this->redirect('@homepage');
    }
    
    $this->form = new RegisterForm();
    
    // Recaptcha parameters
    $captcha = array(
      'recaptcha_challenge_field' => $request->getParameter('recaptcha_challenge_field'),
      'recaptcha_response_field'  => $request->getParameter('recaptcha_response_field'),
    );
    $params = array_merge($request->getParameter('user', array()), array('captcha' => $captcha));
    
    if (!$request->isMethod('post') or !$this->form->bindAndSave($params))
    {
      return sfView::SUCCESS; // redisplay form with errors
    }
    
    // At this point we got a valid form and a created sfGuardUser object
    $user = $this->form->getObject();
    
    // Create activation entry
    $activation = new Activation();
    $activation->setUserId($user->getId());
    $activation->setHash(md5(rand(100000, 999999)));
    $activation->save();
    
    // Send user an activation email
    $request->setAttribute('user', $user);
    $request->setAttribute('activation', $activation);
    $mailSent = $this->sendSwiftSmtpPlainMail('mail', 'register',
                                              $user->getEmail(),
                                              $this->__('Please confirm your Symfonians account creation request'));
    
    // If mail sending failed, 
    if (!$mailSent)
    {
      $request->setError('errors', $this->__('We were unable to send you an activation email. Registration process failed.'));
      $activation->delete();
      $user->delete();
      return sfView::SUCCESS;
    }
    $this->getUser()->setFlash('notice', $this->__('A confirmation mail has been sent to %mail%',
                                                   array('%mail%' => $user->getEmail())));
    $this->redirect('@user_register_done');
  }
  
  public function executeRegisterDone(sfWebRequest $request)
  {
    $this->user = $request->getAttribute('user');
    return sfView::SUCCESS;
  }
  
  public function executeResendActivation(sfWebRequest $request)
  {
    $this->form = new ResendActivationForm();
    
    if ($request->isMethod('post'))
    {
      // Recaptcha parameters
      $captcha = array(
        'recaptcha_challenge_field' => $request->getParameter('recaptcha_challenge_field'),
        'recaptcha_response_field'  => $request->getParameter('recaptcha_response_field'),
      );
      $params = array_merge($request->getParameter('user', array()), array('captcha' => $captcha));
      
      $this->form->bind($params);
      
      if ($this->form->isValid())
      {
        $user = sfGuardUserPeer::retrieveByEmail($params['email']);
        $this->forward404Unless($user); // theoricaly, can't happen
        
        $c = new Criteria();
        $c->add(ActivationPeer::USER_ID, $user->getId());
        $activation = ActivationPeer::doSelectOne($c);
        $request->setAttribute('activation', $activation);
        
        $mailSent = $this->sendSwiftSmtpPlainMail('mail', 'resendActivation',
                                                  $user->getEmail(),
                                                  $this->__('Please activate your account'));
        if (!$mailSent)
        {
          $this->getUser()->setFlash('warning', $this->__('We were unable to send you an email. We are digging the problem, stay tuned.'));
          return sfView::SUCCESS;
        }
        $this->getUser()->setFlash('notice', $this->__('Your activation mail has been sent to '.$user->getEmail()));
        $this->redirect('@homepage');
      }
    }
  }
  
  public function handleErrorChangePassword()
  {
    return sfView::SUCCESS;
  }
  
  public function handleErrorRegister()
  {
    return sfView::SUCCESS;
  }
  
  public function validateActivate()
  {
    $key = $this->getRequestParameter('key');
    $c = new Criteria();
    $c->add(ActivationPeer::HASH, $key);
    $c->addJoin(ActivationPeer::USER_ID, sfGuardUserPeer::ID);
    
    $this->activation = ActivationPeer::doSelectOne($c);
    if (!$this->activation)
    {
      $request->setError('errors', $this->__('Unable to find this activation key: '.$key));
      return false;
    }
    
    $this->user = $this->activation->getsfGuardUser();
    if (!$this->user)
    {
      $this->getRequest()->setError('errors', $this->__('Unable to find user to activate'));
      return false; 
    }
    
    if ($this->user->getIsActive())
    {
      $this->getRequest()->setError('errors', $this->__('Related account has already been activated'));
      return false;
    }
    
    return true;
  }
  
  public function validateChangePassword()
  {
    if ($this->getRequest()->isMethod('post'))
    {
      $user = $this->getUser()->getGuardUser();
      if (!$user->checkPassword($this->getRequestParameter('current_password')))
      {
        $request->setError('errors', $this->__('You did not provide your current password correctly!'));
        return false;
      }
      return true;
    }
  }
  
  public function validateForgotPassword()
  {
    if ($this->getRequest()->isMethod('post'))
    {
      $user = sfGuardUserPeer::retrieveByEmail(trim($this->getRequestParameter('email')));
      if (!$user)
      {
        $this->getRequest()->setError('errors', $this->__('This email has never been registered here'));
        return false;
      }
      if (!$user->getIsActive())
      {
        $this->getRequest()->setError('errors', $this->__('The related account is currently not activated'));
        return false;
      }
    }
    return true;
  }
  
}