I wasn’t able to use the Magento 2 migration tool for products so one of the tasks on my TO DO list was product review migration. Looking around for (free) solutions the only stuff I came across was no longer free or didn’t work. $100 to import 500 reviews – I don’t think so.

If you are looking to do something similar here is a quick copy and paste of the php code I used for the Magento 1 export, and the Magento 2 import.

I am assuming you can plug this into your existing Magento php cli tools which already bootstrap the corresponding Magento1 or 2 core classes. For Magento 1 I first took a full product collection and parsed each product for review data. All the data is saved to a tab seperated CSV file which is then used for the Magento 2 product review import.

Magento 1.9 product review export to csv

echo $c("MAGE1 Migration - Export MAGE1 Product Reviews to CSV")->header. "\n\n";

// LOAD ALL PRODUCTS
//
$_storeID=0; // admin

$_reviewVisibleInStoreViews=array(1,2);

$_storeLocale[0]='admin';
$_storeLocale[1]='de';
$_storeLocale[2]='en';
$this->getProductCollectionAllSKUs($_storeID);

$_products=$this->get('collection');
$_reviewData=array();
$_count=0;

foreach($_products as $_id=>$_product)
{
    $_sku = $_product->getSku();
    $_productId = $_product->getId();
    $_reviewcCollection = \Mage::getModel('review/review')->getCollection()
        ->addStoreFilter($_storeID)
        ->addEntityFilter('product', $_productId)
        ->addStatusFilter(\Mage_Review_Model_Review::STATUS_APPROVED)
        ->setDateOrder()
        ->addRateVotes();

        if (count($_reviewcCollection))
        {

            $_productReview=array();

            foreach($_reviewcCollection as $_review) {

                $_ratings=array();
                $votes = $_review->getRatingVotes();
                $total = 0;

                foreach($votes as $vote)
                {
                    $total += $vote->getPercent();
                    $_ratings[]=$vote->getValue();
                }

                $avgRating = $total / count($votes);

                $_reviewDetail=trim(preg_replace('/\s\s+/', '<br>', $_review['detail']));
                $_reviewTitle=trim(preg_replace('/\s\s+/', '<br>', $_review['title']));

                //var_dump($total, count($votes), $avg);
                $_productReview[]=array(
                    'createdat' => $_review->getCreatedAt(),
                    'review' => $_reviewDetail,
                    'summary' => $_reviewTitle,
                    'nickname' => $_review['nickname'],
                    'customer_id' => ($_review['customer_id'] ? $_review['customer_id'] : null),
                    'ratings' => implode('|', $_ratings),
                    'visibilty' => implode('|', $_reviewVisibleInStoreViews),
                );

                $_count++;
                echo '.';

            }

            $_reviewData[$_sku]=$_productReview;

        }

}

//print_r($_reviewData);
echo "\n".$c($_count. ' product reviews exported for store view '. $_storeID)->info."\n";

// EXPORT CSV
//
//
$_now = new \DateTime(null, new \DateTimeZone('Europe/Berlin'));
$_reviewExportFilename='/home/data/Mage1MigrateReviewsProducts_'.$_now->format('Y-m-d').'_'.$_storeLocale[$_storeID].'.csv';

$_reviewExportHeader='sku,createdat,review,summary,nickname,customer_id,ratings,visibility';
$_reviewExportHeader=explode(',',$_reviewExportHeader);

if (file_exists($_reviewExportFilename)) {unlink($_reviewExportFilename);}

// -- csv seperator
$_seperator="\t"; // TAB
//$_seperator=','; // COMMA

ini_set('default_charset','UTF-8');

$_fileHandle = fopen($_reviewExportFilename, 'w');

    // write UTF8-BOM
    //fwrite($_fileHandle, pack("CCC",0xef,0xbb,0xbf));

    // write header
    if ($_reviewExportHeader) {fwrite($_fileHandle, implode($_seperator, $_reviewExportHeader)."\r\n");}

    echo $c('Creating CSV export file '. $_reviewExportFilename)->info."\n";

    // write data
    foreach ($_reviewData as $_sku => $_reviews)
    {
        foreach ($_reviews as $_review)
        {
            fwrite($_fileHandle, $_sku.$_seperator.implode($_seperator, $_review)."\r\n");
        }
    }

fclose($_fileHandle);

echo $c('Product review export complete!')->success. "\n";

Magento 2 csv product import

