ninoxe 0.0.8

data/app/models/chouette/loader.rb

@@ -0,0 +1,110 @@
+class Chouette::Loader
+
+  attr_reader :schema, :database, :user, :password, :host
+
+  def initialize(schema)
+    @schema = schema
+
+    Chouette::ActiveRecord.connection_pool.spec.config.tap do |config|
+      @database = config[:database]
+      @user = config[:username]
+      @password = config[:password]
+      @host = (config[:host] or "localhost")
+    end
+  end
+
+  # Load dump where datas are in schema 'chouette'
+  def load_dump(file)
+    logger.info "Load #{file} in schema #{schema}"
+    with_pg_password do
+      execute!("sed -e 's/ chouette/ \"#{schema}\"/' -e 's/ OWNER TO .*;/ OWNER TO #{user};/' #{file} | psql #{pg_options} --set ON_ERROR_ROLLBACK=1 --set ON_ERROR_STOP=1")
+    end
+    self
+  end
+
+  def self.chouette_command=(command)
+    Chouette::Command.command = command
+  end
+
+  class << self
+    deprecate :chouette_command= => "Use Chouette::Command.command ="
+  end
+
+  def chouette_command
+    @chouette_command ||= Chouette::Command.new(:schema => schema)
+  end
+
+  def import(file, options = {})
+    options = {
+      :format => :neptune
+    }.merge(options)
+
+    command_options = {
+      :c => "import", 
+      :o => "line", 
+      :format => options.delete(:format).to_s.upcase, 
+      :input_file => File.expand_path(file), 
+      :optimize_memory => true
+    }.merge(options)
+
+    logger.info "Import #{file} in schema #{schema}"
+    chouette_command.run! command_options
+  end
+
+  def backup(file)
+    logger.info "Backup schema #{schema} in #{file}"
+
+    with_pg_password do
+      execute!("pg_dump -n #{schema} -f #{file} #{pg_options}")
+    end
+
+    self
+  end
+
+  def pg_options
+    [].tap do |options|
+      options << "-U #{user}" if user
+      options << "-h #{host}" if host
+      options << database
+    end.join(" ")
+  end
+
+  def create
+    logger.info "Create schema #{schema}"
+    with_pg_password do
+      execute!("psql -c 'CREATE SCHEMA \"#{schema}\";' #{pg_options}")
+    end
+    self
+  end
+
+  def drop
+    logger.info "Drop schema #{schema}"
+    with_pg_password do
+      execute!("psql -c 'DROP SCHEMA \"#{schema}\" CASCADE;' #{pg_options}")
+    end
+    self
+  end
+
+  def with_pg_password(&block)
+    ENV['PGPASSWORD'] = password.to_s if password
+    begin
+      yield
+    ensure
+      ENV['PGPASSWORD'] = nil
+    end
+  end
+
+  @@binarisation_command = "binarisation"
+  cattr_accessor :binarisation_command
+
+  def binarize(period, target_directory)
+    # TODO check these computed daybefore/dayafter
+    day_before = Date.today - period.begin
+    day_after = period.end - period.begin
+
+    execute! "#{binarisation_command} --host=#{host} --dbname=#{database} --user=#{user} --password=#{password} --schema=#{schema} --daybefore=#{day_before} --dayafter=#{day_after} --targetdirectory=#{target_directory}"
+  end
+
+  include Chouette::CommandLineSupport
+
+end

data/app/models/chouette/network.rb

@@ -0,0 +1,33 @@
+class Chouette::Network < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+  
+  has_many :lines
+
+  validates_presence_of :registration_number
+  validates_uniqueness_of :registration_number
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}
+
+  validates_presence_of :name
+
+  attr_accessible :objectid, :object_version, :creation_time, :creator_id, :version_date, :description, :name
+  attr_accessible :registration_number, :source_name, :source_type, :source_identifier, :comment
+
+  def self.object_id_key
+    "GroupOfLine"
+  end
+  
+  def self.nullable_attributes
+    [:source_name, :source_type, :source_identifier, :comment]
+  end
+  
+  def commercial_stop_areas
+    Chouette::StopArea.joins(:children => [:stop_points => [:route => [:line => :network] ] ]).where(:networks => {:id => self.id}).uniq
+  end
+
+  def stop_areas
+    Chouette::StopArea.joins(:stop_points => [:route => [:line => :network] ]).where(:networks => {:id => self.id})
+  end
+  
+end
+

