ixtlan 0.2.0

data/lib/ixtlan/models/word.rb

@@ -0,0 +1,12 @@
+module Ixtlan
+  module Models
+    class Word < Text
+
+      alias :to_x :to_xml_document
+      def to_xml_document(opts, doc = nil)
+        opts.merge!({:element_name => "word", :exclude => [:id, :locale_code, :current, :previous, :updated_at, :approved_at, :updated_by_id, :approved_by_id, :version]})
+        to_x(opts, doc)
+      end
+    end
+  end
+end

data/lib/ixtlan/models.rb

@@ -0,0 +1,13 @@
+module Ixtlan
+  module Models
+    AUTHENTICATION = "::Ixtlan::Models::Authentication" unless const_defined? "AUTHENTICATION"
+    USER = "::Ixtlan::Models::User" unless const_defined? "USER"
+    GROUP = "::Ixtlan::Models::Group" unless const_defined? "GROUP"
+    ROLE = "::Ixtlan::Models::Role" unless const_defined? "ROLE"
+    PERMISSION = "::Ixtlan::Models::Permission" unless const_defined? "PERMISSION"
+    LOCALE = "::Ixtlan::Models::Locale" unless const_defined? "LOCALE"
+    CONFIGURATION = "::Ixtlan::Models::Configuration" unless const_defined? "CONFIGURATION"
+    TRANSLATION = "::Ixtlan::Models::Translation" unless const_defined? "TRANSLATION"
+    TEXT = "::Ixtlan::Models::Text" unless const_defined? "TEXT"
+  end
+end

data/lib/ixtlan/modified_by.rb

@@ -0,0 +1,80 @@
+#require 'dm-core'
+module Ixtlan
+
+  module ModifiedBy    
+    extend ::DataMapper::Chainable
+
+    MODIFIED_BY_PROPERTIES = {
+      :updated_by => lambda {|r, u| r.updated_by = u},
+      :created_by => lambda {|r, u| r.created_by = u if r.new? }
+    }.freeze
+
+    def self.included(model)
+      model.after :save do @current_user = nil; end
+      model.extend(ClassMethods)
+    end
+
+    def current_user=(user)
+      @current_user = user
+    end
+
+    private
+
+    def current_user
+      raise ::DataMapper::MissingCurrentUserError.new("current_user not set. it can be set like any other property") unless @current_user
+      
+      @current_user
+    end
+
+    chainable do
+      def new(attributes = {}, &block)
+        current_user= attributes.delete(:current_user)
+        super(&block)
+      end
+    end
+
+    chainable do
+      def save(*args)
+        set_modified_by if dirty?
+        super()
+      end
+    end
+
+    chainable do
+      def update!(*args)
+        set_modified_by if dirty?
+        super()
+      end
+    end
+
+    def set_modified_by
+      MODIFIED_BY_PROPERTIES.each do |name, setter|
+        if respond_to? name
+          setter.call(self, current_user)
+        end
+      end
+    end
+
+    module ClassMethods
+      def modified_by(type, *names)
+        if(names.empty?)
+          modified_by(type, :created_by, :updated_by)
+        else
+          names.each do |name|
+            case name
+            when *MODIFIED_BY_PROPERTIES.keys
+              belongs_to name, :model => type.to_s
+            else
+              raise ::DataMapper::InvalidModifiedByName, "Invalid 'modified by' name '#{name}'"
+            end
+          end
+        end
+      end
+    end
+
+    class ::DataMapper::InvalidModifiedByName < RuntimeError; end
+    class ::DataMapper::MissingCurrentUserError < RuntimeError; end
+
+    ::DataMapper::Model.append_inclusions self
+  end
+end

data/lib/ixtlan/monkey_patches.rb

