modulatingforce/forcebot_rs
1
0
Fork 0
Code Issues 33 Pull requests 11 Projects 2 Activity

impl other routine attr

Browse source
This commit is contained in:
ModulatingForce 2024-03-27 23:56:34 -04:00
parent e963ae250d
commit 6c3a151668
1 changed files with 94 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

120
src/core/botmodules.rs
View file

@ -636,15 +636,15 @@ impl Routine {
pub async fn validate_attr(routine_attr : &Vec<RoutineAttr>)
-> Result<String,String>
// [ ] => 03.27 - WIP
// [ ] => 03.27 - REVIEW FOR COMPLETION
{
/*
GENERAL LOGIC :
[ ] 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
[ ] 3. If Implemented , then there are additional internal validation based on combination done later
[x] 1. Define RoutineAttr in a broad level that are known to be implented or are work in progress
[x] 2. Built in Logic will check these vectors, and return if Not Implemented
[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>
let wip_attr:Vec<RoutineAttr> = vec![
RoutineAttr::RunOnce,
RoutineAttr::ScheduledStart(chrono::offset::Local::now()),
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![
@ -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) {
return Ok("Valid & Implemented Setup".to_string())
}
if routine_attr.contains(&RoutineAttr::RunOnce) &
routine_attr.contains(&RoutineAttr::LoopInfinitely)
// Below ensures a routine_attr containing LoopInfinitely does not contain conflicit attributes
if routine_attr.contains(&RoutineAttr::LoopInfinitely) &&
( routine_attr.contains(&RoutineAttr::RunOnce)
|| routine_attr.iter().filter(|y| matches!(y,&&RoutineAttr::MaxIterations(_))).next().is_some()
|| routine_attr.iter().filter(|y| matches!(y,&&RoutineAttr::MaxTimeThreshold(_))).next().is_some()
)
{
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
if routine_attr.contains(&RoutineAttr::DelayedStart) &&
@ -718,18 +732,44 @@ 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(
"[ERROR][Routine Feature NOT IMPLEMENTED]",
Some("Routine > Validate_attr()".to_string()),
None,
);
botlog::trace(
"[ERROR][Routine Feature NOT IMPLEMENTED]",
Some("Routine > Validate_attr()".to_string()),
None,
);
Log::flush();
Log::flush();
Err("NOT IMPLEMENTED".to_string())
}
return Err("NOT IMPLEMENTED".to_string())
}
@ -790,11 +830,11 @@ impl Routine {
trg_routine_ar : Arc<RwLock<Routine>>
// ) -> Result<String,String>
) -> Result<Arc<RwLock<Routine>>,String>
// [ ] => 03.27 - WIP
// [ ] => 03.27 - REVIEW FOR COMPLETION
{
// [ ] Asyncio Spawn likely around here
// [ ] & Assigns self.join_handle
// [x] Asyncio Spawn likely around here
// [x] & Assigns self.join_handle
/*
@ -864,7 +904,7 @@ impl Routine {
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>
@ -872,8 +912,11 @@ impl Routine {
(future_dt - chrono::offset::Local::now()).to_std()
}
let delayduration = {
let lock = trg_routine_ar.read().await;
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;
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
@ -964,16 +1015,33 @@ impl Routine {
a.complete_iterations += 1;
if let Some(i) = a.remaining_iterations {
if i > 0 { a.remaining_iterations = Some(i-1) ; }
else { break ; } // if remaining iterations is 0, exit
}
}
// [x]End of Loop Validation
// [x] End of Loop Validation
// These generally may include routine_attr related checks to , for example, break out of the loop
if trg_routine_ar.read().await.routine_attr.contains(&RoutineAttr::RunOnce) {
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;
};
}