typus 3.0.6 → 3.0.7

data/lib/typus/orm/active_record/instance_methods.rb

@@ -0,0 +1,13 @@
+module Typus
+  module Orm
+    module ActiveRecord
+      module InstanceMethods
+
+        def owned_by?(user)
+          send(Typus.user_fk) == user.id
+        end
+
+      end
+    end
+  end
+end

data/lib/typus/orm/active_record/search.rb

@@ -1,18 +1,25 @@
 module Typus
   module Orm
-    module ClassMethods
+    module ActiveRecord
       module Search
 
         def build_search_conditions(key, value)
           Array.new.tap do |search|
-            query = ActiveRecord::Base.connection.quote_string(value.downcase)
-            typus_search_fields.each do |key, value|
+            query = ::ActiveRecord::Base.connection.quote_string(value.downcase)
+
+            search_fields = typus_search_fields
+            search_fields = search_fields.empty? ? { "name" => "@" } : search_fields
+
+            search_fields.each do |key, value|
               _query = case value
                        when "=" then query
                        when "^" then "#{query}%"
                        when "@" then "%#{query}%"
                        end
-              table_key = (adapter == 'postgresql') ? "LOWER(TEXT(#{table_name}.#{key}))" : "#{table_name}.#{key}"
+
+              column_name = (key.match('\.') ? key : "#{table_name}.#{key}")
+              table_key = (adapter == 'postgresql') ? "LOWER(TEXT(#{column_name}))" : "#{column_name}"
+
               search << "#{table_key} LIKE '#{_query}'"
             end
           end.join(" OR ")
@@ -70,7 +77,12 @@ module Typus
         def build_conditions(params)
           Array.new.tap do |conditions|
             query_params = params.dup
-            query_params.reject! { |k, v| !model_fields.keys.include?(k.to_sym) && !model_relationships.keys.include?(k.to_sym) && !(k.to_sym == :search) }
+
+            query_params.reject! do |k, v|
+              !model_fields.keys.include?(k.to_sym) &&
+              !model_relationships.keys.include?(k.to_sym) &&
+              !(k.to_sym == :search)
+            end
 
             query_params.compact.each do |key, value|
               filter_type = model_fields[key.to_sym] || model_relationships[key.to_sym] || key

data/lib/typus/orm/active_record/user.rb

@@ -0,0 +1,157 @@
+module Typus
+  module Orm
+    module ActiveRecord
+      module User
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+
+          def enable_as_typus_user
+
+            extend ClassMethodsMixin
+
+            attr_accessor :password
+            attr_protected :status
+
+            validates :email,
+                      :presence => true,
+                      :uniqueness => true,
+                      :format => { :with => Typus::Regex::Email }
+
+            validates :password,
+                      :confirmation => { :if => :password_required? },
+                      :presence => { :if => :password_required? }
+
+            validates_length_of :password, :within => 6..40, :if => :password_required?
+
+            validates :role, :presence => true
+
+            before_save :initialize_salt, :encrypt_password, :initialize_token
+
+            serialize :preferences
+
+            include InstanceMethods
+
+          end
+
+        end
+
+        module ClassMethodsMixin
+
+          def authenticate(email, password)
+            user = find_by_email_and_status(email, true)
+            user && user.authenticated?(password) ? user : nil
+          end
+
+          def generate(*args)
+            options = args.extract_options!
+
+            options[:password] ||= ActiveSupport::SecureRandom.hex(4)
+            options[:role] ||= Typus.master_role
+
+            new :email => options[:email],
+                :password => options[:password],
+                :password_confirmation => options[:password],
+                :role => options[:role],
+                :preferences => { :locale => ::I18n.default_locale.to_s }
+          end
+
+        end
+
+        module InstanceMethods
+
+          def name
+            full_name = [first_name, last_name].delete_if { |s| s.blank? }
+            full_name.any? ? full_name.join(" ") : email
+          end
+
+          def authenticated?(password)
+            crypted_password == encrypt(password)
+          end
+
+          def resources
+            Typus::Configuration.roles[role].compact
+          end
+
+          def applications
+            Typus.applications.delete_if { |a| application(a).empty? }
+          end
+
+          def application(name)
+            Typus.application(name).delete_if { |r| !resources.keys.include?(r) }
+          end
+
+          def can?(action, resource, options = {})
+            resource = resource.model_name if resource.is_a?(Class)
+
+            return false if !resources.include?(resource)
+            return true if resources[resource].include?("all")
+
+            action = options[:special] ? action : action.acl_action_mapper
+
+            resources[resource].extract_settings.include?(action)
+          end
+
+          def cannot?(*args)
+            !can?(*args)
+          end
+
+          def is_root?
+            role == Typus.master_role
+          end
+
+          def is_not_root?
+            !is_root?
+          end
+
+          def locale
+            (preferences && preferences[:locale]) ? preferences[:locale] : ::I18n.default_locale
+          end
+
+          def locale=(locale)
+            options = { :locale => locale }
+            self.preferences ||= {}
+            self.preferences[:locale] = locale
+          end
+
+          protected
+
+          # TODO: Update the hash generation by a harder one ...
+          def generate_hash(string)
+            Digest::SHA1.hexdigest(string)
+          end
+
+          def encrypt_password
+            return if password.blank?
+            self.crypted_password = encrypt(password)
+          end
+
+          def encrypt(string)
+            generate_hash("--#{salt}--#{string}--")
+          end
+
+          def initialize_salt
+            self.salt = generate_hash("--#{Time.zone.now.to_s(:number)}--#{email}--") if new_record?
+          end
+
+          def initialize_token
+            generate_token if new_record?
+          end
+
+          def generate_token
+            self.token = encrypt("--#{Time.zone.now.to_s(:number)}--#{password}--").first(12)
+          end
+
+          def password_required?
+            crypted_password.blank? || !password.blank?
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/typus/regex.rb

