zena 1.2.7 → 1.2.8

data/app/models/role.rb

@@ -262,6 +262,10 @@ class Role < ActiveRecord::Base
       relation.save!
     end
   end
+  
+  def db_columns
+    @original_columns || {}
+  end
 
   private
     def set_defaults

data/app/models/site.rb

@@ -51,7 +51,7 @@ class Site < ActiveRecord::Base
     ['zips'                , 'site_id = ?'],
     ['nodes'               , 'site_id = ?'],
   ]
-  ACTIONS = %w{clear_cache rebuild_index}
+  ACTIONS = %w{clear_cache rebuild_index rebuild_fullpath}
   PUBLIC_PATH = Bricks.raw_config['public_path'] || '/public'
   CACHE_PATH  = Bricks.raw_config['cache_path']  || '/public'
   
@@ -59,10 +59,11 @@ class Site < ActiveRecord::Base
   safe_method  :host   => String, :lang_list => [String], :default_lang => String, :master_host => String
   safe_method  :root   => Proc.new {|h, r, s| {:method => 'root_node', :class => current_site.root_node.vclass, :nil => true}}
   safe_method  :home   => Proc.new {|h, r, s| {:method => 'home_node', :class => current_site.home_node.vclass, :nil => true}}
+  safe_method  :readonly? => {:method => 'site_readonly?', :class => Boolean}
 
   validate :valid_site
   validates_uniqueness_of :host
-  attr_accessible :name, :languages, :default_lang, :authentication, :http_auth, :ssl_on_auth, :auto_publish, :redit_time, :api_group_id, :home_zip
+  attr_accessible :name, :languages, :default_lang, :authentication, :http_auth, :ssl_on_auth, :site_readonly, :auto_publish, :redit_time, :api_group_id, :home_zip, :skin_zip
   has_many :groups, :order => "name"
   has_many :nodes
   has_many :users
@@ -76,7 +77,7 @@ class Site < ActiveRecord::Base
   include Zena::Use::MLIndex::SiteMethods
 
   @@attributes_for_form = {
-    :bool => %w{authentication http_auth auto_publish ssl_on_auth},
+    :bool => %w{authentication http_auth auto_publish ssl_on_auth site_readonly},
     :text => %w{languages default_lang},
   }
   
@@ -155,7 +156,7 @@ class Site < ActiveRecord::Base
       site.groups << pub << sgroup << editors
 
       # Reload group_ids in admin
-      admin_user.instance_variable_set(:@group_ids, nil)
+      admin_user.reload_groups!
 
       # =========== CREATE Anonymous User =====================
       # create anon user
@@ -251,7 +252,7 @@ class Site < ActiveRecord::Base
     end
   end
 
-  property.string 'usr_prototype_attributes'
+  property.string 'usr_prototype_attributes'  
   property.boolean 'expire_in_dev'
   property.boolean 'ssl_on_auth'
 
@@ -405,6 +406,30 @@ class Site < ActiveRecord::Base
       @home_zip_error = _('could not be found')
     end
   end
+
+  def skin_zip
+    skin ? skin.zip : nil
+  end
+  
+  def skin_zip=(zip)
+    if zip.blank?
+      self[:skin_id] = nil
+    else
+      if id = secure(Node) { Node.translate_pseudo_id(zip) }
+        self[:skin_id] = id
+      else
+        @skin_zip_error = _('could not be found')
+      end
+    end
+  end
+
+  def skin
+    secure(Skin) { Skin.find_by_id(skin_id) }
+  end
+
+  def skin_id
+    @alias && @alias[:skin_id] || self[:skin_id]
+  end
   
   def create_alias(hostname)
     raise "Hostname '#{hostname}' already exists" if Site.find_by_host(hostname)
@@ -463,7 +488,7 @@ class Site < ActiveRecord::Base
     end
   end
 
-  def clear_cache(clear_zafu = true)
+  def clear_cache(should_clear_zafu = true)
     paths = ["#{SITES_ROOT}#{self.cache_path}"]
     aliases = Site.all(:conditions => {:master_id => self.id})
     aliases.each do |site|
