hello-rails 0.0.0 → 0.5.0

data/lib/hello/rails_active_record/email_credential.rb

@@ -0,0 +1,60 @@
+module Hello
+  module RailsActiveRecord
+    class EmailCredential < ::Credential
+
+      # VALIDATIONS
+      before_destroy :cannot_destroy_last_email_credential
+
+      validate :hello_validations
+      validates_uniqueness_of :email
+
+      # SETTERS
+      def email=(v)
+        super(v.to_s.downcase.delete(' '))
+      end
+
+      # CUSTOM METHODS
+
+      def email_confirmed?
+        !!confirmed_at
+      end
+
+      def email_delivered?
+        !!email_delivered_at
+      end
+
+      def email_delivered_at
+        verifying_token_digested_at
+      end
+
+      def confirm_email!
+        update! verifying_token_digest: nil, verifying_token_digested_at: nil, confirmed_at: 1.second.ago
+      end
+
+      private
+
+      def hello_validations
+        validates_presence_of :email
+        return false if errors[:email].any?
+
+        c = Hello.configuration
+        validates_length_of :email, in: c.email_length
+        return false if errors[:email].any?
+
+        validates_format_of :email, with: c.email_regex
+        return false if errors[:email].any?
+      end
+
+      def cannot_destroy_last_email_credential
+        return if hello_is_user_being_destroyed?
+        return unless is_last_email_credential?
+        errors[:base] << 'must have at least one credential'
+        false
+      end
+
+      def is_last_email_credential?
+        user.email_credentials.count == 1
+      end
+    end
+  end
+end

data/lib/hello/rails_active_record/password_credential.rb

@@ -0,0 +1,70 @@
+module Hello
+  module RailsActiveRecord
+    class PasswordCredential < ::Credential
+
+      # VALIDATIONS
+      validates_presence_of :password, on: :create
+      # validates_presence_of :digest
+
+      # before_destroy :cannot_destroy_last_password_credential
+      validate :hello_validations
+
+      # SETTERS
+
+      attr_reader :password
+
+      def password=(value)
+        # puts "password=('#{value}')".blue
+        self.digest = @password = nil if value.blank?
+        @password = value
+
+        self.digest = complex_encryptor.encrypt(value)
+      end
+
+      # CUSTOM METHODS
+
+      def password_is?(plain_text_password)
+        complex_encryptor.match(plain_text_password, digest)
+      end
+
+      def set_generated_password
+        self.password = simple_encryptor.single(4) # 8 chars
+      end
+
+      private
+
+      def hello_validations
+        return true unless digest_changed?
+
+        return false if errors[:password].any?
+        c = Hello.configuration
+
+        validates_length_of :password, in: c.password_length
+        return false if errors[:password].any?
+
+        validates_format_of :password, with: c.password_regex
+        return false if errors[:password].any?
+      end
+
+      def complex_encryptor
+        Hello::Encryptors::Complex.instance
+      end
+
+      def simple_encryptor
+        Hello::Encryptors::Simple.instance
+      end
+
+      # # TODO: code for multiple passwords
+      # def cannot_destroy_last_password_credential
+      #   return if hello_is_user_being_destroyed?
+      #   return if not is_last_password_credential?
+      #   errors[:base] << "must have at least one credential"
+      #   false
+      # end
+
+      # def is_last_password_credential?
+      #   user.password_credentials.count == 1
+      # end
+    end
+  end
+end

data/lib/hello/rails_active_record/user.rb

