2011-06-09 10 views
5

Tengo una aplicación Zend con dos módulos (administración y públicos) y para el público en Tengo el siguiente plugin para analizar mis amigos-url:utilizan adecuadamente de las lenguas en Zend Framework

class Custom_Controller_Plugin_Initializer extends Zend_Controller_Plugin_Abstract { 

    protected $_front; 
    protected $_request; 

    public function __construct() { 
     $this->_front = Zend_Controller_Front::getInstance(); 
     $this->_request = $this->_front->getRequest();   
    } 

    public function preDispatch(Zend_Controller_Request_Abstract $request) { 
    //checking if the url ends with "/"  
     $requestUri = $this->_request->getRequestUri(); 
     $path = parse_url($requestUri, PHP_URL_PATH); 
     $query = parse_url($requestUri, PHP_URL_QUERY); 
     if (substr($path, -1) != '/') { 
      header('location: ' . $path . (isset($query) ? '/?' . $query : '/')); 
      die(); 
     } 
// exploding the uri to get the parts.   
     $uri = explode('/', substr($path, strlen(Zend_Controller_Front::getInstance()->getBaseUrl()) + 1)); 


     $modelLanguage = new Model_Db_Language(); 
    //checking if the first part is of 2 characters and if it's a registered language 
     if ($modelLanguage->checkLanguage($uri[0])) {    
      $language = $uri[0]; 
      unset($uri[0]); //deleting the language from the uri. 
      $uri = array_values($uri); 
     } else { 
      $language = $modelLanguage->autoLanguage(); 
      if (!$uri[0] == '' && (strlen($uri[0]) == 2)) { 
       $uri[0] = $language; 
       header('location: ' . Zend_Controller_Front::getInstance()->getBaseUrl() . '/' . implode($uri) . (isset($query) ? '/?' . $query : '/')); 
       die(); 
      } 
     } 

//remember that the language was deleted from the uri 
     $this->_request->setParam('requestUri', implode('/', $uri)); 

     switch ($uri[0]) { 
      case 'search': 
       unset($uri[0]); 
       $this->_request->setParam('s', urldecode($uri[2])); 
       $this->_request->setModuleName('public'); 
       $this->_request->setControllerName('content'); 
       $this->_request->setActionName('search'); 
       $this->_request->setParam('template', 'search'); 
       break; 
     } 
     $this->_initTranslation($language); 
      $this->_initInterface(); 
}} 

Es muy útil si lo Quiero usar la estructura como domain.com/en/about-us/mision/ porque puedo analizar la url y obtener el primer param "en" y luego encontrar la página asociada a "about-us/mission", pero ¿qué pasa si quiero usar domain.com/en/user/profile/id/1/, conjunto de Zend "en "como controlador y" usuario "como acción. ¿Cómo puedo configurar el idioma en la url y correctamente?

Respuesta

9

Este es un problema común, así que permítanme generalizar y formalizar un poco.

Digamos que usted quiere que su aplicación web para soportar múltiples idiomas y tiene los siguientes requisitos de enrutamiento:

http://domain.com/language-code/controller-name/action-name

En otras palabras que desea utilizar "lenguaje de código", como local y combinar los anteriores con el enrutamiento predeterminado del módulo Zend.

Supongamos que también desea utilizar Zend_Translate para proporcionar contenido traducido según la configuración regional.

Aquí hay un código que uso y con frecuencia "exportar" al proyecto con requisitos similares, estoy abierto a analizarlo más a fondo.

artículos relevantes de configuración:

resources.frontController.plugins.Language = Plugin_Language 
resources.frontController.actionHelperPaths.Controller_Helper = APPLICATION_PATH "/controllers/helpers" 


; Locale 

resources.locale.default = "en_US" 
resources.locale.force = false 

; Translate 

resources.translate.adapter = "Csv" 
resources.translate.data = APPLICATION_PATH "/languages" 

resources.translate.locale = "auto" 
resources.translate.disableNotices = true 
resources.translate.scan = directory 



; Routes 

resources.router.routes.module.type = Zend_Controller_Router_Route_Module 
resources.router.routes.module.abstract = On  

resources.router.routes.language.type = Zend_Controller_Router_Route 
resources.router.routes.language.route = ":language" 
resources.router.routes.language.reqs.language = "^[a-z]{2}$" 
resources.router.routes.language.defaults.language = "en" 