data/app/models/chouette/object_id.rb

@@ -0,0 +1,36 @@
+class Chouette::ObjectId < String
+
+  def valid?
+    parts.present?
+  end
+  alias_method :objectid?, :valid?
+
+  @@format = /^([0-9A-Za-z_]+):([A-Za-z]+):([0-9A-Za-z_-]+)$/ 
+  cattr_reader :format
+
+  def parts
+    match(format).try(:captures)
+  end
+
+  def system_id
+    parts.try(:first)
+  end
+
+  def object_type
+    parts.try(:second)
+  end
+
+  def local_id
+    parts.try(:third)
+  end
+  
+  def self.create(system_id, object_type, local_id)
+    new [system_id, object_type, local_id].join(":")
+  end
+
+  def self.new(string)
+    string ||= ""
+    self === string ? string : super
+  end
+
+end

data/app/models/chouette/pt_link.rb

@@ -0,0 +1,39 @@
+require 'geokit'
+
+class Chouette::PtLink < Chouette::ActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  attr_accessible :start_of_link_id, :end_of_link_id, :route_id, :objectid, :object_version, :creation_time, :creator_id, :name, :comment, :link_distance
+  include Geokit::Mappable
+  
+
+  def geometry
+    the_geom
+  end
+
+  def self.import_csv
+    csv_file = Rails.root + "chouette_pt_links.csv"
+    if File.exists?( csv_file)
+      csv = CSV::Reader.parse(File.read(csv_file))
+
+      slug = csv.shift.first
+
+      Network::Base.find_by_slug( slug).tune_connection
+
+      csv.each do |row|
+        origin = Chouette::StopArea.find_by_objectid( row[0])
+        destination = Chouette::StopArea.find_by_objectid( row[1])
+
+        raise "unknown origin #{row[0]}" unless origin
+        raise "unknown destination #{row[1]}" unless destination
+
+        Chouette::PtLink.create( :departure_id => origin.id,
+                                 :arrival_id => destination.id,
+                                 :the_geom => GeoRuby::SimpleFeatures::Geometry.from_hex_ewkb( row[2]))
+      end
+    end
+    
+  end
+
+end

data/app/models/chouette/route.rb

