The Client

Clickable Automotive is a highly specialized online car parts store that targets the European automotive enthusiasts from Australia, New Zealand and surrounding countries.

If you need quality parts for your BMW for instance, you’ve found it: clickableautomotive.com.au. In no time you will also find parts for your Audi, Volkswagen and other European makes and models.

Lucas O’Brien is the Managing Director of the company located in Port Melbourne, Australia. Since the beginning, it was clear to us how knowledgeable and passionate he is about his business as well as his commitment to quality.

The store’s look-and-feel made it obvious that we were dealing with a business that is well aligned with the modern web and has a very refined taste for design. I must give the credits for the design to Gabe Lopez from Brave Nu Digital. Great work guys!

The Project

Lucas approached us with a recently developed store-front with a hybrid Magento and WordPress integration. He wasn’t overly happy with some User Experience details and wanted to make sure that the SEO best practices were in place to accelerate growth, achieve better rankings and establish an improved conversion rate from the beginning.

Inchoo’s Approach

At Inchoo, we get a lot of enquires for fixes and modifications. Sometimes, behind a small fix or apparent contained issue, lies a hacked Magento core, tons of extensions and badly written custom features – which often gets you into a scenario where you fix one problem followed by three new ones in a never ending loop.

That is the reason why we prefer not to try to win the deal with deliberate low-cost “guesstimates”. If we can not ensure quality and a perfectly stable and bug-free Magento store, we would rather not get the job. That’s part of our commitment to our clients’ satisfaction.

For most existing Magento stores and modules/extension fixes we prefer to provide our estimate after taking a good look at it. We call it the ‘Assessment Approach’.

During the assessment phase, we do a complete screening of Magento’s current situation:

• Magento core files, theme and configurations;
• Custom features and modules;
• User Experience;
• Complete in-site/off-site SEO;
• Conversion analysis.

The deliverables at this stage are a full report on the findings with our suggestions for improvements and a quote for achieving all the initial requests and recommended improvements.

This assessment phase happens before any work is done. For Clickable Automotive, we assigned two of our Magento Certified Developers: Ivan Weiler and Domagoj Potkoc to the development side assessment.

Toni Anicic conducted the on-site/off-site SEO assessment while I performed the UX and E-Commerce Design analysis.

The whole process was very transparent and Lucas didn’t have any trouble to provide us with instant feedback and establish excellent communication with our team.

This approach has been proven to be the most effective, especially when both sides envision the long-term relationship. During the assessment, we will understand the client’s business objectives better while the client will receive valuable advice on how to get the most out of Magento. At the end, we will achieve mutual understanding on how to work together, build trust and make data-driven decisions for the next steps.

Our Findings

Development

From the Magento’s back-end standpoint, the store was in pretty good shape. While the theme coding needed some polishing, the Magento Core was untouched – which is a great thing.

Clickable Automotive was a hybrid of Magento and WordPress. All the articles and content pages were being handled on WordPress, while Magento was used only for the shop. The integration needed some polishing to ensure stability, upgradability and make it seamless from the user standpoint.

To mention the two most important issues: the search functionality was not showing results from articles and products. Secondly, the user couldn’t readily know if he was logged in or not on his Magento account and, when logged in, he could not log out.

Our team also suggested a few configuration adjustments and a few front-end observations.

SEO

Toni has found a few important changes to be made. Firstly, the category navigation were passing more than 8000 uniques URLs to Google, which is a lot for a store in its early days with around 102 products and a handful of blog posts. The majority of these links were serving duplicated content due to the way the layered navigation were implemented.

At that time, the website had just been launched, which explains why many SEO measures were not in place yet. Such as: the rel=prev and rel=next pagination attributes and many other details, such as the meta tags, meta titles and so on.

User Experience/Design

Even before starting this part of the assessment, we already had the client’s heads-up regarding the most important issues that were related to the WordPress + Magento integration. Such as the problem with the ‘My Account’ accessibility and the search feature.

Overall, the design is clean, modern and well aligned to the business goals and targeted audience. However, it wasn’t clear at the first glance that it was mainly an online store. Let’s see the wire-frames:

Home-page

We suggested the inclusion of featured products on the home-page together with the ‘Quick Finder’ feature, in an effort to make a clear statement that we sell car parts. Before, you could only see products under the ‘Products’ tab, which was also replaced by ‘Store’.

Header

We suggested to add a drop-down shopping cart in the header.

Category Page

On the category page, we suggested the inclusion of the ‘Sales and Assistance’ banner in an effort to improve trust and ensure the visitor has the assistance number handy.

Other than that, we advised about a few minor details that were mostly related to contrast and minor e-commerce particularities. We also suggested a few minor improvements to the product rollover with the addition of a button for the link to the product page. A more clear organization of the elements was also suggested for the product page.

Assessment Conclusions

As explained at the beginning of this article, the assessment would bring the full report on the findings and the quote for completion of the requested and suggested tasks. In Clickable Automotive’s case, we had to decide how to proceed in regards to the WordPress + Magento Integration and the ‘Quick Finder’ feature. After that, it is just a matter of doing the work.

WordPress + Magento Integration

We often come across WP + Magento integrations. It is always a bit tricky to make the integration of Magento with WordPress seamless. We have performed this many times and are still doing it. However, we advise our clients that it brings another layer of issues when upgrading the two CMS and adding features, in most cases it is not really needed.

From the administrative standing point it makes maintaining your website a bit more complex than it already is. The client needs to log into two different admin panels, one to add articles and another to manage the shop.

If the plan is to blog one or two times per week then it may not be worth going through the trouble and it would be more beneficial to have a store that will be much faster, more manageable, cheaper to maintain, easier to upgrade and to include more features.

On the other hand, if you have somebody posting articles in a daily basis and your blog is responsible for a considerable amount of your traffic, you are right to go with the WordPress integration, you will definitely miss a few WordPress features.

Then, we could polish the WordPress integration or move away from WordPress and use a the aHeadWorks Blog Extension. Lucas chose to adopt a Magento Blog Extension, leaving WordPress behind – it just makes sense in this case.

Quick Finder Feature

The development of the Quick Finder module requires a project of its own. We even considered integrating it with an external database to populate the part numbers and the technical specification of each item. Although it is achievable, it would make more sense to look at it at a later stage, once the store has achieved a greater variety of products.

Lucas suggested that we provided an estimate for the development of the feature without the integration and considered the utilisation of third-party extensions. If we could find one extension that works well and suffice to our immediate needs, we could look into developing a tailored solution in a few months, after the new store has started generating a revenue that justifies it. Wise decision, totally supported by our team.

We were all in agreement and tested a handful of extensions where Lucas could understand how each one worked and how they would influence the site administration and product inclusion.

In order to do that, we install the extension on a clean Magento installation, understand how it works and test its functionalities. If it looks ok, we install on our production branch, then test again. Just to make sure it does not conflict with other custom features and extensions.

Thankfully, we found one extension that does the job. Although it adds a few extra steps when adding products to the store, we found an excellent starting feature.

The Job Execution

I have been mostly involved in the UX assessment, management tasks while promoting the communication between the team and the client. It was a great experience and I am very proud of the collaboration and results achieved.

Vanja Devcic one of our most experienced front-end developers showed great organisational skills. He has taken the lead during most of the project execution, handled all the communication with the client and provided Lucas with the support he needed to make decisions and achieve the most suitable solution when adjustments were needed or an additional requirement was brought in.

It is also important to mention that this project was ‘man-powered’ by the Certified Magento Developers: Ivan Weiler and Domagoj Potkoc, members of the Casablanca team.

Interview

To give you a clearer picture of how the project went we asked Lucas to write a few words about his experience.

Lucas, would you be able to give us a few words about your experience with Inchoo and your view on the approach to the project?

Sure, working with everyone at Inchoo has been awesome. I originally discovered Inchoo while making the decision to use Magento as our eCommece platform, and some of your blog posts were a big help in guiding our decision. When we launched the original site back in late November last year – we immediately found we were on the back foot chasing a whole list of issues without anyone to support us. Lyssandro was one of the first people I reached out to – to help me get things under control. Right away the suggested approach showed maturity and we quickly connected with the same point of view and understanding of our goals. During the whole process communication was exceptional, and I am thankful to everyone that was willing to take the time to help me understand the technical side of the decisions we were making.

How would you qualify our methodology? What are the strongest or weakest points

What I most respect about Inchoo is their approach to quality, the great team of people and their desire to share knowledge through their blog. It’s great for me to have confidence in the team knowing they’re committed to quality and to ensure we end up with the final product we are looking for.

We are always open for learning, what do you believe could have been done differently?

It would be great to see you switch from using activeCollab to Basecamp in the future.

Given that you are located in Melbourne, Australia; the I am in Sydney and the developers are in Croatia; did you encounter any communication or time difference challenges?

No, not really – I was satisfied with the overlap we had in our time zones to be able to effectively communicate with the team in Croatia.

Do you regret not keeping the WordPress integration? Is there any special feature that you miss?

The backend in WordPress was nice – but otherwise the integration between the two was really clumsy, and it’s a relief to not have to worry about it anymore.

Lastly, our developers want to know when are we going to develop our own ‘Quick Finder’ module? =D

