ixtlan 0.2.0

data/lib/ixtlan/models/configuration.rb

@@ -0,0 +1,74 @@
+require 'dm-core'
+require 'ixtlan/modified_by'
+module Ixtlan
+  module Models
+    class Configuration
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Configuration"
+      end
+
+      property :id, Serial
+
+      property :session_idle_timeout, Integer, :nullable => false
+      
+      property :keep_audit_logs, Integer, :nullable => false 
+      
+      property :notification_sender_email, String, :format => :email, :nullable => true, :length => 64
+
+      property :notification_recipient_emails, String, :format => Proc.new { |email| emails = email.split(','); emails.find_all { |e| e =~ DataMapper::Validate::Format::Email::EmailAddress }.size == emails.size}, :nullable => true, :length => 254 #honour mysql max varchar length
+      
+      timestamps :updated_at
+
+      modified_by ::Ixtlan::Models::USER, :updated_by
+
+      def locales
+        if @locales.nil? 
+          # TODO spec the empty array to make sure new relations are stored
+          # in the database or the locales collection is empty before filling it
+          @locales = ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, Object.full_const_get(::Ixtlan::Models::LOCALE)), [])
+          ConfigurationLocale.all(:configuration_id => id).each{ |cl| @locales << cl.locale }
+          def @locales.configuration=(configuration)
+            @configuration = configuration
+          end
+          @locales.configuration = self
+          def @locales.<<(locale)
+            unless member? locale
+              ConfigurationLocale.create(:configuration_id => @configuration.id, :locale_code => locale.code)
+              super
+            end
+            
+            self
+          end
+          
+          def @locales.delete(locale) 
+            cl = ConfigurationLocale.first(:configuration_id => @configuration.id, :user_id => @user.id, :locale_code => locale.code)
+            if cl
+              cl.destroy
+            end
+            super
+          end
+        end
+        @locales
+      end
+
+      def self.instance
+        # HACK: return a new object in case there is none in the database
+        # to allow rails rake tasks to work with an empty database
+        begin
+          get(1) || new(:id => 1, :session_idle_timeout => 5, :keep_audit_logs => 7)
+        rescue
+          auto_migrate!
+          new(:id => 1, :session_idle_timeout => 5, :keep_audit_logs => 7)
+        end
+      end
+
+      alias :to_x :to_xml_document
+      def to_xml_document(opts, doc = nil)
+        opts.merge!({:methods => [:updated_by, :locales], :exclude => [:updated_by_id, :id]})
+        to_x(opts, doc)
+      end
+    end
+  end
+end

data/lib/ixtlan/models/configuration_locale.rb

@@ -0,0 +1,19 @@
+module Ixtlan
+  module Models
+    class ConfigurationLocale
+
+      include DataMapper::Resource
+      
+      def self.default_storage_name
+        "ConfigurationLocale"
+      end
+
+      property :configuration_id, Integer, :key => true
+      
+      property :locale_code, String, :key => true
+
+      belongs_to :configuration, :model => Models::CONFIGURATION
+      belongs_to :locale, :model => Models::LOCALE
+    end
+  end
+end

data/lib/ixtlan/models/group.rb

