gfdnavi 1.3.0.0

data/app/models/node_entity_abstract.rb

@@ -0,0 +1,112 @@
+require "forwardable"
+
+class NodeEntityAbstract < ActiveRecord::Base
+  extend Forwardable
+
+  self.abstract_class = true
+
+  before_save :save_node
+  after_destroy :destroy_node
+
+  class << self
+    alias :_find :find
+    def find(*args)
+      nodes = Node.send("find_#{table_name}",*args)
+      case nodes
+      when Node
+        return nodes.entity
+      when Array
+        return nodes.collect{|n| n.entity}
+      else
+        return nodes
+      end
+    end
+  end
+
+  def initialize(attrs=nil)
+    super(nil)
+    self.attributes = attrs
+  end
+
+  def attributes=(attrs=nil)
+    attrs_node = Hash.new
+    attrs_org = attrs
+    if attrs
+      attrs = attrs.dup
+      Node.column_names.each{|cname|
+        if ( v=(attrs.delete(cname)||attrs.delete(cname.to_sym)) )
+          attrs_node[cname] = v
+        end
+      }
+    end
+    super(attrs)
+    if n = node
+      n.attributes= attrs_node
+    else
+      n = Node.new(attrs_node)
+    end
+    n.node_type = Node.const_get(self.class.table_name.singularize.upcase)
+    self.node = n
+    n.entity = self
+    return attrs_org
+  end
+
+  def node
+    return @node if @node
+    if node_id
+      @node = Node.find(node_id, :user => :all)
+      return @node
+    end
+    return nil
+  end
+
+  meths = %w(parent name path mtime owner other_mode rgroups wgroups size guest_owner file other_readable title description)
+  meths += meths.collect{|me| "#{me}="}
+  meths += %w(
+     keyword_attributes spatial_and_time_attributes
+     draw_parameters
+     references referenced_by
+     fname
+     set_rgroups set_wgroups
+     add_prefix
+  )
+  meths.each do |me|
+    def_delegator :node, me
+  end
+
+  protected
+  def save_node
+    if node.save
+      self.node_id = node.id
+      return true
+    else
+      node.errors.each{|k,v| errors.add(k,v) }
+      return false
+    end
+  end
+
+  def destroy_node
+    node.destroy
+  end
+
+=begin
+  def method_missing(method_id, *args)
+    begin
+      super(method_id, *args)
+    rescue NoMethodError
+      error = $!
+      begin
+        node.send(method_id, *args)
+      rescue NoMethodError
+        raise error
+      end
+    end
+  end
+=end
+
+  def node=(node)
+    @node = node
+  end
+
+
+end

data/app/models/node_lineage.rb

@@ -0,0 +1,6 @@
+class NodeLineage < ActiveRecord::Base
+   belongs_to :node_ancestor, :class_name => "Node", :foreign_key => "ancestor"
+   belongs_to :node_descendant, :class_name => "Node", :foreign_key => "descendant"
+#  belongs_to :ancestor, :class_name => "Node", :foreign_key => "ancestor"
+#  belongs_to :descendant, :class_name => "Node", :foreign_key => "descendant"
+end

data/app/models/node_relation.rb

@@ -0,0 +1,4 @@
+class NodeRelation < ActiveRecord::Base
+  belongs_to :reference, :class_name => "Node", :foreign_key => "reference"
+  belongs_to :referenced_by, :class_name => "Node", :foreign_key => "referenced_by"
+end

data/app/models/path_node.rb

