@outbuild-company/schedule-core 1.14.0 → 1.14.2

package/dist/index.js

@@ -5367,13 +5367,14 @@ function buildCalendarPatch(activity, newCalendarId, ctx) {
   const newCalendar = ctx.calendars.getCalendar(newCalendarId);
   if (newCalendar) {
     const isMilestone = activity.durationHours === 0;
-    const snapFrom = isMilestone ? startOfUtcDay2(activity.startDate) : activity.startDate;
+    const snapToShiftStart = isMilestone || activity.assignedDefaultCalendar;
+    const snapFrom = snapToShiftStart ? startOfUtcDay2(activity.startDate) : activity.startDate;
     const calendarStart = newCalendar.getClosestWorkTime({
       date: snapFrom,
       direction: "future",
       unit: "hour"
     });
-    if (!activity.autoScheduling || isMilestone || newCalendar.getWorkHours(activity.startDate).length === 0) {
+    if (!activity.autoScheduling || snapToShiftStart || newCalendar.getWorkHours(activity.startDate).length === 0) {
       fields.startDate = calendarStart;
     }
     if (!activity.autoScheduling) {
@@ -15085,6 +15086,9 @@ async function dispatchBulkEdit(action, options, deps) {
   const trackingEvents = [];
   const linkChanges = [];
   const warnings = [];
+  const warningsBeforeExplicitConstraint = /* @__PURE__ */ new Set();
+  const appliedDateColumnsByActivity = /* @__PURE__ */ new Map();
+  const explicitConstraintsByActivity = /* @__PURE__ */ new Map();
   let needsAutoSchedule = false;
   for (const edit of action.edits) {
     const outcome = applyOneEdit2(edit, deps, action.eventSource);
@@ -15102,6 +15106,7 @@ async function dispatchBulkEdit(action, options, deps) {
     if (isExplicitConstraintDateEdit(edit.column)) {
       explicitDateEditActivities.add(String(edit.activityId));
     }
+    recordAppliedDateColumn(appliedDateColumnsByActivity, edit);
     const beforeLinkLags = snapshotIncomingLinkLags(adapter, edit.activityId);
     const preEditSnapshot = snapshotSingleActivity(
       adapter,
@@ -15116,6 +15121,16 @@ async function dispatchBulkEdit(action, options, deps) {
       adapter,
       preEditSnapshot
     );
+    recordWarningsBeforeExplicitConstraint(
+      warningsBeforeExplicitConstraint,
+      warnings,
+      edit
+    );
+    recordExplicitConstraint(
+      explicitConstraintsByActivity,
+      edit,
+      adapter.getActivity(edit.activityId)
+    );
     syncCustomIdTracker(edit, customIdBeforeApply, deps);
     linkChanges.push(
       ...diffIncomingLinkLagChanges(beforeLinkLags, adapter, edit.activityId)
@@ -15135,6 +15150,14 @@ async function dispatchBulkEdit(action, options, deps) {
     now: deps.now,
     options
   };
+  const reconciledWarnings = reconcileAtomicDateConstraints(
+    appliedDateColumnsByActivity,
+    explicitConstraintsByActivity,
+    beforeSnap,
+    warnings,
+    warningsBeforeExplicitConstraint,
+    deps
+  );
   const batchHasConstraintEdits = constraintPriorsByActivity.size > 0;
   const { scheduledIds } = await (batchHasConstraintEdits ? settleConstraintEdits(
     {
@@ -15178,11 +15201,114 @@ async function dispatchBulkEdit(action, options, deps) {
       sirDetection: SIR_DETECTION_PHASE.BEFORE_DIFF,
       links: linkChanges,
       trackingEvents,
-      warnings,
+      warnings: reconciledWarnings,
       hoursPerDay: sector.hoursPerDay
     })
   };
 }
+function recordWarningsBeforeExplicitConstraint(warningsBeforeExplicitConstraint, warnings, edit) {
+  if (!isConstraintEditColumn(edit.column)) return;
+  const activityId = String(edit.activityId);
+  for (const warning of warnings) {
+    if (String(warning.activityId) === activityId) {
+      warningsBeforeExplicitConstraint.add(warning);
+    }
+  }
+}
+function recordExplicitConstraint(constraintsByActivity, edit, activity) {
+  if (!isConstraintEditColumn(edit.column) || !activity) return;
+  constraintsByActivity.set(String(edit.activityId), {
+    constraintType: activity.constraintType,
+    constraintDate: activity.constraintDate ? new Date(activity.constraintDate.getTime()) : null
+  });
+}
+function recordAppliedDateColumn(columnsByActivity, edit) {
+  if (edit.column !== COLUMN.START_DATE && edit.column !== COLUMN.END_DATE) {
+    return;
+  }
+  const activityId = String(edit.activityId);
+  const columns = columnsByActivity.get(activityId) ?? /* @__PURE__ */ new Set();
+  columns.add(edit.column);
+  columnsByActivity.set(activityId, columns);
+}
+function reconcileAtomicDateConstraints(columnsByActivity, explicitConstraintsByActivity, beforeSnap, warnings, warningsBeforeExplicitConstraint, deps) {
+  const reconciledIds = /* @__PURE__ */ new Set();
+  const reconciledWarnings = [];
+  const discardedWarnings = /* @__PURE__ */ new Set();
+  for (const [activityId, columns] of columnsByActivity) {
+    if (!columns.has(COLUMN.START_DATE) || !columns.has(COLUMN.END_DATE)) {
+      continue;
+    }
+    const explicitConstraint = explicitConstraintsByActivity.get(activityId);
+    if (explicitConstraint) {
+      deps.adapter.setActivityFields(activityId, explicitConstraint);
+      for (const warning of warningsBeforeExplicitConstraint) {
+        if (String(warning.activityId) === activityId) {
+          discardedWarnings.add(warning);
+        }
+      }
+      continue;
+    }
+    const before = beforeSnap.get(activityId);
+    const after = deps.adapter.getActivity(activityId);
+    if (!before?.constraintType || !before.constraintDate || !after) continue;
+    const projectedDate = pickProjectedDateForConstraint(
+      before.constraintType,
+      after.startDate,
+      after.endDate
+    );
+    const violatesConstraint = violatesAtomicDateConstraint(
+      before.constraintType,
+      before.constraintDate,
+      projectedDate
+    );
+    reconciledIds.add(activityId);
+    if (violatesConstraint) {
+      deps.adapter.setActivityField(
+        activityId,
+        "constraintType",
+        CONSTRAINT_TYPE.SNET
+      );
+      deps.adapter.setActivityField(
+        activityId,
+        "constraintDate",
+        new Date(after.startDate.getTime())
+      );
+      const warning = toConstraintWarning(
+        activityId,
+        buildConstraintNotification(
+          before.constraintType,
+          before.constraintDate,
+          projectedDate
+        )
+      );
+      if (warning) reconciledWarnings.push(warning);
+      continue;
+    }
+    deps.adapter.setActivityField(
+      activityId,
+      "constraintType",
+      before.constraintType
+    );
+    deps.adapter.setActivityField(
+      activityId,
+      "constraintDate",
+      before.constraintDate
+    );
+  }
+  return [
+    ...warnings.filter(
+      (warning) => !discardedWarnings.has(warning) && !reconciledIds.has(String(warning.activityId))
+    ),
+    ...reconciledWarnings
+  ];
+}
+function violatesAtomicDateConstraint(constraintType, constraintDate, projectedDate) {
+  if (constraintType === CONSTRAINT_TYPE.MSO || constraintType === CONSTRAINT_TYPE.MFO) {
+    return constraintDate.getTime() !== projectedDate.getTime();
+  }
+  return checkConstraintViolation(constraintType, constraintDate, projectedDate).violated;
+}
 function applyOneEdit2(edit, deps, eventSource) {
   const { ctx } = deps;
   const activityId = edit.activityId;