<?php

	echo $c("MAGE2 Import Product Reviews from MAGE1 Migration CSV")->header. "\n\n";

	$_reviewDataCSVFile='/home/data/Mage1MigrateReviewsProducts_2020-01-11_admin.csv';
	$_reviewDataCSV=file('/home/data/Mage1MigrateReviewsProducts_2020-01-11_admin.csv', FILE_IGNORE_NEW_LINES);

	echo $c("Importing from ". $_reviewDataCSVFile)->info. "\n";

	$_count=0;
	$_total=(count($_reviewDataCSV)-1);
	foreach ($_reviewDataCSV as $_key => $_data)
	{
		if ($_key===0){ // build header
			$_keys=explode("\t",trim($_data));
			continue;
		}

		$_dataArray=explode("\t",$_data);

		foreach ($_dataArray as $_key => $_data)
		{
			$_reviewData[$_keys[$_key]]=$_data;
		}

		//print_r($_reviewData);

		try
		{
			$_success=false;

            $_obj=new \PAJ\Library\Magento2\Reviews\AddReview(
                array(
					'reviewdata' => $_reviewData,
					'storeid' => '0'
                )
            );
				$_output=$_obj->get('output');
				$_success=$_obj->get('success');

			if($_success)
			{
				$_count++;
				echo $c("Review ". $_count."/".$_total. " imported.")->success. "\n";
				//print_r($_output);

			}

		}
		catch (\Exception $e)
		{
			// catch bad guys
			//throw new \Exception($e);
			echo $c("ERROR: ". $e->getMessage())->error. "\n";
			continue;
		}

		// 1 product test exit;
		//exit;
	}


if (!$_silent) {

	echo 'Import complete.'. "\n";
}


exit;


class MagentoAddReview extends AbstractApp
{

    /**
     * @var \Magento\Review\Model\RatingFactory;
     */
    private $_ratingFactory;
    /**
     * @var \Magento\Review\Model\ReviewFactory;
     */
    private $_reviewFactory;

    public function run()
    {
        // load a product
        //

        // init vars
        $_data=array();

        $_storeID=$this->_variables['storeid'];
        $_store = $this->_storeManagerInterface->getStore($_storeID);
        $this->_storeManagerInterface->setCurrentStore($_store);
        $_reviewData=$this->_variables['reviewdata'];

        $_sku=$_reviewData['sku'];
        $_customerId=$_reviewData['customer_id'];

        //for Guest user $_customerId=Null;
        //
        if (!$_customerId){$_customerId=Null;}

        // create review data
        //
        $_customerNickName=$_reviewData['nickname'];
        $_reviewTitle=$_reviewData['summary'];
        $_reviewDetail=preg_replace('#<br\s*/?>#i', "\n", $_reviewData['review']);
        $_title=preg_replace('#<br\s*/?>#i', "\n", $_reviewData['summary']);
        $_createdAt=$_reviewData['createdat'];

        // store visibility array, i.e. 1,2 for visibile in store view 1 and 2
        // 
        $_reviewVisibleInStoreViews=explode('|',$_reviewData['visibility']);
        $_ratings=explode('|',$_reviewData['ratings']);

        $_product = $this->_productRepository->get($_sku);
        $_productId=$_product->getId();

        $_reviewFactory = $this->getReviewFactory();
        $_ratingFactory = $this->getRatingFactory();

        foreach ($_ratings as $_key => $_rating)
        {
            $_reviewFinalData['ratings'][$_key+1] = $_rating;
        }

        $_reviewFinalData['nickname'] = $_customerNickName; //add user nickname
        $_reviewFinalData['title'] = $_title; //add title of the review
        $_reviewFinalData['detail'] = $_reviewDetail; //add details of the review
        $_reviewFinalData['customerid'] = $_customerId;

        $review = $_reviewFactory->create()->setData($_reviewFinalData);

        $review->unsetData('review_id');
        $review->setEntityId($review->getEntityIdByCode(\Magento\Review\Model\Review::ENTITY_PRODUCT_CODE))
            ->setEntityPkValue($_productId)
            ->setStatusId(\Magento\Review\Model\Review::STATUS_APPROVED) //By default set approved
            ->setStoreId($_storeID)
            ->setCreatedAt($_createdAt)
            ->setStores($_reviewVisibleInStoreViews)
            ->save();

        foreach ($_reviewFinalData['ratings'] as $ratingId => $rating) {
            $_ratingFactory->create()
                ->setRatingId($ratingId)
                ->setReviewId($review->getId())
                ->addOptionVote($rating, $_productId);
        }
        $review->aggregate();

        //$this->debug($_data);
        $_data['store']['storeid']=$_storeID;
        $_data['reviews']=array(
            'productid'=> $_productId
        );


        return ['magento' => $_data];
    }

