Things I Wish I Found While Searching on Grant Lucas

Setting Currency When Using Universal Analytics and Google Tag Manager Ecommerce

Wed, 07 Dec 2016 11:20:07 -0500

After some frustrations with conflicting documentation, I figured I’d make the blog post I wished I had at the start of this all. This forum post is what finally led me in the correct direction.

If you’re using Universal Analytics through Google Tag Manager and are tracking Standard Ecommerce transactions in multiple currencies, you’ll need some extra setup beyond the documentation they provide. You’ll notice there’s no mention of setting the currency when sending a standard ecommerce transaction because the Universal Analytics through Google Tag Manager doesn’t support it. Thankfully, it’s easy to add.

Setting up Google Tag Manager to pass on currency code

In Tag Manager, you’ll want to create or edit a Universal Analytics tag that has a Track Type of Transaction and under More Settings, expand Fields to Set. Here you’re going to add a new field to map the transaction currency to what Google Analytics expects for the currency code.

Set Field Name to currencyCode and set the Value to a new Data Layer Variable whose variable name is transactionCurrency.

Once set, your Universal Analytics tag for transactions will look like so:

This will map the currency code set in dataLayer.transactionCurrency to Google Analytics’ currencyCode.

Adding currency to your transaction in code

When defining your transaction on the dataLayer object, you can now set dataLayer.transactionCurrency to one of the supported currency codes and Google Analytics will do all the conversions needed.

Example Data Layer Transaction

In the example below, if you have a transaction in Indian Rupees, Google Analytics will take care of converting that to USD if your view is set to display data in USD instead of treating it as 5K USD.

dataLayer.push({
    'transactionId': 123,
    'transactionTotal': 5000.00,
    'transactionCurrency': 'INR',
    'transactionProducts': [
        {
            'sku': 'ABCD',
            'name': 'Super Awesome Product',
            'price': 2500.00,
            'quantity': 2
        }
    ]
});

Caveat: This will apply the currency for the whole transaction. Different currencies per product are not covered here.

Caching Assetic Asset Collections

Fri, 26 Feb 2016 18:07:03 -0500

Recently I was working with Assetic for combining and minifying CSS and JS files but ran into an issue with regards to caching the created asset collection. The resulting minified file was being rewritten on every page load which was no good at all.

TL;DR: Get the asset collection’s “last modified” property and compare it to the written minified file to determine if it needs updating.

Updated Feb 29, 2016

This post originally used String Assets to cache the collection’s content. It was later found that the string asset caches would conflict due to string assets not having “source” or “target” paths which are a component of the hash. Though an arbitrary source could be set on a string asset to resolve the issue, it’s probably better to just use the collection’s getLastModified before writing the minified file. The post has been updated to reflect the new approach.

If you still want to cache a collection, store the contents in a string asset but be sure to at least set source of the string asset to something unique for the collection. This will ensure that if you have multiple collections generated on page load, they won’t conflict.

// Build the string asset with a unique "source"
// The $type here is the CSS media type (screen, print, etc) to make it unique
$collectionAsset = new StringAsset($collection->dump(), array(), 'css/' . $type);
$collectionAsset->getLastModified($collection->getLastModified());

// Cache the string asset for later use
$cachedCollection = new AssetCache($collectionAsset, $cache);

Original Post

Rundown of how to minify, combine, and cache assets with Assetic

Loop through individual assets (CSS or JS files)
Apply filters to minify them
Cache the result so you don’t have to minify them again until the source file changes
Add the asset to an asset collection
Finally, write the minified file if either of the following is true
- The minified file does not exist
- The asset collection’s last modified is newer than that of the minified file on the system
  - This indicates that the minified file is now out of date from what’s been cached
  - This was the key to ensure the minified file wasn’t updated on every page load

The resulting file will be a combination of all minified assets which is only updated when one of the individual assets are updated.

The Code

The following assumes you have an array of file paths. It will write a minified file to the public directory of the site which is only later updated if any of the individual assets have changed.

use Assetic\Asset\AssetCollection;
use Assetic\Asset\FileAsset;
use Assetic\Asset\AssetCache;
use Assetic\Cache\FilesystemCache;
use Assetic\Filter\CssMinFilter;

// Create the collection
$collection = new AssetCollection();

// Create the cache
$cache = new FilesystemCache('/some/path/to/store/cache');

// Loop through file paths
foreach ($files as $filePath) {
    // Create the asset
    $asset = new FileAsset($filePath);

    // Add the filter, for example CSS minification
    $asset->ensureFilter(new CssMinFilter());

    // Cache the asset so we don't have to reapply filters on future page loads
    $cachedAsset = new AssetCache($asset, $cache);

    // Add the cached asset to the collection
    $collection->add($cachedAsset);
}

// Set where to save the file
$absolutePublicMinPath = "/absolute/public/path/here";

// If the minified file doesn't exist OR the minified file is out of date, write
it to the file system
if (!file_exists($absolutePublicMinPath) || $collection->getLastModified() > filemtime($absolutePublicMinPath)) {
    file_put_contents($absolutePublicMinPath, $collection->dump());
}

