Parece que no tienen documentación, excepto algunas llamadas a la API en sus foros oficiales. Tengo experiencia con el framework Zend y CodeIgniter. ¿Puede algún maestro de OpenCart recomendarme la mejor manera de aprenderlo y dominarlo en el menor tiempo posible? Tengo que hacer un gran proyecto con él pronto.

Guía de inicio rápido para desarrolladores de OpenCart 1.5.X para principiantes

Esta guía está escrita para desarrolladores que ya están familiarizados con PHP, OOP y la arquitectura MVC.

A continuación, verá ejemplos del lado del catálogo del carrito. El lado de administración es idéntico en función con la excepción de las vistas que se indican en la sección correspondiente

Entendiendo las Bibliotecas

Se puede acceder a toda la funcionalidad de la biblioteca a través de Controlador, Modelo y Vistas usando $this->library_name. Todos estos se pueden encontrar en la /system/library/carpeta. Por ejemplo, para acceder a los productos del carrito de la compra actual, deberá utilizar la Cartclase, que se encuentra en /system/library/cart.phpy se puede acceder mediante$this->cart->getProducts()

Artículos de uso común

• customer.php - Funciones relacionadas con el cliente
• user.php - Funciones relacionadas con el usuario administrador
• cart.php - Funciones relacionadas con el carrito
• config.php - Todos los ajustes se cargan desde este
• url.php - Funciones de generación de URL

Comprender el parámetro de ruta

El marco de OpenCart se basa en el route=aaa/bbb/cccparámetro de cadena de consulta para saber qué cargar, y es la característica fundamental para encontrar los archivos que necesita editar para cada página. La mayoría de las rutas en realidad solo usan las aaa/bbbque deberían verse como dos partes, sin embargo algunas contienen tres partes. aaa/bbb/cccLa primera parte aaageneralmente está relacionada con la carpeta dentro de una carpeta genérica como el controlador o las carpetas de plantilla. La segunda parte suele estar relacionada con el nombre del archivo, sin la extensión .phpni la correspondiente .tpl. La tercera parte se explica en la sección "Comprensión de los controladores" a continuación.

Entendiendo idiomas

