ixtlan 0.2.4 → 0.3.0

data/lib/ixtlan/models/locale.rb

@@ -1,3 +1,4 @@
+require 'dm-serializer'
 module Ixtlan
   module Models
     class Locale
@@ -12,10 +13,13 @@ module Ixtlan
         ALL = "ALL"
       end
 
-      property :code, String, :nullable => false , :format => /^[a-z][a-z](_[A-Z][A-Z])?$|^#{DEFAULT}$|^#{ALL}$/, :length => 7, :key => true
-      
+      property :id, Serial
+      property :code, String, :required => true , :format => /^[a-z][a-z](_[A-Z][A-Z])?$|^#{DEFAULT}$|^#{ALL}$/, :length => 7, :unique_index => true
+
       timestamps :created_at
 
+      modified_by Models::USER, :created_by
+
       def parent
         c = attribute_get(:code)
         case c.size
@@ -29,17 +33,25 @@ module Ixtlan
       end
 
       def self.default
-        get(DEFAULT) || create(:code => DEFAULT)
+        first(:code => DEFAULT)
       end
 
       def self.every
-        get(ALL) || create(:code => ALL)
+        first(:code => ALL)
+      end
+
+      def self.first_or_get!(id_or_code)
+        first(:code => id_or_code) || get!(id_or_code)
+      end
+
+      def self.first_or_get(id_or_code)
+        first(:code => id_or_code) || get(id_or_code)
       end
 
       def hash
         attribute_get(:code).hash
       end
-      
+
       alias :eql? :==
         def ==(other)
           attribute_get(:code).eql?(other.attribute_get(:code))

data/lib/ixtlan/models/permission.rb

@@ -1,3 +1,4 @@
+require 'dm-serializer'
 module Ixtlan
   module Models
     class Permission
@@ -15,9 +16,9 @@ module Ixtlan
       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]})

data/lib/ixtlan/models/phrase.rb

@@ -1,3 +1,4 @@
+require 'dm-serializer'
 module Ixtlan
   module Models
     class Phrase
@@ -9,25 +10,25 @@ module Ixtlan
 
       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
-      
+      property :code, String, :required => true, :length => 64
+
+      property :text, String, :required => true, :length => 256
+
+      property :current_text, String, :required => false, :length => 256
+
+      property :updated_at, DateTime, :required => true, :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
+      belongs_to :default_translation, :model => Models::TRANSLATION, :required => false
+
+      belongs_to :parent_translation, :model => Models::TRANSLATION, :required => false
 
       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]})
+        opts.merge!({:exclude => [:id, :parent_translation_id, :default_translation_id, :locale_id], :element_name => 'phrase', :methods => [:default_translation, :parent_translation, :locale]})
         to_x(opts, doc)
       end
 
@@ -55,7 +56,7 @@ module Ixtlan
             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  
+            else
               ph.default_translation = trans
             end
           end
@@ -68,4 +69,3 @@ module Ixtlan
     end
   end
 end
-

data/lib/ixtlan/models/role.rb

@@ -1,14 +1,15 @@
+require 'dm-serializer'
 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
+      property :name, String, :required => true , :format => /^[a-zA-Z0-9\-_.]*$/, :length => 32, :key => true
 
       def hash
         attribute_get(:name).hash
@@ -20,9 +21,9 @@ module Ixtlan
       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]})
@@ -32,4 +33,3 @@ module Ixtlan
     end
   end
 end
-

data/lib/ixtlan/models/translation.rb

@@ -1,3 +1,4 @@
+require 'dm-serializer'
 module Ixtlan
   module Models
     class Translation
@@ -6,17 +7,17 @@ module Ixtlan
       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
-      
+      property :text, String, :required => true, :length => 256
+
+      property :previous_text, String, :required => false, :length => 256
+
+      property :approved_at, DateTime, :required => true, :auto_validation => false
+
       belongs_to :approved_by, :model => Models::USER
-      
+
       def self.map_for(args = {})
         map = {}
         I18nText.latest_approved(args.dup).each do |text|
