Move consistency checkers to a class (2)

models/concerns/validate_data.rb

@@ -0,0 +1,265 @@
+# Copyright © Mapotempo, 2021
+#
+# This file is part of Mapotempo.
+#
+# Mapotempo is free software. You can redistribute it and/or
+# modify since you respect the terms of the GNU Affero General
+# Public License as published by the Free Software Foundation,
+# either version 3 of the License, or (at your option) any later version.
+#
+# Mapotempo is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the Licenses for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with Mapotempo. If not, see:
+# <http://www.gnu.org/licenses/agpl.html>
+#
+require 'active_support/concern'
+
+# Expands provided data
+module ValidateData
+  extend ActiveSupport::Concern
+
+  def check_consistency(hash)
+    hash[:services] ||= []
+    hash[:shipments] ||= []
+    @hash = hash
+
+    ensure_uniq_ids
+    ensure_no_conflicting_skills
+
+    configuration = @hash[:configuration]
+    schedule = configuration[:schedule] if configuration
+    periodic_heuristic = configuration &&
+                         configuration[:preprocessing] &&
+                         configuration[:preprocessing][:first_solution_strategy].to_a.include?('periodic')
+    check_matrices
+    check_vehicles
+    check_relations(periodic_heuristic)
+    # TODO : this should be replaced by schedule when max_split does not use visits_number > 1 without schedule anymore
+    # indeed, no configuration implies no schedule and there should be no visits_number > 1 in this case
+    # check_services_and_shipments(schedule)
+    check_services_and_shipments(configuration, schedule)
+    check_shipments_specificities
+
+    check_routes(periodic_heuristic)
+    check_configuration(configuration, periodic_heuristic) if configuration
+  end
+
+  def ensure_uniq_ids
+    # TODO: Active Hash should be checking this
+    [:matrices, :units, :points, :rests, :zones, :timewindows,
+     :vehicles, :services, :shipments, :subtours].each{ |key|
+      next if @hash[key]&.collect{ |v| v[:id] }&.uniq!.nil?
+
+      raise OptimizerWrapper::DiscordantProblemError.new("#{key} IDs should be unique")
+    }
+  end
+
+  def ensure_no_conflicting_skills
+    all_skills = (@hash[:vehicles].to_a + @hash[:services].to_a + @hash[:shipments].to_a).flat_map{ |mission|
+      mission[:skills]
+    }.compact.uniq
+
+    return unless ['vehicle_partition_', 'work_day_partition_'].any?{ |str|
+      all_skills.any?{ |skill| skill.to_s.start_with?(str) }
+    }
+
+    raise OptimizerWrapper::UnsupportedProblemError.new(
+      "There are vehicles or services with 'vehicle_partition_*', 'work_day_partition_*' skills. " \
+      'These skill patterns are reserved for internal use and they would lead to unexpected behaviour.'
+    )
+  end
+
+  def check_matrices
+    # matrix_index consistency
+    if @hash[:matrices].nil? || @hash[:matrices].empty?
+      if @hash[:points]&.any?{ |p| p[:matrix_index] }
+        raise OptimizerWrapper::DiscordantProblemError.new(
+          'There is a point with point[:matrix_index] defined but there is no matrix'
+        )
+      end
+    else
+      max_matrix_index = @hash[:points].max{ |p| p[:matrix_index] || -1 }[:matrix_index] || -1
+      matrix_not_big_enough = @hash[:matrices].any?{ |matrix_group|
+        Models::Matrix.field_names.any?{ |dimension|
+          matrix_group[dimension] &&
+            (matrix_group[dimension].size <= max_matrix_index ||
+              matrix_group[dimension].any?{ |col| col.size <= max_matrix_index })
+        }
+      }
+      if matrix_not_big_enough
+        raise OptimizerWrapper::DiscordantProblemError.new(
+          'All matrices should have at least maximum(point[:matrix_index]) number of rows and columns'
+        )
+      end
+    end
+  end
+
+  def check_vehicles
+    @hash[:vehicles]&.each{ |v|
+      # vehicle time cost consistency
+      if v[:cost_waiting_time_multiplier].to_f > (v[:cost_time_multiplier] || 1)
+        raise OptimizerWrapper::DiscordantProblemError.new(
+          'Cost_waiting_time_multiplier cannot be greater than cost_time_multiplier'
+        )
+      end
+
+      # matrix_id consistency
+      if v[:matrix_id] && (@hash[:matrices].nil? || @hash[:matrices].none?{ |m| m[:id] == v[:matrix_id] })
+        raise OptimizerWrapper::DiscordantProblemError.new('There is no matrix with id vehicle[:matrix_id]')
+      end
+    }
+  end
+
+  def check_services_and_shipments(configuration, schedule)
+    (@hash[:services].to_a + @hash[:shipments].to_a).each{ |mission|
+      if (mission[:minimum_lapse] || 0) > (mission[:maximum_lapse] || 2**32)
+        raise OptimizerWrapper::DiscordantProblemError.new('Minimum lapse can not be bigger than maximum lapse')
+      end
+
+      # TODO : this should be replaced next line when max_split does not use visits_number > 1 without schedule anymore
+      # next if schedule && schedule[:range_indices] || mission[:visits_number].to_i <= 1
+      next if configuration.nil? || schedule && schedule[:range_indices] || mission[:visits_number].to_i <= 1
+
+      raise OptimizerWrapper::DiscordantProblemError.new('There can not be more than one visit without schedule')
+    }
+  end
+
+  def check_shipments_specificities
+    forbidden_position_pairs = [
+      [:always_middle, :always_first],
+      [:always_last, :always_middle],
+      [:always_last, :always_first]
+    ]
+    @hash[:shipments]&.each{ |shipment|
+      return unless forbidden_position_pairs.include?([shipment[:pickup][:position], shipment[:delivery][:position]])
+
+      raise OptimizerWrapper::DiscordantProblemError.new('Unconsistent positions in shipments.')
+    }
+  end
+
+  def check_relations(periodic_heuristic)
+    return unless @hash[:relations].to_a.any?
+
+    # shipment relation consistency
+    if @hash[:relations]&.any?{ |r| r[:type] == :shipment }
+      shipment_relations = @hash[:relations].select{ |r| r[:type] == :shipment }
+
+      shipments_not_having_exactly_two_linked_ids = shipment_relations.reject{ |r| r[:linked_ids].uniq.size == 2 }
+      unless shipments_not_having_exactly_two_linked_ids.empty?
+        raise OptimizerWrapper::DiscordantProblemError.new(
+          'Shipment relations need to have two services -- a pickup and a delivery. ' \
+          'Relations of following services does not have exactly two linked_ids: ' \
+          "#{shipments_not_having_exactly_two_linked_ids.flat_map{ |r| r[:linked_ids] }.uniq.sort.join(', ')}"
+        )
+      end
+
+      pickups = shipment_relations.map{ |r| r[:linked_ids].first }
+      deliveries = shipment_relations.map{ |r| r[:linked_ids].last }
+      services_that_are_both_pickup_and_delivery = pickups & deliveries
+      unless services_that_are_both_pickup_and_delivery.empty?
+        raise OptimizerWrapper::UnsupportedProblemError.new(
+          'A service cannot be both a delivery and a pickup in different relations. '\
+          'Following services appear in multiple shipment relations both as pickup and delivery: ',
+          [services_that_are_both_pickup_and_delivery]
+        )
+      end
+    end
+
+    incompatible_relation_types = @hash[:relations].collect{ |r| r[:type] }.uniq - %i[force_first never_first force_end]
+    return unless periodic_heuristic && incompatible_relation_types.any?
+
+    raise OptimizerWrapper::UnsupportedProblemError.new(
+      "#{incompatible_relation_types} relations not available with specified first_solution_strategy"
+    )
+  end
+
+  def check_routes(periodic_heuristic)
+    @hash[:routes]&.each{ |route|
+      route[:mission_ids].each{ |id|
+        corresponding = @hash[:services]&.find{ |s| s[:id] == id } || @hash[:shipments]&.find{ |s| s[:id] == id }
+
+        if corresponding.nil?
+          raise OptimizerWrapper::DiscordantProblemError.new('Each mission_ids should refer to an existant id')
+        end
+
+        next unless corresponding[:activities] && periodic_heuristic
+
+        raise OptimizerWrapper::UnsupportedProblemError.new('Services in routes should have only one activity')
+      }
+    }
+  end
+
+  def check_configuration(configuration, periodic_heuristic)
+    check_clustering_parameters(configuration) if configuration[:preprocessing]
+    check_schedule_consistency(configuration[:schedule]) if configuration[:schedule]
+    check_periodic_consistency(configuration) if periodic_heuristic
+    check_geometry_parameters(configuration) if configuration[:restitution]
+  end
+
+  def check_clustering_parameters(configuration)
+    return unless configuration[:preprocessing][:partitions]&.any?{ |partition|
+      partition[:entity].to_sym == :work_day
+    }
+
+    if @hash[:services].any?{ |s|
+        min_lapse = s[:minimum_lapse]&.floor || 1
+        max_lapse = s[:maximum_lapse]&.ceil || @hash[:configuration][:schedule][:range_indices][:end]
+
+        s[:visits_number].to_i > 1 && (
+          @hash[:configuration][:schedule][:range_indices][:end] <= 6 ||
+          (min_lapse..max_lapse).none?{ |intermediate_lapse| (intermediate_lapse % 7).zero? }
+       )
+      }
+
+      raise OptimizerWrapper::DiscordantProblemError.new(
+        'Work day partition implies that lapses of all services can be a multiple of 7.
+        There are services whose minimum and maximum lapse do not permit such lapse'
+      )
+    end
+  end
+
+  def check_schedule_consistency(schedule)
+    if schedule[:range_indices][:start] > 6
+      raise OptimizerWrapper::DiscordantProblemError.new('Api does not support schedule start index bigger than 6')
+      # TODO : allow start bigger than 6 and make code consistent with this
+    end
+
+    return unless schedule[:range_indices][:start] > schedule[:range_indices][:end]
+
+    raise OptimizerWrapper::DiscordantProblemError.new('Schedule start index should be less than or equal to end')
+  end
+
+  def check_periodic_consistency(configuration)
+    if @hash[:relations].to_a.any?{ |relation| relation[:type] == 'vehicle_group_duration_on_months' } &&
+       (!configuration[:schedule] || configuration[:schedule][:range_indice])
+      raise OptimizerWrapper::DiscordantProblemError.new(
+        'Vehicle group duration on weeks or months is not available without range_date'
+      )
+    end
+
+    unless @hash[:shipments].to_a.empty?
+      raise OptimizerWrapper::UnsupportedProblemError.new('Shipments are not available with periodic heuristic')
+    end
+
+    unless @hash[:vehicles].all?{ |vehicle| vehicle[:rests].to_a.empty? }
+      raise OptimizerWrapper::UnsupportedProblemError.new('Rests are not available with periodic heuristic')
+    end
+
+    if configuration[:resolution] && configuration[:resolution][:same_point_day] &&
+       @hash[:services].any?{ |service| service[:activities].to_a.size.positive? }
+      raise OptimizerWrapper.UnsupportedProblemError.new(
+        'Same_point_day is not supported if a set has one service with several activities'
+      )
+    end
+  end
+
+  def check_geometry_parameters(configuration)
+    return unless configuration[:restitution][:geometry].any? &&
+                  !@hash[:points].all?{ |pt| pt[:location] }
+
+    raise OptimizerWrapper::DiscordantProblemError.new('Geometry is not available if locations are not defined')
+  end
+end