appoxy_rails 0.0.6

data/README.markdown

@@ -0,0 +1 @@
+Nada.

data/lib/api/api_controller.rb

@@ -0,0 +1,106 @@
+module Appoxy
+
+    module Api
+
+        # The api controllers that use this should set:
+#        protect_from_forgery :only => [] # can add methods to here, eg: :create, :update, :destroy
+
+#                rescue_from SigError, :with => :send_error
+#                rescue_from Api::ApiError, :with => :send_error
+        # before_filter :verify_signature(params)
+
+        # Your Controller must define a secret_key_for_signature method which will return the secret key to use to generate signature.
+
+        module ApiController
+
+            def verify_signature
+                params2 = nil
+                if request.put? || request.post?
+                    # We'll extract params from body instead here
+                    # todo: maybe check for json format first in case this is a file or something?
+                    body = request.body.read
+                    puts 'body=' + body.inspect
+                    params2 = ActiveSupport::JSON.decode(body)
+                    puts 'params2=' + params2.inspect
+                    params.merge! params2
+                end
+
+                #operation = "#{controller_name}/#{action_name}"
+                operation = request.env["PATH_INFO"].gsub(/\/api\//, "")# here we're getting original request url'
+                puts "XXX " + operation
+
+                #getting clean params (without parsed via routes)
+                params_for_signature = params2||request.query_parameters
+                #removing mandatory params
+                params_for_signature = params_for_signature.delete_if {|key, value| ["access_key", "sigv", "sig", "timestamp"].include? key}
+
+
+                #p "params " +operation+Appoxy::Api::Signatures.hash_to_s(params_for_signature)
+                access_key = params["access_key"]
+                sigv = params["sigv"]
+                timestamp = params["timestamp"]
+                sig = params["sig"]
+
+                raise Appoxy::Api::ApiError, "No access_key" if access_key.nil?
+                raise Appoxy::Api::ApiError, "No sigv" if sigv.nil?
+                raise Appoxy::Api::ApiError, "No timestamp" if timestamp.nil?
+                raise Appoxy::Api::ApiError, "No sig" if sig.nil?
+                timestamp2 = Appoxy::Api::Signatures.generate_timestamp(Time.now.gmtime)
+                raise Appoxy::Api::ApiError, "Request timed out!" unless (Time.parse(timestamp2)-Time.parse(timestamp))<60 # deny all requests older than 60 seconds
+                # Get application defined secret_key
+                secret_key = secret_key_for_signature(access_key)
+                sig2 = Appoxy::Api::Signatures.generate_signature(operation+Appoxy::Api::Signatures.hash_to_s(params_for_signature), timestamp, secret_key)
+                #p "signature 1 " + sig2 + " signature 2 " + sig
+                raise Appoxy::Api::ApiError, "Invalid signature!" unless sig == sig2
+
+                puts 'Verified OK'
+                true
+
+            end
+
+
+            def sig_should
+                raise "You didn't define a sig_should method in your controller!"
+            end
+
+
+            def send_ok(msg={})
+                response_as_string = '' # in case we want to add debugging or something
+#                respond_to do |format|
+                #                format.json { render :json=>msg }
+                response_as_string = render_to_string :json => msg
+                render :json => response_as_string
+#                end
+                true
+            end
+
+
+            def send_error(statuscode_or_error, msg=nil)
+                exc = nil
+                if statuscode_or_error.is_a? Exception
+                    exc = statuscode_or_error
+                    statuscode_or_error = 400
+                    msg = exc.message
+                end
+                # deprecate status, should use status_code
+                json_msg = {"status_code"=>statuscode_or_error, "msg"=>msg}
+                render :json=>json_msg, :status=>statuscode_or_error
+                true
+            end
+
+
+        end
+
+
+        class ApiError < StandardError
+
+            def initialize(msg=nil)
+                super(msg)
+
+            end
+
+        end
+
+    end
+
+end

data/lib/api/client.rb

@@ -0,0 +1,110 @@
+module Appoxy
+    module Api
+
+        require 'rest_client'
+
+        # Subclass must define:
+        #  host: endpoint url for service
+        class Client
+
+            attr_accessor :host, :access_key, :secret_key
+
+
+            def initialize(host, access_key, secret_key, options={})
+                @host = host
+                @access_key = access_key
+                @secret_key = secret_key
+            end
+
+
+            def get(method, params={}, options={})
+                begin
+#                ClientHelper.run_http(host, access_key, secret_key, :get, method, nil, params)
+                    parse_response RestClient.get(append_params(url(method), add_params(method, params)), headers)
+                rescue RestClient::BadRequest => ex
+#                    puts ex.http_body
+                    raise "Bad Request: " + ActiveSupport::JSON.decode(ex.http_body)["msg"].to_s
+                end
+            end
+
+
+            def post(method, params={}, options={})
+                begin
+                    parse_response RestClient.post(url(method), add_params(method, params).to_json, headers)
+                    #ClientHelper.run_http(host, access_key, secret_key, :post, method, nil, params)
+                rescue RestClient::BadRequest => ex
+#                    puts ex.http_body
+                    raise "Bad Request: " + ActiveSupport::JSON.decode(ex.http_body)["msg"].to_s
+                end
+
+            end
+
+
+            def put(method, body, options={})
+                begin
+                    parse_response RestClient.put(url(method), add_params(method, body).to_json, headers)
+                    #ClientHelper.run_http(host, access_key, secret_key, :put, method, body, nil)
+                rescue RestClient::BadRequest => ex
+#                    puts ex.http_body
+                    raise "Bad Request: " + ActiveSupport::JSON.decode(ex.http_body)["msg"].to_s
+                end
+            end
+
+
+            def delete(method, params={}, options={})
+                begin
+                    parse_response RestClient.delete(append_params(url(method), add_params(method, params)))
+                rescue RestClient::BadRequest => ex
+                    raise "Bad Request: " + ActiveSupport::JSON.decode(ex.http_body)["msg"].to_s
+                end
+            end
+
+
+            def url(command_path)
+                url = host + command_path
+                url
+            end
+
+
+            def add_params(command_path, hash)
+                ts = Appoxy::Api::Signatures.generate_timestamp(Time.now.gmtime)
+                #p "hash_to s" + command_path + Appoxy::Api::Signatures.hash_to_s(hash)
+                sig = Appoxy::Api::Signatures.generate_signature(command_path + Appoxy::Api::Signatures.hash_to_s(hash), ts, secret_key)
+                extra_params = {'sigv'=>"0.1", 'sig' => sig, 'timestamp' => ts, 'access_key' => access_key}
+                hash.merge!(extra_params)
+
+            end
+
+
+            def append_params(host, params)
+                host += "?"
+                i = 0
+                params.each_pair do |k, v|
+                    host += "&" if i > 0
+                    host += k + "=" + CGI.escape(v)
+                    i+=1
+                end
+                return host
+            end
+
+
+            def headers
+                user_agent = "Appoxy API Ruby Client"
+                headers = {'User-Agent' => user_agent}
+            end
+
+
+            def parse_response(response)
+                begin
+                    return ActiveSupport::JSON.decode(response.to_s)
+                rescue => ex
+                    puts 'response that caused error = ' + response.to_s
+                    raise ex
+                end
+            end
+
+
+        end
+
+    end
+end

data/lib/api/client_helper.rb

@@ -0,0 +1,32 @@
+module Appoxy
+    module Api
+
+        require 'rest_client'
+
+        module ClientHelper
+
+
+        end
+
+        class ClientError < StandardError
+
+            attr_reader :response_hash
+
+            def initialize(class_name, response_hash)
+                puts 'response-hash=' + response_hash.inspect
+                super("#{class_name} - #{response_hash["msg"]}")
+                @response_hash = response_hash
+            end
+        end
+
+        class ServiceError < StandardError
+            attr_reader :body
+
+            def initialize(class_name, body)
+                super("#{class_name}")
+                @body = body
+
+            end
+        end
+    end
+end

data/lib/api/signatures.rb

@@ -0,0 +1,26 @@
+module Appoxy
+    module Api
+        module Signatures
+
+
+            def self.generate_timestamp(gmtime)
+                return gmtime.strftime("%Y-%m-%dT%H:%M:%SZ")
+            end
+
+
+            def self.generate_signature(operation, timestamp, secret_key)
+                my_sha_hmac = Digest::HMAC.digest(operation + timestamp, secret_key, Digest::SHA1)
+                my_b64_hmac_digest = Base64.encode64(my_sha_hmac).strip
+                return my_b64_hmac_digest
+            end
+
+
+            def self.hash_to_s(hash)
+                str = ""
+                hash.each_pair {|key, value| str+= "#{key}#{value}" }
+                #removing all characters that could differ after parsing with rails
+                return str.delete "\"\/:{}[]\' T"
+            end
+        end
+    end
+end

data/lib/appoxy_api.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext'
+require 'digest/hmac'
+require 'net/http'
+require 'base64'
+  
+require File.join(File.dirname(__FILE__), "api", "api_controller")
+require File.join(File.dirname(__FILE__), "api", "client_helper")
+require File.join(File.dirname(__FILE__), "api", "signatures")
+require File.join(File.dirname(__FILE__), "api", "client")
+

data/lib/appoxy_sessions.rb

@@ -0,0 +1,6 @@
+require 'simple_record'
+require File.join(File.dirname(__FILE__), "sessions", "user")
+require File.join(File.dirname(__FILE__), "sessions", "application_controller")
+require File.join(File.dirname(__FILE__), "sessions", "sessions_controller")
+require File.join(File.dirname(__FILE__), "sessions", "users_controller")
+require File.join(File.dirname(__FILE__), "sessions", "shareable")

data/lib/appoxy_ui.rb

@@ -0,0 +1,2 @@
+require File.join(File.dirname(__FILE__), "ui", "application_helper")
+

data/lib/sessions/application_controller.rb

@@ -0,0 +1,82 @@
+module Appoxy
+
+    module Sessions
+        module ApplicationController
+
+
+            def logout_keeping_session!
+                @current_user = nil # not logged in, and don't do it for me
+                session[:user_id] = nil # keeps the session but kill our variable
+            end
+
+
+            def logged_in?
+                #puts 'logged_in??'
+                #puts 'current_user=' + current_user.inspect
+                current_user
+            end
+
+
+            def current_user=(new_user)
+                session[:user_id] = new_user ? new_user.id : nil
+                @current_user = new_user
+            end
+
+
+            def current_user
+                @current_user ||= (login_from_session)
+                @current_user
+            end
+
+
+            def login_from_session
+                #puts 'Login from session=' + session[:user_id].inspect
+                ::User.find_by_id(session[:user_id]) if session[:user_id]
+            end
+
+#
+#            helper_method :logged_in?
+#            helper_method :current_user
+
+
+            protected
+
+            def random_string(length=10)
+                chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
+                password = ''
+                length.times { password << chars[rand(chars.size)] }
+                password
+            end
+
+            def authenticate
+                if !logged_in?
+                    flash[:warning] = "You need to login to access this page."
+                    session[:return_to] = request.request_uri # return to after logging in
+                    puts "ac=" + params[:ac].inspect
+                    if params[:user_id] && params[:ac]
+                        # todo: should we store ac in cookie?  Make it easier to pass around
+                        cookies[:ac] = params[:ac]
+                        # then from an invite
+                        user = ::User.find(params[:user_id])
+                        if user && user.password.blank? # is this the best way to decide of user has not logged in? Could also check status.
+                            redirect_to :controller=>"users", :action=>"new", :email=>user.email, :ac=>params[:ac]
+                            return
+                        end
+                    end
+                    redirect_to :controller=>"sessions", :action=>"new", :ac=>params[:ac]
+                end
+
+                after_authenticate
+
+            end
+            def after_authenticate
+
+            end
+
+
+
+        end
+
+    end
+
+end

data/lib/sessions/sessions_controller.rb

@@ -0,0 +1,119 @@
+module Appoxy
+
+    module Sessions
+        module SessionsController
+
+            def new
+                
+            end
+
+            def create
+                before_create
+
+                logout_keeping_session!
+
+                #puts 'params=' + params.inspect
+                @email = params[:email]
+                @has_password = params[:has_password]
+                #puts 'has_pass? ' + @has_password.inspect
+
+                if params[:has_password].blank?
+                    flash[:error] = "Please click the radio button to let us know if you have a password or not."
+                    render :action=>"new"
+                    return
+                end
+
+                if @has_password == "true"
+                    user = ::User.find_by_email(@email)
+#                    user = User.authenticate(@email, params[:password])
+                    if user && user.authenticate(params[:password])
+                        self.current_user = user
+                        flash[:info] = "Logged in successfully."
+                        orig_url = session[:return_to]
+                        puts 'orig_url = ' + orig_url.to_s
+                        session[:return_to] = nil
+                        if !orig_url.nil?
+                            redirect_to orig_url  # if entered via a different url
+                        else
+                            after_create
+                        end
+                        user.last_login = Time.now
+                        user.save(:dirty=>true)
+                    else
+                        flash[:info] = "Invalid email or password. Please try again."
+                        render :action => 'new'
+                    end
+                else
+                    # new user
+
+                    redirect_to (new_user_path + "?email=#{@email}")
+                end
+
+            end
+
+            def before_create
+
+            end
+            def after_create
+
+            end
+
+
+            def reset_password
+                before_reset_password
+
+                unless verify_recaptcha
+                    flash[:error] = "You are not human! Please try again."
+                    render :action=>"forgot_password"
+                    return
+                end
+
+                @email = params[:email]
+                unless User.email_is_valid? @email
+                    flash[:error] = "You must enter a valid email."
+                    render :action=>"forgot_password"
+                    return
+                end
+
+                @user = ::User.find_by_email(@email)
+                unless @user
+                    flash[:error] = "Email not found."
+                    render :action=>"forgot_password"
+                    return
+                end
+
+                @newpass = random_string(8)
+
+                @user.password = @newpass
+                @user.save(:dirty=>true)
+
+                flash[:success] = "Password reset. You should receive an email shortly with a new password."
+                redirect_to :action=>"new"
+
+                after_reset_password
+            end
+
+            def before_reset_password
+
+            end
+
+            # This is a great spot to send an email with the new password (the only spot actually).
+            def after_reset_password
+
+            end
+
+            def destroy
+                logout
+            end
+
+            def logout
+                @current_user = nil
+                reset_session
+                flash[:info] = "You have been logged out."
+                redirect_to('/')
+            end
+
+
+        end
+    end
+end

data/lib/sessions/shareable.rb

@@ -0,0 +1,206 @@
+require 'aws'
+require 'simple_record'
+
+module Appoxy
+    module Sessions
+        module Shareable
+
+            # Call this method on your Sharable object to share it with the person.
+            # returns: a hash with :user (the user that the item was shared with), :ac (activation code that should be sent to the user)
+            #          or false if couldn't be shared.
+            # You can check for errors by looking at the errors array of the object.
+            # Eg:
+            #   if my_ob.share_with(x)
+            #      # all good
+            #      Mail the user a link that contains user_id and ac, this gem will take care of the rest.
+            #   else
+            #      # not all good, check errors
+            #      errors = my_ob.errors
+            #   end
+
+            def share_with(email, access_rights={}, options={})
+
+                access_rights = {} if access_rights.nil?
+
+                @email = email.strip
+
+                if @email == self.user.email
+                    self.errors.add_to_base("User already owns this item.")
+                    return false
+                end
+
+                user = ::User.find_by_email(@email)
+                if user.nil?
+                    # lets create the user and send them an invite.
+                    user = ::User.new(:email=>@email, :status=>"invited")
+                    user.set_activation_code # todo: this shouldn't be on user anymore
+                    if user.save
+
+                    else
+                        self.errors = user.errors
+                        return false
+                    end
+                end
+                activation_code = user.activation_code
+
+                # check if exists
+                share_domain = self.share_domain
+                item_id_name = self.item_id_name
+#                puts 'share_domain = ' + share_domain.inspect
+                @sdb = SimpleRecord::Base.connection
+#        @shared_with = share_class.find(:first, :conditions=>["user_id = ? and item_id = ?", user.id, @item.id])
+                @project_user = Shareable.get_results(:first, ["select * from #{share_domain} where user_id=? and #{item_id_name} = ?", user.id, self.id])
+                puts 'sharing user=' + @project_user.inspect
+                unless @project_user.nil?
+                    self.errors.add_to_base("This item is already shared with #{email}.")
+                    return false
+                end
+
+                now = Time.now
+                id = share_id(user)
+                @sdb.put_attributes(share_domain, id, {:new_share=>true,
+                                                       :id=>id,
+                                                       :created=>SimpleRecord::Translations.pad_and_offset(now),
+                                                       :updated=>SimpleRecord::Translations.pad_and_offset(now),
+                                                       :user_id => user.id,
+                                                       :activation_code=>activation_code,
+                                                       :status=>"invited",
+                                                       item_id_name => self.id}.merge(access_rights),
+                                    true,
+                                    :create_domain=>true)
+
+#                ret = {
+#                        :user=>user,
+#                        :ac=>activation_code
+#                }
+#                return ret
+                return user
+
+            end
+
+            def item_id_name
+                return self.class.name.foreign_key
+            end
+
+            def common_attributes
+                ["new_share", "id", "created", "updated", "user_id", item_id_name]
+            end
+
+            # Returns a list of users that this item is shared with.
+            def shared_with
+                project_users = Shareable.get_results(:all, ["select * from #{share_domain} where #{item_id_name} = ?", self.id])
+                user_ids = []
+                options_hash = {}
+                project_users.each do |puhash|
+                    puhash.each_pair do |k, v|
+                        puhash[k] = v[0]
+                    end
+                    puts 'puhash=' + puhash.inspect
+                    user_ids << puhash["user_id"]
+                    options_hash[puhash["user_id"]] = puhash
+                end
+                ret = ::User.find(:all, :conditions=>["id in ('#{user_ids.join("','")}')"]).collect do |u|
+                    def u.share_options=(options=nil)
+                        instance_variable_set(:@share_options, options)
+                    end
+
+                    def u.share_options
+                        instance_variable_get(:@share_options)
+                    end
+
+                    u.share_options=options_hash[u.id]
+                    u
+                end
+                ret
+            end
+
+            # this unshares by the 
+            def unshare_by_id(id)
+#        @project_user = ProjectUser.find(params[:pu_id])
+#        @project_user.delete
+#                puts 'unsharing ' + id.to_s
+                @sdb = SimpleRecord::Base.connection
+                puts "delete_attributes=" + @sdb.delete_attributes(share_domain, id.to_s).inspect
+#                puts 'deleted?'
+            end
+
+            # Unshare by user.
+            def unshare(user)
+                @sdb = SimpleRecord::Base.connection
+                @sdb.delete_attributes(share_domain, share_id(user))
+#                @project_user = Shareable.get_results(:first, ["select * from #{share_domain} where user_id=? and #{item_id_name} = ?", user.id, self.id])
+#                @project_user.each do |pu|
+#                    @sdb.delete_attributes(share_domain, pu["id"])
+#                end
+            end
+
+            def update_sharing_options(user, options={})
+                options={} if options.nil?
+#                puts 'options=' + ({ :updated=>Time.now }.merge(options)).inspect
+                @sdb = SimpleRecord::Base.connection
+                @project_user = Shareable.get_results(:first, ["select * from #{share_domain} where user_id=? and #{item_id_name} = ?", user.id, self.id])
+                # compare values
+                to_delete = []
+                @project_user.each_pair do |k, v|
+                    if !common_attributes.include?(k) && !options.include?(k)
+                        to_delete << k
+                    end
+                end
+                if to_delete.size > 0
+                    puts 'to_delete=' + to_delete.inspect
+                    @sdb.delete_attributes(share_domain, share_id(user), to_delete)
+                end
+                @sdb.put_attributes(share_domain, share_id(user), {:updated=>Time.now}.merge(options), true)
+
+            end
+
+            def share_id(user)
+                "#{self.id}_#{user.id}"
+            end
+
+            def share_domain
+#                puts 'instance share_domain'
+                ret = self.class.name + "User"
+#                puts 'SHARE_NAME=' + ret
+                ret = ret.tableize
+#                puts 'ret=' + ret
+                ret
+            end
+
+
+            def self.get_results(which, q)
+                @sdb = SimpleRecord::Base.connection
+                next_token = nil
+                ret = []
+                begin
+                    begin
+                        response =  @sdb.select(q, next_token)
+                        rs = response[:items]
+                        rs.each_with_index do |i, index|
+                            puts 'i=' + i.inspect
+                            i.each_key do |k|
+                                puts 'key=' + k.inspect
+                                if which == :first
+                                    return i[k].update("id"=>k)
+                                end
+                                ret << i[k]
+                            end
+#    break if index > 100
+                        end
+                        next_token = response[:next_token]
+                    end until next_token.nil?
+                rescue Aws::AwsError, Aws::ActiveSdb::ActiveSdbError
+                    if ($!.message().index("NoSuchDomain") != nil)
+                        puts 'NO SUCH DOMAIN!!!'
+                        # this is ok
+                    else
+                        raise $!
+                    end
+                end
+                which == :first ? nil : ret
+            end
+
+        end
+    end
+end
+	

data/lib/sessions/user.rb

@@ -0,0 +1,76 @@
+module Appoxy
+
+    module Sessions
+
+        class User < SimpleRecord::Base
+
+            def self.included(base)
+                puts self.name + " included in " + base.name
+            end
+
+
+            has_strings    :email,
+                           {:name => :password, :hashed=>true},
+                           :first_name,
+                           :last_name,
+                           :remember_me,
+                           :activation_code,
+                           :status # invited, active
+
+            has_dates :last_login
+
+
+            def validate
+                errors.add("email", "is not valid") unless User.email_is_valid?(email)
+
+                if status == "invited"
+                    # doesn't need password
+                else
+                    errors.add("password", "must be at least 6 characters long.") if password.blank?
+                end
+            end
+
+
+            def self.email_is_valid?(email)
+                return email.present? && email =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
+            end
+
+
+            def is_active?
+                status == "active"
+            end
+
+
+
+            def set_activation_code
+                self.activation_code=Digest::SHA1.hexdigest(email.to_s+Time.now.to_s)
+            end
+
+
+            def activate!
+                self.activation_code=nil
+                self.status = "active"
+            end
+
+
+
+            def authenticate(password)
+
+                return nil if attributes["password"].blank? # if the user has no password (will this happen?  maybe for invites...)
+
+                # This is a normal unencrypted password, temporary
+                if attributes["password"][0].length < 100
+                    self.password = attributes["password"][0]
+                    self.save
+                end
+
+                (self.password == password) ? self : nil
+            end
+
+
+        end
+
+    end
+
+end
+

data/lib/sessions/users_controller.rb

@@ -0,0 +1,122 @@
+module Appoxy
+
+    module Sessions
+        module UsersController
+
+
+            def new
+                before_new
+                if params[:id]
+                    @user = ::User.find params[:id]
+                else
+                    @user = ::User.new
+                    @user.email = params[:email] if params[:email]
+                end
+                @user.activation_code = params[:ac] if params[:ac]
+                after_new
+            end
+
+            def before_new
+
+            end
+
+            def after_new
+
+            end
+
+            def create
+
+                before_create
+
+                @user = ::User.new(params[:user])
+
+                if @user.password != params[:password_confirmation]
+                    flash[:error] = "Confirmation password does not match. Please try again."
+                    render :action=>"new"
+                    return
+                end
+
+                if params[:user][:password].length < 6
+                    flash[:error] = "Password can not be less than 6 characters."
+                    render :action=>"new"
+                    return
+                end
+
+                existing_user = ::User.find_by_email(@user.email)
+
+                if existing_user
+                    if params[:ac]
+                        
+                    end
+                    # todo: remove activation_code on user
+                    if @user.activation_code.present?
+                        # hasn't logged in yet, probably invited, need to check access key
+                        if existing_user.activation_code == @user.activation_code
+                            existing_user.activate!
+                            existing_user.password = @user.password
+                            @user = existing_user
+                        end
+                    else
+                        flash[:error] = "The email you entered already exists in our system. You might want to try logging in if you already have an account."
+                        render :action=>"new"
+                        return
+                    end
+                else
+                    @user.status = "active"
+                end
+
+                before_save_in_create
+                if @user.save
+                    self.current_user = @user
+                    flash[:success] = "Your account was created successfully."
+                    after_save_in_create
+                    after_create
+                else
+                    render :action => "new"
+                end
+
+            end
+
+            def before_create
+
+            end
+
+            def before_save_in_create
+
+            end
+
+            def after_save_in_create
+
+            end
+
+            def after_create
+
+            end
+
+
+            # Usually a user gets here via an activation link in email.
+            def activate
+                logout_keeping_session!
+                @user = ::User.find_by_activation_code(params[:ac]) unless params[:ac].blank?
+                case
+                    when (!params[:ac].blank?) && @user && !@user.is_active?
+                        flash[:info] = "Account activated. please login."
+                        @user.activate!
+                        redirect_to login_url
+                    when params[:ac].blank?
+                        flash[:error] = "The activation code was missing.  Please follow the URL from your email."
+                        redirect_to(root_url)
+                    else
+                        flash[:error] = "We couldn't find a user with that activation code -- check your email? Or maybe you've already activated -- try signing in."
+                        redirect_to(root_url)
+                end
+            end
+
+        end
+
+
+    end
+
+
+end
+

data/lib/ui/application_helper.rb

@@ -0,0 +1,35 @@
+module Appoxy
+
+    module UI
+
+        module ApplicationHelper
+
+            def self.included(base)
+#                puts self.class.name + " included in " + base.class.name
+            end
+
+
+            def current_url
+                request.url
+            end
+
+            def flash_messages
+                s = ""
+                flash.each_pair do |type, msg|
+                    if msg.is_a?(Array)
+                        msg.each do |m|
+                            s << content_tag(:div, m, :class => type)
+                        end
+                    else
+                        s << content_tag(:div, msg, :class => type)
+                    end
+                end
+                s.html_safe
+            end
+
+        end
+
+    end
+
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: appoxy_rails
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 6
+  version: 0.0.6
+platform: ruby
+authors: 
+- Travis Reeder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-23 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Appoxy API Helper gem description...
+email: travis@appoxy.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- lib/api/api_controller.rb
+- lib/api/client.rb
+- lib/api/client_helper.rb
+- lib/api/signatures.rb
+- lib/appoxy_api.rb
+- lib/appoxy_sessions.rb
+- lib/appoxy_ui.rb
+- lib/sessions/application_controller.rb
+- lib/sessions/sessions_controller.rb
+- lib/sessions/shareable.rb
+- lib/sessions/user.rb
+- lib/sessions/users_controller.rb
+- lib/ui/application_helper.rb
+- README.markdown
+has_rdoc: true
+homepage: http://www.appoxy.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Appoxy Rails Helper gem
+test_files: []
+