If you’re on mac you can run a LaunchDaemon that will sniff out the volume when it is connected and auto sync. I haven’t got up to that just yet but here is the script

require 'rest-client'
require 'highline/import'
require 'json'
require 'time'

@activityCount = 0
@uploadedCount = 0
@garminPath = "/Volumes/GARMIN/Garmin/Activities"

def startup()
    email = ask("Email: ")
    password = ask("Password: ") { |p| p.echo = false }

    if email && password
        puts "Authenticating with Strava..."
        begin
            response = RestClient.post "https://www.strava.com/api/v2/authentication/login", { email: email, password: password }.to_json, :content_type => :json, :accept => :json
        rescue Exception => e
            puts "Uh oh. It failed. #{e.message}"
        end

        if response.code == 200
            user = JSON.parse(response.body)
            puts "Your session token is: #{user["token"]}"
            
            if !File.exists?("#{@garminPath}/.stravaTrakt")
                File.open("#{@garminPath}/.stravaTrakt", "w")
            end

            dotTrakr = File.open("#{@garminPath}/.stravaTrakt", "r+")
            
            timeLastSaved = dotTrakr.read
            if timeLastSaved.length > 0
                timeLastSaved = Time.parse(timeLastSaved)
            end

            if !timeLastSaved.is_a?(Time)
                files = Dir.glob("#{@garminPath}/*.fit")
                @activityCount = files.length
                files.each { |f| uploadFile(user, f) }
            else
                files = Dir.glob("#{@garminPath}/*.fit").
                    select{|f| File.mtime(f) > timeLastSaved }
                @activityCount = files.length
                files.each{|f| uploadFile(user, f) }
            end
            dotTrakr.close

            if @activityCount == 0
                puts "No activities to sync"
            elsif @uploadedCount == @activityCount
                timeLastSaved = Time.now
                dotTrakr = File.open("#{@garminPath}/.stravaTrakt", "w+")
                dotTrakr.write(timeLastSaved).close
                puts "#{@activityCount} activities have been uploaded. Good work!"
            else
                puts "Some activities were skipped. Look into this"
            end
        end

    end
end

def uploadFile(user, activity)
    puts "Syncing Activity - #{File.basename(activity)} to Strava"
    payload = { token: user["token"], data: File.new(activity, 'rb').read, type: "fit"}

    begin
        response = RestClient.post "http://www.strava.com/api/v2/upload", payload
        if response.code == 200
            body = JSON.parse(response.body)
            puts "Great Success! Upload ID: #{body["upload_id"]}"
            @uploadedCount = @uploadedCount + 1
        end
    rescue Exception => e
        puts "Uh oh, something went wrong uploading the activity: #{e.message}"
    end

end

startup()

The problem with sharing data is that you need to have enough space on the destination media to support all of the data on the host machine; thanks to my failing maths, my friend did not. His HDD filled up to the brim, and missed out newer stuffs. Instead of taking it back and trying to return it, I decided to be a bit more resourceful and takle the issue at hand.

Syncd.rb

Syncd is a simple Ruby script that remembers what was copied onto the destination device/folder and makes sure that if that file goes subsequently missing (like deleting it because the movie wasn’t of their taste) it won’t be re-added upon next sync. So what this means is, my friend gets movies, and deletes all the ones he doesn’t like, which frees up space for new ones that he didn’t have previously.

But how does it work? Pretty simple. On the host machine we litter the folders to be sync’d with indexed tracking crumbs, by default .syncd. These files contain a list of files previously sync’d. Upon each sync the script checks the host .syncd crumb file to see if a file was previously sync’d, if it does check if it still exists on the host, if it doesn’t, don’t sync, it’s been deleted. If it does still exist check if the file is still the same and not modified, if it differs, it needs a resync.

Gimme Script Already

require 'fileutils'
require 'pathname'
require 'digest'
require 'colorize'

class Syncd

def initialize
@dir = '/Volumes/MUSIC'
@remote = '/Users/richard/mew'
@crumbName = '.syncd'
end