There you go! You should now have a minified file which only updates when any of its individual assets are updated. Here’s hoping this saves just one person some time and as always, let me know if there’s a better approach out there! :)

A note on archiving Gmail messages in Mutt

Fri, 24 Jan 2014 12:47:54 -0500

A while ago I switched to Mutt for all of my email needs. I have a mix of regular IMAP accounts and a few Gmail powered accounts set up. The Gmail accounts have always been a thorn in my side due to an early misconception I had about the All Mail folder and archiving. Below is my initial problem, solution and what I found to be the consistent behaviour of a Mutt + Gmail setup.

In Mutt, an easy way to archive email is to set up a macro which moves that email to an archive folder, or in the case of Gmail, the All Mail folder.

Note: These macros assume that you have an archive folder set up. I also use OfflineImap to map my Gmail All Mail folders to Archive folders for consistency.

`1`	`macro index,pager A "<save-message>=Archive<enter>" "Archive Message"`

In a normal IMAP instance, email which is in the inbox only exists in the inbox. In Gmail, email in any folder will show up in your archive/all mail folder. The problem this creates is that when you “Archive” and email, that message is moved to the All Mail folder and, locally in Mutt, you see duplicate emails in All Mail. At first I thought this was a problem and had macro to purge that email from the inbox by unsetting the trash folder and then deleting it.

`1`	`macro index,pager y "<enter-command>unset trash\n <delete-message>" "Gmail archive message"`

This would leave the message in the All Mail folder and remove it from my inbox. This method is full of issues that were very annoying.

After some research I’ve found that the normal archive route that produces duplicates is in fact ok. Duplicates will exist for two syncs up to Gmail. One that sends them up, Gmail then removes the detected duplicates, and then another OfflineImap sync to bring back down those changes.

No more worries about duplicate emails. Just need to dig in and do more testing to get the behaviour down.

My hope is that this post will help others that have run across the same odd behaviour and share the duplication concerns. Good luck in your Mutt + Gmail endeavours!

Using Vim for Arduino development

Wed, 19 Sep 2012 11:26:41 -0400

Here’s a quick post on setting up Vim for Arduino development instead of using the Arduino IDE. If you’re a heavy Vim user, it can be a bit of a shock to go into a different editor. Thankfully the setup is pretty easy to get this all working with Vim. This post is assuming you are comfortable with how Vim is setup and ideally already have an environment that works for you.

Update March 26, 2014

The Arduino Vim plugin originally referenced in this post seems to have been abandoned by the project creator. The README has been updated pointing to a newer Vim Arduino plugin using Ino, command line toolkit for working with Arduino hardware. I haven’t had a chance to test this new solution out fully, but it looks promising. If you have any issue with my guide below using the old plugin, tryout the new plugin and Ino and let me know how it goes!

Once I have a chance to fully test and understand the new build method, I’ll update this post with the new information. On first look, it looks like a project folder structure is imposed by Ino, lib and src folders, but I don’t think that’s too much of an issue in the long run. Overall, I think relying on a command line build process will probably be more stable than trying to tie into the Arduino IDE like before.

Install the Arduino IDE

Wait. What?!? I hear you say. I know, I know. We’re not actually using the Arduino IDE but we need it for some configuration and the files it installs. The Vim plugin we’ll be using ties into what the IDE installs and configures so it’s needed. You can download the IDE from the Arduino site.

Install vim-arduino plugin

To get the main goodness of compiling, monitoring and deploying to an Arduino, grab the latest version of vim-arduino. Install it in your .vim folder using what ever method you use to manage your Vim plugins. Hint: I’d recommend Pathogen as it makes installing as simple as dropping the plugin folder into a bundle folder.

Vim syntax file

Next up is to get the syntax file so we can have nice colour coding for .pde and .ino files. Download the latest arduino.vim and install it in your Vim syntax folder. To get the syntax to apply to the correct file types add the following to your vimrc file

1
2

au BufRead,BufNewFile *.pde set filetype=arduino
au BufRead,BufNewFile *.ino set filetype=arduino

Configuring the Arduino IDE

Before trying to compile and deploy with Vim, get it all working with the Arduino IDE first as the Vim plugin just calls from the settings saved by the IDE. If it’s working in the IDE, it should work in Vim. Make sure you select the right tty.usbmodem* serial port from Tools > Serial Port in the IDE. Note: This will only show when the Arduino is plugged in.

Working from Vim

Once you can communicate with your Arduino from the IDE you should be fully good to go with Vim. You shouldn’t have to open the IDE unless you want some example code. Open up your sketch file in Vim and use <Leader>ac to compile a sketch, <Leader>ad to compile and then deploy to the connected Arduino and <Leader>as to open a new window with screen to monitor the serial output from the Arduino.

And that’s it! Overall I’m really happy with the setup so far. Let me know if it works for you or if there are any issues.