Il semble qu'ils n'ont pas de documentation à l'exception de quelques appels d'API sur leurs forums officiels. J'ai de l'expérience avec le framework Zend et le framework CodeIgniter. Les maîtres OpenCart peuvent-ils me recommander la meilleure façon de l'apprendre et de le maîtriser dans les plus brefs délais? Je dois bientôt faire un gros projet avec.

Guide de démarrage rapide du développeur OpenCart 1.5.X pour les débutants

Ce guide est écrit pour les développeurs déjà familiarisés avec PHP, OOP et l'architecture MVC

Dans ce qui suit, vous verrez des exemples pour le côté catalogue du panier. Le côté admin est identique en fonction à l'exception des vues qui sont notées dans la section correspondante

Comprendre les bibliothèques

Toutes les fonctionnalités de la bibliothèque sont accessibles via le contrôleur, le modèle et les vues en utilisant $this->library_name. Tous ces éléments peuvent être trouvés dans le /system/library/dossier. Par exemple, pour accéder aux produits du panier actuel, vous devrez utiliser la Cartclasse, qui se trouve dans /system/library/cart.phpet est accessible en utilisant$this->cart->getProducts()

Articles couramment utilisés

• customer.php - Fonctions liées au client
• user.php - Fonctions liées à l'utilisateur administrateur
• cart.php - Fonctions liées au panier
• config.php - Tous les paramètres sont chargés à partir de ce
• url.php - Fonctions de génération d'URL

Comprendre le paramètre d'itinéraire

Le cadre d'OpenCart repose sur le route=aaa/bbb/cccparamètre de chaîne de requête pour savoir ce qu'il faut charger, et constitue la fonctionnalité de base pour trouver les fichiers que vous devez modifier pour chaque page. La plupart des routes n'utilisent en fait que le aaa/bbbqui doit être considéré comme deux parties, mais certaines contiennent trois parties aaa/bbb/cccLa première partie aaagénéralement liée au dossier dans un dossier générique tel que les dossiers de contrôleur ou de modèle. La deuxième partie concerne généralement le nom du fichier, sans l' extension .phpou l' .tplextension correspondante. La troisième partie est expliquée dans la section "Comprendre les contrôleurs" ci-dessous

Comprendre les langues