@@ -0,0 +1,69 @@
+module Ixtlan
+  module Models
+    class Group
+
+      include DataMapper::Resource
+      
+      def self.default_storage_name
+        "Group"
+      end
+
+      property :id, Serial, :field => "gidnumber"
+      
+      property :name, String, :nullable => false , :format => /^[^<'&">]*$/, :length => 32, :field => "cn", :unique_index => true
+      
+      timestamps :created_at
+      
+      modified_by Models::USER
+
+      def locales(user = nil)
+#        return ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, Locale), [])
+        if @locales.nil? or not user.nil?
+          
+          # TODO spec the empty array to make sure new relations are stored
+          # in the database or the locales collection is empty before filling it
+          @locales = ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, Models::Locale), [])
+
+          return @locales if user.nil?
+
+          GroupLocaleUser.all(:group_id => id, :user_id => user.id).each{ |glu| @locales << glu.locale }
+          def @locales.group=(group)
+            @group = group
+          end
+          @locales.group = self
+          def @locales.user=(user)
+            @user = user
+          end
+          @locales.user = user
+          def @locales.<<(locale)
+            unless member? locale
+              GroupLocaleUser.create(:group_id => @group.id, :user_id => @user.id, :locale_code => locale.code)
+              super
+            end
+            
+            self
+          end
+          def @locales.delete(locale) 
+            glu = GroupLocaleUser.first(:group_id => @group.id, :user_id => @user.id, :locale_code => locale.code)
+            if glu
+              glu.destroy
+            end
+            super
+          end
+        end
+        @locales
+      end
+
+      if protected_instance_methods.find {|m| m == 'to_x'}.nil?
+       
+        protected
+
+        alias :to_x :to_xml_document
+        def to_xml_document(opts, doc = nil)
+          opts.merge!({:methods => [:locales]})
+          to_x(opts, doc)
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/models/group_locale_user.rb

@@ -0,0 +1,22 @@
+module Ixtlan
+  module Models
+    class GroupLocaleUser
+
+      include DataMapper::Resource
+      
+      def self.default_storage_name
+        "GroupLocaleUser"
+      end
+
+      property :group_id, Integer, :key => true
+      
+      property :user_id, Integer, :key => true
+      
+      property :locale_code, String, :key => true
+
+      belongs_to :group, :model => Models::GROUP
+      belongs_to :user, :model => Models::USER
+      belongs_to :locale, :model => Models::LOCALE
+    end
+  end
+end

data/lib/ixtlan/models/group_user.rb

@@ -0,0 +1,39 @@
+module Ixtlan
+  module Models
+    class GroupUser
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "GroupUser"
+      end
+
+      # dn_prefix { |group_user| "cn=#{group_user.group.name}" }
+      
+      #treebase "ou=groups"
+      
+      # multivalue_field :memberuid
+      
+      #ldap_properties do |group_user|
+      #   {:cn=>"#{group_user.group.name}",  :objectclass => "posixGroup"}
+      # end
+      property :memberuid, String, :key => true
+      property :gidnumber, Integer, :key => true
+      
+      def group
+        Object.full_const_get(Models::GROUP).get!(gidnumber)
+      end
+      
+      def group=(group)
+        gidnumber = group.id
+      end
+      
+      def user
+        Object.full_const_get(Models::USER).first(:login => memberuid)
+      end
+      
+      def user=(user)
+        memberuid = user.login
+      end
+    end
+  end
+end

data/lib/ixtlan/models/locale.rb

@@ -0,0 +1,37 @@
+module Ixtlan
+  module Models
+    class Locale
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Locale"
+      end
+
+      unless const_defined? "DEFAULT"
+        DEFAULT = "DEFAULT"
+        ALL = "ALL"
+      end
+
+      property :code, String, :nullable => false , :format => /^[a-z][a-z](_[A-Z][A-Z])?$|^#{DEFAULT}$|^#{ALL}$/, :length => 7, :key => true
+      
+      timestamps :created_at
+
+      def self.default
+        get(DEFAULT) || create(:code => DEFAULT)
+      end
+
+      def self.every
+        get(ALL) || create(:code => ALL)
+      end
+
+      def hash
+        attribute_get(:code).hash
+      end
+      
+      alias :eql? :==
+        def ==(other)
+          attribute_get(:code).eql?(other.attribute_get(:code))
+        end
+      end
+    end
+end

data/lib/ixtlan/models/permission.rb

@@ -0,0 +1,29 @@
+module Ixtlan
+  module Models
+    class Permission
+
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Permission"
+      end
+
+      property :resource, String,:format => /^[a-zA-Z0-9_.]*$/, :key => true
+
+      property :action, String, :format => /^[a-zA-Z0-9_.]*$/, :key => true
+
+      has n, :roles, :model => Models::ROLE
+
+      if protected_instance_methods.find {|m| m == 'to_x'}.nil?
+       
+        protected
+        
+        alias :to_x :to_xml_document
+        def to_xml_document(opts, doc = nil)
+          opts.merge!({:methods => [:roles]})
+          to_x(opts, doc)
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/models/phrase.rb

