zena 1.0.0.beta3 → 1.0.0.rc1

data/app/models/page.rb

@@ -1,35 +1,5 @@
 =begin rdoc
-=== subclasses
-
-Section::   used to group pages together with a same 'section_id'
-Tag::       used to create collections of items.
-Document::  contains data from uploaded files.
-Image::     subclass of Document, contains image data that can be resized/viewed in the browser.
-TextDocument::  subclass of Document, used by documents that can be edited online (scripts, text).
-Template::  subclass of TextDocument. Contains the zafu code to make the look and feel of the site.
-Skin::      subclass of Template. Contains other templates.
+The Page class is just used to group Section and Project in a common ancestor.
 =end
 class Page < Node
-
-  private
-
-    def validate_node
-      super
-
-      # we are in a scope, we cannot just use the normal validates_...
-      # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-      test_same_name = nil
-      if node_name_changed? || parent_id_changed? || kpath_changed?
-        Node.send(:with_exclusive_scope) do
-          if new_record?
-            cond = ["node_name = ? AND parent_id = ? AND kpath LIKE 'NP%'",              self[:node_name], self[:parent_id]]
-          else
-            cond = ["node_name = ? AND parent_id = ? AND kpath LIKE 'NP%' AND id != ? ", self[:node_name], self[:parent_id], self[:id]]
-          end
-          test_same_name = Node.find(:all, :conditions => cond)
-        end
-        errors.add("node_name", "has already been taken") unless test_same_name == []
-      end
-    end
-
 end

data/app/models/relation.rb

@@ -31,25 +31,25 @@ class Relation < ActiveRecord::Base
       end
 
       if self[:source_role].blank?
-        if klass = Node.get_class_from_kpath(source_kpath)
+        if klass = VirtualClass.find_by_kpath(source_kpath)
           self.source_role = klass.to_s.underscore
         else
           klass = nil
         end
       else
-        klass = Node.get_class_from_kpath(source_kpath)
+        klass = VirtualClass.find_by_kpath(source_kpath)
       end
 
       errors.add(:source_kpath, 'invalid (could not find class)') unless klass
 
       if self[:target_role].blank?
-        if klass = Node.get_class_from_kpath(target_kpath)
+        if klass = VirtualClass.find_by_kpath(target_kpath)
           self.target_role = klass.to_s.underscore
         else
           klass = nil
         end
       else
-        klass = Node.get_class_from_kpath(target_kpath)
+        klass = VirtualClass.find_by_kpath(target_kpath)
       end
 
       errors.add(:target_kpath, 'invalid (could not find class)') unless klass

data/app/models/relation_proxy.rb

@@ -1,5 +1,9 @@
 class RelationProxy < Relation
-  attr_accessor   :side, :link_errors, :start, :other_link, :last_target
+  include RubyLess
+
+  safe_method :name => {:class => String, :method => 'other_role'}
+
+  attr_accessor   :side, :link_errors, :start, :other_link, :last_target, :add_links
   LINK_ATTRIBUTES = Zena::Use::Relations::LINK_ATTRIBUTES
   LINK_ATTRIBUTES_SQL = LINK_ATTRIBUTES.map {|sym| connection.quote_column_name(sym)}.join(',')
   LINK_SELECT     = "nodes.*,links.id AS link_id,#{LINK_ATTRIBUTES.map {|l| "links.#{l} AS l_#{l}"}.join(',')}"
@@ -33,7 +37,7 @@ class RelationProxy < Relation
     def get_proxy(node, role)
       # TODO: use find_by_role(role, node.kpath) when all tests are clear
       rel = find_by_role(role)