Les langues sont stockées dans le /catalog/language/dossier du your-languagesous - dossier. Dans ce cadre, les valeurs de texte générales utilisées sur différentes pages sont stockées dans le your-language.phpfichier à l'intérieur du dossier, de sorte que pour la langue anglaise du côté catalogue, vous trouverez les valeurs dans catalog/language/english/english.php. Pour un texte de page spécifique, vous aurez besoin du routepour la page (c'est généralement le cas, mais pas toujours car vous pouvez spécifier n'importe quel fichier de langue que vous aimez). Par exemple, la page de recherche a l'itinéraire product/search, et par conséquent, le texte spécifique à la langue de cette page peut être trouvé dans catalog/language/english/product/search.php(Notez que le nom du fichier et le sous-dossier correspondent à l'itinéraire suivi par .php.

Pour charger la langue dans un contrôleur, vous utilisez

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

Ensuite, vous pouvez utiliser la fonction de bibliothèque de langues getpour récupérer des textes de langue spécifiques, tels que

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

Les variables de langue sont affectées dans le fichier de langue à l'aide d'une variable spéciale $_qui est un tableau de clés et de valeurs de texte. Dans votre, /catalog/language/english/product/search.phpvous devriez trouver quelque chose de similaire à

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

Les valeurs du fichier de langue global english/english.phpsont automatiquement chargées et disponibles pour une utilisation sans la $this->language->loadméthode

Comprendre les contrôleurs

Les contrôleurs sont chargés en fonction de routeet sont assez simples à comprendre. Les contrôleurs se trouvent dans le /catalog/controller/dossier. Dans la continuité du dernier exemple, le contrôleur de la page de recherche se trouve /product/search.phpdans ce dossier. Notez à nouveau que l'itinéraire suivi par .phpest utilisé.

En ouvrant le fichier du contrôleur, vous verrez un nom de classe Pascal Case étendant la Controllerclasse, appelé ControllerProductSearch. Ceci est encore une fois spécifique à l'itinéraire, Controllersuivi du nom du sous-dossier et du nom du fichier sans l'extension en majuscule. La capitalisation n'est pas réellement requise, mais elle est recommandée pour une lisibilité facile. Il convient de noter que les noms de classe ne prennent aucune valeur du sous-dossier et du nom de fichier autre que des lettres et des chiffres. Les traits de soulignement sont supprimés.

Au sein de la classe se trouvent les méthodes. Les méthodes de la classe déclarée publicsont accessibles pour être exécutées via la route - privatene le sont pas. Par défaut, avec une route standard en deux parties ( aaa/bbbci-dessus), une index()méthode par défaut est appelée. Si la troisième partie d'une route ( cccci-dessus) est utilisée, cette méthode sera exécutée à la place. Par exemple, account/return/insertchargera le /catalog/controller/account/return.phpfichier et la classe, et essaiera d'appeler la insertméthode

Comprendre les modèles

Les modèles d'OpenCart se trouvent dans le /catalog/model/dossier et sont regroupés en fonction de la fonction et non de l'itinéraire, et vous devrez donc les charger dans votre contrôleur via

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

Cela chargera le fichier dans le sous-dossier xxxappelé yyy.php. Il est alors disponible pour être utilisé via l'objet

$this->model_xxx_yyy

et comme avec les contrôleurs, vous ne pouvez appeler que ses publicméthodes. Par exemple, pour redimensionner une image, vous utiliseriez le tool/imagemodèle et appelez sa resizeméthode comme suit

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

Comprendre l'affectation des variables dans les vues du contrôleur

Afin de transmettre des valeurs à la vue depuis le contrôleur, vous devez simplement affecter vos données à la $this->datavariable, qui est essentiellement un tableau de paires clé => valeur. Par exemple

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

L'accès à cela dans une vue est un peu facile à comprendre si vous êtes familier avec la méthode extract () qui convertit chaque clé en une variable. Ainsi, la example_varclé devient $example_varet est accessible en tant que telle dans la vue.

Comprendre les thèmes

Les thèmes sont disponibles uniquement du côté catalogue et sont essentiellement un dossier de modèles, de feuilles de style et d'images de thèmes. Les dossiers de thèmes sont placés dans le /catalog/view/theme/dossier suivi du nom du thème. Le nom du dossier n'a pas d'importance à l'exception du defaultdossier

Le côté administrateur utilise /admin/view/template/(en sautant /theme/theme-name/du chemin car il n'autorise pas des thèmes différents)

Les fichiers de modèle résident dans un templatedossier du dossier de thème. Si un modèle n'est pas disponible pour le thème actuellement sélectionné, le modèle du dossier par défaut est utilisé à la place comme solution de secours. Cela signifie que les thèmes peuvent être créés avec très peu de fichiers et fonctionner toujours pleinement. Cela réduit également la duplication du code et les problèmes lors des mises à niveau

Comprendre les vues (modèles)

Comme pour le langage et les modèles, les fichiers de vue sont généralement liés à l'itinéraire, bien que cela ne soit pas du tout nécessaire. Les modèles du côté catalogue se trouvent généralement dans /catalog/view/theme/your-theme/template/sauf s'il n'existe pas, auquel cas les modèles du thème par défaut seront utilisés. Pour notre exemple de page de recherche ci-dessus, le fichier est product/search.tpl. Pour les itinéraires en trois parties, c'est généralement aaa/bbb_ccc.tplbien qu'il n'y ait pas de règle fixe. Dans l'administrateur, la plupart des pages suivent cela, à l'exception des pages répertoriant des éléments, comme la page de liste des produits, catalog/product_list.tplet le formulaire de modification du produit catalog/product_form.tpl. Encore une fois, ceux-ci ne sont pas définis, mais une norme pour le panier par défaut.

Le fichier modèle est en fait juste un autre fichier php, mais avec une extension .tpl et est en fait exécuté dans le fichier du contrôleur, par conséquent, toutes les choses que vous pouvez coder dans un contrôleur peuvent être exécutées dans un fichier modèle (bien que ce ne soit pas recommandé sauf si nécessaire)

Comprendre l'objet de base de données

Les requêtes sont exécutées à l'aide de

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

DB_PREFIX comme son nom l'indique est une constante contenant le préfixe de la base de données s'il en existe un

$resultrenverra un objet pour les SELECTrequêtes, contenant quelques propriétés

$result->row contient les données de la première ligne si une ou plusieurs sont renvoyées sous forme de tableau associatif

$result->rows contient un tableau de résultats de ligne, idéal pour boucler en utilisant foreach

$result->num_rows contient le nombre de résultats retournés

Il existe également quelques méthodes supplémentaires dont $this->dbdispose l' objet

$this->db->escape()utilise mysql_real_escape_string () sur la valeur passée

$this->db->countAffectedrenvoie le nombre de lignes affectées par une UPDATErequête et ainsi de suite

$this->db->getLastId()renvoie le dernier identifiant d'incrémentation automatique en utilisant mysql_insert_id ()

Comprendre les variables réservées

OpenCart a des variables prédéfinies à utiliser à la place de la norme $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES, $_REQUESTET$_SERVER

$_SESSIONest édité en utilisant $this->session->dataoù data est un tableau associatif imitant le$_SESSION

Tous les autres sont accessibles en utilisant $this->requestet ont été "nettoyés" pour se conformer aux guillemets magiques activés / désactivés, donc

$_GET devient $this->request->get

$_POST devient $this->request->post

$_COOKIE devient $this->request->cookie

$_FILES devient $this->request->files

$_REQUEST devient $this->request->request

$_SERVER devient $this->request->server

Résumé

Bien que ce qui précède ne soit pas un guide à toute épreuve pour les développeurs, j'espère qu'il servira de bon point de départ pour ceux qui commencent.

Méthodes de bibliothèque globale: Fonctions de base de la bibliothèque opencart avec leurs fonctionnalités, la plupart d'entre elles peuvent être appelées de n'importe où dans le catalogue ou les dossiers d'administration (contrôleurs, modèles, vues)

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

Il existe un site Web OpenCart Wiki avec de la documentation pour les développeurs débutants. Suivez les URL ci-dessous pour plus de détails:

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

LIENS D'ARCHIVES 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 = method_reference

Par exemple, la référence de la méthode contient des détails pour:

1. Connexion client
2. Accès à la base de données
3. Manipulation du panier
4. Config
5. Cache
6. Gestion des devises

Il y a encore quelques pages en construction mais ça va être utile.

[Mettre à jour]

Depuis janvier 2018, le domaine opencarhelp.com est en panne.

Bien que ce sujet ait déjà reçu de nombreuses réponses, je voudrais proposer une autre approche de la maîtrise d'OpenCart basée sur mon expérience.

Apprentissage par la pratique

En créant votre propre framework OpenCart à partir de zéro avec une poignée de fichiers, vous pouvez comprendre comment tout est assemblé. Je vais imiter la structure de fichiers d'OpenCart pour vous.

Créer un fichier index.php

<?php
// My simpleCart

1. Registre

Opencart utilise le modèle de registre pour répertorier toutes les instances des classes chargées. C'est le cœur de votre application OpenCart. L'objet de registre est ensuite transmis à chaque catégorie, modèle et bibliothèque pour un accès rapide à d'autres objets.

créer un fichier avec chemin /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;
    }
}