    /**
     * Get Factories
     *
     */
    private function getRatingFactory()
    {
        if (!$this->_ratingFactory) {
            $this->_ratingFactory = \Magento\Framework\App\ObjectManager::getInstance()
                ->get(\Magento\Review\Model\RatingFactory::class);
        }
        return $this->_ratingFactory;
    }
    private function getReviewFactory()
    {
        if (!$this->_reviewFactory) {
            $this->_reviewFactory = \Magento\Framework\App\ObjectManager::getInstance()
                ->get(\Magento\Review\Model\ReviewFactory::class);
        }
        return $this->_reviewFactory;
    }
}

The echo’s use the cool colours from https://github.com/kevinlebrun/colors.php The will probably throw an error for you, sorry!

An example of the install method is shown below with code for a confiurable product dropdown attribute and a text attribute.

To run the install script use php bin/magento setup:upgrade

To force the install script to run again you can delete the module entry in the setup_module database table and run setup:upgrade again. I guess a cleverer way would be to use the upgrade feature but this is really just intended as a one off process to perhaps install 50 product attributes that would otherwise be time consuming to manually configure.

Note the group name let’s you add these custom attributes into their own group which makes them more manageable in the admin interface.

<?php namespace GaiterJones\Catalog\Setup; use Magento\Eav\Setup\EavSetup; use Magento\Eav\Setup\EavSetupFactory; use Magento\Framework\Setup\InstallDataInterface; use Magento\Framework\Setup\ModuleContextInterface; use Magento\Framework\Setup\ModuleDataSetupInterface; class InstallData implements InstallDataInterface { private $eavSetupFactory; public function __construct(EavSetupFactory $eavSetupFactory) { $this->eavSetupFactory = $eavSetupFactory;
    }

    // CUSTOM product attributes / groups
    //
    public function install(ModuleDataSetupInterface $setup, ModuleContextInterface $context)
    {
        $eavSetup = $this->eavSetupFactory->create(['setup' => $setup]);

        // attribute for configurable product
        //
        //
        $eavSetup->addAttribute(
            \Magento\Catalog\Model\Product::ENTITY,
            'product_colour_x',
            [
                'type' => 'int',
                'group' => 'GAITERJONES Product',
                'backend' => '',
                'frontend' => '',
                'label' => 'product_colour_x',
                'default' => '',
                'input' => 'select',
                'class' => '',
                'source' => 'Magento\Eav\Model\Entity\Attribute\Source\Table',
                'global' => \Magento\Eav\Model\Entity\Attribute\ScopedAttributeInterface::SCOPE_GLOBAL,
                'visible' => true,
                'required' => false,
                'user_defined' => true,
                'searchable' => false,
                'filterable' => true,
                'comparable' => false,
                'visible_on_front' => false,
                'used_in_product_listing' => false,
                'unique' => false,
                'apply_to' => ''
            ]
        );

        $eavSetup->addAttribute(
            \Magento\Catalog\Model\Product::ENTITY,
            'selling_unit',
            [
                'type' => 'varchar',
                'group' => 'GAITERJONES Product',
                'backend' => '',
                'frontend' => '',
                'label' => 'Selling Unit',
                'input' => 'text',
                'class' => '',
                'source' => '',
                'global' => \Magento\Eav\Model\Entity\Attribute\ScopedAttributeInterface::SCOPE_GLOBAL,
                'visible' => true,
                'required' => false,
                'user_defined' => true,
                'default' => 'Stück',
                'searchable' => false,
                'filterable' => false,
                'comparable' => false,
                'visible_on_front' => false,
                'used_in_product_listing' => false,
                'unique' => false,
                'apply_to' => ''
            ]
        );

     }
}

The nice folks at Magento call it “Sunsetting“

We have all known this for some time, exactly what that means for Magento 1 stores is open for debate, I doubt the world is going to end but are the risks associated with running deprecated ecommerce store software acceptable?

Magento 2 has been maturing nicely over the last few years and now is definitely as good a time as any to start working on your migration plan.

The costs and time associated with migrating a Magento1 store with “minimal” third party integration are estimated at between $5,000 to $60,000 – 3 to 6 months. Even a very basic migration will require a new custom theme, modules and data export.