@@ -0,0 +1,71 @@
+module Ixtlan
+  module Models
+    class Phrase
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Phrase"
+      end
+
+      property :id, Serial
+
+      property :code, String, :nullable => false, :length => 64
+      
+      property :text, String, :nullable => false, :length => 256
+      
+      property :current_text, String, :nullable => true, :length => 256
+      
+      property :updated_at, DateTime, :nullable => false, :auto_validation => false
+      
+      belongs_to :updated_by, :model => Models::USER
+      
+      belongs_to :locale, :model => Models::LOCALE
+      
+      belongs_to :default_translation, :model => Models::TRANSLATION, :nullable => true
+
+      belongs_to :parent_translation, :model => Models::TRANSLATION, :nullable => true
+
+      alias :to_x :to_xml_document
+      def to_xml_document(opts = {}, doc = nil)
+        opts.merge!({:exclude => [:id, :parent_translation_id, :default_translation_id, :locale_code], :element_name => 'phrase', :methods => [:default_translation, :parent_translation, :locale]})
+        to_x(opts, doc)
+      end
+
+      def self.all(args = {})
+        phrases = ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, Ixtlan::Models::Phrase), [])
+        map = {}
+        locale = (args[:locale] ||= Locale.default)
+        Text.not_approved(args.dup).each do |text|
+          phrase = Phrase.new(:code => text.code, :text => text.text, :current_text => text.text, :locale => locale, :updated_at => text.updated_at, :updated_by => text.updated_by)
+          map[phrase.code] = phrase
+        end
+        Text.latest_approved(args.dup).each do |text|
+          if (phrase = map[text.code])
+            phrase.current_text = text.text
+          else
+            phrase = Phrase.new(:code => text.code, :text => text.text, :current_text => text.text, :locale => locale, :updated_at => text.updated_at, :updated_by => text.updated_by)
+            map[phrase.code] = phrase
+          end
+        end
+        case locale.code.size
+        when 2
+          params = args.dup
+          params[:locale] = Locale.default
+          Translation.map_for(params).each do |code, trans|
+            ph = map[code]
+            if(ph.nil?)
+              map[code] = Phrase.new(:code => code, :text => trans.text, :current_text => trans.text, :locale => locale, :updated_at => trans.approved_at, :updated_by => trans.approved_by, :default_translation => trans)
+            else  
+              ph.default_translation = trans
+            end
+          end
+        when 5
+          raise "not implemented yet"
+        end
+        map.values.each { |ph| phrases << ph}
+        phrases
+      end
+    end
+  end
+end
+

data/lib/ixtlan/models/role.rb

@@ -0,0 +1,35 @@
+module Ixtlan
+  module Models
+    class Role
+
+      include DataMapper::Resource
+      
+      def self.default_storage_name
+        "Role"
+      end
+
+      property :name, String, :nullable => false , :format => /^[a-zA-Z0-9\-_.]*$/, :length => 32, :key => true
+
+      def hash
+        attribute_get(:name).hash
+      end
+
+      alias :eql? :==
+      def ==(other)
+        attribute_get(:name).eql?(other.attribute_get(:name))
+      end
+
+      if protected_instance_methods.find {|m| m == 'to_x'}.nil?
+       
+        protected
+        
+        alias :to_x :to_xml_document
+        def to_xml_document(opts, doc = nil)
+          opts.merge!({:exclude => [:permission_resource,:permission_action]})
+          to_x(opts, doc)
+        end
+      end
+    end
+  end
+end
+

data/lib/ixtlan/models/text.rb