@@ -473,32 +498,30 @@ class Site < ActiveRecord::Base
 
     paths.each do |path|
       if File.exist?(path)
+        # First remove DB entries so that we do not risk race condition where a cached page is created during
+        # filesystem operation and before.
+        Zena::Db.execute "DELETE FROM caches WHERE site_id = #{self[:id]}"
+        Zena::Db.execute "DELETE FROM cached_pages_nodes WHERE cached_pages_nodes.node_id IN (SELECT nodes.id FROM nodes WHERE nodes.site_id = #{self[:id]})"
+        Zena::Db.execute "DELETE FROM cached_pages WHERE site_id = #{self[:id]}"
+      
         Dir.foreach(path) do |elem|
           next unless elem =~ /^(\w\w\.html|\w\w|login\.html)$/
           FileUtils.rmtree(File.join(path, elem))
         end
-
-        Zena::Db.execute "DELETE FROM caches WHERE site_id = #{self[:id]}"
-        Zena::Db.execute "DELETE FROM cached_pages_nodes WHERE cached_pages_nodes.node_id IN (SELECT nodes.id FROM nodes WHERE nodes.site_id = #{self[:id]})"
-        Zena::Db.execute "DELETE FROM cached_pages WHERE site_id = #{self[:id]}"
       end
     end
     
-    # Clear zafu
-    if clear_zafu
-      paths = ["#{SITES_ROOT}#{self.zafu_path}"]
-      aliases.each do |site|
-        paths << "#{SITES_ROOT}#{site.cache_path}"
-      end
-      paths.each do |path|
-        if File.exist?(path)
-          FileUtils.rmtree(path)
-        end
-      end
-    end
+    clear_zafu if should_clear_zafu
 
     true
   end
+  
+  def clear_zafu
+    path = "#{SITES_ROOT}#{self.zafu_path}"
+    if File.exist?(path)
+      FileUtils.rmtree(path)
+    end
+  end
 
   # Rebuild vhash indices for the Site. This method uses the Worker thread to rebuild and works on
   # chunks of 50 nodes.
@@ -517,45 +540,23 @@ class Site < ActiveRecord::Base
     true
   end
 