def sync(dir = nil)
dir = @dir unless dir
Dir.foreach(dir) { |f|
path = dir + '/' + f
next if (f == '..' || f == '.')
if File.directory?(path)
self.sync(path)
else
self.syncFile(path)
end
}
end

@private
def previouslySyncd(file)
filename = File.basename(file)
syncdCrumb = File.dirname(file) + "/#{@crumbName}"
if !File.exists?(syncdCrumb)
FileUtils.touch(syncdCrumb)
end

if File.readlines(syncdCrumb).grep(filename).size == 0
open(syncdCrumb, 'a') { |f|
f.puts File.basename(file)
}
return false
else
return true
end
end

def fileIsIdentical(file, remoteFile)
return false unless File.exists?(remoteFile)
return FileUtils.compare_file(file, remoteFile)
end

def syncFile(file)
remoteFile = @remote + file[@dir.size..file.size]
print "Syncing #{file}... ".light_green
if !previouslySyncd(file) && !fileIsIdentical(file, remoteFile)
begin
Dir.mkdir(File.dirname(remoteFile)) unless File.exists?(File.dirname(remoteFile))
FileUtils.cp(file, remoteFile)
puts "Success!".green
rescue Exception => e
puts "Error: #{e}".red
end
else
puts "Skipped, no need to sync".blue
end
end

end

syncd = Syncd.new()
syncd.sync()

You may need to install the gems like colorize, simply do:

gem install colorize

Also see the defaults in the instance vars. Change them to suit your needs

But why not use rsync?

Rsync doesn’t have a mechanism for keeping track of what it has previously sync’d and what has been deleted.

TODO:

• Optimise the identical hash checks (they slow)
• Support multiple input sources

UIKeyboardTypeDefault

Use the default keyboard for the current input method.

UIKeyboardTypeASCIICapable

Use a keyboard that displays standard ASCII characters.

UIKeyboardTypeNumbersAndPunctuation

Use the numbers and punctuation keyboard.

UIKeyboardTypeURL

Use a keyboard optimized for URL entry. This type features “.”, “/”, and “.com” prominently.

UIKeyboardTypeNumberPad

Use a numeric keypad designed for PIN entry. This type features the numbers 0 through 9 prominently. This keyboard type does not support auto-capitalization.

UIKeyboardTypePhonePad

Use a keypad designed for entering telephone numbers. This type features the numbers 0 through 9 and the “*” and “#” characters prominently. This keyboard type does not support auto-capitalization.

UIKeyboardTypeNamePhonePad

Use a keypad designed for entering a person’s name or phone number. This keyboard type does not support auto-capitalization.

UIKeyboardTypeEmailAddress

Use a keyboard optimized for specifying email addresses. This type features the “@”, “.” and space characters prominently.

UIKeyboardTypeDecimalPad

Use a keyboard with numbers and a decimal point.

UIKeyboardTypeTwitter

Use a keyboard optimized for twitter text entry, with easy access to the @ and # characters.

UIKeyboardTypeAlphabet

Deprecated.

So with my trakt.tv api key I decided to write up a quick ruby script to show what’s currently on my tv:

require "net/http"
require "uri"
require 'json'
require 'yaml'

uri = URI.parse("http://api.trakt.tv/user/watching.json/your_api_key/your_username")
response = Net::HTTP.get_response(uri)
result = JSON.parse response.body

if result.is_a?(Hash)
	
	if result["show"]
		title = "<div style="padding-left: 20px;"><h3>ON MY TV</h3><h5 style="margin-bottom: 10px;">#{result['show']['title']} - #{result['episode']['title']} (s#{result['episode']['season']}e#{result['episode']['number']})</h5>"
		poster = result['show']['images']['poster'].gsub('.jpg', '-138.jpg')
		title << "<img src="#{poster}" /></div>"
	elsif result["movie"]
		title = "<div style="padding-left: 20px;"><h3>ON MY TV</h3><h5 style="margin-bottom: 10px;">#{result['movie']['title']} (#{result['movie']['year']})</h5>"
		poster = result['movie']['images']['poster'].gsub('.jpg', '-138.jpg')
		title << "<img src="#{poster}" /></div>"
	end

	trakt = File.open("/path/to/text_file/playing.txt", "w")
	trakt.write(title)
	trakt.close

