root/trunk/app/models/node.rb @ 114

require 'model_helper'
require 'node_link_association'
require 'anchor'
require 'nav_attribute'

class Node < AbstractModel
  include InheritanceCollector

  property :created_at, "Time"
  property :updated_at, "Time"
      
  has_many :links, :class_name => "NodeLink", :dependent => true, :order => "type, position"
  has_many :link_references, :class_name => "NodeLink", :foreign_key => "target_node_id", :dependent => true, :order => "type, position"

  attr_accessor :container
  
        after_update :refresh_cache
        after_create :refresh_cache
        after_save :refresh_cache
        after_destroy :refresh_cache
        
        @@find_cache = {}
                
  def Node.refresh_cache      
    @@find_cache = {}
  end
    
                def refresh_cache
                        Node.refresh_cache
                end
                
                class << self
                
                        def find_by_sql(sql, raw_records = false)                         
                                sql = sanitize_sql(sql)
                                sql_hash = MD5.hexdigest(sql + raw_records.to_s)
                                
                                unless @@find_cache[sql_hash].nil?
                                        return @@find_cache[sql_hash]
                                end
                                
                                records = connection.select(sql)
                                if raw_records then
                                        records = records
                                else 
                                        records = records.inject([]) { |objects, record| objects << instantiate(record) }
                                end
                                @@find_cache[sql_hash] = records
                                records
                        end
                
                end
        
        
        def self.reset_nav_classes_cache
    @@nav_classes = nil
    @@nav_attributes = nil
  end
    
  def nav_class
    @@nav_classes ||= {}
    if @@nav_classes.include?(self.class.name)
      return @@nav_classes[self.class.name]
    else
      return refresh_nav_class
    end
  end  

  def nav_attributes
    @@nav_attributes ||= {}
    if @@nav_attributes.include?(self.class.name)
      return @@nav_attributes[self.class.name]
    else
      return refresh_nav_attributes
    end
  end
            
  def refresh_nav_class
    nc = NavClass.find_first ["name = ?", self.class.name]
    @@nav_classes[self.class.name] = nc
  end    

  def refresh_nav_attributes
    na = attribute_collect(nav_class).inject({}) do |hash, attr|
      hash[attr.name] = attr
      hash
    end
    @@nav_attributes[self.class.name] = na
  end
  
  def after_save
    after_node_save
  end

  def after_node_save() end

  def after_destroy
    NodeLink.destroy_all ["node_id = ? OR target_node_id = ?", self.id, self.id]
    after_node_delete
  end

  def after_node_delete() end
  
  def label
    if nav_class.label_attribute?
      read_attribute(nav_class.label_attribute).to_s rescue id.to_s
    else
      id.to_s 
    end       
  end
    
  def nav_operations
    @nav_operations ||= read_nav_operations
  end
  
  def read_nav_operations
    ops = operation_collect(nav_class)
    ops = ops.inject({}) { |hash, op| hash[op.name] = op; hash }
  end

  def method_missing(method_id, *arguments)
    method_name = method_id.id2name
      
    if method_name =~ read_method?
      return read_attribute($1) if nav_attributes.include?($1)
      return read_link($1) if node_links.include?($1)
      return do_operation($1, *arguments) if nav_operations.include?($1)
      super
    elsif method_name =~ query_method?
      return query_attribute($1) if nav_attributes.include?($1)
      return query_link($1) if node_links.include?($1)
      super
    else
      super
    end
  end

  def do_operation(op_name, *arguments)
    op = nav_operations[op_name]
    code = op.code
    params = op.params if op.params && !op.params.empty?

    begin   
      buffer = <<-EOS
        def self.#{op_name}(context = nil, controller = nil #{params ? ',' + params : ''})
          #{code}
        end
      EOS
      instance_eval(buffer, op_name, 0)
      ret = send(op_name, *arguments)
    rescue => ex
      ln = -1
      buffer_with_ln = buffer.split("\n").map { |line| ln += 1; "#{ln}:#{line}" }.join("\n")
      err_buffer = "ERROR on trying operation #{op_name}...\nSOURCE CODE:\n#{buffer_with_ln}\nMESSAGE: #{ex.message}\nSTACK TRACE:\n#{ex.backtrace.join("\n")}"
      logger.info err_buffer
      $stdout.puts err_buffer     
      raise
    end
    ret
  end
  
  def node_links
    @node_links ||= load_links
  end

  def load_links
    node_links = {}
    for l in (nav_class.links_all)
      k = l.name.underscore
      node_links[k] = { :link => l, :nodes => nil }
    end
    node_links
  end 

  def read_link(name)
    return nil if node_links[name].nil?                     
    sql = %{ {link} sr:target_node_id {id}; rdf:type {?}; 
              sr:node_id {?}; [ sr:position {node_link_position} ] } 
    link = node_links[name][:link]                     
    nodes = node_links[name][:nodes]
    if nodes.nil?
      target_klass = Object.const_get(link.target_nav_class.name)
      nodes = target_klass.find_all nil, "node_link_position", 
                                    nil, [sql, link.name.to_uri, self.id] 
      nodes.extend(NodeLinkAssociation)
      nodes.parent_node = self
      nodes.link_type = link.name
      node_links[name][:nodes] = nodes
    end
    return nodes
  end

  def query_link(name)
    node_links.include?(name)
  end

  def query_attribute(name)
    not read_attribute(name).nil?
  end
  
  def read_attribute(attr_name)
    val = super(attr_name)
    if val.nil? 
      begin 
        attr_def = nav_attributes[attr_name]
        case attr_def
          when IndexNavAttribute
            val = Index.find(attr_def.index.id)
            params_values = instance_eval(attr_def.params) if attr_def.params?
            val.entries(params_values)
            val.container = self
          when ContextAnchorNavAttribute
            val = ContextAnchorValue.new(self, attr_def)
            val.container = self
          when IndexAnchorNavAttribute
            val = IndexAnchorValue.new(self, attr_def)
            val.container = self
          when ComputedNavAttribute
            val = instance_eval(attr_def.code) rescue nil       
          else
            val = nil
        end
      rescue => ex
        logger.error ex.inspect
        raise "Could not read '#{self.class.name}##{attr_name}' value for node '#{self.id}'\n#{ex}."
      end
    end
    val
  end
    
end