The total cost of migration depends of course on the in house skills you or your company possess. Chances are if you are reading this you already have Magento 1 and PHP experience. That’s good news! If you are new to Magento 2 the bad news is that it’s a steep learning curve to get up to the same speed with Magento 2 that you have right now with trusty old Magento1.

Time invested now in setting up an Magento2 development environment is time well spent. I spent the last couple of years dabbling with Magento 2when I had the time – most of my time was spent getting my Magento 2 Docker environment right and testing migration methods.

Migrating a mature Magento 1 store to Magento 2 is a daunting task. If your store has been around for a long time (mine started life as Magento 1.3 in 2009) no doubt you will have a very customised theme and installed or developed a lot of custom modules and features over the years. You may have 1000’s of products, 10’000s of customers and hopefully a lot of order data.

So where do you start? In a perfect world you would start with the official Magento 2 migration plan and within half an hour and a few clicks your Magento 1 store is automagically migrated to Magento 2. This fairy tale migration only really works on vanilla Magento 1 installs with no customisation. Having said that as of the latest Magento 2 (2.3.x) the migration process has matured and improved. It is definitely worth familiarising yourself with the migration tool as you probably will need it to migrate some of your Mage 1 data.

For me the migration tool worked perfectly for customer data, but not for products. And of course unless you want to use the basic Magento 2 theme, migrating your Magento 1 theme is simply not possible.

Once you accept the fact that you are going to have to pretty much rebuild your Shop from scratch it’s time to step back and have a think about how to rebuild 1000’s of products.

Having worked with Magento 1 for almost 10 years I was used to exporting product data for use in other applications such as Amazon and eBay product feeds, so I thought why not simply export the Magento 1 data in a format that Magento 2 can import.

This is not a bad idea, but we are talking about a lot of data – thousands of products, multi store views, lots of custom attributes. That’s a pretty big CSV file to manage.

A much better idea is to create a “skeleton” export of your Magento 1 product data – just the bare bones of the products, enough for Magento 2 to import them with enough data to create the product.

Once you have the basic product structure imported simply synchronise the data between MAGE1 and MAGE2! Sounds complex but actually it is pretty easy.

We just need two PHP scripts, one with access to the MAGE1 source files and database and one with access to the MAGE2 installation. The MAGE2 script calls the MAGE1 script to request product data for a SKU. The MAGE1 script extracts all the product data you need into an array returning it in JSON format to MAGE2 which in turn updates the corresponding MAGE2 skeleton product. This is done for each store view.

There are some complications associated with configurable products, attribute sets and product attributes which you need to create and import, but once the basic product is in MAGE2 the synchronisation process works perfectly.

At the time of writing I can synchronise all data for all product types including, pricing, tier pricing, custom attributes and product images.

I can keep Magento 2 in sync with changes or updates to the live Magento 1 shop simply by restoring the latest database backup to my Magento 1 migration database and performing a new product sync.

I started my Migration about 6 weeks ago (May 2019) and having developed the import and sync process I am just about ready to start on a “live” dev build of my new Magento 2 store. I don’t have a new theme yet but there is a lot of work to do getting the catalog ready and customising core templates and code.

I will be updating this blog with my progress and hopefully developing the MAGE1 to MAGE2 export and sync scripts to be made available to download.

Stay tuned to watch this dummy migrate a Magento 1 store to Magento 2!

Magento Open Source v1 covering Magento versions up to 1.9.x is still the eCommerce platform for many small businesses and whilst we all know we need to move to Magento 2 the time and resources required to migrate a successful v1 shop to v2 are for many people prohibitive.

PHP7

The original system requirements for Magento 1 were based on PHP5. Magento 1 users were forced to stay with an operating system that distributed PHP5, a PHP upgrade would break Magento. There were unofficial patches available that would make Magento compatible with later versions of PHP but I was always wary of applying unofficial core code changes to my live shops.

In September 2018 Magento made the PHP7 patches official, and they were included in the December 1.9.4.0 update.

My Magento live Shops were built on Ubuntu Trusty 14.04 LTS which included PHP5. My Docker containers used Trusty as the main OS for my docker images. Now, with the 1.9.4.0 update we can move to current versions of PHP and enjoy the performance benefits of PHP7.x.

PHUSION

As a big fan of Ubuntu I usually build my Ubuntu Docker containers using the Phusion Ubuntu base image. For my Magento2 containers I compile PHP myself so for Magento 1.9.4.0 it was pretty easy to migrate a Magento2 Dockerfile to use for Magento1 on PHP 7.2.

