Struct Productivity 

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

Productivity calculator with comprehensive work time analysis.

This structure holds all the data needed for accurate productivity calculations, including workday timing, manual breaks, different categories of pauses, and configuration settings. It provides the central calculation logic used throughout the application.

Data Categories

• Workday: Start/end times defining the total work session
• Breaks: Manual breaks explicitly added by the user
• Short Pauses: Automatic pauses below the minimum threshold (not stored in DB)
• Long Pauses: Automatic pauses above the minimum threshold (stored in DB)
• Config: Productivity configuration settings and thresholds

Usage Pattern

1. Create instance with Productivity::new() - automatically loads all relevant data
2. Call calculate_productivity() for the main productivity percentage
3. Use helper methods for break recommendations and analysis (now parameter-free)

Fields

workday: Workday

The workday record containing start/end times

breaks: Vec<Break>

Manual breaks explicitly added by the user

short_pauses: Vec<Pause>

Short automatic pauses (< min_pause_duration, not in database)

long_pauses: Vec<Pause>

Long automatic pauses (>= min_pause_duration, stored in database)

config: ProductivityConfig

Productivity configuration settings and thresholds

Implementations

impl Productivity

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

Creates a new productivity calculator for the given workday.

This constructor automatically loads all relevant data for productivity calculations:

• Reads the current configuration to get pause duration thresholds
• Loads manual breaks from the database for the workday date
• Loads short pauses (below min_pause_duration threshold)
• Loads long pauses (at or above min_pause_duration threshold)

The pause categorization is based on the min_pause_duration setting from the monitor configuration. This threshold determines which pauses are stored in the database vs. calculated on-the-fly.

Arguments

• workday - The workday record to analyze

Returns

Returns a configured Productivity instance with all data loaded.

Errors

Returns an error if:

• Configuration file cannot be read
• Database queries fail
• Data integrity issues are encountered

Examples

let productivity = Productivity::new(&workday)?;
let current_productivity = productivity.calculate_productivity();
println!("Current productivity: {:.1}%", current_productivity);

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

Creates a productivity calculator with provided test data.

This constructor is primarily intended for testing scenarios where you want to provide specific pause and break data without database dependencies. It uses default productivity configuration settings.

Arguments

• workday - The workday record to analyze
• breaks - Manual breaks to include in calculations
• short_pauses - Short automatic pauses (< threshold)
• long_pauses - Long automatic pauses (>= threshold)

Examples

let productivity = Productivity::with_test_data(
    &workday,
    vec![],
    vec![],
    vec![]
);
let result = productivity.calculate_productivity();

pub fn calculate_needed_break_duration( &self, target_productivity: Option<f64>, ) -> u64

Calculates the break duration needed to reach target productivity.

This function determines how many minutes of manual breaks need to be added to achieve a specific productivity threshold. This is used for generating break recommendations when productivity falls below acceptable levels.

Calculation Logic

The function works backwards from the target productivity:

1. Calculate current net work time and gross time using internal data
2. Determine required available work time for target productivity
3. Calculate needed break duration to achieve that available work time
4. Account for existing manual breaks in the calculation

Productivity Improvement Strategy

By adding manual breaks:

• Gross time: Remains the same (workday boundaries unchanged)
• Available work time: Decreases (manual breaks excluded)
• Net work time: Decreases slightly (existing pauses unchanged)
• Productivity ratio: Improves (net/available increases)

Data Sources

This method uses data already loaded in the struct:

• self.workday for timing boundaries
• self.long_pauses for pause calculations
• self.breaks for existing manual breaks
• self.config.min_productivity_threshold as the default target

Arguments

• target_productivity - Optional desired productivity percentage (0.0-100.0). If None, uses the configured minimum productivity threshold.

Returns

Returns the number of minutes of breaks needed to reach the target, or 0 if the target is already achieved or impossible to reach.

Examples

let productivity = Productivity::new(&workday)?;

// Use default threshold from config
let needed_minutes = productivity.calculate_needed_break_duration(None);

// Use custom threshold
let needed_minutes = productivity.calculate_needed_break_duration(Some(75.0));

if needed_minutes > 0 {
    println!("Add {} minutes of breaks to improve productivity", needed_minutes);
}

pub fn should_suggest_productivity_improvements(&self) -> bool

Check if productivity suggestions should be made based on workday progress.

This function determines whether enough of the workday has passed to make meaningful productivity recommendations. It prevents premature suggestions when the workday has just started.

Configuration Sources

This method uses configuration data already loaded in the struct:

• self.config.workday_hours for expected workday duration
• self.config.min_workday_fraction_before_suggest for minimum elapsed fraction
• self.workday.start for timing calculations

Returns

true if suggestions should be made, false otherwise

Examples

let productivity = Productivity::new(&workday)?;
if productivity.should_suggest_productivity_improvements() {
    // Make productivity recommendations
}

pub fn check_productivity_recommendations(&self) -> Option<u64>

Check if productivity recommendations should be shown and calculate needed break duration.

This function combines productivity checking with break duration calculation to provide a complete recommendation system. It checks if suggestions should be made and calculates the break duration needed to reach the target productivity threshold.

Self-Contained Logic

This method uses all data already loaded in the struct:

• self.config for productivity thresholds and timing rules
• self.workday for timing calculations
• self.long_pauses and self.breaks for break calculations
• Internal methods for consistent calculations

Decision Flow

1. Timing Check: Verify enough workday time has elapsed
2. Productivity Check: Calculate current productivity level
3. Threshold Check: Compare against minimum acceptable productivity
4. Recommendation Calculation: Determine needed break duration
5. Feasibility Check: Ensure recommendation is practical

Returns

Returns Some(needed_minutes) if recommendations should be shown, None if productivity is acceptable or recommendations shouldn’t be made yet.

Examples

let productivity = Productivity::new(&workday)?;

if let Some(needed_minutes) = productivity.check_productivity_recommendations() {
    println!("Consider adding {} minutes of breaks", needed_minutes);
}

pub fn calculate_productivity(&self) -> f64

Calculates productivity percentage for the workday.

This is the central productivity calculation method that properly handles different types of work interruptions to provide accurate productivity metrics. The method implements a sophisticated calculation that distinguishes between various types of time allocation.

Calculation Logic

The productivity calculation follows this formula:

Productivity = (Net Work Time / Available Work Time) * 100

Where:
- Gross Duration = End Time - Start Time
- Available Work Time = Gross Duration - Manual Breaks - Long Pauses  
- Net Work Time = Available Work Time - Short Pauses (adjusted for overlaps)

Time Categories

1. Manual Breaks: User-defined break periods (excluded from work time)
2. Long Pauses: Automatic pauses >= min_pause_duration (recorded in DB)
3. Short Pauses: Automatic pauses < min_pause_duration (not recorded in DB)
4. Active Work: Time when user is actively working

Overlap Handling

Short pauses are adjusted to avoid double-counting time that’s already accounted for in manual breaks:

• If short_pause_duration <= break_duration: Set short pauses to zero
• Otherwise: Subtract break duration from short pauses

Edge Cases

• Returns 0.0% if no available work time exists
• Clamps result between 0.0% and 100.0% to handle calculation edge cases
• Handles ongoing workdays by using current time as end time

Returns

Productivity percentage as a float between 0.0 and 100.0.

Examples

let productivity = productivity_instance.calculate_productivity();

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