Project data#

use plen_core::{
    schedule, DateTime, LinkData, LinkType, ProjectData, SolveOptions, TaskData, TaskType,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    // A summary with no dates: its span comes from its children.
    let mut phase = TaskData::new("phase");
    phase.task_type = TaskType::Summary;

    let mut design = TaskData::new("design");
    design.parent = Some("phase".into());
    design.start_date = Some(monday);
    design.duration = Some(3.0);

    let mut build = TaskData::new("build");
    build.parent = Some("phase".into());
    build.start_date = Some(monday);
    build.duration = Some(5.0);

    // A milestone needs only one date.
    let mut release = TaskData::new("release");
    release.task_type = TaskType::Milestone;
    release.start_date = Some(monday);

    let data = ProjectData {
        tasks: vec![phase, design, build, release],
        links: vec![
            LinkData {
                id: "l1".into(),
                source: "design".into(),
                target: "build".into(),
                link_type: LinkType::Fs,
                lag: 0.0,
                lag_unit: None,
            },
            LinkData {
                id: "l2".into(),
                source: "build".into(),
                target: "release".into(),
                link_type: LinkType::Fs,
                lag: 0.0,
                lag_unit: None,
            },
        ],
        ..Default::default()
    };

    let result = schedule(data, &SolveOptions::default())?;
    for update in &result.updates {
        if let (Some(start), Some(end)) = (update.start_date, update.end_date) {
            println!("{}: {start} .. {end}", update.id);
        }
    }
    Ok(())
}

use plen_core::Id;

fn main() {
    let numeric: Id = 1.into();
    let text = Id::from("1");
    assert_eq!(numeric, text);

    // -0 and 0 share the key "0".
    assert_eq!(Id::from(-0.0), Id::from("0"));

    println!("{numeric}"); // prints the key: 1
}

use chrono::{NaiveDate, NaiveDateTime};
use plen_core::DateTime;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let a = DateTime::from_ymd_hm(2026, 3, 2, 9, 30).ok_or("invalid date")?;

    let naive = NaiveDate::from_ymd_opt(2026, 3, 2)
        .and_then(|day| day.and_hms_opt(9, 30, 45))
        .ok_or("invalid date")?;
    let b = DateTime::from(naive); // 09:30:45 becomes 09:30
    assert_eq!(a, b);

    println!("{a}"); // 2026-03-02 09:30
    let back: NaiveDateTime = a.into();
    println!("{back}");
    Ok(())
}

use plen_core::{
    schedule, DateTime, ProjectData, SchedulingConfig, SolveOptions, TaskData, TimeUnit,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    // 12 working hours: the default calendar works 08-12 and 13-17.
    let mut review = TaskData::new("review");
    review.start_date = Some(monday);
    review.duration = Some(12.0);

    // This task counts in minutes instead of the project's hours.
    let mut sync = TaskData::new("sync");
    sync.start_date = Some(monday);
    sync.duration = Some(90.0);
    sync.duration_unit = Some(TimeUnit::Minute);

    let data = ProjectData {
        config: SchedulingConfig {
            duration_unit: TimeUnit::Hour,
            ..Default::default()
        },
        tasks: vec![review, sync],
        ..Default::default()
    };

    let result = schedule(data, &SolveOptions::default())?;
    println!("{} updates", result.updates.len());
    Ok(())
}

use plen_core::{
    schedule, DateTime, LinkData, LinkType, Note, ProjectData, SolveOptions, TaskData, TimeUnit,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;
    let task = |id: &str| {
        let mut t = TaskData::new(id);
        t.start_date = Some(monday);
        t.duration = Some(2.0);
        t
    };

    let links = vec![
        // b starts 1 working day after a starts.
        LinkData {
            id: "ss".into(),
            source: "a".into(),
            target: "b".into(),
            link_type: LinkType::Ss,
            lag: 1.0,
            lag_unit: None,
        },
        // c finishes 4 working hours after b finishes.
        LinkData {
            id: "ff".into(),
            source: "b".into(),
            target: "c".into(),
            link_type: LinkType::Ff,
            lag: 4.0,
            lag_unit: Some(TimeUnit::Hour),
        },
        // Points at a task that doesn't exist: dropped, not an error.
        LinkData {
            id: "stray".into(),
            source: "c".into(),
            target: "missing".into(),
            link_type: LinkType::Fs,
            lag: 0.0,
            lag_unit: None,
        },
    ];

    let data = ProjectData {
        tasks: vec![task("a"), task("b"), task("c")],
        links,
        ..Default::default()
    };

    let result = schedule(data, &SolveOptions::default())?;
    for note in &result.notes {
        if let Note::DroppedLink { link, reason } = note {
            println!("link {link} dropped: {reason}");
        }
    }
    Ok(())
}