dans votre index.php

<?php
// My simpleCart

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

//initialize registry
$registry = new Registry;

2. Sortie

Ajoutons maintenant une sortie qui sera notre HTML à l'avenir. Après tout, l'idée est d'envoyer une chaîne de texte au navigateur.

Créer un fichier 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;
        }
    }
}

et dans votre 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();

Remarquez que j'ai ajouté Hello world uniquement à titre d'exemple. Nous l'enlèverons plus tard. Actualisez votre site pour le vérifier. Le navigateur devrait s'afficher Hello World.

3. Contrôleurs

Considérez les contrôleurs comme des pages. Ils définiront ce qui sera affiché au client: texte, html, json, téléchargement ou même une image. Pour l'instant, nous voulons juste une page qui envoie du texte.

Nous allons créer un contrôleur pour la homepage.

ajouter un fichier avec chemin 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);
    }
}

et modifiez votre 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();

remarquez comment j'ai passé le $refistryà ControllerCommonHome afin que je puisse y accéder à l'intérieur du contrôleur.

4. Routeur

Nous ne voulons pas que les contrôleurs soient codés en dur, n'est-ce pas. Nous utiliserons un paramètre routede l'adresse URL pour indiquer à notre panier quel contrôleur charger.

Créer un fichier avec chemin system/library/request.php

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

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

