root/trunk/lib/model/PluginsfGuardUser.php

<?php

/*
 * This file is part of the symfony package.
 * (c) 2004-2006 Fabien Potencier <fabien.potencier@symfony-project.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 *
 * @package    symfony
 * @subpackage plugin
 * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
 * @version    SVN: $Id: PluginsfGuardUser.php 7995 2008-03-20 06:58:43Z fabien $
 */
class PluginsfGuardUser extends BasesfGuardUser
{
  protected
    $profile        = null,
    $groups         = null,
    $permissions    = null,
    $allPermissions = null;

  /**
   * Human readable string representation for current object instance
   *
   * @return string
   */
  public function __toString()
  {
    return $this->getDisplayName();
  }

  /**
   * Adds a skill tag to current person
   *
   * @param  mixed  $skills
   */
  public function addSkill($skills)
  {
    return $this->addTag($skills);
  }

  /**
   * Retrieves calculated user age
   *
   * @return int
   */
  public function getAge()
  {
    $age = null;

    if ($this->getBirthdate())
    {
      $age   = date("Y") - (int) $this->getBirthdate('Y');
      $month = (int) $this->getBirthdate('m');
      $day   = (int) $this->getBirthdate('d');

      if (date("m") < $month || (date("m") == $month && date("d") < $day))
      {
        --$age;
      }
    }

    return $age;
  }

  /**
   * Check if user allow to be contacted. If he published a job offer in its own
   * name, we override his settings
   *
   * @param  boolean  $check_jobs  Check if user has submitted a job in his name
   * @return boolean
   */
  public function getAllowContact($check_jobs = false)
  {
    $allow = parent::getAllowContact();

    if ($check_jobs && $this->countJobs(new Criteria) > 0)
    {
      $allow = true;
    }

    return $allow;
  }

  /**
   * Retrieves companies associated with current user
   *
   * @param  string  $type  Filter type (submitted, related, all)
   * @return array
   */
  public function getCompanies($type = 'submitted')
  {
    $c = new Criteria();
    $c->add(CompanyPeer::IS_ACTIVE, true);
    $c->addAscendingOrderByColumn(CompanyPeer::NAME);
    switch ($type)
    {
      case 'all':
        $companies = CompanyPeer::doSelect($c);
      break;
      case 'related':
        $c->addJoin(CompanyPersonPeer::COMPANY_ID, CompanyPeer::ID);
        $c->add(CompanyPersonPeer::USER_ID, $this->getId());
        $companies = CompanyPeer::doSelect($c);
      break;
      case 'submitted':
      default:
        $companies = $this->getCompanys($c);
      break;
    }
    return $companies;
  }

  /**
   * Retrieves simple hash of related companies. Useful for populating a select
   * html tag
   *
   * @param  string  $type  Filter type (submitted, related, all)
   * @return array
   */
  public function getCompaniesArray($type = 'submitted')
  {
    $companies = array();
    foreach ($this->getCompanies($type) as $company)
    {
      $companies[$company->getId()] = $company->getName();
    }
    return $companies;
  }

  /**
   * Returns related companies string
   *
   * @param  string  $separator
   * @return string
   */
  public function getCompaniesString($separator = ', ')
  {
    $companies = array();
    foreach ($this->getCompanies('related') as $company)
    {
      $companies[] = $company->getName();
    }
    return implode($separator, $companies);
  }

  /**
   * Retrieves country name
   *
   * @return string
   */
  public function getCountryName()
  {
    if ($this->getCountry())
    {
      sfLoader::loadHelpers('I18N');
      return format_country($this->getCountry());
    }
  }

  /**
   * Retrieves user display name
   *
   * @return string
   */
  public function getDisplayName()
  {
    $display_name = parent::getDisplayName();
    if (!is_null($display_name) && trim($display_name))
    {
      return $display_name;
    }
    else
    {
      return parent::getUsername();
    }
  }