use plen_core::{
    schedule, DateTime, Note, ProjectData, SchedulingConfig, SolveOptions, TaskData,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    let mut done = TaskData::new("done");
    done.start_date = Some(monday);
    done.duration = Some(2.0);
    done.progress = 1.0; // completed, because use_progress is on

    let mut pinned = TaskData::new("pinned");
    pinned.start_date = Some(monday);
    pinned.duration = Some(1.0);
    pinned.auto_scheduling = false; // fixed

    let mut later = TaskData::new("later");
    later.unscheduled = true; // no dates needed

    let data = ProjectData {
        config: SchedulingConfig {
            use_progress: true,
            ..Default::default()
        },
        tasks: vec![done, pinned, later],
        ..Default::default()
    };

    let result = schedule(data, &SolveOptions::default())?;
    for note in &result.notes {
        if let Note::DroppedTask { task, reason } = note {
            println!("task {task}: {reason}"); // task later: unscheduled
        }
    }
    Ok(())
}

use plen_core::{
    schedule, CalendarMode, DateTime, GapBehavior, Id, ProjectData, SchedulingConfig,
    SolveOptions, TaskData, TimeUnit,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let kickoff = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    let config = SchedulingConfig {
        apply_constraints: true,           // constraints act as hard bounds
        gap_behavior: GapBehavior::Compress, // pull tasks to their earliest
        duration_unit: TimeUnit::Hour,
        project_start: Some(kickoff),      // nothing starts before this
        calendar_mode: CalendarMode::Task, // task calendars only, as gantt does
        root_id: Id::from(-1),             // gantt data with a virtual root of -1
        ..Default::default()
    };

    let mut task = TaskData::new(1);
    task.parent = Some(Id::from(-1)); // equals root_id: no parent
    task.start_date = Some(kickoff);
    task.duration = Some(4.0);

    let data = ProjectData {
        config,
        tasks: vec![task],
        ..Default::default()
    };
    schedule(data, &SolveOptions::default())?;
    Ok(())
}

use plen_core::{schedule, DateTime, Error, ProjectData, SolveOptions, TaskData};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    let mut ok = TaskData::new("ok");
    ok.start_date = Some(monday);
    ok.duration = Some(1.0);

    let mut broken = TaskData::new("broken");
    broken.duration = Some(2.0); // only one of start / end / duration

    let data = ProjectData {
        tasks: vec![ok, broken],
        ..Default::default()
    };

    match schedule(data, &SolveOptions::default()) {
        Err(Error::Input(e)) => {
            println!("{}: {}", e.path.as_deref().unwrap_or("-"), e.message);
        }
        Err(e) => return Err(e.into()),
        Ok(_) => println!("scheduled"),
    }
    Ok(())
}

use plen_core::{
    DateTime, Note, Project, ProjectData, ProjectOptions, SolveOptions, TaskData, Validation,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let monday = DateTime::from_ymd_hm(2026, 3, 2, 8, 0).ok_or("invalid date")?;

    let mut first = TaskData::new("a");
    first.start_date = Some(monday);
    first.duration = Some(1.0);

    // Same id again: in repair mode the last record wins.
    let mut second = TaskData::new("a");
    second.start_date = Some(monday);
    second.duration = Some(3.0);

    let mut project = Project::new(ProjectOptions {
        validation: Validation::Repair,
    });
    let data = ProjectData {
        tasks: vec![first, second],
        ..Default::default()
    };
    let result = project.solve(Some(data), &SolveOptions::default())?;
    for note in &result.notes {
        if let Note::Repaired { path, message } = note {
            println!("{path}: {message}");
        }
    }
    Ok(())
}