config.ru
---------

require 'bundler'
Bundler.setup

require 'sinatra'
require 'main'
require 'rack/hoptoad'
require 'sequel'
require 'json'
require 'logger'

use Rack::Hoptoad, 'b6f45e9ce320d8c9d0adf4538317a07a'
disable :run, :reload

run Sinatra::Application



main.rb
-------

helpers do
  def get_locale_id(db)
    locale = extract_locale_from_accept_language_header
    locale_id = db[:languages].select(:id).filter(:locale => locale).first

    if !locale_id
      locale_id = db[:languages].select(:id).filter(:locale => "en").first
    end

    locale_id[:id].to_i
  end

  def get_client_id(db)
    client_id = db[:clients].select(:id).filter(:name => params[:client]).first

    if client_id
      client_id[:id].to_i
    else
      return -1
    end
  end

  def get_environment_id(db, client_id)
    environment_id = db[:environments].select(:id).filter(:client_id => client_id, :name => params[:environment]).first

    if environment_id
      environment_id[:id].to_i
    else
      return -1
    end
  end

  def get_last_modify(db, environment_id)
    environment = db[:environments].select(:updated_at).filter(:id => environment_id).first
    if environment
      puts environment[:updated_at]
      environment[:updated_at].to_i.to_s
    else
      ""
    end
  end

  def extract_locale_from_accept_language_header
    request.env['HTTP_ACCEPT_LANGUAGE'].scan(/^[a-z]{2}/).first
  end

  def connect_to_db
    database = "cms_#{settings.environment.to_s}"
    Sequel.connect(:adapter => 'mysql', :host => 'localhost', :database => database, :user => 'root', :password => '')
  end

  def get_all_keys(db, language_id)
    keys = db[:translation_keys].join_table(:inner, :key_values, {:translation_key_id => :id})
    keys = keys.join_table(:inner, :translation_values, {:id => :translation_value_id})
    keys = keys.filter(:language_id => language_id)
    keys = keys.filter(:client_id => params[:client])
    keys = keys.filter(:environment_id => params[:environment])
  end

  def get_all_keys(db, language_id, client_id, environment_id)
    keys = db[:translation_keys].join_table(:inner, :key_values, {:translation_key_id => :id})
    keys = keys.join_table(:inner, :translation_values, {:id => :translation_value_id})
    #keys = keys.join_table(:inner, :value_environments, {:translation_value_id => :id})
    #keys = keys.join_table(:inner, :environments, {:id => :environment_id})
    keys = keys.filter(:language_id => language_id)
    keys = keys.filter(:translation_keys__client_id => client_id)
    keys = keys.filter(:key_values__environment_id => environment_id)
  end

  def get_tags_sub_query(db, params)
    taggings = db[:taggings]
    sub_query = taggings.join(:tags, :id => :tag_id).filter({:taggable_type => 'TranslationKey'}).select(:taggable_id)
    sub_query = sub_query.filter( :name.like(*params) )
  end

  def replace_blobs_with_strings(hash)
    result = {}
    hash.each_pair{|k,v| result[k.to_s] = v.to_s}
    result
  end

  def add_slash_to_values(hash)
    result = {}
    hash.each_pair{|k,v| result[k] = '/' + v}
    result
  end

  def add_client_to_values(hash, client_name)
    result = {}
    hash.each_pair{|k,v| result["#{k}_environment_uri"] = "/#{client_name}/" + v}
    result
  end
end

get '/' do
  {"clients_uri" => "/clients"}.to_json
end

get '/clients' do
  db = connect_to_db

  result = ""
  hash = db[:clients].select(:description, :name).to_hash(:description, :name)
  if hash
    result = replace_blobs_with_strings(hash)
    result = add_slash_to_values(result)
  end

  if !result.empty?
    result.to_json
  else
    status 404
  end
end

get '/:client' do
  db = connect_to_db
  client_name = params[:client]
  client_id = db[:clients].select(:id).filter(:name => client_name)

  result = ""
  hash = db[:environments].select(:name).filter(:client_id => client_id).to_hash(:name, :name)
  if hash
    result = replace_blobs_with_strings(hash)
    result = add_client_to_values(hash, client_name)
  end

  if !result.empty?
    result.to_json
  else
    status 404
  end
end

#/ext/qa or /ext/qa?key=key1
get '/:client/:environment' do
  if params['key']
    db = connect_to_db
    language_id = get_locale_id(db)
    client_id = get_client_id(db)
    environment_id = get_environment_id(db, client_id)

    result = ""
    if client_id != -1 and environment_id != -1
      keys = get_all_keys(db, language_id, client_id, environment_id)
      result = keys.select(:translation_keys__name, :text).filter(:translation_keys__name => params['key']).all
    end

    if !result.empty?
      result[0][:text].to_s
    else
      status 404
    end
  else # /ext/qa
    db = connect_to_db
    client_name = params[:client]
    environment_name = params[:environment]

    client = db[:clients].select(:id).filter(:name => client_name).first
    client_id = client[:id] if client

    environment = db[:environments].select(:id).filter(:name => environment_name, :client_id => client_id).first

    result = ""
    if client_id and environment
      last_modify_time = get_last_modify(db, environment[:id])

      result = {"modification_time" => last_modify_time,
                "key_list_uri" => "/#{client_name}/#{environment_name}/all",
                "key_search_uri" => "/#{client_name}/#{environment_name}?key=key1"}
    end

    if !result.empty?
      result.to_json
    else
      status 404
    end
  end
end

#ext/qa/all or ext/qa/all?tags=tag1,tag2
get '/:client/:environment/all' do
  if params['tags']
    db = connect_to_db
    language_id = get_locale_id(db)
    client_id = get_client_id(db)
    environment_id = get_environment_id(db, client_id)

    result = ""
    if client_id != -1 and environment_id != -1
      keys = get_all_keys(db, language_id, client_id, environment_id)
      sub_query = get_tags_sub_query(db, params['tags'].split(','))
      keys = keys.filter(:translation_keys__id => sub_query)
      hash = keys.select(:translation_keys__name, :text).to_hash(:name, :text)
      result = replace_blobs_with_strings(hash)
    end

    if !result.empty?
      result.to_json
    else
      status 404
    end

  else # ext/qa/all
    db = connect_to_db
    language_id = get_locale_id(db)
    client_id = get_client_id(db)
    environment_id = get_environment_id(db, client_id)

    result = ""
    if client_id != -1 and environment_id != -1
      keys = get_all_keys(db, language_id, client_id, environment_id)
      hash = keys.select(:translation_keys__name, :text).to_hash(:name, :text)
      result = replace_blobs_with_strings(hash)
    end

    if !result.empty?
      result.to_json
    else
      status 404
    end
  end
end