Upgrade

Upgrading my Docker Magento1 PHP5 shops to PHP7 was simply a case of applying the 1.9.4.0 upgrade, replacing my old Ubuntu Trusty base image with the Ubuntu Bionic PHP7.2 image and restarting.

I am still testing all my extensions and associated PHP5 Magento application code for functionality but so far the upgrade looks good.

You can find my Magento 1.9.4.0 PHP7.2 image here. My Dev shop running Magento 1.9.4.0 with PHP7.2 in Docker is here.

Github for the source files is here https://github.com/gaiterjones/docker-magento1-php7

Move tracking code to Google Tag Manager

Visitors must give positive consent before their data is used. If you are tracking customer visits with third party tools such as Google Analytics, or customer service modules the user needs to “opt in” and give positive consent to permit you to use his data. By using Google Tag Manager you can load all your custom html and javascript tracking code after the user provides consent. Google Tag Manager applies your third party tacking code to all pages making it easier to implement changes.

Add a cookie consent toolbar

The GDPR wants you to clearly state what personal data if any you are storing or sharing with third parties. You need to add a cookie consent toolbar to your Magento site that clearly states how and why you use cookies, which third party tracking tools you use and how you share visitor data with third parties. Visitors must give positive consent to this policy – it is no longer acceptable to say that consent is implied by using the website, users must actively provide consent and your backend logic must implement this. Give visitors as much information as possible and link the cookie consent toolbar to your Data Protection (Privacy) Policy.

Allow individuals to remove or anonymise data

You need to be able to provide assurance that admin staff or customers can remove personal data stored in your Magento store on request.

Allow individuals to opt out from subscriptions

Make sure your opt-out (and opt-in) to newsletter subscriptions is working.

Perform Security Testing

Use the Magento Security scan or Mage Report to provide assurance that your Magento installation is up to date and patched against known security vulnerabilities.

Update your Data Protection (Privacy) Policy

Make sure your Data Protection Policy is up to date and available from every page of your Magento site.

Data Access

Individuals have the right to ask you of all their personal data and this needs to be a full copy of all data held in Magento. Make sure you are able to fulfill such a request, the GDPR states that this information should be made a available, without charge, within 30 days of the request.

Create a Compliance Document

You need to be able to demonstrate a diligent and earnest effort to comply with the GDPR. Create a compliance document that shows how you are meeting the GDPR requirements, the document should include

• A compliance audit
  • List the steps you have taken to comply with the GDPR
• Information audit
  • Audit your systems and clearly state where personal data is stored
    • is it internet facing?
    • is it shared with third parties?
    • how is it secured?
    • Where is it physically stored, servers, pc’s etc.
• Data Protection Policy
  • Include your policy documents

Magento GDPR Compliance Module

A quick Google for GDPR modules for Magento 1.x and 2.x show there are a few solutions available and most are not free. Two free modules are available

Magento 1 https://marketplace.magento.com/zero1-zero1-gdpr.html

Magento 2 https://github.com/AdFabConnect/magento2gdpr

I don’t yet have a live Magento 2 store so have not tested the Magento 2 module. I installed the Zero1 module and found it to contain a couple of bugs which made it unuseable, it appears to be bait to encourage you to purchase the commercial version. The module is fairly simple providing you with a frontend Cookie Consent toolbar, a frontend customer account deletion/anonymisation button and a backend method for anonymising customer data. I took this code and enhanced it with an existing cookie toolbar I had previously developed and the module is free to test and use at https://github.com/gaiterjones/magento1-gdpr

Install the module with modman using modman clone https://github.com/gaiterjones/magento1-gdpr

You will see a new menu item called GDPR in the Configuration -> Customers section.

Adding your Google Tag Manager ID enables the Google Tag Manager code which will insert any tags you have configured into your Magento site.

Enabling the customer account deletion and anonymisation will provide you with two new admin buttons when you view customer information

This enables admin staff to delete and anonymise customer and order data and send a confirmation email. In debug mode both these buttons can be tested for functionality. A similar button is activated in the frontend Customer Account section allowing customers to close their account and anonymise their data. You will be notified by email when a customer closes their account.

Debug mode lets you test the module without actually deleting anything, specifically the confirmation emails and notices sent by the module.

You change the look of the Cooke Policy consent bar skin choosing between light or dark skins and you can customise the consent bar text further as you wish.