-  # Recreates the fullpath ('/zip/zip/zip').
-  # TODO: find a way to use SiteWorker (need to remove get_nodes): fix rake when this is done.
-  def rebuild_fullpath(parent_id = nil, parent_fullpath = "", parent_basepath = "", start=[])
-    raise Zena::InvalidRecord, "Infinit loop in 'ancestors' (#{start.inspect} --> #{parent_id})" if start.include?(parent_id)
-    start += [parent_id]
-    i = 0
-    batch_size = 100
-    children = []
-    while true
-      rec = Zena::Db.fetch_attributes(['id', 'fullpath', 'basepath', 'custom_base', 'zip'], 'nodes', "parent_id #{parent_id ? "= #{parent_id}" : "IS NULL"} AND site_id = #{self.id} ORDER BY id ASC LIMIT #{batch_size} OFFSET #{i * batch_size}")
-      break if rec.empty?
-      rec.each do |rec|
-        if parent_id
-          rec['fullpath'] = parent_fullpath == '' ? rec['zip'] : "#{parent_fullpath}/#{rec['zip']}"
-        else
-          # root node
-          rec['fullpath'] = ''
-        end
-
-        if rec['custom_base'] == Zena::Db::TRUE_RESULT
-          rec['basepath'] = rec['fullpath']
-        else
-          rec['basepath'] = parent_basepath
-        end
-
-        id = rec.delete('id')
-        children << [id, rec['fullpath'], rec['basepath'], start]
-        Zena::Db.execute "UPDATE nodes SET #{rec.map {|k,v| "#{Zena::Db.connection.quote_column_name(k)}=#{Zena::Db.quote(v)}"}.join(', ')} WHERE id = #{id}"
+  # Rebuild fullpath cache for the Site. This method uses the Worker thread to rebuild.
+  #
+  # The visitor used during index rebuild should be an admin user.
+  def rebuild_fullpath(nodes = nil, page = nil, page_count = nil)
+    if !page
+      Zena::SiteWorker.perform(self, :rebuild_fullpath)
+    else
+      if page == 1
+        Site.logger.error("\n----------------- REBUILD FULLPATH FOR SITE #{host} (#{Node.count(:conditions => {:site_id => id})} nodes)-----------------\n")
+        # Rebuild all paths at once (no pagination because of recursion)
+        Zena::Use::Ancestry.rebuild_all_paths(root_node)
       end
-      # 50 more
-      i += 1
-    end
-    children.each do |child|
-      rebuild_fullpath(*child)
     end
 
     true
   end
-
+  
   # Rebuild property indices for the Site. This method uses the Worker thread to rebuild and works on
   # chunks of 50 nodes.
   #
@@ -613,11 +614,16 @@ class Site < ActiveRecord::Base
       end
       
       if @home_zip_error
-        errors.add('root_id', @home_zip_error)
+        errors.add('root_zip', @home_zip_error)
         @home_zip_error = nil
       end
+      
+      if @skin_zip_error
+        errors.add('skin_zip', @skin_zip_error)
+        @skin_zip_error = nil
+      end
     end
 
 end
 
-Bricks.apply_patches
+Bricks.apply_patches

data/app/models/template.rb

@@ -95,7 +95,7 @@ class Template < TextDocument
         end
       end
 
-      if version.edited?
+      if prop.changes.keys != []
          self.mode = mode.gsub(/[^a-zA-Z\+]/, '') if mode
 
         if !target_klass.blank?

data/app/models/user.rb

@@ -29,6 +29,7 @@ class User < ActiveRecord::Base
   include Property
   RESCUE_SKIN_ID = -1
   ANY_SKIN_ID    = 0
+  ATTRIBUTES_FROM_PROFILE = [:group_ids, :status]
 
   property do |p|
     # nil ==> no dev mode
@@ -65,15 +66,16 @@ class User < ActiveRecord::Base
 
   safe_attribute          :login, :time_zone, :created_at, :updated_at, :lang, :id
   safe_method             :status => Number, :status_name => String,
-                          :is_anon? => Boolean, :is_admin? => Boolean, :user? => Boolean, :commentator? => Boolean,
+                          :is_anon? => Boolean, :is_admin? => Boolean, :is_manager? => Boolean, :user? => Boolean, :commentator? => Boolean,
                           :moderated? => Boolean, :asset_host? => Boolean, [:in_group?, String] => Boolean,
-                          :group_names => [String]
+                          :group_names => [String], [:group_id_to_name, Number] => String, :site => Site
 
   safe_context            :node => node_user_proc,
                           :to_publish => ['Version'], :redactions => ['Version'], :proposed => ['Version'],
                           :comments_to_publish => ['Comment']
 
-  attr_accessible         :login, :lang, :node, :time_zone, :status, :group_ids, :site_ids, :crypted_password, :password, :dev_skin_id, :node_attributes
+  attr_accessible         :login, :lang, :node, :time_zone, :status, :group_ids, :site_ids, :crypted_password, :password, :dev_skin_id, :node_attributes,
+                          :login_attempt_count, :is_profile, :profile
   attr_accessor           :visited_node_ids
   attr_accessor           :ip
 
@@ -92,14 +94,16 @@ class User < ActiveRecord::Base
   before_destroy          :dont_destroy_protected_users
   validates_presence_of   :site_id
   before_create           :create_node
+  after_save              :user_after_save
 
   Status = {
-    :su          => 80,
-    :admin       => 60,  # can create other users, manage site, etc
-    :user        => 50,  # can write articles + publish (depends on access rights)
-    :commentator => 40,  # can write comments
-    :moderated   => 30,  # can write comments (moderated)
-    :reader      => 20,  # can read
+    :su          => 80,  # Not used
+    :admin       => 60,  # Is in all groups, can access admin interface, etc
+    :manager     => 55,  # Can manage other users. Cannot edit groups.
+    :user        => 50,  # Can write articles + publish (depends on access rights)
+    :commentator => 40,  # Can write comments
+    :moderated   => 30,  # Can write comments (moderated)
+    :reader      => 20,  # Can read
     :deleted     => 0,
   }.freeze
   Num_to_status = Hash[*Status.map{|k,v| [v,k]}.flatten].freeze
@@ -210,6 +214,11 @@ class User < ActiveRecord::Base
   def is_admin?
     status.to_i >= User::Status[:admin]
   end
+  
+  # Has user administration rights
+  def is_manager?
+    status.to_i >= User::Status[:manager]
+  end
 
   # Return true if the user is the anonymous user for the current visited site
   def is_anon?
@@ -226,9 +235,20 @@ class User < ActiveRecord::Base
     end
   end
   
+  # Return the name of a group for a given id. If the visitor is not in the group,
+  # the method returns nil
+  def group_id_to_name(id)
+    (@group_ids_to_name ||= Hash[*all_groups.map{|g| [g.id, g.name]}.flatten])[id]
+  end
+  
   def in_group?(name)
     group_names.include?(name)
   end
+  
+  def reload_groups!
+    @group_ids  = nil
+    @all_groups = nil
+  end
 
   # Return true if the user's status is high enough to start editing nodes.
   def user?
@@ -269,19 +289,15 @@ class User < ActiveRecord::Base
   # Zena::Db.fetch_ids("SELECT id FROM groups WHERE site_id = #{current_site.id} ORDER BY name ASC")
   # Zena::Db.fetch_ids("SELECT group_id FROM groups_users WHERE user_id = #{id} ORDER BY name ASC", 'group_id')
   def group_ids
-    @group_ids ||= if is_admin?
-      site.groups.map(&:id)
-    else
-      groups.all(:order=>'name').map(&:id)
-    end
+    @group_ids ||= all_groups.map(&:id)
   end
-
-  # Return all groups (used in forms) managed by the user.
+  
+  # Return all groups in which the user belongs directly or indirectly (admin).
   def all_groups
-    if is_admin?
-      site.groups
+    @all_groups ||= if is_admin?
+      site.groups.all(:order => 'name')
     else
-      groups.all(:order=>'name').map(&:id)
+      groups.all(:order => 'name')
     end
   end
 
@@ -338,7 +354,7 @@ class User < ActiveRecord::Base
       nil
     when ANY_SKIN_ID
       # normal skin
-      node.skin || (node.parent ? node.parent.skin : nil)
+      current_site.skin || node.skin || (node.parent ? node.parent.skin : nil)
     else
       # find skin from zip
       secure(Skin) { Skin.find_by_zip(skin_zip)}
@@ -362,6 +378,31 @@ class User < ActiveRecord::Base
   def dev_mode?
     !dev_skin_id.blank?
   end
+  
+  def profile=(m)
+    if !visitor.is_manager?
+      # Make sure the user is a manager before changing profile
+      @profile_error = _('Cannot be changed')
+    elsif m.blank?
+      self[:profile_id] = nil
+    else
+      # Try to find profile user
+      if profile = secure(User) { User.find_by_login_and_is_profile(m.to_s, true) }
+        # Copy access definitions from profile to current user done during validation
+        self[:profile_id] = profile.id
+      else
+        @profile_error = _('Cannot be found')
+      end
+    end
+  end
+  
+  def profile_user
+    @profile_user ||= secure(User) { User.find(self[:profile_id]) }
+  end
+  
+  def profile
+    profile_user ? profile_user.login : ''
+  end
 
   private
 
@@ -372,6 +413,8 @@ class User < ActiveRecord::Base
     def create_node
       # do not try to create a node if the root node is not created yet
       return unless visitor.site.root_id
+      # This happens if the user is created from the node[user] params.
+      return if self[:node_id]
       @node.version.status = Zena::Status::Pub
 
       unless @node.save
@@ -391,7 +434,24 @@ class User < ActiveRecord::Base
       return true if current_site.being_created?
 
       self[:site_id] = visitor.site[:id]
-
+      
+      if self[:profile_id]
+        # Copy elements
+        profile = secure(User) { User.find(self[:profile_id] ) }
+        ATTRIBUTES_FROM_PROFILE.each do |k|
+          self.send(:"#{k}=", profile.send(k))
+        end
+        
+        # Ignore setting (to avoid loops)
+        if self[:is_profile]
+          self[:profile_id] = nil
+        end
+      elsif @defined_group_ids && !visitor.is_admin?
+        # Do not allow direct edition of groups by non-admin (even manager cannot do this).
+        @defined_group_ids = nil
+        @defined_group_ids_error = true
+      end
+      
       if new_record?
         self.status = site.anon.status if status.blank?
         self.lang   = site.anon.lang   if lang.blank?
@@ -400,7 +460,7 @@ class User < ActiveRecord::Base
       end
 
       if login.blank? && !is_anon?
-        self.login = name
+        self.login = self.node.title.strip
       end
       
       if !is_admin?
@@ -414,9 +474,25 @@ class User < ActiveRecord::Base
     def valid_user
       self[:site_id] = visitor.site[:id]
 
-      if !site.being_created? && !visitor.is_admin? && visitor[:id] != self[:id]
-        errors.add('base', 'You do not have the rights to do this.')
-        return false
+      if !site.being_created?
+        if !visitor.is_manager? && visitor[:id] != self[:id]
+          errors.add('base', 'You do not have the rights to do this.')
+          return false
+        elsif visitor.is_admin?
+          # All OK
+        elsif visitor.is_manager?
+          # Changing status of users above or equal to manager not allowed
+          if status_changed? && status >= User::Status[:manager]
+            errors.add('base', 'You cannot set this status (too high).')
+            return false
+          end
+          
+          # Editing users above or equal to manager not allowed
+          if status_was.to_i >= User::Status[:manager] && visitor.id != self.id
+            errors.add('base', 'You cannot edit this user (high status).')
+            return false
+          end
+        end
       end
 
       errors.add('lang', 'not available') unless site.lang_list.include?(lang)
@@ -434,7 +510,7 @@ class User < ActiveRecord::Base
           old = User.find(self[:id])
           self[:crypted_password] = old[:crypted_password] if self[:crypted_password].nil? || self[:crypted_password] == ""
           errors.add(:login, "can't be blank") if self[:login].blank?
-          errors.add(:status, 'You do not have the rights to do this.') if self[:id] == visitor[:id] && old.is_admin? && self.status.to_i != old.status
+          errors.add(:status, 'You cannot remove your own access rights.') if self[:id] == visitor[:id] && old.is_admin? && self.status.to_i != old.status
         end
       end
 
@@ -445,16 +521,34 @@ class User < ActiveRecord::Base
           errors.add(:time_zone, 'invalid')
         end
       end
-
+      
+      if self.is_profile_was && !self.is_profile
+        # Make sure there are no dependant users
+        if secure(User) { User.all(:conditions => {:profile_id => self.id}) }
+          errors.add('is_profile', _('Cannot be removed (profile used).'))
+        end
+      end
+      
+      if @profile_error
+        errors.add(:profile_id, @profile_error)
+        remove_instance_variable :@profile_error
+      end
+      
       if @password_too_short
-        errors.add(:password, 'too short')
+        errors.add(:password, _('Too short'))
         remove_instance_variable :@password_too_short
       end
+      
+      if @defined_group_ids_error
+        errors.add(:group_ids, _('Only admin can change groups.'))
+        remove_instance_variable :@defined_group_ids_error
+      end
     end
 
     def valid_node
       return unless visitor.site[:root_id] # do not validate node if the root node is not created yet
-      return if !new_record? && !@node
+
+      return if (!new_record? || self[:node_id]) && !@node
       if !@node
         # force creation of node, even if it is a plain copy of the prototype
         self.node_attributes = {'title' => login}
@@ -499,4 +593,16 @@ class User < ActiveRecord::Base
     def old
       @old ||= self.class.find(self[:id])
     end
+    
+    def user_after_save
+      @node.save if @node
+      return unless is_profile?
+      
+      if users = secure(User) { User.all(:conditions => {:profile_id => self.id}) }
+        users.each do |u|
+          u.save # this will trigger sync
+        end
+      end
+      true
+    end
 end