Struct Productivity 

pub struct Productivity {
    pub workday: Workday,
    pub short_pauses: Vec<Pause>,
    pub long_pauses: Vec<Pause>,
    pub config: ProductivityConfig,
}

The central productivity calculation, with the data it runs on.

The split into short and long pauses drives the whole formula: long pauses shrink the available time, short ones count against it.

Fields

workday: Workday

The workday record containing start/end times

short_pauses: Vec<Pause>

Short automatic pauses (< min_pause_duration, not in database)

long_pauses: Vec<Pause>

Long pauses (>= min_pause_duration, plus any manual protected pauses)

config: ProductivityConfig

Productivity configuration settings and thresholds

Implementations

impl Productivity

pub fn new(workday: &Workday) -> Result<Self>

Loads the workday’s pauses, split at min_pause_duration from the monitor config.

use kasl::libs::productivity::Productivity;
use kasl::db::workdays::Workdays;
use chrono::Local;

let mut workdays = Workdays::new()?;
let workday = workdays.fetch(Local::now().date_naive())?.unwrap();
let productivity = Productivity::new(&workday)?;
let current_productivity = productivity.calculate_productivity();
println!("Current productivity: {:.1}%", current_productivity);

pub fn with_test_data( workday: &Workday, short_pauses: Vec<Pause>, long_pauses: Vec<Pause>, ) -> Self

Builds a calculator from explicit data, bypassing config and database - for tests.

use kasl::libs::productivity::Productivity;
use kasl::db::workdays::Workday;
use chrono::Local;

let workday = Workday {
    id: 1,
    date: Local::now().date_naive(),
    start: Local::now().naive_local(),
    end: None,
};
let productivity = Productivity::with_test_data(
    &workday,
    vec![],
    vec![]
);
let result = productivity.calculate_productivity();

pub fn is_below_threshold(&self) -> bool

Reports whether productivity has fallen below the configured threshold.

The check is suppressed early in the day: a short elapsed period makes the ratio swing wildly on a single pause, so warning then would be noise. Once min_workday_fraction_before_suggest of the expected workday has passed, the figure is stable enough to act on.

pub fn calculate_productivity(&self) -> f64

Returns the day’s productivity percentage, clamped to 0-100.

(work - short pauses) / work, where work is the gross day minus long pauses. An ongoing day is measured up to now (via crate::libs::report::workday_end_time); a day with no work time yet reads 0.

use kasl::libs::productivity::Productivity;
use kasl::db::workdays::Workday;
use chrono::Local;

let workday = Workday {
    id: 1,
    date: Local::now().date_naive(),
    start: Local::now().naive_local(),
    end: None,
};
let productivity_instance = Productivity::with_test_data(&workday, vec![], vec![]);
let productivity = productivity_instance.calculate_productivity();

if productivity >= 75.0 {
    println!("Good productivity: {:.1}%", productivity);
} else {
    println!("Consider taking a break to improve focus");
}