Merge model from ninoxe gem

48 files changed, 3179 insertions, 0 deletions

diff --git a/app/models/chouette/access_link.rb b/app/models/chouette/access_link.rb
new file mode 100644
index 000000000..b43dcfb7f
--- /dev/null
+++ b/app/models/chouette/access_link.rb
@@ -0,0 +1,65 @@
+module Chouette
+  class AccessLink < TridentActiveRecord
+    # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+    self.primary_key = "id"
+
+    attr_accessor :access_link_type, :link_orientation_type, :link_key
+
+    belongs_to :access_point, :class_name => 'Chouette::AccessPoint'
+    belongs_to :stop_area, :class_name => 'Chouette::StopArea'
+
+    validates_presence_of :name
+    validates_presence_of :link_orientation
+
+    def self.nullable_attributes
+      [:link_distance, :default_duration, :frequent_traveller_duration, :occasional_traveller_duration,
+        :mobility_restricted_traveller_duration, :link_type]
+    end
+
+    def access_link_type
+      link_type && Chouette::ConnectionLinkType.new(link_type.underscore)
+    end
+
+    def access_link_type=(access_link_type)
+      self.link_type = (access_link_type ? access_link_type.camelcase : nil)
+    end
+
+    @@access_link_types = nil
+    def self.access_link_types
+      @@access_link_types ||= Chouette::ConnectionLinkType.all
+    end
+
+    def link_orientation_type
+      link_orientation && Chouette::LinkOrientationType.new(link_orientation.underscore)
+    end
+
+    def link_orientation_type=(link_orientation_type)
+      self.link_orientation = (link_orientation_type ? link_orientation_type.camelcase : nil)
+    end
+
+    @@link_orientation_types = nil
+    def self.link_orientation_types
+      @@link_orientation_types ||= Chouette::LinkOrientationType.all
+    end
+
+    def geometry
+      GeoRuby::SimpleFeatures::LineString.from_points( [ access_point.geometry, stop_area.geometry], 4326) if access_point.geometry and stop_area.geometry
+    end
+
+    def link_key
+      Chouette::AccessLink.build_link_key(access_point,stop_area,link_orientation_type)
+    end
+    
+    def self.build_link_key(access_point,stop_area,link_orientation_type)
+      if link_orientation_type == "access_point_to_stop_area"
+        "A_#{access_point.id}-S_#{stop_area.id}"
+      else  
+        "S_#{stop_area.id}-A_#{access_point.id}"
+      end
+    end
+
+    def geometry_presenter
+      Chouette::Geometry::AccessLinkPresenter.new self
+    end
+  end
+end
diff --git a/app/models/chouette/access_point.rb b/app/models/chouette/access_point.rb
new file mode 100644
index 000000000..43c8e1b3a
--- /dev/null
+++ b/app/models/chouette/access_point.rb
@@ -0,0 +1,162 @@
+require 'geokit'
+require 'geo_ruby'
+
+class Chouette::AccessPoint < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+  include Geokit::Mappable
+  has_many :access_links, :dependent => :destroy
+  belongs_to :stop_area
+  
+  attr_accessor :access_point_type
+  attr_writer :coordinates
+  
+  validates_presence_of :name
+  validates_presence_of :access_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_format_of :coordinates, :with => %r{\A *-?(0?[0-9](\.[0-9]*)?|[0-8][0-9](\.[0-9]*)?|90(\.[0]*)?) *\, *-?(0?[0-9]?[0-9](\.[0-9]*)?|1[0-7][0-9](\.[0-9]*)?|180(\.[0]*)?) *\Z}, :allow_nil => true, :allow_blank => true
+
+  def self.nullable_attributes
+    [:street_name, :country_code, :comment, :long_lat_type, :zip_code, :city_name]
+  end
+
+  before_save :coordinates_to_lat_lng
+
+  def combine_lat_lng
+    if self.latitude.nil? || self.longitude.nil?
+      ""
+    else
+      self.latitude.to_s+","+self.longitude.to_s 
+    end
+  end
+  
+  def coordinates
+      @coordinates || combine_lat_lng
+  end
+  
+  def coordinates_to_lat_lng
+    if ! @coordinates.nil?
+      if @coordinates.empty?
+        self.latitude = nil
+        self.longitude = nil
+      else
+        self.latitude = BigDecimal.new(@coordinates.split(",").first)
+        self.longitude = BigDecimal.new(@coordinates.split(",").last)
+      end
+      @coordinates = nil 
+    end
+  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 
+    stop_area.geometry or stop_area.default_position
+  end
+
+
+  def access_point_type
+    access_type && Chouette::AccessPointType.new(access_type.underscore)
+  end
+
+  def access_point_type=(access_point_type)   
+    self.access_type = (access_point_type ? access_point_type.camelcase : nil)
+  end
+
+  @@access_point_types = nil
+  def self.access_point_types
+    @@access_point_types ||= Chouette::AccessPointType.all.select do |access_point_type|
+      access_point_type.to_i >= 0
+    end
+  end
+
+  def generic_access_link_matrix
+     matrix = Array.new
+     hash = Hash.new
+     access_links.each do |link|
+        hash[link.link_key] = link
+     end
+     key=Chouette::AccessLink.build_link_key(self,stop_area,"access_point_to_stop_area")
+     if hash.has_key?(key)
+       matrix << hash[key]
+     else
+       link = Chouette::AccessLink.new
+       link.access_point = self
+       link.stop_area = stop_area
+       link.link_orientation_type = "access_point_to_stop_area"
+       matrix << link
+     end
+     key=Chouette::AccessLink.build_link_key(self,stop_area,"stop_area_to_access_point")
+     if hash.has_key?(key)
+       matrix << hash[key]
+     else
+       link = Chouette::AccessLink.new
+       link.access_point = self
+       link.stop_area = stop_area
+       link.link_orientation_type = "stop_area_to_access_point"
+       matrix << link
+     end
+     matrix
+  end
+
+  def detail_access_link_matrix
+     matrix = Array.new
+     hash = Hash.new
+     access_links.each do |link|
+        hash[link.link_key] = link
+     end
+     stop_area.children_at_base.each do |child|
+       key=Chouette::AccessLink.build_link_key(self,child,"access_point_to_stop_area")
+       if hash.has_key?(key)
+         matrix << hash[key]
+       else
+         link = Chouette::AccessLink.new
+         link.access_point = self
+         link.stop_area = child
+         link.link_orientation_type = "access_point_to_stop_area"
+         matrix << link
+       end
+       key=Chouette::AccessLink.build_link_key(self,child,"stop_area_to_access_point")
+       if hash.has_key?(key)
+         matrix << hash[key]
+       else
+         link = Chouette::AccessLink.new
+         link.access_point = self
+         link.stop_area = child
+         link.link_orientation_type = "stop_area_to_access_point"
+         matrix << link
+       end
+     end
+     matrix
+  end
+
+  def geometry_presenter
+    Chouette::Geometry::AccessPointPresenter.new self
+  end
+end
diff --git a/app/models/chouette/access_point_type.rb b/app/models/chouette/access_point_type.rb
new file mode 100644
index 000000000..94d28e5ae
--- /dev/null
+++ b/app/models/chouette/access_point_type.rb
@@ -0,0 +1,50 @@
+class Chouette::AccessPointType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["in", 0],
+    ["out", 1],
+    ["in_out", 2]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
diff --git a/app/models/chouette/active_record.rb b/app/models/chouette/active_record.rb
new file mode 100644
index 000000000..59052075e
--- /dev/null
+++ b/app/models/chouette/active_record.rb
@@ -0,0 +1,66 @@
+#require "active_record"
+require 'deep_cloneable'
+module Chouette
+  class ActiveRecord < ::ActiveRecord::Base
+
+    self.abstract_class = true
+
+    before_save :nil_if_blank
+
+    # to be overrided to set nullable attrs when empty
+    def self.nullable_attributes
+      []
+    end
+
+    def nil_if_blank
+      self.class.nullable_attributes.each { |attr| self[attr] = nil if self[attr].blank? }
+    end
+
+
+    def human_attribute_name(*args)
+      self.class.human_attribute_name(*args)
+    end
+
+    # class << self
+    #   alias_method :create_reflection_without_chouette_naming, :create_reflection
+
+    #   def create_reflection(macro, name, options, active_record)
+    #     options = 
+    #       Reflection.new(macro, name, options, active_record).options_with_default
+
+    #     create_reflection_without_chouette_naming(macro, name, options, active_record)
+    #   end
+    # end
+
+
+
+    # class Reflection
+
+    #   attr_reader :macro, :name, :options, :active_record
+
+    #   def initialize(macro, name, options, active_record)
+    #     @macro, @name, @options, @active_record = macro, name.to_s, options, active_record
+    #   end
+
+    #   def collection?
+    #     macro == :has_many
+    #   end
+
+    #   def singular_name
+    #     collection? ? name.singularize : name
+    #   end
+
+    #   def class_name
+    #     "Chouette::#{singular_name.camelize}"
+    #   end
+
+    #   def options_with_default
+    #     options.dup.tap do |options|
+    #       options[:class_name] ||= class_name
+    #     end
+    #   end
+
+    # end
+
+  end
+end
diff --git a/app/models/chouette/area_type.rb b/app/models/chouette/area_type.rb
new file mode 100644
index 000000000..af614dc55
--- /dev/null
+++ b/app/models/chouette/area_type.rb
@@ -0,0 +1,56 @@
+class Chouette::AreaType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    if (to_s == 'itl') 
+      to_s.upcase
+    else
+      camelize
+    end
+  end
+
+  @@definitions = [
+    ["boarding_position", 0],
+    ["quay", 1],
+    ["commercial_stop_point", 2],
+    ["stop_place", 3],
+    ["itl", 4]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
diff --git a/app/models/chouette/command.rb b/app/models/chouette/command.rb
new file mode 100644
index 000000000..d2995a000
--- /dev/null
+++ b/app/models/chouette/command.rb
@@ -0,0 +1,94 @@
+require 'tmpdir'
+
+#if RUBY_PLATFORM == "java"
+  # FIXME disable remove_entry_secure because incompatible with jruby ?! 
+  # See http://jira.codehaus.org/browse/JRUBY-4082
+  module FileUtils
+    def self.remove_entry_secure(*args)
+      self.remove_entry *args
+    end
+  end
+#end
+
+class Chouette::Command
+
+  include Chouette::CommandLineSupport
+
+  @@command = "chouette"
+  cattr_accessor :command
+
+  attr_accessor :database, :schema, :host, :user, :password, :port
+
+  def initialize(options = {})
+    database_options_from_active_record.merge(options).each do |k,v|
+      send "#{k}=", v
+    end
+  end
+
+  def database_options_from_active_record
+    config = Chouette::ActiveRecord.connection_pool.spec.config
+    { 
+      :database => config[:database], 
+      :user => config[:username],
+      :password => config[:password],
+      :port => config[:port],
+      :host => (config[:host] or "localhost")
+    }
+  end
+
+
+  def run!(options = {})
+    Dir.mktmpdir do |config_dir|
+      chouette_properties = File.join(config_dir, "chouette.properties")
+      open(chouette_properties, "w") do |f|
+        f.puts "database.name = #{database}"
+        f.puts "database.schema = #{schema}"
+        #f.puts "database.showsql = true"
+        f.puts "hibernate.username = #{user}"
+        f.puts "hibernate.password = #{password}"
+        f.puts "jdbc.url=jdbc:postgresql://#{host}:#{port}/#{database}"
+        f.puts "jdbc.username = #{user}"
+        f.puts "jdbc.password = #{password}"
+        #f.puts "database.hbm2ddl.auto=update"
+      end
+
+      logger.debug "Chouette properties: #{File.readlines(chouette_properties).collect(&:strip).join(', ')}"
+
+      command_line = "#{command} -classpath #{config_dir} #{command_options(options)}"
+      logger.debug "Execute '#{command_line}'"
+
+      execute! command_line
+    end
+  end
+
+  class Option
+
+    attr_accessor :key, :value
+
+    def initialize(key, value)
+      @key, @value = key.to_s, value
+    end
+
+    def command_key
+      key.camelize(:lower) 
+    end
+
+    def to_s
+      unless value == true
+        "-#{command_key} #{value}"
+      else
+        "-#{command_key}"
+      end
+    end
+
+  end
+
+  def command_options(options)
+    options.collect do |key, value|
+      Option.new(key, value)
+    end.sort_by(&:key).join(' ')
+  end
+
+  
+
+end
diff --git a/app/models/chouette/command_line_support.rb b/app/models/chouette/command_line_support.rb
new file mode 100644
index 000000000..99c61fa5b
--- /dev/null
+++ b/app/models/chouette/command_line_support.rb
@@ -0,0 +1,35 @@
+module Chouette::CommandLineSupport
+
+  class ExecutionError < StandardError; end
+
+  def available_loggers
+    [].tap do |logger|
+      logger << Chouette::ActiveRecord.logger  
+      logger << Rails.logger if defined?(Rails)
+      logger << Logger.new($stdout)
+    end.compact
+  end
+
+  def logger
+    @logger ||= available_loggers.first
+  end
+
+  def max_output_length
+    2000
+  end
+
+  def execute!(command)
+    logger.debug "execute '#{command}'"
+
+    output = `#{command} 2>&1`
+    output = "[...] #{output[-max_output_length,max_output_length]}" if output.length > max_output_length
+    logger.info output unless output.empty?
+
+    if $? != 0
+      raise ExecutionError.new("Command failed: #{command} (error code #{$?})")
+    end
+
+    true
+  end
+
+end
diff --git a/app/models/chouette/company.rb b/app/models/chouette/company.rb
new file mode 100644
index 000000000..d0375b2e6
--- /dev/null
+++ b/app/models/chouette/company.rb
@@ -0,0 +1,14 @@
+class Chouette::Company < Chouette::TridentActiveRecord
+  has_many :lines
+
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}, :allow_nil => true, :allow_blank => true
+  validates_presence_of :name
+  validates_format_of :url, :with => %r{\Ahttps?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?\Z}, :allow_nil => true, :allow_blank => true
+
+  def self.nullable_attributes
+    [:organizational_unit, :operating_department_name, :code, :phone, :fax, :email, :url, :time_zone]
+  end
+
+
+end
+
diff --git a/app/models/chouette/connection_link.rb b/app/models/chouette/connection_link.rb
new file mode 100644
index 000000000..045f7c1d9
--- /dev/null
+++ b/app/models/chouette/connection_link.rb
@@ -0,0 +1,47 @@
+class Chouette::ConnectionLink < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  attr_accessor :connection_link_type
+
+  belongs_to :departure, :class_name => 'Chouette::StopArea'
+  belongs_to :arrival, :class_name => 'Chouette::StopArea'
+
+  validates_presence_of :name
+
+  def self.nullable_attributes
+    [:link_distance, :default_duration, :frequent_traveller_duration, :occasional_traveller_duration,
+      :mobility_restricted_traveller_duration, :link_type]
+  end
+
+  def connection_link_type
+    link_type && Chouette::ConnectionLinkType.new( link_type.underscore)
+  end
+
+  def connection_link_type=(connection_link_type)
+    self.link_type = (connection_link_type ? connection_link_type.camelcase : nil)
+  end
+
+  @@connection_link_types = nil
+  def self.connection_link_types
+    @@connection_link_types ||= Chouette::ConnectionLinkType.all
+  end
+
+  def possible_areas
+    Chouette::StopArea.where("area_type != 'ITL'")
+  end
+
+  def stop_areas
+    Chouette::StopArea.where(:id => [self.departure_id,self.arrival_id])
+  end
+
+  def geometry
+    GeoRuby::SimpleFeatures::LineString.from_points( [ departure.geometry, arrival.geometry], 4326) if departure.geometry and arrival.geometry
+  end
+
+  def geometry_presenter
+    Chouette::Geometry::ConnectionLinkPresenter.new self
+  end
+
+end
+
diff --git a/app/models/chouette/connection_link_type.rb b/app/models/chouette/connection_link_type.rb
new file mode 100644
index 000000000..41635f48c
--- /dev/null
+++ b/app/models/chouette/connection_link_type.rb
@@ -0,0 +1,51 @@
+class Chouette::ConnectionLinkType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["underground", 0],
+    ["mixed", 1],
+    ["overground", 2]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
+
diff --git a/app/models/chouette/direction.rb b/app/models/chouette/direction.rb
new file mode 100644
index 000000000..93bc1318b
--- /dev/null
+++ b/app/models/chouette/direction.rb
@@ -0,0 +1,60 @@
+class Chouette::Direction < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    to_s
+  end
+
+  @@definitions = [
+    ["straight_forward", 0],
+    ["backward", 1],
+    ["clock_wise", 2],
+    ["counter_clock_wise", 3],
+    ["north", 4],
+    ["north_west", 5],
+    ["west", 6],
+    ["south_west", 7],
+    ["south", 8],
+    ["south_east", 9],
+    ["east", 10],
+    ["north_east", 11]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
+
diff --git a/app/models/chouette/exporter.rb b/app/models/chouette/exporter.rb
new file mode 100644
index 000000000..df85a9dde
--- /dev/null
+++ b/app/models/chouette/exporter.rb
@@ -0,0 +1,32 @@
+class Chouette::Exporter
+
+  attr_reader :schema
+
+  def initialize(schema)
+    @schema = schema
+  end
+
+  def chouette_command
+    @chouette_command ||= Chouette::Command.new(:schema => schema)
+  end
+
+  def export(file, options = {})
+    options = {
+      :format => :neptune
+    }.merge(options)
+
+    command_options = {
+      :c => "export", 
+      :o => "line", 
+      :format => options.delete(:format).to_s.upcase, 
+      :output_file => File.expand_path(file), 
+      :optimize_memory => true
+    }.merge(options)
+
+    logger.info "Export #{file} in schema #{schema}"
+    chouette_command.run! command_options
+  end
+
+  include Chouette::CommandLineSupport
+
+end
diff --git a/app/models/chouette/file_validator.rb b/app/models/chouette/file_validator.rb
new file mode 100644
index 000000000..513648a62
--- /dev/null
+++ b/app/models/chouette/file_validator.rb
@@ -0,0 +1,47 @@
+class Chouette::FileValidator
+
+  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
+
+  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 validate(file, options = {})
+    options = {
+      :format => :neptune
+    }.merge(options)
+
+    command_options = {
+      :c => "validate", 
+      :o => "line", 
+      :input_file => File.expand_path(file), 
+      :optimize_memory => true
+    }.merge(options)
+
+    logger.info "Validate #{file}"
+    chouette_command.run! command_options
+  end
+
+
+  include Chouette::CommandLineSupport
+
+end
diff --git a/app/models/chouette/footnote.rb b/app/models/chouette/footnote.rb
new file mode 100644
index 000000000..de427b249
--- /dev/null
+++ b/app/models/chouette/footnote.rb
@@ -0,0 +1,6 @@
+class Chouette::Footnote < Chouette::ActiveRecord
+  belongs_to :line, inverse_of: :footnotes
+  has_and_belongs_to_many :vehicle_journeys, :class_name => 'Chouette::VehicleJourney'
+
+  validates_presence_of :line
+end
diff --git a/app/models/chouette/for_alighting_enumerations.rb b/app/models/chouette/for_alighting_enumerations.rb
new file mode 100644
index 000000000..4f34927d3
--- /dev/null
+++ b/app/models/chouette/for_alighting_enumerations.rb
@@ -0,0 +1,8 @@
+module Chouette
+  module ForAlightingEnumerations
+    extend Enumerize
+    extend ActiveModel::Naming
+    
+    enumerize :for_alighting, in: %w[normal forbidden request_stop is_flexible]
+  end
+end
diff --git a/app/models/chouette/for_boarding_enumerations.rb b/app/models/chouette/for_boarding_enumerations.rb
new file mode 100644
index 000000000..48f8762c2
--- /dev/null
+++ b/app/models/chouette/for_boarding_enumerations.rb
@@ -0,0 +1,8 @@
+module Chouette
+  module ForBoardingEnumerations
+    extend Enumerize
+    extend ActiveModel::Naming
+
+    enumerize :for_boarding, in: %w[normal forbidden request_stop is_flexible]
+  end
+end
diff --git a/app/models/chouette/group_of_line.rb b/app/models/chouette/group_of_line.rb
new file mode 100644
index 000000000..1c1ae5f4c
--- /dev/null
+++ b/app/models/chouette/group_of_line.rb
@@ -0,0 +1,28 @@
+class Chouette::GroupOfLine < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+  
+  has_and_belongs_to_many :lines, :class_name => 'Chouette::Line', :order => 'lines.name'
+
+  validates_presence_of :name
+
+  attr_reader :line_tokens
+  
+  def self.nullable_attributes
+    [:comment]
+  end
+  
+  def commercial_stop_areas
+    Chouette::StopArea.joins(:children => [:stop_points => [:route => [:line => :group_of_lines] ] ]).where(:group_of_lines => {:id => self.id}).uniq
+  end
+
+  def stop_areas
+    Chouette::StopArea.joins(:stop_points => [:route => [:line => :group_of_lines] ]).where(:group_of_lines => {:id => self.id})
+  end
+  
+  def line_tokens=(ids)
+    self.line_ids = ids.split(",")
+  end
+
+end
+
diff --git a/app/models/chouette/journey_frequency.rb b/app/models/chouette/journey_frequency.rb
new file mode 100644
index 000000000..45b8aea8c
--- /dev/null
+++ b/app/models/chouette/journey_frequency.rb
@@ -0,0 +1,36 @@
+module Chouette
+
+  class JourneyFrequencyValidator < ActiveModel::Validator
+    def validate(record)
+      timeband = record.timeband
+      if timeband
+        first_departure_time = record.first_departure_time.utc.strftime( "%H%M%S%N" )
+        last_departure_time  = record.last_departure_time.utc.strftime( "%H%M%S%N" )
+        timeband_start_time  = timeband.start_time.utc.strftime( "%H%M%S%N" )
+        timeband_end_time    = timeband.end_time.utc.strftime( "%H%M%S%N" )
+
+        unless first_departure_time.between? timeband_start_time, timeband_end_time
+          record.errors[:first_departure_time] << I18n.t('activerecord.errors.models.journey_frequency.start_must_be_after_timeband')
+        end
+        unless last_departure_time.between? timeband_start_time, timeband_end_time
+          record.errors[:last_departure_time] << I18n.t('activerecord.errors.models.journey_frequency.end_must_be_before_timeband')
+        end
+      end
+      if record.first_departure_time == record.last_departure_time
+        record.errors[:last_departure_time] << I18n.t('activerecord.errors.models.journey_frequency.end_must_be_different_from_first')
+      end
+      if record.scheduled_headway_interval.blank? || (record.scheduled_headway_interval.strftime( "%H%M%S%N" ) == Time.current.midnight.strftime( "%H%M%S%N" ))
+        record.errors[:scheduled_headway_interval] << I18n.t('activerecord.errors.models.journey_frequency.scheduled_headway_interval_greater_than_zero')
+      end
+    end
+  end
+
+  class JourneyFrequency < ActiveRecord
+    belongs_to :vehicle_journey_frequency, foreign_key: 'vehicle_journey_id'
+    belongs_to :timeband
+    validates :first_departure_time, presence: true
+    validates :last_departure_time,  presence: true
+    validates :scheduled_headway_interval, presence: true
+    validates_with JourneyFrequencyValidator
+  end
+end
diff --git a/app/models/chouette/journey_pattern.rb b/app/models/chouette/journey_pattern.rb
new file mode 100644
index 000000000..d48733edb
--- /dev/null
+++ b/app/models/chouette/journey_pattern.rb
@@ -0,0 +1,109 @@
+class Chouette::JourneyPattern < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  belongs_to :route
+  has_many :vehicle_journeys, :dependent => :destroy
+  has_many :vehicle_journey_at_stops, :through => :vehicle_journeys
+  has_and_belongs_to_many :stop_points, -> { order("stop_points.position") }, :before_add => :vjas_add, :before_remove => :vjas_remove, :after_add => :shortcuts_update_for_add, :after_remove => :shortcuts_update_for_remove
+  has_many :journey_pattern_sections
+  has_many :route_sections, through: :journey_pattern_sections, dependent: :destroy
+
+  validates_presence_of :route
+
+  enum section_status: { todo: 0, completed: 1, control: 2 }
+
+  attr_accessor  :control_checked
+  after_update :control_route_sections, :unless => "control_checked"
+
+  # TODO: this a workarround
+  # otherwise, we loose the first stop_point
+  # when creating a new journey_pattern
+  def special_update
+    bck_sp = self.stop_points.map {|s| s}
+    self.update_attributes :stop_points => []
+    self.update_attributes :stop_points => bck_sp
+  end
+
+  def departure_stop_point
+    return unless departure_stop_point_id
+    Chouette::StopPoint.find( departure_stop_point_id)
+  end
+
+  def arrival_stop_point
+    return unless arrival_stop_point_id
+    Chouette::StopPoint.find( arrival_stop_point_id)
+  end
+
+  def shortcuts_update_for_add( stop_point)
+    stop_points << stop_point unless stop_points.include?( stop_point)
+
+    ordered_stop_points = stop_points
+    ordered_stop_points = ordered_stop_points.sort { |a,b| a.position <=> b.position} unless ordered_stop_points.empty?
+
+    self.update_attributes( :departure_stop_point_id => (ordered_stop_points.first && ordered_stop_points.first.id),
+                             :arrival_stop_point_id => (ordered_stop_points.last && ordered_stop_points.last.id))
+  end
+
+  def shortcuts_update_for_remove( stop_point)
+    stop_points.delete( stop_point) if stop_points.include?( stop_point)
+
+    ordered_stop_points = stop_points
+    ordered_stop_points = ordered_stop_points.sort { |a,b| a.position <=> b.position} unless ordered_stop_points.empty?
+
+    self.update_attributes( :departure_stop_point_id => (ordered_stop_points.first && ordered_stop_points.first.id),
+                             :arrival_stop_point_id => (ordered_stop_points.last && ordered_stop_points.last.id))
+  end
+
+  def vjas_add( stop_point)
+    return if new_record?
+
+    vehicle_journeys.each do |vj|
+      vjas = vj.vehicle_journey_at_stops.create :stop_point_id => stop_point.id
+    end
+  end
+
+  def vjas_remove( stop_point)
+    return if new_record?
+
+    vehicle_journey_at_stops.where( :stop_point_id => stop_point.id).each do |vjas|
+      vjas.destroy
+    end
+  end
+
+  def control_route_sections
+    stop_area_ids = self.stop_points.map(&:stop_area_id)
+    control_route_sections_by_stop_areas(stop_area_ids)
+  end
+
+  def control_route_sections_by_stop_areas(stop_area_ids)
+    journey_pattern_section_all
+    i = 0
+    to_control = false
+    stop_area_ids.each_cons(2) do |a|
+      jps = @route_sections_orders[i]
+      i += 1
+      unless jps
+        to_control = true
+        next
+      end
+      unless [jps.route_section.departure.id, jps.route_section.arrival.id] == a
+        jps.destroy
+        to_control = true
+      end
+    end
+    self.control_checked = true
+    to_control ? self.control! : self.completed!
+  end
+
+  protected
+
+  def journey_pattern_section_all
+    @route_sections_orders = {}
+    self.journey_pattern_sections.all.map do |journey_pattern_section|
+      @route_sections_orders[journey_pattern_section.rank] = journey_pattern_section
+    end
+  end
+
+end
+
diff --git a/app/models/chouette/journey_pattern_section.rb b/app/models/chouette/journey_pattern_section.rb
new file mode 100644
index 000000000..3ccba8ec0
--- /dev/null
+++ b/app/models/chouette/journey_pattern_section.rb
@@ -0,0 +1,20 @@
+class Chouette::JourneyPatternSection < Chouette::ActiveRecord
+  belongs_to :journey_pattern
+  belongs_to :route_section
+
+  validates :journey_pattern_id, presence: true
+  validates :route_section_id, presence: true
+  validates :rank, presence: true, numericality: :only_integer
+  validates :journey_pattern_id, uniqueness: { scope: [:route_section_id, :rank] }
+
+  default_scope { order(:rank) }
+
+  def self.update_by_journey_pattern_rank(journey_pattern_id, route_section_id, rank)
+    jps = self.find_or_initialize_by(journey_pattern_id: journey_pattern_id, rank: rank)
+    if route_section_id.present?
+      jps.update_attributes(route_section_id: route_section_id)
+    else
+      jps.destroy
+    end
+  end
+end
diff --git a/app/models/chouette/line.rb b/app/models/chouette/line.rb
new file mode 100644
index 000000000..d69203233
--- /dev/null
+++ b/app/models/chouette/line.rb
@@ -0,0 +1,74 @@
+class Chouette::Line < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  belongs_to :company
+  belongs_to :network
+  has_many :routes, :dependent => :destroy
+  has_many :journey_patterns, :through => :routes
+  has_many :vehicle_journeys, :through => :journey_patterns
+
+  has_and_belongs_to_many :group_of_lines, :class_name => 'Chouette::GroupOfLine', :order => 'group_of_lines.name'
+
+  has_many :footnotes, :inverse_of => :line, :validate => :true, :dependent => :destroy
+  accepts_nested_attributes_for :footnotes, :reject_if => :all_blank, :allow_destroy => true
+
+  attr_reader :group_of_line_tokens
+  attr_accessor :transport_mode
+
+  validates_presence_of :network
+  validates_presence_of :company
+
+  validates_format_of :registration_number, :with => %r{\A[\d\w_\-]+\Z}, :allow_nil => true, :allow_blank => true
+  validates_format_of :stable_id, :with => %r{\A[\d\w_\-]+\Z}, :allow_nil => true, :allow_blank => true
+  validates_format_of :url, :with => %r{\Ahttps?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?\Z}, :allow_nil => true, :allow_blank => true
+  validates_format_of :color, :with => %r{\A[0-9a-fA-F]{6}\Z}, :allow_nil => true, :allow_blank => true
+  validates_format_of :text_color, :with => %r{\A[0-9a-fA-F]{6}\Z}, :allow_nil => true, :allow_blank => true
+
+  validates_presence_of :name
+
+  def self.nullable_attributes
+    [:published_name, :number, :comment, :url, :color, :text_color, :stable_id]
+  end
+
+  def geometry_presenter
+    Chouette::Geometry::LinePresenter.new self
+  end
+
+  def transport_mode
+    # return nil if transport_mode_name is nil
+    transport_mode_name && Chouette::TransportMode.new( transport_mode_name.underscore)
+  end
+
+  def transport_mode=(transport_mode)
+    self.transport_mode_name = (transport_mode ? transport_mode.camelcase : nil)
+  end
+
+  @@transport_modes = nil
+  def self.transport_modes
+    @@transport_modes ||= Chouette::TransportMode.all.select do |transport_mode|
+      transport_mode.to_i > 0
+    end
+  end
+
+  def commercial_stop_areas
+    Chouette::StopArea.joins(:children => [:stop_points => [:route => :line] ]).where(:lines => {:id => self.id}).uniq
+  end
+
+  def stop_areas
+    Chouette::StopArea.joins(:stop_points => [:route => :line]).where(:lines => {:id => self.id})
+  end
+
+  def stop_areas_last_parents
+    Chouette::StopArea.joins(:stop_points => [:route => :line]).where(:lines => {:id => self.id}).collect(&:root).flatten.uniq
+  end
+
+  def group_of_line_tokens=(ids)
+    self.group_of_line_ids = ids.split(",")
+  end
+
+  def vehicle_journey_frequencies?
+    self.vehicle_journeys.unscoped.where(journey_category: 1).count > 0
+  end
+
+end
diff --git a/app/models/chouette/link_orientation_type.rb b/app/models/chouette/link_orientation_type.rb
new file mode 100644
index 000000000..ec279aba3
--- /dev/null
+++ b/app/models/chouette/link_orientation_type.rb
@@ -0,0 +1,49 @@
+class Chouette::LinkOrientationType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["access_point_to_stop_area", 0],
+    ["stop_area_to_access_point", 1]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
diff --git a/app/models/chouette/loader.rb b/app/models/chouette/loader.rb
new file mode 100644
index 000000000..40a2be4ee
--- /dev/null
+++ b/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
diff --git a/app/models/chouette/network.rb b/app/models/chouette/network.rb
new file mode 100644
index 000000000..a631d70ec
--- /dev/null
+++ b/app/models/chouette/network.rb
@@ -0,0 +1,46 @@
+class Chouette::Network < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  has_many :lines
+
+  attr_accessor :source_type_name
+
+  validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}, :allow_nil => true, :allow_blank => true
+  validates_presence_of :name
+
+  def self.object_id_key
+    "PTNetwork"
+  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
+
+  def source_type_name
+    # return nil if source_type is nil
+    source_type && Chouette::SourceType.new( source_type.underscore)
+  end
+
+  def source_type_name=(source_type_name)
+    self.source_type = (source_type_name ? source_type_name.camelcase : nil)
+  end
+
+  @@source_type_names = nil
+  def self.source_type_names
+    @@source_type_names ||= Chouette::SourceType.all.select do |source_type_name|
+      source_type_name.to_i > 0
+    end
+  end
+
+
+end
+
diff --git a/app/models/chouette/object_id.rb b/app/models/chouette/object_id.rb
new file mode 100644
index 000000000..4f58048e1
--- /dev/null
+++ b/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
diff --git a/app/models/chouette/pt_link.rb b/app/models/chouette/pt_link.rb
new file mode 100644
index 000000000..8a4e368ea
--- /dev/null
+++ b/app/models/chouette/pt_link.rb
@@ -0,0 +1,37 @@
+require 'geokit'
+
+class Chouette::PtLink < Chouette::ActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  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
diff --git a/app/models/chouette/route.rb b/app/models/chouette/route.rb
new file mode 100644
index 000000000..d5e39ac12
--- /dev/null
+++ b/app/models/chouette/route.rb
@@ -0,0 +1,183 @@
+class Chouette::Route < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  attr_accessor :wayback_code
+  attr_accessor :direction_code
+
+  def self.nullable_attributes
+    [:published_name, :comment, :number, :name]
+  end
+
+  belongs_to :line
+
+  has_many :journey_patterns, :dependent => :destroy
+  has_many :vehicle_journeys, :dependent => :destroy do
+    def timeless
+      Chouette::Route.vehicle_journeys_timeless(proxy_association.owner.journey_patterns.pluck( :departure_stop_point_id))
+    end
+  end
+  has_many :vehicle_journey_frequencies, :dependent => :destroy do
+    # Todo : I think there is a better way to do this.
+    def timeless
+      Chouette::Route.vehicle_journeys_timeless(proxy_association.owner.journey_patterns.pluck( :departure_stop_point_id))
+    end
+  end
+  belongs_to :opposite_route, :class_name => 'Chouette::Route', :foreign_key => :opposite_route_id
+  has_many :stop_points, -> { order('position ASC') }, :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, -> { order('stop_points.position ASC') }, :through => :stop_points 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
+  accepts_nested_attributes_for :stop_points, :allow_destroy => :true
+
+  # validates_presence_of :name
+  validates_presence_of :line
+  # validates_presence_of :direction_code
+  # validates_presence_of :wayback_code
+
+  before_destroy :dereference_opposite_route
+
+  after_commit :journey_patterns_control_route_sections
+
+  def geometry_presenter
+    Chouette::Geometry::RoutePresenter.new self
+  end
+
+  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(journey_category_model)
+    send(journey_category_model)
+        .joins(:journey_pattern, :vehicle_journey_at_stops)
+        .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
+
+  def journey_patterns_control_route_sections
+    self.journey_patterns.each do |jp|
+      jp.control_route_sections
+    end
+  end
+
+  protected
+
+  def self.vehicle_journeys_timeless(stop_point_id)
+    all( :conditions => ['vehicle_journeys.id NOT IN (?)', Chouette::VehicleJourneyAtStop.where(stop_point_id: stop_point_id).pluck(:vehicle_journey_id)] )
+  end
+
+end
diff --git a/app/models/chouette/route_section.rb b/app/models/chouette/route_section.rb
new file mode 100644
index 000000000..99f1e776f
--- /dev/null
+++ b/app/models/chouette/route_section.rb
@@ -0,0 +1,82 @@
+class Chouette::RouteSection < Chouette::TridentActiveRecord
+  belongs_to :departure, class_name: 'Chouette::StopArea'
+  belongs_to :arrival, class_name: 'Chouette::StopArea'
+  has_many :journey_pattern_sections
+  has_many :journey_patterns, through: :journey_pattern_sections, dependent: :destroy
+
+  validates :departure, :arrival, presence: true
+  validates :processed_geometry, presence: true
+
+  scope :by_endpoint_name, ->(endpoint, name) do
+    joins("INNER JOIN stop_areas #{endpoint} ON #{endpoint}.id = route_sections.#{endpoint}_id").where(["#{endpoint}.name ilike ?", "%#{name}%"])
+  end
+  scope :by_line_id, ->(line_id) do
+    joins(:journey_pattern_sections, :journey_patterns).joins('INNER JOIN routes ON journey_patterns.route_id = routes.id').where("routes.line_id = #{line_id}")
+  end
+
+  def stop_areas
+    [departure, arrival].compact
+  end
+
+  def default_geometry
+    points = stop_areas.collect(&:geometry).compact
+    GeoRuby::SimpleFeatures::LineString.from_points(points) if points.many?
+  end
+
+  def name
+    stop_areas.map do |stop_area|
+      stop_area.try(:name) or '?'
+    end.join(' - ') + " (#{geometry_description})"
+  end
+
+  def via_count
+    input_geometry ? [ input_geometry.points.count - 2, 0 ].max : 0
+  end
+
+  def geometry_description
+    if input_geometry || processed_geometry
+      [ "#{distance.to_i}m" ].tap do |parts|
+        parts << "#{via_count} #{'via'.pluralize(via_count)}" if via_count > 0
+      end.join(' - ')
+    else
+      "-"
+    end
+  end
+
+  DEFAULT_PROCESSOR = Proc.new { |section| section.input_geometry || section.default_geometry.try(:to_rgeo) }
+
+  @@processor = DEFAULT_PROCESSOR
+  cattr_accessor :processor
+
+  def instance_processor
+    no_processing || processor.nil? ? DEFAULT_PROCESSOR : processor
+  end
+
+  def process_geometry
+    if input_geometry_changed? || processed_geometry.nil?
+      self.processed_geometry = instance_processor.call(self)
+      self.distance = processed_geometry.to_georuby.to_wgs84.spherical_distance if processed_geometry
+    end
+
+    true
+  end
+  before_validation :process_geometry
+
+  def editable_geometry=(geometry)
+    self.input_geometry = geometry
+  end
+
+  def editable_geometry
+    input_geometry.try(:to_georuby) or default_geometry
+  end
+
+  def editable_geometry_before_type_cast
+    editable_geometry.to_ewkt
+  end
+
+  def geometry(mode = nil)
+    mode ||= :processed
+    mode == :editable ? editable_geometry : processed_geometry.to_georuby
+  end
+
+end
diff --git a/app/models/chouette/source_type.rb b/app/models/chouette/source_type.rb
new file mode 100644
index 000000000..124a6c433
--- /dev/null
+++ b/app/models/chouette/source_type.rb
@@ -0,0 +1,56 @@
+class Chouette::SourceType < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["public_and_private_utilities", 0],
+    ["road_authorities", 1],
+    ["transit_operator", 2],
+    ["public_transport", 3],
+    ["passenger_transport_coordinating_authority", 4],
+    ["travel_information_service_provider", 5],
+    ["travel_agency", 6],
+    ["individual_subject_of_travel_itinerary", 7],
+    ["other_information", 8]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
diff --git a/app/models/chouette/stop_area.rb b/app/models/chouette/stop_area.rb
new file mode 100644
index 000000000..b7cdd313a
--- /dev/null
+++ b/app/models/chouette/stop_area.rb
@@ -0,0 +1,323 @@
+require 'geokit'
+require 'geo_ruby'
+
+class Chouette::StopArea < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.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_writer :coordinates
+
+  after_update :journey_patterns_control_route_sections,
+               if: Proc.new { |stop_area| ['boarding_position', 'quay'].include? stop_area.stop_area_type }
+
+  validates_format_of :registration_number, :with => %r{\A[\d\w_\-]+\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_format_of :coordinates, :with => %r{\A *-?(0?[0-9](\.[0-9]*)?|[0-8][0-9](\.[0-9]*)?|90(\.[0]*)?) *\, *-?(0?[0-9]?[0-9](\.[0-9]*)?|1[0-7][0-9](\.[0-9]*)?|180(\.[0]*)?) *\Z}, :allow_nil => true, :allow_blank => true
+  validates_format_of :url, :with => %r{\Ahttps?:\/\/([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?\Z}, :allow_nil => true, :allow_blank => true
+
+  def self.nullable_attributes
+    [:registration_number, :street_name, :country_code, :fare_code,
+     :nearest_topic_name, :comment, :long_lat_type, :zip_code, :city_name, :url, :time_zone]
+  end
+
+  after_update :clean_invalid_access_links
+
+  before_save :coordinates_to_lat_lng
+
+  def combine_lat_lng
+    if self.latitude.nil? || self.longitude.nil?
+      ""
+    else
+      self.latitude.to_s+","+self.longitude.to_s
+    end
+  end
+
+  def coordinates
+      @coordinates || combine_lat_lng
+  end
+
+  def coordinates_to_lat_lng
+    if ! @coordinates.nil?
+      if @coordinates.empty?
+        self.latitude = nil
+        self.longitude = nil
+      else
+        self.latitude = BigDecimal.new(@coordinates.split(",").first)
+        self.longitude = BigDecimal.new(@coordinates.split(",").last)
+      end
+      @coordinates = nil
+    end
+  end
+
+  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 geometry_presenter
+    Chouette::Geometry::StopAreaPresenter.new self
+  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 self.stop_place
+    where :area_type => "StopPlace"
+  end
+
+  def self.physical
+    where :area_type => [ "BoardingPosition", "Quay" ]
+  end
+
+  def self.itl
+    where :area_type => "ITL"
+  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
+    where(nil).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
+
+  def duplicate
+    sa = self.deep_clone :except => [:object_version, :parent_id, :registration_number]
+    sa.uniq_objectid
+    sa.name = I18n.t("activerecord.copy", :name => self.name)
+    sa
+  end
+
+  def journey_patterns_control_route_sections
+    if self.changed_attributes['latitude'] || self.changed_attributes['longitude']
+      self.stop_points.each do |stop_point|
+        stop_point.route.journey_patterns.completed.map{ |jp| jp.control! }
+      end
+    end
+  end
+
+end
diff --git a/app/models/chouette/stop_point.rb b/app/models/chouette/stop_point.rb
new file mode 100644
index 000000000..b77189fc1
--- /dev/null
+++ b/app/models/chouette/stop_point.rb
@@ -0,0 +1,41 @@
+module Chouette
+  class StopPoint < TridentActiveRecord
+    include ForBoardingEnumerations
+    include ForAlightingEnumerations
+    
+    # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+    self.primary_key = "id"
+
+    belongs_to :stop_area
+    belongs_to :route, inverse_of: :stop_points
+    has_many :vehicle_journey_at_stops, :dependent => :destroy
+    has_many :vehicle_journeys, -> {uniq}, :through => :vehicle_journey_at_stops
+
+    acts_as_list :scope => :route, top_of_list: 0
+
+    validates_presence_of :stop_area
+    validate :stop_area_id_validation
+
+    scope :default_order, order("position")
+
+    before_destroy :remove_dependent_journey_pattern_stop_points
+    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  
+
+    def stop_area_id_validation
+      if stop_area_id.nil?
+        errors.add(:stop_area_id, I18n.t("errors.messages.empty"))
+      end
+    end
+
+    def self.area_candidates
+      Chouette::StopArea.where( :area_type => ['Quay', 'BoardingPosition'])
+    end
+
+  end
+end
diff --git a/app/models/chouette/time_table.rb b/app/models/chouette/time_table.rb
new file mode 100644
index 000000000..033c39f1c
--- /dev/null
+++ b/app/models/chouette/time_table.rb
@@ -0,0 +1,450 @@
+class Chouette::TimeTable < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  self.primary_key = "id"
+
+  acts_as_taggable
+  
+  attr_accessor :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday  
+  attr_accessor :tag_search
+
+  def self.ransackable_attributes auth_object = nil
+    (column_names + ['tag_search']) + _ransackers.keys
+  end
+
+  has_and_belongs_to_many :vehicle_journeys, :class_name => 'Chouette::VehicleJourney'
+
+  has_many :dates, -> {order(:date)}, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTableDate", :dependent => :destroy
+  has_many :periods, -> {order(:period_start)}, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTablePeriod", :dependent => :destroy
+
+  after_save :save_shortcuts
+
+  def self.object_id_key
+    "Timetable"
+  end
+
+  accepts_nested_attributes_for :dates, :allow_destroy => :true
+  accepts_nested_attributes_for :periods, :allow_destroy => :true
+
+  validates_presence_of :comment
+  validates_associated :dates
+  validates_associated :periods
+
+  def self.start_validity_period
+    [Chouette::TimeTable.minimum(:start_date)].compact.min
+  end
+  def self.end_validity_period
+    [Chouette::TimeTable.maximum(:end_date)].compact.max
+  end
+
+  def save_shortcuts
+      shortcuts_update
+      self.update_column(:start_date, start_date)
+      self.update_column(:end_date, end_date)
+  end
+
+  def shortcuts_update(date=nil)
+    dates_array = bounding_dates
+    #if new_record?
+      if dates_array.empty?
+        self.start_date=nil
+        self.end_date=nil
+      else
+        self.start_date=dates_array.min
+        self.end_date=dates_array.max
+      end
+    #else
+     # if dates_array.empty?
+     #   update_attributes :start_date => nil, :end_date => nil
+     # else
+     #   update_attributes :start_date => dates_array.min, :end_date => dates_array.max
+     # end
+    #end
+  end
+
+  def validity_out_from_on?(expected_date)
+    return false unless self.end_date
+    self.end_date <= expected_date
+  end
+  def validity_out_between?(starting_date, ending_date)
+    return false unless self.start_date
+    starting_date < self.end_date  &&
+      self.end_date <= ending_date
+  end
+  def self.validity_out_from_on?(expected_date,limit=0)
+    if limit==0
+      Chouette::TimeTable.where("end_date <= ?", expected_date)
+    else
+      Chouette::TimeTable.where("end_date <= ?", expected_date).limit( limit)
+    end
+  end
+  def self.validity_out_between?(start_date, end_date,limit=0)
+    if limit==0
+      Chouette::TimeTable.where( "? < end_date", start_date).where( "end_date <= ?", end_date)
+    else
+      Chouette::TimeTable.where( "? < end_date", start_date).where( "end_date <= ?", end_date).limit( limit)
+    end
+  end
+
+  # Return days which intersects with the time table dates and periods
+  def intersects(days)
+    [].tap do |intersect_days|
+      days.each do |day|
+        intersect_days << day if include_day?(day)
+      end
+    end
+  end
+
+  def include_day?(day)
+    include_in_dates?(day) || include_in_periods?(day)
+  end
+
+  def include_in_dates?(day)
+    self.dates.any?{ |d| d.date === day && d.in_out == true }
+  end
+
+  def excluded_date?(day)
+    self.dates.any?{ |d| d.date === day && d.in_out == false }
+  end
+
+  def include_in_periods?(day)
+    self.periods.any?{ |period| period.period_start <= day &&
+                                day <= period.period_end &&
+                                valid_days.include?(day.cwday) &&
+                                ! excluded_date?(day) }
+  end
+
+  def include_in_overlap_dates?(day)
+    return false if self.excluded_date?(day)
+
+    counter = self.dates.select{ |d| d.date === day}.size + self.periods.select{ |period| period.period_start <= day && day <= period.period_end && valid_days.include?(day.cwday) }.size
+    counter <= 1 ? false : true
+   end
+
+  def periods_max_date
+    return nil if self.periods.empty?
+
+    min_start = self.periods.map(&:period_start).compact.min
+    max_end = self.periods.map(&:period_end).compact.max
+    result = nil
+
+    if max_end && min_start
+      max_end.downto( min_start) do |date|
+        if self.valid_days.include?(date.cwday) && !self.excluded_date?(date)
+            result = date
+            break
+        end
+      end
+    end
+    result
+  end
+  def periods_min_date
+    return nil if self.periods.empty?
+
+    min_start = self.periods.map(&:period_start).compact.min
+    max_end = self.periods.map(&:period_end).compact.max
+    result = nil
+
+    if max_end && min_start
+      min_start.upto(max_end) do |date|
+        if self.valid_days.include?(date.cwday) && !self.excluded_date?(date)
+            result = date
+            break
+        end
+      end
+    end
+    result
+  end
+  def bounding_dates
+    bounding_min = self.dates.select{|d| d.in_out}.map(&:date).compact.min
+    bounding_max = self.dates.select{|d| d.in_out}.map(&:date).compact.max
+
+    unless self.periods.empty?
+      bounding_min = periods_min_date if periods_min_date &&
+          (bounding_min.nil? || (periods_min_date < bounding_min))
+
+      bounding_max = periods_max_date if periods_max_date &&
+          (bounding_max.nil? || (bounding_max < periods_max_date))
+    end
+
+    [bounding_min, bounding_max].compact
+  end
+
+  def day_by_mask(flag)
+    int_day_types & flag == flag
+  end
+
+  def self.day_by_mask(int_day_types,flag)
+    int_day_types & flag == flag
+  end
+
+
+  def valid_days
+    # Build an array with day of calendar week (1-7, Monday is 1).
+    [].tap do |valid_days|
+      valid_days << 1  if monday
+      valid_days << 2  if tuesday
+      valid_days << 3  if wednesday
+      valid_days << 4  if thursday
+      valid_days << 5  if friday
+      valid_days << 6  if saturday
+      valid_days << 7  if sunday
+    end
+  end
+
+  def self.valid_days(int_day_types)
+    # Build an array with day of calendar week (1-7, Monday is 1).
+    [].tap do |valid_days|
+      valid_days << 1  if day_by_mask(int_day_types,4)
+      valid_days << 2  if day_by_mask(int_day_types,8)
+      valid_days << 3  if day_by_mask(int_day_types,16)
+      valid_days << 4  if day_by_mask(int_day_types,32)
+      valid_days << 5  if day_by_mask(int_day_types,64)
+      valid_days << 6  if day_by_mask(int_day_types,128)
+      valid_days << 7  if day_by_mask(int_day_types,256)
+    end
+  end
+
+  def monday
+    day_by_mask(4)
+  end
+  def tuesday
+    day_by_mask(8)
+  end
+  def wednesday
+    day_by_mask(16)
+  end
+  def thursday
+    day_by_mask(32)
+  end
+  def friday
+    day_by_mask(64)
+  end
+  def saturday
+    day_by_mask(128)
+  end
+  def sunday
+    day_by_mask(256)
+  end
+
+  def set_day(day,flag)
+    if day == '1' || day == true
+      self.int_day_types |= flag
+    else
+      self.int_day_types &= ~flag
+    end
+    shortcuts_update
+  end
+
+  def monday=(day)
+    set_day(day,4)
+  end
+  def tuesday=(day)
+    set_day(day,8)
+  end
+  def wednesday=(day)
+    set_day(day,16)
+  end
+  def thursday=(day)
+    set_day(day,32)
+  end
+  def friday=(day)
+    set_day(day,64)
+  end
+  def saturday=(day)
+    set_day(day,128)
+  end
+  def sunday=(day)
+    set_day(day,256)
+  end
+
+  def effective_days_of_period(period,valid_days=self.valid_days)
+    days = []
+      period.period_start.upto(period.period_end) do |date|
+        if valid_days.include?(date.cwday) && !self.excluded_date?(date)
+            days << date
+        end
+      end
+    days
+  end
+
+  def effective_days(valid_days=self.valid_days)
+    days=self.effective_days_of_periods(valid_days)
+    self.dates.each do |d|
+      days |= [d.date] if d.in_out
+    end
+    days.sort
+  end
+
+  def effective_days_of_periods(valid_days=self.valid_days)
+    days = []
+    self.periods.each { |p| days |= self.effective_days_of_period(p,valid_days)}
+    days.sort
+  end
+
+  def clone_periods
+    periods = []
+    self.periods.each { |p| periods << p.copy}
+    periods
+  end
+
+  def included_days
+    days = []
+    self.dates.each do |d|
+      days |= [d.date] if d.in_out
+    end
+    days.sort
+  end
+
+  def excluded_days
+    days = []
+    self.dates.each do |d|
+      days |= [d.date] unless d.in_out
+    end
+    days.sort
+  end
+
+
+  # produce a copy of periods without anyone overlapping or including another
+  def optimize_periods
+    periods = self.clone_periods
+    optimized = []
+    i=0
+    while i < periods.length
+      p1 = periods[i]
+      optimized << p1
+      j= i+1
+      while j < periods.length
+        p2 = periods[j]
+        if p1.contains? p2
+          periods.delete p2
+        elsif p1.overlap? p2
+          p1.period_start = [p1.period_start,p2.period_start].min
+          p1.period_end = [p1.period_end,p2.period_end].max
+          periods.delete p2
+        else
+          j += 1
+        end
+      end
+      i+= 1
+    end
+    optimized.sort { |a,b| a.period_start <=> b.period_start}
+  end
+
+  # add a peculiar day or switch it from excluded to included
+  def add_included_day(d)
+    if self.excluded_date?(d)
+       self.dates.each do |date|
+         if date.date === d
+           date.in_out = true
+         end
+       end
+    elsif !self.include_in_dates?(d)
+       self.dates << Chouette::TimeTableDate.new(:date => d, :in_out => true)
+    end
+  end
+
+  # merge effective days from another timetable
+  def merge!(another_tt)
+    transaction do
+    # if one tt has no period, just merge lists
+    if self.periods.empty? || another_tt.periods.empty?
+      if !another_tt.periods.empty?
+        # copy periods
+        self.periods = another_tt.clone_periods
+        # set valid_days
+        self.int_day_types = another_tt.int_day_types
+      end
+      # merge dates
+      self.dates ||= []
+      another_tt.included_days.each do |d|
+        add_included_day d
+      end
+    else
+      # check if periods can be kept
+      common_day_types = self.int_day_types & another_tt.int_day_types & 508
+      # if common day types : merge periods
+      if common_day_types != 0
+        periods = self.optimize_periods
+        another_periods = another_tt.optimize_periods
+        # add not common days of both periods as peculiar days
+        self.effective_days_of_periods(self.class.valid_days(self.int_day_types ^ common_day_types)).each do |d|
+          self.dates |= [Chouette::TimeTableDate.new(:date => d, :in_out => true)]
+        end
+        another_tt.effective_days_of_periods(self.class.valid_days(another_tt.int_day_types ^ common_day_types)).each do |d|
+          add_included_day d
+        end
+        # merge periods
+        self.periods = periods | another_periods
+        self.int_day_types = common_day_types
+        self.periods = self.optimize_periods
+      else
+        # convert all period in days
+        self.effective_days_of_periods.each do |d|
+          self.dates << Chouette::TimeTableDate.new(:date => d, :in_out => true) unless self.include_in_dates?(d)
+        end
+        another_tt.effective_days_of_periods.each do |d|
+          add_included_day d
+        end
+      end
+    end
+    # if remained excluded dates are valid in other tt , remove it from result
+    self.dates.each do |date|
+      date.in_out = true if date.in_out == false && another_tt.include_day?(date.date)
+    end
+
+    # if peculiar dates are valid in new periods, remove them
+    if !self.periods.empty?
+      days_in_period = self.effective_days_of_periods
+      dates = []
+      self.dates.each do |date|
+        dates << date unless date.in_out && days_in_period.include?(date.date)
+      end
+      self.dates = dates
+    end
+    self.dates.to_a.sort! { |a,b| a.date <=> b.date}
+    self.save!
+    end
+  end
+
+  # remove dates form tt which aren't in another_tt
+  def intersect!(another_tt)
+    transaction do
+      
+      # transform tt as effective dates and get common ones
+      days = another_tt.intersects(self.effective_days) & self.intersects(another_tt.effective_days)
+      self.dates.clear
+      days.each {|d| self.dates << Chouette::TimeTableDate.new( :date =>d, :in_out => true)}
+      self.periods.clear
+      self.int_day_types = 0
+      self.dates.to_a.sort! { |a,b| a.date <=> b.date}
+      self.save!
+    end
+  end
+
+
+  def disjoin!(another_tt)
+    transaction do
+      # remove days from another calendar
+      days_to_exclude = self.intersects(another_tt.effective_days)
+      days = self.effective_days - days_to_exclude
+      self.dates.clear
+      self.periods.clear
+      self.int_day_types = 0
+
+      days.each {|d| self.dates << Chouette::TimeTableDate.new( :date =>d, :in_out => true)}
+
+      self.dates.to_a.sort! { |a,b| a.date <=> b.date}
+      self.periods.to_a.sort! { |a,b| a.period_start <=> b.period_start}
+      self.save!
+    end
+  end
+
+  def duplicate
+    tt = self.deep_clone :include => [:periods, :dates], :except => :object_version
+    tt.uniq_objectid
+    tt.comment = I18n.t("activerecord.copy", :name => self.comment)
+    tt
+  end
+
+end
+
diff --git a/app/models/chouette/time_table_date.rb b/app/models/chouette/time_table_date.rb
new file mode 100644
index 000000000..4624ae88e
--- /dev/null
+++ b/app/models/chouette/time_table_date.rb
@@ -0,0 +1,14 @@
+class Chouette::TimeTableDate < Chouette::ActiveRecord
+  self.primary_key = "id"
+  belongs_to :time_table, inverse_of: :dates
+  acts_as_list :scope => 'time_table_id = #{time_table_id}',:top_of_list => 0
+
+  validates_presence_of :date
+  validates_uniqueness_of :date, :scope => :time_table_id
+
+  def self.model_name
+    ActiveModel::Name.new Chouette::TimeTableDate, Chouette, "TimeTableDate"
+  end
+
+end
+
diff --git a/app/models/chouette/time_table_period.rb b/app/models/chouette/time_table_period.rb
new file mode 100644
index 000000000..0a75c18c3
--- /dev/null
+++ b/app/models/chouette/time_table_period.rb
@@ -0,0 +1,40 @@
+class Chouette::TimeTablePeriod < Chouette::ActiveRecord
+  self.primary_key = "id"
+  belongs_to :time_table, inverse_of: :periods
+  acts_as_list :scope => 'time_table_id = #{time_table_id}',:top_of_list => 0
+
+  validates_presence_of :period_start
+  validates_presence_of :period_end
+  
+  validate :start_must_be_before_end
+
+  
+  def self.model_name
+    ActiveModel::Name.new Chouette::TimeTablePeriod, Chouette, "TimeTablePeriod"
+  end
+  
+  def start_must_be_before_end
+    # security against nil values
+    if period_end.nil? || period_start.nil?
+      return
+    end
+    if period_end <= period_start
+      errors.add(:period_end,I18n.t("activerecord.errors.models.time_table_period.start_must_be_before_end"))
+    end
+  end
+    
+  def copy
+    Chouette::TimeTablePeriod.new(:period_start => self.period_start,:period_end => self.period_end)
+  end
+  
+  # Test to see if a period overlap this period
+  def overlap?(p)
+     (p.period_start >= self.period_start && p.period_start <= self.period_end) || (p.period_end >= self.period_start && p.period_end <= self.period_end)
+  end
+
+  # Test to see if a period is included in this period
+  def contains?(p)
+     (p.period_start >= self.period_start && p.period_end <= self.period_end)
+  end
+  
+end
diff --git a/app/models/chouette/timeband.rb b/app/models/chouette/timeband.rb
new file mode 100644
index 000000000..9844dd1b1
--- /dev/null
+++ b/app/models/chouette/timeband.rb
@@ -0,0 +1,30 @@
+module Chouette
+
+  class TimebandValidator < ActiveModel::Validator
+    def validate(record)
+      if record.end_time <= record.start_time
+        record.errors[:end_time] << I18n.t('activerecord.errors.models.timeband.start_must_be_before_end')
+      end
+    end
+  end
+
+  class Timeband < Chouette::TridentActiveRecord
+    self.primary_key = "id"
+
+    validates :start_time, :end_time, presence: true
+    validates_with TimebandValidator
+
+    default_scope { order(:start_time) }
+
+    def self.object_id_key
+      "Timeband"
+    end
+
+    def fullname
+      fullname = "#{I18n.l(self.start_time, format: :hour)}-#{I18n.l(self.end_time, format: :hour)}"
+      "#{self.name} (#{fullname})" if self.name
+    end
+
+  end
+
+end
diff --git a/app/models/chouette/transport_mode.rb b/app/models/chouette/transport_mode.rb
new file mode 100644
index 000000000..825ef15b8
--- /dev/null
+++ b/app/models/chouette/transport_mode.rb
@@ -0,0 +1,71 @@
+class Chouette::TransportMode < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    camelize
+  end
+
+  @@definitions = [
+    ["interchange", -1],
+    ["unknown", 0],
+    ["coach", 1],
+    ["air", 2],
+    ["waterborne", 3],
+    ["bus", 4],
+    ["ferry", 5],
+    ["walk", 6],
+    ["metro", 7],
+    ["shuttle", 8],
+    ["rapid_transit", 9],
+    ["taxi", 10],
+    ["local_train", 11],
+    ["train", 12],
+    ["long_distance_train", 13],
+    ["tramway", 14],
+    ["trolleybus", 15],
+    ["private_vehicle", 16],
+    ["bicycle", 17],
+    ["other", 18]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+  def public_transport?
+    not interchange?
+  end
+
+end
diff --git a/app/models/chouette/trident_active_record.rb b/app/models/chouette/trident_active_record.rb
new file mode 100644
index 000000000..b89b85863
--- /dev/null
+++ b/app/models/chouette/trident_active_record.rb
@@ -0,0 +1,132 @@
+class Chouette::TridentActiveRecord < Chouette::ActiveRecord
+    before_validation :prepare_auto_columns
+    after_validation :reset_auto_columns
+    
+    after_save :build_objectid
+
+    self.abstract_class = true
+    #
+    # triggers to generate objectId and objectVersion 
+    # TODO setting prefix in referential object
+    
+    def self.object_id_key
+      model_name
+    end
+    
+    def prefix
+      "NINOXE"
+    end
+    def prepare_auto_columns
+      # logger.info 'calling before_validation'
+      # logger.info 'start before_validation : '+self.objectid.to_s
+      if self.objectid.nil? || self.objectid.blank?
+        # if empty, generate a pending objectid which will be completed after creation
+        if self.id.nil?
+           self.objectid = "#{prefix}:#{self.class.object_id_key}:__pending_id__#{rand(1000)}"
+        else
+           self.objectid = "#{prefix}:#{self.class.object_id_key}:#{self.id}"
+           fix_uniq_objectid
+        end
+      elsif not self.objectid.include? ':'
+        # if one token : technical token : completed by prefix and key
+        self.objectid = "#{prefix}:#{self.class.object_id_key}:#{self.objectid}"
+      end
+      # logger.info 'end before_validation : '+self.objectid
+      # initialize or update version
+      if self.object_version.nil?
+        self.object_version = 1
+      else
+        self.object_version += 1
+      end
+      self.creation_time = Time.now
+      self.creator_id = 'chouette'
+    end
+    
+    def reset_auto_columns
+      clean_object_id unless self.errors.nil? || self.errors.empty?
+    end
+    
+    def clean_object_id
+      if self.objectid.include?("__pending_id__")
+        self.objectid=nil
+      end
+    end  
+    
+    def fix_uniq_objectid
+        base_objectid = self.objectid.rpartition(":").first
+        self.objectid = "#{base_objectid}:#{self.id}"
+        if !self.valid?
+          base_objectid="#{self.objectid}_"
+          cnt=1
+          while !self.valid? 
+            self.objectid = "#{base_objectid}#{cnt}"
+            cnt += 1
+          end
+        end
+      
+    end
+    
+    def build_objectid
+      #logger.info 'start after_create : '+self.objectid
+      if self.objectid.include? ':__pending_id__'
+        fix_uniq_objectid
+        self.update_attributes( :objectid => self.objectid, :object_version => (self.object_version - 1) )
+      end
+      #logger.info 'end after_create : '+self.objectid
+    end
+
+  validates_presence_of :objectid
+  validates_uniqueness_of :objectid
+  validates_numericality_of :object_version
+  validate :objectid_format_compliance
+
+  def objectid_format_compliance
+    if !self.objectid.valid?
+      #errors.add(:objectid, "is not a valid ObjectId object")
+      errors.add(:objectid,I18n.t("activerecord.errors.models.trident.invalid_object_id",:type => self.class.object_id_key))
+#    else
+#      unless self.objectid.object_type==self.class.object_id_key
+#        errors.add(:objectid,I18n.t("activerecord.errors.models.trident.invalid_object_id_type",:type => self.class.object_id_key))
+#      end
+    end
+  end
+  
+  def uniq_objectid
+    i = 0
+    baseobjectid = self.objectid
+    while self.class.exists?(:objectid => self.objectid) 
+      i += 1
+      self.objectid = baseobjectid+"_"+i.to_s
+    end
+  end
+
+  def self.model_name
+    ActiveModel::Name.new self, Chouette, self.name.demodulize
+  end
+
+  def objectid
+    Chouette::ObjectId.new read_attribute(:objectid)
+  end
+
+#  def version
+#    self.object_version
+#  end
+
+#  def version=(version)
+#    self.object_version = version
+#  end
+
+  before_validation :default_values, :on => :create
+  def default_values
+    self.object_version ||= 1
+  end
+
+  def timestamp_attributes_for_update #:nodoc:
+    [:creation_time]
+  end
+  
+  def timestamp_attributes_for_create #:nodoc:
+    [:creation_time]
+  end
+
+end
diff --git a/app/models/chouette/vehicle_journey.rb b/app/models/chouette/vehicle_journey.rb
new file mode 100644
index 000000000..44a9f8975
--- /dev/null
+++ b/app/models/chouette/vehicle_journey.rb
@@ -0,0 +1,114 @@
+module Chouette
+  class VehicleJourney < TridentActiveRecord
+
+    # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+    self.primary_key = "id"
+
+    enum journey_category: { timed: 0, frequency: 1 }
+
+    default_scope { where(journey_category: journey_categories[:timed]) }
+
+    attr_accessor :transport_mode_name
+    attr_reader :time_table_tokens
+
+    def self.nullable_attributes
+      [:transport_mode, :published_journey_name, :vehicle_type_identifier, :published_journey_identifier, :comment, :status_value]
+    end
+
+    belongs_to :company
+    belongs_to :route
+    belongs_to :journey_pattern
+
+    has_and_belongs_to_many :footnotes, :class_name => 'Chouette::Footnote'
+
+    validates_presence_of :route
+    validates_presence_of :journey_pattern
+
+    has_many :vehicle_journey_at_stops, -> { includes(:stop_point).order("stop_points.position") }, :dependent => :destroy
+    has_and_belongs_to_many :time_tables, :class_name => 'Chouette::TimeTable', :foreign_key => "vehicle_journey_id", :association_foreign_key => "time_table_id"
+    has_many :stop_points, -> { order("stop_points.position") }, :through => :vehicle_journey_at_stops
+
+    validate :increasing_times
+    validates_presence_of :number
+
+    before_validation :set_default_values
+    def set_default_values
+      if number.nil?
+        self.number = 0
+      end
+    end
+
+    scope :without_any_time_table, -> { joins('LEFT JOIN "time_tables_vehicle_journeys" ON "time_tables_vehicle_journeys"."vehicle_journey_id" = "vehicle_journeys"."id" LEFT JOIN "time_tables" ON "time_tables"."id" = "time_tables_vehicle_journeys"."time_table_id"').where(:time_tables => { :id => nil}) }
+    scope :without_any_passing_time, -> { joins('LEFT JOIN "vehicle_journey_at_stops" ON "vehicle_journey_at_stops"."vehicle_journey_id" = "vehicle_journeys"."id"').where(vehicle_journey_at_stops: { id: nil }) }
+
+    accepts_nested_attributes_for :vehicle_journey_at_stops, :allow_destroy => true
+
+    def transport_mode_name
+      # return nil if transport_mode is nil
+      transport_mode && Chouette::TransportMode.new( transport_mode.underscore)
+    end
+
+    def transport_mode_name=(transport_mode_name)
+      self.transport_mode = (transport_mode_name ? transport_mode_name.camelcase : nil)
+    end
+
+    @@transport_mode_names = nil
+    def self.transport_mode_names
+      @@transport_mode_names ||= Chouette::TransportMode.all.select do |transport_mode_name|
+        transport_mode_name.to_i > 0
+      end
+    end
+
+    def increasing_times
+      previous = nil
+      vehicle_journey_at_stops.select{|vjas| vjas.departure_time && vjas.arrival_time}.each do |vjas|
+        errors.add( :vehicle_journey_at_stops, 'time gap overflow') unless vjas.increasing_times_validate( previous)
+        previous = vjas
+      end
+    end
+
+    def missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      selected_journey_pattern.stop_points - self.stop_points
+    end
+    def extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      self.stop_points - selected_journey_pattern.stop_points
+    end
+    def extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      extra_stops = self.extra_stops_in_relation_to_a_journey_pattern(selected_journey_pattern)
+      self.vehicle_journey_at_stops.select { |vjas| extra_stops.include?( vjas.stop_point)}
+    end
+    def time_table_tokens=(ids)
+      self.time_table_ids = ids.split(",")
+    end
+    def bounding_dates
+      dates = []
+
+      time_tables.each do |tm|
+        dates << tm.start_date if tm.start_date
+        dates << tm.end_date if tm.end_date
+      end
+
+      dates.empty? ? [] : [dates.min, dates.max]
+    end
+
+    def update_journey_pattern( selected_journey_pattern)
+      return unless selected_journey_pattern.route_id==self.route_id
+
+      missing_stops_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |sp|
+        self.vehicle_journey_at_stops.build( :stop_point => sp)
+      end
+      extra_vjas_in_relation_to_a_journey_pattern(selected_journey_pattern).each do |vjas|
+        vjas._destroy = true
+      end
+    end
+
+    def self.matrix(vehicle_journeys)
+      {}.tap do |hash|
+        vehicle_journeys.map{ |vj|
+          vj.vehicle_journey_at_stops.map{ |vjas |hash[ "#{vj.id}-#{vjas.stop_point_id}"] = vjas }
+        }
+      end
+    end
+
+  end
+end
diff --git a/app/models/chouette/vehicle_journey_at_stop.rb b/app/models/chouette/vehicle_journey_at_stop.rb
new file mode 100644
index 000000000..7d6414f55
--- /dev/null
+++ b/app/models/chouette/vehicle_journey_at_stop.rb
@@ -0,0 +1,48 @@
+module Chouette
+  class VehicleJourneyAtStop < ActiveRecord
+    include ForBoardingEnumerations
+    include ForAlightingEnumerations
+
+    # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+    self.primary_key = "id"
+
+    belongs_to :stop_point
+    belongs_to :vehicle_journey
+
+    attr_accessor :_destroy
+
+    validate :arrival_must_be_before_departure
+    def arrival_must_be_before_departure
+      # security against nil values
+      return unless arrival_time && departure_time
+
+      if exceeds_gap?( arrival_time, departure_time)
+        errors.add(:arrival_time,I18n.t("activerecord.errors.models.vehicle_journey_at_stop.arrival_must_be_before_departure"))
+      end
+    end
+
+    after_initialize :set_virtual_attributes
+    def set_virtual_attributes
+      @_destroy = false
+    end
+
+    def increasing_times_validate( previous)
+      result = true
+      return result unless previous
+
+      if exceeds_gap?( previous.departure_time, departure_time)
+        result = false
+        errors.add( :departure_time, 'departure time gap overflow')
+      end
+      if exceeds_gap?( previous.arrival_time, arrival_time)
+        result = false
+        errors.add( :arrival_time, 'arrival time gap overflow')
+      end
+      result
+    end
+    def exceeds_gap?(first, second)
+      (4 * 3600) < ((second - first) % (3600 * 24))
+    end
+
+  end
+end
diff --git a/app/models/chouette/vehicle_journey_frequency.rb b/app/models/chouette/vehicle_journey_frequency.rb
new file mode 100644
index 000000000..41ba49082
--- /dev/null
+++ b/app/models/chouette/vehicle_journey_frequency.rb
@@ -0,0 +1,69 @@
+module Chouette
+  class VehicleJourneyFrequency < VehicleJourney
+
+    after_initialize :fill_journey_category
+
+    default_scope { where(journey_category: journey_categories[:frequency]) }
+
+    has_many :journey_frequencies, dependent: :destroy, foreign_key: 'vehicle_journey_id'
+    accepts_nested_attributes_for :journey_frequencies, allow_destroy: true
+
+    validate :require_at_least_one_frequency
+
+    def self.matrix(vehicle_journeys)
+      hash = {}
+      vehicle_journeys.each do |vj|
+        vj.journey_frequencies.each do |jf|
+          next if jf.scheduled_headway_interval.hour == 0 && jf.scheduled_headway_interval.min == 0
+          interval = jf.scheduled_headway_interval.hour.hours + jf.scheduled_headway_interval.min.minutes
+          first_departure_time = jf.first_departure_time
+          while first_departure_time <= jf.last_departure_time
+            hash[first_departure_time] = vj
+            first_departure_time += interval
+          end
+        end
+      end
+      hash.sort.to_h
+    end
+
+    def self.matrix_interval(matrix)
+      hash = prepare_matrix(matrix)
+      matrix.each do |departure_time, vj|
+        @base_departure_time = departure_time
+        vj.vehicle_journey_at_stops.each_cons(2) { |vjas, vjas_next|
+          vjas_dup = vjas.dup
+          vjas_dup.departure_time = @base_departure_time
+          hash[vjas.stop_point.stop_area.name][departure_time.to_i] = vjas_dup
+          @base_departure_time = vjas_dup.departure_time + (vjas_next.departure_time - vjas.departure_time)
+          @last_vjas_next = vjas_next.dup
+        }
+        # Add last stop_point
+        @last_vjas_next.departure_time = @base_departure_time
+        hash[@last_vjas_next.stop_point.stop_area.name][departure_time.to_i] = @last_vjas_next
+      end
+      hash
+    end
+
+    private
+
+    def self.prepare_matrix(matrix)
+      matrix.map{ |departure_time, vj|
+        Hash[
+          vj.vehicle_journey_at_stops.map{ |sp|
+            [
+              sp.stop_point.stop_area.name, Hash[matrix.map{ |departure_time2, vj2| [departure_time2.to_i, nil] }]
+            ]
+          }
+        ]
+      }.inject(&:merge)
+    end
+
+    def fill_journey_category
+      self.journey_category = :frequency
+    end
+
+    def require_at_least_one_frequency
+      errors.add(:base, I18n.t('vehicle_journey_frequency.require_at_least_one_frequency')) unless journey_frequencies.size > 0
+    end
+  end
+end
diff --git a/app/models/chouette/wayback.rb b/app/models/chouette/wayback.rb
new file mode 100644
index 000000000..b2950449d
--- /dev/null
+++ b/app/models/chouette/wayback.rb
@@ -0,0 +1,50 @@
+class Chouette::Wayback < ActiveSupport::StringInquirer
+
+  def initialize(text_code, numerical_code)
+    super text_code.to_s
+    @numerical_code = numerical_code
+  end
+
+  def self.new(text_code, numerical_code = nil)
+    if text_code and numerical_code
+      super
+    elsif self === text_code 
+      text_code
+    else
+      if Fixnum === text_code
+        text_code, numerical_code = definitions.rassoc(text_code)
+      else
+        text_code, numerical_code = definitions.assoc(text_code.to_s)
+      end
+
+      super text_code, numerical_code
+    end
+  end
+
+  def to_i
+    @numerical_code
+  end
+
+  def inspect
+    "#{to_s}/#{to_i}"
+  end
+
+  def name
+    to_s
+  end
+
+  @@definitions = [
+    ["straight_forward", 0],
+    ["backward", 1]
+  ]
+  cattr_reader :definitions
+
+  @@all = nil
+  def self.all
+    @@all ||= definitions.collect do |text_code, numerical_code|
+      new(text_code, numerical_code)
+    end
+  end
+
+end
+
diff --git a/app/presenters/chouette/geometry/access_link_presenter.rb b/app/presenters/chouette/geometry/access_link_presenter.rb
new file mode 100644
index 000000000..b0f1d5f94
--- /dev/null
+++ b/app/presenters/chouette/geometry/access_link_presenter.rb
@@ -0,0 +1,11 @@
+class Chouette::Geometry::AccessLinkPresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(access_link)
+    @access_link = access_link
+  end
+
+  def geometry
+    to_line_string_feature( [ @access_link.stop_area , @access_link.access_point ] )
+  end
+end
diff --git a/app/presenters/chouette/geometry/access_point_presenter.rb b/app/presenters/chouette/geometry/access_point_presenter.rb
new file mode 100644
index 000000000..d3ecb6128
--- /dev/null
+++ b/app/presenters/chouette/geometry/access_point_presenter.rb
@@ -0,0 +1,11 @@
+class Chouette::Geometry::AccessPointPresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(access_point)
+    @access_point = access_point
+  end
+
+  def geometry
+    to_point_feature( @access_point)
+  end
+end
diff --git a/app/presenters/chouette/geometry/connection_link_presenter.rb b/app/presenters/chouette/geometry/connection_link_presenter.rb
new file mode 100644
index 000000000..10f7fcd17
--- /dev/null
+++ b/app/presenters/chouette/geometry/connection_link_presenter.rb
@@ -0,0 +1,11 @@
+class Chouette::Geometry::ConnectionLinkPresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(connection_link)
+    @connection_link = connection_link
+  end
+
+  def geometry
+    to_line_string_feature( @connection_link.stop_areas)
+  end
+end
diff --git a/app/presenters/chouette/geometry/general_presenter.rb b/app/presenters/chouette/geometry/general_presenter.rb
new file mode 100644
index 000000000..3f0dd0031
--- /dev/null
+++ b/app/presenters/chouette/geometry/general_presenter.rb
@@ -0,0 +1,20 @@
+module Chouette::Geometry::GeneralPresenter
+
+  def to_line_string_feature( stop_areas)
+    points = stop_areas.collect(&:geometry).compact
+    GeoRuby::SimpleFeatures::LineString.from_points(points)
+  end
+
+  def to_multi_point_feature( stop_areas)
+    points = stop_areas.collect(&:geometry).compact
+    GeoRuby::SimpleFeatures::MultiPoint.from_points( points )
+  end
+
+  def to_point_feature( stop_area)
+    return nil unless stop_area.longitude && stop_area.latitude
+    GeoRuby::SimpleFeatures::Point.from_lon_lat( stop_area.longitude, stop_area.latitude, 4326)
+  end
+
+end
+
+
diff --git a/app/presenters/chouette/geometry/line_presenter.rb b/app/presenters/chouette/geometry/line_presenter.rb
new file mode 100644
index 000000000..89ab39185
--- /dev/null
+++ b/app/presenters/chouette/geometry/line_presenter.rb
@@ -0,0 +1,42 @@
+class Chouette::Geometry::LinePresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(line)
+    @line = line
+  end
+
+  # return line geometry based on CommercialStopPoint
+  #
+  def geometry
+    features = commercial_links.map { |link| to_line_string_feature(link) }
+    GeoRuby::SimpleFeatures::MultiLineString.from_line_strings( features, 4326)
+  end
+  #
+  # return line's stop_areas cloud geometry
+  #
+  def stop_areas_geometry
+    to_multi_point_feature( @line.commercial_stop_areas)
+  end
+
+  def commercial_links
+    link_keys = []
+    [].tap do |stop_area_links|
+      @line.routes.each do |route|
+        previous_commercial = nil
+        routes_localized_commercials(route).each do |commercial|
+          if previous_commercial && !link_keys.include?( "#{previous_commercial.id}-#{commercial.id}")
+            stop_area_links << [ previous_commercial, commercial]
+            link_keys << "#{previous_commercial.id}-#{commercial.id}"
+            link_keys << "#{commercial.id}-#{previous_commercial.id}"
+          end
+          previous_commercial = commercial
+        end
+      end
+    end
+  end
+
+  def routes_localized_commercials(route)
+    route.stop_areas.map { |sa| sa.parent}.compact.select { |sa| sa.latitude && sa.longitude}
+  end
+
+end
diff --git a/app/presenters/chouette/geometry/route_presenter.rb b/app/presenters/chouette/geometry/route_presenter.rb
new file mode 100644
index 000000000..292548c91
--- /dev/null
+++ b/app/presenters/chouette/geometry/route_presenter.rb
@@ -0,0 +1,22 @@
+class Chouette::Geometry::RoutePresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(route)
+    @route = route
+  end
+
+  # return route's stop_areas cloud geometry
+  #
+  def stop_areas_geometry
+    to_multi_point_feature( @route.stop_areas.with_geometry )
+  end
+
+  # return route geometry based on BoardingPosition or Quay
+  #
+  def geometry
+    to_line_string_feature( @route.stop_areas.with_geometry )
+  end
+
+
+end
+
diff --git a/app/presenters/chouette/geometry/stop_area_presenter.rb b/app/presenters/chouette/geometry/stop_area_presenter.rb
new file mode 100644
index 000000000..195405eab
--- /dev/null
+++ b/app/presenters/chouette/geometry/stop_area_presenter.rb
@@ -0,0 +1,13 @@
+class Chouette::Geometry::StopAreaPresenter
+  include Chouette::Geometry::GeneralPresenter
+
+  def initialize(stop_area)
+    @stop_area = stop_area
+  end
+
+  # return line geometry based on CommercialStopPoint
+  #
+  def geometry
+    to_point_feature( @stop_area)
+  end
+end