Tijl/-/add-simple-without-deadline

src/lib.rs

@@ -53,7 +53,7 @@
 //! quality perception of the ZinZen® projects.
 
 use chrono::NaiveDateTime;
-use models::{activity::Activity, calendar::Calendar, goal::Goal, task::FinalTasks};
+use models::{calendar::Calendar, goal::Goal, task::FinalTasks};
 use serde_wasm_bindgen::{from_value, to_value};
 use services::activity_generator;
 use services::activity_placer;
@@ -94,44 +94,31 @@ pub fn run_scheduler(
 
     calendar.add_budgets_from(goals);
 
-    //generate and place simple goal activities
-    let simple_goal_activities =
-        activity_generator::generate_simple_goal_activities(&calendar, goals);
-    dbg!(&simple_goal_activities);
+    let mut base_activities = activity_generator::get_base_activities(&calendar, goals);
 
-    let simple_filler_activities =
-        activity_generator::generate_simple_filler_goal_activities(&calendar, goals);
-    dbg!(&simple_filler_activities);
-
-    //generate and place budget goal activities
-    let budget_goal_activities: Vec<Activity> =
-        activity_generator::generate_budget_goal_activities(&calendar, goals);
-    dbg!(&budget_goal_activities);
-    dbg!(&calendar);
-
-    let activities: Vec<Activity> = [
-        simple_goal_activities,
-        simple_filler_activities,
-        budget_goal_activities,
-    ]
-    .concat();
-    activity_placer::place(&mut calendar, activities);
+    base_activities = activity_placer::place(&mut calendar, base_activities);
 
     calendar.log_impossible_min_day_budgets();
 
-    if let Some(get_to_week_min_budget_activities) =
-        activity_generator::generate_get_to_week_min_budget_activities(&calendar, goals)
-    {
-        activity_placer::place(&mut calendar, get_to_week_min_budget_activities);
-    }
+    let get_to_week_min_budget_activities =
+        activity_generator::get_budget_min_week_activities(&calendar, goals);
+    activity_placer::place(&mut calendar, get_to_week_min_budget_activities);
     //TODO: Test that day stays below min when week min being reached so other goals can get to the week min too
 
     calendar.log_impossible_min_week_budgets();
 
     let top_up_week_budget_activities =
-        activity_generator::generate_top_up_week_budget_activities(&calendar, goals);
+        activity_generator::get_budget_top_up_week_activities(&calendar, goals);
     activity_placer::place(&mut calendar, top_up_week_budget_activities);
     //TODO: Test that day stays below min or max when week max being reachd
 
+    //TODO: Fit simple budget activities into scheduled budgets?
+    //      No need, as simple budget activities will share the same overlay, but with less hours
+    //      Thus, the flex will always be higher than (or equal to?) the MinDayBudget activities
+    //      So MinDayBudget will get chosen last unless flex is equal and order happens to favor MinDayBudget
+    //          => TODO: order activities before placing?
+
+    calendar.log_impossible_base_activities(base_activities);
+
     calendar.print()
 }

src/models/activity.rs