@@ -0,0 +1,11 @@
+module Typus
+
+  module Regex
+
+    Email = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/
+
+    Url = /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix
+
+  end
+
+end

data/lib/typus/version.rb

@@ -1,3 +1,3 @@
 module Typus
-  VERSION = "3.0.6"
+  VERSION = "3.0.7"
 end

data/test/app/controllers/admin/account_controller_test.rb

@@ -0,0 +1,104 @@
+require "test_helper"
+
+=begin
+
+  What's being tested here?
+
+    - Create first user. (/admin/account/new)
+    - Stuff that happens when there are already users.
+
+=end
+
+class Admin::AccountControllerTest < ActionController::TestCase
+
+  context "No users" do
+
+    should "render new when there are not admin users" do
+      get :new
+
+      assert_response :success
+      assert_template "new"
+      assert_equal "Enter your email below to create the first user.", flash[:notice]
+    end
+
+    should "render session layout" do
+      get :new
+      assert_template "new"
+      assert_template "layouts/admin/session"
+    end
+
+    should "verify forgot_password redirects to new when there are no admin users" do
+      get :forgot_password
+
+      assert_response :redirect
+      assert_redirected_to new_admin_account_path
+    end
+
+    should "verify send_password redirects to new when there are no admin users"
+
+    should "not sign_up invalid emails" do
+      post :create, :typus_user => { :email => "example.com" }
+
+      assert_response :redirect
+      assert_redirected_to :action => :new
+      assert flash.empty?
+    end
+
+    should "sign_up a valid email" do
+      assert_difference('TypusUser.count') do
+        post :create, :typus_user => { :email => "john@example.com" }
+      end
+
+      assert_response :redirect
+      assert_redirected_to :action => "show", :id => TypusUser.find_by_email("john@example.com").token
+    end
+
+  end
+
+  context "There are users" do
+
+    setup do
+      @typus_user = Factory(:typus_user)
+    end
+
+    should "new redirect new admin session when there are admin users" do
+      get :new
+      assert_response :redirect
+      assert_redirected_to new_admin_session_path
+    end
+
+    should "verify forgot_password is rendered when there are admin users" do
+      get :forgot_password
+      assert_response :success
+      assert_template "forgot_password"
+    end
+
+    should "not_send_recovery_password_link_to_unexisting_user" do
+      post :send_password, { :typus_user => { :email => "unexisting" } }
+      assert_response :success
+      assert flash.empty?
+    end
+
+    should "test_should_send_recovery_password_link_to_existing_user" do
+      post :send_password, { :typus_user => { :email => @typus_user.email } }
+
+      assert_response :redirect
+      assert_redirected_to new_admin_session_path
+      assert_equal "Password recovery link sent to your email.", flash[:notice]
+    end
+
+    should "test_should_create_admin_user_session_and_redirect_user_to_its_details" do
+      get :show, { :id => @typus_user.token }
+
+      assert_equal @typus_user.id, @request.session[:typus_user_id]
+      assert_response :redirect
+      assert_redirected_to :controller => "/admin/typus_users", :action => "edit", :id => @typus_user.id
+    end
+
+    should "test_should_return_404_on_reset_passsword_if_token_is_not_valid" do
+      assert_raise(ActiveRecord::RecordNotFound) { get :show, { :id => "unexisting" } }
+    end
+
+  end
+
+end

data/test/app/controllers/admin/assets_controller_test.rb