end

Three things to note here. You will need to update your api-key, username and the path to where you want the text file to be written.

Next up I poll trakt’s api every 5mins via:

crontab -e
*/5 * * * * ruby trakt.rb

Which updates the playlist.txt file. I then bring that into my blog with a simple:

echo file_get_contents('playlist.txt');

Let me know if you use this so I can checkout some new things to watch!

Stop Schema Time!

First up let’s talk about the database schema. If you’re new to the concept of single table inheritance and polymorphism then I hope I can explain how I’ve structured my schema to handle, hopefully, a myriad of media design solutions. We’ll use the models I will be using later on in this tutorial to set up this discussion:

• A user has_many shows
• A show has_many episodes
• An episode has_many videos
• An episode has_many audio files
• An episode has_many images

Now immediately you might be thinking of hitting up rails g migration etc and generating a videos, audio and images table, all with an episode_id field. Hold your horses. What happens when I say that a show can also have many images, you would then need to make a seperate table for shows_images, and it can keep going and going.

Polymorphism!

Introducing polymorphism! A polymorphic model is a model that wraps over itself, is independent on a parent model, and cares not about your ids. It belongs to itself and no one else, its it’s own woman. But how do you reference back to your models. Well rails handles this issue quite well, it stores the referencing model in a #{alias}_type field, and the according owner id in its #{alias}_id field. Going forward an example polymorphic table would be:

CREATE TABLE `assets` (
	`id` int(11) NOT NULL AUTO_INCREMENT,
	`type` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
	`filename` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
	`checksum` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
	`path` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
	`filesize` int(11) DEFAULT NULL,
	`width` int(11) DEFAULT NULL,
	`height` int(11) DEFAULT NULL,
	`duration` int(11) DEFAULT NULL,
	`bit_rate` int(11) DEFAULT NULL,
	`assetable_id` int(11) DEFAULT NULL,
	`assetable_type` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
	`created_at` datetime DEFAULT NULL,
	`updated_at` datetime DEFAULT NULL,
	PRIMARY KEY (`id`)
)

So it’s SQL, get over it. So now if it’s an image, or a video, or an audio file, or any file, they get stored here. Now you don’t have to store all your media metadata and associations here, but it can save on tables and simplifies asset handling. Now single table inheritance comes into play by putting a model inbetween the polymorphic Asset model and the owner model. So instead of Episode has_many Asset (a bit weird), we can simply do Episode has_many Videos where Videos extends Asset. A bit much to get your head around, lets make some migrations, make some models and see how the schema pans out!

Rails Time

TO get started cd to the chose place you do your business in and run:

rails new test_app

Fill our your condit/database.yml config so you can connect to the db. Once created we may as well add the required gems for this walkthrough. Open up your Gemfile and add in:

gem 'mysql2'
gem 'simple_form'
gem 'carrierwave'
gem 'rmagick'
gem 'friendly_id'
gem 'uuidtools'
gem 'mediainfo'

Save and then in your command line run bundle install, good times. Now let’s start with our migrations, we’ll skip the user side of things for the time being as I don’t really want to include authentication in this tutorial. So Let’s start with the Show model. In your command line run:

rails g model Show title:string slug:string

Now the Episode Model:

rails g model Episode episode_id:integer title:string slug:string

For the asset table we’ll just make a blank model with no fields. We will modify the asset migration manually. Just so we can see how to reference, the references…

rails g model Asset

After that, open the create_assets.rb migration file in db/migrate/ and look at the change method. You should see something stock standard:

class CreateAssets < ActiveRecord::Migration
  def change
    create_table :assets do |t|

      t.timestamps
    end
  end
end

Cool story hansel… But this does nothing! No polymorphism, in fact just a lot of tumbleweed. Lets paste this in instead of what is there and then discuss

