impl other routine attr

This commit is contained in:
ModulatingForce 2024-03-27 23:56:34 -04:00
parent e963ae250d
commit 6c3a151668

View file

@ -636,15 +636,15 @@ impl Routine {
pub async fn validate_attr(routine_attr : &Vec<RoutineAttr>) pub async fn validate_attr(routine_attr : &Vec<RoutineAttr>)
-> Result<String,String> -> Result<String,String>
// [ ] => 03.27 - WIP // [ ] => 03.27 - REVIEW FOR COMPLETION
{ {
/* /*
GENERAL LOGIC : GENERAL LOGIC :
[ ] 1. Define RoutineAttr in a broad level that are known to be implented or are work in progress [x] 1. Define RoutineAttr in a broad level that are known to be implented or are work in progress
[ ] 2. Built in Logic will check these vectors, and return if Not Implemented [x] 2. Built in Logic will check these vectors, and return if Not Implemented
[ ] 3. If Implemented , then there are additional internal validation based on combination done later [x] 3. If Implemented , then there are additional internal validation based on combination done later
*/ */
@ -657,9 +657,14 @@ impl Routine {
// WORK IN PROGRESS VECTOR - Vec<$RoutineAttr> // WORK IN PROGRESS VECTOR - Vec<$RoutineAttr>
let wip_attr:Vec<RoutineAttr> = vec![ let wip_attr:Vec<RoutineAttr> = vec![
RoutineAttr::RunOnce,
RoutineAttr::ScheduledStart(chrono::offset::Local::now()),
RoutineAttr::DelayedStart, RoutineAttr::DelayedStart,
RoutineAttr::ScheduledStart(chrono::offset::Local::now()),
RoutineAttr::LoopDuration(Duration::from_secs(1)),
RoutineAttr::LoopInfinitely, // Note : There's no added implementation for this
RoutineAttr::RunOnce,
RoutineAttr::MaxTimeThreshold(chrono::offset::Local::now()),
RoutineAttr::MaxIterations(1),
]; ];
let implemented_attr:Vec<RoutineAttr> = vec![ let implemented_attr:Vec<RoutineAttr> = vec![
@ -693,18 +698,27 @@ impl Routine {
// [ ] 3. If Implemented , then there are additional internal validation based on combination done later // [x] 3. If Implemented , then there are additional internal validation based on combination done later to ERR
if routine_attr.contains(&RoutineAttr::RunOnce) { // Below ensures a routine_attr containing LoopInfinitely does not contain conflicit attributes
return Ok("Valid & Implemented Setup".to_string()) if routine_attr.contains(&RoutineAttr::LoopInfinitely) &&
} ( routine_attr.contains(&RoutineAttr::RunOnce)
|| routine_attr.iter().filter(|y| matches!(y,&&RoutineAttr::MaxIterations(_))).next().is_some()
if routine_attr.contains(&RoutineAttr::RunOnce) & || routine_attr.iter().filter(|y| matches!(y,&&RoutineAttr::MaxTimeThreshold(_))).next().is_some()
routine_attr.contains(&RoutineAttr::LoopInfinitely) )
{ {
return Err("Conflicting Routine Attributes".to_string()) return Err("Conflicting Routine Attributes".to_string())
} }
// [x] if there is no RunOnce, there must be a LoopDuration
if !routine_attr.contains(&RoutineAttr::RunOnce)
&& routine_attr.iter()
.filter(|x| matches!(x,&&RoutineAttr::LoopDuration(_)) )
.next().is_none()
{
return Err("LoopDuration is required if not RunOnce".to_string());
}
// [x] Err if DelayedStart but no LoopDuration // [x] Err if DelayedStart but no LoopDuration
if routine_attr.contains(&RoutineAttr::DelayedStart) && if routine_attr.contains(&RoutineAttr::DelayedStart) &&
@ -718,7 +732,30 @@ impl Routine {
// [x] 4. If all other failure checks above works, ensure one more time that the attribute is implemented
// - If not, routine NOT IMPLEMENTED error
if routine_attr.iter()
.filter(|x| {
let inx = x;
wip_attr.iter().filter(|y| matches!(y,i if i == inx)).next().is_none()
|| implemented_attr.iter().filter(|y| matches!(y,i if i == inx)).next().is_none()
})
.next()
.is_none()
{
botlog::trace(
"[ERROR][Routine Feature NOT IMPLEMENTED]",
Some("Routine > Validate_attr()".to_string()),
None,
);
Log::flush();
Ok("Implemented & Validated".to_string())
} else {
botlog::trace( botlog::trace(
@ -729,7 +766,10 @@ impl Routine {
Log::flush(); Log::flush();
return Err("NOT IMPLEMENTED".to_string()) Err("NOT IMPLEMENTED".to_string())
}
} }
@ -790,11 +830,11 @@ impl Routine {
trg_routine_ar : Arc<RwLock<Routine>> trg_routine_ar : Arc<RwLock<Routine>>
// ) -> Result<String,String> // ) -> Result<String,String>
) -> Result<Arc<RwLock<Routine>>,String> ) -> Result<Arc<RwLock<Routine>>,String>
// [ ] => 03.27 - WIP // [ ] => 03.27 - REVIEW FOR COMPLETION
{ {
// [ ] Asyncio Spawn likely around here // [x] Asyncio Spawn likely around here
// [ ] & Assigns self.join_handle // [x] & Assigns self.join_handle
/* /*
@ -864,7 +904,7 @@ impl Routine {
Log::flush(); Log::flush();
// [ ] If Scheduled Start or Delayed Start, Handle that first // [x] If Scheduled Start or Delayed Start, Handle that first
fn duration_to_datetime(future_dt: DateTime<Local>) -> Result<Duration,OutOfRangeError> fn duration_to_datetime(future_dt: DateTime<Local>) -> Result<Duration,OutOfRangeError>
@ -872,8 +912,11 @@ impl Routine {
(future_dt - chrono::offset::Local::now()).to_std() (future_dt - chrono::offset::Local::now()).to_std()
} }
let delayduration = { let delayduration = {
let lock = trg_routine_ar.read().await; let lock = trg_routine_ar.read().await;
let mut related_attrs = lock let mut related_attrs = lock
@ -947,9 +990,17 @@ impl Routine {
} }
{ // [x] Prior to Loop that calls Custom Routine Execution Body { // [x] Loop Initialization - Prior to Loop that calls Custom Routine Execution Body
let mut a = trg_routine_ar.write().await; let mut a = trg_routine_ar.write().await;
a.start_time = Some(chrono::offset::Local::now()); a.start_time = Some(chrono::offset::Local::now());
if let Some(&RoutineAttr::MaxIterations(iternum)) =
a.routine_attr.iter()
.filter(|x| matches!(x,RoutineAttr::MaxIterations(_)))
.next()
{
a.remaining_iterations = Some(iternum);
}
} }
loop { // [x] Routine loop loop { // [x] Routine loop
@ -964,6 +1015,7 @@ impl Routine {
a.complete_iterations += 1; a.complete_iterations += 1;
if let Some(i) = a.remaining_iterations { if let Some(i) = a.remaining_iterations {
if i > 0 { a.remaining_iterations = Some(i-1) ; } if i > 0 { a.remaining_iterations = Some(i-1) ; }
else { break ; } // if remaining iterations is 0, exit
} }
} }
@ -974,6 +1026,22 @@ impl Routine {
if trg_routine_ar.read().await.complete_iterations > 0 { break; } if trg_routine_ar.read().await.complete_iterations > 0 { break; }
} }
// return if max time has passed
if let Some(&RoutineAttr::MaxTimeThreshold(dt)) = trg_routine_ar.read().await.routine_attr.iter()
.filter(|x| matches!(x,&&RoutineAttr::MaxTimeThreshold(_)) )
.next() {
if chrono::offset::Local::now() > dt { break; }
}
// [x] Checks for Loop duration to sleep
if let Some(&RoutineAttr::LoopDuration(dur)) = trg_routine_ar.read().await.routine_attr.iter()
.filter(|x| matches!(x,&&RoutineAttr::LoopDuration(_)) )
.next()
{
sleep(dur).await;
};
} }