[59539] Add automatic scheduling mode

app/contracts/work_packages/base_contract.rb

@@ -101,19 +101,19 @@ class BaseContract < ::ModelContract
     attribute :schedule_manually
     attribute :ignore_non_working_days,
               writable: ->(*) {
-                !automatically_scheduled_parent?
+                leaf_or_manually_scheduled?
               }
 
     attribute :start_date,
               writable: ->(*) {
-                !automatically_scheduled_parent?
+                leaf_or_manually_scheduled?
               } do
       validate_after_soonest_start(:start_date)
     end
 
     attribute :due_date,
               writable: ->(*) {
-                !automatically_scheduled_parent?
+                leaf_or_manually_scheduled?
               } do
       validate_after_soonest_start(:due_date)
     end
@@ -227,7 +227,10 @@ def assignable_assignees
     attr_reader :can
 
     def validate_after_soonest_start(date_attribute)
-      if !model.schedule_manually? && before_soonest_start?(date_attribute)
+      return if model.schedule_manually?
+      return if model.children.any?
+
+      if before_soonest_start?(date_attribute)
         message = I18n.t("activerecord.errors.models.work_package.attributes.start_date.violates_relationships",
                          soonest_start: model.soonest_start)
 
@@ -627,8 +630,8 @@ def calculated_duration
       @calculated_duration ||= WorkPackages::Shared::Days.for(model).duration(model.start_date, model.due_date)
     end
 
-    def automatically_scheduled_parent?
-      !model.leaf? && !model.schedule_manually?
+    def leaf_or_manually_scheduled?
+      model.leaf? || model.schedule_manually?
     end
   end
 end

app/models/relation.rb

@@ -103,6 +103,12 @@ class Relation < ApplicationRecord
   scope :follows_with_lag,
         -> { follows.where("lag > 0") }
 
+  scope :of_successor,
+        ->(work_package) { where(from: work_package) }
+
+  scope :not_of_predecessor,
+        ->(work_package) { where.not(to: work_package) }
+
   validates :lag, numericality: { allow_nil: true }
 
   validates :to, uniqueness: { scope: :from }
@@ -134,10 +140,23 @@ def label_for(work_package)
     TYPES[relation_type] ? TYPES[relation_type][key] : :unknown
   end
 
+  def predecessor = to
+  def predecessor_id = to_id
+  def successor = from
+  def successor_id = from_id
+
+  def predecessor_date
+    predecessor.due_date || predecessor.start_date
+  end
+
+  def successor_date
+    successor.start_date || successor.due_date
+  end
+
   def successor_soonest_start
-    if follows? && (to.start_date || to.due_date)
+    if follows? && predecessor_date
       days = WorkPackages::Shared::Days.for(from)
-      relation_start_date = (to.due_date || to.start_date) + 1.day
+      relation_start_date = predecessor_date + 1.day
       days.soonest_working_day(relation_start_date, lag:)
     end
   end

app/models/work_packages/scopes/covering_dates_and_days_of_week.rb

@@ -39,19 +39,61 @@ module WorkPackages::Scopes::CoveringDatesAndDaysOfWeek
     # @param days_of_week number[] An array of the ISO days of the week to
     #   consider. 1 is Monday, 7 is Sunday.
     def covering_dates_and_days_of_week(days_of_week: [], dates: [])
+      work_packages_periods_cte = work_packages_periods_cte_for_covering_work_packages
+      where_covers_periods(work_packages_periods_cte, days_of_week, dates)
+    end
+
+    def predecessors_needing_relations_rescheduling(days_of_week: [], dates: [])
+      work_packages_periods_cte = work_packages_periods_cte_for_predecessors_needing_relations_rescheduling
+      where_covers_periods(work_packages_periods_cte, days_of_week, dates)
+    end
+
+    private
+
+    def where_covers_periods(work_packages_periods_cte, days_of_week, dates)
       days_of_week = Array(days_of_week)
       dates = Array(dates)
       return none if days_of_week.empty? && dates.empty?
 
-      where("id IN (#{query(days_of_week, dates)})")
-    end
+      covering_work_packages_query_sql = <<~SQL.squish
+        -- select work packages dates
+        WITH
+          -- cte returning a table with work package id, period start_date and end_date
+          #{work_packages_periods_cte},
 
