Sembra che non abbiano documentazione tranne alcune chiamate api sui loro forum ufficiali. Ho esperienza con il framework Zend e il framework CodeIgniter. Qualche master OpenCart può consigliarmi il modo migliore per impararlo e padroneggiarlo nel minor tempo possibile? Ci devo fare presto un grande progetto.

Guida rapida per sviluppatori OpenCart 1.5.X per principianti

Questa guida è scritta per sviluppatori che hanno già familiarità con PHP, OOP e l'architettura MVC

Di seguito, vedrai esempi per il lato catalogo del carrello. Il lato amministratore è identico in funzione ad eccezione delle visualizzazioni che sono indicate nella sezione pertinente

Capire le biblioteche

Tutte le funzionalità della libreria sono accessibili tramite Controller, Model e Views usando $this->library_name. Tutti questi possono essere trovati nella /system/library/cartella. Ad esempio, per accedere ai prodotti del carrello della spesa corrente, è necessario utilizzare la Cartclasse, che si trova in /system/library/cart.phped è possibile accedervi utilizzando$this->cart->getProducts()

Articoli di uso comune

• customer.php - Funzioni relative al cliente
• user.php - Funzioni relative all'utente amministratore
• cart.php - Funzioni relative al carrello
• config.php - Tutte le impostazioni vengono caricate da questo
• url.php - Funzioni di generazione di URL

Comprensione del parametro del percorso

Il framework di OpenCart si basa sul route=aaa/bbb/cccparametro della stringa di query per sapere cosa caricare ed è la caratteristica fondamentale per trovare i file da modificare per ogni pagina. La maggior parte delle rotte utilizza in realtà solo il aaa/bbbche dovrebbe essere visto come due parti, tuttavia alcune contengono tre parti aaa/bbb/cccLa prima parte aaageneralmente si riferisce alla cartella all'interno di una cartella generica come il controller o le cartelle dei modelli. La seconda parte di solito si riferisce al nome del file, senza il relativo .phpo l' .tplestensione. La terza parte è spiegata nella sezione "Informazioni sui controller" di seguito

Capire le lingue