Haha! Certainly developing our own ‘Quick Finder’ is something we will need to discuss implementing further down the road, and I know you and the team are really excited to get started working on it! Me? I just look forward to never having to see another CSV file in my life!

In Response…

To be honest, I also find Basecamp much easier to use – in fact, we were using Basecamp until the end of last year. The reason why we use activeCollab now is that it has a powerful reporting tool and administration features that help us to keep better track of the project progress.

We made this move in anticipation for the ActiveCollab Version 3 that is going to be released soon. It will bring many improvements and we are confident that it will be much easier to use.

Regarding the custom ‘Quick Finder’ development – we understand your position and we will patiently look forward to it. Custom module development is the work and the hobby for most of our developers, that’s all.

I would like to thank you for your collaboration and for the opportunity to work on this project. Clickable Automotive was our first Australian launch and a great start for Inchoo Australia. I hope we will continue collaborating and growing our businesses together for years to come.

Features

• Automatically gets all the photosets from the specified user and makes them available in Magento back-end
• Allows you to choose which photosets you want to display on the site
• Configurable pagination
• Configurable thumbnail size
• Configurable tooltips with different skin styles to choose from
• Integrated Lightbox that can be disabled if you want to use your own
• Fully customizable carousel block that can be added to any page
• Fully customizable Flickr API response caching for increased performance
• Using AJAX to eliminate the page loading delay caused by Flickr API requests

How to install?

Download Inchoo Flickr Gallery extension files to your Magento root directory. You can find it on github at https://github.com/srka/Inchoo-Flickr-Gallery. Extension files will be extracted into the base package / default template so if you have your own package just copy the extension files to your package / template directories.

If you are logged in to your Magento back-end you have to log out and then log in again. Clearing the cache would also be a good idea.

Configuration

Inchoo Flickr Gallery extension is made to be fully and easily configurable from Magento back-end. Just go to System -> Configuration -> Inchoo -> Flickr Gallery to find all the available configuration options.

To get started you’ll need to have a Flickr API Key and User ID. Go to http://www.flickr.com/services/api/misc.api_keys.html to get your own Flickr API Key and http://idgettr.com/ for your User ID. Once you enter your API Key and User ID save your configuration and you will get the list of all the photosets available for the user specified with the User ID. You can select all of them or just the ones you want to show on the site and save your configuration. That should be enough get the gallery up and running.

All other configuration options are pretty straightforward with useful descriptions so there is no need to explain them separately.

How to access the gallery on the front-end?

By default, Inchoo Flickr Gallery extension adds a link to the footer but you can open the gallery directly at www.yoursite.com/gallery

Screenshots

Having a quick and on time access to your Magento website logs can sometimes be crucial to your business. Since Magento does not have native way of reading log files other than accessing them trough FTP/SSH, Magentic is here to fill in the blank. Just touch the screen of your iOS based device and your logs are here.

We prepared a short demo / promo video:

Outstanding features:

• Quick, simple and user friendly access to latest Magento log file entries
• Add multiple Magento installations, not limited to just one
• View aggregated log messages from all var/log/*.log files
• Get basic Magento version/edition info
• Get total customers/orders/newsletter-subscribers info
• Get list of existing websites and their stores
• Email your developer/friend/coworker specific log message

Cool, I want it! Where do I start?

1. Get Magentic from iTunes or Google Play ( just $1.99 )
2. Get Inchoo_Magentic Magento extension from Magento Connect ( free )
3. Configure iOS Magentic app to point to your Magento store
4. Enjoy using the app…

Support

If you have some support or Q&A questions for Magentic please write on magentic@inchoo.net or contact the Magentic team trough Twitter. We will give our best to reply if possible.

In case you need extra info about the Inchoo_Magentic extension here is the Google Document link with detailed description of extension. And below are some screenshots of the Magentic iOS app.

Screenshots

The idea

Magento 1.6 and earlier
The general idea is to use static blocks because they are easily editable and can hold many different types of content. The problem with static blocks is that you cannot assign them directly to product categories in Magento, or can you? Here’s an idea, set the “Identifier” value of the static block to be the same as the “URL Key” of the desired category. Now you have a logical connection between your static block and a product category. We just have to display the appropriate static blocks in the main navigation drop-down.

Magento 1.7
Now, in version 1.7 Magento introduced a completely new way of rendering menu items (thanks Johnboy for reminding me) that require some changes for this to work. The general idea is the same as above (for Magento 1.6) but this time we need to use something else instead of “URL Key” to connect our static block to a category. This time we will use the category ID value with a simple string prefix.

The implementation

Magento 1.6 and earlier
To implement this simple idea we need to override a core Magento block class and add a few lines of code to a single function. How simple is that

1. First we need to override the core Magento block class by copying the block file from core to local folder. We are going to use “Mage_Catalog_Block_Navigation”class so we need to copy:

   /app/code/core/Mage/Catalog/Block/Navigation.php

   to

   /app/code/local/Mage/Catalog/Block/Navigation.php

   If you don’t have a folder structure in your local folder you will need to create it.

2. Find the protected function _renderCategoryMenuItemHtml (should begin at around line 218). This is the function that will render all the menu items which is exactly what we need.
3. Now find this piece of code (lines 309-312):

   
   $html[] = '<ul class="level' . $level . '">';
   $html[] = $htmlChildren;
   $html[] = '</ul>';
   

4. Add the following code just above the line with the closed ul tag:

   
   $staticBlock = trim($this->getLayout()->createBlock('cms/block')->setBlockId(strtolower($category->getUrlKey()))->toHtml());
   if(!empty($staticBlock)){
   	$html[] = '<span class="nav-static-block" style="background:#fff; border-top:1px solid #ccc; padding:10px;">';
   	$html[] = $staticBlock;
   	$html[] = '</span>';
   }
   

   The end result should look like this:

   
   $html[] = '<ul class="level' . $level . '">';
   $html[] = $htmlChildren;
   $staticBlock = trim($this->getLayout()->createBlock('cms/block')->setBlockId(strtolower($category->getUrlKey()))->toHtml());
   if(!empty($staticBlock)){
   	$html[] = '<span class="nav-static-block" style="background:#fff; border-top:1px solid #ccc; padding:10px;">';
   	$html[] = $staticBlock;
   	$html[] = '</span>';
   }
   $html[] = '</ul>';
   

   The implementation is simple, check if there is a static block with the identifier value that is the same as the current category URL Key. If so, add the static block to the menu.

   I used some inline CSS for the sake of simplicity but you should use your own.

5. Now you need to create a static block with the identifier value set to whatever category URL Key you want and you are all done! I used the default Magento sample data and created a static block with the identifier set to “furniture” because that is the URL Key of the Furniture category.

Magento 1.7
This time we need to override a different Magento core class because in 1.7 Magento uses  Mage_Page_Block_Html_Topmenu to render the main menu.

1. First we need to override the core Magento block class by copying the block file from core to local folder. We need to copy:

   /app/code/core/Mage/Page/Block/Html/Topmenu.php

   to

   /app/code/local/Mage/Page/Block/Html/Topmenu.php

   If you don’t have a folder structure in your local folder you will need to create it.

2. Find the protected function _getHtml (should begin at around line 84).
3. Now find this piece of code (lines 121-123):

   
   $html .= '<ul>';
   $html .= $this->_getHtml($child, $childrenWrapClass);
   $html .= '</ul>';
   

4. Add the following code just above the line with the closed ul tag:

   
   $staticBlock = trim($this->getLayout()->createBlock('cms/block')->setBlockId($child->getId())->toHtml());
   if(!empty($staticBlock)){
   	$html .= '<span style="background:#fff; border-top:1px solid #ccc; padding:10px;">';
   	$html .= $staticBlock;
   	$html .= '</span>';
   }
   

   The end result should look like this:

   
   $html .= '<ul class="level' . $childLevel . '">';
   $html .= $this->_getHtml($child, $childrenWrapClass);
   $staticBlock = trim($this->getLayout()->createBlock('cms/block')->setBlockId($child->getId())->toHtml());
   if(!empty($staticBlock)){
   	$html .= '<span class="nav-static-block" style="background:#fff; border-top:1px solid #ccc; padding:10px;">';
   	$html .= $staticBlock;
   	$html .= '</span>';
   }
   $html .= '</ul>';
   

   The implementation is simple, check if there is a static block with the identifier value set to current category ID with a prefix “category-node-”. If so, add the static block to the menu. The prefix is used because if you inspect the value of $chlid->getId() you will see that it returns a category ID with that prefix so, for example, if the category ID is “10″ you will get “category-node-10″. I used this value because it is unique for each individual category.

   I used some inline CSS for the sake of simplicity but you should use your own.

5. Now you need to create a static block with the identifier value set to whatever category Prefix+Category ID you want and you are all done! I used the default Magento sample data and created a static block with the identifier set to “category-node-10″ because Furniture category has the id of 10. That’s it.

Hope you’ll find this post helpful.

So if there are no constant new orders and/or new customers, I can not test my APNS integration.

At first I started to enter orders and customers manually on dev server, but it took much time, so I decided to do something to solve it.
After some searching, i didn’t find the suitable extension to solve automatic creation of customers and orders as I need, so that’s the reason a new extension was made.

So let me list the features that I needed in new extension:

• Automatic creation of random customers with fully random names and addresses, e-mail adresses and other random personal data.
• Automatic creation of orders with random order items in basket.
• Automatic shipment
• Automatic invoice
• Make all of this features random
• Work with cron job, so generation is happening periodically (every minute, or depends how my Magento cron is set).

One interesting thing that I found when searching inside Magento core source code is a class Mage_Adminhtml_Model_Sales_Order_Random.

When I looked in code, it was obvious for me that this class was made for some purpose, but when trying to find where this class is used, I didn’t find nothing. Anyway, I decided to try this class to see if it works well, but this class has some serious issues in code that have to be rewritten in order to make it work.

So, here is my new order creation source code:

<!--?php <br ?-->
/*
 * @category Inchoo
 * @package Inchoo_Demostore
 * @author Darko Goleš
 * @copyright Inchoo
 * @license http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 */