-    private
+          -- All days between the start date of a work package and its due date
+          covered_dates AS (
+            SELECT
+            id,
+            generate_series(work_packages_periods.start_date,
+                            work_packages_periods.end_date,
+                            '1 day')          AS date
+            FROM work_packages_periods
+          ),
+
+          -- All days between the start date of a work package and its due date including the day of the week for each date
+          covered_dates_and_wday AS (
+            SELECT
+              id,
+              date,
+              EXTRACT(isodow FROM date) dow
+            FROM covered_dates
+          )
+
+        -- select id of work packages covering the given days
+        SELECT id FROM covered_dates_and_wday
+        WHERE dow IN (:days_of_week) OR date IN (:dates)
+      SQL
+
+      covering_work_packages_query_sql = sanitize_sql([covering_work_packages_query_sql, { days_of_week:, dates: }])
+
+      where("id IN (#{covering_work_packages_query_sql})")
+    end
 
-    def query(days_of_week, dates)
-      sql = <<~SQL.squish
-        -- select work packages dates with their followers dates
-        WITH work_packages_with_dates AS (
+    def work_packages_periods_cte_for_covering_work_packages
+      <<~SQL.squish
+        -- select work packages dates
+        work_packages_with_dates AS (
           SELECT work_packages.id,
             work_packages.start_date AS work_package_start_date,
             work_packages.due_date AS work_package_due_date
@@ -68,30 +110,48 @@ def query(days_of_week, dates)
             LEAST(work_package_start_date, work_package_due_date) AS start_date,
             GREATEST(work_package_start_date, work_package_due_date) AS end_date
           FROM work_packages_with_dates
+        )
+      SQL
+    end
+
+    def work_packages_periods_cte_for_predecessors_needing_relations_rescheduling
+      <<~SQL.squish
+        follows_relations
+          AS (SELECT
+            relations.id as id,
+            relations.to_id as pred_id,
+            relations.from_id as succ_id,
+            COALESCE(wp_pred.due_date, wp_pred.start_date) + INTERVAL '1 DAY' as pred_date,
+            COALESCE(wp_succ.start_date, wp_succ.due_date) - INTERVAL '1 DAY' as succ_date,
+            wp_succ.schedule_manually as succ_schedule_manually
+          FROM relations
+          LEFT JOIN work_packages wp_pred ON relations.to_id = wp_pred.id
+          LEFT JOIN work_packages wp_succ ON relations.from_id = wp_succ.id
+          WHERE relation_type = 'follows'
         ),
-        -- All days between the start date of a work package and its due date
-        covered_dates AS (
-          SELECT
-           id,
-           generate_series(work_packages_periods.start_date,
-                           work_packages_periods.end_date,
-                           '1 day')          AS date
-          FROM work_packages_periods
+        -- select automatic follows relations. A relation is automatic if the
+        -- successor is scheduled automatically and both successor and
+        -- predecessor have dates
+        -- also excluded relations that have no duration (predecessor and successor "touch" each other)
+        automatic_follows_relations AS (
+          SELECT *
+          FROM follows_relations
+          WHERE succ_schedule_manually = false
+            AND pred_date IS NOT NULL
+            AND succ_date IS NOT NULL
+            AND pred_date <= succ_date
         ),
-        -- All days between the start date of a work package and its due date including the day of the week for each date
-        covered_dates_and_wday AS (
-          SELECT
-            id,
-            date,
-            EXTRACT(isodow FROM date) dow
-          FROM covered_dates
+        -- keep only the longest relation for each successor
+        -- get the predecessor id and the relation period for each relation
+        work_packages_periods AS (
+          SELECT DISTINCT ON (succ_id)
+            pred_id as id,
+            pred_date as start_date,
+            succ_date as end_date
+          FROM automatic_follows_relations
+          ORDER BY succ_id, pred_date ASC
         )
-        -- select id of work packages covering the given days
-        SELECT id FROM covered_dates_and_wday
-        WHERE dow IN (:days_of_week) OR date IN (:dates)
       SQL
-
-      sanitize_sql([sql, { days_of_week:, dates: }])
     end
   end
 end

app/models/work_packages/scopes/for_scheduling.rb

@@ -30,6 +30,7 @@
 module WorkPackages::Scopes
   module ForScheduling
     extend ActiveSupport::Concern
+    using CoreExtensions::SquishSql
 
     class_methods do
       # Fetches all work packages that need to be evaluated for eventual
@@ -51,6 +52,11 @@ module ForScheduling
       # statement works, is that a work package is considered to be scheduled
       # manually if *all* of its descendants are scheduled manually.
       #
+      # One notable exception is if one of the manually scheduled children is
+      # the origin work package of the rescheduling. In this case, the parent is
+      # also subject to reschedule as the origin work package dates may have
+      # changed.
+      #
       # For example in case of the hierarchy:
       #   A and B <- hierarchy (C is parent of both A and B) - C <- hierarchy - D
       # * A and B are work packages
@@ -103,13 +109,13 @@ module ForScheduling
       # @param work_packages WorkPackage[] A set of work packages for which the
       #   set of related work packages that might be subject to reschedule is
       #   fetched.
-      def for_scheduling(work_packages)
+      def for_scheduling(work_packages, switching_to_automatic_mode: [])
         return none if work_packages.empty?
 
         sql = <<~SQL.squish
           WITH
             RECURSIVE
-            #{scheduling_paths_sql(work_packages)}
+            #{scheduling_paths_sql(work_packages, switching_to_automatic_mode:)}
 
             SELECT id
             FROM to_schedule
@@ -154,24 +160,44 @@ def for_scheduling(work_packages)
       #
       # Paths whose ending work package is marked to be manually scheduled are
       # not joined with any more.
-      def scheduling_paths_sql(work_packages)
+      def scheduling_paths_sql(work_packages, switching_to_automatic_mode: [])
+        automatic_ids = switching_to_automatic_mode.map do |wp|
+          ::OpenProject::SqlSanitization.sanitize("(:id)", id: wp.id)
+        end.join(", ")
+
         values = work_packages.map do |wp|
           ::OpenProject::SqlSanitization
-            .sanitize "(:id, false, false)",
+            .sanitize "(:id, false, false, true)",
                       id: wp.id
         end.join(", ")
 
         <<~SQL.squish
-          to_schedule (id, manually) AS (
+          -- All work packages that are switching to automatic scheduling mode
+          -- but are still seen as manually scheduled from the database's perspective.
+          switching_to_automatic_mode (id) AS (
+            SELECT id::bigint FROM (VALUES #{automatic_ids.presence || '(NULL)'}) AS t(id)
+          ),
 
-            SELECT * FROM (VALUES#{values}) AS t(id, manually, hierarchy_up)
+          -- recursively fetch all work packages that are eligible for rescheduling
+          to_schedule (id, manually, hierarchy_up, origin) AS (
+
+            SELECT * FROM (VALUES#{values}) AS t(id, manually, hierarchy_up, origin)
 
             UNION
 
             SELECT
               relations.from_id id,
-              (related_work_packages.schedule_manually OR COALESCE(descendants.manually, false)) manually,
-              relations.hierarchy_up
+              (
+                (
+                  related_work_packages.schedule_manually
+                  AND switching_to_automatic_mode.id IS NULL
+                ) OR (
+                  COALESCE(descendants.manually, false)
+                  AND NOT (to_schedule.origin AND relations.hierarchy_up)
+                )
+              ) manually,
+              relations.hierarchy_up,
+              false origin
             FROM
               to_schedule
             JOIN LATERAL
@@ -196,12 +222,14 @@ def scheduling_paths_sql(work_packages)
                 FROM
                   work_package_hierarchies
                 WHERE
-                  NOT to_schedule.manually
+                  (NOT to_schedule.manually OR to_schedule.origin)
                   AND ((work_package_hierarchies.ancestor_id = to_schedule.id AND NOT to_schedule.hierarchy_up AND work_package_hierarchies.generations = 1)
                        OR (work_package_hierarchies.descendant_id = to_schedule.id AND work_package_hierarchies.generations > 0))
               ) relations ON relations.to_id = to_schedule.id
             LEFT JOIN work_packages related_work_packages
               ON relations.from_id = related_work_packages.id
+            LEFT JOIN switching_to_automatic_mode
+              ON related_work_packages.id = switching_to_automatic_mode.id
             LEFT JOIN LATERAL (
               SELECT
                 descendant_hierarchies.ancestor_id from_id,

app/seeders/demo_data/work_package_seeder.rb

@@ -199,6 +199,7 @@ def work_package_attributes
           due_date:,
           duration:,
           ignore_non_working_days:,
+          schedule_manually:,
           estimated_hours:
         }
       end
@@ -213,7 +214,7 @@ def initialize(attributes)
 
       def start_date
         days_ahead = attributes["start"] || 0
-        Time.zone.today.monday + days_ahead.days
+        Date.current.monday + days_ahead.days
       end
 
       def due_date
@@ -230,6 +231,14 @@ def ignore_non_working_days
           .any? { |date| working_days.non_working?(date) }
       end
 
+      def schedule_manually
+        if attributes["schedule_manually"].nil?
+          WorkPackage.column_defaults["schedule_manually"]
+        else
+          ActiveModel::Type::Boolean.new.cast(attributes["schedule_manually"])
+        end
+      end
+
       def estimated_hours
         attributes["estimated_hours"]&.to_i
       end