@@ -0,0 +1,99 @@
+module Hello
+  module RailsActiveRecord
+    class User < ::ActiveRecord::Base
+      self.table_name = 'users'
+
+      # ASSOCIATIONS
+
+      has_many :credentials,          dependent: :destroy, class_name: '::Credential'
+      has_many :email_credentials,    dependent: :destroy, class_name: '::EmailCredential'
+      has_one  :password_credential,  dependent: :destroy, class_name: '::PasswordCredential'
+      has_many :password_credentials, dependent: :destroy, class_name: '::PasswordCredential'
+      has_many :accesses,             dependent: :destroy, class_name: '::Access'
+
+      alias :main_password_credential :password_credential
+
+      # VALIDATIONS
+
+      validates_presence_of :username, :locale, :time_zone
+      validates_uniqueness_of :username
+      validate :hello_validations
+
+      # SETTERS
+
+      def username=(v)
+        super(v.to_s.downcase.remove(' '))
+      end
+
+      # OVERRIDES
+
+      def destroy
+        # In Rails 4.0
+        # 'this instance' and the 'user in the credential instance'
+        # are 2 separate instances, making it impossible for them to share state
+        # therefore, an instance variable used as a flag will not work for Rails 4.0
+        # It will however, work for Rails 4.1 and 4.2
+        # @hello_is_this_being_destroyed = true
+        Thread.current['Hello.destroying_user'] = true
+        super
+      end
+
+      # def hello_is_this_being_destroyed?
+      #   !!@hello_is_this_being_destroyed
+      # end
+
+
+      # CUSTOM METHODS
+
+      def as_json_web_api
+        as_json
+      end
+
+      def password_is?(plain_text_password)
+        password_credential.password_is?(plain_text_password)
+      end
+
+      def role_is?(role)
+        send("#{role}?")
+      end
+
+      def in_any_role?(roles)
+        roles.each { |r| role_is?(r) and return true }
+        false
+      end
+
+      def set_generated_username
+        loop do
+          self.username = _make_up_new_username
+          break if _username_unique?
+        end
+      end
+
+      private
+
+      def hello_validations
+        c = Hello.configuration
+
+        validates_inclusion_of :locale,    in:   c.locales
+        validates_inclusion_of :time_zone, in:   c.time_zones
+        validates_format_of    :username,  with: c.username_regex
+        validates_length_of    :username,  in:   c.username_length
+      end
+
+      def _make_up_new_username
+        Hello::Encryptors::Simple.instance.single(16) # 16 chars
+      end
+
+      def _username_unique?
+        !self.class.unscoped.where(username: username).where.not(id: id).exists?
+      end
+
+      # def username_suggestions
+      #   email1 = email.to_s.split('@').first
+      #   name1  = name.to_s.split(' ')
+      #   ideas = [name1, email1].flatten
+      #   [ideas.sample, rand(999)].join.parameterize
+      # end
+    end
+  end
+end

data/lib/hello/rails_controller.rb

@@ -0,0 +1,124 @@
+module Hello
+  module RailsController
+    extend ActiveSupport::Concern
+
+    autoload :RestrictByRole, 'hello/rails_controller/restrict_by_role'
+
+    module ClassMethods
+      def sign_out!(options = {})
+        before_action(options) { sign_out! }
+      end
+
+      def kick(*args)
+        options, roles = Hello::Utils.trailing_options(args)
+        before_action(options) { kick(*roles) }
+      end
+
+      def dont_kick(*args)
+        options, roles = Hello::Utils.trailing_options(args)
+        before_action(options) { dont_kick(*roles) }
+      end
+
+      def dont_kick_people
+        # :)
+      end
+
+      def sudo_mode(options = {})
+        before_action(options) { sudo_mode }
+      end
+    end
+
+    included do
+      around_action :hello_around_action
+
+      helper_method :sign_up_disabled,
+                    :current_user, :current_accesses, :current_access,
+                    :signed_in?, :is_current_access?, :sudo_mode?
+
+      delegate :sign_in!, :sign_out!, :signed_in?,
+               :current_user, :is_current_user?,
+               :current_access, :current_accesses, :is_current_access?,
+               :session_token=, :session_tokens,
+               to: :hello_manager
+
+      delegate :kick, :dont_kick,
+               to: :restrict_by_role
+    end
+
+    def hello_manager
+      env['hello'] ||= Hello::RequestManager.create(request)
+    end
+
+
+
+    def sign_up_disabled
+      Hello.configuration.sign_up_disabled || action_name=='disabled'
+    end
+
+    def hello_store_url_on_session!
+      if hello_manager.stateful?
+        session[:url] = url_for(params.permit!.merge(only_path: true))
+      end
+    end
+
+
+
+    def sudo_mode?
+      current_access && current_access.sudo_expires_at.future?
+    end
+
+    def sudo_mode
+      unless sudo_mode?
+        hello_store_url_on_session!
+        render_sudo_mode_form
+      end
+    end
+
+    def render_sudo_mode_form
+      render 'hello/authentication/sudo_mode'
+    end
+
+
+
+    private
+
+    def restrict_by_role
+      @_hello_rbr ||= RestrictByRole.new(self)
+    end
+
+
+    def use_locale(locale)
+      locale ||= current_user && current_user.locale
+      locale ||= session['locale']
+      locale ||= recommended_locale.to_s
+
+      I18n.locale = session['locale'] = locale
+    end
+
+    def hello_around_action(&block)
+      use_locale(nil)
+
+      if current_user
+        # begin keep-alive
+        Access.cached_destroy_all_expired
+        current_access.keep_alive!
+        expires_in = view_context.time_ago_in_words(current_access.expires_at)
+        logger.info "  #{'Hello Session'.bold.light_blue} expires in #{expires_in}"
+        # end keep-alive
+
+        Thread.current['Hello.destroying_user'] = nil
+        Time.use_zone(current_user.time_zone, &block)
+        Thread.current['Hello.destroying_user'] = nil
+      else
+        yield
+      end
+    end
+
+    def recommended_locale
+      y = Hello.configuration.locales
+      x = http_accept_language.compatible_language_from(y)
+      x || I18n.default_locale
+    end
+
+  end
+end