@@ -0,0 +1,38 @@
+if RUBY_PLATFORM =~ /java/
+  require 'zlib'
+  class Zlib::GzipWriter
+    def <<(arg)
+      write(arg)
+    end
+  end
+end
+# fix with rails development mode and class reloading
+# not sure where the exact problem is :-(
+module Extlib
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      # be less strict and allow matching class names to OK as well
+      klasses.each { |k| return if value.kind_of?(k) or value.class.name == k.name }     
+      raise ArgumentError, "+\#{name}+ should be \#{klasses.map { |k| k.name } * ' or '}, but was \#{value.class.name}", caller(2)
+    end
+  end
+end
+if RUBY_PLATFORM =~ /java/
+  module DataMapper
+    module Validate
+      class NumericValidator
+        
+        def validate_with_comparison(value, cmp, expected, error_message_name, errors, negated = false)
+          return if expected.nil?
+          if cmp == :=~ 
+              return value =~ expected
+          end
+          comparison = value.send(cmp, expected)
+          return if negated ? !comparison : comparison
+          
+          errors << ValidationErrors.default_error_message(error_message_name, field_name, expected)
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/optimistic_persistence.rb

@@ -0,0 +1,20 @@
+require 'ixtlan/optimistic_persistence_module'
+require 'dm-core'
+module DataMapper
+
+  class StaleResourceError < StandardError; end
+
+end
+
+module Ixtlan   
+  module OptimisticPersistence
+    
+    def self.included(base)
+      base.send(:include, ::Ixtlan::OptimisticPersistenceModule)
+      base.before :valid? do
+        raise ::DataMapper::StaleResourceError.new(model.name + "(#{key}) was stale") if stale?
+      end
+    end
+    ::DataMapper::Model.append_inclusions self
+  end
+end

data/lib/ixtlan/optimistic_persistence_module.rb

@@ -0,0 +1,22 @@
+module Ixtlan
+  module OptimisticPersistenceModule
+    def stale?
+      if(!new? && prop = properties[:updated_at] && dirty?)
+        updated_at = original_attributes[prop] || properties[:updated_at].get!(self)
+        qu = {}
+        c = model.key_conditions(repository, key)
+        c.each {|p,v| qu[p.name] = v}
+        
+        s = self.model.first(qu)
+        if s.nil? 
+          false 
+        else
+          # use to_s to get it to work in both MRI and JRuby
+          s.updated_at.to_s != updated_at.to_s
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/ixtlan/optimistic_persistence_validation.rb

@@ -0,0 +1,21 @@
+require 'ixtlan/optimistic_persistence_module'
+
+module DataMapper
+
+  class StaleResource < StandardError; end
+   
+  module OptimisticPersistenceValidation
+    
+    def self.included(base)
+      base.send(:include, ::Ixtlan::OptimisticPersistenceModule)
+      base.validates_with_block :stale do
+        if(stale?)
+          [false, "stale resource, please reload the resource"]
+        else
+          true
+        end
+      end
+    end
+    Model.append_inclusions self
+  end
+end

data/lib/ixtlan/passwords.rb

@@ -0,0 +1,19 @@
+module Ixtlan
+  class Passwords
+    def self.generate(length=64)
+      # A-Z starting with 97 and having 26 characters
+      # a-z starting with 65 and having 26 characters
+      # 0-9 starting with 48 and lies inside range starting with 33 and having 26 characters
+      offset=[97, 65, 33]
+      
+      # collect random characters from the either of the above ranges
+      begin
+        pwd = (0..(length - 1)).collect do
+          j = ActiveSupport::SecureRandom.random_number(78)
+          (offset[j / 26] + (j % 26)).chr
+        end.join
+      end while !((pwd =~ /[a-z]/) && (pwd =~ /[A-Z]/) && (pwd =~ /[!-;]/))
+      pwd
+    end
+  end
+end

data/lib/ixtlan/rails/audit.rb

@@ -0,0 +1,22 @@
+module Ixtlan
+  module Rails
+    module AuditBase
+      def self.included(base)
+        base.append_after_filter(Audit)
+      end
+    end
+
+    class Audit
+
+      def self.logger
+        @logger ||= UserLogger.new(self)
+      end
+
+      def self.filter(controller)
+        logger.log_action(controller)
+      end
+    end
+  end
+end
+
+::ActionController::Base.send(:include, Ixtlan::Rails::AuditBase)