class Inchoo_Demostore_Model_Sales_Order_Random {

    protected $_quote;
    protected $_order;
    protected $_store;
    protected $_customer;
    protected $_productCollection;
    protected static $_storeCollection;
    protected static $_customerCollection;

    public function __construct() {
        $this->_quote = Mage::getModel('sales/quote')->save();
        $this->_order = Mage::getModel('sales/order');
    }

    protected function _getStores() {
        if (!self::$_storeCollection) {
            self::$_storeCollection = Mage::getResourceModel('core/store_collection')
                    ->load();
        }
        return self::$_storeCollection->getItems();
    }

    protected function _getCustomers() {
        if (!self::$_customerCollection) {
            self::$_customerCollection = Mage::getResourceModel('customer/customer_collection')
                    ->addAttributeToSelect('*')
                    ->joinAttribute('billing_country_id', 'customer_address/country_id', 'default_billing', null, 'inner')
                    ->joinAttribute('shipping_country_id', 'customer_address/country_id', 'default_shipping', null, 'inner')
                    ->load();
        }

        return self::$_customerCollection->getItems();
    }

    protected function _getProducts() {
        if (!$this->_productCollection) {
            $this->_productCollection = Mage::getResourceModel('catalog/product_collection');
            Mage::getSingleton('catalog/product_status')->addVisibleFilterToCollection($this->_productCollection);
            $this->_productCollection->addAttributeToSelect('name')
                    ->addAttributeToSelect('sku')
                    ->addAttributeToFilter('type_id', Mage_Catalog_Model_Product_Type::TYPE_SIMPLE)
                    ->load();
        }

        return $this->_productCollection->getItems();
    }

    protected function _getCustomer() {
        if (!$this->_customer) {
            $items = $this->_getCustomers();
            $randKey = array_rand($items);
            $this->_customer = $items[$randKey];
        }
        return $this->_customer;
    }

    protected function _getRandomProduct() {
        $items = $this->_getProducts();
        $randKey = array_rand($items);
        return isset($items[$randKey]) ? $items[$randKey] : false;
    }

    protected function _getStore() {
        if (!$this->_store) {
            $items = $this->_getStores();
            $randKey = array_rand($items);
            $this->_store = $items[$randKey];
        }
        return $this->_store;
    }

    public function createOrder() {
        $customer = $this->_getCustomer();

        $this->_quote->setStore($this->_getStore())
                ->setCustomer($customer)->setCustomerIsGuest(0);
        $this->_quote->getBillingAddress()->importCustomerAddress($customer->getDefaultBillingAddress());
        $this->_quote->getShippingAddress()->importCustomerAddress($customer->getDefaultShippingAddress());

        $productCount = rand(3, 10);
        for ($i = 0; $i < $productCount; $i++) {             $product = $this->_getRandomProduct();
            if ($product) {
                $product->setQuoteQty(1);

                $stockData = $product->getStockData();
                if (!$stockData) {
                    $product = $product->load($product->getId());
                    $stockData = array(
                        'manage_stock' => 1,
                        'is_in_stock' => 1,
                        'qty' => 1
                    );

                    $product->setStockData($stockData);
                    $product->save();
                }
                $this->_quote->addProduct($product);
            }
        }

        $this->_quote->getPayment()->setMethod('checkmo');
        $this->_quote->getShippingAddress()->setShippingMethod('flatrate_flatrate'); //->collectTotals()->save();
        $this->_quote->getShippingAddress()->setCollectShippingRates(true);
        $this->_quote->collectTotals()
                ->save();
        $this->_quote->save();

        $service = Mage::getModel('sales/service_quote', $this->_quote);
        $service->submitAll();

        $order = $service->getOrder();
        $rand = rand(1, 4);

        switch ($rand) {
            case 1:
                $this->invoiceOrder($order);
                break;
            case 2:
                $this->shipOrder($order);
                break;
            case 3:
                $this->invoiceOrder($order);
                $this->shipOrder($order);
                break;
            default:
                break;
        }

        return $this;
    }

    protected function invoiceOrder($order) {

        try {

            if (!$order->canInvoice()) {
                $order->addStatusHistoryComment('Inchoo_Invoicer: Order cannot be invoiced.', false);
                $order->save();
            }

            $invoice = Mage::getModel('sales/service_order', $order)->prepareInvoice();

            $invoice->setRequestedCaptureCase(Mage_Sales_Model_Order_Invoice::CAPTURE_OFFLINE);
            $invoice->register();

            $invoice->getOrder()->setCustomerNoteNotify(false);
            $invoice->getOrder()->setIsInProcess(true);
            $order->addStatusHistoryComment('Automatically INVOICED by Inchoo_Invoicer.', false);

            $transactionSave = Mage::getModel('core/resource_transaction')
                    ->addObject($invoice)
                    ->addObject($invoice->getOrder());

            $transactionSave->save();
        } catch (Exception $e) {
            Mage::logException($e);
        }
    }

    protected function shipOrder($order) {

        try {
            $shipment = $order->prepareShipment();
            $shipment->register();

            $order->setIsInProcess(true);
            $order->addStatusHistoryComment('Automatically SHIPPED by Inchoo_Invoicer.', false);

            $transactionSave = Mage::getModel('core/resource_transaction')
                    ->addObject($shipment)
                    ->addObject($shipment->getOrder())
                    ->save();
        } catch (Exception $e) {
            Mage::logException($e);
        }
    }

}

As you can see from source code, invoice and shipment will not be generated every time, but random sometimes shipment, sometimes order, sometimes both and sometimes nothing.

       $order = $service->getOrder();
        $rand = rand(1, 4);

        switch ($rand) {
            case 1:
                $this->invoiceOrder($order);
                break;
            case 2:
                $this->shipOrder($order);
                break;
            case 3:
                $this->invoiceOrder($order);
                $this->shipOrder($order);
                break;
            default:
                break;
        }

There are bunch of articles here on inchoo.net about programatically creating orders and/or customers, so this article is not about how to do it, but rather to inform the community that the extension that I am talking about is available on Magento Connect under name: Inchoo Demostore, so, Dear developers, if you need to save some time, feel free to install it to dynamically – periodically create new customers and orders on your development or some demo server.

I am aware that this extension can be improved with possible configuration options added, maybe on admin side, adding additional features for creating orders, random quantities for order items, but, hey – this extension is made for developers to save their time, and I don’t see a problem if someone wants to improve it. For me, it it enough to give fresh data to demo store for Mageboard Application.

Cheers.

Some of key features:

• Autodetects the mobile device
• jQuery mobile (v. 1.1.0)
• Homepage slider (http://swipejs.com/)
• Almost all pages styled

Installation is simple, just copy downloaded files, (app, skin) after that go to administration and do some Magento magic. Magento already have browser detection, you only need to create rule. In our case we dropped table support because most of them will display normal desktop view store. Here is rule:

iPhone|iPod|BlackBerry|Palm|Googlebot-Mobile|mobile|mobi|Windows Mobile|Safari Mobile|Android|Opera Mini|Fennec

You can add any other browser to this Expression, just point your device to http://whatsmyuseragent.com/ and find out user agent name of device browser. And this is how it looks in administration

Using expressions

We need to mention that theme is independent from main store theme, all files which are edited don’t “break” default Magento markup we are only using power of HTML5 and one of the new cool feature “custom data attributes“.

Simply, the specification for custom data attributes states that any attribute that starts with “data-” will be treated as a storage area for private data (private in the sense that the end user can’t see it – it doesn’t affect layout or presentation).

Short explanation by John Resig

And here is our example for store header:

</pre>
<div data-role="header" data-position="inline" data-theme="c">
<h1><a href="<?php echo $this->getUrl('') ?>" data-icon="home">
<img src="<?php echo $this->getLogoSrc() ?>" alt="<?php echo $this->getLogoAlt() ?>" /></a></h1>
<!--?php echo $this----->getChildhtml('top-user');?></div>
<pre>

We don’t have any local hosted files regarding to jQuery because it is much easier to edit and place the newest version of js.

					<![CDATA[<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script><script type="text/javascript">jQuery.noConflict();</script>]]>
					<![CDATA[<script type="text/javascript" src="http://code.jquery.com/mobile/1.1.0/jquery.mobile-1.1.0.min.js"></script>]]>
				<![CDATA[		<link rel="stylesheet" href="http://code.jquery.com/mobile/1.1.0/jquery.mobile-1.1.0.min.css" />]]>
            skin_jsjs/swipe.js

Ah, if you need more info about jQuery mobile framework go to: http://jquerymobile.com/.

Swipe JS, http://swipejs.com/,

Swipe is a lightweight mobile slider with 1:1 touch movement, resistant bounds, scroll prevention, and completely library agnostic. .

Ok, we made simple approach, create static block, named Slider with ID slider and place this code

</pre>
<div style="display: block;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<div style="display: none;"><img src="{{media url=" alt="" /></div>
<pre>

If is there no needs for homepage slider just removed it from local.xml (from line 44).

For styling pages, we cover most of them but there is always more space to improve some part of Magento interface.

For demo and download go to our demo store http://imobile.inchoo4u.net with your smartphone, emulate in browser (change user agent), visit @ github, or just scan this QR code.

So if you have any suggestion, issues, trouble just comment below, enjoy

I will tell you a secret of how I managed NOT to get negatively affected by any Google’s update since I started in the world of SEO back in 2005. I fear no Pandas, Penguins or Maydays and this is why:

I only do white-hat SEO. I read official Google blogs, watch their official videos and do what they tell us to do. It’s so simple, yet so many SEOs don’t get it.

The SEO industry is pretty big, yet I can see some official Google videos explaining some really useful things with just a few thousand views. Why don’t you listen to them? They are trying to help you. They tell you exactly what they want SEOs to do and SEOs just don’t wanna listen.

When the Panda hit, I thought people will finally get it, but nop, they continued using spammy SEO tactics. I fear Penguin update will be no different and that a big majority of SEOs out there will still use spammy SEO tactics.

So listen to key advice on your SEO tactics by a person who survived all of the Google’s updates since 2005. These are the top 3 things you need to do:

1. Create awesome content:

You heard it lots of times – content is king. Let me say it again: content is king. Repeat after me: content is king. What is content? It’s text, it’s images, it’s videos. What should this content consist of? It should consist of exactly what your visitor is searching for. Nothing more and nothing less. No magical formula for keyword density or number of images or amount of text. Just write / make exactly what your visitors need and that’s it!

Why does this work and why it will not hit me on the next Google update?

Because Google wants to deliver the best content for the search phrase the user has entered. If you have the best content for the query, Google is trying really hard to optimize the algorithm so that YOUR content is on the number one spot.

2. Promote awesome content but don’t spam:

We all want to see awesome stuff. This is why promoting awesome content is good. We don’t want to get spammed. This is why you shouldn’t spam.

Why does this work and why it will not hit me on the next Google update?

Because Google’s algorithms are not so advanced that they can know what’s the best content, they need to rely on content’s popularity. If you promote it to your audience and your audience likes it – retweets it, likes it on facebook, +1s it, links to it) its a sign to Google that they are satisfied with your content. But don’t spam them since Google cares about their searchers and wouldn’t like to show them on a number one spot for their query a website that got there due to spam and not due to having the best content.

3. Make your website’s navigation logical and easy to use:

Make important pages accessible. Make it easy for someone who landed “in the middle of your website” to figure out where he is and easily navigate from there. Make your site structure logical for the user, and Google will love it. Making unnatural anchor text link patterns will not help you in the long run.

Why does this work and why it will not hit me on the next Google update?

If user can easily find what he’s looking for, so will Google. If you make user happy, you make Google happy. It’s very simple. If you make navigation for Google and not for user, Google will not like it.

The number one question you need to ask yourself if you are getting outranked by your competitors:

1. Do I have the best content for that query?

It’s that simple. It’s the most important question to ask yourself. Don’t try to rank bad content. Don’t try to rank wrong content for the query. If your content sucks, create new content which is a better fit for the query.

And now you know. Now you know how to survive the Zebra attack that Google will eventually release and hit the SERPs (yea, these updates are usually named after black and white animals ). I’d say “good luck”, but if you listen to this advice, you will not need it.

First of all, let’s create new Android project, I set it to be for android 2.3.3. After creating new project, we need to download and import ksoap2-android library inside the project and add it to build path.

Ksoap2-android library can be downloaded from here (http://code.google.com/p/ksoap2-android/downloads/detail?name=ksoap2-android-assembly-2.4-jar-with-dependencies.jar&can=2&q=)

When download ksoap2-android-assembly-2.4-jar-with-dependencies.jar, make additional folder inside your android project, call it for example “lib” and paste ksoap2-android-assembly-2.4-jar-with-dependencies.jar there.

After that, right click on pasted file in package explorer (assuming that you are using Eclipse) and choose: Build Path -> Add To Build Path.

Of course, If we want to access Magento web services SOAP API, we need to go to Magento installation’s admin area and under System/Web services/Roles create Role with appropriate resources (for development purpose, we can mark them all), and then System/Web services/Users create new API user.

After that we need to assign roles we created to user in order to make the whole thing work. We will need user-name and apiKey from there to be able to log-in with our SOAP client.

Now, we are ready to start developing out test application.

As I said, this example is for tutorial purposes – only, and it’s not right way to make Http requests from main Activity, but is just for purposes of this article, so we will now write out code inside Main Activity’s onCreate method:

package com.soap.test;

import java.io.IOException;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class SoapTestActivity extends Activity {
	/** Called when the activity is first created. */

	private static final String NAMESPACE = "urn:Magento";
	private static final String URL = "http://yourhost.com/api/v2_soap/";

	@Override
	public void onCreate(Bundle savedInstanceState) {

		//our code goes here

		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}

}

Fist we are going to create and set new SoapSerializationEnvelope:

 //...

		try {

			SoapSerializationEnvelope env = new SoapSerializationEnvelope(
					SoapEnvelope.VER11);

			env.dotNet = false;
			env.xsd = SoapSerializationEnvelope.XSD;
			env.enc = SoapSerializationEnvelope.ENC;

		} catch (Exception e) {
			e.printStackTrace();
		}

//...

After that, lets create our request object and assign it to envelope. We are going first to call “login” method to Magento API in order to authenticate and retreive the sessionId.

//...
		try {

			SoapSerializationEnvelope env = new SoapSerializationEnvelope(
					SoapEnvelope.VER11);

			env.dotNet = false;
			env.xsd = SoapSerializationEnvelope.XSD;
			env.enc = SoapSerializationEnvelope.ENC;

			SoapObject request = new SoapObject(NAMESPACE, "login");

			request.addProperty("username", "mobile");
			request.addProperty("apiKey", "mobile123");

			env.setOutputSoapObject(request);

		} catch (Exception e) {
			e.printStackTrace();
		}

		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}

Of course, we have to add request parameters to login method, and it’s done with request.addProperty and then assign request object to envelope.
After that, we need to call SOAP method and retrieve result. so, here is complete Activity source code:

package com.soap.test;

import java.io.IOException;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class SoapTestActivity extends Activity {
	/** Called when the activity is first created. */

	private static final String NAMESPACE = "urn:Magento";
	private static final String URL = "http://yourhost.com/api/v2_soap/";

	@Override
	public void onCreate(Bundle savedInstanceState) {

		try {

			SoapSerializationEnvelope env = new SoapSerializationEnvelope(
					SoapEnvelope.VER11);

			env.dotNet = false;
			env.xsd = SoapSerializationEnvelope.XSD;
			env.enc = SoapSerializationEnvelope.ENC;

			SoapObject request = new SoapObject(NAMESPACE, "login");

			request.addProperty("username", "mobile");
			request.addProperty("apiKey", "mobile123");

			env.setOutputSoapObject(request);

			HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

			androidHttpTransport.call("", env);
			Object result = env.getResponse();

			Log.d("sessionId", result.toString());

		} catch (Exception e) {
			e.printStackTrace();
		}

		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}

}

We retrieved session id as can be seen in LogCat window:

After this basic steps, we just have to make SOAP calls same way to other web service methods, and provide retrieved sessionId in each call.

For example, let’s call customerCustomerList method to retrieve list of customers:

package com.soap.test;

import java.io.IOException;

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import org.xmlpull.v1.XmlPullParserException;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

public class SoapTestActivity extends Activity {
	/** Called when the activity is first created. */

	private static final String NAMESPACE = "urn:Magento";
	private static final String URL = "http://yourhost.com/api/v2_soap/";

	@Override
	public void onCreate(Bundle savedInstanceState) {

		try {

			SoapSerializationEnvelope env = new SoapSerializationEnvelope(
					SoapEnvelope.VER11);

			env.dotNet = false;
			env.xsd = SoapSerializationEnvelope.XSD;
			env.enc = SoapSerializationEnvelope.ENC;

			SoapObject request = new SoapObject(NAMESPACE, "login");

			request.addProperty("username", "mobile");
			request.addProperty("apiKey", "mobile123");

			env.setOutputSoapObject(request);

			HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

			androidHttpTransport.call("", env);
			Object result = env.getResponse();

			Log.d("sessionId", result.toString());

			//making call to get list of customers

			String sessionId = result.toString();

			request = new SoapObject(NAMESPACE, "customerCustomerList");
			request.addProperty("sessionId",sessionId );

			env.setOutputSoapObject(request);
			androidHttpTransport.call("", env);

			result = env.getResponse();

			Log.d("Customer List", result.toString());

		} catch (Exception e) {
			e.printStackTrace();
		}

		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
	}

}

As we can see in LogCat window, we got customer list object with child objects as response.

If you want to find out what methods in Magento API v2 are available and what parameters should be used for request, just open URL: http://yourhost.com/api/v2_soap/?wsdl=1 and you will see all available methods and their request and response parameters that can be used.

Of course, don’t forget to set android.permission.INTERNET in AndroidManifest.xml file.

Hope that you will find this post helpful in own projects. Cheers!

Gravatar URLs are based on the use of the hashed value of an email address. To create accurate hash you need to:

1. Trim whitespace from email address
2. Force all characters to lower-case
3. MD5 hash the final string

#import "GetGravatar.h"
#import <CommonCrypto/CommonDigest.h>

@implementation GetGravatar

+ (NSURL*)gravatarURL:(NSString*)aEmail
{
if (aEmail)
{
NSString *email = [[aEmail stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] lowercaseString];

NSString *emailMD5 = [GetGravatar md5HexDigest:email];

NSString *gravatarString = [NSString stringWithFormat:@"http://www.gravatar.com/avatar/%@", emailMD5];

return [NSURL URLWithString:gravatarString];
}

return nil;
}

+ (NSString*)md5HexDigest:(NSString*)input
{
const char* str = [input UTF8String];
unsigned char result[CC_MD5_DIGEST_LENGTH];
CC_MD5(str, strlen(str), result);

NSMutableString *ret = [NSMutableString stringWithCapacity:CC_MD5_DIGEST_LENGTH*2];

for(int i = 0; i<CC_MD5_DIGEST_LENGTH; i++)
[ret appendFormat:@"%02x",result[i]];

return ret;
}

@end

Next step is to define view in which your graph will be presented and define data which will be shown. Your views class must be CPTGraphHostingView. In my case this is in MBReportViewController.nib. Now create MBBarPlot class. It’s a subclass of NSObject.

MBBarPlot.h

#import <Foundation/Foundation.h>
#import "CorePlot-CocoaTouch.h"

@interface MBBarPlot : NSObject <CPTPlotDataSource>

@property (nonatomic, retain) CPTGraphHostingView *hostingView;
@property (nonatomic, retain) CPTXYGraph *graph;
@property (nonatomic, retain) NSMutableArray *graphData;
@property (nonatomic, retain) INReport *currentReport;

-(id)initWithHostingView:(CPTGraphHostingView *)hostingView andReport:(INReport*)aReport;
-(void)plotSetups;

@end

MBBarPlot.m

#import "MBBarPlot.h"
#import "INReport.h"

@implementation MBSimplePlot

@synthesize hostingView;
@synthesize graph;
@synthesize graphData;
@synthesize currentReport;

- (id)initWithHostingView:(CPTGraphHostingView *)hostingView andReport:(INReport*)aReport
{
self = [super init];

if ( self != nil )
{
self.hostingView = hostingView;
self.graph = nil;
self.graphData = [aReport reportsXYItemEntity];
self.currentReport = aReport;
}

return self;
}

- (void)plotSetups
{
if ( (self.hostingView == nil) || (self.graphData == nil) || (self.graph == nil) )
return;

self.graph = [[CPTXYGraph alloc] initWithFrame:[self.hostingView bounds]] ;
self.hostingView.hostedGraph = self.graph;

// here yo can set graph elements:
// paddings
// line styles
// text style
// min and max values on axis
// title
// axis labels ...

CPTBarPlot *plot = [[CPTBarPlot alloc] init] ;
plot.delegate = self;
plot.dataSource = self;
[self.graph addPlot:plot];
}

-(NSUInteger)numberOfRecordsForPlot:(CPTPlot *)plot
{
return [self.graphData count];
}

-(NSNumber *)numberForPlot:(CPTPlot *)plot field:(NSUInteger)fieldEnum recordIndex:(NSUInteger)index
{
if ( fieldEnum == CPTBarPlotFieldBarLocation )
return [NSNumber numberWithFloat:index*10];
   else
return [NSNumber numberWithFloat:[[[self.graphData objectAtIndex:index] y] floatValue]];
}

@end

In MBReportViewController you need to create instance of your chart with initWithHostingView:andReport: after that call plotSetups where you can set plot frame, plot space, axis set, line style, text style, plot type, legend etc. With Core Plot you can choose various plot types and easily adjust them to fit your needs. Here are the result:

Let’s start from beginning, to everything clear later:

SOAP basics

SOAP = Simple Object Access Protocol. It is based on XML mostly via HTTP (POST).
Soap basic structure is basically Envelope with Header and Body inside:

Soap structure

Some example SOAP message looks like this:

POST /InStock HTTP/1.1
Host: www.example.org
Content-Type: application/soap+xml; charset=utf-8
Content-Length: 299
SOAPAction: "http://www.w3.org/2003/05/soap-envelope"

<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Header>
  </soap:Header>
  <soap:Body>
     <m:GetStockPrice xmlns:m="http://www.example.org/stock">
     <m:StockName>IBM</m:StockName>
     </m:GetStockPrice>
  </soap:Body>
</soap:Envelope>

WSDL

WSDL stands for: “Web Services Description Language”. It is basically XML – based language that is used for describing the functionality offered by a web service.

There are two possible versions of WSDL: WSDL 1.1 and WSDL 2.0. Since Magento uses WSDL 1.1, I will continue with this WSDL version in this article.

Objects in WSDL

Magento Core API

There are two API types present in Magento by default (I am talking about Magento versions 1.6.2CE and below):

• XML-RPC
• SOAP (API v1 and v2)

More on API types and differences you can find in post: Consuming SOAP web services in iOS by Ivan Kalaica

Accessing Magento API via SOAP – basic steps

1. Create appropriate role (Magento Admin)
2. Create web services user (Magento Admin)
3. Assign created role to the user (Magento Admin)
4. Log-in to web service and retrieve Session Id (Soap Client)
5. Call appropriate method (Soap Client)

Creating Web Service Role

First we should define appropriate roles for web services user, so, log-in to admin panel, go to menu: System/Web services/Roles and click on Add New Role button.

On “Role info” tab, we need to enter some custom Role name, and then click on Role resources tab, choose wanted role resources and Save Role.

Role resources necessary for usage with API are basically defined in each Magento module’s api.xml file in etc folder, and can be checked there what role resources are needed for successful consuming specific API method.

Creating Web Service User

After creating role, let’s create web services user that will have defined role permissions.
Go to menu: System/Web Services/Users and click on “Add New User” button. Under “User Info” tab fill the fields, and pay attention that “User Name” and “API key” values are values that we will use on client side to access API.

Assigning created Role to the User

After that, we just have to click on User Role tab and click on radio-button to assign wanted role to current user.
After that we just need to click Save User button.

Calling Magento API v1 methods

<?php

$api_url_v1 = "http://magento.local/api/soap/?wsdl=1";

$username = 'mobile';
$password = 'mobile123';

$cli = new SoapClient($api_url_v1);

//retreive session id from login
$session_id = $cli->login($username, $password);

//call customer.list method
$result = $cli->call($session_id, 'customer.list', array(array()));

Calling Magento API v2 methods

<?php

$api_url_v2 = "http://magento.local/api/v2_soap/?wsdl=1";

$username = 'mobile';
$password = 'mobile123';

$cli = new SoapClient($api_url_v2);

//retreive session id from login
$session_id = $cli->login($username, $password);

//call customer.list method
$result = $cli->customerCustomerList($session_id);

If you compare those two versions of API calls, you will notice that v1 uses method “call” for ever requested method, and v2 has defined full method name to call.

//API v1 way
$result = $cli->call($session_id, 'customer.list', array(array()));

//API v2 way
$result = $cli->customerCustomerList($session_id);</pre>

Basically, API v2 calls method same way like v1, but there is some kind of wrapper around call method in v2. Somebody will ask: Why Magento did something like this? Why would somebody make different methods for accessing API when we have “call” method already?

Here comes the basic difference between v1 and v2 API in Magento.

To demystify that, we should first look at and compare WSDL for v1 and v2 API in Magento.

If we open url: http://yourserver.com/api/soap/?wsdl we can see that few basic method are inside: call, multiCall, login etc…
But, if we look at http://yourserver.com/api/v2_soap/?wsdl, we will find that there is bunch of methods defined inside.

Imagine that you want to use some generator for SOAP methods to auto-generate your client-side classes end entities for consuming web services.
When using WSDL generated for API v1, we could just generate those few methods which will not tell to our source code generator what methods are available, and what parameters for each methods can we use, what entities we should have on client side … but if we are consuming web services through v2 API, it’s already served for us inside WSDL…

Conclusion:

When using Magento v1 API, we access resources via call method and provide API method name and parameters as parameters of call method.

When using Magento v2 API, we access resources via real method name and we provide parameters as defined in WSDL for each specific method.

OK. When we got this difference, and showed how to consume SOAP, let’s focus on creating own web service methods compatible with API v2.

Practical example: Creating own API v2 method

Basic steps:

1. Create Magento Extension (we are not going explain here how to do it)
2. Create Model for API method
3. Create and configure api.xml file
4. Create wsdl.xml file (with proper definitions)
5. Create wsi.xml file (with proper definitions) (OPTIONAL)

Creating Model for API v2

After properly configuring our config.xml it looks like this:

<?xml version="1.0"?>

<config>
   <modules>
      <Inchoo_Mapy>
         <version>1.0.1</version>
      </Inchoo_Mapy>
   </modules>
   <global>
      <models>
         <inchoo_mapy>
             <class>Inchoo_Mapy_Model</class>
         </inchoo_mapy>
      </models>
   </global>
</config>

Let’s navigate through Magento core files to see where Magento API models are in file-system:

Since we are going to use API v2 only, We will create our model like this:

Creating and configuring api.xml

The easiest way is to copy/paste one of Magento’s api.xml files in our etc folder and make changes there to suit our needs. Our final api.xml should look like this:

<?xml version="1.0"?>
<config>
   <api>
     <resources>
     <!-- START GUSTOMER GROUP RESOURCES -->
       <mapy_customer_group>
            <model>inchoo_mapy/customer_group_api</model>
            <title>Inchoo Customer's Groups API</title>
            <acl>mapy_data</acl>
            <methods>
              <list translate="title" module="inchoo_mapy">
                  <title>Retrieve customer groups</title>
                  <method>mapyItems</method>
              </list>
            </methods>
       </mapy_customer_group>
     <!-- END CUSTOMER GROUP RESOURCES -->
    </resources>
    <v2>
      <resources_function_prefix>
           <mapy_customer_group>mapy_customerGroup</mapy_customer_group>
           </resources_function_prefix>
    </v2>
    <acl>
       <resources>
           <mapy_data translate="title" module="inchoo_mapy">
              <title>Mapy data</title>
              <sort_order>3</sort_order>
           </mapy_data>
       </resources>
    </acl>
  </api>
</config>

Here is logic that has to be implemented in api.xml file. Api.xml file basically connects API calls with php methods inside specific models. Also, the ACL resources are defined here for specific api call.

Creating wsdl.xml file

When working with wsdl.xml and wsi.xml later, if you are happy NetBeans user, I strongly suggest you to search on Google and download the XML Tools plug-in that can make life much easier …

There are few things that we have to fill-in when creating wsdl.xml.

• Bindings
• Port types
• Messages
• Types / Complex types

Also, it’s easier to copy one of Magento’s wsdl files, paste it in our etc folder and remove unnecessary things and add our own inside.

Here is NetBeans – XML Tools screen-shot how this look like:

This  image is showing logic and direction how should we fill-in wsdl.xml:

Let’s now look at real xml source:

After we finished with wsdl, let’s go to http://ourmagento/api/v2_soap/?wsdl=1 to see changes in global wsdl we made. (Don’t forget to clear cache first!).

We can see that all wsdl.xml files including ours are rendered as single.

All available wsdl definitions for current Magento installations are shown and our definitions should be there.

Now we are ready to use our newly created SOAP method.

But, if we want use some generator for client classes with that, for example SUDZC (http://sudzc.com) we need to make one more thing in order to make it possible…

WSI

- WSI is in basic compatibility layer for different frameworks and provides a little bit more information that can be used for example with XSLT to transform definitions into our client source code.
- It’s not essential in order web services to work.
- It is rendered when: Magento admin: System/Configuration/Services/Magento core API/WSI-Compliance configuration value is set to “YES”.

We could say that following sections we have to fill-in inside, in order to add our definitions properly:

• Bindings
• Port types
• Messages
• Types / elements
• Types / complex types

Let’s copy/paste one of Magento’s wsi.xml inside our etc folder first. After that, let’s delete all unnecessary definitions for our SOAP method.

Adding definitions inside WSI except for slightly different definitions are basically the same as for wsdl.xml. If you are using existing wsi.xml, it’s easy to delete unnecessary and rename few nodes to suit your needs. Just follow the rule to fill all of this in the above list (Bindings, Port types … ).

Here you can download archive with basic wsdl.xml, wsi.xml, api.xml so you can easier start writing your own web service methods. Just put these files in your etc folder, rename appropriate things with your own and that’s it.

That would be all for now. If interested in Magento API, stay tuned.

Cheers

Directly changing sub-project source files would end up with very painful merging after version control update. Sub-classing default class to add one more property is also painful experience comparing to Objective-C categories pattern (you would need to change class name everywhere you made an instance of default class). It’s true that in class category you can not declare iVar’s or make @synthesize but nevertheless you CAN extend class with another property by drilling down all to runtime.h. Below you can see example.

@interface SomeClass (Private)

@property (nonatomic, assign) id newProperty;

@end

NSString * const kNewPropertyKey = @"kNewPropertyKey";

@implementation SomeClass (Private)

@dynamic newProperty;

- (void)setNewProperty:(id)aObject
{
	objc_setAssociatedObject(self, kNewPropertyKey, aObject, OBJC_ASSOCIATION_ASSIGN);
}

- (id)newProperty
{
	return objc_getAssociatedObject(self, kNewPropertyKey);
}

@end

This way you can have always keep your Xcode sub-project up-to date without painful merging. Also, it’s easier but not recommended to use categories over sub-classing pattern when you need to overwrite default class implementation (good only in cases you know what’s get overwritten).

In contrast to Objective-C class Extensions this way you don’t have to re-declare property that is publicly declared in default class. In Objective-C class Extensions it is also generally common for a class to have a publicly declared API and to then have additional methods declared privately for use solely by the class or the framework within which the class resides. Class extensions allow you to declare additional required methods for a class in locations other than within the primary class @interface block.

@interface MyClass : NSObject

@property (retain, readonly) float value;

@end

// Private extension, typically hidden in the main implementation file.

@interface MyClass ()

@property (retain, readwrite) float value;

@end

@interface MyClass : NSObject

- (float)value;

@end

@interface MyClass () {

    float value;

}

- (void)setValue:(float)newValue;

@end

@implementation MyClass

- (float)value {

    return value;

}

- (void)setValue:(float)newValue {

    value = newValue;

}

@end

The implementation of the setValue: method must appear within the main @implementation block for the class (you cannot implement it in a category). If this is not the case, the compiler emits a warning that it cannot find a method definition for setValue:. Therefore you should use objc_getAssociatedObject & objc_setAssociatedObject to make’s your development way easier.

NEW: Mageboard Lite Now Available!

For those of you who want to see Mageboard in action before you decide to spend the money on it, we created a free application called Mageboard Lite. For feature comparison chart, please see the Mageboard landing page. For the Mageboard Lite app store URL, follow this link.

Customers

Mageboard allows you to get to know your customers better – when have they logged in, how much money have they spent, how many orders have they made, what do they look like and much more. Looking for someone special? Use our quick search. Want to know who is your best customer? It’s only one touch away. Can’t remember the name of the customer? Maybe you know what group they belong to. Mageboard makes it personal – call your customers, send them mail or sms, visit them, you can get directions from our app. It’s almost like a social app! 

Orders

Every time a new order is made, you will get a push notification. Review quickly all your orders – who made it and when, order amount and status. Are you interested only in a specific orders? Use our filter by statuses or advanced filter. Want to see much more details? It’s only one touch away.

Reports

Mageboard has 12 default reports which user can modify, delete, move, print or mail. How many new customers have signed up over the weekend, what was your total order value in the last month, what are your customers searching for most on your site, what were the most viewed products on your site last week? You can prepare any type of report in a matter of seconds and quickly determine where your strengths are, and what needs to be improved. Mageboard is using Core Plot for creating reports. Core Plot is a plotting framework for iOS and OS X. It’s easy to implement and modify, we highly recommend it!

Stay tuned, more killer features are coming up…

REST (Representational state transfer) – first of all requests and responses are built around the transfer of representations of resources. A resource can be essentially any coherent and meaningful concept that may be addressed. A representation of a resource is typically a document that captures the current or intended state of a resource. Main focus – data transfer.

SOAP (Simple Object Access Protocol) brings it’s own protocol and focuses on exposing pieces of application logic (not data) as services. It exposes operations and focuses on accessing named operations, each implement some business logic through different interfaces. That’s why SOAP is considered as successor of XML-RPC and also uses XML to encode its HTTP-based calls. Everything is done via HTTP POST request.

SOAP is mostly used for Enterprise applications to integrate wide types and no. of applications and another trend is to integrate with legacy systems. With that said, consuming SOAP should be an easy task. This is when WSDL comes in story.

WSDL (Web Services Description Language) is an XML-based language that is used for describing the functionality offered by a Web service. A WSDL description of a web service (also referred to as a WSDL file) provides a machine-readable description of how the service can be called, what parameters it expects, and what data structures it returns. It thus serves a roughly similar purpose as a method signature in a programming language.

To conclude introduction part, it’s good to know both of them. Enough with apples and oranges. Let’s see how to consume SOAP in iOS environment.

Having web service interface definition gives us opportunity to generate client side implementation automatically. Sudzc (http://sudzc.com/) is very good example of code generator for accessing SOAP-based web services on iOS platform. It basically generates all the backend part you need for your project. Although there are few things I would change in generated implementation my opinion is that Sudzc is good choice.

You can test Sudzc simply by going to http://sudzc.com/, uploading this WSDL and clicking Generate. Unzip downloaded and you should get fresh generated Xcode project. Open Xcode project and expand Source -> Examples.

As you can see Sudzc has generated all you need to consume SOAP web service, in this case Magento Core API. Find INMagentoService class and there you will see all API methods you can call. In each method you can pass delegate and feedback selector. Below you can see how to retrieve sales orders list.

- (void)salesOrderListCall
{
    INMagentoService* service = [INMagentoService service];

    // Returns NSMutableArray*. Retrieve list of orders by filters
    [service salesOrderList:self
                     action:@selector(salesOrderListHandler:)
                  sessionId:@""
                    filters:[[INfilters alloc] init]];
}

// Handle the response from salesOrderList.
- (void)salesOrderListHandler: (id) value
{
    // Handle errors
    if([value isKindOfClass:[NSError class]]) {
        NSLog(@"%@", value);
        return;
    }

    // Handle faults
    if([value isKindOfClass:[SoapFault class]]) {
        NSLog(@"%@", value);
        return;
    }

    // Do something with the NSMutableArray* result
    NSMutableArray* result = (NSMutableArray*)value;
    NSLog(@"salesOrderList returned the value: %@", result);
}

All API call examples are located in INMagentoServiceExample class. Just copy anything you need from there and paste it to your view controller. Now you are ready to consume SOAP web service in iOS environment.

First, let’s assume a few things:
1) the package is named ‘Company’ and the module is named ‘Module’
2) you know how to make a php module and a new block class. The block’s alias is in this example ‘module/dynamic’
3) the phtml template for the dynamic block will be dynamic.phtml
4) the block id of the static cms block will be ‘static_block’ (and you already created it in the admin)
5) you need to add the email of the current customer to the static block. The logic of when you want to show the block and everything deeper is out of the scope of this document.