@@ -21,10 +21,10 @@ pub struct Activity {
     pub min_block_size: usize,
     pub max_block_size: usize,
     pub calendar_overlay: Vec<Option<Weak<Hour>>>,
-    pub time_budgets: Vec<TimeBudget>,
     pub total_duration: usize,
     pub duration_left: usize,
     pub status: Status,
+    pub deadline: NaiveDateTime,
 }
 impl Activity {
     pub fn get_compatible_hours_overlay(
@@ -138,9 +138,10 @@ impl Activity {
                 //TODO: shouldn't this logic be in creating the activity and then set to min_block_size so we can just use that here?
                 let offset_size: usize = match self.activity_type {
                     ActivityType::SimpleGoal => self.total_duration,
-                    ActivityType::Budget => self.min_block_size,
+                    ActivityType::BudgetMinDay => self.min_block_size,
                     ActivityType::GetToMinWeekBudget => 1,
                     ActivityType::TopUpWeekBudget => 1,
+                    ActivityType::SimpleFiller => self.total_duration,
                 };
                 for offset in 0..offset_size {
                     match &self.calendar_overlay[hour_index + offset] {
@@ -178,17 +179,8 @@ impl Activity {
         best_scheduling_index_and_conflicts.map(|(best_index, _, size)| (best_index, size))
     }
 
-    pub(crate) fn get_activities_from_simple_goal(
-        goal: &Goal,
-        calendar: &Calendar,
-        parent_goal: Option<Goal>,
-    ) -> Vec<Activity> {
-        if goal.children.is_some() || goal.filters.as_ref().is_some() {
-            return vec![];
-        }
-
-        let (adjusted_goal_start, adjusted_goal_deadline) =
-            goal.get_adj_start_deadline(calendar, parent_goal);
+    pub(crate) fn get_simple_activities(goal: &Goal, calendar: &Calendar) -> Vec<Activity> {
+        let (adjusted_goal_start, adjusted_goal_deadline) = goal.get_adj_start_deadline(calendar);
         let mut activities: Vec<Activity> = Vec::with_capacity(1);
 
         if let Some(activity_total_duration) = goal.min_duration {
@@ -216,10 +208,10 @@ impl Activity {
                 min_block_size,
                 max_block_size: min_block_size,
                 calendar_overlay: compatible_hours_overlay,
-                time_budgets: vec![],
                 total_duration: activity_total_duration,
                 duration_left: activity_total_duration,
                 status: Status::Unprocessed,
+                deadline: goal.deadline,
             };
             dbg!(&activity);
             activities.push(activity);
@@ -228,10 +220,7 @@ impl Activity {
         activities
     }
 
-    pub(crate) fn get_activities_from_budget_goal(
-        goal: &Goal,
-        calendar: &Calendar,
-    ) -> Vec<Activity> {
+    pub(crate) fn get_budget_min_day_activities(goal: &Goal, calendar: &Calendar) -> Vec<Activity> {
         if goal.filters.as_ref().is_none() {
             return vec![];
         }
@@ -240,8 +229,7 @@ impl Activity {
                 return vec![];
             }
         }
-        let (adjusted_goal_start, adjusted_goal_deadline) =
-            goal.get_adj_start_deadline(calendar, None);
+        let (adjusted_goal_start, adjusted_goal_deadline) = goal.get_adj_start_deadline(calendar);
         let mut activities: Vec<Activity> = Vec::with_capacity(1);
 
         for day in 0..(adjusted_goal_deadline - adjusted_goal_start).num_days() as u64 {
@@ -277,15 +265,15 @@ impl Activity {
 
                     let activity = Activity {
                         goal_id: goal.id.clone(),
-                        activity_type: ActivityType::Budget,
+                        activity_type: ActivityType::BudgetMinDay,
                         title: goal.title.clone(),
                         min_block_size: adjusted_min_block_size,
                         max_block_size: config.max_per_day,
                         calendar_overlay: compatible_hours_overlay,
-                        time_budgets: vec![],
                         total_duration: adjusted_min_block_size,
                         duration_left: config.min_per_day,
                         status: Status::Unprocessed,
+                        deadline: goal.deadline,
                     };
                     dbg!(&activity);
                     activities.push(activity);
@@ -324,10 +312,10 @@ impl Activity {
             min_block_size: 1,
             max_block_size: max_hours,
             calendar_overlay: compatible_hours_overlay,
-            time_budgets: vec![],
             total_duration: max_hours,
             duration_left: max_hours,
             status: Status::Unprocessed,
+            deadline: goal_to_use.deadline,
         });
 
         activities
@@ -363,10 +351,10 @@ impl Activity {
             min_block_size: 1,
             max_block_size: max_hours,
             calendar_overlay: compatible_hours_overlay,
-            time_budgets: vec![],
             total_duration: max_hours,
             duration_left: max_hours,
             status: Status::Unprocessed,
+            deadline: goal_to_use.deadline,
         });
 
         activities
@@ -468,6 +456,7 @@ impl Activity {
             self.status = Status::Impossible;
         }
     }
+
     pub(crate) fn release_claims(&mut self) {
         let mut empty_overlay: Vec<Option<Weak<Hour>>> =
             Vec::with_capacity(self.calendar_overlay.capacity());
@@ -477,16 +466,11 @@ impl Activity {
         self.calendar_overlay = empty_overlay;
     }
 
-    pub(crate) fn get_filler_activities_from_simple_goal(
-        goal: &Goal,
-        calendar: &Calendar,
-        parent_goal: Option<Goal>,
-    ) -> Vec<Activity> {
+    pub(crate) fn get_simple_filler_activities(goal: &Goal, calendar: &Calendar) -> Vec<Activity> {
         if goal.children.is_none() || goal.filters.as_ref().is_some() {
             return vec![];
         }
-        let (adjusted_goal_start, adjusted_goal_deadline) =
-            goal.get_adj_start_deadline(calendar, parent_goal);
+        let (adjusted_goal_start, adjusted_goal_deadline) = goal.get_adj_start_deadline(calendar);
         let mut activities: Vec<Activity> = Vec::with_capacity(1);
 
         if let Some(activity_total_duration) = goal.min_duration {
@@ -509,15 +493,15 @@ impl Activity {
 
             let activity = Activity {
                 goal_id: goal.id.clone(),
-                activity_type: ActivityType::SimpleGoal,
+                activity_type: ActivityType::SimpleFiller,
                 title: goal.title.clone(),
                 min_block_size,
                 max_block_size: min_block_size,
                 calendar_overlay: compatible_hours_overlay,
-                time_budgets: vec![],
                 total_duration: activity_total_duration,
                 duration_left: activity_total_duration,
                 status: Status::Unprocessed,
+                deadline: goal.deadline,
             };
             dbg!(&activity);
             activities.push(activity);
@@ -538,9 +522,10 @@ pub enum Status {
 #[derive(Clone, Debug, PartialEq)]
 pub enum ActivityType {
     SimpleGoal,
-    Budget,
+    BudgetMinDay,
     GetToMinWeekBudget,
     TopUpWeekBudget,
+    SimpleFiller,
 }
 
 impl fmt::Debug for Activity {

src/models/budget.rs

@@ -46,7 +46,7 @@ impl Budget {
                 ActivityType::SimpleGoal => {
                     budget_cut_off_number = time_budget.min_scheduled;
                 }
-                ActivityType::Budget => {
+                ActivityType::BudgetMinDay => {
                     budget_cut_off_number = time_budget.min_scheduled;
                 }
                 ActivityType::GetToMinWeekBudget => {
@@ -61,6 +61,7 @@ impl Budget {
                 ActivityType::TopUpWeekBudget => {
                     budget_cut_off_number = time_budget.max_scheduled;
                 }
+                ActivityType::SimpleFiller => budget_cut_off_number = time_budget.min_scheduled,
             }
             //figure out how many of the hours in hour_index till hour_index + offset are in the time_budget window
             let mut hours_in_time_budget_window = 0;

src/models/calendar.rs

@@ -1,3 +1,4 @@
+use super::activity::Activity;
 use super::budget::{get_time_budgets_from, Budget, TimeBudgetType};
 use super::goal::Goal;
 use super::task::{DayTasks, FinalTasks, Task};
@@ -70,6 +71,15 @@ impl Calendar {
         date_time_of_index_to_test.weekday()
     }
 
+    pub fn is_budget(&self, goal_id: String) -> bool {
+        for budget in self.budgets.iter() {
+            if budget.participating_goals.contains(&goal_id) {
+                return true;
+            }
+        }
+        false
+    }
+
     pub fn get_index_of(&self, date_time: NaiveDateTime) -> usize {
         if date_time < self.start_date_time.sub(Duration::days(1))
             || date_time > self.end_date_time.add(Duration::days(1))
@@ -294,6 +304,21 @@ impl Calendar {
         self.impossible_activities.extend(impossible_activities);
     }
 
+    pub fn log_impossible_base_activities(&mut self, activities: Vec<Activity>) {
+        for activity in activities {
+            if activity.status == super::activity::Status::Impossible
+                && activity.deadline.year() != 1970
+            {
+                self.impossible_activities.push(ImpossibleActivity {
+                    id: activity.goal_id.clone(),
+                    hours_missing: activity.duration_left,
+                    period_start_date_time: self.start_date_time,
+                    period_end_date_time: self.end_date_time,
+                })
+            }
+        }
+    }
+
     fn impossible_activities(&mut self) -> Vec<ImpossibleActivity> {
         let mut impossible_activities = vec![];
         for budget in &self.budgets {

src/models/goal.rs

@@ -46,11 +46,7 @@ pub struct BudgetConfig {
 }
 
 impl Goal {
-    pub fn get_adj_start_deadline(
-        &self,
-        calendar: &Calendar,
-        parent_goal: Option<Goal>,
-    ) -> (NaiveDateTime, NaiveDateTime) {
+    pub fn get_adj_start_deadline(&self, calendar: &Calendar) -> (NaiveDateTime, NaiveDateTime) {
         let mut adjusted_goal_start = self.start;
         if self.start.year() == 1970 || self.start < calendar.start_date_time {
             adjusted_goal_start = calendar.start_date_time;
@@ -60,18 +56,6 @@ impl Goal {
             adjusted_goal_deadline = calendar.end_date_time;
         }
 
-        // Make sure child goal not fall outside of parent goal start and deadline
-        if let Some(parent_goal) = parent_goal {
-            // means this is a child goal
-            if adjusted_goal_start < parent_goal.start {
-                adjusted_goal_start = parent_goal.start;
-            }
-            if adjusted_goal_deadline > parent_goal.deadline && parent_goal.deadline.year() != 1970
-            {
-                adjusted_goal_deadline = parent_goal.deadline;
-            }
-        }
-
         if self.filters.is_none() {
             return (adjusted_goal_start, adjusted_goal_deadline);
         }