root/trunk/lib/model/Application.php

<?php
/**
 * Subclass for representing a row from the 'applications' table.
 *
 * @package lib.model
 */
class Application extends BaseApplication
{

  /**
   * Returns a string representation of current object
   *
   * @return string
   */
  public function __toString()
  {
    return $this->getName();
  }

  /**
   * Fills current Application with array parameters, including tags
   *
   * @param  array   $arr
   * @param  string  $keyType
   */
  public function fromArray($arr, $keyType = BasePeer::TYPE_PHPNAME)
  {
    parent::fromArray($arr, $keyType);

    foreach (array('tags', 'Tags') as $tagField)
    {
      if (array_key_exists($tagField, $arr))
      {
        $this->setTags($arr[$tagField]);
      }
    }
  }

  /**
   * Converts current Application to an associative array
   *
   * @param  string $keyType
   * @return array
   */
  public function toArray($keyType = BasePeer::TYPE_PHPNAME)
  {
    $arr = parent::toArray($keyType);

    if (BasePeer::TYPE_FIELDNAME == $keyType)
    {
      $arr['tags'] = $this->getTagsString();
    }
    else if (BasePeer::TYPE_PHPNAME == $keyType)
    {
      $arr['Tags'] = $this->getTagsString();
    }

    return $arr;
  }

  /**
   * Retrieves related companies for this app
   *
   * @param  Criteria  $c
   * @return array
   */
  public function getCompanies(Criteria $c = null)
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $c->addJoin(ApplicationCompanyPeer::APPLICATION_ID, ApplicationPeer::ID);
    $c->addJoin(ApplicationCompanyPeer::COMPANY_ID, CompanyPeer::ID);
    $c->add(ApplicationPeer::ID, $this->getId());
    $c->add(CompanyPeer::IS_ACTIVE, true);
    return CompanyPeer::doSelect($c);
  }

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

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

  /**
   * Retrieves related developpers for this app
   *
   * @param  Criteria  $c
   * @return array
   */
  public function getDevelopers(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(ApplicationPeer::ID, $this->getId());
    $c->add(sfGuardUserPeer::IS_ACTIVE, true);
    return sfGuardUserPeer::doSelect($c);
  }

  /**
   * Retrieves related developpers and return their names in a string
   *
   * @param  Criteria  $c
   * @param  string    $separator
   * @return string
   */
  public function getDevelopersString(Criteria $c = null, $separator = ', ')
  {
    if (!$c instanceof Criteria)
    {
      $c = new Criteria;
    }
    $devs = array();
    foreach ($this->getDevelopers($c) as $developer)
    {
     $devs[] = $developer->getDisplayName();
    }
    return implode($separator, $devs);
  }

  /**
   * Returns a string containing ap tags
   *
   * @param  string  $separator
   * @return string
   */
  public function getTagsString($separator = ', ')
  {
    return implode($separator, $this->getTags());
  }

  /**
   * Check if current app has given user as related developer
   *
   * @param  $user
   * @return boolean
   */
  public function hasDeveloper($user)
  {
    if (is_null($user))
    {
      return false;
    }
    elseif ($user instanceof sfGuardUser)
    {
      $user = $user->getId();
    }
    elseif (!is_int($user))
    {
      throw new sfException('Impossible to check user from value '.
                            var_export($user, true));
    }
    $c = new Criteria();
    $c->add(ApplicationDeveloperPeer::DEVELOPER_ID, $user);
    return ($this->countApplicationDevelopers($c) > 0);
  }

  /**
   * Checks if current Application has a related Company
   *
   * @param  mixed   $company  Can be an integer or a BaseCompany object instance
   * @return boolean
   */
  public function hasCompanyConnected($company)
  {
    if (!$company)
    {
      return false;
    }

    if ($company instanceof BaseCompany)
    {
      $company_id = $company->getId();
    }
    else
    {
      $company_id = $company;
    }

    $c = new Criteria;
    $c->add(ApplicationCompanyPeer::COMPANY_ID, $company_id);

    return ($this->countApplicationCompanys($c) > 0);
  }

  /**
   * Checks if an application is owned by a given user
   *
   * @param int|sfGuardUser $user
   */
  public function isOwnedBy($user_id)
  {
    if ($user_id instanceof sfGuardUser)
    {
      $user_id = $user_id->getId();
    }

    return ($this->getSubmitterId() === $user_id);
  }

  /**
   * Deletes app
   *
   * @param  Connection $con
   * @return int
   */
  public function delete($con = null)
  {
    $this->removeAllTags();
    $this->save();
    $delete = parent::delete($con);
    return $delete;
  }

  /**
   * Saves app
   *
   * @param  Connection $con
   * @return int
   */
  public function save($con = null)
  {
    $new = $this->isNew();
    $modified = $this->isModified();
    $save = parent::save($con);

    // Create "app created" event object
    if ($modified && $this->getSubmitterId())
    {
      $event = new Event();
      $event->setSourceModel('sfGuardUser');
      $event->setSourceSlug($this->getsfGuardUser()->getUsername());
      $event->setSourceName($this->getsfGuardUser()->getDisplayName());
      $event->setTargetModel('Application');
      $event->setTargetSlug($this->getSlug());
      $event->setTargetName($this->getName());
      if ($new)
      {
        $event->setType('addition');
      }
      else
      {
        $event->setType('update');
      }
      $event->save();
    }

    return $save;
  }

  /**
   * Sets the feed url value
   *
   * @param string $v
   */
  public function setFeedUrl($v)
  {
    if ('http://' == trim(strtolower($v)))
    {
      $v = null;
    }

    return parent::setFeedUrl($v);
  }

  /**
   * Sets the homepage url value
   *
   * @param string $v
   */
  public function setHomepage($v)
  {
    if ('http://' == trim(strtolower($v)))
    {
      $v = null;
    }

    return parent::setHomepage($v);
  }

  /**
   * Sets is_featured field and update according relations
   *
   * @param  boolean $flag
   */
  public function setIsFeatured($flag)
  {
    if ($flag && !$this->getIsFeatured())
    {
      // Flag all apps as unfeatured
      $c = new Criteria();
      $c->add(ApplicationPeer::IS_FEATURED, false);
      ApplicationPeer::doUpdate($c);
    }
    parent::setIsFeatured($flag);
  }

  /**
   * Sets application tags, only if application has already been saved
   *
   * @param array|string $tags  Tags for the application
   */
  public function setTags($tags)
  {
    if ($this->isNew())
    {
      return;
    }

    $this->removeAllTags();
    $this->addTag($tags);
  }

}

$columns_map = array('from' => ApplicationPeer::NAME,
                     'to'   => ApplicationPeer::SLUG);

sfPropelBehavior::add('Application',
                      array('sfPropelActAsSluggableBehavior' =>
                            array('columns'   => $columns_map,
                                  'separator' => '-',
                                  'permanent' => true),
                            'sfPropelActAsTaggableBehavior'));

//sfLucenePropelBehavior::getInitializer()->setupModel('Application');