@@ -37,4 +38,3 @@ module Ixtlan
     end
   end
 end
-

data/lib/ixtlan/models/update_children.rb

@@ -0,0 +1,74 @@
+module Ixtlan
+  module Models
+    module UpdateChildren
+
+      def update_children(new_children, old_children_sym)
+        # get the dm-core/collection and its model
+        old_children = send(old_children_sym)
+        model = old_children.model
+
+        # make sure we have an array
+        if new_children.is_a?(Array)
+          # ids of new children
+          new_ids = new_children.collect { |v| v.to_i }
+        else
+          new_children = if new_children.nil?
+                           []
+                         else
+                           new_children[new_children.keys[0]]
+                         end
+          new_children = [new_children] unless new_children.is_a? Array
+
+          # ids of new children
+          new_ids = new_children.collect { |v| v[:id].to_i }
+        end
+
+        # delete obsolete old children
+        old_children.select do |g|
+          !(new_ids.member? g.id)
+        end.each do |g|
+          old_children.delete(g)
+        end
+
+        # add missing new children
+        old_ids = old_children.collect { |g| g.id }
+        new_ids.each do |gid|
+          old_children << model.get!(gid)  unless old_ids.member? gid
+        end
+      end
+
+      def update_restricted_children(new_children, old_children_sym, allowed_children)
+        # get the dm-core/collection and its model
+        old_children = send(old_children_sym)
+        model = old_children.model
+
+        # make sure we have an array
+        new_children = if new_children.nil?
+                         []
+                       else
+                         new_children[new_children.keys[0]]
+                       end
+        new_children = [new_children] unless new_children.is_a? Array
+
+        # ids of new children
+        new_ids = new_children.collect { |v| v[:id].to_i }
+        # ids of allowed children
+        allowed_ids = allowed_children.collect { |g| g.id }
+
+        # delete obsolete and allowed old children
+        set = old_children.select do |g|
+          !(new_ids.member? g.id) && (allowed_ids.member? g.id)
+        end
+        set.each do |g|
+          old_children.delete(g)
+        end
+
+        # add missing and allowed new children
+        old_ids = old_children.collect { |g| g.id }
+        new_ids.each do |gid|
+          old_children << model.get!(gid) if !old_ids.member?(gid) && allowed_ids.member?(gid)
+        end
+      end
+    end
+  end
+end

data/lib/ixtlan/models/user.rb

@@ -2,10 +2,14 @@ require 'digest/sha1'
 require 'base64'
 require 'ixtlan/modified_by'
 require 'dm-serializer'
+require 'ixtlan/models/update_children'
 module Ixtlan
   module Models
     class User
       include DataMapper::Resource
+      include UpdateChildren
+
+      GROUP = Object.full_const_get(Models::GROUP)
 
       def self.default_storage_name
         "User"
@@ -13,15 +17,15 @@ module Ixtlan
 
       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 :login, String, :required => true, :field => "uid", :length => 4..32, :unique_index => true, :format => /^[a-zA-Z0-9]*$/, :writer => :private
 