@@ -0,0 +1,158 @@
+class Chouette::Route < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  attr_accessor :wayback_code
+  attr_accessor :direction_code
+
+  attr_accessible :direction_code, :wayback_code, :line_id, :objectid, :object_version, :creation_time, :creator_id, :name
+  attr_accessible :comment, :opposite_route_id, :published_name, :number, :direction, :wayback
+
+  def self.nullable_attributes
+    [:published_name, :comment, :number]
+  end
+
+  belongs_to :line
+
+  has_many :journey_patterns, :dependent => :destroy
+  has_many :vehicle_journeys, :dependent => :destroy do
+    def timeless
+      all( :conditions => ['vehicle_journeys.id NOT IN (?)', Chouette::VehicleJourneyAtStop.where( :stop_point_id => proxy_association.owner.journey_patterns.pluck( :departure_stop_point_id)).pluck(:vehicle_journey_id)] )
+    end
+  end
+  belongs_to :opposite_route, :class_name => 'Chouette::Route', :foreign_key => :opposite_route_id
+  has_many :stop_points, :order => 'position', :dependent => :destroy do
+    def find_by_stop_area(stop_area)
+      stop_area_ids = Integer === stop_area ? [stop_area] : (stop_area.children_in_depth + [stop_area]).map(&:id)
+      where( :stop_area_id => stop_area_ids).first or
+        raise ActiveRecord::RecordNotFound.new("Can't find a StopArea #{stop_area.inspect} in Route #{proxy_owner.id.inspect}'s StopPoints")
+    end
+
+    def between(departure, arrival)
+      between_positions = [departure, arrival].collect do |endpoint|
+        case endpoint
+        when Chouette::StopArea
+          find_by_stop_area(endpoint).position
+        when  Chouette::StopPoint
+          endpoint.position
+        when Integer
+          endpoint
+        else
+          raise ActiveRecord::RecordNotFound.new("Can't determine position in route #{proxy_owner.id} with #{departure.inspect}")
+        end        
+      end
+      where(" position between ? and ? ", between_positions.first, between_positions.last)
+    end
+  end
+  has_many :stop_areas, :through => :stop_points, :order => 'stop_points.position' do
+    def between(departure, arrival)
+      departure, arrival = [departure, arrival].collect do |endpoint|
+        String === endpoint ? Chouette::StopArea.find_by_objectid(endpoint) : endpoint
+      end
+      proxy_owner.stop_points.between(departure, arrival).includes(:stop_area).collect(&:stop_area)
+    end
+  end
+
+  validates_presence_of :name
+  validates_presence_of :line
+  validates_presence_of :direction_code
+  validates_presence_of :wayback_code
+  
+  before_destroy :dereference_opposite_route
+  
+  def dereference_opposite_route
+    self.line.routes.each do |r|
+      r.update_attributes( :opposite_route => nil) if r.opposite_route == self
+    end
+  end
+
+  def geometry
+    points = stop_areas.map(&:to_lat_lng).compact.map do |loc|
+      [loc.lng, loc.lat]
+    end
+    GeoRuby::SimpleFeatures::LineString.from_coordinates( points, 4326)
+  end
+
+  def time_tables
+    self.vehicle_journeys.joins(:time_tables).map(&:"time_tables").flatten.uniq
+  end
+
+  def sorted_vehicle_journeys
+    vehicle_journeys.includes( :vehicle_journey_at_stops, :journey_pattern).where( "vehicle_journey_at_stops.stop_point_id=journey_patterns.departure_stop_point_id").order( "vehicle_journey_at_stops.departure_time")
+  end
+
+  def self.direction_binding
+    { "A" => "straight_forward", 
+      "R" => "backward",
+      "ClockWise" => "clock_wise",
+      "CounterClockWise" => "counter_clock_wise",
+      "North" => "north",
+      "NorthWest" => "north_west", 
+      "West" => "west",
+      "SouthWest" => "south_west",
+      "South" => "south",
+      "SouthEast" => "south_east",
+      "East" => "east",
+      "NorthEast" => "north_east"}
+  end
+  def direction_code
+    return nil if self.class.direction_binding[direction].nil?
+    Chouette::Direction.new( self.class.direction_binding[direction])
+  end
+  def direction_code=(direction_code)
+    self.direction = nil
+    self.class.direction_binding.each do |k,v| 
+      self.direction = k if v==direction_code
+    end
+  end
+  @@directions = nil
+  def self.directions
+    @@directions ||= Chouette::Direction.all
+  end
+  def self.wayback_binding
+    { "A" => "straight_forward", "R" => "backward"}
+  end
+  def wayback_code
+    return nil if self.class.wayback_binding[wayback].nil?
+    Chouette::Wayback.new( self.class.wayback_binding[wayback])
+  end
+  def wayback_code=(wayback_code)
+    self.wayback = nil
+    self.class.wayback_binding.each do |k,v| 
+      self.wayback = k if v==wayback_code
+    end
+  end
+  @@waybacks = nil
+  def self.waybacks
+    @@waybacks ||= Chouette::Wayback.all
+  end
+  
+  def stop_point_permutation?( stop_point_ids)
+    stop_points.map(&:id).map(&:to_s).sort == stop_point_ids.map(&:to_s).sort
+  end
+
+  def reorder!( stop_point_ids)
+    return false unless stop_point_permutation?( stop_point_ids)
+    
+    stop_area_id_by_stop_point_id = {}
+    stop_points.each do |sp|
+      stop_area_id_by_stop_point_id.merge!( sp.id => sp.stop_area_id)
+    end
+
+    reordered_stop_area_ids = []
+    stop_point_ids.each do |stop_point_id|
+      reordered_stop_area_ids << stop_area_id_by_stop_point_id[ stop_point_id.to_i]
+    end
+
+    stop_points.each_with_index do |sp, index|
+      if sp.stop_area_id.to_s != reordered_stop_area_ids[ index].to_s
+        #result = sp.update_attributes( :stop_area_id => reordered_stop_area_ids[ index])
+        sp.stop_area_id = reordered_stop_area_ids[ index]
+        result = sp.save!
+      end
+    end
+
+    return true
+  end
+end
+

