Cómo crear una librería personalizada en OpenCart

Aunque OpenCart ofrece un montón de funciones en la instalación por defecto, es posible que necesites añadir una característica que no esté incluida, y te veas obligado a integrar una librería de terceros. OpenCart cuenta con un montón de loibrerías para las operaciones del día a día como la interacción con el sistema de configuración o la base de datos, tratar con el correo electrónico, etc En este artículo, vamos a ver cómo crear tu propia librería personalizada en OpenCart.

En este artículo, vamos a crear una librería personalizada que permitirá realizar llamadas CURL. Vamos a hacer las cosas simples y directas, como lo más importante de entender es el concepto en sí, la aplicación puede variar en función de la complejidad.

Vamos a utilizar la versión más reciente de OpenCart. Asumimos que estás familiarizado con la estructura de módulos de OpenCart.

¿Qué es una librería en OpenCart?

Por lo tanto, ¿qué es exactamente una librería en OpenCart? En términos simples, es un conjunto de scripts útiles que nos proporcionan una funcionalidad usada comúnmente en el framework. En OpenCart, encontrarás que todas las librerías se albergan bajo el directorio system/library. Por ejemplo, una solicitud entrante se lleva a cabo con la librería Request, y para la gestión de respuesta se hace uso de la librería Response. Del mismo modo, hay librerías para cacheos, clientes, bases de datos, sistemas de configuración... sólo por nombrar algunos.

Generalmente, tendrás que cargar las librerías requeridas en el código de tu controlador/modelo. Deberás hacer algo así para cargar cualquier librería:

$cache = $this->load->library('cache');

En el ejemplo anterior, hemos cargado la librería caché. Así que de ahora en adelante, serás capaz de utilizar el objeto $cache para llamar a los métodos definidos en ducha librería. Como puedes ver, es una manera realmente flexible para cargar los objetos que necesites.

Ahora, vamos a implementar una librería, que se pueda utilizar cada vez que necesites realizar llamadas CURL. Esto es muy útil para evitar la duplicación de código en los controladores, ya que para cada solicitud CURL necesitarás una instancia del objeto y establecer los headers comunes. Vamos a meterla dentro de la librería común, de modo que sea reutilizable y, así, evitar la duplicación de código por todos los módulos.

Antes de seguir adelante y empezar la implementación de nuestra librería personalizada, vamos a echar un vistazo rápido a una de las librerías del núcleo de OpenCart.

Explorando librerías del núcleo de OpenCart

Como ya hemos hablado antes de la librería caché, en la sección anterior, ahora vamos a explorar el código de dicha librería. Abre el archivo system/library/cache.php en tu editor de texto favorito.

class Cache {
  private $cache;
 
  public function __construct($driver, $expire = 3600) {
    $class = 'Cache\' . $driver;
 
    if (class_exists($class)) {
      $this->cache = new $class($expire);
    } else {
      exit('Error: Could not load cache driver ' . $driver . ' cache!');
    }
  }
 
  public function get($key) {
    return $this->cache->get($key);
  }
 
  public function set($key, $value) {
    return $this->cache->set($key, $value);
  }
 
  public function delete($key) {
    return $this->cache->delete($key);
  }
}

Bastante fácil, ¿verdad? Nos proporciona una sencilla implementación basada en la clase con los métodos necesarios. Aunque se trata de un ejemplo muy sencillo, puede ser bastante compleja de implementar. Es por eso que vamos a llevar a cabo un ejemplo mucho más fácil para que puedas familiarizarte con el código

Creando una librería personalizada: Curl

Así que ahora, que ya cuentas con la teoría de las librerías del núcleo, vamos a crear nuestra propia. Crear un archivo system/library/curl.php con el siguiente contenido.

class Curl {
  private $logger;
  private static $instance;
   
  /**
   * @param  object  $registry  Registry Object
   */
  public static function get_instance($registry) {
    if (is_null(static::$instance)) {
      static::$instance = new static($registry);
    }
 
    return static::$instance;
  }
 
  /** 
   * @param  object  $registry  Registry Object
   * 
   * You could load some useful libraries, few examples:
   *
   *   $registry->get('db');
   *   $registry->get('cache');
   *   $registry->get('session');
   *   $registry->get('config');
   *   and more... 
   */
  protected function __construct($registry) {
    // load the "Log" library from the "Registry"
    $this->logger = $registry->get('log');
  }
   
  /**
   * @param  string  $url     Url
   * @param  array  $params  Key-value pair
   */
  public function do_request($url, $params=array()) {
    // log the request
    $this->logger->write("Initiated CURL request for: {$url}");
     
    // init curl object
    $ch = curl_init();
    curl_setopt($ch,CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
     
    // prepare post array if available
    $params_string = '';
    if (is_array($params) && count($params)) {
      foreach($params as $key=>$value) {
        $params_string .= $key.'='.$value.'&';
      }
      rtrim($params_string, '&');
     
      curl_setopt($ch,CURLOPT_POST, count($params));
      curl_setopt($ch,CURLOPT_POSTFIELDS, $params_string);
    }
     
    // execute request
    $result = curl_exec($ch);
     
    // close connection
    curl_close($ch);
     
    return $result;
  }
}

Hemos definido una clase Curl con un puñado de métodos.

Comenzamos con el método getInstance, que nos permite crear un objeto de la misma clase. También se asegurará de que en un momento dado solo tengamos una instancia de la clase.

A continuación, definimos el constructor con el argumento $registry. Por supuesto, no es necesario ningún argumento, pero a modo de ejemplo lo he utilizado para demostrar cómo cargar otras librerías usando el objeto $registry. En nuestro ejemplo, vamos a cargar la librería Log y la asignaremos a la propiedad logger. Vamos a utilizar esta librería para registrar las solicitudes de curl para propósitos de depuración.

Por último, hay un método llamado do_request el que hace todo el trabajo sucio por nosotros. Tiene dos parámetros: $url, que contiene la dirección URL a la que vamos a hacer la solicitud curl, y $params, que contiene un array de parámetros opcionales en el caso de que necesites postear algún dato. El siguiente código es bastante sencillo de entender: se hace una llamada curl y retorna una respuesta.

Ya casi hemos terminado la implementación de nuestra librería personalizada. La veremos en acción en la siguiente sección.

Cómo utilizar nuestra librería personalizada

Si necesitas cargar la librería y utilizar sus métodos, échale un vistazo al siguiente código y tómalo como ejemplo:

// load curl library
$this->load->library('curl');
$obj_curl = Curl::get_instance($this->registry);
         
$result = $obj_curl->do_request($url);
$result = $obj_curl->do_request($url, $params); // in case of $params needed

Fuente: Sajal Soni

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.