data/lib/ixtlan/rails/error_handling.rb

@@ -0,0 +1,130 @@
+module Ixtlan
+  module Rails
+    module ErrorHandling
+
+      def log_user_error(exception)
+        UserLogger.new(Ixtlan::Rails::ErrorHandling).log_action(self, " - #{exception.class} - #{exception.message}")
+        log_error(exception)
+      end
+
+      def internal_server_error(exception)
+        dump_error(exception, Object.full_const_get(::Ixtlan::Models.CONFIGURATION).instance)
+        status = :internal_server_error
+        error_page(:internal_server_error, exception) do |exception|
+          "internal server error: #{exception.class.name}"
+        end
+      end
+
+      def error_page(status, exception, &block)
+        respond_to do |format| 
+          format.html { 
+            @notice = block.call(exception)
+            if logged_in?
+              render :template => "errors/error", :status => status
+            else
+              render :template => "sessions/login", :status => status
+            end
+          }
+          format.xml { head status }
+        end
+      end
+
+      def page_not_found(exception)
+        log_user_error(exception)
+        status = rescue_responses[exception.class.name]
+        status = status == :internal_server_error ? :not_found : status
+        error_page(status, exception) { "page not found" }
+      end
+
+      def stale_resource(exception)
+        log_user_error(exception)
+        respond_to do |format| 
+          format.html { 
+            render :template => "errors/stale", :status => :conflict
+          }
+          format.xml { head :conflict }
+        end
+      end
+
+      def dump_error(exception, config)
+        log_user_error(exception)
+        dumper = DumpError.new(config.notification_sender_email, 
+                               config.notification_recipient_email)
+        dumper.dump(self, exception)
+      end
+    end
+    
+    class ErrorNotifier < ActionMailer::Base
+      require 'pathname'
+
+      def error_notification(email_from, email_to, exception, error_file)
+        @subject    = exception.to_s
+        @body       = {:text => "#{error_file}"}
+        @recipients = email_to
+        @from       = email_from
+        @sent_on    = Time.now
+        @headers    = {}
+        path = Pathname(__FILE__).parent.dirname.to_s
+        view_paths << path unless view_paths.member? path
+        @template   = "error_notification.rhtml"
+      end
+
+    end
+    
+    class DumpError
+      
+      def initialize(email_from, email_to, errors_dir = "#{RAILS_ROOT}/log/errors")
+        FileUtils.mkdir_p(errors_dir)
+        @errors_dir = File.new(errors_dir)
+        @email_from = email_from
+        @email_to = email_to
+      end
+
+      def dump(controller, exception)
+        time = Time.now
+        error_log_id = "#{time.tv_sec}#{time.tv_usec}"
+        
+        log_file = File.join(@errors_dir.path.to_s, "error-#{error_log_id}.log")
+        logger = Logger.new(log_file)
+        
+        dump_environment(logger, exception, controller)
+        ErrorNotifier.deliver_error_notification(@email_from, @email_to, exception, log_file) unless @email_to.blank?
+        log_file
+      end 
+
+      private
+
+      def dump_environment_header(logger, header)
+        logger.error("\n===================================================================\n#{header}\n===================================================================\n");
+      end
+      
+      def dump_environment(logger, exception, controller)
+        dump_environment_header(logger, "REQUEST DUMP");
+        dump_hashmap(logger, controller.request.env)
+        
+        dump_environment_header(logger, "RESPONSE DUMP");
+        dump_hashmap(logger, controller.response.headers)
+        
+        dump_environment_header(logger, "SESSION DUMP");
+        dump_hashmap(logger, controller.session)
+        
+        dump_environment_header(logger, "PARAMETER DUMP");
+        map = {}
+        dump_hashmap(logger, controller.params.each{ |k,v| map[k]=v })
+        
+        dump_environment_header(logger, "EXCEPTION");
+        logger.error("#{exception.class}:#{exception.message}")
+        logger.error("\t" + exception.backtrace.join("\n\t"))
+      end
+
+      def dump_hashmap(logger, map)
+        for key,value in map
+          logger.error("\t#{key} => #{value.inspect}")
+        end
+      end
+
+    end
+  end
+end
+
+ActionController::Base.send(:include, Ixtlan::Rails::ErrorHandling)