-      property :name, String, :nullable => false, :format => /^[^<">]*$/, :length => 2..64, :field => "cn"
+      property :name, String, :required => true, :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 :email, String, :required => true, :format => :email_address, :required => true, :length => 8..64, :unique_index => true, :field => "mail"
 
-      property :language, String, :nullable => false, :format => /[a-z][a-z]/, :length => 2, :field => "preferredlanguage"
+      property :language, String, :required => false, :format => /[a-z][a-z]/, :length => 2, :field => "preferredlanguage"
 
-      property :hashed_password, String, :nullable => true, :length => 128, :accessor => :private, :field => "userpassword"
+      property :hashed_password, String, :required => false, :length => 128, :accessor => :private, :field => "userpassword"
 
       timestamps :at
 
@@ -30,15 +34,15 @@ module Ixtlan
       # Virtual attribute for the plaintext password
       attr_reader :password
 
-      validates_is_unique  :login
-      validates_is_unique  :email
+      #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
@@ -58,12 +62,20 @@ module Ixtlan
         end
       end
 
+      def self.first_or_get!(id_or_login)
+        first(:login => id_or_login) || get!(id_or_login)
+      end
+
+      def self.first_or_get(id_or_login)
+        first(:login => id_or_login) || get(id_or_login)
+      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 = ::DataMapper::Collection.new(::DataMapper::Query.new(self.repository, GROUP), [])
+          GroupUser.all(:memberuid => login).each do |gu|
             @groups << gu.group
           end
           def @groups.user=(user)
@@ -72,22 +84,26 @@ module Ixtlan
           @groups.user = self
           def @groups.<<(group)
             group.locales(@user)
+            group.domains(@user)
             unless member? group
               gu = GroupUser.create(:memberuid => @user.login, :gidnumber => group.id)
               super
             end
-            
+
             self
           end
-          
-          def @groups.delete(group) 
+
+          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) }
+          @groups.each do |g|
+            g.locales(self)
+            g.domains(self)
+          end
         end
         @groups
       end
@@ -97,13 +113,89 @@ module Ixtlan
         attribute_set(:login, new_login) if login.nil?
       end
 
+      def root?
+        groups.detect { |g| g.root? } || false
+      end
+
+      def locales_admin?
+        groups.detect { |g| g.locales_admin? } || false
+      end
+
+      def domains_admin?
+        groups.detect { |g| g.domains_admin? } || false
+      end
+
+      def update_all_children(new_groups)
+        if current_user.root?
+          # root has no restrictions
+          update_children(new_groups, :groups)
+          update_locales_domains(new_groups)
+        else
+          update_restricted_children(new_groups, :groups, current_user.groups)
+          if current_user.locales_admin? || current_user.domains_admin?
+            # locales/domains admin can use all locales/domains
+            update_locales_domains(new_groups)
+          end
+          if !current_user.locales_admin? || !current_user.domains_admin?
+            update_restricted_locales_domains(new_groups, current_user.groups)
+          end
+        end
+      end
+
+      def update_locales_domains(new_groups)
+        if(new_groups)
+          # make sure we have an array
+          new_groups = new_groups[:group]
+          new_groups = [new_groups] unless new_groups.is_a? Array
+
+          # create a map group_id =>  group
+          user_groups_map = {}
+          groups.each { |g| user_groups_map[g.id.to_s] = g }
+
+          # for each new groups update the locales/domains respectively
+          new_groups.each do |group|
+             if user_groups_map.key?(group[:id])
+               user_groups_map[group[:id]].update_children(group[:locales], :locales) if current_user.locales_admin? || current_user.root?
+               user_groups_map[group[:id]].update_children(group[:domains], :domains) if current_user.domains_admin? || current_user.root?
+             end
+          end
+        end
+      end
+
+      def update_restricted_locales_domains(new_groups, ref_groups)
+        if(new_groups)
+          # make sure we have an array
+          new_groups = new_groups[:group]
+          new_groups = [new_groups] unless new_groups.is_a? Array
+
+          # create a map group_id =>  group
+          user_groups_map = {}
+          groups.each { |g| user_groups_map[g.id.to_s] = g }
+          # create a map group_id =>  group for the reference group
+          ref_group_locales = {}
+          ref_groups.each { |g| ref_group_locales[g.id.to_s] = g.locales }
+          ref_group_domains = {}
+          ref_groups.each { |g| ref_group_domains[g.id.to_s] = g.domains }
+
+          # for each new groups update the locales respectively
+          new_groups.each do |group|
+            if user_groups_map.key?(group[:id])
+              user_groups_map[group[:id]].update_restricted_children(group[:locales], :locales, ref_group_locales[group[:id]] || []) unless current_user.locales_admin?
+              user_groups_map[group[:id]].update_restricted_children(group[:domains], :domains, ref_group_domains[group[:id]] || []) unless current_user.domains_admin?
+            end
+          end
+        end
+      end
+
       if protected_instance_methods.find {|m| m == 'to_x'}.nil?
