zena 0.15.0

data/app/models/note.rb

@@ -0,0 +1,58 @@
+=begin rdoc
+A note is a 'dated' element. It is typically used for blog entries or/and calendar events.
+
+=== dates
+
+On top of the Node's dates (+created_at+, +updated_at+, +publish_from+), a note uses the following:
+
+log_at::    used to sort/display blog entries
+event_at::  used in calendars
+
+These two dates enable you to announce an event in the blog list a couple of days before it actually occurs (event_at). All dates are stored internally as 'utc' and are converted to/from the visitor's current timezone.
+
+=== links
+
+Default links for Notes are:
+
+calendars::  make this note appear in the given calendar (there is one calendar per project). By default the note is not included in its project's calendar.
+projects::   make this note appear in the blog of the given project. A note always appear in its project.
+
+=== subclasses
+
+
+=== subclasses to implement before 1.0
+Task::       manage things to be done (parent = Note = Todo). The parent provides the 'due date'.
+Letter::     like the name says...
+Request::    subclass of Todo. Manage user/client requests.
+Bug::        (the class we most need!). subclass of Request.
+Milestone::  special event used when choosing a Request/Bug's parent.
+=end
+class Note < Node
+
+  before_validation :prepare_note
+  class << self
+
+    def select_classes
+      list = subclasses.inject([]) do |list, k|
+        next if k.to_s == 'Post'
+        list << k.to_s
+        list
+      end.sort
+      list.unshift 'Post'
+    end
+  end
+
+  def export_keys
+    h = super
+    h[:dates].merge!('log_at' => log_at, 'event_at' => event_at)
+    h
+  end
+
+  private
+
+  def prepare_note
+    self[:log_at]   ||= self[:event_at] || Time.now
+    self[:event_at] ||= self[:log_at]
+    self.name = version.title unless self[:name]
+  end
+end

data/app/models/page.rb

@@ -0,0 +1,53 @@
+=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 skin name must be unique throughout the site as it is used to identify the 'theme' of the site or parts of the site.
+=end
+class Page < Node
+  before_validation :update_base_path #, :if => 'custom_base.changed?'
+
+  # url base path. If a node is in 'projects' and projects has custom_base set, the
+  # node's basepath becomes 'projects', so the url will be 'projects/node34.html'.
+  # The basepath is cached. If rebuild is set to true, the cache is updated.
+  def basepath(rebuild=false, update = true)
+    if !self[:basepath] || rebuild
+      if self[:custom_base]
+        self.basepath = fullpath(rebuild, update)
+        # FIXME: REMOVE this UPDATE !
+        self.connection.execute "UPDATE #{self.class.table_name} SET basepath=#{Node.connection.quote(self.basepath)} WHERE id='#{self[:id]}'" if !new_record? && update && self.basepath_changed?
+      else
+        super
+      end
+    end
+    self[:basepath]
+  end
+
+  private
+    def update_base_path
+      self[:basepath] = self.basepath(true)
+    end
+
+    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
+      Node.send(:with_exclusive_scope) do
+        if new_record?
+          cond = ["name = ? AND parent_id = ? AND kpath LIKE 'NP%'",              self[:name], self[:parent_id]]
+        else
+          cond = ["name = ? AND parent_id = ? AND kpath LIKE 'NP%' AND id != ? ", self[:name], self[:parent_id], self[:id]]
+        end
+        test_same_name = Node.find(:all, :conditions=>cond)
+      end
+      errors.add("name", "has already been taken") unless test_same_name == []
+    end
+
+end

data/app/models/project.rb

@@ -0,0 +1,10 @@
+=begin rdoc
+
+Beware that the project is not in it's own project. The project's project_id is the same as it's parent. This should not confuse you too much as finding the root node for a project is not as interesting as finding the projects in a project.
+=end
+class Project < Page
+
+  def get_project_id
+    self[:id]
+  end
+end