data/lib/ixtlan/rails/guard.rb

@@ -0,0 +1,11 @@
+require 'ixtlan/guard'
+
+ActionController::Base.send(:include, Ixtlan::ActionController::Guard)
+ActionController::Base.send(:before_filter, :guard)
+ActionView::Base.send(:include, Ixtlan::Allowed)
+module Erector
+  class Widget
+    include Ixtlan::Allowed
+  end
+end
+

data/lib/ixtlan/rails/session_timeout.rb

@@ -0,0 +1,93 @@
+module Ixtlan
+  module Rails
+    module SessionTimeout
+
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        private
+
+        CONFIG = Object.full_const_get(Ixtlan::Models::CONFIGURATION)
+
+        def session_user_logger
+          @session_user_logger ||= UserLogger.new(Ixtlan::Rails::SessionTimeout)
+        end
+        
+        def expire_session
+          session.clear
+          #      reset_session
+          render_session_timeout
+          return false
+        end
+        
+        public
+        
+        def check_session_expiry
+          if !session[:expires_at].nil? and session[:expires_at] < DateTime.now
+            # Session has expired.
+            session_user_logger.log(self, "session timeout")
+            expire_session
+          else
+            # Assign a new expiry time
+            session[:expires_at] = session_timeout.minutes.from_now
+            return true
+          end
+        end
+        
+        def check_session_ip_binding
+          if !session[:session_ip].nil? and session[:session_ip] != request.headers['REMOTE_ADDR']
+            # client IP has changed
+            session_user_logger.log(self, "IP changed from #{session[:session_ip]} to #{request.headers['REMOTE_ADDR']}")
+            expire_session
+          else
+            # Assign client IP 
+            session[:session_ip] = request.headers['REMOTE_ADDR']
+            return true
+          end
+        end
+        
+        def check_session
+          check_session_ip_binding and check_session_expiry
+        end
+        
+        def check_session_browser_signature
+          if !session[:session_browser_signature].nil? and session[:session_browser_signature] != retrieve_browser_signature
+            # browser signature has changed
+            session_user_logger.log(self, "browser signature changed from #{session[:session_browser_signature]} to #{retrieve_browser_signature}")
+            expire_session
+            return false
+          else
+            # Assign a browser signature
+            session[:session_browser_signature] = retrieve_browser_signature
+            return true
+          end
+        end
+        
+        def retrieve_browser_signature
+          [request.headers['HTTP_USER_AGENT'],
+           request.headers['HTTP_ACCEPT_LANGUAGE'],
+           request.headers['HTTP_ACCEPT_ENCODING'],
+           request.headers['HTTP_ACCEPT']].join('|')
+        end
+        
+        def render_session_timeout
+          respond_to do |format| 
+            format.html { 
+              @notice = "session timeout" unless @notice
+              render :template => "sessions/login"
+            }
+            format.xml { head :unauthorized }
+          end
+        end
+        
+        def session_timeout
+          CONFIG.instance.session_idle_timeout
+        end
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, Ixtlan::Rails::SessionTimeout)

data/lib/ixtlan/rails/timestamps_modified_by_filter.rb

