softwear 2.0.0

data/lib/softwear/auth/stubbed_model.rb

@@ -0,0 +1,130 @@
+module Softwear
+  module Auth
+    # =======================================================================
+    # In development, unless ENV['AUTH_SERVER'] is set, Softwear::Auth::Model is
+    # set to this StubbedModel. The StubbedModel does not contact the auth_server,
+    # and instead retrieves user info from config/users.yml, which assumes the
+    # following format:
+=begin
+---
+signed_in: nigel@annarbortees.com
+
+users:
+  admin@softwearcrm.com:
+    first_name: Admin
+    last_name:  User
+    roles:
+      - sales_manager
+
+  nigel@annarbortees.com:
+    first_name: Nigel
+    last_name:  Baillie
+    roles:
+      - developer
+      - admin
+
+  ricky@annarbortees.com:
+    first_name: Ricky
+    last_name:  Winowiecki
+    roles:
+      - developer
+      - administrator
+=end
+    # Changes in this .yml file will be reflected live, without restarting your
+    # server.
+    # =======================================================================
+    class StubbedModel < Softwear::Auth::StandardModel
+      class << self
+        def raw_query(m, *args)
+          return 'yes' if m =~ /^token/
+          raise %[Cannot perform auth server queries on stubbed auth model. (tried to send "#{m.split(/\s+/).first} ..." query)]
+        end
+
+        def users_yml_file
+          Rails.root.join('config', 'users.yml').to_s
+        end
+
+        def users_yml
+          if @users_yml
+            yml_mtime = File.mtime(users_yml_file)
+
+            if @users_yml_modified.nil? || yml_mtime > @users_yml_modified
+              @users_yml_modified = yml_mtime
+              @users_yml = nil
+            end
+          else
+            @users_yml_modified = File.mtime(users_yml_file)
+          end
+
+          if @users_yml.nil?
+            @users_yml = YAML.load(IO.read(users_yml_file)).with_indifferent_access
+            @users_yml[:users].to_a.each_with_index do |entry, i|
+              entry[1][:id] ||= i + 1
+            end
+          end
+          @users_yml
+        end
+
+        #
+        # Transforms
+        # ['email@email.com', { 'attr1' => 'val1', 'attr2' => 'val2' }]
+        # From the yml format
+        #
+        # Into
+        # { 'email' => 'email@email.com', 'attr1' => 'val1', 'attr2' => 'val2' }
+        #
+        def yml_entry(entry, id_if_default = nil)
+          attributes = {}.with_indifferent_access
+
+          if entry.nil?
+            entry = ['usernotfound@example.com', { first_name: 'Unknown', last_name: 'User', id: id_if_default || -1 }]
+          end
+
+          attributes[:email] = entry[0]
+          attributes.merge!(entry[1])
+          if attributes[:profile_picture]
+            attributes[:profile_picture_url] ||= "file://#{attributes[:profile_picture]}"
+          end
+
+          new(attributes).tap { |u| u.instance_variable_set(:@persisted, true) }
+        end
+
+        def find(target_id)
+          return nil if target_id.nil?
+          yml_entry users_yml[:users].to_a[target_id.to_i - 1], target_id.to_i
+        end
+
+        def all
+          users_yml[:users].to_a.map(&method(:yml_entry))
+        end
+
+        def of_role(*roles)
+          roles = Array(roles).map(&:to_s)
+          all.select { |u| !u.roles.nil? && roles.any? { |r| u.roles.include?(r) } }
+        end
+
+        def auth(_token, _appname = nil)
+          signed_in = users_yml[:signed_in]
+
+          yml_entry [signed_in, users_yml[:users][signed_in]] unless signed_in.blank?
+        end
+      end
+
+      def yml_entry(*args)
+        self.class.yml_entry(*args)
+      end
+      def users_yml(*args)
+        self.class.users_yml(*args)
+      end
+
+      def reload
+        update_attributes yml_entry users_yml[:users].to_a[id - 1]
+        self
+      end
+
+      def valid_password?
+        true
+      end
+    end
+  end
+end

data/lib/softwear/auth/token_authentication.rb