data/app/models/reference.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+A reference represents some information that the site mirrors. It is not displayed in the page hierarchy nor in some date related view (calendar,blog) but is usually found by doing a search or by its links. For example you could create a Tag called 'clients' and link every contact that is a client to this tag. Going to this tag you would have the list of clients.
+
+A reference can only be created in a Section. It can be linked from anywhere.
+
+=== subclasses
+
+Contact:: every User has a unique contact page to store address, name, phone, etc.
+Book::    used to add a bibliography and/or by the 'Reading' class (not implemented yet).
+
+=== links
+
+Default links for Reference are:
+
+reference_for::  nodes for which the current item is a reference.
+=end
+class Reference < Node
+end

data/app/models/relation.rb

@@ -0,0 +1,18 @@
+class Relation < ActiveRecord::Base
+  validate        :valid_relation
+  attr_accessor   :side, :link_errors, :start, :link
+  attr_protected  :site_id
+  has_many        :links, :dependent => :destroy
+
+  # FIXME: validate uniqueness of source_role and target_role in scope site_id
+  # FIXME: set kpath from class
+
+  private
+    def valid_relation
+      unless visitor.is_admin?
+        errors.add('base', 'You do not have the rights to do this.')
+        return false
+      end
+      self[:site_id] = current_site[:id]
+    end
+end

data/app/models/relation_proxy.rb