@@ -0,0 +1,33 @@
+module Ixtlan
+  module Rails
+    module TimestampsModifiedBy
+      module Base
+        def self.included(base)
+          base.prepend_around_filter(Filter)
+        end
+      end
+      
+      class Filter
+        def self.filter(controller)
+          name = controller.params[:controller]
+          unless name.nil?
+            parameters = controller.params[name.singular.to_sym]
+            unless parameters.nil?
+              parameters.delete(:created_at)
+              parameters.delete(:created_on)
+              parameters.delete(:created_by)
+              # do not delete the updated_at so that optimistic persistence
+              # can work !!!!
+              #parameters.delete(:updated_at)
+              parameters.delete(:updated_on)
+              parameters.delete(:updated_by)
+            end
+          end
+          yield if block_given?
+        end
+      end
+    end
+  end
+end
+
+::ActionController::Base.send(:include, Ixtlan::Rails::TimestampsModifiedBy::Base)

data/lib/ixtlan/rails/unrestful_authentication.rb

@@ -0,0 +1,137 @@
+module Ixtlan
+module Rails
+  module UnrestfulAuthentication
+
+    private
+
+    USER = Object.full_const_get(Ixtlan::Models::USER)
+
+    AUTHENTICATION = Object.full_const_get(Ixtlan::Models::AUTHENTICATION)
+
+    def authentication_logger
+      @authentication_logger ||= UserLogger.new(Ixtlan::Rails::UnrestfulAuthentication)
+    end
+
+    protected
+
+    def logged_in?
+      !session[:user_id].nil?
+    end
+
+    def current_user
+      session[:user] = login_from_session if logged_in? and session[:user].nil?
+      session[:user]
+    end 
+
+    def current_user=(new_user)
+      session[:user_id] = new_user ? new_user.id : nil
+      session[:user] = new_user
+    end
+
+    def verify_authenticity
+      if request.content_type == 'application/xml'
+        params[request_forgery_protection_token] = request.headers[:authenticity_token]
+      end
+      verify_authenticity_token if logged_in?
+    end
+
+    def authenticate
+      if logged_in?
+        case(request.method)
+        when :delete
+          logout
+        else
+          true
+        end
+      else
+        case(request.method)
+        when :get   
+          session.clear
+          render_login_page
+        when :post
+          user = login_from_params
+          if user.instance_of? String
+            authentication_logger.log_user(params[:login], user + " from IP #{request.headers['REMOTE_ADDR']}")
+            session.clear
+            render_access_denied
+          else
+            authentication_logger.log_user(user.login, "logged in")
+            session.clear
+            #  reset_session
+            self.current_user = user
+            render_successful_login
+          end
+        else
+          session.clear
+          render_access_denied
+        end
+        false
+      end
+    end
+
+    def login_from_params
+      USER.authenticate(params[:login], params[:password])
+    end
+
+    def login_from_session
+      USER.get(session[:user_id])
+    end
+
+    def logout
+      if(params[:login] == current_user.login or request.content_type == 'application/xml')
+        authentication_logger.log_user(current_user.login, "logged out")
+        current_user = nil
+        session.clear
+        # reset_session
+        render_logout_page
+        false
+      else
+        true
+      end
+    end
+
+    def render_successful_login
+      respond_to do |format|
+        format.html { redirect_to request.url, :status => :moved_permanently}
+        format.xml do
+          authentication = AUTHENTICATION.new
+          authentication.login = self.current_user.login
+          authentication.user = self.current_user
+          authentication.token = form_authenticity_token
+          render :xml => authentication.to_xml
+        end
+      end
+    end
+
+    def render_access_denied
+      respond_to do |format|
+        format.html do
+          @notice = "access denied" unless @notice
+          render :template => "sessions/login", :status => :unauthorized
+        end
+        format.xml { head :unauthorized}
+      end
+    end
+
+    def render_login_page
+      respond_to do |format|
+        format.html { render :template => "sessions/login" }
+        format.xml { head :unauthorized }
+      end
+    end
+
+    def render_logout_page
+      respond_to do |format|
+        format.html do
+          @notice = "logged out" unless @notice
+          render :template => "sessions/login"
+        end
+        format.xml { head :ok }
+      end
+    end    
+  end
+end
+end
+
+ActionController::Base.send(:include, Ixtlan::Rails::UnrestfulAuthentication)
+ActionController::Base.send(:prepend_before_filter, :authenticate)