You can see the consent bar working at http://magento1.gaiterjones.com

Seek advice

Compliance with these new regulations is important, if you are unsure where to begin with GDPR compliance seek professional advice!

The information presented here is a summary of my own personal findings and thoughts on how to improve Magento 1 GDPR compliance and no guarantee whatsoever is provided that the information presented here will ensure GDPR compliance! Use the Magento module at your own risk – be sure to test it first on your development site.

This is an example of a PHP app I created using the Framework 7 HTML framework as a mobile Magento admin interface to refresh caches, check orders, activate customers and set customer groups from a mobile device.

The customer activation is specifically for use with Vinai/customer-activation.

What is PayPal Plus?

PayPal introduced PayPal Plus in February 2015 as an all in one payment solution for online retailers in Germany. It differs from the normal Magento PayPal methods – standard and express in a few ways.

• it uses PayPal’s RESTful API
• payment methods are embedded in a checkout “payment wall” using an iFrame
• multiple payment options are available
  • credit card, direct debit  (Lastschrift), invoice payment (Kaufaufrechnung)
• a paypal account is not required to pay

Why is PayPal Plus only available in Germany

The Germans are very careful when it comes to online data protection, especially where money is concerned. I would guess that the requirement for other payment methods in Germany such as Lastschrift (direct debit) which is a very popular way of paying for all sorts of things in Germany has prompted Paypal to develop a solution tailored specifically toward German consumer requirements.

How to implement PayPal Plus

Magento module

PayPal will send you an open source PayPal Plus module developed by iWays. The module will run on Magento CE 1.7 or greater using the default checkout. It also supports some other one page checkout modules.

Module installation is pretty straight forward – I didn’t find a GitHub version so created my own as I prefer to manage my module installations with modman.

After installation refresh your caches and a new payment method is created, configure PayPal Plus from system > config > sales > payment methods > paypalplus settings.

The Merchant Country for your store must be set to Germany, PayPal Plus is (at the time of writing) only available in Germany, the module settings will not be displayed if your Merchant Country is not set to Germany.

Configure your PayPal app client and client secret and turn on the sandbox mode for testing.

Note – if you have OPCACHE enabled and the opcache.save_comments option disabled you Magento will throw an exception with a “class should have a proper return type” error. Enable save_comments and reload Apache to continue.

REST API

In REST the classic API signature is replaced with client_ID and client secret. These need to be generated by creating a PayPal app. To create a PayPal app log in to the PayPal Developer portal with your PayPal account and navigate to the My REST apps page. Click Create App to begin the application-creation process. The app will automatically be in sandbox mode.

testing

With valid sandbox API credentials and the module enabled you will see your payment methods have been replaced by the PayPalPlus payment methods templates (base/default/template/paypalplus). The template embeds the PayPal Plus payment wall iFrame into your checkout page including the 4 standard payment methods.

Note – if you have already extended and customised the base payment method template it has now also been extended by the iWays modules templates. You will need to extend the iWays templates and modify them with your customisations.

The default payment wall is white as shown above, at the time of writing there are no options available to change the style. colours etc of the payment wall.

The module quite cleverly detects your existing PayPal payment methods – express, standard etc. And knows to replace them with PayPal plus. Your other payment methods will appear below the PayPal Plus options nicely styled to match the payment wall. You should leave all your existing PayPal payment options enabled, should there be any problems with PayPal Plus your shop will automatically fall back to your normal payment methods.

You can also integrate your other payment methods directly into the payment wall by enabling them in the  “allow third party modules” module settings.

In sandbox mode you can now test out all the payment options. To test Kauf auf Rechnung (Invoice) you need to set the “Show PuI in Sandbox” option to Yes in the module development settings options. PuI is Payment Upon Invoice – a rather literal translation of the German Kauf auf Rechnung.

Kauf auf Rechnung

PayPal Plus lets customers order and pay by invoice. The merchant receives the payment directly from Paypal like any other PayPal transaction. The goods can be shipped as soon as the merchant is paid by PayPal and the customer has up to 30 days to pay the invoice, paying the outstanding amount directly to PayPal.

Many online retailers shy away from offering this kind of payment option due to the problems arising from unpaid invoices and chasing debtors for payment but with PayPal taking over this responsibility there is no reason (apart from the PayPal transaction fees) to not offer it.

One problem with this option is making sure that the customer knows to pay the outstanding invoice amount to Paypal and not the Merchant. You will notice when you test payments that the module shows all payment methods on order confirmations as “PayPal, Lastschrift, Kreditkarte, Kauf auf Rechnung”.