class CreateAssets < ActiveRecord::Migration
  def change
    create_table :assets do |t|
    	t.string :type
    	t.string :filename
    	t.string :checksum
    	t.string :path
    	t.integer :filesize
    	t.integer :width
    	t.integer :height
    	t.integer :duration
    	t.integer :bit_rate

    	t.references :assetable, :polymorphic => true
      t.timestamps
    end
  end
end

Now the first 9 fields are all specific to the media’s meta data. We will be populating them a bit later. The most important line is t.references :assetable, :polymorphic => true. Do not forget this one. It sets up the polymorphism, assetable makes the table self referential, and polymorphic true handles the _type field creation, so you can see what model it belongs to. Boom! let’s rake

bundle exec rake db:create
bundle exec rake db:migrate

Hopefully all went well and your tables are created!

Scaffolding

Let’s get our views and controllers done and dusted so we can get into the cool stuff

rails g scaffold shows --skip-migration
rails g scaffold episodes --skip-migration

Overwrite the tests, we don’t have time to do them today. With that done lets go straight to setting up our associations.

Assetable?

Open up our show model in models/show.rb We will set up the association it requires, and also some added magic to get slugs going.

class Show < ActiveRecord::Base

  #Associations
  #belongs_to :user
  has_many :episodes

  #Slugs
  extend FriendlyId
  friendly_id :title, use: :slugged

end

You can see this is pretty straight forward with the association to episodes. friendly_id? wtf? It’s an awesome gem that turns whatever you want into a slug. Here we are turning the title field into a slug, stored by default into the slug field. We have that covered in our migrations already

Next up let’s do the more complex one, our episode model:

class Episode < ActiveRecord::Base

	belongs_to :show
  has_many :videos, :as => :assetable
  accepts_nested_attributes_for :videos, :reject_if => proc { |v| v[:filename].blank? }

  before_save :set_asset_path

	#Slugs
  extend FriendlyId
  friendly_id :title, use: :slugged

  validates :title, :presence => true, :length => {:within => 5..40}

  protected
  def set_asset_path
    self.videos.each do |e|
      e.path = "uploads/#{self.show.slug}/#{self.slug}"
    end
  end

end

Okay let’s step through this line by line (we still haven’t made our STI’s yet, we’ll get to that soon). Firstly we set up our association back to show, it will come in handy. Next up we make a has_many :videos however, it acts as assetable. This tells episode to treat the association as the destination table being polymorphic. So when it looks up it will use the asset_type and asset_id fields in unison to return the relevant record. This doesn’t make the table polymorphic, we need to hook that up in the Asset model also

The accepts_nested_attributes_for property allows us to save videos through the episode model directly to it’s destination table, in this case asset table (we need to make the link, patience). :reject_if is a validation that will ignore the file if it has a null filename. This stops people from submitting the form with a file, and storing a null record into the asset table, bit annoying but very easy to stop.

The before save call runs a special method I’ve made which gives us power to save the file into a dynamic location on the server. In this case I store it in /uploads/show-slug-name/episode-slug/filename.mp3. This is also saved in the database, for your pleasure. Besides that there is yet another friendly slug, to make a slug for our episode and then a basic validation rule on the title. Boom!

ASSETS Model

class Asset < ActiveRecord::Base
  belongs_to :assetable, :polymorphic => true
  before_save :store_metadata

  private
  def store_metadata
  	if self.filename.present? &amp;amp;amp;&amp;amp;amp; self.changed?
  	  file_path = "#{Rails.root}/public/#{self.filename}"
  		file = Mediainfo.new file_path
  		if file.image?
	  		image_meta(file)
	  	elsif file.video?
	  		video_meta(file, file_path)
	  	elsif file.audio?
				audio_meta(file)
	  	end
  	end
  end

  def video_meta(file, file_path)
    self.filesize = file.size
    self.bit_rate = file.video.bit_rate
    self.duration = file.video.duration
    self.checksum = ::Digest::MD5.file(file_path).hexdigest
    self.width = file.video.width
    self.height = file.video.height
  end