Los idiomas se almacenan en la /catalog/language/carpeta de la your-languagesubcarpeta. Dentro de esto, los valores de texto generales utilizados en varias páginas se almacenan en el your-language.phparchivo dentro de la carpeta, por lo que para el idioma inglés en el lado del catálogo, encontrará los valores en catalog/language/english/english.php. Para un texto de página específico, necesitará el routepara la página (este es generalmente el caso, pero no siempre, ya que puede especificar cualquier archivo de idioma que desee). Por ejemplo, la página de búsqueda tiene la ruta product/searchy, por lo tanto, el texto específico del idioma para esa página se puede encontrar en catalog/language/english/product/search.php(Observe que el nombre del archivo y la subcarpeta coinciden con la ruta seguida por .php.

Para cargar el idioma en un controlador, usa

$this->language->load('product/search');

Luego, puede utilizar la función de biblioteca de idiomas getpara recuperar textos de idiomas específicos, como

$some_variable = $this->language->get('heading_title');

Las variables de idioma se asignan en el archivo de idioma mediante una variable especial $_que es una matriz de claves y valores de texto. En tu /catalog/language/english/product/search.phpdeberías encontrar algo similar a

$_['heading_title']     = 'Search';

Los valores en el archivo de idioma global english/english.phpse cargan automáticamente y están disponibles para su uso sin el $this->language->loadmétodo

Entender los controladores

Los controladores se cargan en función del routey son bastante sencillos de entender. Los controladores se encuentran en la /catalog/controller/carpeta. Continuando con el último ejemplo, el Controlador de la página de búsqueda se encuentra /product/search.phpdentro de esta carpeta. Observe de nuevo que .phpse utiliza la ruta seguida por .

Al abrir el archivo del controlador, verá un nombre de clase Pascal Case que extiende la Controllerclase, llamado ControllerProductSearch. De nuevo, esto es específico de la ruta, Controllerseguido del nombre de la subcarpeta y el nombre del archivo sin la extensión en mayúscula. Las mayúsculas no son realmente necesarias, pero se recomiendan para facilitar la lectura. Vale la pena señalar que los nombres de clase no toman ningún valor de la subcarpeta y el nombre del archivo que no sean letras y números. Se eliminan los guiones bajos.

Dentro de la clase están los métodos. Los métodos de la clase declarada publicson accesibles para ejecutarse a través de la ruta; privateno lo son. De forma predeterminada, con una ruta estándar de dos partes ( aaa/bbbarriba), index()se llama a un método predeterminado . Si cccse usa la tercera parte de una ruta ( arriba), este método se ejecutará en su lugar. Por ejemplo, account/return/insertcargará el /catalog/controller/account/return.phparchivo y la clase e intentará llamar al insertmétodo

Comprensión de modelos

Los modelos en OpenCart se encuentran en la /catalog/model/carpeta y se agrupan según la función, no la ruta, y por lo tanto deberá cargarlos en su controlador a través de

$this->load->model('xxx/yyy');

Esto cargará el archivo en la subcarpeta xxxllamada yyy.php. Entonces está disponible para su uso a través del objeto

$this->model_xxx_yyy

y al igual que con los controladores, solo puede llamar a sus publicmétodos. Por ejemplo, para cambiar el tamaño de una imagen, usaría el tool/imagemodelo y llamaría a su resizemétodo de la siguiente manera

$this->load->model('tool/image');
$this->model_tool_image->resize('image.png', 300, 200);

Comprender la asignación de variables en vistas desde el controlador

Para pasar valores a la vista desde el controlador, simplemente necesita asignar sus datos a la $this->datavariable, que es esencialmente una matriz de pares clave => valor. Como ejemplo

$this->data['example_var'] = 123;

Acceder a esto en una vista es un poco, debería ser fácil de entender si está familiarizado con el método extract () que convierte cada clave en una variable. Entonces la example_varclave se convierte $example_vary se puede acceder a ella como tal en la vista.

Entendiendo temas

Los temas están disponibles solo en el lado del catálogo y son básicamente una carpeta de plantillas, hojas de estilo e imágenes de temas. Las carpetas de temas se colocan en la /catalog/view/theme/carpeta seguida del nombre del tema. El nombre de la carpeta no es importante con excepción de la defaultcarpeta

El lado del administrador usa /admin/view/template/(omitiendo el /theme/theme-name/de la ruta ya que no permite diferentes temas)

Los archivos de plantilla residen en una templatecarpeta dentro de la carpeta del tema. Si alguna plantilla no está disponible para el tema seleccionado actualmente, la plantilla de la carpeta predeterminada se utiliza en su lugar como alternativa. Esto significa que los temas se pueden crear con muy pocos archivos y seguir funcionando plenamente. También reduce la duplicación de código y los problemas a medida que se realizan actualizaciones.

Comprensión de las vistas (plantillas)

Al igual que con el idioma y los modelos, los archivos de vista generalmente están relacionados con la ruta, aunque no tienen que estarlo en absoluto. Las plantillas en el lado del catálogo generalmente se encuentran a /catalog/view/theme/your-theme/template/menos que no exista, en cuyo caso se usarán las plantillas del tema predeterminado. Para nuestro ejemplo de página de búsqueda anterior, el archivo es product/search.tpl. Para rutas con tres partes, generalmente está adentro, aaa/bbb_ccc.tplaunque no hay una regla establecida. En el administrador, la mayoría de las páginas siguen esto, con la excepción de que las páginas que enumeran elementos, como la página de listado de productos, están en catalog/product_list.tply el formulario de edición de productos está en catalog/product_form.tpl. Nuevamente, estos no están establecidos, sino un estándar para el carrito predeterminado.

El archivo de plantilla es de hecho solo otro archivo php, pero con una extensión .tpl y en realidad se ejecuta en el archivo del controlador, por lo tanto, todas las cosas que puede codificar en un controlador se pueden ejecutar en un archivo de plantilla (aunque no se recomienda a menos que sea absolutamente necesario necesario)

Comprender el objeto de la base de datos

Las consultas se ejecutan usando

$result = $this->db->query("SELECT * FROM `" . DB_PREFIX . "table`");

DB_PREFIX como sugiere el nombre es una constante que contiene el prefijo de la base de datos si existe

$resultdevolverá un objeto para SELECTconsultas, que contiene algunas propiedades

$result->row contiene los datos de la primera fila si uno o más se devuelven como una matriz asociativa

$result->rows contiene una matriz de resultados de fila, ideal para recorrer con foreach

$result->num_rows contiene el número de resultados devueltos

También hay algunos métodos adicionales que $this->dbtiene el objeto

$this->db->escape()usa mysql_real_escape_string () en el valor pasado

$this->db->countAffecteddevuelve el número de filas afectadas por una UPDATEconsulta y así sucesivamente

$this->db->getLastId()devuelve la última identificación de incremento automático usando mysql_insert_id ()

Comprender las variables reservadas

OpenCart ha predefinido de variables para usar en lugar de la norma $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES, $_REQUESTY$_SERVER

$_SESSIONse edita utilizando $this->session->datadonde los datos son una matriz asociativa que imita el$_SESSION

Se puede acceder a todos los demás usando $this->requesty se han "limpiado" para cumplir con las comillas mágicas habilitadas / deshabilitadas, por lo que

$_GET se convierte en $this->request->get

$_POST se convierte en $this->request->post

$_COOKIE se convierte en $this->request->cookie

$_FILES se convierte en $this->request->files

$_REQUEST se convierte en $this->request->request

$_SERVER se convierte en $this->request->server

Resumen

Si bien lo anterior no es una guía a prueba de balas para los desarrolladores, es de esperar que sirva como un buen punto de partida para los que comienzan.

Métodos de biblioteca global: funciones básicas de biblioteca opencart junto con sus funcionalidades, la mayoría de estas se pueden llamar desde cualquier lugar del catálogo o carpetas de administración (controladores, modelos, vistas)

CACHE
$this->cache->delete($key) - Deletes cache [product, category, country, zone, language, currency,
manufacturer]

CART
$this->cart->getProducts() Gets all products currently in the cart including options, discounted prices, etc.
$this->cart->add( $product_id, $qty = 1, $options = array()) - Allows you to add a product to the cart
$this->cart->remove( $key ) - Allows you to remove a product from the cart
$this->cart->clear() - Allows you to remove all products from the cart
$this->cart->getWeight() - Sum of the weight of all products in the cart that have require shipping set to Yes
$this->cart->getSubTotal() - returns the subtotal of all products added together before tax
$this->cart->getTotal() - returns the total of all products added together after tax
$this->cart->countProducts() - returns the count of all product in the cart
$this->cart->hasProducts() - returns true if there is at least one item in the cart
$this->cart->hasStock() - returns false if there is at least one item in the cart that is out of stock
$this->cart->hasShipping() - returns true if there is at least one item in the cart that requires shipping
$this->cart->hasDownload() - returns true if there is at least one item in the cart that has a download
associated

CONFIG
$this->config->get($key) - returns setting value by keyname based on application (catalog or admin)
$this->config->set($key, $value) - set the value to override the setting value. DOES NOT SAVE TO DATABASE

CURRENCY
$this->currency->set($currency) - set or override the currency code to be used in the session
$this->currency->format($number, $currency = '', $value = '', $format = TRUE) - format the currency
$this->currency->convert($value, $from, $to) - convert a value from one currency to another. Currencies must
exist
$this->currency->getId() - get the database entry id for the current currency (1, 2, 3, 4)
$this->currency->getCode() - get the 3-letter iso code for the current currency (USD, EUR, GBP, AUD, etc)
$this->currency->getValue($currency) - get the current exchange rate from the database for the specified
currency.
$this->currency->has(currency) - Check if a currency exists in the opencart currency list

CUSTOMER
$this->customer->login($email, $password) - Log a customer in
$this->customer->logout() - Log a customer out
$this->customer->isLogged() - check if customer is logged in
$this->customer->getId() - get the database entry id for the current customer (integer)
$this->customer->getFirstName() - get customer first name
$this->customer->getLastName() - get customer last name
$this->customer->getEmail() - get customer email
$this->customer->getTelephone() - get customer telephone number
$this->customer->getFax() - get customer fax number
$this->customer->getNewsletter() - get customer newsletter status
$this->customer->getCustomerGroupId() - get customer group id
$this->customer->getAddressId() - get customer default address id (maps to the address database field)

DATABASE
$this->db->query($sql) - Execute the specified sql statement. Returns row data and rowcount.
$this->db->escape($value) - Escape/clean data before entering it into database
$this->db->countAffected($sql) - Returns count of affected rows from most recent query execution
$this->db->getLastId($sql) - Returns last auto-increment id from more recent query execution 4

DOCUMENT (*Called from controller only before renderer)
$this->document->setTitle($title) - Set page title
$this->document->getTitle()- Get page title
$this->document->setDescription($description) - Set meta description
$this->document->getDescription()- Get meta description
$this->document->setKeywords()- Set meta keywords
$this->document->getKeywords()- Get meta keywords
$this->document->setBase($base) - Set page base
$this->document->getBase() - Get page base
$this->document->setCharset($charset) - Set page charset
$this->document->getCharset() - Get page charset
$this->document->setLanguage($language) - Set page language
$this->document->getLanguage()- Get page language
$this->document->setDirection($direction) - Set page direction (rtl/ltr)
$this->document->getDirection()- Get page direction (rtl/ltr)
$this->document->addLink( $href, $rel ) – Add dynamic <link> tag
$this->document->getLinks()- Get page link tags
$this->document->addStyle( $href, $rel = 'stylesheet', $media = 'screen' ) – Add dynamic style
$this->document->getStyles()- Get page styles
$this->document->addScript( $script ) - Add dynamic script
$this->document->getScripts()- Get page scripts
$this->document->addBreadcrumb($text, $href, $separator = ' &gt; ') – Add breadcrumb
$this->document->getBreadcrumbs()- Get Breadcrumbs

ENCRYPT
$this->encryption->encrypt($value) - Encrypt data based on key in admin settings
$this->encryption->decrypt($value) - Decrypt data based on key in admin settings

IMAGE
$this->image->resize($width = 0, $height = 0)

JSON
$this->json->encode( $data )
$this->json->decode( $data , $assoc = FALSE)

LANGUAGE
$this->language->load($filename);

LENGTH
$this->length->convert($value, $from, $to) - convert a length to another. units must exist
$this->length->format($value, $unit, $decimal_point = '.', $thousand_point = ',') - format the length to use
unit

LOG
$this->log->write($message) - Writes to the system error log

REQUEST
$this->request->clean($data) - Cleans the data coming in to prevent XSS
$this->request->get['x'] - Same as $_GET['x']
$this->request->post['x'] - Same as $_POST['x']

RESPONSE
$this->response->addHeader($header) - additional php header tags can be defined here
$this->response->redirect($url) - redirects to the url specified

TAX
$this->tax->setZone($country_id, $zone_id) - Set the country and zone id for taxing (integer)
$this->tax->calculate($value, $tax_class_id, $calculate = TRUE) - Calculate all taxes to be added to the total
$this->tax->getRate($tax_class_id) - Get the rates of a tax class id
$this->tax->getDescription($tax_class_id) - Get the description of a tax class id
$this->tax->has($tax_class_id) - Check if a tax class id exists in opencart

SESSION
$this->session->data['x'] - Same as $_SESSION['x']  

Hay un sitio web OpenCart Wiki con documentación para desarrolladores principiantes. Siga las direcciones URL que se proporcionan a continuación para obtener más detalles:

http://wiki.opencarthelp.com/doku.php?id=start
http://wiki.opencarthelp.com/doku.php?id=methods_reference

Vínculos ARCHIVO DE INTERNET

http://web.archive.org/web/20160305131349/http://wiki.opencarthelp.com/doku.php?id=start http://web.archive.org/web/20160305131349/http://wiki .opencarthelp.com / doku.php? id = referencia_métodos

Por ejemplo, la referencia del método tiene detalles para:

1. Inicio de sesión del cliente
2. Acceso DB
3. Manejo del carrito de compras
4. Config
5. Cache
6. Manejo de moneda

Aún así, hay algunas páginas en construcción, pero será útil.

[Actualizar]

A partir de enero de 2018, el dominio opencarhelp.com está inactivo.

Aunque este tema ya ha sido respondido muchas veces, me gustaría ofrecer otro enfoque para dominar OpenCart basado en mi experiencia.

Aprender haciendo

Al crear su propio marco OpenCart desde cero con un puñado de archivos, puede comprender cómo se organiza todo. Estaré imitando la estructura de archivos de OpenCart por ti.

Crea un archivo index.php

<?php
// My simpleCart

1. Registro

Opencart usa el patrón de Registro para enumerar todas las instancias de clases cargadas. Es el corazón de su aplicación OpenCart. Luego, el objeto de registro se pasa a todas las categorías, modelos y bibliotecas para acceder rápidamente a otros objetos.

crear un archivo con ruta /system/engine/registry.php

<?php
// Registry class. 
class Registry
{
    private $data = array();

    public function set($key, $value){
        $this->data[$key] = $value;
    }

    public function get($key){
        return (isset($this->data[$key])) ? $this->data[$key] : false;
    }
}

en tus index.php

<?php
// My simpleCart

//load dependency files
require_once('system/engine/registry.php');

//initialize registry
$registry = new Registry;

2. Salida

Ahora agreguemos una salida que será nuestro HTML en el futuro. Después de todo, la idea es enviar una cadena de texto al navegador.

Crea un archivo system/library/response.php

<?php
class Response {
    private $output;

    public function getOutput() {
        return $this->output;
    }

    public function setOutput($output) {
        $this->output = $output;
    }

    public function output() {
        if ($this->output) {
            echo $this->output;
        }
    }
}

y en tu index.php

<?php
// My simpleCart

//load dependency files
require_once('system/engine/registry.php');
require_once('system/library/response.php');

//initialize registry
$registry = new Registry;

//initialize response
$response = new Response;
//add response object to the registry
$registry->set('response', $response);

//lets set an output as a test
$registry->get('response')->setOutput('Hello World');

//send the output to the client
$registry->get('response')->output();

Observe que agregué Hola mundo solo como ejemplo. Lo eliminaremos más adelante. Actualice su sitio para comprobarlo. Debería mostrarse el navegador Hello World.

3. Controladores

Piense en los controladores como páginas. Definirán lo que se mostrará al cliente: texto, html, json, descarga o incluso una imagen. Por ahora, solo queremos una página que envíe texto.

Crearemos un controlador para la homepágina.

agregar un archivo con ruta catalog/controller/common/home.php

<?php

class ControllerCommonHome{

    private $registry = array();

    public function __construct($registry){
        $this->registry = $registry;
    }

    public function index(){

        $output = 'Home Page';
        //using the registry to get the response object and set the Output
        $this->registry->get('response')->setOutput($output);
    }
}

y edita tu index.php

<?php
// My simpleCart

//load registry
require_once('system/engine/registry.php');
//load response
require_once('system/library/response.php');

//initialize registry
$registry = new Registry;

//initialize response
$response = new Response;
//add resoinse object to the registry
$registry->set('response', $response);

//load controller common/home
require_once('catalog/controller/common/home.php');
$controller = new ControllerCommonHome($registry);
$controller->index();

//send the output to the client
$registry->get('response')->output();

observe cómo pasé el $refistryal ControllerCommonHome para poder acceder a él dentro del controlador.

4. Enrutador

No queremos que los controladores estén codificados, ¿no? Usaremos un parámetro routede la dirección URL para decirle a nuestro carrito qué controlador cargar.

Crea un archivo con ruta system/library/request.php

<?php
class Request {
    public $get = array();

    //for now I just need the $_GET parameter
    public function __construct() {
        $this->get = $_GET;
    }
}

Cree la clase Router que será responsable de inicializar el archivo del controlador en función de la ruta (en otras palabras: llamar dinámicamente al controlador)

<?php
class Router {
    private $registry;

    public function __construct($registry) {
        $this->registry = $registry;
    }

    public function dispatch($route) {
        require_once('catalog/controller/'.$route.'.php');
        $class = "Controller".str_replace('/', '', $route);
        $controller = new $class($this->registry);
        $controller->index();
    }
}

cárgalo en tu index.php

<?php
require_once('system/engine/registry.php');
require_once('system/engine/router.php');
require_once('system/library/response.php');
require_once('system/library/request.php');

$registry = new Registry;

$response = new Response;
$registry->set('response', $response);

$request = new Request;
$registry->set('request', $request);

//get the route from the url
if(isset($registry->get('request')->get['route'])){
    $route = $registry->get('request')->get['route'];
}else{
    $route = 'common/home';
}

//initiate the router and dispatch it base on the route
$router = new Router($registry);
$router->dispatch($route);


$registry->get('response')->output();

Observe cómo cargo todo en el $registryy luego se lo paso al $routerque luego se lo paso al $controller.

Esta publicación ya es demasiado larga, pero espero que brinde una comprensión básica del patrón MVC en OpenCart.

Si quieres que continúe con esta publicación y te cuente cómo funcionan otras cosas como modelos y vistas, califica esta respuesta para que yo sepa.

También echa un vistazo a mi https://www.youtube.com/dreamvention de Youtube y a mi blog https://dreamvention.com/blog. ¡Publicaré más consejos y tutoriales para ustedes!

PHP es un lenguaje bastante grande con más de 5000 funciones integradas, por lo que una estrategia para aprender una nueva plataforma es identificar qué funciones usa con más frecuencia y dedicar un tiempo a conocerlas muy bien.

Ejecuté algunas consultas en el código fuente de OpenCart y las 10 funciones más utilizadas son:

array()
count()
explode()
implode()
mktime()
delete()
time()
date()
sprintf()
list()

Los 52 enumerados aquí, así como los comandos bash de Linux que puede usar en cualquier base de código para identificar las funciones de uso común: https://www.antropy.co.uk/blog/efficient-learning-for-new-opencart-developers/

Esta lista de reproducción de videos de youtube también puede ser útil para convertirse en gurús de desarrolladores de OpenCart:

Tutoriales de vídeos de OpenCart

1. Introducción y tabla de contenido Este video describe la introducción de la serie
2. Instalación de OpenCart localhost Este video pasa por la instalación de OpenCart en localhost
3. Estructura de archivos y carpetas de OpenCart Describe la estructura de archivos y carpetas de OpenCart
4. Crear esquema de tabla de base de datos en OpenCart Muestra el esquema de tabla de base de datos y muestra cómo crear tablas de base de datos en OpenCart
5. Métodos de objetos predefinidos de la biblioteca OpenCart Describe los métodos de los objetos predefinidos de la biblioteca OpenCart y muestra dónde encontrarlos.

6. Patrón MVCL, flujo de código y solicitud y respuesta en OpenCart Muestra el patrón MVCL, flujo de código y solicitud y respuesta en OpenCart. Describen el flujo como en la siguiente imagen:

7. Instalar, configurar y desinstalar el módulo OpenCart Muestra tres formas de cargar módulos, luego instalar, configurar y desinstalar el módulo / extensión OpenCart 3.

8. Diseños y posición en OpenCart 3 Describe los diseños y posiciones de OpenCart 3. Muestra cómo mostrar diseños personalizados para diferentes páginas, dando ejemplos de páginas de categorías. Mostramos el diseño diferente para una categoría diferente.

9. Descripción general de eventos de OpenCart Aprenderá qué son los eventos en OpenCart, cómo funcionan y qué los hace tan útiles.

10. Documentación de la API de Opencart para desarrolladores Este video mostrará cómo usar y hacer una API de Opencart personalizada

Una vez que vea estos videos, puede comenzar a codificar :)