Watch the screencast

The post Setting up a staging site for PrestaShop and Thirtybees appeared first on NemoPS.

1- You don’t keep PS_DEV_MODE enabled

On your dev sites, always keep development mode. If you don’t know how to, just reach out config/defines.inc.php, locate define(‘_PS_MODE_DEV_’, false) and set it to true. If you need to test out performance, you might want to turn on _PS_DEBUG_PROFILING_ as well

2- Not enough testing

It’s obvious, but again often overlooked. Always make sure you test your modules on all the PrestaShop versions you want it to work with.. Test it not only locally, but online as well. If it involves category pages, make sure it works and it’s compatible with the Layered Navigation module. Also, try to have as many standard modules installed as you can, when you run your tests; this ensures your addon is compatible with at least the basic functionalities of the software.

3- Core files modification

I will never stress this highly enough: do not ever apply your modifications directly to core files (unless it’s impossible to do otherwise). Always use overrides, since it’s easier to point out a modification added with this method, rather than having to scrub through all the original files.

4- Not enough comments

Even if you use overrides, make sure you point out which part of the code you amended. I often found myself lost in overridden methods, since they were an almost identical copy of the original, with the tiniest modification to a single sql query, without anything pointing it out.

5- Breaking the MVC pattern

If you need to query the database, always use a class. It’s bad practice to run queries directly from controllers, so make sure you always use them exclusively to bind a class to a view. You will have to create another file, but the result is going to be cleaner and easier to maintain. For example, if you need you get a list of entries from your module’s table, you might want to have a class included in your controller with require_once at the very beginning of it. Alternatively, you can always access the module’s core file’s methods from any controller, using $this->module.

6- Including CSS and Javascript in templates

PrestaShop has two methods for inclusing Javascript and CSS: AddCSS and AddJS (please refer to: Essential Prestashop Functions). It’s not advised to use «style» tags directly within templates. You can use script tags, but only if it’s strictly necessary.

7- Too much Javascript

The modern web is full of fancy animations and pretty things that make a page render nice to the viewer, but also slower. Make sure you do not over-rely on javascript for page rendering. I have come across templates that could not be used at all without Javascript, and this is potentially harmful to any shop. Consider this: a single javascript error can kill the whole website’s accessibility. For this reason, always make sure your addon/theme runs fine without Javascript (just disable it from any browser console and test)

8- No indentation indentation/formatting

Try to format your code a bit. It’s not necessary to slavishly follow the standards PrestaShop requires to validate a module for the addons store, if you are selling it on your site. However, it’s a lot easier for us other developers to read your code, if it has a decent formatting.

9- Extensive usage of custom code for the back office

PrestaShop has tons of helpers for the back office, it’s better to rely on those instead of writing huge blocks of code with custom styling. It’s always better to output things with a template, whenever possible, and in any case use the standard css classes/boxes even when outputting directly from PHP.

10 – Eccessive use of custom hooks

Plenty templates I worked on had an insane amount of custom hooks. If you are a template developer, try to keep them at a bare minimum, unless strictly necessary, and rely on PrestaShop’s standard ones instead. A theme made up entirely with custom hooks is a real pain to deal with.

Want to know more about PrestaShop Development?

Have a look at my PrestaShop Modules Course

The post 10 mistakes to avoid in PrestaShop Development appeared first on NemoPS.

NOTICE: Values with “=” in the declaration are optionals.

Database-related Functions

// Retrieving an array of values from the given table
Db::getInstance()->executeS($sql, $array = true, $use_cache = true);

// Retrieving a single value
Db::getInstance()->getValue($sql, $use_cache = true);

// Retrieving a whole row
Db::getInstance()->getRow($sql, $use_cache = true);

// Executing a generic query, returns true if succeeded, false if failed
Db::getInstance()->execute($sql, $use_cache = true)

// Inserting a row
Db::getInstance()->insert($table, $data, $null_values = false, $use_cache = true, $type = Db::INSERT, $add_prefix = true)