end

Now the majority of this model is metadata extraction, we will get to that a bit later. For now we’ll look at line 2, belongs_to. This sets up the association to it self, stating that it’s also polymorphic. This ties in all the love we needed for this model! But our uploaders are not in just yet. We will need to go back and fill in the gaps. And by gaps lets add in our single table inheritance models.

STI <3

Firstly let’s create this model. Make a new folder in app/models and call it episode. Inside it let’s make the file video.rb What is this? This is the middle earth for our association. Rails automatically sets this join up so it seems, so to add this middle point in let’s add some code to get a deeper understanding as to just what is going on!

class Episode::Video < Asset
  mount_uploader :filename, VideoUploader
  attr_accessible :filename, :assets
end

A key point to this file is line 1. This sets up the middle association, Episode::Video, which is the classname, directly extends Asset! Finally! So working backwards. A video is an asset that belongs to an Episode that belongs to a Show! Line 2 sets up the CarrierWave uploader, which we will create shortly. In order to save to the asset table, we need to tell Rails that the attributes to :assets are also accessible (this had me stumped for a bit).

Coming shortly… Carrierwave uploaders, simple_form, and the media info gem love!

Starting off this plugin is currently in it’s infancy. It supports crossfading of whatever elements you want, provided they are wrapped in a container. So if you have a bunch of Div’s, IMG’s, LI’s, or hopes and dreams layered behind one another, the darthFader has you covered.

It also allows you to set up a nav, with forward and back buttons, and dots to replicate how many items in the carousel, of which are clickable to jump you to the item you’ve chosen.

Download the jQuery plugin via:

git clone https://github.com/voidet/jQuery.darthFader /path/to/my/awesome/project

Sites using the force:

http://www.langfordsjewellers.com/

http://www.goplacesbrisbane.com/

http://www.honeybs.tv/

This will save the darthFader plugin ready for you to include in your project. From there you can attach it to your carousel elements by:

$('#carousel-element').darthFader()

Currently there are a few options you can override. The carousel nav element and the pause duration. More will come. I plan on adding a heap more animation styles and configuration options to give more flexibility to the plugin.

However an example on how to override the current options would be:

$('#carousel-element').darthFader({"nav": '#this-is-my-nav-element', 'speed': 5000})

Anyhow let me know if you have any additional features you would like to see included and I will happily consider

Now this isn’t a jailbreak tutorial, unlike the iPhone tuts I’ve written in the past. Otherwise this post would be obsolete before I push the publish button. Instead I’m going to show you how to pair up Plex Media Center’s awesomeness with Trakt’s wickedness so you can follow what you’ve watched, get recommendations and follow trends, all automatically through a scrobbling script.

First of all I will assume you have Plex Media Centre installed on the machine that you are going to scrobble from (this post isn’t at all specific to AppleTV, as the scrobble script analyses Plex Media Centre’s log files). I will also assume you have the libraries set up on your media centre and that you have happily enjoyed viewing content from the server before. Now lastly you will need a Trakt.tv account. They’re free, and damn simple to get so head over to Trakt.tv and set up an account.

Now with all the fluff out of the way lets get started. Ensure the media server is set up and running. Next we’ll clone down the scrobbling script created by Tester22, who seems to be all about the automated torrent and workflow scripts for mac. Open up Terminal.app and:

cd ~/Library/
git clone https://github.com/voidet/Plex-Trakt-Scrobbler.git plextrakt
cd plextrakt

What did we just do here? Well we copied down a running git repository from tester22 of which we will work with now. Next up we need to enter our Trakt.tv username and password:

mv config_sample.ini config.ini
vi config.ini

We moved the sample config.ini to the appropriate config.ini file the scrobble script is expecting. You should now see something like:

[Trakt]
username = your_username
password = your_password

[Optional]
log_path =

We will ignore the log_path for now, but change your_username and your_password to the trait username and password you signed up with. You are using the text editor vim, so if you need a hand look up the shortcuts. But for a quick help, press i to change the cursor to insert text, escape to get pointer back, and shift + zz to save and close. That should be all you need.