At the time of writing there is actually no way to distinguish between PayPal Plus Paypal, Kreditkarte or Lastschrift payments. You can however identify invoice Kauf auf Rechnung payments.

If you look at a payment made with Kauf auf Rechnung you will see the order has a ppp_pui_instruction_type object set to “PAY_UPON_INVOICE”, this lets you check for invoice payments using something like

	if($_order->getPayment()->getData('ppp_pui_instruction_type')=='PAY_UPON_INVOICE')
	{
		$_isPUI=true;
	}

This is useful because Paypal recommends you make sure the customer is aware that the payment must be made to PayPal. By identifying an invoice payment we can customise the information shown to the customer when they pay using Kauf auf Rechnung.

For example we can customise the new order email to show Kauf auf Rechnung as the payment method, and add the recommended PayPal invoice payment text to the payment information.

Similarly we can add the same information to the checkout success page.

To customise your email templates you need to add a new handler to your layout.

<?xml version="1.0"?>
<layout version="0.1.0">
	<!-- sales payment info handler -->
	<my_sales_email_payment_info>
		<block type="core/template" name="addPaymentInfo" template="my/sales/email/payment/info.phtml" />
	</my_sales_email_payment_info>
</layout>

in your sales/email/payment/info.phtml template add the logic and information you want to display in the sales email.

<?php

$_order = $this->getOrder();
$_isPUI=false;

	
	if($_order->getPayment()->getData('ppp_pui_instruction_type')=='PAY_UPON_INVOICE')
	{
		$_isPUI=true;
	}
	

?>
<?php if($_isPUI):?>
		<p>YOUR CUSTOM TEXT</p>
<?php endif;?>

You can now call this handler from anywhere in your sales email templates using

{{layout handle="my_sales_email_payment_info" order=$order}}

to display the information from your template. We can do exactly the same for the checkout success page, you just need to retrieve the order object first.

$_order = Mage::getModel('sales/order')->load(Mage::getSingleton('checkout/session')->getLastOrderId());

Conclusions

Considering Paypal used to belong to eBay, and eBay now owns Magento it’s likely that PayPal plus will become part of the Magento core code at some point in the future. The iWays module is well written and works well – it will need some customisation to fit into your own specific requirements especially if you have already customised your payment method templates. Time will tell how invoice payments work…

The test files are included in the Magento root /dev folder.  The files are included for development purposes and might reveal your passwords or other sensitive information when accessed with malicious intent. The /dev directories and files are not protected by default and according to Magento, “these tests are not supposed to end up on production servers”.

Do not install these files in a production environment.

Delete the /dev/ folder from your production server.
Delete the /dev/ folder after upgrading to a newer version of Magento.

Magento Pagespeed 100/100 rating

Well unfortunately due to some core Magento design issues I think the answer is no, BUT – you should be able to achieve a green rating of at least 90 to 95.

The last time I worked on Pagespeed optimisation I achieved an 85 desktop rating for a Magento landing page, today I achieved a 93 rating by further optimising JavaScript, CSS and HTML.

Magento Pagespeed Optimisation

Google Pagespeed insights targets 5 main optimisation categories

• Stylesheets optimizations
• Javascript files optimizations
• Images optimizations
• HTML optimizations
• Tracking activity filters

When you run the insights tool these are the areas that will be looked at and reported on. Google will clearly tell you where your Magento store needs improvement, it is likely you will need to look at both your server configuration and Magento to address Pagespeed issues found by Magento.

Problems such as web server compression not enabled, browser caching not enabled and server response times will require changes to your web server setup or core server configuration.

Image optimisation is achievable with free image tools.

CSS, Javascript and HTML optimisation and full page caching requires some extra Magento tweeking.

Magento CSS, Javascript and HTML optimisation

Depending on your Magento theme there can be a lot of javascript and CSS includes in your source html. Best practice is to configure Magento to combine CSS and Javascript into one file. You do this by enabling JavaScript and CSS merge in System -> Configuration -> Advanced -> Developer. You should also then install Fooman Speedster Advanced which will also minify JavaScript and CSS.

This process works well,  but by default Magento will insert all your JS and CSS into the header of the rendered webpage. The best practice for any CSS or JavaScript that might block the rendering of the webpage (DOM) until they are loaded is to move the JavasScript to the footer of the page.