@@ -0,0 +1,153 @@
+require "test_helper"
+
+=begin
+
+  What's being tested here?
+
+    - Asset management like attach (edit) and detach (update).
+    - Assets runnings with a custom template.
+
+=end
+
+class Admin::AssetsControllerTest < ActionController::TestCase
+
+  setup do
+    @request.session[:typus_user_id] = Factory(:typus_user).id
+    @post = Factory(:post)
+  end
+
+  context "edit" do
+
+    setup do
+      @asset = Factory(:asset)
+      @request.env['HTTP_REFERER'] = "/admin/assets/edit/#{@asset.id}"
+    end
+
+    should "verify there is a file link" do
+      get :edit, { :id => @asset.id }
+      assert_match /media/, @response.body
+    end
+
+    should "verify dragonfly can be removed" do
+      get :edit, { :id => @asset.id }
+      assert_match /Remove/, @response.body
+
+      assert @asset.dragonfly_uid.present?
+
+      get :update, { :id => @asset.id, :attribute => "dragonfly" }
+      assert_response :redirect
+      assert_redirected_to "/admin/assets/edit/#{@asset.id}"
+      assert_equal "Asset successfully updated.", flash[:notice]
+
+      @asset.reload
+      assert @asset.dragonfly_uid.blank?
+    end
+
+    should "verify dragonfly_required can not removed" do
+      get :edit, { :id => @asset.id }
+      assert_no_match /Remove required file/, @response.body
+
+      get :update, { :id => @asset.id, :attribute => "dragonfly_required" }
+      assert_response :success
+
+      @asset.reload
+      assert @asset.dragonfly_required.present?
+    end
+
+    should "verify message on polymorphic relationship" do
+      asset = Factory(:asset)
+      get :edit, { :id => asset.id, :resource => @post.class.name, :resource_id => @post.id }
+      assert_select 'body div#flash', "Cancel adding a new asset?"
+    end
+
+  end
+
+  context "Headless" do
+
+    should "render index with a custom layout" do
+      get :index, { :layout => "admin/headless" }
+      assert_response :success
+      assert_template "admin/headless"
+    end
+
+    should "render new with a custom layout" do
+      get :new, { :layout => "admin/headless" }
+      assert_response :success
+      assert_template "admin/headless"
+    end
+
+    should "render edit with a custom layout" do
+      asset = Factory(:asset)
+      get :edit, { :id => asset.id, :layout => "admin/headless" }
+      assert_response :success
+      assert_template "admin/headless"
+    end
+
+    context "create" do
+
+      should "redirect to edit with custom layout" do
+        asset = {:caption => "My Caption", :dragonfly_required => File.new("#{Rails.root}/public/images/rails.png")}
+
+        assert_difference('Asset.count') do
+          post :create, { :asset => asset, :layout => "admin/headless" }
+        end
+
+        assert_response :redirect
+        assert_redirected_to :action => "edit", :id => Asset.last.id, :layout => "admin/headless"
+      end
+
+      should "redirect to index with custom layout" do
+        Typus::Resources.expects(:action_after_save).returns("index")
+        asset = {:caption => "My Caption", :dragonfly_required => File.new("#{Rails.root}/public/images/rails.png")}
+
+        assert_difference('Asset.count') do
+          post :create, { :asset => asset, :layout => "admin/headless" }
+        end
+
+        assert_response :redirect
+        assert_redirected_to :action => "index", :layout => "admin/headless"
+      end
+
+      should "render new with custom layout after an error" do
+        post :create, { :asset => {}, :layout => "admin/headless" }
+        assert_response :success
+        assert_template "new"
+        assert_template "admin/headless"
+      end
+
+    end
+
+    context "update" do
+
+      setup do
+        @asset = Factory(:asset)
+      end
+
+      should "redirect to edit with custom layout" do
+        asset = {:caption => "My Caption", :dragonfly_required => File.new("#{Rails.root}/public/images/rails.png")}
+        post :update, { :id => @asset.id, :asset => asset, :layout => "admin/headless" }
+        assert_response :redirect
+        assert_redirected_to :action => "edit", :id => @asset.id, :layout => "admin/headless"
+      end
+
+      should "render update with custom layout after an error" do
+        post :update, { :id => @asset.id, :asset => { :caption => nil }, :layout => "admin/headless" }
+        assert_response :success
+        assert_template "admin/helpers/resources/_errors"
+        assert_template "admin/resources/edit"
+        assert_template "admin/headless"
+      end
+
+      should "redirect to index with custom layout" do
+        Typus::Resources.expects(:action_after_save).returns("index")
+        asset = {:caption => "My Caption", :dragonfly_required => File.new("#{Rails.root}/public/images/rails.png")}
+        post :update, { :id => @asset.id, :asset => asset, :layout => "admin/headless" }
+        assert_response :redirect
+        assert_redirected_to :action => "index", :layout => "admin/headless"
+      end
+
+    end
+
+  end
+
+end