data/lib/hello/rails_controller/restrict_by_role.rb

@@ -0,0 +1,79 @@
+module Hello
+  module RailsController
+    class RestrictByRole
+
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def kick(*roles)
+        to_home_page if current_user.in_any_role?(roles)
+      end
+
+      def dont_kick(*roles)
+        to_home_page if not current_user.in_any_role?(roles)
+      end
+
+      private
+
+      def current_user
+        @controller.current_user || ::User.new(role: 'guest')
+      end
+
+      def to_home_page
+        if current_user.guest?
+          to_sign_in
+        elsif current_user.onboarding?
+          to_onboarding
+        else
+          to_root
+        end
+      end
+
+      def to_root
+        respond_to do |format|
+          format.html { redirect_to '/' }
+          format.json do
+            data   = { 'message' => 'Access Denied.' }
+            status = :forbidden # 403
+            render json: data, status: status
+          end
+        end
+      end
+
+      def to_sign_in
+        respond_to do |format|
+          format.html do
+            hello_store_url_on_session!
+            redirect_to hello.sign_in_path
+          end
+          format.json do
+            data   = { 'message' => 'An active access token must be used to query information about the current user.' }
+            status = :unauthorized # 401
+            render json: data, status: status
+          end
+        end
+      end
+
+      def to_onboarding
+        respond_to do |format|
+          format.html { redirect_to '/onboarding' }
+          format.json do
+            data   = { 'message' => 'Access Denied, visit /onboarding and complete your registration.' }
+            status = :forbidden # 403
+            render json: data, status: status
+          end
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if @controller.respond_to?(method)
+          @controller.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/hello/rails_helper.rb

@@ -0,0 +1,35 @@
+module Hello
+  module RailsHelper
+    def method_missing(method, *args, &block)
+      # # http://candland.net/2012/04/17/rails-routes-used-in-an-isolated-engine/
+      # puts "LOOKING FOR ROUTES #{method}"
+      return super unless method.to_s.end_with?('_path', '_url')
+      return super unless main_app.respond_to?(method)
+      main_app.send(method, *args)
+    end
+
+    def respond_to?(method)
+      return super unless method.to_s.end_with?('_path', '_url')
+      return super unless main_app.respond_to?(method)
+      true
+    end
+
+    # [['English', 'en']]
+    def hello_locale_select_options
+      available_locales_with_names.map { |k, v| [v, k] }
+    end
+
+    def human_current_locale
+      t('hello.locale_name')
+    end
+
+    def current_locale
+      session['locale']
+    end
+
+    def available_locales_with_names
+      Hello::Locales.all.select { |k, _v| Hello.configuration.locales.include? k }
+    end
+
+  end
+end