@@ -0,0 +1,60 @@
+class PathNode
+  attr_accessor :path,:entries,:children,:count,:parent
+  def initialize
+    @path=""
+    @entries=Array.new
+    @parent=nil
+    @children=Hash.new
+    @count=0
+  end
+
+  def addpath_r(strary)
+    @count=@count+1
+    if strary.size==0 then
+      return self
+    else
+      cur = strary.shift()
+      if @children.key?(cur) then
+	@children[cur].addpath_r(strary)
+      else
+	newnode=PathNode.new
+        newnode.path=cur
+        @children[cur]=newnode
+	newnode.addpath_r(strary)
+      end
+    end
+  end
+
+  def find_child(str)
+    if @children then
+      @children.each{|c|
+        if c.path==str then
+          return c
+        end
+      }
+    end
+    return
+  end
+  
+  def addpath(n)
+    if @path=="/" then
+     strary=n.path.split(/\//)
+     strary.delete_at(0)
+     #entry=strary[strary.size-1]
+     strary.pop
+     node=addpath_r(strary)
+     node.entries.push(n)
+    end
+  end
+
+  
+end
+
+
+#root=PathNode.new
+#root.path="/"
+#addpath("/a0/b0/c0/d0",root)
+#addpath("/a0/b1/c0/d0",root)
+#addpath("/a0/b1/c0/d1",root)
+#addpath("/a1/b1/c0/d1",root)
+#root.printpath(0)

data/app/models/query.rb

@@ -0,0 +1,193 @@
+class Query 
+  attr_reader :spatial_region
+  attr_reader :start_lon, :start_lat
+  attr_reader :end_lon, :end_lat
+  attr_reader :time_region
+  attr_reader :starttime, :endtime
+  attr_reader :keywords
+  attr_reader :listmode
+  attr_reader :zoomlevel, :oldzoomlevel
+  attr_reader :center_x, :center_y
+  attr_reader :window_start_lon, :window_start_lat
+  attr_reader :window_end_lon, :window_end_lat
+
+
+  def initialize(params=Hash.new)
+    if params[:spatial_region] == "1"
+      @spatial_region = true
+      @start_lon = params[:start_lon].to_f
+      @start_lat = params[:start_lat].to_f
+      @end_lon = params[:end_lon].to_f
+      @end_lat = params[:end_lat].to_f
+      
+      @start_lon=360+@start_lon if @start_lon < 0 
+      @end_lon=360+@end_lon if @end_lon < 0 
+
+      @start_lon, @end_lon = [@end_lon, @start_lon] if @start_lon > @end_lon
+      @start_lat, @end_lat = [@end_lat, @start_lat] if @start_lat > @end_lat
+
+      @window_start_lon = params[:window_start_lon].to_f
+      @window_start_lat = params[:window_start_lat].to_f
+      @window_end_lon = params[:window_end_lon].to_f
+      @window_end_lat = params[:window_end_lat].to_f
+
+      @window_start_lon=360+@window_start_lon if @window_start_lon < 0
+      @window_end_lon=360+@window_end_lon if @window_end_lon < 0
+      
+      @window_start_lon, @window_end_lon = [0,360] if @window_start_lon > @window_end_lon
+      @window_start_lat, @window_end_lat = [-90,90] if @window_start_lat > @window_end_lat
+
+      
+      @window_start_lon = @start_lon if @window_start_lon<@start_lon
+      @window_start_lat = @start_lat if @window_start_lat<@start_lat
+      @window_end_lon = @end_lon if @window_end_lon>@end_lon
+      @window_end_lat = @end_lat if @window_end_lat>@end_lat
+      
+    end
+    if params[:time_region] == "1"
+      @starttime = Time.utc( params["starttime(1i)"], params["starttime(2i)"], params["starttime(3i)"], params["starttime(4i)"], params["starttime(5i)"] )
+      @endtime = Time.utc( params["endtime(1i)"], params["endtime(2i)"], params["endtime(3i)"], params["endtime(4i)"], params["endtime(5i)"] )
+      @time_region = true
+    end
+    
+    if params[:zoomlevel]!=nil then
+      @zoomlevel=params[:zoomlevel]
+    else
+      @zoomlevel=1
+    end
+    
+    if params[:oldzoomlevel]!=nil then
+      @oldzoomlevel=params[:oldzoomlevel]
+    else
+      @oldzoomlevel=1
+    end
+    
+    if params[:center_x]!=nil then
+      @center_x=params[:center_x]
+    else
+      @center_x=136.0
+    end
+    
+    if params[:center_y]!=nil then
+      @center_y=params[:center_y]
+    else
+      @center_y=37.0
+    end
+    
+    
+    @keywords = params[:keywords]
+    @keywords = nil if @keywords == ""
+  end
+
+  def querystring(area)
+    return nil unless keywords || spatial_region || time_region
+    #tables = ["variables v"]
+    tables = []
+    conditions = Array.new
+    sorts = Array.new
+    
+    sorts.push "n.path"
+
+    if keywords
+      kcond = Array.new
+      keywords.split(" ").each{|key|
+        if (v=key.to_i).to_s == key || (v=key.to_f).to_s == key
+          kcond.push KeywordAttribute.format_value_search(v, :like, "k")
+        else
+          kcond.push "k.name like '%#{key}%' or k.value like '%#{key}%' "
+        end
+        kcond.push "v.path like '%#{key}%'"
+      }
+      kcond = kcond.join(" or ")
+      path = Variable.connection.adapter_name=="MySQL" ? "concat(d.path,'%')" : "d.path||'%'"
+      subquery =<<-EOF
+        (select distinct v.*
+           from nodes d, nodes v, keyword_attributes k
+           where v.node_type=#{Node::VARIABLE} and d.node_type=#{Node::DIRECTORY} and
+                (   (v.id=k.node_id and (#{kcond}))
+                 or (v.path like #{path} and d.id=k.node_id and (#{kcond})))
+        ) as n
+      EOF
+      tables.push subquery
+    else 
+      tables.push "nodes n"
+    end
+
+    conditions.push "n.node_type=#{Node::VARIABLE}"
+
+    tables.push "spatial_and_time_attributes st"
+
+    if time_region
+      conditions.push "n.starttime<='#{endtime.strftime(format)}' and v.endtime>='#{starttime.strftime(format)}'"
+    end
+
+    format = "%Y-%m-%d %H:%M:%S"
+
+    if area == "no_region"
+      if spatial_region
+        return "select * from nodes where null"
+      end
+      area_condition = "not exists (select * from spatial_and_time_attributes as st where st.node_id=n.id and (st.longitude_lb||st.longitude_rt||st.latitude_lb||st.latitude_rt))"
+    else
+
+      conditions.push "st.node_id=n.id"
+      area_condition ="not(st.node_id IS NULL)";
+    end
+
+    if time_region
+      area_condition += "and (st.starttime<='#{endtime.strftime(format)}' and st.endtime>='#{starttime.strftime(format)}')"
+    end
+
+    lon_width = 360*0.9
+    lat_width = 180*0.9
+    case area
+    when "points"
+      area_condition += " and (st.longitude_lb = st.longitude_rt)"
+      area_condition += " and (st.latitude_lb = st.latitude_rt)"
+
+    when "partial"
+      area_condition += " and ((abs(st.longitude_lb-st.longitude_rt)<#{lon_width} and not(st.longitude_lb=0 and st.longitude_rt=0 ) and not(st.longitude_lb = st.longitude_rt and st.latitude_lb = st.latitude_rt))"
+      area_condition += " or (abs(st.latitude_lb-st.latitude_rt)<#{lat_width} and not(st.latitude_lb=0 and st.latitude_rt=0 ) and not(st.longitude_lb = st.longitude_rt and st.latitude_lb = st.latitude_rt ))) "
+
+    when "global"
+      area_condition += " and abs(st.longitude_lb-st.longitude_rt)>=#{lon_width}"
+      area_condition += " and abs(st.latitude_lb-st.latitude_rt)>=#{lat_width}"
+
+    end
+
+    if spatial_region
+      slon=start_lon; slat=start_lat;
+      elon=end_lon; elat=end_lat;
+      slon=window_start_lon if start_lon<window_start_lon
+      slat=window_start_lat if start_lon<window_start_lat
+      elon=window_end_lon if end_lon>window_end_lon
+      elat=window_end_lat if end_lon<window_end_lat
+
+      area_condition+=" and st.longitude_lb <= #{elon} and st.longitude_rt >= #{slon}"
+      area_condition+=" and st.latitude_lb <= #{elat} and st.latitude_rt >= #{slat}"
+      #      s="pow(s.longitude_lb+s.longitude_rt+(#{slon}*-1)+(#{elon}*-1),2)+"
+      #      s+="pow(s.latitude_lb+s.latitude_rt+(#{slat}*-1)+(#{elat}*-1),2)"
+      s="(st.longitude_lb+st.longitude_rt+(#{slon}*-1)+(#{elon}*-1))*(st.longitude_lb+st.longitude_rt+(#{slon}*-1)+(#{elon}*-1))+"
+      s+="(st.latitude_lb+st.latitude_rt+(#{slat}*-1)+(#{elat}*-1))*(st.latitude_lb+st.latitude_rt+(#{slat}*-1)+(#{elat}*-1))"
+      sorts.push s
+    end
+
+    conditions.push area_condition
+
+    
+    if Variable.connection.adapter_name == "PostgreSQL"
+      res = "select distinct on (n.path) n.* "
+    else
+      res = "select distinct n.* "
+    end
+    res += "from "
+    res += tables.join(", ")
+    res += " where "
+    res += conditions.join(" and ")
+    if sorts.size > 0
+      res += " order by "
+      res += sorts.join(",")
+    end
+    return res
+  end
+end

data/app/models/query_history.rb

@@ -0,0 +1,12 @@
+class QueryHistory < ActiveRecord::Base
+
+ def self.new_setid 
+   res = self.find_by_sql("select max(queryset_id)+1 as ans from query_histories");
+   if res.size>0 && res[0].ans then
+     return res[0].ans
+   else
+     return 1
+   end   
+ end
+
+end

data/app/models/results.rb

@@ -0,0 +1,48 @@
+require "activerecord_gfdnavi"
+
+class Results
+ attr_accessor :id, :keynames
+  def initialize(id)
+    @id=id
+    @keynames = Array.new
+  end
+ 
+  def get_keyname_list
+    if @id!=0 then
+      keylist=KeywordAttribute.find(:all,:select=>"keyword_attributes.name as kname,count(*) as cnt",:joins=>"JOIN cache_#{@id} ON variable_id=cache_#{@id}.vid",:group=>"keyword_attributes.name",:order=>"cnt DESC")
+    else
+      keylist=KeywordAttribute.find(:all,:select=>"keyword_attributes.name as kname,count(*) as cnt",:joins=>"JOIN variables ON variable_id=variables.id",:group=>"keyword_attributes.name",:order=>"cnt DESC")
+    end
+    return keylist
+  end
+ 
+ def get_path_list
+  if @id!=0 then
+    tables="(select v.* from variables v,cache_#{@id} c where v.id=c.vid)"
+    path=QueryHistory.find(@id).path
+  else
+    tables="variables"
+    path="/"
+  end
+      sql1=<<-EOM
+       select d2.path as dpath, count(v.id) as cnt
+       from directories d1,directories d2,#{tables} v
+       where d1.path = ?
+         and d2.parent_id = d1.id
+         and v.path like #{concat("d2.path","'%'")}
+       group by d2.path
+       order by cnt DESC
+     EOM
+     pathlist = Directory.find_by_sql [sql1,path]
+   return pathlist
+ end
+ 
+ def get_keyvalue_list(keyname)
+   if @id!=0 then
+    valuelist=KeywordAttribute.find(:all,:joins=>"JOIN cache_#{@id} ON variable_id=cache_#{@id}.vid",:select=>"value,num_value,count(*) as cnt",:conditions=>["keyword_attributes.name=?",keyname],:group=>"value")
+   else
+    valuelist=KeywordAttribute.find(:all,:joins=>"JOIN variables ON variable_id=variables.id",:select=>"value,num_value,count(*) as cnt",:conditions=>["keyword_attributes.name=?",keyname],:group=>"value")   
+   end
+   return valuelist   
+ end
+end

data/app/models/sign_up_user.rb

@@ -0,0 +1,25 @@
+class SignUpUser < ActiveRecord::Base
+
+
+  protected
+
+  before_create :crypt_password
+  def crypt_password
+    write_attribute("password", User.sha1(password))
+  end
+
+  def validate
+    if User.find(:first,:conditions=>["login=?",login])
+      errors.add(:login, "is already being used")
+    end
+  end
+
+  validates_length_of :login, :within => 3..10
+  validates_length_of :password, :within => 5..40
+  validates_presence_of :login, :password, :full_name, :email_address, :affiliation
+  validates_presence_of :password_confirmation, :on => :create
+  validates_confirmation_of :password, :on => :create
+  validates_uniqueness_of :login
+  validates_format_of :email_address, :with => /^(\w|-)+@(\w|-)+\.(\w|-)+/, :message => "email address is invalid"
+
+end