-        alias :to_x :to_xml_document 
+        alias :to_x :to_xml_document
 
         protected
 
         def to_xml_document(opts={}, doc = nil)
-          opts.merge!({:exclude => [:hashed_password], :methods => [:groups]})
+          unless(opts[:methods] || opts[:exclude])
+            opts.merge!({:exclude => [:hashed_password], :methods => [:groups]})
+          end
           to_x(opts, doc)
         end
       end

data/lib/ixtlan/models/word.rb

@@ -1,10 +1,11 @@
+require 'dm-serializer'
 module Ixtlan
   module Models
     class Word < Ixtlan::Models::I18nText
 
       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]})
+        opts.merge!({:element_name => "word", :exclude => [:id, :locale_id, :current, :previous, :updated_at, :approved_at, :updated_by_id, :approved_by_id, :version]})
         to_x(opts, doc)
       end
     end

data/lib/ixtlan/models.rb

@@ -6,6 +6,7 @@ module Ixtlan
     ROLE = "::Ixtlan::Models::Role" unless const_defined? "ROLE"
     PERMISSION = "::Ixtlan::Models::Permission" unless const_defined? "PERMISSION"
     LOCALE = "::Ixtlan::Models::Locale" unless const_defined? "LOCALE"
+    DOMAIN = "::Ixtlan::Models::Domain" unless const_defined? "DOMAIN"
     CONFIGURATION = "::Ixtlan::Models::Configuration" unless const_defined? "CONFIGURATION"
     TRANSLATION = "::Ixtlan::Models::Translation" unless const_defined? "TRANSLATION"
     TEXT = "::Ixtlan::Models::I18nText" unless const_defined? "TEXT"

data/lib/ixtlan/modified_by.rb

@@ -1,12 +1,13 @@
 #require 'dm-core'
 module Ixtlan
 
-  module ModifiedBy    
+  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? }
+      :created_by => lambda {|r, u| r.created_by = u #if r.new? 
+}
     }.freeze
 
     def self.included(model)
@@ -22,7 +23,7 @@ module Ixtlan
 
     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
 
@@ -56,14 +57,15 @@ module Ixtlan
     end
 
     module ClassMethods
-      def modified_by(type, *names)
-        if(names.empty?)
-          modified_by(type, :created_by, :updated_by)
+      def modified_by(type, names = nil, options = {})
+        if(names.nil?)
+          modified_by(type, [:created_by, :updated_by])
         else
+          names = [names] unless names.is_a?(Enumerable)
           names.each do |name|
             case name
             when *MODIFIED_BY_PROPERTIES.keys
-              belongs_to name, :model => type.to_s
+              belongs_to name, options.merge!({:model => type.to_s})
             else
               raise ::DataMapper::InvalidModifiedByName, "Invalid 'modified by' name '#{name}'"
             end

data/lib/ixtlan/monkey_patches.rb

@@ -12,8 +12,8 @@ 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)
+      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
@@ -21,15 +21,15 @@ 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 == :=~ 
+          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

data/lib/ixtlan/optimistic_persistence.rb

@@ -6,9 +6,9 @@ module DataMapper
 
 end
 
-module Ixtlan   
+module Ixtlan
   module OptimisticPersistence
-    
+
     def self.included(base)
       base.send(:include, ::Ixtlan::OptimisticPersistenceModule)
       base.before :valid? do

data/lib/ixtlan/optimistic_persistence_module.rb

@@ -6,10 +6,10 @@ module Ixtlan
         qu = {}
         c = model.key_conditions(repository, key)
         c.each {|p,v| qu[p.name] = v}
-        
+
         s = self.model.first(qu)
-        if s.nil? 
-          false 
+        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

data/lib/ixtlan/optimistic_persistence_validation.rb

@@ -3,9 +3,9 @@ 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

data/lib/ixtlan/passwords.rb

@@ -1,19 +1,21 @@
 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
+      if length > 0
+        # 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
 end