// Updating values
Db::getInstance()->update($table, $data, $where = '', $limit = 0, $null_values = false, $use_cache = true, $add_prefix = true)

// Erase the given entry
Db::getInstance()->delete($table, $where = '', $limit = 0, $use_cache = true, $add_prefix = true)

// Escape data
Db::getInstance()->escape($string, $html_ok = false, $bq_sql = false)

// Get the primary key of the last item you added
Db::getInstance()->Insert_ID()

These methods serve as helpers so that we don’t have to create a new mysql connection every time we want to run a query

Example Usage

// Returns an array with each item correspinding to a single database row
// It should only be used to retrieve values, use execute or the other helpers to insert/update them
$customers = Db::getInstance()->executeS('SELECT * FROM '._DB_PREFIX_.'customers');

// Returns product data of the ones that belong to the given category only (id = 4)
$products = Db::getInstance()->executeS('
	SELECT * FROM '._DB_PREFIX_.'product p
	LEFT JOIN '._DB_PREFIX_.'category_product cp ON (cp.id_product = p.id_product)
	WHERE cp.id_category = 4
');


// Retrieving the specific product name for our current language
$product_name = Db::getInstance()->getValue('SELECT name FROM '._DB_PREFIX_.'product_lang WHERE id_product = 1 AND id_lang = ' . $this->context->language->id);

// Get the whole row for customer id = 1
$customer = Db::getInstance()->getRow('SELECT * FROM '._DB_PREFIX_.'customer WHERE id_customer = 1');


// Insert some data manually (not recommended, unless you have some really specific SQL to use)
Db::getInstance()->execute('INSERT INTO '._DB_PREFIX_.'customer (id_customer, email, firstname, lastname) VALUES (9, "nemo@nemops.com", "Fabio", "Porta")');

// Inserting a row
// The $data array must be configured like 
// 		column => value

$data = array(
	'id_customer' => 1,
	'email' => "nemo@nemops.com",
	'firstname' => "Fabio",
	'lastname' => "Porta",
);
Db::getInstance()->insert('customer', $data);

// Updating values, array configured as above
$data = array(
	'id_customer' => 1,
	'email' => "nemo@nemops.com",
	'firstname' => "Fabio",
	'lastname' => "Porta",
);
Db::getInstance()->update('customer', $data, 'id_customer = 1');

// Erase customer with id = 1
Db::getInstance()->delete('customer', 'id_customer = 1');

// Escape data
$sanitized = Db::getInstance()->escape('<div class="test"><div>', true);
// will return <div class=\"test\"><div>

// Get the primary key of the last item you added

$data = array(
	'email' => "nemo@nemops.com",
	'firstname' => "Fabio",
	'lastname' => "Porta",
);
Db::getInstance()->insert('customer', $data);
$last_id = Db::getInstance()->Insert_ID()
// $last_id will be the id_customer of the entry we just added

The Query object in Prestashop

DbQuery::select($fields)
DbQuery::from($table, $alias = null)
DbQuery::join($fields)
DbQuery::leftJoin($table, $alias = null, $on = null)
DbQuery::where($restriction)
DbQuery::having($restriction)
DbQUery::orderBy($fields)
DbQUery::groupBy($fields)
DbQuery::limit($limit, $offset = 0)

All these functions are used to streamline a query creation. Inspect the DbQuery class to have a complete list.

Example Usage

	// get all products with id > 3, with relative language data

	$query = new DbQuery();
	$query->select('p.*, pl.*')
		->from('product', 'p')
		->leftJoin('product_lang', 'pl', 'p.id_product = pl.id_product')
		->where('p.id_product > 34')
		->where('pl.id_lang = ' . $this->context->language->id)
		->groupBy('p.id_product')
		->limit(5)

	$result = Db::getInstance()->getValue($query);

Quick escape in a SQL query

pSQL($string, $htmlOK = false)

Sanitize data which will be injected into SQL query

Example Usage

	$search = '2" clamps';
	// get aliases for the given search word, as you can see the above requires douple quotes to be escaped
	$aliases = Db::getInstance()->executeS('
	SELECT a.alias
	FROM `'._DB_PREFIX_.'alias` a
	WHERE `search` = \''.pSQL($search).'\'');

Wrapping it up

All of the methods we examined today are a huge time saver when dealing with the Database in Prestashop. I rarely use the query object, I admit, as I prefer relying on the other methods. However, since it’s getting more and more built into the standard workflow of core modules and methods, it’s good practice to start using that as well, and integrate it into your own Prestashop Module/Extension.

Additional Resources

• Essential Prestashop Functions – Day 1
• Essential Prestashop Functions – Day 3
• Essential Prestashop Functions – Day 4
• Essential Prestashop Functions – Day 5

The post Essential Prestashop Functions – Day 2 appeared first on NemoPS.

If you want to dive into Prestashop development, these are likely the first methods you’ll be needing.

NOTICE: Values with “=” in the declaration are optionals.

Managing Configuration values in Prestashop

// Updating a single/multiple value/s
Configuration::updateValue($key, $values, $html = false, $id_shop_group = null, $id_shop = null);

// Getting a single value
Configuration::get($key, $id_lang = null, $id_shop_group = null, $id_shop = null)

// Getting Multiple Values
Configuration::getMultiple($keys, $id_lang = null, $id_shop_group = null, $id_shop = null)

// Getting the same key in all languages
Configuration::getInt($key, $id_shop_group = null, $id_shop = null)

// Erase the given entry
Configuration::deleteByName($key)

These methods are used to interact with the *prefix_*configuration table. It’s the quickest way to store simple data in Prestashop.

Example Usage

// Saving a normal string
$my_text = 'This is some text';
Configuration::updateValue('MY_CONFIG_PARAMETER', $my_text);

// Saving an html string
$my_text = '<p>This is some text</p>';
Configuration::updateValue('MY_CONFIG_PARAMETER', $my_text, true);

// Saving multiple values, KEYS represend ID_LANG
$my_texts = array(
	1 => 'This is some text',
	2 => 'This is some text in another language'
	);
Configuration::updateValue('MY_CONFIG_PARAMETER_MULTILANG', $my_text);


// Getting a single value
$my_text = Configuration::get('MY_CONFIG_PARAMETER');

// Getting a single value for the current language only
$my_text = Configuration::get('MY_CONFIG_PARAMETER', $this->context->language->id);

// Getting Multiple Values
$keys_to_get = array('MY_CONFIG_PARAMETER', 'OTHER_CONFIG_PARAMETER');
Configuration::getMultiple($keys_to_get);

// Delete the given key
Configuration::deleteByName('MY_CONFIG_PARAMETER');

Getting POST and GET in Prestashop

Tools::getValue($key, $default_value = false)

Retrieves the current POST or GET variable with the given key

Example Usage

// Getting either POST or GET with the key 'myvalue', the second parameter is what to assign then nothing is found.
$value = Tools::getValue('myvalue', 4);
// If no 'myvalue' POST or GET variable is set, $value will be 4.

Checking for submitted data in Prestashop

Tools::isSubmit($key);

Check whether or not the given key has been submitted to the current page.

Example Usage

if(Tools::isSubmit('myvalue'))
{
	// do something
}

Displaying Errors in Prestashop

Tools::displayError($string = 'Fatal error', $htmlentities = true, Context $context = null)

Displays an error with proper formatting.

Example Usage

if($myvalue != 1)
{
	// will need to be displayed later on
	$error_string = Tools::displayError('It is different from 1');
}

Displaying Confirmations in Prestashop Modules

$this->displayConfirmation($string);

Displays a properly formatted confirmation message. $this refers to a module, it is therefore only available in module contexts only. Refer to the proper variable elsewhere.

// this is inside a module's method
if($myvalue == 1)
{
	// will need to be displayed later on
	$conf_string = $this->displayConfirmation('Updated!');
}

Adding CSS in Prestashop

ControllerCore::addCSS($css_uri, $css_media_type = 'all', $offset = null, $check_path = true)

Appends the given CSS file/s to the page

Example Usage

// this is inside a module's method
$this->context->controller->addCSS($this->_path.'css/myfile.css', 'all');

// this is inside a controller's method
$this->addCSS(_THEME_CSS_DIR_.'product.css');

// adding multiple files
$files = array(
	_THEME_CSS_DIR_.'product.css' => 'all',
	_THEME_CSS_DIR_.'other_css.css' => 'all'
);
$this->addCSS($files);

Adding Javascript in Prestashop

ControllerCore::addJS($js_uri, $check_path = true);

Appends the given JS file/s to the page

Example Usage

// this is inside a module's method
$this->context->controller->addCSS($this->_path.'css/myfile.css', 'all');

// this is inside a controller's method
$this->addCSS(_THEME_CSS_DIR_.'product.css');

Adding jQuery Plugins in Prestashop

ControllerCore::addJqueryPlugin($name, $folder = null, $css = true)

Appends the given jQuery Plugin/s to the page

Example Usage

// this is inside a module's method, multiple files
$this->context->controller->addjqueryPlugin('fancybox');

// this is inside a controller's method
$this->addjqueryPlugin('fancybox');

// this is inside a controller's method, multiple values
$this->addjQueryPlugin(array('scrollTo', 'alerts', 'chosen', 'autosize', 'fancybox' ));

// this is inside a controller's method, without loading the plugin's CSS
$this->addjQueryPlugin('growl', null, false);

Adding jQuery UI Components in Prestashop

ControllerCore::addJqueryUI($component, $theme = 'base', $check_dependencies = true);

Appends the given jQuery UI component/s to the page

Example Usage

// this is inside a module's method, single file
$this->context->controller->addjQueryUI(ui.datepicker');

// this is inside a controller's method, multiple files
$this->addJqueryUI(array('ui.slider', 'ui.datepicker'));

Wrapping it up

We saw quite a number of useful PrestaShop Functions today, which are enough to start coding your own, simple module. Apart from trying to remember them all, I suggest creating code snippets with some text expander, so you can quickly drop them in, without having to remember the exact syntax.

Additional Resources

• Essential Prestashop Functions – Day 2
• Essential Prestashop Functions – Day 3
• Essential Prestashop Functions – Day 4
• Essential Prestashop Functions – Day 5

The post Essential Prestashop Functions – Day 1 appeared first on NemoPS.

What are hooks?

If you have been using Prestashop for quite some time, I bet you found yourself saying “Why in the world can’t I place something there? I really want to do it!” in more than one occasion. Yes, it can be frustrating, because Prestashop only allows you to execute your modules in specific spots, defined by the software itself. These places are commonly known as hooks. And this is actually all what hooks are, as the name suggests: they represent definite points of the code which you can use to run your own module’s functions.

If this may be considered as a limitation, since it forces the developer to only use those specific points to run a module’s code without touching the core files, it’s also a powerful and easy solution to greatly improve Prestashop’s basics functionalities. Actually, hooks make your life A LOT easier when extending the package. At least, you don’t have to mess for ages with XML and Zend Framework ugly PHP (have I heard someone screaming Magento?).

Anyway, if you are a developer, and know how to code a prestashop module, you’ll be quite used to the following structure:

public function hookLeftColumn($params)
{
    /* Code to be executed */
}

This function allows the module to be hooked to the left column, and running proper code from there, be it something to display to the user, or stas gathering stuff. In any case, you will always need to run a hookSomewhere function to run the module’s code in a specific place.

Visual Hooks VS Action Hooks

Hooks can be basically grouped into 2 main groups: Visual Hooks, and Action Hooks.

The first ones are generally used to display content to your website, and provide a visual feedback to the customer. While there are in fact back Office visual hooks, like the one used to display new tabs on the Stats page, most of them are defined by controllers in front office, and assigned to variables to be executed within the template. An example of this is the “Left Column” hook we saw previously, used to show modules on the left column of the base template

Action hooks are, on the other side, deputed to only run code, without actually display content. They are placed both in class and controller files, and may come in handy when we need to gather data thrown by a class, manipulate it, or use it for  purposes other than Prestashop’s default one. As the name suggests, they occur when a spacific action takes place. An example of action hook is the “cart” hook, executed in the Cart.php Class when a cart is created or updated.

To exemplify, let’s say we have a “best sales” module, and it uses database caching to optimize performance. It retrieves best sellers from a cached version of the product list created once in a while. Well, this once in a while can be set in two ways: the traditional way is to set up a cron job, and refresh the list once every hour, or day, or so; the other way would be using hooks. We could hook the module to “newOrder”, which is a hook that executes when a new order is placed, and code a function that refreshes data in that particular moment. This way, there would be now need to fetch all product data every time the page reloads, thus increasing our site’s speed. Of course, this is just an example (taken from one of my modules, Best sales of the day/week/month/period, which you can find here), and there are other many things you can do with action hooks.

Whichever purpose hooks have, they all share the same basic structure:

• A database entry in the ps_hook table 

This is the core part of the hooks, since it’s what makes Prestashop know whether the specific hook we are currently calling exists or not.

•  The hookExec() function which executes it

It’s the function that runs the hooks execution, and therefore all hookNameOfTheHook() function associated to it(see next). The function is defined in the Module Class, and can be passed a number of parameters to be stored in the $params variable of the executing function.

Module::hookExec('nameofthehook')

Module::hookExec('nameofthehook', $params_array)

When creating a front office visual hook, instead of directly executing the hooks attached modules, the action is assigned to a variable to be called by smarty within the template.

self::$smarty->assign('HOOK_NAMEOFTHEHOOK', Module::hookExec('nameofthehook'));

In this case, you would also need to add the following code to the template file where you wanted to display the hook’s content

{$HOOK_NAMEOFTHEHOOK}

• A hookNameOfTheHook() function to be placed in modules in order to hook them

Without this, a module would not be hooked to anything and would never execute. This last function is the most important one, since it allows you to perform any action for the desired hook. We already saw the code for the HookLeftColumn() function.

public function hookLeftColumn($params)
{
    /* Code to be executed */
}

This function usually returns a template file in front office hooks

return $this->display(__FILE__, 'filename.tpl')

Let’s go into action: creating a new Hook in Prestashop

Now that we know enough about hooks, let’s create a new hook that will allow us to display modules content at the beginning of  each category page.

The first step will be to let Prestashop know the hook exists, so let’s add it to the database. We can go 2 ways: log in to phpmyadmin (or any sql manager) and add the column manually; or create a module which, when installed, will add the hook.

The database way:

Log in to your sql manager. In your prestashop database, look for the table ps_hook (remember, ps_ is just the default prefix, you can have anything instead of that! Take note of your prefix). If you’re using phpMyAdmin, click on the yourprefixHook table, then Insert, and add values for the name (which should be all underscore and without spaces), title and description then click add. Alternatively, you can use run this SQL query:

INSERT INTO `ps_hook` (`name`, `title`, `description`) 
VALUES ('category', 'Category', 'Hooks before the product list in a category');

The module way:

If the hook is only used by a module, we can also bind it to the module itself, and add it in the installation process. Let’s create a function that looks like this:

protected function addHook() {
    $check = Db::getInstance()->getRow('
			SELECT name
			FROM '._DB_PREFIX_.'hook
			WHERE name = "category"
			');

    if (!$check) {
	$query = "INSERT INTO "._DB_PREFIX_."hook (`name`, `title`, `description`) VALUES ('category', 'Category', 'Hooks before the product list in a category');";
	if(Db::getInstance()->Execute($query))
	    return true;
	else
	    return false;
    }
    else return true;
}

The $check part is useful to know if another hook with the same name exists, since creating douplicates will definitely cause problems!

Executing the hook

Now that prestashop has the hook data stored, it’s time to run it’s execution

self::$smarty->assign('HOOK_CATEGORY', Module::hookExec('category'));

We can place this code in the FrontController.php file, or any other controller, since we are going to use the hook for display purposes. Using the FrontController saves us the time of thinking where exactly it should run, because assigning the variable in the DisplayHeader function will set it for every front page, before even one of the other hooks is assigned. So, to add the assignment to the Front Controller, let’s create a new FrontController.php file, place it into override/classes, and fill it with the following code.

<?php 

Class FrontController extends FrontControllerCore
{

	public function displayHeader()
	{
		if (!self::$initialized)
			 $this->init();

			self::$smarty->assign('HOOK_CATEGORY', Module::hookExec('category'));

		parent::displayHeader();		
	}

}

Note the if (!self::$initialized)  $this->init(); snippet at the beginning of the function. This ensures the controller is properly initialized, and fixes problems in pages such as payment or order confirmation..

Even though using the front controller saves us the time of having to scrub through all other controllers to find the right position to execute it, be aware that it will be assigning the execution for every front page of the shop. So, for our purposes, it would have been better to add the assignment in the process() function of the CategoryController. In the end, of course, the choice is all up to you. For the sake of it, here is what adding the code to a categoryController override would have looked like

class CategoryController extends CategoryControllerCore
{

    public function process()
    {
        parent::process();
        if (!($id_category = (int)Tools::getValue('id_category')) OR !Validate::isUnsignedId($id_category))
            $this->errors[] = Tools::displayError('Missing category ID');
	else
		{
                     self::$smarty->assign('HOOK_CATEGORY', Module::hookExec('category'));
          }
    }
}

Now, let’s add the hook to the template

Let’s open up the category.tpl file of our template.Just before this code

{if $products}

Which is line 90 of the prestashop_new template, add the following

{$HOOK_CATEGORY}

Most of the work it’s done, and we have just successfully added a new hook in Prestashop!

Creating a module to be hooked

…Yay, okay, but we need to test this new hook, or else we don’t know if it really works or not. I’ve prepared a testing module, which can be found as an attachment at the beginning of the post. Grab it, copy the “testing” folder inside the modules folder and open the testing.php file.

If you know something about modules, you’ll definitely know they have to be registered to a hook before they can be executed. If you don’t want to do it manually from the positions tab in back office, add the following code in the install() function:

public function install()
{
    if (!parent::install() OR
	!$this->registerHook('Category'))
        return false;
    return true;
}

Now, at the bottom of the file, create the hookCategory Function:

public function hookCategory($params)
{
    global $cookie, $smarty;
    return $this->display(__FILE__, 'testing.tpl');
}

And that’s all!

Let’s install the module, go to a category page of the shop and see if the template’s content appears where we placed the hook variable. It’s likely we won’t see anything at the moment, but don’t fear. Since Prestashop uses caching, we must first re-compile the cache to see changes. Let’s go to preferences, then performance in back office, and turn on the option “Force Compile”, then refresh the category page. At this point, we should see a piece of text saying “Howdy guys! testing new hooks” If you don’t, since the Force Compile feature is a bit buggy, go to the Tools/Smarty/Compile folder and delete everything except the index.php. This should fix it, and you should be able to see the text.

Conclusion

We’re done! Thanks for reading. If you still have questions about how to create new hooks, feel free to contact me and I’ll be glad to help you.

Additional Resources

• A list of Prestashop Hooks
• EZ Hook module: add new hooks in a couple of clicks

The post A deeper look at Prestashop Hooks appeared first on NemoPS.