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
149
150
151
152
153

#[cfg(test)]
#[path = "../../tests/unit/validation/jobs_test.rs"]
mod jobs_test;

use super::*;
use crate::extensions::MultiDimensionalCapacity;

/// Checks that plan has no jobs with duplicate ids.
fn check_e1100_no_jobs_with_duplicate_ids(ctx: &ValidationContext) -> Result<(), FormatError> {
    get_duplicates(ctx.jobs().map(|job| &job.id)).map_or(Ok(()), |ids| {
        Err(FormatError::new(
            "E1100".to_string(),
            "duplicated job ids".to_string(),
            format!("remove duplicated jobs with for the ids: '{}'", ids.join(", ")),
        ))
    })
}

/// Checks that jobs have proper demand.
fn check_e1101_correct_job_types_demand(ctx: &ValidationContext) -> Result<(), FormatError> {
    let ids = ctx
        .jobs()
        .filter(|job| {
            job.pickups
                .as_ref()
                .iter()
                .chain(job.deliveries.as_ref().iter())
                .chain(job.replacements.as_ref().iter())
                .flat_map(|tasks| tasks.iter())
                .any(|task| task.demand.is_none())
                || job.services.iter().flat_map(|tasks| tasks.iter()).any(|task| task.demand.is_some())
        })
        .map(|job| job.id.clone())
        .collect::<Vec<_>>();

    if ids.is_empty() {
        Ok(())
    } else {
        Err(FormatError::new(
            "E1101".to_string(),
            "invalid job task demand".to_string(),
            format!("correct demand based on job task type for jobs: '{}'", ids.join(", ")),
        ))
    }
}

/// Checks that sum of pickup/delivery demand should be equal.
fn check_e1102_multiple_pickups_deliveries_demand(ctx: &ValidationContext) -> Result<(), FormatError> {
    let has_tasks = |tasks: &Option<Vec<JobTask>>| tasks.as_ref().map_or(false, |tasks| tasks.len() > 0);
    let get_demand = |tasks: &Option<Vec<JobTask>>| {
        if let Some(tasks) = tasks {
            tasks
                .iter()
                .map(|task| {
                    task.demand.clone().map_or_else(
                        || MultiDimensionalCapacity::default(),
                        |demand| MultiDimensionalCapacity::new(demand),
                    )
                })
                .sum()
        } else {
            MultiDimensionalCapacity::default()
        }
    };

    let ids = ctx
        .jobs()
        .filter(|job| has_tasks(&job.pickups) && has_tasks(&job.deliveries))
        .filter(|job| get_demand(&job.pickups) - get_demand(&job.deliveries) != MultiDimensionalCapacity::default())
        .map(|job| job.id.clone())
        .collect::<Vec<_>>();

    if ids.is_empty() {
        Ok(())
    } else {
        Err(FormatError::new(
            "E1102".to_string(),
            "invalid pickup and delivery demand".to_string(),
            format!("correct demand so that sum of pickups equal to sum of deliveries, jobs: '{}'", ids.join(", ")),
        ))
    }
}

/// Checks that job's time windows are correct.
fn check_e1103_time_window_correctness(ctx: &ValidationContext) -> Result<(), FormatError> {
    let has_invalid_tws = |tasks: &Option<Vec<JobTask>>| {
        tasks.as_ref().map_or(false, |tasks| {
            tasks
                .iter()
                .flat_map(|task| task.places.iter())
                .filter_map(|place| place.times.as_ref())
                .any(|tws| !check_raw_time_windows(tws, false))
        })
    };

    let ids = ctx
        .jobs()
        .filter(|job| has_invalid_tws(&job.pickups) || has_invalid_tws(&job.deliveries))
        .map(|job| job.id.clone())
        .collect::<Vec<_>>();

    if ids.is_empty() {
        Ok(())
    } else {
        Err(FormatError::new(
            "E1103".to_string(),
            "invalid time windows in jobs".to_string(),
            format!("change job task place time windows so that they don't intersect, jobs: '{}'", ids.join(", ")),
        ))
    }
}

/// Checks that reserved job ids are no used.
fn check_e1104_no_reserved_ids(ctx: &ValidationContext) -> Result<(), FormatError> {
    let ids = ctx.jobs().filter(|job| is_reserved_job_id(&job.id)).map(|job| job.id.clone()).collect::<Vec<_>>();

    if ids.is_empty() {
        Ok(())
    } else {
        Err(FormatError::new(
            "E1104".to_string(),
            "reserved job id is used".to_string(),
            format!("change job id from reserved: jobs: '{}'", ids.join(", ")),
        ))
    }
}

/// Checks that job has at least one job task.
fn check_e1105_empty_jobs(ctx: &ValidationContext) -> Result<(), FormatError> {
    let ids = ctx.jobs().filter(|job| ctx.tasks(job).is_empty()).map(|job| job.id.clone()).collect::<Vec<_>>();

    if ids.is_empty() {
        Ok(())
    } else {
        Err(FormatError::new(
            "E1105".to_string(),
            "empty job".to_string(),
            format!("add at least one job task: ids '{}'", ids.join(", ")),
        ))
    }
}

/// Validates jobs from the plan.
pub fn validate_jobs(ctx: &ValidationContext) -> Result<(), Vec<FormatError>> {
    combine_error_results(&[
        check_e1100_no_jobs_with_duplicate_ids(ctx),
        check_e1101_correct_job_types_demand(ctx),
        check_e1102_multiple_pickups_deliveries_demand(ctx),
        check_e1103_time_window_correctness(ctx),
        check_e1104_no_reserved_ids(ctx),
        check_e1105_empty_jobs(ctx),
    ])
}