resources.router.routes.default.type = Zend_Controller_Router_Route_Chain 
resources.router.routes.default.chain = "language,module" 


; View 

resources.view.helperPath.View_Helper = APPLICATION_PATH "/views/helpers" 

Aquí el lenguaje Plugin registrado:

class Plugin_Language extends Zend_Controller_Plugin_Abstract { 

    public function routeStartup(Zend_Controller_Request_Abstract $request){ 

     if (substr($request->getRequestUri(), 0, -1) == $request->getBaseUrl()){ 

      /* Access to the Base Url (no language information) */ 

      /* Get current locale language (autodetected) */ 
      $language = Zend_Registry::get("Zend_Locale")->getLanguage(); 


      /* If requested language isn't available set to the default one */ 
      if (!Zend_Registry::get('Zend_Translate')->isAvailable($language)){ 

       Zend_Registry::set(
        "Zend_Locale", 
        new Zend_Locale("default") 
       ); 

       $language = Zend_Registry::get("Zend_Locale")->getLanguage(); 

       Zend_Registry::get("Zend_Translate")->setLocale(
        Zend_Registry::get('Zend_Locale') 
       ); 
      } 


      /* Modifiy Request Uri with Language info from current Locale */ 
      $request->setRequestUri($request->getRequestUri().$language."/"); 
      $request->setParam("language", $language); 

     } 
    } 


    public function routeShutdown(Zend_Controller_Request_Abstract $request){ 

     /* Get language from request param */ 
     $language = $request->getParam("language"); 

     /* If requested language isn't available set to the default one */ 
     if (!Zend_Registry::get('Zend_Translate')->isAvailable($language)) 
      throw new Zend_Controller_Router_Exception('Translation language is not available', 404); 

     /* Set the locale */ 

     Zend_Registry::set(
       "Zend_Locale", 
       new Zend_Locale($language) 
     ); 

     /* Set the traslator */ 

     Zend_Registry::get("Zend_Translate")->setLocale(
       Zend_Registry::get("Zend_Locale") 
     ); 


    } 

} 

La acción de ayuda:

class Controller_Helper_Language extends Zend_Controller_Action_Helper_Abstract { 

    /** 
    * 
    * Get Current language 
    * 
    * @return mixed string|null 
    */ 
    public function getCurrent(){ 

     if (!Zend_Registry::isRegistered("Zend_Locale")) 
      return null; 

     return Zend_Registry::get("Zend_Locale")->getLanguage(); 

    } 

    /** 
    * 
    * Get translator 
    * 
    * @return mixed Zend_Translate|null 
    * 
    */ 
    public function getTranslator(){ 

     if (!Zend_Registry::isRegistered("Zend_Translate")) 
      return null; 

     return Zend_Registry::get("Zend_Translate"); 

    } 

} 

El (por defecto) anulando una vista URL Helper. Debe escribir sus direcciones URL de acuerdo con la nueva ruta que está utilizando:

class View_Helper_Url extends Zend_View_Helper_Url { 

    protected function _getCurrentLanguage(){ 

     return Zend_Controller_Action_HelperBroker::getStaticHelper('Language') 
      ->getCurrent(); 

    } 

    public function Url($urlOptions = array(), $name = null, $reset = true, $encode = true){ 

     $urlOptions = array_merge(
      array(
       "language" => $this->_getCurrentLanguage() 
      ), 
      $urlOptions 
     ); 

     return parent::url($urlOptions,$name,$reset,$encode); 

    } 

} 

Espero que esta ayuda.

0

Yo diría que debe usar un enrutador personalizado. Para eso sirve el enrutador: determinar los parámetros del URI. Ahora solo permite que el enrutador funcione sin ningún motivo. Porque luego cambias el resultado de su trabajo.

Escribir enrutador personalizado no es tan difícil y le sugiero que lo haga. Puede escribir allí algo como:

  1. explotar por/
  2. es la primera parte "en", "de" o "es", si es así establecer lang = $ arr [0]
  3. trabajo como predeterminado ruta para Zend_Router

Y usted puede agregar muchas más opciones. También la coincidencia puede ser mucho más rápida porque puedes estructurar lógicamente la descomposición del URI. El enrutador normal es tonto: simplemente coincide con el URI para enrutar la expresión regular y se detiene cuando se encuentra la coincidencia.