Le lingue sono memorizzate nella /catalog/language/cartella nella your-languagesottocartella. All'interno di questo, i valori di testo generali utilizzati nelle varie pagine sono memorizzati nel your-language.phpfile all'interno della cartella, quindi per la lingua inglese sul lato del catalogo, troverai i valori in catalog/language/english/english.php. Per il testo di una pagina specifica, avrai bisogno del routeper la pagina (questo è generalmente il caso, ma non sempre poiché puoi specificare qualsiasi file di lingua che ti piace). Ad esempio, la pagina di ricerca ha il percorso product/searche quindi il testo specifico della lingua per quella pagina può essere trovato in catalog/language/english/product/search.php(Notare che il nome del file e la sottocartella corrispondono al percorso seguito da .php.

Per caricare la lingua in un controller, usi

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

Quindi è possibile utilizzare la funzione della libreria della lingua getper recuperare testi in lingue specifiche, come

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

Le variabili della lingua vengono assegnate nel file della lingua utilizzando una variabile speciale $_che è un array di chiavi e valori di testo. Nel tuo /catalog/language/english/product/search.phpdovresti trovare qualcosa di simile a

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

I valori nel file della lingua globale english/english.phpvengono caricati automaticamente e possono essere utilizzati senza il $this->language->loadmetodo

Capire i controller

I controller vengono caricati in base a routee sono abbastanza semplici da capire. I controller si trovano nella /catalog/controller/cartella. Continuando dall'ultimo esempio, /product/search.phpall'interno di questa cartella si trova il controller per la pagina di ricerca . Notare di nuovo che .phpviene utilizzato il percorso seguito da .

Aprendo il file del controller, vedrai un nome di Controllerclasse Pascal Case che estende la classe, chiamato ControllerProductSearch. Anche questo è specifico del percorso, Controllerseguito dal nome della sottocartella e dal nome del file senza l'estensione in maiuscolo. Le maiuscole non sono effettivamente richieste, ma sono consigliate per una facile leggibilità. Vale la pena notare che i nomi delle classi non prendono alcun valore dalla sottocartella e dal nome del file oltre a lettere e numeri. I trattini bassi vengono rimossi.

All'interno della classe ci sono i metodi. I metodi nella classe dichiarata publicsono accessibili per essere eseguiti tramite il percorso - privatenon lo sono. Per impostazione predefinita, con un percorso standard in due parti ( aaa/bbbsopra), index()viene chiamato un metodo predefinito . Se viene utilizzata la terza parte di un percorso ( cccsopra), verrà eseguito questo metodo. Ad esempio, account/return/insertcaricherà il /catalog/controller/account/return.phpfile e la classe e proverà a chiamare il insertmetodo

Comprensione dei modelli

I modelli in OpenCart si trovano nella /catalog/model/cartella e sono raggruppati in base alla funzione, non al percorso, quindi sarà necessario caricarli nel controller tramite

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

Questo caricherà il file nella sottocartella xxxchiamata yyy.php. È quindi disponibile per l'uso tramite l'oggetto

$this->model_xxx_yyy

e come con i controller, puoi solo chiamare i suoi publicmetodi. Ad esempio, per ridimensionare un'immagine, dovresti usare il tool/imagemodello e chiamare il suo resizemetodo come segue

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

Comprensione dell'assegnazione delle variabili nelle viste dal controller

Per passare i valori alla vista dal controller, è sufficiente assegnare i dati alla $this->datavariabile, che è essenzialmente un array di coppie chiave => valore. Come esempio

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

Accedere a questo in una vista è un po 'dovrebbe essere facile da capire se hai familiarità con il metodo extract () che converte ogni chiave in una variabile. Quindi la example_varchiave diventa $example_vared è possibile accedervi come tale nella vista.

Comprensione dei temi

I temi sono disponibili solo sul lato catalogo e sono fondamentalmente una cartella di modelli, fogli di stile e immagini di temi. Le cartelle dei temi vengono posizionate nella /catalog/view/theme/cartella seguite dal nome del tema. Il nome della cartella non è importante ad eccezione della defaultcartella

Il lato amministratore utilizza /admin/view/template/(saltando /theme/theme-name/dal percorso in quanto non consente temi diversi)

I file modello risiedono in una templatecartella all'interno della cartella del tema. Se un modello non è disponibile per il tema attualmente selezionato, il modello della cartella predefinita viene utilizzato come riserva. Ciò significa che i temi possono essere creati con pochissimi file e continuano a funzionare completamente. Riduce anche la duplicazione del codice e i problemi quando vengono effettuati gli aggiornamenti

Comprensione delle visualizzazioni (modelli)

Come con la lingua e i modelli, i file di visualizzazione sono generalmente correlati al percorso, anche se non devono esserlo affatto. I modelli sul lato del catalogo si trovano solitamente a /catalog/view/theme/your-theme/template/meno che non esistano, nel qual caso verranno utilizzati i modelli del tema predefinito. Per il nostro esempio di pagina di ricerca sopra, il file è product/search.tpl. Per i percorsi con tre parti, generalmente è in aaa/bbb_ccc.tplsebbene non ci siano regole fisse. Nell'amministratore, la maggior parte delle pagine segue questo, con l'eccezione che le pagine che elencano gli elementi, come la pagina dell'elenco dei prodotti, sono presenti catalog/product_list.tple il modulo di modifica del prodotto è attivo catalog/product_form.tpl. Ancora una volta, questi non sono impostati, ma uno standard per il carrello predefinito.

Il file modello è in realtà solo un altro file php, ma con estensione .tpl ed è effettivamente eseguito nel file del controller, quindi tutte le cose che puoi codificare in un controller possono essere eseguite in un file modello (sebbene non sia consigliato a meno che non sia assolutamente necessario)

Comprensione dell'oggetto database

Le query vengono eseguite utilizzando

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

DB_PREFIX come suggerisce il nome, è una costante contenente il prefisso del database, se esistente

$resultrestituirà un oggetto per le SELECTquery, contenente alcune proprietà

$result->row contiene i dati della prima riga se uno o più vengono restituiti come array associativo

$result->rows contiene un array di risultati di riga, ideale per il looping utilizzando foreach

$result->num_rows contiene il numero di risultati restituiti

Ci sono anche alcuni metodi extra di cui $this->dbdispone l' oggetto

$this->db->escape()usa mysql_real_escape_string () sul valore passato

$this->db->countAffectedrestituisce il numero di righe interessate da una UPDATEquery e così via

$this->db->getLastId()restituisce l'ultimo ID di incremento automatico utilizzando mysql_insert_id ()

Comprensione delle variabili riservate

OpenCart ha predefinito le variabili da utilizzare al posto dello standard $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES, $_REQUESTE$_SERVER

$_SESSIONviene modificato utilizzando $this->session->datadove i dati sono un array associativo che imita il file$_SESSION

Tutti gli altri sono accessibili usando $this->requeste sono stati "puliti" per conformarsi alle virgolette magiche abilitate / disabilitate, quindi

$_GET diventa $this->request->get

$_POST diventa $this->request->post

$_COOKIE diventa $this->request->cookie

$_FILES diventa $this->request->files

$_REQUEST diventa $this->request->request

$_SERVER diventa $this->request->server

Sommario

Sebbene quanto sopra non sia una guida a prova di proiettile per gli sviluppatori, si spera che serva come un buon punto di partenza per coloro che iniziano

Metodi di libreria globale: funzioni di libreria opencart di base insieme alle loro funzionalità, la maggior parte di questi può essere chiamata da qualsiasi punto del catalogo o delle cartelle di amministrazione (controller, modelli, viste)

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']  

Esiste un sito Web OpenCart Wiki con documentazione per sviluppatori principianti. Segui gli URL forniti di seguito per maggiori dettagli:

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

Link ARCHIVIO 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 = methods_reference

Ad esempio, il riferimento al metodo contiene dettagli per:

1. accesso cliente
2. Accesso DB
3. Gestione del carrello
4. Config
5. Cache
6. Gestione della valuta

Ci sono ancora alcune pagine in costruzione, ma sarà utile.

[Aggiornare]

A partire da gennaio 2018, il dominio opencarhelp.com è inattivo.

Sebbene questo argomento abbia già ricevuto risposta molte volte, vorrei offrire un altro approccio alla padronanza di OpenCart in base alla mia esperienza.

Imparare facendo

Creando il tuo framework OpenCart da zero con una manciata di file puoi capire come tutto è messo insieme. Imiterò la struttura dei file di OpenCart per te.

Crea un file index.php

<?php
// My simpleCart

1. Registro

Opencart utilizza il pattern Registry per elencare tutte le istanze delle classi caricate. È il cuore della tua app OpenCart. L'oggetto del registro viene quindi passato a ogni categoria, modello e libreria per un rapido accesso ad altri oggetti.

crea un file con percorso /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;
    }
}

