• Version used: Prestashop 1.7.2.4

In this tutorial we will see how to apply my previous guide on Creating a “Clear cart” button in PrestaShop to PrestaShop 1.7, as it doesn’t work out of the box because of the new template.

The basic code still works, and the process is more or less the same, though the files needing modifications are totally different. For this tutorial, I will be using the classic (or standard) template, so wherever you read “themename”, just put classic. As a side not, please notice some files might be different if you use a custom PrestaShop theme.

Adding the button to the cart page in PrestaShop 1.7

The PrestaShop 1.7 template structure is quite different from 1.6, so we need to account for that. The main view for the cart is now located at themes/*themename*/templates/checkout/, and it’s called cart.tpl. Open it up, and locat the following block:

      {block name='cart_overview'}
        {include file='checkout/_partials/cart-detailed.tpl' cart=$cart}
      {/block}

This represents the products list block, and we want to add the button right after it:

    <a class="btn btn-primary" style="float:right" id="removeAll" href="javascript:void(0)">
      Empty Cart
    </a>

At this point, unlike 1.6 where we could add our code directly to the template, with PrestaShop 1.7 we have to use a new file, named custom.js.

Adding new javascript to a PrestaShop 1.7 template

Open up custom.js, located in themes/*themename*/assets/js.
It’s empty by default, so if not (as in the case of custom templates), just add the code at the end.

This file is loaded on all pages, and since we only want to run it on the cart one, we have to wrap our snippet with a condition:

if(prestashop.page.page_name == 'cart')
{}

The prestashop javascript variable is a new global available in all pages of the shop, which contains a number of useful data that can be used in scripts. In this case, we use the current page name.

Here is all the rest of the code we need:

$(document).ready(function() {

	    $('#removeAll').click(function(e) {
	        e.preventDefault()
	        $.ajax({
	            type: 'POST',
	            headers: { "cache-control": "no-cache" },
	            url: prestashop.urls.base_url + "cart",
	            async: true,
	            cache: false,
	            data: 'deleteAll=1&token=' + prestashop.token + '&ajax=true',
	            success: function(data){	
	                window.location.reload();
	            }
	        })
	    });
	});	

Explanation: we are using the prestashop variable again, this time to fetch the base url. The cart controller, which we will be editing shortly, can be accessed at /cart by default, so we pass this url to the ajax call.
For the querystring, we pass in deleteAll, to make sure we can refer to this action in the next step, a token required by PrestaShop 1.7, and ajax=true, so that the cart know the action has to be run in ajax mode.
If the call is successful, we refresh the page to show that the cart is now empty.

Editing the CartController

PrestaShop 1.7 discourages the use of overrides, but we will use one in any case
Create a new file in override/controllers/front, and name it cartController.php. Reach back the original cart controller in the main controllers/front, and copy the whole updateCart method, pasting it into our new file:

    protected function updateCart()
    {
        // Update the cart ONLY if $this->cookies are available, in order to avoid ghost carts created by bots
        if ($this->context->cookie->exists() && !$this->errors && !($this->context->customer->isLogged() && !$this->isTokenValid())) {
            if (Tools::getIsset('add') || Tools::getIsset('update')) {
                $this->processChangeProductInCart();
            } elseif (Tools::getIsset('delete')) {
                $this->processDeleteProductInCart();
            } elseif (CartRule::isFeatureActive()) {
                if (Tools::getIsset('addDiscount')) {
                    if (!($code = trim(Tools::getValue('discount_name')))) {
                        $this->errors[] = $this->trans('You must enter a voucher code.', array(), 'Shop.Notifications.Error');
                    } elseif (!Validate::isCleanHtml($code)) {
                        $this->errors[] = $this->trans('The voucher code is invalid.', array(), 'Shop.Notifications.Error');
                    } else {
                        if (($cartRule = new CartRule(CartRule::getIdByCode($code))) && Validate::isLoadedObject($cartRule)) {
                            if ($error = $cartRule->checkValidity($this->context, false, true)) {
                                $this->errors[] = $error;
                            } else {
                                $this->context->cart->addCartRule($cartRule->id);
                            }
                        } else {
                            $this->errors[] = $this->trans('This voucher does not exist.', array(), 'Shop.Notifications.Error');
                        }
                    }
                } elseif (($id_cart_rule = (int)Tools::getValue('deleteDiscount')) && Validate::isUnsignedId($id_cart_rule)) {
                    $this->context->cart->removeCartRule($id_cart_rule);
                    CartRule::autoAddToCart($this->context);
                }
            }
        } elseif (!$this->isTokenValid() && Tools::getValue('action') !== 'show' && !Tools::getValue('ajax')) {
            Tools::redirect('index.php');
        }
    }

