ninoxe 1.0.3 → 1.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Njg5Yzg4YjEzOWIyZGUxNjc2MWU5YTEzMWYyOThiZTVjZmFlZjI1Yg==
+  data.tar.gz: !binary |-
+    N2YzZmUzM2Y1MzYyNWYwMDI0MWViOGQzODQzNGEyYjY5MzY2NDY0Yg==
+SHA512:
+  metadata.gz: !binary |-
+    YzUzNWM2ZWQwMmE4ODkzODYxZGZjNmE2MzViOGUzY2U4NDFiNTE0ZmQ5MDg5
+    ODkzZTJmNjY0YjU2MDdhNThiZWUzYzAxNTQ0N2VlN2U2Y2Q4NTI2NmRhZDJj
+    YjY3MTk5Y2Y4MmQzM2Q0MTJkODUyOTJlMDQzNDVlOGU3ZmJkZTA=
+  data.tar.gz: !binary |-
+    MDYwZWI4OTZmMDUzNzE0NjRhZjI5OGQ0NzVmZDg4ZjlmMTc2M2Q3ODY5Njk1
+    MTU3YzQ2OWIwYzZiODczMTUyNzQ2ZTBjNWE3OTIwYjlmYjcwZWE1NTA1ZDk3
+    ZGMwOTQzNmEwNzY2NTY4MTYxZDFiOGZlZTFlZjVjMjNlMGY2ZDg=

data/app/models/chouette/access_point.rb

@@ -9,19 +9,16 @@ class Chouette::AccessPoint < Chouette::TridentActiveRecord
   belongs_to :stop_area
   
   attr_accessor :access_point_type
+  attr_writer :coordinates
+
   attr_accessible :objectid, :object_version, :creation_time, :creator_id, :name, :comment
   attr_accessible :longitude, :latitude, :long_lat_type
-  #attr_accessible :x, :y, :projection_type
-  attr_accessible :country_code, :street_name
+  attr_accessible :country_code, :street_name, :zip_code, :city_name
   attr_accessible :openning_time, :closing_time, :access_type, :access_point_type
   attr_accessible :mobility_restricted_suitability, :stairs_availability, :lift_availability
   attr_accessible :stop_area_id
+  attr_accessible :coordinates
   
-  # workaround of ruby 1.8 private method y block attribute y reading access
-  #def y
-  #  read_attribute :y
-  #end
-
   validates_presence_of :name
   validates_presence_of :access_type
 
@@ -30,14 +27,38 @@ class Chouette::AccessPoint < Chouette::TridentActiveRecord
   validates_numericality_of :latitude, :less_than_or_equal_to => 90, :greater_than_or_equal_to => -90, :allow_nil => true
   validates_numericality_of :longitude, :less_than_or_equal_to => 180, :greater_than_or_equal_to => -180, :allow_nil => true
 