@@ -0,0 +1,140 @@
+module Ixtlan
+  module Models
+    class Text
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Text"
+      end
+
+      property :id, Serial
+      
+      property :code, String, :nullable => false, :length => 64
+      
+      property :text, String, :nullable => false, :length => 256
+      
+      property :version, Integer, :nullable => true
+      
+      property :current, Boolean, :nullable => false, :auto_validation => false
+
+      property :previous, Boolean, :nullable => false, :auto_validation => false
+
+      property :updated_at, DateTime, :nullable => false, :auto_validation => false
+      
+      belongs_to :updated_by, :model => Models::USER
+      
+      property :approved_at, DateTime, :nullable => true
+      
+      belongs_to :approved_by, :model => Models::USER, :nullable => true
+      
+      belongs_to :locale, :model => Models::LOCALE
+
+      validates_with_method :invariant
+
+      def invariant
+        no_version = original_attributes[:version].nil? && attribute_get(:version).nil?
+        if no_version
+          if (!attribute_get(:version).nil? && attribute_dirty?(:version) && attribute_dirty?(:text))
+            [false, 'can not approve and change text at the same time']
+          elsif new?
+            [true]
+          elsif attribute_dirty?(:code)
+            [false, 'code is invariant']
+          else
+            [true]
+          end
+        else
+          if (!attribute_get(:version).nil? && attribute_dirty?(:version))
+            if (attribute_dirty?(:text))
+              [false, 'can not approve and change text at the same time']
+            elsif !original_attributes[properties[:version]].nil?
+              [false, 'can not change version']
+            else
+              [true]
+            end
+          elsif attribute_dirty?(:code)
+            [false, 'can not change code']
+          elsif attribute_dirty?(:text)
+            [false, 'can not change text']
+          else
+            [true]
+          end
+        end
+      end
+
+      validates_with_method :cascade
+
+      def cascade
+        size = 
+          case locale.code.size
+          when 2
+            self.model.latest_approved(:code => code, :locale => Locale.default).size 
+          when 5
+            self.model.latest_approved(:code => code, :locale => Locale.get(locale.code[0,1])).size
+          else
+            1
+          end
+        if(size == 0)
+          [false, "parent text for '#{code}' does not exists"]
+        else
+          [true]
+        end
+      end
+
+      before :save do
+        if(new? or attribute_get(:version).nil?)
+          attribute_set(:version, nil)
+          attribute_set(:current, false)
+          attribute_set(:previous, false)
+          attribute_set(:approved_at, nil)
+          approved_by = nil
+        end
+      end
+
+      def approve(params = {})
+        latest = self.class.latest_approved(:code => attribute_get(:code),
+                                            :locale => locale).first
+        previous = self.class.second_latest_approved(:code => attribute_get(:code),
+                                                     :locale => locale).first
+        params[:version] = latest.nil? ? 1 : latest.version + 1
+        params[:current] = true
+        params[:approved_at] = attribute_get(:updated_at)
+        params[:approved_by] = params[:current_user]
+        
+        p = (previous.nil? ? true : previous.update(:previous => false,
+                                                    :current_user => params[:current_user]))
+        l = (latest.nil? ? true : latest.update(:current => false, 
+                                                :previous => true,
+                                                :current_user => params[:current_user]))
+        u = update(params)
+        
+        u && l && p
+      end
+      
+      def approved?
+        !attribute_get(:version).nil?
+      end
+
+      def self.latest_approved(args = {})
+        args[:current] = true
+        all(args)
+      end
+
+      def self.second_latest_approved(args = {})
+        args[:previous] = true
+        all(args)
+      end
+
+      def self.approved(args = {})
+        args[:version.not] = nil
+        all(args)
+      end
+
+      def self.not_approved(args = {})
+        args[:version] = nil
+        all(args)
+      end
+    end
+  end
+end
+

data/lib/ixtlan/models/translation.rb