Créez la classe Router qui sera responsable de l'initialisation du fichier Controller en fonction de la route (en d'autres termes: appelez dynamiquement le contrôleur)

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

chargez-le dans votre 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();

Remarquez comment je charge tout dans le $registrypuis le passe au $routerqui le passe ensuite au $controller.

Cet article est déjà trop long, mais j'espère qu'il donnera une compréhension de base du modèle MVC dans OpenCart.

Si vous voulez que je continue avec cet article et que je vous dise comment d'autres choses fonctionnent comme les modèles et les vues, évaluez cette réponse pour que je sache.

Consultez également mon Youtube https://www.youtube.com/dreamvention et mon blog https://dreamvention.com/blog Je publierai plus de conseils et de tutoriels là-bas pour vous les gars!

PHP est un langage assez volumineux avec plus de 5000 fonctions intégrées, donc une stratégie pour apprendre une nouvelle plate-forme consiste à identifier les fonctions qu'elle utilise le plus fréquemment et à passer du temps à les connaître très bien.

J'ai exécuté quelques requêtes sur le code source d'OpenCart et les 10 fonctions les plus couramment utilisées sont:

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

Les 52 commandes répertoriées ici ainsi que les commandes bash Linux que vous pouvez utiliser sur n'importe quelle base de code pour identifier les fonctions couramment utilisées: https://www.antropy.co.uk/blog/efficace-learning-for-new-opencart-developers/

Cette liste de lecture de vidéos youtube peut également être utile pour devenir des développeurs OpenCart Gurus:

Tutoriels Vidéos OpenCart

1. Introduction et table des matières Cette vidéo présente l'introduction de la série
2. Installation d'OpenCart localhost Cette vidéo passe par l'installation d'OpenCart dans localhost
3. Fichiers et structure de dossiers d'OpenCart Il décrit la structure de fichiers et de dossiers d'OpenCart
4. Création d'un schéma de table de base de données dans OpenCart Il montre le schéma de table de base de données et montre comment créer des tables de base de données dans OpenCart
5. Méthodes des objets prédéfinis de la bibliothèque OpenCart Elle décrit les méthodes des objets prédéfinis de la bibliothèque OpenCart et indique où les trouver.

6. Modèle MVCL, flux de code et demande et réponse dans OpenCart Il montre le modèle MVCL, flux de code et demande et réponse dans OpenCart. Ils décrivent le flux comme dans l'image ci-dessous:

7. Installer, configurer et désinstaller le module Opencart Il montre trois façons de télécharger des modules, puis d'installer, de configurer et de désinstaller le module / extension OpenCart 3.

8. Dispositions et position dans Opencart 3 Il décrit les dispositions et les positions d'OpenCart 3. Il montre comment afficher des mises en page personnalisées pour différentes pages, en donnant des exemples de pages de catégories. Nous montrons la disposition différente pour une catégorie différente.

9. Aperçu des événements d'OpenCart Vous apprendrez quels événements sont dans OpenCart, comment ils fonctionnent et ce qui les rend si utiles.

10. Documentation de l'API Opencart pour les développeurs Cette vidéo montrera comment utiliser et créer une API opencart personnalisée

Une fois que vous voyez ces vidéos, vous pouvez commencer à coder :)