John Stanfield dot com

A client asked us to show Google Analytics data on one of our sites, so that they would not have to leave our site to get that data. I decided that the best way to do this is to import the requested Google Analytics metrics daily at 3:00 a.m. This way, we query Google Analytics only once per day (rather than on every page request). There is a quota policy on querying Google Analytics data, and this ensures that we don’t come close to filling that quota.

The example below borrows from the Google Analytics curl tester.

There are a few Ruby libraries for accomplishing this task, but my needs were so simple that I preferred to retrieve the XML from Google Analytics and get the metrics from XPath queries.

Google Analytics metrics, request and response, and XML are well-documented.

require 'net/http'
require 'uri'
require 'rexml/document'

http = Net::HTTP.new('www.google.com',443)
http.use_ssl = true

# in order to query Google Analytics, you have to log into Google and acquire an authorization token
path = '/accounts/ClientLogin'
data = {'Email' => 'YOUR_EMAIL',
'Passwd' => 'YOUR_PASSWORD',
'accountType' => 'GOOGLE',
'source' => 'GA-curl-tester',
'service' => 'analytics'}

resp,data = http.post(path,data.to_query)
auth_token = resp.body.split("\n").detect{|x|x=~/^Auth=/}.sub(/^Auth=/,'')

# now use the authorization token get the GA data
data = {'ids' => 'ga:YOUR_ACCOUNT_ID',
'metrics' => 'ga:visitors,ga:pageviews',
'start-date' => '2011-01-01',
'end-date' => Date.yesterday.strftime('%Y-%m-%d')}

path = "/analytics/feeds/data/?#{data.to_query}"
h = {'Authorization' => "GoogleLogin auth=#{auth_token}"}
resp,data = http.get(path,h)
ga_xml_string = resp.body
doc = REXML::Document.new(ga_xml_string)

# you can store these variables in a database or handle them in whatever manner you see fit
ga_visitors=REXML::XPath.first(doc,"//dxp:aggregates/dxp:metric[@name='ga:visitors']").attributes['value']
ga_pageviews=REXML::XPath.first(doc,"//dxp:aggregates/dxp:metric[@name='ga:pageviews']").attributes['value']

Each subdomain on each of our sites has varying, configurable password settings. For example, client A might not care what passwords its users choose. Client B might want a combination of numbers, letters, and symbols with a total length between 8 and 20. I solved this problem by dynamically building the regular expression based on the options chosen by the client.

password_min = 8
password_max = 20
password_min_letters = 0
password_symbols = 2
password_min_numbers = 2

PasswordRegexStubs = {
  :base=>"^.*OPTIONS.*$",
  :length=>"(?=.{MIN_LENGTH,MAX_LENGTH})",
  :symbols=>"(?=.*([@\#\$\%^&\*+=][^@\#\$\%^&\*+=]*){MIN_SYMBOLS})",
  :numbers=>"(?=.*([0-9][^0-9]*){MIN_NUMBERS})",
  :letters=>"(?=.*([a-z,A-Z][^a-z,^A-Z]*){MIN_LETTERS})"
}

options = ""
options << PasswordRegexStubs[:length].gsub('MIN_LENGTH',password_min).gsub('MAX_LENGTH',password_max) if password_min > 0
options << PasswordRegexStubs[:symbols].gsub('MIN_SYMBOLS',password_min_symbols.to_s) if password_min_symbols > 0
options << PasswordRegexStubs[:numbers].gsub('MIN_NUMBERS',password_min_numbers.to_s) if password_min_numbers > 0
options << PasswordRegexStubs[:letters].gsub('MIN_LETTERS',password_min_letters.to_s) if password_min_letters > 0
regex = /#{PasswordRegexStubs[:base].gsub('OPTIONS',options)}/

Now you can use regex however you please…. In Ruby:

'asdf'=~regex
 =>nil

'a$sd3f'=~regex
=>nil

'a$s^d3f2'=~regex
=>0

Or use it in a template or partial for client-side use with Javascript:

In Rails 1.x and 2.x, if you needed to do something advanced with the recipients of an email you could do something like what’s below. I don’t have a straightforward example of why you would want to do this, but it’s something that I did in a delayed-email-delivery plug-in which worked in Rails 1.x and 2.x but needed a little fixing when I moved to Rails 3.x.

  mail = Mailer.create_foo_email
  mail.bcc "John Stanfield <noreply@johnstanfield.com>"
  from = mail.from_addrs.first
  puts "hello from #{from.name} #{from.address}"
  bccs=mail.bcc_addrs
  bccs.each do |bcc|
    puts "hello to #{bcc.name} #{bcc.address}"
  end

However, in Rails 3.x, TMail (and TMail::Address) is no longer used. Rails 3.x uses Mail (and Mail::Address) which behaves differently. To accomplish what’s above, you have to do this:

  mail = Mailer.create_foo_email
  mail.bcc "John Stanfield <noreply@johnstanfield.com>"
  from = Mail::Address.new(mail.header[:from].decoded).name
  puts "hello from #{from.name} #{from.address}"
  bccs = Mail::AddressList.new(mail.header[:bcc].decoded)
  bccs.addresses.each do |bcc|
    puts "hello to #{bcc.name} #{bcc.address}"
  end

Recently a client had me do some data decryption. They use Java, I use Ruby.

Not being a Java developer, I can’t say for sure… But it looks like Java returns printable strings rather than unprintable garbage when encrypting (but maybe it was something the client was doing). Ruby prefers unadulterated garbage. It took a call to the client to figure out why I couldn’t decrypt their string using their supplied key. I tried base-64 decoding and a bunch of other stuff. Turns out I had to take their key and string and decode each set of two characters as the hex representation of the garbage.

In other words, “1234″ is not “1234″ but is instead 0×12 followed by 0×34.

This ended up working.

  # string and key are hex encoded -- 89f8 is 0x89 and 0xf8
  string=s2h("12345678")
  key=s2h("90abcdef")

  aes = OpenSSL::Cipher::Cipher.new('AES-128-ECB')
  aes.decrypt
  aes.key = key
  render :text=>aes.update(string)+aes.final

  # convert "1234" into 0x12 and 0x34
  # convert each of those to integer using base-16
  # return the character represented by that integer
  def s2h(s)
    hex=''
    (s.size/2).times do |t|
      h=s[(t*2)..((t*2)+1)]
      hex<<h.to_i(16).chr
    end
    hex
  end