root/trunk/plugins/sfPropelActAsLocalizableBehaviorPlugin/lib/sfPropelActAsLocalizableBehavior.class.php

<?php
/**
 * Localizable behavior class for Propel
 *
 * @package plugins
 * @authior Nicolas Perriault
 */
class sfPropelActAsLocalizableBehavior
{
  
  /**
   * Cached localizations
   * @var array
   */
  protected static $localizations = array();
  
  /**
   * Behavior activation status
   * @var boolean
   */
  protected static $isActivated = true;
  
  /**
   * Cache a localization
   *
   * @param sfLocalization $localization
   */
  public static function addCachedLocalization(sfLocalization $localization)
  {
    $model_name = $localization->getModelName();
    $model_id = $localization->getModelId();
    self::$localizations[$model_name][$model_id] = $localization;
  }
  
  /**
   * Deactivate behavior
   *
   */
  public static function disable()
  {
    self::$isActivated = false;
  }
  
  /**
   * Activate behavior
   *
   */
  public static function enable()
  {
    self::$isActivated = true;
  }
  
  /**
   * Get a cached localization
   *
   * @param  string  $model_name
   * @param  string  $model_id
   * @return mixed
   */
  public static function getCachedLocalization($model_name, $model_id)
  {
    if (self::hasCachedLocalization($model_name, $model_id))
    {
      return self::$localizations[$model_name][$model_id];
    }
    else
    {
      return null;
    }
  }
  
  /**
   * Checks if a cached version of a localization exists
   *
   * @param string $model_name
   * @param string $model_id
   * @return boolean
   */
  public static function hasCachedLocalization($model_name, $model_id)
  {
    return isset(self::$localizations[$model_name]) 
        && isset(self::$localizations[$model_name][$model_id])
        && self::$localizations[$model_name][$model_id] instanceof sfLocalization;
  }
  
  /**
   * Actions to perform after an object has been deleted
   *
   * @param BaseObject $object
   * @return mixed
   */
  public function postDelete(BaseObject $object)
  {
    $model_name = get_class($object);
    $model_id = $object->getPrimaryKey();
    $c = new Criteria;
    $c->add(sfLocalizationPeer::MODEL_NAME, $model_name);
    $c->add(sfLocalizationPeer::MODEL_ID, $model_id);
    return sfLocalizationPeer::doDelete($c);
  }
  
  /**
   * Retrieves coordinates array for given object
   *
   * @param BaseObject $object
   * @return array
   */
  public function getCoordinates(BaseObject $object)
  {
    $localization = $object->getLocalization();
    if (is_null($localization))
    {
      return null;
    }
    return array('latitude'  => $localization->getLatitude(),
                 'longitude' => $localization->getLongitude());
  }
  
  /**
   * Retrieves latitude for given object
   *
   * @param BaseObject $object
   * @return float
   */
  public function getLatitude(BaseObject $object)
  {
    $coord = $this->getCoordinates($object);
    if (is_array($coord) && count($coord) > 0 && isset($coord['latitude']))
    {
      return $coord['latitude'];
    }
  }
  
  /**
   * Retrieves longitude for given object
   *
   * @param BaseObject $object
   * @return float
   */
  public function getLongitude(BaseObject $object)
  {
    $coord = $this->getCoordinates($object);
    if (is_array($coord) && count($coord) > 0 && isset($coord['longitude']))
    {
      return $coord['longitude'];
    }
  }
  
  /**
   * Retrieves BaseObjet location string, according to passed parameter
   *
   * @param BaseObject $object
   * @return string
   */
  public static function getLocationString(BaseObject $object)
  {
    $location_getter = sfConfig::get(
      sprintf('propel_behavior_sfPropelActAsLocalizableBehavior_%s_location_getter',
              get_class($object)));
    if (!method_exists($object, $location_getter))
    {
      throw new sfPropelActAsLocalizableBehaviorException(
                  sprintf('Location getter method "%s::%s" does not exist',
                          get_class($object),
                          $location_getter));
    }
    return trim((string) call_user_func(array($object, $location_getter)));
  }
  
  /**
   * Retrieve sfLocalization associated to current object
   *
   * @param  BaseObject $object
   * @param  boolean    $reload  Forces data refresh (with a db query)
   * @return sfLocalization
   */
  public function getLocalization(BaseObject $object, $reload = false)
  {
    $model_name = get_class($object);
    $model_id = $object->getPrimaryKey();
    if (!self::hasCachedLocalization($model_name, $model_id) or $reload)
    {
      $localization = sfLocalizationPeer::getOrCreate($model_name, $model_id);
      self::addCachedLocalization($localization);
      return $localization;
    }
    else
    {
      return self::getCachedLocalization($model_name, $model_id);
    }
  }
  
  /**
   * Update localization associated to object
   *
   * @param  BaseObject $object
   * @param  string     $location
   * @return mixed
   */
  public function updateLocalization(BaseObject $object, $location = null)
  {
    if (is_null($location))
    {
      $location = self::getLocationString($object);
    }
    
    if (!$location)
    {
      return null;
    }
    
    $client = new YahooGeocodingApiClient();
    try
    {
      $coord = $client->setLocation($location)->query()->getFirst();
      if (!$coord)
      {
        sfLogger::getInstance()->info(sprintf('No geolocalization result found for location "%s"',
                                              $location));
        return null;
      }
    }
    catch (Exception $e)
    {
      sfLogger::getInstance()->warning(sprintf('Error while localizing location "%s": %s',
                                               $location,
                                               $e->getMessage()));
      return null;
    }
    
    $localization = $object->getLocalization();
    $localization->setLatitude($coord['latitude']);
    $localization->setLongitude($coord['longitude']);
    $res = $localization->save();
    self::addCachedLocalization($localization);
    return $res;
  }

}