praytimes 1.1.0

Muslim prayer times calculation
Documentation 
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

use crate::internal_calculator;
use crate::types::{Location, Parameters, PraytimesOutput, TuneOffsets};
use crate::utils::julian_date::to_julian_date;
use chrono::{NaiveDate, NaiveDateTime};

/// Main public api for the prayertimes calculation
#[derive(Debug, Clone)]
pub struct Calculator {
    params: Parameters,
    tuning_offsets: TuneOffsets,
}

impl Calculator {
    /// Calculate the prayertimes in a given location and a given date
    pub fn calculate(&self, location: &Location, date: &NaiveDate) -> PraytimesOutput {
        let calculator = internal_calculator::InternalCalculator {
            date: &date,
            location: &location,
            params: &self.params,
            julian_date: to_julian_date(date, location),
        };
        let times = calculator.calculate();
        self.tune(times)
    }
    fn tune(&self, times: PraytimesOutput) -> PraytimesOutput {
        PraytimesOutput {
            imsak: Self::tune_time(times.imsak, self.tuning_offsets.imsak),
            fajr: Self::tune_time(times.fajr, self.tuning_offsets.fajr),
            dhuhr: Self::tune_time(times.dhuhr, self.tuning_offsets.dhuhr),
            asr: Self::tune_time(times.asr, self.tuning_offsets.asr),
            sunset: Self::tune_time(times.sunset, self.tuning_offsets.sunset),
            maghrib: Self::tune_time(times.maghrib, self.tuning_offsets.maghrib),
            isha: Self::tune_time(times.isha, self.tuning_offsets.isha),
            midnight: Self::tune_time(times.midnight, self.tuning_offsets.midnight),
            sunrise: Self::tune_time(times.sunrise, self.tuning_offsets.sunrise),
        }
    }
    fn tune_time(time: Option<NaiveDateTime>, offset: Option<f64>) -> Option<NaiveDateTime> {
        match (time, offset) {
            (Some(time), Some(o)) => NaiveDateTime::from_timestamp_millis(
                time.timestamp_millis() + (o * 60.0 * 1000.0) as i64,
            ),
            _ => time,
        }
    }
    /// Create new calculator based on input parameters ( can be grabbed from praytimes::methods as well or manually used)
    /// There is also a tuning offsets input so you can specify how the times are get tuned after calculation for precaution
    pub fn new(params: Parameters, tuning_offsets: TuneOffsets) -> Self {
        Self {
            params,
            tuning_offsets,
        }
    }
}