First let’s look @ the phtml file, which only uses the method which we’ll create afterwards in the block class:

<?php if(Mage::getSingleton('customer/session')->getCustomer()->getId()) : ?>
	<?php echo $this->getStaticBlock();?>
<?php endif;?>

As you see, we’re only checking if the customer is set and are getting the static block. So next let’s see the logic in the dynamic block class:

<?php
/**
 * Just another block class
 */
class Company_Module_Block_Dynamic extends Mage_Core_Block_Template
{
	/**
	 * This getter will return the html of your static block
	 * @return string
	 */
	public function getStaticBlock()
	{
		// loading the static block
		$block = Mage::getModel('cms/block')
		->setStoreId(Mage::app()->getStore()->getId())
		->load('static_block');
		/* @var $block Mage_Cms_Model_Block */

		// setting the assoc. array we send to the filter.
		$array = array();
		// the array keys are named after the tags in the static block. let's say $array['customer_email'] is {{var customer_email}} in the static block. you can set as many variables you need.
		$array['customer_email'] = Mage::getSingleton('customer/session')->getCustomer()->getEmail();

		// loading the filter which will get the array we created and parse the block content
		$filter = Mage::getModel('cms/template_filter');
		/* @var $filter Mage_Cms_Model_Template_Filter */
		$filter->setVariables($array);

		// return the filtered block content.
		return $filter->filter($block->getContent());

	}
}
?>