All we have to do now is add our condition, as part of all those ELSEIFs:

            elseif (Tools::getIsset('deleteAll')) {
                $this->context->cart->delete();
                $this->context->cookie->id_cart = 0;
                die(1);
            }

Here is the final code:

    protected function updateCart()
    {
        // Update the cart ONLY if $this->cookies are available, in order to avoid ghost carts created by bots
        if ($this->context->cookie->exists() && !$this->errors && !($this->context->customer->isLogged() && !$this->isTokenValid())) {
            if (Tools::getIsset('add') || Tools::getIsset('update')) {
                $this->processChangeProductInCart();
            } elseif (Tools::getIsset('delete')) {
                $this->processDeleteProductInCart();

            } elseif (Tools::getIsset('deleteAll')) { /* Nemo */
                $this->context->cart->delete();
                $this->context->cookie->id_cart = 0;
                die(1);
            } elseif (CartRule::isFeatureActive()) {
                if (Tools::getIsset('addDiscount')) {
                    if (!($code = trim(Tools::getValue('discount_name')))) {
                        $this->errors[] = $this->trans('You must enter a voucher code.', array(), 'Shop.Notifications.Error');
                    } elseif (!Validate::isCleanHtml($code)) {
                        $this->errors[] = $this->trans('The voucher code is invalid.', array(), 'Shop.Notifications.Error');
                    } else {
                        if (($cartRule = new CartRule(CartRule::getIdByCode($code))) && Validate::isLoadedObject($cartRule)) {
                            if ($error = $cartRule->checkValidity($this->context, false, true)) {
                                $this->errors[] = $error;
                            } else {
                                $this->context->cart->addCartRule($cartRule->id);
                            }
                        } else {
                            $this->errors[] = $this->trans('This voucher does not exist.', array(), 'Shop.Notifications.Error');
                        }
                    }
                } elseif (($id_cart_rule = (int)Tools::getValue('deleteDiscount')) && Validate::isUnsignedId($id_cart_rule)) {
                    $this->context->cart->removeCartRule($id_cart_rule);
                    CartRule::autoAddToCart($this->context);
                }
            }
        } elseif (!$this->isTokenValid() && Tools::getValue('action') !== 'show' && !Tools::getValue('ajax')) {
            Tools::redirect('index.php');
        }
    }

We are done! Reach the back office, Advanced Parameters, Performance, and hit the clear cache button on the top right, so that the override takes place.

Should it not work, check that Disable all overrides is set to no, right below on the same page. If it still doesn’t, try editing the core CartController.php.

The post Creating a “Clear cart” button in PrestaShop 1.7 appeared first on NemoPS.

Introduction

You might have come across the need to translate the price per unit field in your PrestaShop or Thirtybees, but crashed against the software’s limitation, as that’s a single language property. Any product field can be made multi-language with a simple modification, so let’s see how to do it using the Unity one as example in this tutorial!

Step 1 – Adding the new database column

In order to make the field translatable, we have to add it to the product_lang table in the database. Not only, but we also have to erase the same column in both the product and product_shop tables, to avoid conflicts when retrieving values from the database. Let’s add it first!

Using phpMyAdmin or Adminer, locate the *prefix*product_lang table in your database, and add a new column as VARCHAR, 24 characters long. Once done, it will look like this:

Next, let’s get rid of the leftovers: open the *prefix*product table and drop the unity column first, and then on the product_shop table.
We are done! We just broke the Product class though, and have to compensate by letting it know where to grab the new values from.

Step 2 – Editing the product class

We have a new column in the database, but at this point the Product class would still just ignore it. To have it lookup, and save into the correct table, we must tell it that the property we are wanting to translate is a multilanguage field. To do so, we must change its definition.