@@ -0,0 +1,40 @@
+module Ixtlan
+  module Models
+    class Translation
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "Translation"
+      end
+      
+      property :id, Serial
+
+      property :text, String, :nullable => false, :length => 256
+      
+      property :previous_text, String, :nullable => true, :length => 256
+      
+      property :approved_at, DateTime, :nullable => false, :auto_validation => false
+      
+      belongs_to :approved_by, :model => Models::USER
+      
+      def self.map_for(args = {})
+        map = {}
+        Text.latest_approved(args.dup).each do |text|
+          map[text.code] = Translation.create(:text => text.text, :approved_at => text.approved_at, :approved_by => text.approved_by)
+        end
+        Text.second_latest_approved(args.dup).each do |text|
+          translation = map[text.code]
+          translation.previous_text = text.text
+        end
+        map
+      end
+
+      alias :to_x :to_xml_document
+      def to_xml_document(opts = {}, doc = nil)
+        opts.merge!({:exclude => [:id]})
+        to_x(opts, doc)
+      end
+    end
+  end
+end
+

data/lib/ixtlan/models/user.rb

@@ -0,0 +1,112 @@
+require 'digest'
+require 'base64'
+require 'ixtlan/modified_by'
+require 'dm-serializer'
+module Ixtlan
+  module Models
+    class User
+      include DataMapper::Resource
+
+      def self.default_storage_name
+        "User"
+      end
+
+      property :id, Serial, :field => "uidnumber"
+
+      property :login, String, :nullable => false , :length => 4..32, :index => :unique_index, :format => /^[a-zA-z0-9]*$/, :writer => :private, :field => "uid"
+
+      property :name, String, :nullable => false, :format => /^[^<">]*$/, :length => 2..64, :field => "cn"
+
+      property :email, String, :nullable => false, :format => :email_address, :nullable => false, :length => 8..64, :index => :unique_index, :field => "mail"
+
+      property :language, String, :nullable => false, :format => /[a-z][a-z]/, :length => 2, :field => "preferredlanguage"
+
+      property :hashed_password, String, :nullable => true, :length => 128, :accessor => :private, :field => "userpassword"
+
+      timestamps :at
+
+      modified_by ::Ixtlan::Models::USER
+
+      # Virtual attribute for the plaintext password
+      attr_reader :password
+
+      validates_is_unique  :login
+      validates_is_unique  :email
+
+      def reset_password(len = 12)
+        @password = Ixtlan::Passwords.generate(len)
+        attribute_set(:hashed_password, Ixtlan::Digest.ssha(@password, "--#{Time.now}--#{login}--"))
+        @password
+      end
+      
+      def digest
+        ::Base64.decode64(@hashed_password[6,200])
+      end
+
+      def self.authenticate(login, password)
+        user = first(:login => login) # need to get the salt
+        if user
+          digest = user.digest
+          salt = digest[20,147]
+          if ::Digest::SHA1.digest("#{password}" + salt) == digest[0,20]
+            user
+          else
+            "wrong password"
+          end
+        else
+          "unknown login"
+        end
+      end
+
+      def groups
+        if @groups.nil?
+          # TODO spec the empty array to make sure new relations are stored
+          # in the database or the groups collection is empty before filling it
+          @groups = ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, Models::Group), [])
+          GroupUser.all(:memberuid => login).each do |gu| 
+            @groups << gu.group
+          end
+          def @groups.user=(user)
+            @user = user
+          end
+          @groups.user = self
+          def @groups.<<(group)
+            group.locales(@user)
+            unless member? group
+              gu = GroupUser.create(:memberuid => @user.login, :gidnumber => group.id)
+              super
+            end
+            
+            self
+          end
+          
+          def @groups.delete(group) 
+            gu = GroupUser.first(:memberuid => @user.login, :gidnumber => group.id)
+            if gu
+              gu.destroy
+            end
+            super
+          end
+          @groups.each {|g| g.locales(self) }
+        end
+        @groups
+      end
+
+      # make sure login is immutable
+      def login=(new_login)
+        attribute_set(:login, new_login) if (login.nil? or login == "'NULL'" or login == "NULL")
+      end
+
+      if protected_instance_methods.find {|m| m == 'to_x'}.nil?
+        alias :to_x :to_xml_document 
+
+        protected
+
+        def to_xml_document(opts={}, doc = nil)
+          opts.merge!({:exclude => [:hashed_password], :methods => [:groups]})
+          to_x(opts, doc)
+        end
+      end
+    end
+  end
+end