Ok. Now enter somewhere in your static_block CMS block the tag {{var customer_email}} (or some other key you added) and it’ll be dynamically added into CMS block.

The agenda is rich and divided in three tracks:

• Technology Track – unfortunately, this one is not for me any more. I can’t myself fully follow programming trends, so I would mostly just blink if I attend these sessions. However, it is good to know that Imagine has a lot of good sessions for developers, and not just business people. I expect Inchoo will have more crew next year.
• Business Track – is oriented for consultants and merchants
• Partner Powered Track – will be oriented for partners. I’m very looking forward to be at Annual Magento Solution Partner Leadership Summit (I just remembered I need to find my invitation).

Besides of fun simply by going there, there are some goals I set for myself to achieve at Imagine:

1. For starters, I’m really looking forward meeting some of our US clients face to face. Skype video call was most advanced form of meetings with them so far. It will be great to shake hands.
2. Check out and get insight of what X.Commerce really is. I don’t know about the rest of you guys, but almost a year passed since I heard this term for the first time and I still don’t know what will it be in reality and what opportunities or threats are there for us. I read that we will have a revolution, but even after reading the post, I am not sure where’s the catch.
3. Check out where Magento is heading and evaluate how much will it be affected by eBay and the whole X.Commerce thing.
4. Evaluate Magento’s strategy for partners.
5. Reconnect with the guys from other Magento partners like WebShopApps, Blue Acorn, Classy Llamas, Gorilla Commerce and others…