Open up Product.php, located in the classes/ folder.

Scroll down until you find the following line, part of the $definition property:

'unity'                     => ['type' => self::TYPE_STRING, 'shop' => true, 'validate' => 'isString'],

To make any field translatable, we can simply add ‘lang’ => true as follows

'unity'                     => ['type' => self::TYPE_STRING, 'shop' => true, 'validate' => 'isString', 'lang' => true],

Please notice that, as always, using an override is strongly recommended, instead of editing core files.

Step 3 – Editing the back office

The controller

This is the most complicated part, as we will have to edit both the admin controller for products, and the correct template. For our example, the template is prices.tpl, but it will be different if the field you want to translate is in another tab.

Let’s start with the controller. The prices template does not offer us any option for translating fields, and therefore misses the indispensable $languages variable.
Open up AdminProductsController, located in controllers/admin

We are interested in the method called initFormPrices, so once you find it you can simply clone that to an override, or continue editing the core.

Right after $data is assigned, at the very beginning of the function, but before $product = $obj, add the following

if (!$this->default_form_language) {
    $this->getLanguages();
}
$data->assign(array(
    'languages'=> $this->_languages,
    'id_lang' => $this->context->language->id,
    'default_form_language' => $this->default_form_language,
));

Explanation: Nothing too complex here, we are first checking if languages are loaded, and if not, assigning them to the controller. Then, we simply assign that class property to the template, along with a few other required ones. Please notice we do not use a common smarty assign, but the $data variable instead.

The template

Time to make our changes visible in the back office! For the unity field, let’s open up *admin folder*/themes/default/template/controllers/products/prices.tpl

Locate the input with id unity, which will look more or less like the following:

<input id="unity" name="unity" type="text" value="{$product->unity|htmlentitiesUTF8}"  maxlength="255" onkeyup="if (isArrowKey(event)) return ;unitySecond();" onchange="unitySecond();"/>

Instead of this input, we will use a handy template PrestaShop makes available to us. Replace the above with the following code:

{include file="controllers/products/input_text_lang.tpl"
languages=$languages
input_class="{$class_input_ajax}{if !$product->id || Configuration::get('PS_FORCE_FRIENDLY_PRODUCT')}copy2friendlyUrl{/if} updateCurrentText"
input_value=$product->unity
input_name="unity"}

Save and refresh, and you will see the new field, translatable, appearing in the prices table of the back office. Time to test it, and see if it’s saving properly.
We can take an extra step and translate the preview below as well:

<span id="unity_second">{$product->unity}</span>

to

<span id="unity_second">{$product->unity.{$id_lang}}</span>

At this point we can go ahead and test the Front Office. If everything has been done correctly, as soon as you change language, the class should automatically pick the correct translation for the field. Neat!

The post Make product fields multi-language in PrestaShop and ThirtyBees appeared first on NemoPS.

Watch the screencast

Final Code

<?php

include(dirname(__FILE__).'/config/config.inc.php');
include(dirname(__FILE__).'/init.php');


// we have a csv file open
$default_lang = Configuration::get('PS_LANG_DEFAULT');
// looping through products
// this is a single line in the loop


$product = new Product(20);
$product->name = [$default_lang => 'Test'];
$product->link_rewrite = [$default_lang => 'test'];
$product->price = 13.90;
$product->quantity = 70;
$product->id_category = [3,4];
$product->id_category_default = 3;
StockAvailable::setQuantity((int)$product->id, 0, $product->quantity, Context::getContext()->shop->id);

$product->update();

The post Create products from PHP in PrestaShop appeared first on NemoPS.

Adding the button to the cart page

The first thing we need is, of course, a button to play with. The ideal place where to add it is shopping-cart.tpl, specifically right after the order summary table. Therefore, open up the file, located in the theme folder, and read the end of the table, around line 454 of the default template:

					{/foreach}
				</tbody>
			{/if}
		</table>

Right after the table, let’s add a simple button:

		<a class="btn btn-default pull-right" id="removeAll" href="javascript:void(0)">
			Empty Cart
		</a>

Then, we need it to do something. We could use a submit, inside a form, but modern standards require speed, and nothing beats ajax in this.
Right after the button, let’s add a script tag:

<script>
			$(document).ready(function() {
				$('#removeAll').click(function(e) {
				});
			});
				
</script>

We want to target the click event of our new button, and fire an ajax request to the cart controller:

$(document).ready(function() {
	$('#removeAll').click(function(e) {
		e.preventDefault()
		$.ajax({
			type: 'POST',
			headers: { "cache-control": "no-cache" },
			url: baseUri + '?rand=' + new Date().getTime(),
			async: true,
			cache: false,
			dataType : "json",
			data: 'controller=cart&deleteAll=1&token=' + static_token + '&ajax=true',
			success: function(data){
				$('.opc-main-block, .step-num, #HOOK_SHOPPING_CART_EXTRA').fadeOut('fast');
				$('#order-detail-content').fadeOut('fast', function() {
					$('#emptyCartWarning').fadeIn('slow');	
				});
				ajaxCart.refresh();
			}
		})
	});
});

Explanation: The url we call is simply the base one, plus a random value with the date, to avoid the request being cached. In terms of data, we need to pass in the controller (cart), and action (deleteAll, which doesn’t exist yet, but we will create in a second), the security token, and then ajax=true.
On success, we fade out the page content, making sure any stuff from the One Page Checkout is hidden as well, and we also refresh the cart block.

The next step is to create something to handle the new deleteAll command.

Editing the CartController

As always, instead of modifying the core file, make sure you use an override for this method. The function we are interested in is postProcess:

    public function postProcess()
    {
        // Update the cart ONLY if $this->cookies are available, in order to avoid ghost carts created by bots
        if ($this->context->cookie->exists() && !$this->errors && !($this->context->customer->isLogged() && !$this->isTokenValid())) {
            if (Tools::getIsset('add') || Tools::getIsset('update')) {
                $this->processChangeProductInCart();
            } elseif (Tools::getIsset('delete')) {
                $this->processDeleteProductInCart();
            } elseif (Tools::getIsset('changeAddressDelivery')) {
                $this->processChangeProductAddressDelivery();
            } elseif (Tools::getIsset('allowSeperatedPackage')) {
                $this->processAllowSeperatedPackage();
            } elseif (Tools::getIsset('duplicate')) {
                $this->processDuplicateProduct();
            }
            // Make redirection
            if (!$this->errors && !$this->ajax) {
                $queryString = Tools::safeOutput(Tools::getValue('query', null));
                if ($queryString && !Configuration::get('PS_CART_REDIRECT')) {
                    Tools::redirect('index.php?controller=search&search='.$queryString);
                }

                // Redirect to previous page
                if (isset($_SERVER['HTTP_REFERER'])) {
                    preg_match('!http(s?)://(.*)/(.*)!', $_SERVER['HTTP_REFERER'], $regs);
                    if (isset($regs[3]) && !Configuration::get('PS_CART_REDIRECT')) {
                        $url = preg_replace('/(\?)+content_only=1/', '', $_SERVER['HTTP_REFERER']);
                        Tools::redirect($url);
                    }
                }

                Tools::redirect('index.php?controller=order&'.(isset($this->id_product) ? 'ipa='.$this->id_product : ''));
            }
        } elseif (!$this->isTokenValid()) {
            Tools::redirect('index.php');
        }
    }

See all those elseifs? We need another condition to target our deleteAll command. Therefore, at the end of the stack, add another:

...
} elseif (Tools::getIsset('duplicate')) {
    $this->processDuplicateProduct();
} elseif (Tools::getIsset('deleteAll')) {

}
// Make redirection
if (!$this->errors && !$this->ajax) {
...

Inside it, we do not need fancy stuff, only:

elseif (Tools::getIsset('deleteAll')) {
                
    $this->context->cart->delete();
    $this->context->cookie->id_cart = 0;
    die(1);


}

This will clear the cart for good, and reset the id for the current user. You can also avoid resetting it, if you prefer.
Save and test the button now. Make sure you clear the class_index.php file inside cache/, if you used an override.
We are done!

The post Creating a “Clear cart” button in PrestaShop 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 optional.

Getting a Product’s Price

// It needs an instance
Product::getPrice($tax = true, $id_product_attribute = null, $decimals = 6,
		$divisor = null, $only_reduc = false, $usereduc = true, $quantity = 1)

// Static way
Product::getPriceStatic($id_product, $usetax = true, $id_product_attribute = null, $decimals = 6, $divisor = null,
		$only_reduc = false, $usereduc = true, $quantity = 1, $force_associated_tax = false, $id_customer = null, $id_cart = null,
		$id_address = null, &$specific_price_output = null, $with_ecotax = true, $use_group_reduction = true, Context $context = null,
		$use_customer_price = true);

Both methods can be equally used to get a product’s price. While the first needs to be ran by a product instance, the second is static and can be ran from every context, as long as you provide the product id.

Example Usage

// get the product price, after instanciating a new object

$product = new Produc(4); // instanciate a product with id = 4
// get the price, but dynamically check if it needs to apply taxes or not
$product_price = $product->getPrice(Product::$_taxCalculationMethod == PS_TAX_INC);
// get the price of a specific combination, always with taxes
$product_attribute_price = $product->getPrice(true, 77);


// get price without instanciating an object
$products = array(
	0 => array('id_product' => 2),
	1 => array('id_product' => 86),
	2 => array('id_product' => 12),
);

foreach($products as $key => $product)
	$products[$key]['price'] = Product::getPriceStatic($product['id_product']);

Getting a Product’s Name

Product::getProductName($id_product, $id_product_attribute = null, $id_lang = null);

Retrieves the given product name in a single language (if not specified, the current one)

Example Usage

// Gets the name in the current language
$name = Product::getProductName(34);

// Gets the combination name in a chosen language
$name = Product::getProductName(34, 6, 2);

Getting a Product’s Quantity

Product::getQuantity($id_product, $id_product_attribute = null, $cache_is_pack = null);

// This will consider a specific warehouse
Product::getRealQuantity($id_product, $id_product_attribute = 0, $id_warehouse = 0, $id_shop = null)

They both return the product’s quantity, but the latter is to be preferred with advanced stock management in mind.

Example Usage

// gets the quantity of all products in the array
$products = array(
	0 => array('id_product' => 2),
	1 => array('id_product' => 86),
	2 => array('id_product' => 12),
);

foreach($products as $key => $product)
	$products[$key]['qty'] = Product::getQuantity($product['id_product']);


// Gets quantity for a specific combination of a product (product id = 6, combination id = 99)
$quantity = Product::getQuantity(6, 99);


// Gets the quantity in stock for the specific warehouse ID
$quantity = Product::getRealQuantity(6, 0, 1);

Getting and displaying Products Cover Image

// Returns an image ID
Product::getCover($id_product, Context $context = null);

// Uses the product rewrite and image id to get the actual image link
Link::getImageLink($name, $ids, $type = null);

These can be used in conjunction to display the product’s cover.

Example Usage

// returns an array like array('id_image' => 66)
$cover = Product::getCover(5);

if($cover) // if there is an image
{
	// notice 'ipod-nano' is the product link_rewrite field here;
	$img_link = $this->context->link->getImageLink('ipod-nano', $cover['id_image']); // remember the previous is an array
}

Getting Product Features for the front office

// Gets features so they can be properly displayed
Product::getFrontFeatures($id_lang);

// The same, but static
Product::getFrontFeaturesStatic($id_lang, $id_product);

These methods come in handy when you want to display product features with their names and values.

Example Usage

$product = new Product(10);
$features = $product->getFrontFeatures($this->context->language->id);


// static way
$features = Product::getFrontFeaturesStatic($this->context->language->id, 10);

Getting Product Categories

// Get ids of the categories this product belongs to
Product::getCategories();

// The same, Static
Product::getProductCategories($id_product);

// Get more data about categories, including name and link_rewrite
Product::getProductCategoriesFull($id_product, $id_lang = null);

// Get all parent categories, up to the root, in a single language. It will only consider the default one as starting point
Product::getParentCategories($id_lang = null);

They are all used to retrieve data about the product’s category association.

Example Usage

$product = new Product(10);
// $categories will be ids only
$categories = $product->getCategories();

// Using the same Object, get all parents
$parent_categories = $product->getParentCategories();

// Static way, getting more data in the current language
$categories = Product::getProductCategoriesFull(10, $this->context->language->id);

Additional Resources

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

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