reminder-bot/src/time_parser.rs

201 lines
5.5 KiB
Rust
Raw Normal View History

use std::time::{SystemTime, UNIX_EPOCH};
use std::fmt::{Display, Formatter, Result as FmtResult};
2020-09-01 14:34:50 +00:00
use crate::consts::{LOCAL_TIMEZONE, PYTHON_LOCATION};
use chrono::TimeZone;
use chrono_tz::Tz;
use std::convert::TryFrom;
use std::str::from_utf8;
use tokio::process::Command;
2020-09-01 14:34:50 +00:00
#[derive(Debug)]
pub enum InvalidTime {
ParseErrorDMY,
ParseErrorHMS,
ParseErrorDisplacement,
ParseErrorChrono,
}
impl Display for InvalidTime {
fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
write!(f, "InvalidTime: {:?}", self)
}
}
impl std::error::Error for InvalidTime {}
enum ParseType {
Explicit,
Displacement,
}
2020-09-01 14:34:50 +00:00
pub struct TimeParser {
timezone: Tz,
inverted: bool,
time_string: String,
parse_type: ParseType,
}
impl TryFrom<&TimeParser> for i64 {
type Error = InvalidTime;
fn try_from(value: &TimeParser) -> Result<Self, Self::Error> {
value.timestamp()
}
}
impl TimeParser {
pub fn new(input: &str, timezone: Tz) -> Self {
let inverted = input.starts_with('-');
let parse_type = if input.contains('/') || input.contains(':') {
ParseType::Explicit
} else {
ParseType::Displacement
};
Self {
timezone,
inverted,
time_string: input.trim_start_matches('-').to_string(),
parse_type,
}
}
2020-09-01 14:34:50 +00:00
pub fn timestamp(&self) -> Result<i64, InvalidTime> {
match self.parse_type {
ParseType::Explicit => Ok(self.process_explicit()?),
ParseType::Displacement => {
let now = SystemTime::now();
let since_epoch = now
.duration_since(UNIX_EPOCH)
.expect("Time calculated as going backwards. Very bad");
2020-09-01 14:34:50 +00:00
Ok(since_epoch.as_secs() as i64 + self.process_displacement()?)
}
2020-09-01 14:34:50 +00:00
}
}
pub fn displacement(&self) -> Result<i64, InvalidTime> {
match self.parse_type {
ParseType::Explicit => {
let now = SystemTime::now();
let since_epoch = now
.duration_since(UNIX_EPOCH)
.expect("Time calculated as going backwards. Very bad");
Ok(self.process_explicit()? - since_epoch.as_secs() as i64)
}
2020-09-01 14:34:50 +00:00
ParseType::Displacement => Ok(self.process_displacement()?),
}
}
2020-09-01 14:34:50 +00:00
fn process_explicit(&self) -> Result<i64, InvalidTime> {
let segments = self.time_string.matches('-').count();
2020-09-01 14:34:50 +00:00
let parse_string = if segments == 1 {
let slashes = self.time_string.matches('/').count();
2020-09-01 14:34:50 +00:00
match slashes {
0 => Ok("%d-".to_string()),
1 => Ok("%d/%m-".to_string()),
2 => Ok("%d/%m/%Y-".to_string()),
_ => Err(InvalidTime::ParseErrorDMY),
2020-09-01 14:34:50 +00:00
}
} else {
Ok("".to_string())
}? + {
let colons = self.time_string.matches(':').count();
2020-09-01 14:34:50 +00:00
match colons {
1 => Ok("%H:%M"),
2 => Ok("%H:%M:%S"),
_ => Err(InvalidTime::ParseErrorHMS),
2020-09-01 14:34:50 +00:00
}
}?;
let dt = self
.timezone
.datetime_from_str(self.time_string.as_str(), &parse_string)
.map_err(|_| InvalidTime::ParseErrorChrono)?;
2020-09-01 14:34:50 +00:00
Ok(dt.timestamp() as i64)
}
2020-09-01 14:34:50 +00:00
fn process_displacement(&self) -> Result<i64, InvalidTime> {
let mut current_buffer = "0".to_string();
2020-09-01 14:34:50 +00:00
let mut seconds = 0 as i64;
let mut minutes = 0 as i64;
let mut hours = 0 as i64;
let mut days = 0 as i64;
for character in self.time_string.chars() {
match character {
's' => {
2020-09-01 14:34:50 +00:00
seconds = current_buffer.parse::<i64>().unwrap();
current_buffer = String::from("0");
}
'm' => {
2020-09-01 14:34:50 +00:00
minutes = current_buffer.parse::<i64>().unwrap();
current_buffer = String::from("0");
}
'h' => {
2020-09-01 14:34:50 +00:00
hours = current_buffer.parse::<i64>().unwrap();
current_buffer = String::from("0");
}
'd' => {
2020-09-01 14:34:50 +00:00
days = current_buffer.parse::<i64>().unwrap();
current_buffer = String::from("0");
}
c => {
if c.is_digit(10) {
2020-08-30 20:08:08 +00:00
current_buffer += &c.to_string();
} else {
return Err(InvalidTime::ParseErrorDisplacement);
}
}
}
}
let full = (seconds
+ (minutes * 60)
+ (hours * 3600)
+ (days * 86400)
+ current_buffer.parse::<i64>().unwrap())
* if self.inverted { -1 } else { 1 };
2020-09-01 14:34:50 +00:00
Ok(full)
}
}
pub(crate) async fn natural_parser(time: &str, timezone: &str) -> Option<i64> {
Command::new(&*PYTHON_LOCATION)
.arg("-c")
.arg(include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/dp.py")))
.arg(time)
.arg(timezone)
.arg(&*LOCAL_TIMEZONE)
.output()
.await
.ok()
.map(|inner| {
if inner.status.success() {
Some(from_utf8(&*inner.stdout).unwrap().parse::<i64>().unwrap())
} else {
None
}
})
.flatten()
.map(|inner| if inner < 0 { None } else { Some(inner) })
.flatten()
}