See you in Vegas. You can reach me via Twitter on https://twitter.com/#!/tomislavbilic or SMS me to +385.91.577.1025.

Cheers!

Tested in Magento CE 1.6.1.0.

Implementation

1. So, if you didn’t already modified head.phtml file, create identical directory hierarchy and copy/paste head.phtml in your theme or package.

Path example if using package:
..\app\design\frontend\[your_package_name]\default\template\page\html\head.phtml

Path example if using theme:
..\app\design\frontend\default\[your_theme_name]\template\page\html\head.phtml

2. Add code below to head.phtml. I’ve added code at the bottom of file.

<?php
$actionName = $this->getAction()->getFullActionName();
if ($actionName == 'catalog_category_view') // Category Page
{
    $category = Mage::registry('current_category');
    $prodCol = $category->getProductCollection()->addAttributeToFilter('status', 1)->addAttributeToFilter('visibility', array('in' => array(Mage_Catalog_Model_Product_Visibility::VISIBILITY_IN_CATALOG, Mage_Catalog_Model_Product_Visibility::VISIBILITY_BOTH)));
    $tool = $this->getLayout()->createBlock('page/html_pager')->setLimit($this->getLayout()->createBlock('catalog/product_list_toolbar')->getLimit())->setCollection($prodCol);
    $linkPrev = false;
    $linkNext = false;
    if ($tool->getCollection()->getSelectCountSql()) {
        if ($tool->getLastPageNum() > 1) {
            if (!$tool->isFirstPage()) {
                $linkPrev = true;
                if ($tool->getCurrentPage() == 2) {
                    $url = explode('?', $tool->getPreviousPageUrl());
                    $prevUrl = @$url[0];
                }
                else {
                    $prevUrl = $tool->getPreviousPageUrl();
                }
            }
            if (!$tool->isLastPage()) {
                $linkNext = true;
                $nextUrl = $tool->getNextPageUrl();
            }
        }
    }
    if ($linkPrev) echo '<link rel="prev" href="' . $prevUrl . '" />';
    if ($linkNext) echo '<link rel="next" href="' . $nextUrl . '" />';
}

?>

Result

Below is a result if you are on page 3.

<head>
...
<link rel="prev" href="http://www.example.com/store.html?p=2">

<link rel="next" href="http://www.example.com/store.html?p=4">
...
</head>

Search engine optimization in Magento’s Configuration

After implementing rel=”prev” and rel=”next” you need to re-config Magento’s SEO options, which means that you don’t need anymore Canonical Link Meta Tag For Categories. Below is a example how we setup Magento’s SEO options for one of our clients.

A story that perfectly reflects this attitude towards our clients started out 3 months ago when we were approached by Michael Vilnov from Bilvask.nu to produce a new custom website for his car detailing company.

After our sales manager Aron Stanic won the deal we fired up the project with our marketing guru Toni Anicic doing the wireframes. These were then passed on from Osijek to Lyssandro Reis in Sydney, one of our best designers, with a task to work closely with Michael and produce the design templates. Time zone problems were surpassed and Lyssandro and Michael worked together using video chats and screencasts, almost as they were sitting in the same office.

Once finished templates arrived at Novi Sad office, Srdjan Stojiljkovic, our frontend developer started to work on his HTML/CSS/JS magic, bringing life into those still Photoshop layers. At the same time Nikola Stojiljkovic, Srdjan’s brother and our backend developer was bending Magento to his own will, customizing it to serve our clients needs, as if the framework was tailored for them only.

Here is a short list of custom features we developed for Bilvask specific needs:

• backend controlled home page slider module
• extensive contact form module, with backend control
• customer uploaded images, backend control – with preview, and mass actions
• AJAX top cart
• custom main menu with dynamic content from static blocks
• guide pages with integrated products
• custom product reviews
• split attributes for products
• shipping quotes in customer cart page
• custom sidebar for categories and sub categories
• split descriptions for category pages

Although we don’t like to use 3rd party extensions, client used quite a few of them, and we made sure they all played nicely with each other:

• Woopra Live Chat
• J2T AJAX Add to Cart
• One Step Checkout
• Sweet Tooth Reward Points
• Post Denmark
• e-pay
• schema org, Facebook Open Graph
• Video Gallery

So, did it end well? Did we surpass language barriers, conquered the timezones, and avoided extension pits with sharp spikes?

We approached Michael as he is the only one entitled to answer that question. When we asked him to write a short testimonial, he felt a need to go a step further and wrote up a review on his experience working with us from start to finish, explaining along the way our methodologies and work ethics.