nel tuo index.php

<?php
// My simpleCart

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

//initialize registry
$registry = new Registry;

2. Uscita

Ora aggiungiamo un output che sarà il nostro HTML in futuro. Dopotutto, l'idea è di inviare una stringa di testo al browser.

Crea file 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;
        }
    }
}

e nel tuo 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();

Notare che ho aggiunto Hello world solo come esempio. Lo rimuoveremo più avanti. Aggiorna il tuo sito per controllarlo. Il browser dovrebbe essere visualizzato Hello World.

3. Controller

Pensa ai controller come a delle pagine. Definiranno cosa verrà mostrato al client: testo, html, json, download o anche un'immagine. Per ora, vogliamo solo una pagina che invia testo.

Creeremo un controller per la homepagina.

aggiungi un file con percorso 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);
    }
}

e modifica il tuo 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();

nota come ho passato il $refistrya ControllerCommonHome in modo che potessi accedervi all'interno del controller.

4. Router

Non vogliamo che i controller siano hardcoded, giusto. Useremo un parametro routedall'indirizzo URL per dire al nostro carrello quale controller caricare.

Crea un file con percorso system/library/request.php

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

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

Creare la classe Router che sarà responsabile dell'inizializzazione del file Controller in base al percorso (in altre parole: chiamare dinamicamente il controller)

<?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();
    }
}

caricalo nel tuo 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();

Notate come carico tutto in $registrye poi lo passo a $routerche poi lo passa a $controller.

Questo post è già troppo lungo, ma spero che possa fornire una comprensione di base del pattern MVC in OpenCart.

Se vuoi che continui con questo post e ti dica come funzionano altre cose come modelli e visualizzazioni, valuta questa risposta in modo che io lo sappia.

Dai un'occhiata anche al mio Youtube https://www.youtube.com/dreamvention e al mio blog https://dreamvention.com/blog, vi posterò altri suggerimenti e tutorial!

PHP è un linguaggio abbastanza grande con oltre 5000 funzioni integrate, quindi una strategia per imparare una nuova piattaforma è identificare quali funzioni utilizza più frequentemente e dedicare del tempo a conoscerle molto bene.

Ho eseguito alcune query sul codice sorgente di OpenCart e le prime 10 funzioni più comunemente utilizzate sono:

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

Tutti i 52 elencati qui così come i comandi bash di Linux che puoi utilizzare su qualsiasi codebase per identificare le funzioni di uso comune: https://www.antropy.co.uk/blog/efficient-learning-for-new-opencart-developers/

Questa playlist di video di YouTube può anche essere utile per diventare Guru degli sviluppatori OpenCart:

Tutorial video OpenCart

1. Introduzione e sommario Questo video illustra l'introduzione della serie
2. Installazione di OpenCart localhost Questo video passa attraverso l'installazione di OpenCart in localhost
3. File e struttura delle cartelle di Opencart Descrive la struttura dei file e delle cartelle di OpenCart
4. Creazione dello schema della tabella del database in OpenCart Mostra lo schema della tabella del database e mostra come creare tabelle del database in OpenCart
5. Metodi predefiniti degli oggetti della libreria OpenCart Descrive i metodi degli oggetti predefiniti della libreria OpenCart e mostra dove trovarli.

6. Pattern MVCL, flusso di codice e richiesta e risposta in OpenCart Mostra pattern MVCL, flusso di codice e richiesta e risposta in OpenCart. Descrivono il flusso come nella foto qui sotto:

7. Installa, configura e disinstalla il modulo Opencart Mostra tre modi per caricare i moduli, quindi installare, configurare e disinstallare il modulo / estensione OpenCart 3.

8. Layout e posizione in Opencart 3 Descrive i layout e le posizioni di OpenCart 3. Mostra come mostrare layout personalizzati per pagine diverse, fornendo esempi di pagine di categorie. Mostriamo il layout diverso per una categoria diversa.

9. Panoramica degli eventi di Opencart Imparerai cosa sono gli eventi in OpenCart, come funzionano e cosa li rende così utili.

10. Documentazione API Opencart per sviluppatori Questo video mostra come utilizzare e creare un'API Opencart personalizzata

Una volta visualizzati questi video, puoi iniziare a programmare :)