@@ -0,0 +1,72 @@
+module Softwear
+  module Auth
+    module TokenAuthentication
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :user_class
+        cattr_accessor :token_auth_options
+      end
+
+      def token_authenticate_user!
+        user_class = self.class.user_class || base_class.user_class || User
+        options    = (self.class.token_auth_options || base_class.token_auth_options || {}).with_indifferent_access
+        params_options  = (options[:params]  || {}).with_indifferent_access
+        headers_options = (options[:headers] || {}).with_indifferent_access
+
+        email_param  = params_options[:email]                 || 'user_email'
+        token_param  = params_options[:authentication_token]  || 'user_token'
+        email_header = headers_options[:email]                || 'X-User-Email'
+        token_header = headers_options[:authentication_token] || 'X-User-Token'
+
+        email = params[email_param] || request.headers[email_header]
+        token = params[token_param] || request.headers[token_header]
+
+        return render_unauthorized if email.blank? || token.blank?
+
+        case user_class.query "token #{Figaro.env.hub_app_name} #{email} #{token}"
+        when 'no'      then render_unauthorized
+        when 'invaild' then render_unauthorized
+        when 'sorry'   then render_internal_server_error
+        when 'yes'     then true
+        end
+      end
+
+      private
+
+      def http_headers
+        Hash[
+          request.headers.each
+            .select { |h| h[0] =~ /^HTTP/ }
+            .map { |h| [h[0].gsub(/^HTTP_/, ''), h[1]] }
+        ]
+      end
+
+      def render_unauthorized
+        Rails.logger.error "#{self.class.name} Token authentication unauthorized request.\n"\
+          "Params: #{JSON.pretty_generate(params)}\n"\
+          "Headers: #{JSON.pretty_generate(http_headers)}"
+
+        respond_to do |format|
+          format.json do
+            render status: :unauthorized,
+                   json: { error: "Invalid or missing credentials" }
+          end
+        end
+      end
+
+      def render_internal_server_error
+        Rails.logger.error "#{self.class.name} Token authentication request resulted in error.\n"\
+          "Params: #{JSON.pretty_generate(params)}\n"\
+          "Headers: #{JSON.pretty_generate(http_headers)}"
+
+        respond_to do |format|
+          format.json do
+            render status: :internal_server_error,
+                   json: { error: "Authentication server broke" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/softwear/engine.rb

@@ -0,0 +1,5 @@
+module Softwear
+  class Engine < ::Rails::Engine
+    isolate_namespace Softwear
+  end
+end

data/lib/softwear/error_catcher.rb

@@ -0,0 +1,65 @@
+module Softwear
+  module ErrorCatcher
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from Exception, StandardError, with: :error_report_form unless Rails.env.test?
+    end
+
+    protected
+
+    def iterm_annotation(content)
+      puts "=======================================================\033]1337;AddAnnotation=#{content}\a"
+    end
+
+    def error_report_form(error)
+      time_of_error = Time.now.strftime("%x %I:%M %p")
+
+      iterm_annotation("Begin #{error.class.name} (#{time_of_error})")
+      Rails.logger.error "**** #{error.class.name}: #{error.message} ****\n\n"\
+        "\t#{error.backtrace.join("\n\t")}"
+      iterm_annotation("End #{error.class.name} (#{time_of_error})")
+
+      @error = error
+      @additional_info = gather_additional_info
+
+      begin
+        respond_to do |format|
+          format.html { render 'softwear/errors/internal_server_error', layout: layout_for_error, status: 500 }
+          format.js   { render 'softwear/errors/internal_server_error', layout: layout_for_error, status: 500 }
+          format.json { render json: '{}', status: 500 }
+        end
+      rescue AbstractController::DoubleRenderError => e
+        Rails.logger.error "DOUBLE RENDER ERROR IN CONTROLLER ERROR CATCHER!!! #{e.message}"
+      end
+    end
+
+    def filter_params(params)
+      new_hash = {}
+      params.each do |key, value|
+        new_value = value
+
+        case key.to_s
+        when /cc_number/ then new_value = "<FILTERED>"
+        when /cc_cvc/    then new_value = "<FILTERED>"
+        when /password/  then new_value = "<FILTERED>"
+        end
+
+        new_hash[key] = new_value
+      end
+      new_hash
+    end
+
+    def gather_additional_info
+      JSON.pretty_generate(filter_params(params)) + "|||" +
+      instance_variables
+        .reject { |v| /^@_/ =~ v.to_s || %i(@view_renderer @output_buffer @view_flow @error).include?(v) }
+        .map { |v| "#{v}: #{instance_variable_get(v).inspect}" }
+        .join("|||")
+    end
+
+    def layout_for_error
+      current_user ? 'application' : 'no_overlay'
+    end
+  end
+end

data/lib/softwear/library/api_controller.rb

@@ -0,0 +1,169 @@
+require 'inherited_resources'
+
+module Softwear
+  module Library
+    class ApiController < ActionController::Base
+      include ::InheritedResources::Actions
+      include ::InheritedResources::BaseHelpers
+      extend  ::InheritedResources::ClassMethods
+      extend  ::InheritedResources::UrlHelpers
+
+      skip_before_filter :authenticate_user!
+      skip_before_filter :verify_authenticity_token
+
+      before_filter :allow_origin
+
+      respond_to :json
+      self.responder = InheritedResources::Responder
+
+      self.class_attribute :resource_class, :instance_writer => false unless self.respond_to? :resource_class
+      self.class_attribute :parents_symbols,  :resources_configuration, :instance_writer => false
+
+      def self.base_class
+        Softwear::Library::ApiController
+      end
+
+      def self.token_authenticate(user_class, options = {})
+        include Softwear::Auth::TokenAuthentication
+        self.user_class = user_class
+        self.token_auth_options = options
+        prepend_before_filter :token_authenticate_user!
+      end
+
+      def index(&block)
+        yield if block_given?
+
+        key_values = (permitted_attributes + [:id]).uniq.map do |a|
+          [a, params[a]] if params[a]
+        end
+          .compact
+
+        self.records ||= resource_class
+        self.records = records.where(Hash[key_values])
+
+        respond_to do |format|
+          format.json(&render_json(records))
+        end
+      end
+
+      def show
+        super do |format|
+          format.json(&render_json)
+        end
+      end
+
+      def update
+        self.record = resource_class.find(params[:id])
+
+        permitted_attributes.each do |a|
+          begin
+            record.send("#{a}=", params[a]) if params[a]
+          rescue ActiveRecord::AssociationTypeMismatch
+            # If you try to send "job" as an attribute to order, we're assuming it's
+            # not intentional. Send "job_attributes" or update the job model separately
+            # to actually update the job.
+          end
+        end
+
+        if record.save
+          respond_to { |format| format.json(&render_json) }
+        else
+          respond_to { |format| format.json(&render_errors) }
+        end
+      end
+
+      def create
+        create! do |success, failure|
+          success.json do
+            headers['Location'] = resource_url(record.id)
+            render_json(status: 201).call
+          end
+          failure.json(&render_errors)
+        end
+      end
+
+      def options
+        head(:ok) if request.request_method == 'OPTIONS'
+      end
+
+      protected
+
+      def base_class
+        self.class.base_class
+      end
+
+      def render_json(options = {})
+        proc do
+          if options.is_a?(Hash)
+            records = nil
+          else
+            records = options
+            options = {}
+          end
+          rendering = {
+            json: (records || record),
+            methods: (['id'] + permitted_attributes).uniq,
+            include: includes
+          }
+            .merge(options)
+
+          render rendering
+        end
+      end
+
+      def render_errors(options = {})
+        proc do
+          Rails.logger.error "API #{record.class.name} ERROR: #{record.errors.full_messages}"
+
+          rendering = {
+            json: { errors: record.errors },
+            status: :unprocessable_entity
+          }
+            .merge(options)
+
+          render rendering
+        end
+      end
+
+      def self.model_name
+        name.gsub('Api::', '').gsub('Controller', '').singularize
+      end
+
+      # Override this to specify the :include option of rendering json.
+      def includes
+        {}
+      end
+
+      def records
+        instance_variable_get("@#{resource_class.model_name.collection}")
+      end
+
+      def records=(r)
+        instance_variable_set("@#{resource_class.model_name.collection}", r)
+      end
+
+      def record
+        instance_variable_get("@#{resource_class.model_name.element}")
+      end
+
+      def record=(r)
+        instance_variable_set("@#{resource_class.model_name.element}", r)
+      end
+
+      def allow_origin
+        headers['Access-Control-Allow-Origin'] = '*'
+        headers['Access-Control-Allow-Methods'] = 'GET, POST, PUT, PATCH, DELETE'
+        headers['Access-Control-Allow-Headers'] = 'X-Requested-With'
+        headers['Access-Control-Allow-Credentials'] = 'true'
+      end
+
+      def permitted_attributes
+        resource_class.column_names + ['state_event']
+      end
+
+      def permitted_params
+        { resource_class.model_name.element => permitted_attributes }
+      end
+    end
+  end
+end

data/lib/softwear/library/capistrano.rb

@@ -0,0 +1,94 @@
+module Softwear
+  module Library
+    def self.capistrano(context)
+      context.instance_eval do
+        Rake::Task["deploy:compile_assets"].clear
+
+        ruby = fetch(:rvm_ruby_string) || fetch(:rvm_ruby_version)
+
+        namespace :deploy do
+
+          desc 'Assure softwear-lib is up to date before deploying'
+          task :update_softwear_lib do
+            on roles(:app), in: :sequence do
+              execute "~/.rvm/bin/rvm #{ruby} do gem install --no-ri --no-rdoc softwear-lib"
+            end
+          end
+
+          desc 'Signal the running rails app to restart'
+          task :restart do
+            on roles([:web, :app]), in: :sequence, wait: 5 do
+              execute :mkdir, '-p', "#{release_path}/tmp"
+              execute :touch, release_path.join('tmp/restart.txt')
+            end
+          end
+
+          after :publishing, :restart_sidekiq_manager do
+            on roles(:sidekiq) do
+              execute 'sudo restart sidekiq-manager'
+            end
+          end
+
+          # This is more problematic than helpful
+=begin
+          if !$LOAD_PATH.grep(/sunspot_solr/).empty? || fetch(:no_reindex)
+            before :publishing, :reindex_solr do
+              on roles(:db) do
+                with rails_env: fetch(:rails_env) || fetch(:stage) do
+                  within(release_path) do
+                    execute :rake, 'sunspot:solr:reindex'
+                  end
+                end
+              end
+            end
+          end
+=end
+
+          # This is no longer necessary
+          # before :updating, :update_softwear_lib
+          after :publishing, :restart
+
+          desc 'Compile assets'
+          task :compile_assets => [:set_rails_env] do
+            invoke 'deploy:assets:precompile_local'
+            invoke 'deploy:assets:backup_manifest'
+          end
+
+          namespace :assets do
+
+            desc "Precompile assets locally and then rsync to web servers"
+            task :precompile_local do
+              # compile assets locally
+              run_locally do
+                execute "RAILS_ENV=#{fetch(:stage)} bundle exec rake assets:precompile"
+              end
+
+              # rsync to each server
+              assets_dir = "public/#{fetch(:assets_prefix) || 'assets'}"
+              local_dir  = "./#{assets_dir}/"
+              on roles( fetch(:assets_roles, [:web]) ) do
+                # this needs to be done outside run_locally in order for host to exist
+                remote_dir = "#{host.user}@#{host.hostname}:#{release_path}/#{assets_dir}"
+
+                execute "mkdir -p #{release_path}/#{assets_dir}"
+                run_locally { execute "rsync -av --delete #{local_dir} #{remote_dir}" }
+
+                if fetch(:asset_sync)
+                  with rails_env: fetch(:rails_env) || fetch(:stage) do
+                    within(release_path) do
+                      with_rvm(fetch(:task_ruby_version)) { execute :rake, 'assets:sync' }
+                    end
+                  end
+                end
+              end
+
+              # clean up
+              run_locally { execute "rm -rf #{local_dir}" }
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/softwear/library/controller_authentication.rb

@@ -0,0 +1,145 @@
+module Softwear
+  module Library
+    module ControllerAuthentication
+      extend ActiveSupport::Concern
+
+      class NotSignedInError < StandardError
+      end
+
+      included do
+        rescue_from NotSignedInError, with: :user_not_signed_in
+        rescue_from Softwear::Auth::Model::AuthServerDown, with: :auth_server_down
+
+        helper_method :current_user
+        helper_method :user_signed_in?
+
+        helper_method :destroy_user_session_path
+        helper_method :users_path
+        helper_method :user_path
+        helper_method :edit_user_path
+      end
+
+      def user_class
+        if Softwear::Auth::Model.descendants.size > 1
+          raise "More than one descendent of Softwear::Auth::Model is not supported."
+        elsif Softwear::Auth::Model.descendants.size == 0
+          # Assume there is a "User" model
+          begin
+            User.inspect
+            return User if User.ancestors.include?(Softwear::Auth::Model)
+          rescue NameError => _
+          end
+          raise "Please define a user model that extends Softwear::Auth::Model."
+        end
+        Softwear::Auth::Model.descendants.first
+      end
+
+      # ====================
+      # Action called when a NotSignedInError is raised.
+      # ====================
+      def user_not_signed_in
+        if Softwear::Auth::Model::STUBBED
+          self.user_token = "dummy-token"
+          authenticate_user!
+        else
+          redirect_to softwear_hub_url + "/users/sign_in?#{{return_to: request.original_url}.to_param}"
+        end
+      end
+
+      # ====================
+      # Action called when a NotSignedInError is raised.
+      # ====================
+      def auth_server_down(error)
+        respond_to do |format|
+          format.html do
+            render inline: \
+              "<div class='panel panel-danger'>"\
+                "<div class='panel-heading'>"\
+                  "<h3 class='panel-title'>#{error.message}</h3>"\
+                "</div>"\
+                "<div class='panel-body'>"\
+                  "Not all site functions will work until the problem is resolved. "\
+                  "<a href='javascript' onclick='history.go(-1);return false;' class='btn btn-default'>Go back.</a>"\
+                "</div>"\
+              "</div>"
+          end
+
+          format.js do
+            render inline: "alert(\"#{error.message.gsub('"', '\"')}\");"
+          end
+        end
+      end
+
+      # ====================
+      # Drop this into a before_filter to require a user be signed in on every request -
+      # just like in Devise.
+      # ====================
+      def authenticate_user!
+        if user_token.blank?
+          raise NotSignedInError, "No token"
+        end
+
+        if user = user_class.auth(user_token)
+          @current_user = user
+        else
+          self.user_token = nil
+          raise NotSignedInError, "Invalid token"
+        end
+      end
+
+      def current_user
+        return @current_user if @current_user
+
+        if @current_user.nil? && !user_token.blank?
+          @current_user = user_class.auth(user_token)
+        else
+          nil
+        end
+      end
+
+      def user_signed_in?
+        !!current_user
+      end
+
+      # -- url uelpers --
+
+      def softwear_hub_url
+        if Rails.env.production?
+          Figaro.env.softwear_hub_url || (raise "Please set softwear_hub_url in application.yml")
+        elsif Rails.env.test?
+          'http://hub.example.com'
+        else
+          Figaro.env.softwear_hub_url || 'http://localhost:2995'
+        end
+      end
+
+      def destroy_user_session_path
+        softwear_hub_url + "/users/sign_out"
+      end
+
+      def user_path(user)
+        user_id = user.is_a?(user_class) ? user.id : user
+        softwear_hub_url + "/users/#{user_id}"
+      end
+
+      def edit_user_path(user)
+        user_id = user.is_a?(user_class) ? user.id : user
+        softwear_hub_url + "/users/#{user_id}/edit"
+      end
+
+      def users_path
+        softwear_hub_url + "/users"
+      end
+
+      private
+
+      def user_token
+        session[:user_token]
+      end
+
+      def user_token=(new_token)
+        session[:user_token] = new_token
+      end
+    end
+  end
+end