zinzen 0.3.0

Algorithm for auto-scheduling time-constrained tasks on a timeline
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::models::activity::{ActivityStatus, ActivityType};
use crate::models::interval::Interval;
use crate::models::task::TaskCompletedToday;
use crate::models::{activity::Activity, budget::TimeBudgetType, calendar::Calendar, goal::Goal};
use crate::technical::error::SchedulerError;
use std::collections::BTreeMap;

pub fn add_budget_min_week_activities(calendar: &Calendar, activities: &mut Vec<Activity>) {
    crate::log_debug!("Adding budget min week activities...");
    let mut get_to_week_min_budget_activities = vec![];
    for budget in &calendar.budgets {
        let mut is_min_week_reached = true;
        for time_budget in &budget.time_budgets {
            if time_budget.time_budget_type != TimeBudgetType::Week {
                continue;
            }
            if time_budget.scheduled < time_budget.min_scheduled {
                is_min_week_reached = false;
            }
        }
        if !is_min_week_reached {
            for time_budget in &budget.time_budgets {
                if time_budget.time_budget_type == TimeBudgetType::Week
                    && time_budget.scheduled < time_budget.min_scheduled
                {
                    get_to_week_min_budget_activities.extend(
                        Activity::get_activities_to_get_min_week_budget(
                            budget,
                            calendar,
                            time_budget,
                        ),
                    );
                }
            }
        }
    }
    crate::log_dbg!(&get_to_week_min_budget_activities);
    activities.extend(get_to_week_min_budget_activities);
}

pub fn add_budget_top_up_week_activities(calendar: &Calendar, activities: &mut Vec<Activity>) {
    crate::log_debug!("Adding budget top up week activities...");
    let mut top_up_activities = vec![];
    for budget in &calendar.budgets {
        let mut max_per_week = 0;
        for time_budget in &budget.time_budgets {
            if time_budget.time_budget_type == TimeBudgetType::Week
                && time_budget.scheduled != time_budget.max_scheduled
            {
                max_per_week = time_budget.max_scheduled;
            }
        }
        for time_budget in &budget.time_budgets {
            if time_budget.time_budget_type == TimeBudgetType::Period
                && time_budget.min_scheduled < time_budget.max_scheduled
                && time_budget.scheduled < time_budget.max_scheduled
            {
                top_up_activities.extend(Activity::get_activities_to_top_up_week_budget(
                    budget,
                    calendar,
                    time_budget,
                    max_per_week,
                ));
            }
        }
    }
    crate::log_dbg!(&top_up_activities);
    activities.extend(top_up_activities);
}

pub(crate) fn add_simple_activities(
    calendar: &mut Calendar,
    goals: &BTreeMap<String, Goal>,
    activities: &mut Vec<Activity>,
) -> Result<(), SchedulerError> {
    crate::log_debug!("Adding simple activities...");
    let mut simple_activities = vec![];
    for goal in goals.values() {
        if goal.min_duration.is_none() {
            continue;
        };
        simple_activities.extend(Activity::get_simple_activities(goal, calendar));
    }
    activities.extend(simple_activities);
    Ok(())
}

pub(crate) fn add_budget_min_day_activities(
    calendar: &mut Calendar,
    activities: &mut Vec<Activity>,
) {
    crate::log_debug!("Adding budget min day/period activities...");
    let mut min_day_activities = vec![];
    for budget in &calendar.budgets {
        for time_budget in &budget.time_budgets {
            if time_budget.time_budget_type == TimeBudgetType::Week {
                continue;
            }
            if time_budget.scheduled < time_budget.min_scheduled {
                min_day_activities.extend(Activity::get_activities_to_get_to_min_day_budget(
                    budget,
                    calendar,
                    time_budget,
                ));
            }
        }
    }
    crate::log_dbg!(&min_day_activities);
    activities.extend(min_day_activities);
}

pub(crate) fn add_tasks_completed_today(
    calendar: &Calendar,
    goals: &BTreeMap<String, Goal>,
    tasks_completed_today: &[TaskCompletedToday],
    activities: &mut Vec<Activity>,
) {
    crate::log_debug!("Adding tasks completed today...");
    for task in tasks_completed_today {
        let Some(goal) = goals.get(&task.goalid) else {
            continue;
        };
        let start_index = calendar.get_index_of(task.start);
        let end_index = calendar.get_index_of(task.deadline);
        let duration = end_index.saturating_sub(start_index);
        if duration == 0 {
            continue;
        }
        activities.push(Activity {
            goal_id: goal.id.clone(),
            activity_type: ActivityType::SimpleGoal,
            title: goal.title.clone(),
            min_block_size: duration,
            max_block_size: duration,
            total_duration: duration,
            duration_left: duration,
            status: ActivityStatus::Unprocessed,
            start: task.start,
            deadline: Some(task.deadline),
            compatible_intervals: vec![Interval {
                start: start_index,
                end: end_index,
            }],
            incompatible_intervals: vec![],
            flex: Some(1),
        });
    }
}