With that done we need to test the script. Back in terminal (with vim closed and your config all sorted) run:

python script.py

Now when I first ran this I had some issues, namely with element_tree and simple_json. Quite simply, they weren’t installed. So if you have these issues, lets install them! Back in terminal:

curl -O http://effbot.org/media/downloads/elementtree-1.2.6-20050316.tar.gz
tar xzf elementtree-1.2.6-20050316.tar.gz
cd elementtree-1.2.6-20050316
sudo python setup.py install

Now that’s element tree sorted. Let’s get simple JSON also:

cd ../
curl -O http://pypi.python.org/packages/source/s/simplejson/simplejson-2.3.2.tar.gz#md5=0863e016f682f06ead07dd9efad95194
tar xzf simplejson-2.3.2.tar.gz
cd simplejson-2.3.2
sudo python setup.py install

You should be all sorted now. So let’s try the scrobbling script again:

cd ~/Library/plextrakt
python script.py

If all’s well, which I hope it is, you should see some output put to the screen:

Started monitoring a MacOSX running 10.7.2 with PMS Version 0.9.5.2-bf472e4
This plugin is in version 0.1 and is monitoring the log at /Users/voidet/Library/Logs/Plex Media Server.log
additional data is collected from PMS running at http://localhost:32400/ and reported to trakt.tv with username voidet.

That’s right, my username is voidet. If you don’t see something like this, you borked it, or your setup is not entirely…. set, up. Leave a comment and I’ll try help you figure it out.

So you have the scrobbler running, awesome! But what if you reboot, how do we get this going automatically again. Well let’s add this into a LaunchAgent and call it a day. In terminal do this:

vi ~/Library/LaunchAgents/tv.trakt.plist

Next up, press “i” and paste this in:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
	<dict>
		<key>KeepAlive</key>
			<true/>
		<key>Label</key>
			<string>tv.trakt.plist</string>
		<key>ProgramArguments</key>
			<array>
			<string>/usr/bin/python</string>
			<string>/Users/USERNAME_HERE/Library/plextrakt/script.py</string>
			</array>
		<key>RunAtLoad</key>
			<true/>
	</dict>
</plist>

Ensure you change USERNAME_HERE to be the home directory name of your user. For me, it is voidet. To save press escape then shift + zz. Saved and ready to load, on load…

launchctl load -w ~/Library/LaunchAgents/tv.trakt.plist

Reboot and start watching some TV shows or Movies, because they should start coming into Trakt.tv website where you can start getting great recommendations. Big thanks to Tester22 for they’re amazing work, and merging my pull request, also to the hard work of Trakt team and Plex hackers to get Plex on my AppleTV2!

Why Remember Me

Remember me isn’t just a standard set a cookie and run with it type persistent login handler. Instead remember me uses salted tokens alongside the user’s auto login cookie to protect against session hijacking. The basic gist of the cycle is that a user is given a cookie with a unique set of authentication tokens. When a new login is made these tokens change, and if the user who presents a cookie to renew a session does no longer comply with these tokens, they’re denied and all cookies and sessions are flushed out!

What is different from this plugin to that of the others I find on google? Well RememberMe is secure, as secure as the word can be when written on the internet. It uses a token for its authenticity which is salted to ensure no cookie hijacking is possible. It is also extremely easy to set up. Just clone the plugin, add it to your app controller, add in one line to your login method and add a checkbox to your form. You’ll then have tasty cookies remembering your authenticated users with extremely minimal risk of cookie hijacking.

Installing Remember Me

First watch this. Now install Remember me as a plugin through GitHub:

Github: https://github.com/voidet/remember_me

cd myapp
git clone git://github.com/voidet/remember_me.git remember_me

or if you’re using submodules which you should be:

cd myapp
git submodule add git://github.com/voidet/remember_me.git app/plugins/remember_me
git submodule init
git submodule update

You will also need to add two fields in your database that you use for user auth. The default names are token and token_salt. You can override which is shown in the next section.