The Google Pagespeed insights tool will quite likely tell you that you have render blocking JS and CSS.

There are ways of customising the layout of your theme to move certain JS and CSS source files to the footer, in practice this can be complicated because you need to ensure that the loading order of your JavasScript files does not change so that scripts or plugins with dependencies on other JS libraries still run.

The guys at Mediarox have developed a neat solution that simply does a big cut and paste on your html code, finding all JS script and CSS elements, removing them from the header of the html and placing them in the footer.

I was pretty skeptical at first as to how effective this would be, but after installing the module and testing it I couldn’t see any major problems. The Mediarox module doesn’t minify html which was something I had been working on, so I integrated my minify html module into theirs and forked it on github.

My minify module uses the minify code from the Minify project. My version of magento-pagespeed is adapted to work with a modified Lestis full page cache and the Mediarox JS and CSS modules.

Install magento-pagespeed

modman clone https://github.com/gaiterjones/magento-pagespeed

Install the module and configure it at System -> Configuration -> Advanced -> Pagespeed. Here you can enable or disable HTML Minify, JS and CSS optmisation individually. I also added an extra option to disable all modules for logged in users.

If you want to exclude any JS scripts from optimisation enable the exclude list option and add a regex to identify the script.

Magento-pagespeed optimises Magento JS, CSS and html, I then cache the optimised html with Lesti_FPC. When implemented correctly you will see debug comments in the source of the Magento webpage indicating which Pagespeed (PS) module optimisations took place:

<!– +PS JS 28-08-2015 07:50:04 4ms –>
<!– +PS MIN_HTML 28-08-2015 07:50:04 30ms –>
<!– +FPC 28-08-2015 07:50:04 –>

Here we see PS JS and PS MIN_HTML are enabled. The JS optimisation took 4ms, the HTML minify code took 30ms. the html was then cached by Lest_FPC.

Moving the JS to the footer really helps to improve render blocking and this is reflected by the Pagespeed Insights tool running on my dev site :

We can see that there are still render blocking issues and you need to experiment with CSS optimisation for your theme, a side effect of moving all CSS to the footer is that your page may load with some default styles until the CSS is loaded, leading to an ugly transition from unstyled to styled elements on the page. You can see how highly these issues are ranked by Google, render blocking CSS and Javascript that could be further compressed by 2% (1.3 Kb) is costing me 7 points on the insight scale and stopping me from getting to 100/100.

Could I get to 100/100, probably but 93 is still a pretty good result I think.

Resources

• magento-pagespeed
  • js, css, html optimisation module adapted from Mediarox Pagespeed
  • installation
    • modman clone https://github.com/gaiterjones/magento-pagespeed
• Lesti FPC
  • adapted to work with magento-pagespeed
  • installation
    • modman clone https://github.com/gaiterjones/Lesti_Fpc

If you want to show your grouped product lowest price including tier prices you need to modify price.phtml in app/design/frontend/yourtheme/default/template/catalog/product

If you edit price.phtml and scroll to the bottom you will see the logic for grouped products and the getDisplayMinimalPrice html. Add the code below just above the line with $showMinPrice = $this->getDisplayMinimalPrice();

This will get all the prices associated with the grouped product and set the lowest to be displayed as the miminal or “starting as” price. You can see this working here http://dev.gaiterjones.com/magento/catalogsearch/result/?q=1114 where the starting price is 99 – the lowest tier price. Without this modification the starting price is shown as the lowest unit price.

			// get lowest price from tiers

			$_groupedProductChildPrices=array();

			// get child products of grouped product
			//
			$_childProductIds = $_product->getTypeInstance()->getChildrenIds($_product->getId());

			foreach ($_childProductIds as $_ids) {

				foreach ($_ids as $_id) {

					$_childProduct = Mage::getModel('catalog/product')->load($_id);

					// get all associated group product pricing, including tier prices
					$_groupedProductChildPrices[] = $_childProduct['price'];

						if($_childProduct->getTierPrice() != NULL) {
							foreach($_childProduct->getTierPrice() as $tier){
								$_groupedProductChildPrices[]= $tier['price'];
							}
						}

				}
			}

			// set lowest price and reset minimal price variables
			//
			$_lowestGroupProductPrice=min($_groupedProductChildPrices);

			$_minimalPriceValue = $_store->roundPrice($_store->convertPrice($_lowestGroupProductPrice));
			$_minimalPrice = $_taxHelper->getPrice($_product, $_minimalPriceValue, $_simplePricesTax);