Watch the screencast

Text Version

If you have lots of users it might happen sometimes that a product goes out of stock while it’s in someone’s cart. For example two users add the last unit, one proceeds to the checkout and the other doesn’t. What happens is when the second customer places the order, the product will not be available anymore, and it will cause confusion if not irritation to that person, especially if you cannot restock that specific item.

The Cart Presenter in PrestaShop 1.7

The first file we need to edit is the cartPresenter, which is responsible of displaying cart information across the store.

Open up src/Adapter/Cart/cartpresenter.php and add the following around line 51, in the class properties:

private static $removedProducts = [];

Then locate the present method, and right after the following statement:

        if ($shouldSeparateGifts) {
            $rawProducts = $cart->getProductsWithSeparatedGifts();
        } else {
            $rawProducts = $cart->getProducts(true);
        }

Add this:

        // start nemo

        if(!self::$removedProducts)
            foreach ($rawProducts as $pk => $product)
            {
            // we want to remove the product in case it's not available
                if($product['quantity_available'] <= 0 && !Product::isAvailableWhenOutOfStock($product['out_of_stock']))
                {
                    Context::getContext()->cart->deleteProduct($product['id_product'],$product['id_product_attribute'], $product['id_customization'], $product['id_address_delivery']);
                    self::$removedProducts[] = $product['name'];
                    unset($rawProducts[$pk]);
                    continue;
                }
            }
           
        Context::getContext()->smarty->assign(['removed_products' => self::$removedProducts]);
        \Media::addJsDef(['removed_products' => self::$removedProducts]);

And that’s all for php! Before continuing let’s make sure the product actually gets removed, so let’s test it and see if they really get removed!

The shopping cart template in PrestaShop 1.7

Let’s open up themes/classic/modules/ps_shoppingcart/ps_shoppingcart.tpl

{if isset($removed_products) && $removed_products}
  <div id="removed-modal" class="modal">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <p>{l s='These products are out of stock' d='Shop.Theme.Checkout'}</p>
            <ul>
              {foreach from=$removed_products item='r_product'}
                <li>- {$r_product}</li>
              {/foreach}
            </ul>
            <p>{l s='And have therefore been removed from your cart' d='Shop.Theme.Checkout'}</p>
        </div>

      </div>
    </div>
  </div>
{/if}

And the very last thing is actually triggering the modal when we need, so let’s add some javascript to themes/classic/assets/js/custom.js

if(removed_products.length > 0) {
	$('#removed-modal').modal('show');
}

And that’s it! Now this modal doesn’t look so fancy, but no worries since in one of the next videos we will go over creating and styling custom popups in prestashop 1.7, so stay tuned!

The post Removing out of stock products from the cart in PrestaShop 1.7 appeared first on NemoPS.

• 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.

Watch the screencast

Text Version

All of the modifications need to be applied to AdminOrdersController.php, located in controllers/admin
Add to $this->_select (do not forget the comma!):

od.product_quantity_return as has_returned,

Add to $this->_join:

LEFT JOIN `'._DB_PREFIX_.'order_detail` od ON (od.`id_order` = a.`id_order`)

Right after the join variable is set, add:

$this->_group = 'GROUP BY a.id_order';

This way we avoid duplicates in the order list.

In the next step we will add the actual column, scroll down to around line 130, and add the following to the $this->fields_list variable:

                'has_returned'            => [
                    'title'      => $this->l('Return'),
                    'align'      => 'text-center',
                    'type'       => 'bool',
                    'callback'       => 'getIsReturned',
                ],

Lastly, out of the construct method (it can be anywhere, right after it or at the end of the file) we will add the callback function:

    public function getIsReturned($a, $order)
    {
        $has_returned = Db::getInstance()->getValue('SELECT product_quantity_return FROM '._DB_PREFIX_.'order_detail WHERE id_order =' .(int)$order['id_order'] .' AND product_quantity_return > 0');

        $class = $has_returned ? 'icon-check' : 'icon-remove';
        return '<i class="'.$class.'"></i>';

    }

The post Mark orders with returned products in the order list of ThirtyBees and PrestaShop 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.

Watch the screencast

The post Limit the total number of products in the cart – PrestaShop 1.6 appeared first on NemoPS.

The post Display products from subcategories in PrestaShop 1.6 appeared first on NemoPS.

Watch the Screencast

The post Update price on quantity change in PrestaShop 1.6 appeared first on NemoPS.

Watch the Screencast

The post Display price and Add to Cart in the viewed Products Block in PrestaShop appeared first on NemoPS.

• PrestaShop Version used: 1.6.1.5

The background

Do you allow back ordering products? If so, you might have noticed PrestaShop tends to be confusing on combinations. In the default template, when a combination is available and has stock, it displays the classic X items in stock message. However, if you select a combination that has currently zero stock, even if available for order, it displays nothing. Forum users have reported customers being confused by this, so let’s see how to fix it, and give our customers more feedback!

The translatable string

Unless you run a single language shop, you will need the text we are going to display to be translatable. Therefore, we will take advantage of PrestaShop’s AddJsDefL method to add a javascript variable that can easily be translated from the back office. Open up your product.tpl file, located in the theme folder. At the very end of it, add the following:

{addJsDefL name='onBackOrderText'}{l s='On backorder' js=1}{/addJsDefL}

What does it do? It takes any content between tags and assigns it to the variable with a given name. There is a manual method as well, but this is the one that better complies to PrestaShop standards. If you want to know more about this and other functions, you can refer to my Essential PrestaShop functions series.

Editing product.js

Now that we have a string to play with, we have to make it work as we want. Open up product.js, located in the theme folder /js/. Please notice yours might be different if you do not use the default template. Locate the following at around line 630:

		if (allowBuyWhenOutOfStock && !selectedCombination['unavailable'] && productAvailableForOrder)
		{
			$('#add_to_cart:hidden').fadeIn(600);

			if (stock_management && availableLaterValue != '')
			{
				$('#availability_value').addClass('label-warning').text(availableLaterValue).show('slow');
				$('#availability_statut:hidden').show('slow');
			}
			else 
				$('#availability_statut:visible').hide('slow');
				
		}

The last part, in the else, is the one responsible for not displaying anything. We could simply comment it out, but if you try it, you will notice it says the product is available in other variants only. What to do then? Let’s modify it as follows:

		if (allowBuyWhenOutOfStock && !selectedCombination['unavailable'] && productAvailableForOrder)
		{
			$('#add_to_cart:hidden').fadeIn(600);

			if (stock_management && availableLaterValue != '')
			{
				$('#availability_value').addClass('label-warning').text(availableLaterValue).show('slow');
				$('#availability_statut:hidden').show('slow');
			}
			else {
				$('#availability_value').addClass('label-warning').text(onBackOrderText).show('slow');
				// $('#availability_statut:visible').hide('slow');
			}
				
		}

We just added brackets to the else statement, then copied the label-warning part from above, and used our text variable instead. Save and refresh, then try reloading the page with the combination selected, as well as switching between that and others. You will notice the text behaves as expected now!

The post Adding text for back-orderable Combinations in PrestaShop appeared first on NemoPS.