data/app/models/chouette/stop_area.rb

@@ -0,0 +1,273 @@
+require 'geokit'
+require 'geo_ruby'
+
+class Chouette::StopArea < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+  include Geokit::Mappable
+  has_many :stop_points, :dependent => :destroy
+  has_many :access_points, :dependent => :destroy
+  has_many :access_links, :dependent => :destroy
+  has_and_belongs_to_many :routing_lines, :class_name => 'Chouette::Line', :foreign_key => "stop_area_id", :association_foreign_key => "line_id", :join_table => "routing_constraints_lines", :order => "lines.number"
+  has_and_belongs_to_many :routing_stops, :class_name => 'Chouette::StopArea', :foreign_key => "parent_id", :association_foreign_key => "child_id", :join_table => "stop_areas_stop_areas", :order => "stop_areas.name"
+
+  acts_as_tree :foreign_key => 'parent_id',:order => "name"
+
+  attr_accessor :stop_area_type
+  attr_accessor :children_ids
+  
+  attr_accessible :routing_stop_ids, :routing_line_ids, :children_ids, :stop_area_type, :parent_id, :objectid
+  attr_accessible :object_version, :creation_time, :creator_id, :name, :comment, :area_type, :registration_number
+  attr_accessible :nearest_topic_name, :fare_code, :longitude, :latitude, :long_lat_type, :x, :y, :projection_type
+  attr_accessible :country_code, :street_name
+  
+  # workaround of ruby 1.8 private method y block attribute y reading access
+  def y
+    read_attribute :y
+  end
+
+  validates_uniqueness_of :registration_number, :allow_nil => true, :allow_blank => true
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}, :allow_blank => true
+  validates_presence_of :name
+  validates_presence_of :area_type
+
+  validates_presence_of :latitude, :if => :longitude
+  validates_presence_of :longitude, :if => :latitude
+  validates_numericality_of :latitude, :less_than_or_equal_to => 90, :greater_than_or_equal_to => -90, :allow_nil => true
+  validates_numericality_of :longitude, :less_than_or_equal_to => 180, :greater_than_or_equal_to => -180, :allow_nil => true
+
+  validates_presence_of :x, :if => :y
+  validates_presence_of :y, :if => :x
+  validates_numericality_of :x, :allow_nil => true
+  validates_numericality_of :y, :allow_nil => true
+
+  def self.nullable_attributes
+    [:registration_number, :street_name, :country_code, :fare_code, :nearest_topic_name, :comment, :projection_type, :long_lat_type]
+  end
+
+  after_update :clean_invalid_access_links
+
+  def children_in_depth
+    return [] if self.children.empty?
+
+    self.children + self.children.map do |child|
+      child.children_in_depth
+    end.flatten.compact
+  end
+
+  def possible_children
+    case area_type
+      when "BoardingPosition" then []
+      when "Quay" then []
+      when "CommercialStopPoint" then Chouette::StopArea.where(:area_type => ['Quay', 'BoardingPosition']) - [self]
+      when "StopPlace" then Chouette::StopArea.where(:area_type => ['StopPlace', 'CommercialStopPoint']) - [self]
+      when "ITL" then Chouette::StopArea.where(:area_type => ['Quay', 'BoardingPosition', 'StopPlace', 'CommercialStopPoint'])
+    end
+      
+  end
+
+  def possible_parents
+    case area_type
+      when "BoardingPosition" then Chouette::StopArea.where(:area_type => "CommercialStopPoint")  - [self]
+      when "Quay" then Chouette::StopArea.where(:area_type => "CommercialStopPoint") - [self]
+      when "CommercialStopPoint" then Chouette::StopArea.where(:area_type => "StopPlace") - [self]
+      when "StopPlace" then Chouette::StopArea.where(:area_type => "StopPlace") - [self]
+    end
+  end
+
+  def lines
+    if (area_type == 'CommercialStopPoint')
+      self.children.collect(&:stop_points).flatten.collect(&:route).flatten.collect(&:line).flatten.uniq
+    else
+      self.stop_points.collect(&:route).flatten.collect(&:line).flatten.uniq
+    end
+  end
+
+  def routes
+    self.stop_points.collect(&:route).flatten.uniq
+  end
+
+  def self.commercial
+    where :area_type => "CommercialStopPoint"
+  end
+
+  def to_lat_lng
+    Geokit::LatLng.new(latitude, longitude) if latitude and longitude
+  end
+
+  def geometry
+    GeoRuby::SimpleFeatures::Point.from_lon_lat(longitude, latitude, 4326) if latitude and longitude
+  end
+
+  def geometry=(geometry)
+    geometry = geometry.to_wgs84
+    self.latitude, self.longitude, self.long_lat_type = geometry.lat, geometry.lng, "WGS84"
+  end
+
+  def position 
+    geometry
+  end
+
+  def position=(position)
+    position = nil if String === position && position == ""
+    position = Geokit::LatLng.normalize(position), 4326 if String === position
+    self.latitude = position.lat
+    self.longitude = position.lng
+  end
+
+  def default_position 
+    # for first StopArea ... the bounds is nil :(
+    Chouette::StopArea.bounds and Chouette::StopArea.bounds.center
+  end
+
+  def self.near(origin, distance = 0.3)
+    origin = origin.to_lat_lng
+
+    lat_degree_units = units_per_latitude_degree(:kms)
+    lng_degree_units = units_per_longitude_degree(origin.lat, :kms)
+    
+    where "SQRT(POW(#{lat_degree_units}*(#{origin.lat}-latitude),2)+POW(#{lng_degree_units}*(#{origin.lng}-longitude),2)) <= #{distance}"
+  end
+
+  def self.bounds
+    # Give something like :
+    # [["113.5292500000000000", "22.1127580000000000", "113.5819330000000000", "22.2157050000000000"]]
+    min_and_max = connection.select_rows("select min(longitude) as min_lon, min(latitude) as min_lat, max(longitude) as max_lon, max(latitude) as max_lat from #{table_name} where latitude is not null and longitude is not null").first
+    return nil unless min_and_max
+
+    # Ignore [nil, nil, nil, nil]
+    min_and_max.compact!
+    return nil unless min_and_max.size == 4
+
+    min_and_max.collect! { |n| n.to_f }
+
+    # We need something like :
+    # [[113.5292500000000000, 22.1127580000000000], [113.5819330000000000, 22.2157050000000000]]
+    coordinates = min_and_max.each_slice(2).to_a
+    GeoRuby::SimpleFeatures::Envelope.from_coordinates coordinates
+  end
+
+  def stop_area_type
+    area_type && Chouette::AreaType.new(area_type.underscore)
+  end
+
+  def stop_area_type=(stop_area_type)   
+    self.area_type = (stop_area_type ? stop_area_type.camelcase : nil)
+    if self.area_type == 'Itl'
+      self.area_type = 'ITL'
+    end
+  end
+
+  @@stop_area_types = nil
+  def self.stop_area_types
+    @@stop_area_types ||= Chouette::AreaType.all.select do |stop_area_type|
+      stop_area_type.to_i >= 0
+    end
+  end
+
+  def children_ids=(children_ids)
+    children = children_ids.split(',').uniq
+    # remove unset children
+    self.children.each do |child|
+      if (! children.include? child.id)
+        child.update_attribute :parent_id, nil
+      end
+    end
+    # add new children
+    Chouette::StopArea.find(children).each do |child|
+       child.update_attribute :parent_id, self.id
+    end
+  end
+  
+  def routing_stop_ids=(routing_stop_ids)
+    stops = routing_stop_ids.split(',').uniq
+    self.routing_stops.clear
+    Chouette::StopArea.find(stops).each do |stop|
+      self.routing_stops << stop
+    end
+  end
+
+  def routing_line_ids=(routing_line_ids)
+    lines = routing_line_ids.split(',').uniq
+    self.routing_lines.clear
+    Chouette::Line.find(lines).each do |line|
+      self.routing_lines << line
+    end
+  end
+
+  def self.without_geometry
+    where("latitude is null or longitude is null")
+  end
+
+  def self.with_geometry
+    where("latitude is not null and longitude is not null")
+  end
+
+  def self.default_geometry!
+    count = 0
+    scoped.find_each do |stop_area|
+      Chouette::StopArea.unscoped do
+        count += 1 if stop_area.default_geometry!
+      end
+    end
+    count
+  end
+
+  def default_geometry!
+    new_geometry = default_geometry
+    update_attribute :geometry, new_geometry if new_geometry
+  end
+
+  def default_geometry
+    children_geometries = children.with_geometry.map(&:geometry).uniq
+    GeoRuby::SimpleFeatures::Point.centroid children_geometries if children_geometries.present?
+  end
+  
+  def generic_access_link_matrix
+     matrix = Array.new
+     access_points.each do |access_point|
+       matrix += access_point.generic_access_link_matrix
+     end
+     matrix
+  end
+
+  def detail_access_link_matrix
+     matrix = Array.new
+     access_points.each do |access_point|
+       matrix += access_point.detail_access_link_matrix
+     end
+     matrix
+  end
+  
+  def children_at_base
+    list = Array.new
+    children_in_depth.each do |child|
+      if child.area_type == 'Quay' || child.area_type == 'BoardingPosition'
+        list << child
+      end 
+    end
+    list
+  end
+  
+  def parents
+    list = Array.new
+    if !parent.nil?
+      list << parent
+      list += parent.parents
+    end
+    list
+  end
+  
+  def clean_invalid_access_links
+    stop_parents = parents
+    access_links.each do |link|
+      unless stop_parents.include? link.access_point.stop_area
+        link.delete
+      end
+    end
+    children.each do |child|
+      child.clean_invalid_access_links
+    end
+  end
+  
+end

data/app/models/chouette/stop_point.rb

@@ -0,0 +1,33 @@
+class Chouette::StopPoint < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  belongs_to :stop_area
+  belongs_to :route
+  acts_as_list :scope => 'route_id = \'#{route.id}\'',:top_of_list => 0
+
+  attr_accessible :route_id, :stop_area_id, :objectid, :object_version, :creation_time, :creator_id, :position
+
+  has_many :vehicle_journey_at_stops, :dependent => :destroy
+  has_many :vehicle_journeys, :through => :vehicle_journey_at_stops, :uniq => true
+  
+  before_destroy :remove_dependent_journey_pattern_stop_points
+  
+  validates_presence_of :stop_area
+  validates_presence_of :route
+  
+  scope :default_order, order("position")
+
+  def self.area_candidates
+    Chouette::StopArea.where( :area_type => ['Quay', 'BoardingPosition'])
+  end
+
+  def remove_dependent_journey_pattern_stop_points
+    route.journey_patterns.each do |jp|
+      if jp.stop_point_ids.include?( id)
+        jp.stop_point_ids = jp.stop_point_ids - [id]
+      end
+    end
+  end
+
+end