@@ -0,0 +1,379 @@
+class RelationProxy < Relation
+  attr_accessor   :side, :link_errors, :start, :other_link, :last_target
+  LINK_ATTRIBUTES = Zena::Use::Relations::LINK_ATTRIBUTES
+  LINK_ATTRIBUTES_SQL = LINK_ATTRIBUTES.map {|sym| "`#{sym}`"}.join(',')
+  LINK_SELECT     = "nodes.*,links.id AS link_id,#{LINK_ATTRIBUTES.map {|l| "links.#{l} AS l_#{l}"}.join(',')}"
+
+  class << self
+
+    # Open a relation to a role. start => 'role'
+    def find_by_role(role)
+      rel = find(:first, :conditions => ["(source_role = ? OR target_role = ?) AND site_id = ?", role, role, current_site[:id]])
+      return nil unless rel
+      if rel.target_role == role
+        rel.side = :source
+      else
+        rel.side = :target
+      end
+      rel
+    end
+
+    # Find a relation proxy for a role through a given node.
+    # The finder makes sure the class path is compatible with the node's class/virtual_class given as parameter.
+    def get_proxy(node, role)
+      rel = find_by_role(role)
+      if rel && (node.new_record? || node.vclass.kpath =~ /\A#{rel.this_kpath}/)
+        rel.start = node
+        rel
+      else
+        # invalid relation for the given class path
+        nil
+      end
+    end
+  end
+
+  # Used by relation_links
+  def records(options={})
+    return @records if defined? @records
+    opts = { :select     => LINK_SELECT,
+             :joins      => "INNER JOIN links ON nodes.id=links.#{other_side} AND links.relation_id = #{self[:id]} AND links.#{link_side} = #{@start[:id]}",
+             :group      => 'nodes.id'}
+
+    [:order, :limit, :conditions].each do |sym|
+      opts[sym] = options[sym] if options[sym]
+    end
+
+    @records = secure(Node) { Node.find(:all, opts) }
+  end
+
+  # I do not think this method is used anymore (all is done by @node.find(...)).
+  def record(options={})
+    return @record if defined?(@record) || @start.new_record?
+    opts = { :select     => LINK_SELECT,
+             :joins      => "INNER JOIN links ON nodes.id=links.#{other_side} AND links.relation_id = #{self[:id]} AND links.#{link_side} = #{@start[:id]}",
+             :group      => 'nodes.id'}
+
+    # limit overwritten options to 'order', 'limit' in case this method is used with unsafe parameters from the web.
+    [:order].each do |sym|
+      opts[sym] = options[sym] if options[sym]
+    end
+
+    @record = secure(Node) { Node.find(:first, opts) }
+  end
+
+  # Define the caller's side. Changes the relation into a proxy so we can add/remove links. This sets the caller on the source side of the relation.
+  def source=(start)
+    @start = start
+    @side  = :source
+  end
+
+  # Define the caller's side. Changes the relation into a proxy so we can add/remove links. This sets the caller on the target side of the relation.
+  def target=(start)
+    @start = start
+    @side  = :target
+  end
+
+  # When a ...-to-many node is loaded and we modify it, focus on this specific node. For example:
+  # calendar_status does not make sense (there can be many calendars). But if we focus on a specific
+  # calendar, we then get the status for this particular link.
+  def other_link=(link)
+    return unless link[:relation_id] == self[:id]
+    @other_link = link
+  end
+
+  # get
+
+  def other_link
+    other_links ? other_links[0] : nil
+  end
+
+  def other_id
+    other_link ? other_link[other_side] : nil
+  end
+
+  def other_zip
+    record ? record[:zip] : nil
+  end
+
+  def other_ids
+    (other_links || []).map { |l| l[other_side] }
+  end
+
+  def other_zips
+    (records || []).map { |r| r[:zip] }
+  end
+
+  LINK_ATTRIBUTES.each do |sym|
+    define_method(sym) do
+      other_link ? other_link[sym] : nil
+    end
+  end
+
+  def other_role
+    @side == :source ? target_role : source_role
+  end
+
+  def this_role
+    @side == :source ? source_role : target_role
+  end
+
+  def other_icon
+    @side == :source ? target_icon : source_icon
+  end
+
+  # set
+  def other_id=(v)
+    if !v.kind_of?(Array) && v.to_i < 0
+      # removing a link
+      # TODO: support Array
+      if link = other_links.select { |l| l[other_side] == -v }.first
+        remove_link(link)
+      else
+        # ignore
+      end
+    else
+      attributes_to_update[:id] = v.kind_of?(Array) ? v.uniq.compact.map {|v| v.to_i} : (v.blank? ? nil : v.to_i)
+    end
+  end
+
+  def other_ids=(v)
+    self.other_id = v
+  end
+
+  def remove_link(link)
+    @links_to_delete ||= []
+    @links_to_delete << link
+  end
+
+  LINK_ATTRIBUTES.each do |sym|
+    define_method("other_#{sym}=") do |v|
+      attributes_to_update[sym] = v.blank? ? nil : v
+    end
+  end
+
+  def this_kpath
+    @side == :source ? source_kpath : target_kpath
+  end
+
+  def other_kpath
+    @side == :source ? target_kpath : source_kpath
+  end
+
+  # find the links from the current context (source or target)
+  def other_links
+    @other_links ||= Link.find(:all, :conditions => ["relation_id = ? AND #{link_side} = ?", self[:id], @start[:id]])
+  end
+
+  # link can be changed if user can write in old and new
+  # 1. can remove old link
+  # 2. can write in new target
+  def attributes_to_update_valid?
+    return true unless @attributes_to_update || @links_to_delete
+
+    @link_errors  = []
+    @add_links    = []
+    @del_links    = []
+    @update_links = []
+
+    if @links_to_delete
+      # only removing links
+      @del_links = @links_to_delete
+      @attributes_to_update = {}
+    else
+
+      # check if we have an update/create
+      unless @attributes_to_update.has_key?(:id)
+        # try to find current id/ids
+        if @other_link
+          @attributes_to_update[:id] = @other_link[other_side]
+        elsif link_id = @start.link_id
+          @other_link = Link.find(link_id)
+          @attributes_to_update[:id] = @other_link[other_side]
+        elsif unique?
+          if other_id
+            @attributes_to_update[:id] = other_id
+          elsif @attributes_to_update.keys == [:id]
+            # ignore (set icon_id = nil when already == nil)
+          else
+            @link_errors << "invalid target"
+          end
+        else
+          # error: cannot set other attributes (status/comment) on multiple nodes
+          @link_errors << "invalid target"
+        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}'."
+        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."
+        end
+      end
+
+      return false if @link_errors != []
+
+      # 1. find what changed
+      if @attributes_to_update[:id].kind_of?(Array)
+        # ..-to-many
+        # define all links
+
+        # list of link ids set
+        add_link_ids = @attributes_to_update[:id]
+
+        # find all current links
+        # TODO: this could be optimzed (avoid loading all links...)
+        other_links.each do |link|
+          obj_id = link[other_side]
+          if add_link_ids.include?(obj_id) && (@attributes_to_update[:date].nil? || @attributes_to_update[:date] == link[:date])
+            # ignore existing link
+            add_link_ids.delete(obj_id)
+          else
+            # remove unused links / link to replace
+            @del_links << link
+          end
+        end
+        @add_links = add_link_ids.map {|obj_id| Hash[:id,obj_id] }
+      elsif unique?
+        # ..-to-one
+        # define/update link
+        if other_id == @attributes_to_update[:id]
+          # same target: update
+          @update_links << changed_link(other_link, @attributes_to_update)
+        else
+          # other target: replace
+          @del_links = [other_link] if other_link
+          @add_links << @attributes_to_update unless @attributes_to_update[:id].blank?
+        end
+      else
+        # ..-to-many
+        # add/update a link
+        # TODO: optimize to avoid loading all links...
+        if @attributes_to_update[:id].blank? && @attributes_to_update[:date]
+          # delete
+          @del_links = other_links.select {|l| @attributes_to_update[:date] == l[:date]}
+        else
+          links = other_links.select {|l| l[other_side] == @attributes_to_update[:id] && (@attributes_to_update[:date].nil? || @attributes_to_update[:date] == l[:date])}
+          if links != []
+            # update
+            if (@attributes_to_update.keys & LINK_ATTRIBUTES) != []
+              links.each do |link|
+                if link[other_side] == @attributes_to_update[:id]
+                  @update_links << changed_link(link, @attributes_to_update)
+                end
+              end
+            end
+          else
+            # add
+            @add_links << @attributes_to_update
+          end
+        end
+      end
+    end
+
+    # 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])
+        # 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]])
+            @del_links << previous_link
+          end
+        end
+      else
+        @link_errors << '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'
+      end
+    end
+
+    @update_links.compact!
+    return @link_errors == []
+  end
+
+  # Return updated link if changed or nil when nothing changed
+  def changed_link(link, attrs)
+    changed = false
+    LINK_ATTRIBUTES.each do |sym|
+      next unless attrs.has_key?(sym)
+      if attrs[sym] != link[sym]
+        changed = true
+        link[sym] = attrs[sym]
+      end
+    end
+    changed ? link : nil
+  end
+
+  def update_links!
+    return unless @attributes_to_update
+    @del_links.each    { |l| l.destroy }
+    @update_links.each { |l| l.save }
+
+    return if @add_links == []
+
+    list = []
+    @add_links.each do |hash|
+      next if hash[:id].blank?
+      list << "(#{self[:id]},#{@start[:id]},#{hash[:id]},#{LINK_ATTRIBUTES.map{|sym| Link.connection.quote(hash[sym])}.join(',')})"
+    end
+    Link.connection.execute "INSERT INTO links (`relation_id`,`#{link_side}`,`#{other_side}`,#{LINK_ATTRIBUTES_SQL}) VALUES #{list.join(',')}"
+    @attributes_to_update = nil
+    @links_to_delete      = nil
+    remove_instance_variable(:@records)     if defined?(@records)
+    remove_instance_variable(:@record)      if defined?(@record)
+    remove_instance_variable(:@other_links) if defined?(@other_links)
+  end
+
+  def unique?
+    @side == :source ? target_unique : source_unique
+  end
+
+  def as_unique?
+    @side == :source ? source_unique : target_unique
+  end
+
+  # def source_unique
+  #   self[:source_unique] ? true : false
+  # end
+  #
+  # def target_unique
+  #   self[:target_unique] ? true : false
+  # end
+
+  def link_side
+    @side == :source ? 'source_id' : 'target_id'
+  end
+
+  def other_side
+    @side == :source ? 'target_id' : 'source_id'
+  end
+
+  private
+    def relation_class
+      @start.relation_base_class
+    end
+
+    def find_node(obj_id, unique)
+      unique ? secure_drive(Node) { Node.find_by_id(obj_id) } : secure_write(Node) { Node.find_by_id(obj_id) }
+    end
+
+    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}%"]) }
+      else
+        secure_write(relation_class) { relation_class.find(:first, :conditions=>['id = ? AND kpath LIKE ?', obj_id, "#{other_kpath}%"]) }
+      end
+    end
+
+    def attributes_to_update
+      @attributes_to_update ||= {}
+    end
+end