  /**
   * Retrieves related applications
   *
   * @param  Criteria  $c
   * @return array
   */
  public function getRelatedApplications(Criteria $c = null)
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $c->addJoin(ApplicationDeveloperPeer::APPLICATION_ID, ApplicationPeer::ID);
    $c->addJoin(ApplicationDeveloperPeer::DEVELOPER_ID, sfGuardUserPeer::ID);
    $c->add(sfGuardUserPeer::ID, $this->getId());
    return ApplicationPeer::doSelect($c);
  }

  /**
   * Retrieves related applications and return their names in a string
   *
   * @param  string  $separator
   * @return string
   */
  public function getRelatedApplicationsString(Criteria $c = null, $separator = ', ')
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $applications = array();
    foreach ($this->getRelatedApplications($c) as $application)
    {
     $applications[] = $application->getName();
    }
    return implode($separator, $applications);
  }

  /**
   * Retrieves related companies
   *
   * @param  Criteria  $c
   * @return array
   */
  public function getRelatedCompanies(Criteria $c = null)
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $c->addJoin(CompanyPersonPeer::COMPANY_ID, CompanyPeer::ID);
    $c->addJoin(CompanyPersonPeer::USER_ID, sfGuardUserPeer::ID);
    $c->add(sfGuardUserPeer::ID, $this->getId());
    return CompanyPeer::doSelect($c);
  }

  /**
   * Retrieves mail sender address, in the form "Firstname Lastname" <name@isp.tld>
   *
   * @return string
   */
  public function getEmailSender()
  {
    return sprintf('"%s" <%s>', $this->getDisplayName(), $this->getEmail());
  }

  /**
   * Retrieves complete user geographical address in one line. This method is
   * mainly used for google maps links.
   *
   * @return string
   */
  public function getFullAddress()
  {
    sfLoader::loadHelpers('I18N');
    $address = sprintf('%s %s %s %s, %s (%s)',
                      $this->getAddress(),
                      $this->getZip(),
                      $this->getCity(),
                      $this->getState(),
                      format_country($this->getCountry()),
                      $this->getDisplayName());
    return SymfoniansToolkit::onelinize($address);
  }

  /**
   * Retrieves user location
   *
   * @return string
   */
  public function getLocation()
  {
    sfLoader::loadHelpers('I18N');
    $address = sprintf('%s %s %s %s, %s',
                      $this->getAddress(),
                      $this->getZip(),
                      $this->getCity(),
                      $this->getState(),
                      format_country($this->getCountry()));
    return SymfoniansToolkit::onelinize($address);
  }

  /**
   * Return avatar path, with optional stored format
   *
   * @param  string  $format (small16, small48, standard)
   * @return string
   */
  public function getAvatarPath($format = 'standard')
  {
    if (!parent::getAvatarPath())
    {
      return null;
    }

    return sprintf('/%s/%s', $format, parent::getAvatarPath());
  }

  /**
   * Checks if a user has entered an address
   *
   * @return boolean
   */
  public function hasAddress()
  {
    return $this->getCountry() && $this->getCity();
  }

  /**
   * Checks if a user has been recommended by another given user
   *
   * @param sfGuardUser $user
   * @return boolean
   */
  public function hasBeenRecommendedBy($user)
  {
    if ($user instanceof sfOutputEscaperObjectDecorator)
    {
      $user = $user->getRawValue();
    }

    if ($user instanceof sfGuardUser)
    {
      $user = $user->getId();
    }

    $c = new Criteria();
    $c->add(RecommendationPeer::RECOMMENDED_ID, $this->getId());
    $c->add(RecommendationPeer::RECOMMENDER_ID, $user);

    return (RecommendationPeer::doCount($c) > 0);
  }

  /**
   * Check if current user has given skill name
   *
   * @param  string  $skill
   * @return boolean
   */
  public function hasSkill($skill)
  {
    return $this->hasTag($skill);
  }

  /**
   * Set user passord
   *
   * @param string $password
   */
  public function setPassword($password)
  {
    if (!$password)
    {
      return;
    }

    $salt = md5(rand(100000, 999999).$this->getUsername());
    $this->setSalt($salt);
    $algorithm = sfConfig::get('app_sf_guard_plugin_algorithm_callable', 'sha1');
    $algorithmAsStr = is_array($algorithm) ? $algorithm[0].'::'.$algorithm[1] : $algorithm;
    if (!is_callable($algorithm))
    {
      throw new sfException(sprintf('The algorithm callable "%s" is not callable.', $algorithmAsStr));
    }
    $this->setAlgorithm($algorithmAsStr);

    parent::setPassword(call_user_func_array($algorithm, array($salt.$password)));
  }

  public function setPasswordBis($password)
  {
  }

  public function setPasswordHash($v)
  {
    if (!is_null($v) && !is_string($v))
    {
      $v = (string) $v;
    }

    if ($this->password !== $v)
    {
      $this->password = $v;
      $this->modifiedColumns[] = sfGuardUserPeer::PASSWORD;
    }
  }

  /**
   * Checks if given password matches current user one
   *
   * @param string $password
   * @return boolean
   */
  public function checkPassword($password)
  {
    if ($callable = sfConfig::get('app_sf_guard_plugin_check_password_callable'))
    {
      return call_user_func_array($callable, array($this->getUsername(), $password));
    }
    else
    {
      return $this->checkPasswordByGuard($password);
    }
  }

  /**
   * Checks password
   *
   * @param string $password
   * @return boolean
   */
  public function checkPasswordByGuard($password)
  {
    $algorithm = $this->getAlgorithm();

    if (false !== $pos = strpos($algorithm, '::'))
    {
      $algorithm = array(substr($algorithm, 0, $pos), substr($algorithm, $pos + 2));
    }

    if (!is_callable($algorithm))
    {
      throw new sfException(sprintf('The algorithm callable "%s" is not callable.', $algorithm));
    }

    return $this->getPassword() == call_user_func_array($algorithm, array($this->getSalt().$password));
  }

  public function getProfile()
  {
    if (!is_null($this->profile))
    {
      return $this->profile;
    }

    $profileClass = sfConfig::get('app_sf_guard_plugin_profile_class', 'sfGuardUserProfile');
    if (!class_exists($profileClass))
    {
      throw new sfException(sprintf('The user profile class "%s" does not exist.', $profileClass));
    }

    $fieldName = sfConfig::get('app_sf_guard_plugin_profile_field_name', 'user_id');
    $profilePeerClass =  $profileClass.'Peer';

    // to avoid php segmentation fault
    class_exists($profilePeerClass);

    $foreignKeyColumn = call_user_func_array(array($profilePeerClass, 'translateFieldName'), array($fieldName, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_COLNAME));

    if (!$foreignKeyColumn)
    {
      throw new sfException(sprintf('The user profile class "%s" does not contain a "%s" column.', $profileClass, $fieldName));
    }

    $c = new Criteria();
    $c->add($foreignKeyColumn, $this->getId());

    $this->profile = call_user_func_array(array($profileClass.'Peer', 'doSelectOne'), array($c));

    if (!$this->profile)
    {
      $this->profile = new $profileClass();
      if (method_exists($this->profile, 'setsfGuardUser'))
      {
        $this->profile->setsfGuardUser($this);
      }
      else
      {
        $method = 'set'.call_user_func_array(array($profilePeerClass, 'translateFieldName'), array($fieldName, BasePeer::TYPE_FIELDNAME, BasePeer::TYPE_PHPNAME));
        $this->profile->$method($this->getId());
      }
    }

    return $this->profile;
  }

  public function getPlace()
  {
    sfLoader::loadHelpers('I18N');
    $address = sprintf('%s %s %s %s %s',
                      $this->getAddress(),
                      $this->getZip(),
                      $this->getCity(),
                      $this->getState(),
                      format_country($this->getCountry()));
    return SymfoniansToolkit::onelinize($address);
  }

  /**
   * Retrieves all recommendations received by current user. Mainly a proxy to
   * the ugly named "getRecommendationsRelatedByRecommendedId" method.
   *
   * @param  Criteria   $c
   * @param  Connection $con
   * @return array
   */
  public function getReceivedRecommendations(Criteria $c = null, $con = null)
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $c->addDescendingOrderByColumn(RecommendationPeer::UPDATED_AT);
    return $this->getRecommendationsRelatedByRecommendedId($c, $con);
  }

  /**
   * Retrieves all recommendations sent by current user. Mainly a proxy to the
   * ugly named "getRecommendationsRelatedByRecommenderId" method.
   *
   * @param  Criteria   $c
   * @param  Connection $con
   * @return array
   */
  public function getSentRecommendations(Criteria $c = null, $con = null)
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $c->addDescendingOrderByColumn(RecommendationPeer::UPDATED_AT);
    return $this->getRecommendationsRelatedByRecommenderId($c, $con);
  }

  /**
   * Get user skill tags
   *
   * @return array
   */
  public function getSkills()
  {
    return $this->getTags();
  }

  /**
   * Get user skill tags string
   *
   * @return string
   */
  public function getSkillsString($separator = ', ')
  {
    return implode($separator, $this->getSkills());
  }

  public function addGroupByName($name, $con = null)
  {
    $group = sfGuardGroupPeer::retrieveByName($name);
    if (!$group)
    {
      throw new Exception(sprintf('The group "%s" does not exist.', $name));
    }

    $ug = new sfGuardUserGroup();
    $ug->setsfGuardUser($this);
    $ug->setGroupId($group->getId());

    $ug->save($con);
  }

  public function addPermissionByName($name, $con = null)
  {
    $permission = sfGuardPermissionPeer::retrieveByName($name);
    if (!$permission)
    {
      throw new Exception(sprintf('The permission "%s" does not exist.', $name));
    }

    $up = new sfGuardUserPermission();
    $up->setsfGuardUser($this);
    $up->setPermissionId($permission->getId());

    $up->save($con);
  }

  public function hasGroup($name)
  {
    if (!$this->groups)
    {
      $this->getGroups();
    }

    return isset($this->groups[$name]);
  }

  public function getGroups()
  {
    if (!$this->groups)
    {
      $this->groups = array();

      $c = new Criteria();
      $c->add(sfGuardUserGroupPeer::USER_ID, $this->getId());
      $ugs = sfGuardUserGroupPeer::doSelectJoinsfGuardGroup($c);

      foreach ($ugs as $ug)
      {
        $group = $ug->getsfGuardGroup();
        $this->groups[$group->getName()] = $group;
      }
    }

    return $this->groups;
  }

  public function getGroupNames()
  {
    return array_keys($this->getGroups());
  }

  public function hasPermission($name)
  {