-  #validates_presence_of :x, :if => :y
-  #validates_presence_of :y, :if => :x
-  #validates_numericality_of :x, :allow_nil => true
-  #validates_numericality_of :y, :allow_nil => true
+  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]
+    [: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

data/app/models/chouette/active_record.rb

@@ -1,5 +1,5 @@
 #require "active_record"
-
+require 'deep_cloneable'
 module Chouette
   class ActiveRecord < ::ActiveRecord::Base
 

data/app/models/chouette/line.rb

@@ -6,11 +6,13 @@ class Chouette::Line < Chouette::TridentActiveRecord
   attr_accessible :transport_mode, :network_id, :company_id, :objectid, :object_version
   attr_accessible :creation_time, :creator_id, :name, :number, :published_name, :transport_mode_name
   attr_accessible :registration_number, :comment, :mobility_restricted_suitability, :int_user_needs
+  attr_accessible :flexible_service
 
   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'
   attr_accessible :group_of_lines, :group_of_line_ids, :group_of_line_tokens

data/app/models/chouette/stop_area.rb

@@ -15,13 +15,14 @@ class Chouette::StopArea < Chouette::TridentActiveRecord
 
   attr_accessor :stop_area_type
   attr_accessor :children_ids
+  attr_writer :coordinates
   
   attr_accessible :routing_stop_ids, :routing_line_ids, :children_ids, :stop_area_type, :parent_id, :objectid
   attr_accessible :object_version, :creation_time, :creator_id, :name, :comment, :area_type, :registration_number
   attr_accessible :nearest_topic_name, :fare_code, :longitude, :latitude, :long_lat_type
-  attr_accessible :country_code, :street_name
+  attr_accessible :country_code, :street_name, :zip_code, :city_name
   attr_accessible :mobility_restricted_suitability, :stairs_availability, :lift_availability, :int_user_needs
-
+  attr_accessible :coordinates
   
   validates_uniqueness_of :registration_number, :allow_nil => true, :allow_blank => true
   validates_format_of :registration_number, :with => %r{\A[0-9A-Za-z_-]+\Z}, :allow_blank => true
@@ -33,11 +34,40 @@ class Chouette::StopArea < Chouette::TridentActiveRecord
   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
-    [:registration_number, :street_name, :country_code, :fare_code, :nearest_topic_name, :comment, :long_lat_type]
+    [:registration_number, :street_name, :country_code, :fare_code, :nearest_topic_name, :comment, :long_lat_type, :zip_code, :city_name]
   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?
@@ -278,4 +308,12 @@ class Chouette::StopArea < Chouette::TridentActiveRecord
     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
+  
+  
 end

data/app/models/chouette/time_table.rb

@@ -1,13 +1,21 @@
 class Chouette::TimeTable < Chouette::TridentActiveRecord
   # FIXME http://jira.codehaus.org/browse/JRUBY-6358
   self.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_accessible :start_date, :end_date
-  attr_accessible :school_holliday,:public_holliday,:market_day
   attr_accessor :monday,:tuesday,:wednesday,:thursday,:friday,:saturday,:sunday
-  attr_accessor :school_holliday,:public_holliday,:market_day
+
+  acts_as_taggable
+  attr_accessible :tag_list, :tag_search
+  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, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTableDate", :order => :date, :dependent => :destroy, :after_add => :shortcuts_update, :after_remove => :shortcuts_update
   has_many :periods, inverse_of: :time_table, :validate => :true, :class_name => "Chouette::TimeTablePeriod", :order => :period_start, :dependent => :destroy, :after_add => :shortcuts_update, :after_remove => :shortcuts_update
@@ -25,10 +33,10 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   validates_associated :periods
 
   def self.start_validity_period
-    [Chouette::TimeTable.minimum(:start_date)].compact.min 
+    [Chouette::TimeTable.minimum(:start_date)].compact.min
   end
   def self.end_validity_period
-    [Chouette::TimeTable.maximum(:end_date)].compact.max 
+    [Chouette::TimeTable.maximum(:end_date)].compact.max
   end
 
   def shortcuts_update(date=nil)
@@ -40,7 +48,7 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
       else
         self.start_date=dates_array.min
         self.end_date=dates_array.max
-      end      
+      end
     #else
      # if dates_array.empty?
      #   update_attributes :start_date => nil, :end_date => nil
@@ -88,17 +96,26 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   end
 
   def include_in_dates?(day)
-    self.dates.any?{ |d| d.date === 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) }
+    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
+    counter <= 1 ? false : true
+   end
 
   def periods_max_date
     return nil if self.periods.empty?
@@ -107,11 +124,12 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
     max_end = self.periods.map(&:period_end).compact.max
     result = nil
 
-    if max_end
-      max_end.downto(max_end-7) do |date|
-        result = date if result.nil? && 
-                          self.valid_days.include?(date.cwday) &&
-                          ( date >= min_start)
+    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
@@ -123,24 +141,25 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
     max_end = self.periods.map(&:period_end).compact.max
     result = nil
 
-    if min_start
-      min_start.upto(min_start+7) do |date|
-        result = date if result.nil? && 
-                          self.valid_days.include?(date.cwday) &&
-                          ( date <= max_end)
+    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.map(&:date).compact.min
-    bounding_max = self.dates.map(&:date).compact.max
+    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 = periods_max_date if periods_max_date &&
           (bounding_max.nil? || (bounding_max < periods_max_date))
     end
 
@@ -151,6 +170,11 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
     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|
@@ -164,6 +188,19 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
     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
@@ -185,25 +222,16 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   def sunday
     day_by_mask(256)
   end
-  def school_holliday
-    day_by_mask(512)
-  end  
-  def public_holliday
-    day_by_mask(1024)
-  end  
-  def market_day
-    day_by_mask(2048)
-  end  
-  
+
   def set_day(day,flag)
-    if (day == '1') 
+    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
@@ -225,15 +253,293 @@ class Chouette::TimeTable < Chouette::TridentActiveRecord
   def sunday=(day)
     set_day(day,256)
   end
