ninoxe 0.0.8

data/app/models/chouette/time_table.rb

@@ -0,0 +1,146 @@
+class Chouette::TimeTable < Chouette::TridentActiveRecord
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+  
+  attr_accessible :objectid, :object_version, :creation_time, :creator_id, :version, :comment
+  attr_accessible  :int_day_types,:monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
+  attr_accessor :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
+
+  has_many :dates, :class_name => "Chouette::TimeTableDate", :order => :date, :dependent => :destroy
+  has_many :periods, :class_name => "Chouette::TimeTablePeriod", :order => :period_start, :dependent => :destroy
+
+  def self.object_id_key
+    "Timetable"
+  end
+
+  accepts_nested_attributes_for :dates, :allow_destroy => :true
+  accepts_nested_attributes_for :periods, :allow_destroy => :true
+  attr_accessible :dates_attributes,:periods_attributes
+
+  validates_presence_of :comment
+
+  def self.start_validity_period
+    [Chouette::TimeTableDate.minimum(:date),Chouette::TimeTablePeriod.minimum(:period_start)].compact.min 
+  end
+  def self.end_validity_period
+    [Chouette::TimeTableDate.maximum(:date),Chouette::TimeTablePeriod.maximum(:period_end)].compact.max 
+  end
+
+  def validity_out_from_on?(expected_date)
+    return false if bounding_dates.empty?
+    bounding_dates.max <= expected_date
+  end
+  def validity_out_between?(start_date, end_date)
+    return false if bounding_dates.empty?
+    start_date < bounding_dates.max  &&
+      bounding_dates.max <= end_date
+  end
+  def self.validity_out_from_on?(expected_date,limit=0)
+    expired = []
+    includes(:dates,:periods).find_each do |tm|
+      expired << tm if tm.validity_out_from_on?( expected_date)
+      break if (limit > 0 && expired.size == limit) 
+    end
+    expired
+  end
+  def self.validity_out_between?(start_date, end_date,limit=0)
+    expired = []
+    includes(:dates,:periods).find_each do |tm|
+      expired << tm if tm.validity_out_between?( start_date, end_date)
+      break if (limit > 0 && expired.size == limit) 
+    end
+    expired
+  end
+
+  def include_day?(day)
+    self.dates.any?{ |d| d.date === day } || self.periods.any?{ |period| period.period_start <= day && day <= period.period_end }
+  end
+
+  def include_in_dates?(day)
+    self.dates.any?{ |d| d.date === day }
+  end
+
+  def include_in_periods?(day)
+    self.periods.any?{ |period| period.period_start <= day && day <= period.period_end && valid_days.include?(day.cwday) }
+  end
+
+  def include_in_overlap_dates?(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 bounding_dates
+    (self.dates.map(&:date) + self.periods.map(&:period_start) + self.periods.map(&:period_end)).compact
+  end
+
+  def day_by_mask(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 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') 
+      self.int_day_types |= flag
+    else
+      self.int_day_types &= ~flag
+    end
+  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
+  
+end
+

data/app/models/chouette/time_table_date.rb

@@ -0,0 +1,14 @@
+class Chouette::TimeTableDate < Chouette::ActiveRecord
+  set_primary_key :id
+  belongs_to :time_table
+  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
+
+  attr_accessible :date, :position, :time_table_id, :time_table
+  def self.model_name
+    ActiveModel::Name.new Chouette::TimeTableDate, Chouette, "TimeTableDate"
+  end
+end
+

data/app/models/chouette/time_table_period.rb

@@ -0,0 +1,26 @@
+class Chouette::TimeTablePeriod < Chouette::ActiveRecord
+  set_primary_key :id
+  belongs_to :time_table
+  acts_as_list :scope => 'time_table_id = #{time_table_id}',:top_of_list => 0
+
+  attr_accessible :period_start, :period_end, :position,:time_table_id,:time_table
+  
+  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
+end

data/app/models/chouette/time_table_vehicle_journey.rb

@@ -0,0 +1,5 @@
+class Chouette::TimeTableVehicleJourney < Chouette::ActiveRecord
+  belongs_to :time_table
+  belongs_to :vehicle_journey
+end
+

data/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

data/app/models/chouette/trident_active_record.rb

@@ -0,0 +1,97 @@
+class Chouette::TridentActiveRecord < Chouette::ActiveRecord
+    before_validation :prepare_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.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}"
+        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 build_objectid
+      #logger.info 'start after_create : '+self.objectid
+      if self.objectid.include? ':__pending_id__'
+        base_objectid = self.objectid.rpartition(":").first
+        self.update_attributes( :objectid => "#{base_objectid}:#{self.id}", :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, "doesn't have expected 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 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

data/app/models/chouette/vehicle_journey.rb

@@ -0,0 +1,101 @@
+class Chouette::VehicleJourney < Chouette::TridentActiveRecord
+  #
+  # FIXME http://jira.codehaus.org/browse/JRUBY-6358
+  set_primary_key :id
+
+  attr_accessor :transport_mode_name
+  attr_accessible :route_id, :journey_pattern_id, :time_slot_id, :company_id, :objectid, :object_version, :creation_time, :creator_id, :comment, :status_value
+  attr_accessible :route, :transport_mode,:transport_mode_name, :published_journey_name, :published_journey_identifier, :facility, :vehicle_type_identifier, :number
+  attr_accessible :vehicle_journey_at_stops_attributes, :time_table_tokens, :time_tables
+  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
+
+  validates_presence_of :route
+  validates_presence_of :journey_pattern
+
+  has_many :vehicle_journey_at_stops, :dependent => :destroy, :include => :stop_point, :order => "stop_points.position"
+  accepts_nested_attributes_for :vehicle_journey_at_stops, :allow_destroy => true
+
+  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, :through => :vehicle_journey_at_stops, :order => 'stop_points.position'
+
+  validate :increasing_times
+  validates_presence_of :number
+  
+  before_validation :set_default_values
+  def set_default_values
+    if number.nil?
+      self.number = 0
+    end
+  end
+  
+  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|
+      tm_bounding_dates = tm.bounding_dates
+      unless tm_bounding_dates.empty?
+        dates << tm.bounding_dates.min
+        dates << tm.bounding_dates.max
+      end
+    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
+end

data/app/models/chouette/vehicle_journey_at_stop.rb

@@ -0,0 +1,45 @@
+class Chouette::VehicleJourneyAtStop < Chouette::ActiveRecord
+  set_primary_key :id
+  
+  belongs_to :stop_point
+  belongs_to :vehicle_journey
+
+  after_initialize :set_virtual_attributes
+
+  attr_accessor :_destroy
+  attr_accessible :vehicle_journey_id, :stop_point_id, :connecting_service_id, :boarding_alighting_possibility, :arrival_time, :departure_time, :waiting_time, :elapse_duration, :headway_frequency, :_destroy, :stop_point
+
+  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
+
+  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)
+    3600 < ( ( second-first)%( 3600 * 24))
+  end
+
+  def set_virtual_attributes
+    @_destroy = false
+  end
+
+end

data/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
+

data/app/views/layouts/ninoxe/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Ninoxe</title>
+  <%= stylesheet_link_tag    "ninoxe/application", :media => "all" %>
+  <%= javascript_include_tag "ninoxe/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/database.yml

@@ -0,0 +1,9 @@
+development:
+  adapter: postgresql
+  database: ninoxe_dev
+  username: <%= ENV['USER'] %>
+  
+test:
+  adapter: postgresql
+  database: ninoxe_test
+  username: <%= ENV['USER'] %>

data/config/database.yml.ci

@@ -0,0 +1,14 @@
+development:
+  adapter: postgresql
+  database: ninoxe_dev
+  username: chouette
+  password: chouette
+  template: template1
+  
+test:
+  adapter: postgresql
+  host: localhost
+  database: ninoxe_test
+  username: chouette
+  password: chouette
+  template: template1

data/config/database.yml.travis

@@ -0,0 +1,9 @@
+development:
+  adapter: postgresql
+  database: ninoxe_dev
+  username: postgres
+  
+test:
+  adapter: postgresql
+  database: ninoxe_test
+  username: postgres

data/config/locales/en.yml

@@ -0,0 +1,15 @@
+en:
+  activerecord:
+    errors:
+      models:
+        trident:
+          invalid_object_id: "invalid syntax, expected as [A-Za-z0-9_]:%{type}:[A-Za-z0-9_-]"
+          invalid_object_id_type: invalid type, must be %{type}
+        time_table_period:
+          start_must_be_before_end: end date must be after start date
+        time_table_date: 
+          attributes:
+            date:
+              taken: dupplicate date for this timetable
+        vehicle_journey_at_stop:
+          arrival_must_be_before_departure: arrival time must be before departure time

data/config/locales/fr.yml

@@ -0,0 +1,16 @@
+fr:
+  activerecord:
+    errors:
+      models:
+        trident:
+          invalid_object_id: "syntaxe invalide, [A-Za-z0-9_]:%{type}:[A-Za-z0-9_-] attendu"
+          invalid_object_id_type: type invalide, %{type} attendu
+        time_table_period:
+          start_must_be_before_end: la date de fin doit être postérieure à la date de début
+        time_table_date: 
+          attributes:
+            date:
+              taken: date déjà saisie pour ce calendrier
+        vehicle_journey_at_stop:
+          arrival_must_be_before_departure: "l'heure d'arrivée doit être antérieure à l'heure de départ"
+           

data/config/routes.rb

@@ -0,0 +1,2 @@
+Ninoxe::Engine.routes.draw do
+end

data/db/migrate/20120213131553_create_chouette_line.rb

@@ -0,0 +1,26 @@
+class CreateChouetteLine < ActiveRecord::Migration
+  def up
+    create_table "lines", :force => true do |t|
+      t.integer  "network_id",                :limit => 8
+      t.integer  "company_id",                  :limit => 8
+      t.string   "objectid", :null => false
+      t.integer  "object_version"
+      t.datetime "creation_time"
+      t.string   "creator_id"
+      t.string   "name"
+      t.string   "number"
+      t.string   "published_name"
+      t.string   "transport_mode_name"
+      t.string   "registration_number"
+      t.string   "comment"
+      t.boolean  "mobility_restricted_suitability"
+      t.integer  "int_user_needs"
+    end
+
+    add_index "lines", ["objectid"], :name => "lines_objectid_key", :unique => true
+    add_index "lines", ["registration_number"], :name => "lines_registration_number_key", :unique => true
+  end
+
+  def down    
+  end
+end