Here is what he had to say:

The difference between A: doing a job and B: doing a perfect job.

Our company Bilvask.nu, is a Danish based Car detailing company with a webshop selling high-end car care equipment. Our daily work with luxury cars always requires a strong founded feeling of quality towards our work every single time. This being in all aspects of our relations, towards our clients, suppliers and partners.

However, on the IT development side of business, we’ve always had problems finding the same passion for reaching the ultimate result of perfection and customer service.

We stumbled upon Inchoo after searching for a solution partner for our new Magento store. We had been in the online business for a few years, and were now in the marked for a 100% custom made Magento store – to our exact specifications.

We chose Inchoo to make our new shop / website, because of several factors. The fact that they had Magento Silver Partner Status, and at the same time they had several employees Magento certified. This made Inchoo a trustworthy partner from the get go.

Starting at the first contact, working with Inchoo as a supplier of Magento web solutions have been a pure pleasure.

First Contact, pre-work process

First contact was replied fast, yet thoughtful. There was no sense of rush, yet a sense that the company didn’t just send you a standard email-answer, because of lack of time. The answer was prompt, and revealed a serious attitude towards taking care of other peoples business, other peoples livelihood.

The sketch up of the budget and site outline was made in due time, described in detail, nothing left out.
Inchoo didn’t seem to be to interested in ”fitting” our budget, but more interested in giving a realistic price of the task as they saw it carried out in best practice.
The initial offer Inchoo gave us was outlined as a best case, worst case and realistic case scenarios, with pricing for all the various turn of events.
We’ve yet to see a better written partnership contract anywhere, and we’ve contacted a few before making our choice. The offer as well as fast contact made us confident in our choice, Inchoo was the company to go with.

The actual work process

Inchoo works within an agile project planning strategy – meaning, that all aspects of the shop build can be changed until a certain time of any process. This gives great opportunities to change elements as the build moves along, as there will always be aspects of a project this size, that will be able to be optimized as work goes deeper into details. Flaws are ironed as the work progresses, mistakes are caught, better and easier solutions are found along the way.

Inchoo’s way of leading us through the process of the build, with specialists on each phase:

• Wireframing phase
• Design phase
• Development phase
• Launch phase
• Aftercare phase

This left us with a sense of constantly being in touch with the right people, who could give the feedback needed. We have at no point in the build been in doubt of who to contact, and the person who we wished to contact was never too busy to answer the phone, skype or email.

When making a project that lasts for several months, flaws will occur. Its humanly impossible to run a marathon without putting a foot wrong. Especially here, I think Inchoo showed the proper professionalism not trying to hide, cover or in any way make up excuses for time or progress being set back. Problems where explained and then dealt with, in fast and efficient manner.
When all things are good, its easy to pad each other on the back and say great work, but when problems occur, this is when true work ethics show.

Launch

3 months after the first contact we had our launch. Minor bugs where taken care of in a fast and efficient manner. At no point have we experienced that our development team moved on to new projects. They are still as accessible as they where during our work process.

Aftercare

At the current time, it is difficult for us to value the aftercare that Inchoo offers, but rest a sure if it’s anything like what we’ve have experienced so far, and I cant wait to continue working with them in the future.

There is no doubt in my mind, that I will stick with the development team to continue creating a further success with our webshop.

To all of Inchoo – Thank you guys for a wonderful experience in work ethics.

It’s been a pure pleasure.

Michael Vilnov Hansen
CEO
Bilvask.nu

——

EDIT: This was, as most of you accurately guessed, an April Fools’ Day joke. Thanks to everyone who joined in with their comments and for keeping the joke alive for some extra hours last Sunday – it was a rather obvious one (after all, who would simply share a cheat sheet, right? ), but we thought it would give you a couple of laughs. Happy certification, everyone!!!

——

Here at Inchoo we have always taken pride in sharing our knowledge of Magento with the rest of the community, so this is only a continuation of a long-lasting tradition.

There’s been quite a few articles written on the whole certification process, one of the most recent ones being Ben Marks of Blue Acorn sharing his thoughts on how to become certified - but this – this is something completely different!

We have 4 certified developers today (haven’t used the cheat sheet ourselves yet), and with the results of our recent investigation (and with special thanks to all of you guys out there who were flunking the tests only to get us this invaluable info), there’s much more to come from us, and hopefully from all of you, our loyal readers and followers.

Have you just started poking around Magento but find it a bit overwhelming to pass the exam?

Or are you a Magento Solution Partner with little to none dedicated Magento developers, paying for your partner status simply because you can and outsourcing the development to other companies? You were probably worried when Magento announced you’ll need to have certified developers on board – well, worry no more – with our ultimate cheat sheet you can have your community managers pass the exam in their first try! Add a couple more people to the mix and you’re golden!

Discovering the patterns

This cheat sheet was prepared after we gathered the details about questions from 42 exams taken worldwide (it took quite an effort getting all these developers sneak in those mini cameras to capture the questions). Not in our wildest dreams did we expect to find clear answer patterns.

You can imagine our surprise when our consulting partner, a tenured professor at the University of Osijek’s Department of Mathematics, told us that to a math-trained eye the answer patterns were so obvious it would take a high-school graduate several hours to understand them and pass this exam.

The exam apparently uses one of the most common math concepts – prime numbers – as the pattern to answering the questions correctly.

How come this was missed by the Magento Certification Board, you may ask? Well, call us conspiracy theorists if you will, but this can’t be a pure coincidence, so we somehow feel this was done on purpose, to allow the developers around their companies (who have the inside info) to pass the certification with flying colors.

Well, guys – the jig is up! Now everyone can become a Magento Certified Developer, and here’s how:

What do you need to pass the exam?

1. Exam voucher number

You have to purchase a voucher to be able to register for the exam, so once you make the purchase, you will get what appears to be a randomly generated voucher number, but what it actually represents is the first clue, or the key to solving the test, even if you have virtually no prior Magento experience.

The last digit on the voucher number is the one that’s going to help you pass as it will correspond to the actual exam you’ll be solving. It contains the hidden answer to the first exam question and after that it’s all a smooth ride. It’s all explained in detail in the actual cheat sheet below.

2. Prime numbers

Well, you probably remember all about the prime numbers from your math class, right? I thought so – in a nutshell, a prime number is the one that only has two divisors – number 1 and itself – so, prime numbers are 2,3,5,7,11,13,… the list goes on indefinitely (but you’ll only need first seven primes to pass the exam).

And that’s all the info you need – so, how does this actually help? Using your unique voucher number and primes with a little help from the cheat sheet, you can get all the answers right.

The cheat sheet revealed

So, without further ado, the cheat sheet together with instructions can be downloaded right here.

Download the Magento Certified Developer exam cheat sheet!

We actually gave this cheat sheet to one of the developers who initially flunked the test, and she was happy to share her thoughts for this article:

“Guys – this is incredible! Works like a charm! Ok, there was quite a bit of counting involved, but it also helps you not to look suspicious finishing the test too quickly. I deliberately answered several questions wrong and passed with a stunning 64/70 score! Thanks a lot for the cheat sheet, and I can only hope more people will benefit from this! Love Magento, love the community!”

April Første, Magento Certified Developer (Denmark)

So, there you go – what are you waiting for? Get Magento certified! And yes, you’re welcome!

The concept of open communication of sharing the way you work with your customers and clients is called Marketing by sharing. It’s first mentioned by Jason Fried who is the co-founder and President of 37signals.

But you need to know how to do it well and to show great respect to your readers and potential customers. Also be careful not to show any disrespect to your clients. Of course, you can’t share everything and you should think of your strategy and channels of sharing.

Here are some tips from our experience on how to be a good marketer of sharing.    

1. Get to know your key competences so you know what and how to share

You can’t mix and offer everything your business includes and deals with, since it might not be interesting and helpful to your readers as you may think. You are not forced to tell people everything your business works on, but you want to help them understand and want your products and services. Be aware of yourself and your business and learn what are your strengths that are worth talking about.

2. Empower learning in organization

Don’t do that just because its trendy to say you are a (lifelong) learning organization, but because you really aim for self-improvement and team growth. Let your employees see their job positions as platforms to develop themselves.

3. Be unique, be worth coming back to

Be consistent in delivering your promises by delivering only quality solutions (knowledge). You don’t want to share something that could be easily found by Google – but you want to be easily found by Google Build your type of knowledge sharing as something that could grow to be a positive habit of your customers, readers and community.

4. Don’t forget all about it when your business is enjoying prosperity

Knowledge sharing is about creating respectful relationships with your customers and people that want to listen to you. Don’t forget about them when you fulfil your initial goals. You might not get a second chance to be listened to.

5. Remember that those who actually have a lot of knowledge are not afraid of using it

Knowledge is the only resource that grows by sharing, so don’t be afraid of the opportunities to become better. If your company really has a lot of knowledge that can serve to others and eventually be sold through your products and services, you won’t even think of hiding it. If you really care (as you probably say you do), you will gladly involve customers and community in the life of your company, as your products and services are targeted at them. You will listen to them because they will be more than happy to tell you what you can do for them.

Don’t hesitate. Go market by sharing.