-      if rel && (node.new_record? || node.vclass.kpath =~ /\A#{rel.this_kpath}/)
+      if rel && (node.new_record? || node.kpath =~ /\A#{rel.this_kpath}/)
         rel.start = node
         rel
       else
@@ -82,11 +86,13 @@ class RelationProxy < Relation
   end
 
   def other_zips
+    return nil unless @start[:id]
     return @other_zips if defined?(@other_zips)
     @other_zips = @records ? @records.map { |r| r.zip} : Zena::Db.fetch_ids("SELECT zip FROM nodes INNER JOIN links ON nodes.id=links.#{other_side} AND links.relation_id = #{self[:id]} AND links.#{link_side} = #{@start[:id]} WHERE #{secure_scope('nodes')} GROUP BY nodes.zip", 'zip')
   end
 
   def records(opts = {})
+    return nil unless @start[:id]
     return @records if defined?(@records)
     options = {
       :select => "nodes.*, #{LINK_SELECT}",
@@ -114,12 +120,30 @@ class RelationProxy < Relation
   end
 
   # Get class of other element (used by QueryNode to properly set resulting class).
-  def other_klass
-    Node.get_class_from_kpath(@side == :source ? self[:target_kpath] : self[:source_kpath])
+  def other_vclass
+    VirtualClass.find_by_kpath(@side == :source ? self[:target_kpath] : self[:source_kpath])
+  end
+
+  # set from query builder
+  def qb=(qb)
+    if qb.blank?
+      self.other_id = []
+    else
+      query = @start.class.build_query(:all, qb,
+        :node_name       => '@start',
+        :main_class      => @start.virtual_class,
+        :rubyless_helper => @start.virtual_class,
+        :default         => {:order => 'id asc'}
+      )
+      self.other_id = secure(Node) {Node.find_by_sql(eval(query.to_s))} || []
+    end
+  rescue ::QueryBuilder::Error => err
+    attributes_to_update[:errors] = {'base' => err.message}
   end
 
   # set
   def other_id=(v)
+    attributes_to_update[:errors] = {}
     if !v.kind_of?(Array) && v.to_i < 0
       # removing a link
       # TODO: support Array
@@ -128,8 +152,62 @@ class RelationProxy < Relation
       else
         # ignore
       end
+    elsif v.kind_of?(Array)
+      if v.first.kind_of?(Node)
+        node_by_id = attributes_to_update[:nodes] = {}
+        v.each do |r|
+          node_by_id[r.id.to_i] = r
+        end
+        attributes_to_update[:id] = v.map{|r| r.id.to_i}
+      else
+        attributes_to_update[:id] = v.map(&:to_i)
+      end
+    else
+      attributes_to_update[:id] = v.blank? ? nil : v.to_i
+    end
+  end
+
+  # set
+  def other_zip=(zip_values)
+    # Translate ids and then set
+    errors    = attributes_to_update[:errors]    = {}
+    id_to_zip = attributes_to_update[:id_to_zip] = {}
+
+    if zip_values.kind_of?(Array)
+      attributes_to_update[:id] = []
+      zip_values.each do |zip|
+        if id = secure(Node) { Node.translate_pseudo_id(zip,  :id, @start) }
+          # ok
+          id_to_zip[id] = zip
+          attributes_to_update[:id] << id
+        else
+          # error
+          errors[zip] = _('could not be found')
+        end
+      end
+    elsif zip_values.blank?
+      # remove all
+      attributes_to_update[:id] = nil
     else
-      attributes_to_update[:id] = v.kind_of?(Array) ? v.uniq.compact.map {|v| v.to_i} : (v.blank? ? nil : v.to_i)
+      if id = secure(Node) { Node.translate_pseudo_id(zip_values, :id, @start) }
+        if id < 0
+          # removing a link
+          # TODO: support Array
+          if link = other_links.select { |l| l[other_side] == -id }.first
+            remove_link(link)
+          else
+            # ignore
+          end
+        else
+          id_to_zip[id] = zip_values
+          attributes_to_update[:id] = id
+        end
+      else
+        # error
+        # do not try to add
+        attributes_to_update[:id] = :ignore
+        errors[zip_values] = _('could not be found')
+      end
     end
   end
 
@@ -137,6 +215,10 @@ class RelationProxy < Relation
     self.other_id = v
   end
 
+  def other_zips=(v)
+    self.other_zip = v
+  end
+
   def remove_link(link)
     @links_to_delete ||= []
     @links_to_delete << link
@@ -167,7 +249,7 @@ class RelationProxy < Relation
   def attributes_to_update_valid?
     return true unless @attributes_to_update || @links_to_delete
 
-    @link_errors  = []
+    @link_errors  = {}
     @add_links    = []
     @del_links    = []
     @update_links = []
@@ -179,7 +261,7 @@ class RelationProxy < Relation
     else
 
       # check if we have an update/create
-      unless @attributes_to_update.has_key?(:id)
+      unless @attributes_to_update.has_key?(:id) # set during other_id=
         # try to find current id/ids
         if @other_link
           @attributes_to_update[:id] = @other_link[other_side]
@@ -192,25 +274,28 @@ class RelationProxy < Relation
           elsif @attributes_to_update.keys == [:id]
             # ignore (set icon_id = nil when already == nil)
           else
-            @link_errors << "invalid target"
+            @link_errors['update'] = _('missing target')
           end
         else
           # error: cannot set other attributes (status/comment) on multiple nodes
-          @link_errors << "invalid target"
+          @link_errors['update'] = _('cannot update multiple targets')
         end
       end
 
       if @attributes_to_update[:id].kind_of?(Array)
         if unique?
-          @link_errors << "Cannot set multiple targets on #{as_unique? ? 'one' : 'many'}-to-one relation '#{this_role}'."
+          # TODO: translate
+          @link_errors['arity'] = "Cannot set multiple targets on #{as_unique? ? 'one' : 'many'}-to-one relation '#{this_role}'."
         elsif (@attributes_to_update.keys & LINK_ATTRIBUTES) != []
           keys = @attributes_to_update.keys
           keys.delete(:id)
-          @link_errors << "Cannot set attributes #{keys.join(', ')} on multiple targets."
+          # TODO: translate
+          @link_errors['arity'] = "Cannot set attributes #{keys.join(', ')} on multiple targets."
         end
       end
 
-      return false if @link_errors != []
+      return false if @link_errors != {}
+      @link_errors = @attributes_to_update[:errors] || {}
 
       # 1. find what changed
       if @attributes_to_update[:id].kind_of?(Array)
@@ -262,6 +347,8 @@ class RelationProxy < Relation
                 end
               end
             end
+          elsif @attributes_to_update[:id] == :ignore
+            # bad id set, just used for error reporting
           else
             # add
             @add_links << @attributes_to_update
@@ -270,10 +357,14 @@ class RelationProxy < Relation
       end
     end
 
+    id_to_zip = attributes_to_update[:id_to_zip] || {}
+
     # 2. can write in new target ? (and remove targets previous link)
     @add_links.each do |hash|
       # last_target is used by "linked_node" from Node to get hold of the last linked node
       if @last_target = find_target(hash[:id])
+        # store remote node so that we can use in index rebuild (scope_index)
+        hash[:node] = @last_target
         # make sure we can overwrite previous link if as_unique
         if as_unique?
           if previous_link = Link.find(:first, :conditions => ["relation_id = ? AND #{other_side} = ?", self[:id], @last_target[:id]])
@@ -281,19 +372,35 @@ class RelationProxy < Relation
           end
         end
       else
-        @link_errors << 'invalid target'
+        if zip = id_to_zip[hash[:id]]
+          key = zip
+        elsif node = secure(Node) { Node.find_by_id(hash[:id]) }
+          key = node.zip
+        else
+          key = 'id'
+        end
+
+        @link_errors[key] = _('invalid target')
       end
     end
 
     # 1. can remove old link ?
     @del_links.each do |link|
       unless find_node(link[other_side], unique?)
-        @link_errors << 'cannot remove link'
+        if zip = id_to_zip[link[other_side]]
+          key = zip
+        elsif node = secure(Node) { Node.find_by_id(hash[:id]) }
+          key = node.zip
+        else
+          key = 'id'
+        end
+
+        @link_errors[key] = _('cannot remove link')
       end
     end
 
     @update_links.compact!
-    return @link_errors == []
+    return @link_errors == {}
   end
 
   # Return updated link if changed or nil when nothing changed
@@ -364,12 +471,16 @@ class RelationProxy < Relation
 
     def find_target(obj_id)
       if as_unique?
-        secure_drive(relation_class) { relation_class.find(:first, :conditions=>['id = ? AND kpath LIKE ?', obj_id, "#{other_kpath}%"]) }
+        cache[obj_id] ||= secure_drive(relation_class) { relation_class.find(:first, :conditions=>['id = ? AND kpath LIKE ?', obj_id, "#{other_kpath}%"]) }
       else
-        secure_write(relation_class) { relation_class.find(:first, :conditions=>['id = ? AND kpath LIKE ?', obj_id, "#{other_kpath}%"]) }
+        cache[obj_id] ||= secure_write(relation_class) { relation_class.find(:first, :conditions=>['id = ? AND kpath LIKE ?', obj_id, "#{other_kpath}%"]) }
       end
     end
 
+    def cache
+      @cache ||= attributes_to_update[:nodes] || {}
+    end
+
     def attributes_to_update
       @attributes_to_update ||= {}
     end

data/app/models/role.rb

@@ -1,22 +1,38 @@
 require 'property/stored_role'
 
 class Role < ActiveRecord::Base
+  # We define 'klass' in the Role used by the real classes so that property methods can be
+  # defined.
+  attr_accessor :klass
+
+  # Only store partial class name in 'type' field (not ::Role)
+  self.store_full_sti_class = false
+
   include Property::StoredRole
   has_many :stored_columns, :class_name => 'Column', :dependent => :destroy
   has_and_belongs_to_many :nodes
 
   before_validation :set_defaults
   validate :check_can_save
+  attr_accessible :name, :superclass, :icon
+
+  after_save :expire_vclass_cache
+  after_destroy :expire_vclass_cache
 
   include RubyLess
-  safe_method :columns => {:class => ['Column'], :method => 'columns.values', :nil => false}
+  # Columns defined in the role.
+  safe_method :columns     => {:class => ['Column'], :method => 'defined_safe_columns'}
+
   safe_method :name => String
 
+  # We use property to store index information, default values and such
+  include Property
+
   def superclass
     if new_record?
       Node
     else
-      Node.get_class_from_kpath(kpath)
+      VirtualClass.find_by_kpath(kpath)
     end
   end
 
@@ -28,13 +44,22 @@ class Role < ActiveRecord::Base
     end
   end
 
+  # By default, all defined columns are safe (see )
+  def defined_safe_columns
+    @safe_column ||= defined_columns.values.sort {|a,b| a.name <=> b.name}
+  end
 
   private
     def set_defaults
+      self[:type] = self.class.to_s
       self.site_id = visitor.site.id
     end
 
     def check_can_save
       errors.add('base', 'You do not have the rights to change roles.') unless visitor.is_admin?
     end
+
+    def expire_vclass_cache
+      VirtualClass.expire_cache!
+    end
 end

data/app/models/site.rb

@@ -7,7 +7,6 @@ The #Site model holds configuration information for a site:
 
 +host+::            Unique host name. (teti.ch, zenadmin.org, dev.example.org, ...)
 +root_id+::         Site root node id. This is the only node in the site without a parent.
-+su_id+::           Super User id. This user has extended priviledges on the site. It should only be used in case of emergency.
 +anon_id+::         Anonymous user id. This user is the 'public' user of the site. Even if +authorize+ is set to true, this user is needed to configure the defaults for all newly created users.
 +public_group_id+:: Id of the 'public' group. Every user of the site (with 'anonymous user') belongs to this group.
 +site_group_id+::   Id of the 'site' group. Every user except anonymous are part of this group. This group can be seen as the 'logged in users' group.
@@ -69,24 +68,22 @@ class Site < ActiveRecord::Base
       # =========== CREATE zip counter ==========================
       connection.execute "INSERT INTO zips (site_id, zip) VALUES (#{site[:id]},0)"
 
-      # =========== CREATE Super User ===========================
-      # create su user
-      su = User.new_no_defaults( :login => host, :password => su_password,
-        :first_name => "Super", :name => "User", :lang => site.default_lang, :status => User::Status[:su])
-      su.site = site
+      # =========== CREATE Admin User ===========================
 
-      Thread.current[:visitor] = su
+      # create admin user
+      admin_user = User.new_no_defaults( :login => 'admin',           :password => su_password,
+                                         :lang  => site.default_lang, :status => User::Status[:admin])
+      admin_user.site = site
+
+      Thread.current[:visitor] = admin_user
 
-      unless su.save
+      unless admin_user.save
         # rollback
         Site.connection.execute "DELETE FROM #{Site.table_name} WHERE id = #{site.id}"
         Site.connection.execute "DELETE FROM zips WHERE site_id = #{site.id}"
-        raise Exception.new("Could not create super user for site [#{host}] (site#{site[:id]})\n#{su.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}")
+        raise Exception.new("Could not create admin user for site [#{host}] (site#{site[:id]})\n#{admin_user.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}")
       end
 
-      site[:su_id] = su[:id]
-
-
       # =========== CREATE PUBLIC, ADMIN, SITE GROUPS ===========
       # create public group
       pub = site.send(:secure,Group) { Group.create(:name => 'public') }
@@ -96,6 +93,9 @@ class Site < ActiveRecord::Base
       admin = site.send(:secure,Group) { Group.create( :name => 'admin') }
       raise Exception.new("Could not create admin group for site [#{host}] (site#{site[:id]})\n#{admin.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") if admin.new_record?
 
+      # add admin to the 'admin group'
+      admin.users << admin_user
+
       # create site group
       sgroup = site.send(:secure,Group) { Group.create( :name => 'site') }
       raise Exception.new("Could not create site group for site [#{host}] (site#{site[:id]})\n#{sgroup.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") if sgroup.new_record?
@@ -104,39 +104,27 @@ class Site < ActiveRecord::Base
       site.site_group_id   = sgroup[:id]
       site.groups << pub << sgroup << admin
 
-      # =========== CREATE Anonymous, admin =====================
+      # Reload group_ids in admin
+      admin_user.instance_variable_set(:@group_ids, nil)
+
+      # =========== CREATE Anonymous User =====================
       # create anon user
-      # FIXME: make sure user_id = admin user
 
-      anon = site.send(:secure, User) {User.new_no_defaults( :login => nil, :password => nil,
-        :first_name => "Anonymous", :name => "User", :lang => site.default_lang, :status => User::Status[:moderated])}
+      anon = site.send(:secure, User) do
+        User.new_no_defaults( :login => nil, :password => nil,
+        :lang => site.default_lang, :status => User::Status[:moderated])
+      end
 
       anon.site = site
       raise Exception.new("Could not create anonymous user for site [#{host}] (site#{site[:id]})\n#{anon.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") unless anon.save
       site[:anon_id] = anon[:id]
 
-      # create admin user
-      admin_user = site.send(:secure,User) { User.new_no_defaults( :login => 'admin', :password => su_password,
-        :first_name => "Admin", :name => "User", :lang => site.default_lang, :status => User::Status[:admin]) }
-      admin_user.site = site
-      raise Exception.new("Could not create admin user for site [#{host}] (site#{site[:id]})\n#{admin_user.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") unless admin_user.save
-      class << admin_user
-        # until participation is created
-        def status; User::Status[:admin]; end
-        def lang; site.default_lang; end
-      end
-      # add admin to the 'admin group'
-      admin.users << admin_user
-
       # =========== CREATE ROOT NODE ============================
-      # reload admin so all groups are set
-
-      #admin_user = site.send(:secure, User) { User.find(admin_user[:id]) }
 
-      # make admin the current visitor
-      Thread.current[:visitor] = admin_user
+      root = site.send(:secure,Project) do
+        Project.create( :title => site.name, :rgroup_id => pub[:id], :wgroup_id => sgroup[:id], :dgroup_id => admin[:id], :title => site.name, :v_status => Zena::Status[:pub])
+      end
 
-      root = site.send(:secure,Project) { Project.create( :node_name => site.name, :rgroup_id => pub[:id], :wgroup_id => sgroup[:id], :dgroup_id => admin[:id], :title => site.name, :v_status => Zena::Status[:pub]) }
       raise Exception.new("Could not create root node for site [#{host}] (site#{site[:id]})\n#{root.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") if root.new_record?
 
       Node.connection.execute "UPDATE nodes SET section_id = id, project_id = id WHERE id = '#{root[:id]}'"
@@ -150,16 +138,17 @@ class Site < ActiveRecord::Base
       raise Exception.new("Could not save site definition for site [#{host}] (site#{site[:id]})\n#{site.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") unless site.save
 
       # =========== CREATE CONTACT PAGES ==============
-      [su, admin_user, anon].each do |user|
-        user.send(:create_contact)
+      {admin_user => 'Admin User', anon => 'Anonymous User'}.each do |user, title|
+        # forces @node creation
+        user.node_attributes = {'title' => title, 'parent_id' => root[:id] }
+        user.send(:create_node)
         user.save
       end
 
       # =========== LOAD INITIAL DATA (default skin) =============
 
-      nodes = site.send(:secure,Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'db', 'init', 'base'), :parent_id => root[:id], :defaults => { :v_status => Zena::Status[:pub], :rgroup_id => pub[:id], :wgroup_id => sgroup[:id], :dgroup_id => admin[:id] } ) }.values
-
-      # == set skin name to 'default' for all elements in the site == #
+      nodes = site.send(:secure, Node) { Node.create_nodes_from_folder(:folder => File.join(Zena::ROOT, 'db', 'init', 'base'), :parent_id => root[:id], :defaults => { :v_status => Zena::Status[:pub], :rgroup_id => pub[:id], :wgroup_id => sgroup[:id], :dgroup_id => admin[:id] } ) }.values
+      # == set skin id to 'default' for all elements in the site == #
       skin = nodes.detect {|n| n.kind_of?(Skin) }
       Node.connection.execute "UPDATE nodes SET skin_id = '#{skin.id}' WHERE site_id = '#{site[:id]}'"
 
@@ -184,6 +173,10 @@ class Site < ActiveRecord::Base
     end
   end
 
+  property.string 'usr_prototype_attributes'
+
+  Site.attributes_for_form[:text] << 'usr_prototype_attributes'
+
   # Return path for static/cached content served by proxy: RAILS_ROOT/sites/_host_/public
   # If you need to serve from another directory, we do not store the path into the sites table
   # for security reasons. The easiest way around this limitation is to symlink the 'public' directory.
@@ -208,12 +201,6 @@ class Site < ActiveRecord::Base
     @anon ||= User.find_by_id_and_site_id(self[:anon_id], self.id)
   end
 
-  # Return the super user. This user has extended priviledges on the data (has access to private other's data).
-  # This is an emergency user.
-  def su
-    @su ||= User.find_by_id_and_site_id(self[:su_id], self.id)
-  end
-
   # TODO: test
   def root_node
     secure(Node) { Node.find(self[:root_id]) }
@@ -221,17 +208,17 @@ class Site < ActiveRecord::Base
 
   # Return the public group: the one in which every visitor belongs.
   def public_group
-    @public_group ||= Group.find(self[:public_group_id])
+    @public_group ||= secure(Group) { Group.find(self[:public_group_id]) }
   end
 
   # Return the site group: the one in which every visitor except 'anonymous' belongs (= all logged in users).
   def site_group
-    @site_group ||= Group.find(self[:site_group_id])
+    @site_group ||= secure(Group) { Group.find(self[:site_group_id]) }
   end
 
   # Return the API group: the one in which API visitors must be to use the API.
   def api_group
-    @api_group ||= Group.find_by_id(self[:api_group_id])
+    @api_group ||= secure(Group) { Group.find_by_id(self[:api_group_id]) }
   end
 
   # Return true if the given user is an administrator for this site.
@@ -241,7 +228,7 @@ class Site < ActiveRecord::Base
 
   # Return the ids of the administrators of the current site.
   def admin_user_ids
-    # TODO: admin_user_ids could be cached in the 'site' record.
+    # TODO: PERFORMANCE admin_user_ids could be cached in the 'site' record.
     @admin_user_ids ||= secure!(User) { User.find(:all, :conditions => "status >= #{User::Status[:admin]}") }.map {|r| r[:id]}
   end
 
@@ -277,7 +264,7 @@ class Site < ActiveRecord::Base
 
   # ids of the users that cannot be removed
   def protected_user_ids
-    [anon_id, su_id]
+    [anon_id, visitor.id] # cannot remove self
   end
 
   # Return an array with the languages for the site.
@@ -304,6 +291,24 @@ class Site < ActiveRecord::Base
     end
   end
 
+  def iformats_updated!
+    Site.connection.execute "UPDATE sites SET formats_updated_at = (SELECT updated_at FROM iformats WHERE site_id = #{self[:id]} ORDER BY iformats.updated_at DESC LIMIT 1) WHERE id = #{self[:id]}"
+    if $iformats
+      $iformats[self[:id]] = @iformats = nil
+    end
+  end
+  
+  def virtual_classes
+   @iformats ||= begin
+     $iformats ||= {} # mem cache
+     site_formats = $iformats[self[:id]]
+     if !site_formats || self[:formats_updated_at] != site_formats[:updated_at]
+       site_formats = $iformats[self[:id]] = Iformat.formats_for_site(self[:id]) # reload
+     end
+     site_formats
+    end
+  end
+
   def iformats_updated!
     Site.connection.execute "UPDATE sites SET formats_updated_at = (SELECT updated_at FROM iformats WHERE site_id = #{self[:id]} ORDER BY iformats.updated_at DESC LIMIT 1) WHERE id = #{self[:id]}"
     if $iformats
@@ -353,17 +358,20 @@ class Site < ActiveRecord::Base
     true
   end
 
-  # TODO: replace fullpath defined from names by '/zip/zip/zip'
-  def rebuild_fullpath(parent_id = nil, parent_fullpath = "", parent_basepath = "")
+  # Recreates the fullpath ('/zip/zip/zip').
+  # TODO: find a way to use SiteWorker (need to remove get_nodes)
+  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', 'node_name'], '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}")
+      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['node_name'] : "#{parent_fullpath}/#{rec['node_name']}"
+          rec['fullpath'] = parent_fullpath == '' ? rec['zip'] : "#{parent_fullpath}/#{rec['zip']}"
         else
           # root node
           rec['fullpath'] = ''
@@ -376,7 +384,7 @@ class Site < ActiveRecord::Base
         end
 
         id = rec.delete('id')
-        children << [id, rec['fullpath'], rec['basepath']]
+        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}"
       end
       # 50 more