From there it is a matter of adding it into your controller and ensuring you have your form fields linked up to what RememberMe is listening for.

Adding Remember Me to your application

Firstly you will need to add RememberMe to your controller, probably best to do this in app_controller.php so it is fired on all pages that use it:

var $components = array('RememberMe.RememberMe');

After that you will need to tell RememberMe what form field you are using to activate the remember me function (like the name of a checkbox on a login screen that asks you if you want to be remembered for a while). The default is “remember_me” but if you want to change it you could do something like:

var $components = array('RememberMe.RememberMe' => array('field_name' => 'i_am_so_custom_it_hurts');

Now add this field into your form and once posted you can set up the RememberMe cookie! Like:

function members_login() {
    if ($this->Auth->user()) {
        if (!empty($this->data)) {
            $this->RememberMe->setRememberMe($this->data[$this->Member->alias]);
        }
        $this->redirect($this->Auth->loginRedirect);
    }
}

Of course this is an example. If you’re using auth remember to disable autoRedirect otherwise this action won’t be fired.

Refresh my Cookie!

A built in method comes with RememberMe. It is used to refresh the contents of the AuthCookie on page load, so it has the longest lifetime it can (without going outside the bounds of inactivity (which you set as a cookie setting)). To do so simply call:

if ($this->params['action'] != 'members_logout') {
        $this->RememberMe->checkUser();
    }

This will refresh the cookie and log the user in if there is no Session available. Of course you don’t want to run this on logout methods, as you won’t be logged out!

Feedback

If you feel this plugin is missing something I would love to hear what you would like me to add in! But otherwise enjoy and please leave some feedback

Titanium is a tool that converts Javascript code to a native iPhone, iPad & Android application. When I say native I don’t mean it is simply a web form that uses the WebUI kit in iOS that some other convert tools use; nope native. I introduce Titanium now because it looks like this is a tool I will be using quite frequently in the near future.

Anyhow getting stuck into development I started with using TitaniumUI’s TableView. It was too easy except after each label I added to a TableViewRow the text was looking not so sharp. At first I thought it was my eyes. Turns out that labels in a TableViewRow with an automatic height make the font rendering a bit blurry.

After looking into the issue for a few more hours and no help on the Q&A’s I decided to get going on a fix. What I came up with was basically generating a label, getting the height of the label, then using that height + 1 pixel to add to the TableViewRow’s height. An example of the fix result:

var win = Titanium.UI.currentWindow;

var yummydata = ['list', 'of', 'elements'];
var rowData = [];
for (var i = 0; i < yummydata.length; i++) {
	var labelToPlace = Titanium.UI.createLabel({
		text: yummydata[i],
		textAlign: 'left'
	});
	var rowHeight = labelToPlace.height + 1;
	rowData[] = Titanium.UI.createTableViewRow({height: rowHeight});
}

var tableView = Titanium.UI.createTableView( { data : rowData } );
win.add(tableView);

I’m not entirely sure why this occurs, and I am fairly new to titanium, but am wondering if it has anything to do with the Row adding in 1px additional for the row separator. Either way this easy fix got the text crisp again.

From here no more introductions

What Is Form Keeper?

This is where Form Keeper steps in. Form Keeper is a CakePHP 1.3 plugin that takes over from where CakePHP’s awesome Form Helper left off. Usually your forms would be constructed in a way like:

<input name="data[ModelName][field_name]" id="ModelNameFieldName" value="" type="hidden" />

This is all well and good. PHP will take those posted results, turn the data into a multidimensional array, pass it onto CakePHP and CakePHP will handle the rest, like a boss. The only problem with this is, it leaves a bad feeling in my stomach, in that, the end user knows your models, your field names in the database. Now there may be no immediate security threat with that, but less information provided, means less information for the end user to get construct blueprints of your database. So with FormKeeper you get:

<input name="6a03949c66c7cc5c7bce550c21308659c1d848a7" type="text" maxlength="40" id="6a03949c66c7cc5c7bce550c21308659c1d848a7">

What FormKeeper Does

Form Keeper takes your forms, with all the power of CakePHP’s FormHelper, and adds a layer of one way encryption to your field names and field id’s. These values are firstly SHA1′d, cached locally into a hash table of your choice (using CakePHP’s cache engine, also check out my CakePHP SuperStack plugin for some cache redundancy action), then outputted to the view. When the form is then submitted, FormKeeper checks the value is in the hash table, reconstructs the data multidimensional array, and inserts the values.

Now if you are thinking “this is all good, but CakePHP’s security component is a mean bastard when it comes to forms and blackhole-ing”, well that part is covered. The tokenizing works just fine with this plugin, so you can use the security component alongside the FormKeeper for obfuscation and form tampering fun.

Setting FormKeeper Up

This is all well and good, but how do I set FormKeeper up? Quite easily, FormKeeper is a CakePHP plugin, so all you need to do is clone the Github repository to your plugins directory and then include both the plugin’s helper and component elements to either your AppController (if you want to use it site wide) or to the controller of your choice.

git clone https://github.com/voidet/form_keeper app/plugins/form_keeper

Or if you use submodules (like you should):

git submodule add https://github.com/voidet/form_keeper app/plugins/form_keeper
git submodule init
git submodule update

From there all that is left is adding it to your controller(s):

<?php

class UsersController extends AppController {

	public $components = array('FormKeeper.FormKeeper');
	public $helpers = array('FormKeeper.FormKeeper');

Now user views have access to the FormKeeper power! But how do views use it? Easy, instead of $this->Form, you will now use $this->FormKeeper, for everything!

<?php

echo $this->FormKeeper->create();
echo $this->FormKeeper->input('username');
echo $this->FormKeeper->input('password');
echo $this->FormKeeper->input('remember_me', array('type' => 'checkbox'));
echo $this->FormKeeper->end('Login');

Configuration

There are two parameters (so far) that you can change for the plugin. It’s as simple as adding in a configuration file into your app/config folder, named form_keeper.php, app/config/form_keeper.php. The two parameters that can be changed is the salt string to encrypt with (if not provided the Security.salt value in core.php will be used) and the cache config that you want to use (by default it will be the default core cache config, which is usually file). So create app/config/form_keeper.php and add in:

<?php

$config['FormKeeper'] = array(
	'salt' => 'ixNE257AeJI2mbVicRwjEFM169seG59lzmxP8N4Z',
	'cacheKey' => 'default',
);

Also please note that the Id’s of the input field are also hashed. To avoid this, you can simply provide an id in your input options, as you would to override cake’s default ID. This is primarily used for object selection in the DOM with jQuery etc.

Security Component

CakePHP has an excellent form tampering protection method that comes standard with the Security Component. It basically takes all the form fields in the view/layout between create and end, serializes their names and then hashes this into a token. The token is stored in a hidden field within the form, and once posted back is then checked against the posted data keys. If there is any variance in the rehashed field names that have been posted and in the token field then the user’s request will be blackHoled, effectively white screen of death (which can be easily overridden for your security pleasure).

FormKeeper maintains this level of security and functionality of CakePHP’s security component. The way FormKeeper achieves this is simply down to order of execution. FormKeeper taps into the power of the Form Helper by overriding how it creates field names. So basically Security Component generates it’s tokens (found in Form::secure()) against FormKeepers new field names. Coming back is also a matter of execution. FormKeeper remaps/restitches the hashed/protected field names back into the proper data[Model][fieldname] structure, because Security Component get’s its eager hands on the data ready to crush with the blackHole method. So in effect FormKeeper gets in and out before Security component knows any different.

Thats It!

This is an early release of the plugin, and is not tested in production just yet. Expect many updates to come in the near future, and hopefully some test cases to be written. Also if you’re using the security component, then please include it after the FormKeeper component at this point in time, as that is what has been *thoroughly* tested with. Thank you in advance for any comments and feedback left! If you’re having issues with the plugin, I usually respond pretty fast with updates or advice. Enjoy!