-  def school_holliday=(day)
-    set_day(day,512)
-  end  
-  def public_holliday=(day)
-    set_day(day,1024)
-  end  
-  def market_day=(day)
-    set_day(day,2048)
-  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.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
+    common_day_types = self.int_day_types & another_tt.int_day_types & 508
+    # if both tt have periods with common day_types, intersect them
+    if !self.periods.empty? && !another_tt.periods.empty?
+      if common_day_types != 0
+        periods = []
+        days = []
+        valid_days = self.class.valid_days(common_day_types)
+        self.optimize_periods.each do |p1|
+          another_tt.optimize_periods.each do |p2|
+            if p1.overlap? p2
+              # create period for intersection
+              pi = Chouette::TimeTablePeriod.new(:period_start => [p1.period_start,p2.period_start].max,
+                                                 :period_end => [p1.period_end,p2.period_end].min)
+              if !self.effective_days_of_period(pi,valid_days).empty? && !another_tt.effective_days_of_period(pi,valid_days).empty?
+                if pi.period_start == pi.period_end
+                  days << pi.period_start
+                else
+                  periods << pi
+                end
+              end
+            end
+          end
+        end
+        # intersect dates
+        days |= another_tt.intersects(self.included_days) & self.intersects(another_tt.included_days)
+        excluded_days = self.excluded_days | another_tt.excluded_days
+        self.dates.clear
+        days.each {|day| self.dates << Chouette::TimeTableDate.new( :date =>day, :in_out => true)}
+        self.periods = periods
+        common_day_types = 0 if periods.empty?
+        self.int_day_types = common_day_types
+        days_of_periods = self.effective_days_of_periods
+        excluded_days.each do |day|
+          self.dates << Chouette::TimeTableDate.new( :date =>day, :in_out => false) if days_of_periods.contains?(day)
+        end
+      end
+    else
+      # 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
+    end
+    self.dates.sort! { |a,b| a.date <=> b.date}
+    self.save!
+    end
+  end
+
+
+  def disjoin!(another_tt)
+    transaction do
+    common_day_types = self.int_day_types & another_tt.int_day_types & 508
+    # if both tt have periods with common day_types, reduce first ones to exclude second
+    if !self.periods.empty? && !another_tt.periods.empty?
+      if common_day_types != 0
+        periods = []
+        days = []
+        valid_days = self.class.valid_days(self.int_day_types)
+        remain_days = self.class.valid_days(self.int_day_types & ~another_tt.int_day_types)
+        self.optimize_periods.each do |p1|
+          deleted = false
+          another_tt.optimize_periods.each do |p2|
+            if  p2.contains? p1
+              # p1 is removed, keep remaining dates as included
+              days |= self.effective_days_of_period(p1,remain_days)
+              deleted = true
+              break
+            elsif  p1.contains? p2
+              # p1 is broken in 2; keep remaining dates covered by p2 as included days
+              days |= self.effective_days_of_period(p2,remain_days)
+              if  p1.period_start != p2.period_start
+                pi = Chouette::TimeTablePeriod.new(:period_start => p1.period_start,
+                                                   :period_end => p2.period_start - 1)
+                if !self.effective_days_of_period(pi,valid_days).empty?
+                  if pi.period_start == pi.period_end
+                    days << pi.period_start
+                  else
+                    periods << pi
+                  end
+                end
+              end
+              if p1.period_end != p2.period_end
+                 p1.period_start = p2.period_end + 1
+              else
+                 deleted = true
+                 break
+              end
+            elsif  p1.overlap? p2
+              if p2.period_start <= p1.period_start
+                p2.period_start = p1.period_start
+                p1.period_start = p2.period_end + 1
+              else
+                p2.period_end = p1.period_end
+                p1.period_end = p2.period_start - 1
+              end
+              days |= self.effective_days_of_period(p2,remain_days)
+            end
+          end
+          unless deleted || self.effective_days_of_period(p1,valid_days).empty?
+            if p1.period_start != p1.period_end
+              periods << p1
+            else
+              days << p1.period_start
+            end
+          end
+        end
+        # rebuild periods and dates
+        self.periods = periods
+        self.int_day_types = 0 if periods.empty?
+        days.each { |d| self.dates |= [Chouette::TimeTableDate.new( :date =>d, :in_out => true)] }
+      end
+    else
+      # otherwise remove or exclude dates and delete empty periods
+      # first remove peculiar dates
+      days = self.intersects(another_tt.effective_days)
+      self.dates -= self.dates.select{|date| days.include?(date.date)}
+      # then add excluded dates
+      self.intersects(another_tt.effective_days).each do |d|
+        self.dates |= [Chouette::TimeTableDate.new( :date =>d, :in_out => false)]
+      end
+    end
+    self.dates.sort! { |a,b| a.date <=> b.date}
+    self.periods.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
 

data/app/models/chouette/time_table_date.rb

@@ -2,18 +2,18 @@ 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
 
-  attr_accessible :date, :position, :time_table_id, :time_table
-  
+  attr_accessible :date, :position, :time_table_id, :time_table, :in_out
+
   after_update :update_parent
-  
+
   def self.model_name
     ActiveModel::Name.new Chouette::TimeTableDate, Chouette, "TimeTableDate"
   end
-  
+
   def update_parent
     time_table.shortcuts_update
   end