Roy
313 lines
7.2 KiB
Python
313 lines
7.2 KiB
Python
from typing import List
|
|
from .condition import Condition
|
|
from .action import Action
|
|
from time import time
|
|
from datetime import datetime
|
|
|
|
key_list = {
|
|
'deviceList': 'device',
|
|
'parameterSet': 'parameter_set'
|
|
}
|
|
|
|
class Task:
|
|
def __init__(self, task):
|
|
self._id = None
|
|
self._uuid = None
|
|
self._type = None
|
|
self._name = None
|
|
self._parent = None
|
|
self._cycle = None
|
|
self._cycle_count = 0
|
|
self._cycle_next = None
|
|
self._cycle_next_uuid = None
|
|
self._device = None
|
|
self._event = None
|
|
self._trigger = None
|
|
self._parameter_set = None
|
|
self._condition = None
|
|
self._action = None
|
|
# -1: init 0: start(idle), 1: run, 2: close(idle)
|
|
self._status = 0
|
|
self._next = None
|
|
|
|
# action & condition info
|
|
self._condition_list: List[Condition] = []
|
|
self._action_list: List[Action] = []
|
|
self._instruction_list = []
|
|
self._record_list = []
|
|
|
|
# time info
|
|
self._start_time = []
|
|
self._idle_time = []
|
|
self._end_time = []
|
|
self._period = None
|
|
|
|
# trigger info
|
|
self._button_trigger = False
|
|
|
|
self.load_task(task)
|
|
|
|
def load_task(self, task) -> None:
|
|
# update task attribute
|
|
for key, value in task.items():
|
|
if key in key_list.keys():
|
|
key = key_list[key]
|
|
if key == 'condition':
|
|
self.update_condition_list(value)
|
|
if key == 'action':
|
|
self.update_action_list(value)
|
|
# print(key, value)
|
|
setattr(self, key, value)
|
|
|
|
def update_condition_list(self, condition_dict):
|
|
self._condition_list.clear()
|
|
for key, condition in condition_dict.items():
|
|
self._condition_list.append(Condition(key, condition))
|
|
|
|
def update_action_list(self, action_dict):
|
|
self._action_list.clear()
|
|
for key, action in action_dict.items():
|
|
self._action_list.append(Action(key, action))
|
|
|
|
@property
|
|
def id(self) -> str:
|
|
return self._id
|
|
|
|
@id.setter
|
|
def id(self, new_id):
|
|
self._id = new_id
|
|
|
|
@property
|
|
def uuid(self) -> str:
|
|
return self._uuid
|
|
|
|
@uuid.setter
|
|
def uuid(self, new_uuid):
|
|
self._uuid = new_uuid
|
|
|
|
@property
|
|
def type(self):
|
|
return self._type
|
|
|
|
@type.setter
|
|
def type(self, new_type):
|
|
self._type = new_type
|
|
|
|
@property
|
|
def name(self):
|
|
return self._name
|
|
|
|
@name.setter
|
|
def name(self, new_name):
|
|
self._name = new_name
|
|
|
|
@property
|
|
def parent(self):
|
|
if self._parent == None:
|
|
return {"folder": [2]}
|
|
return self._parent
|
|
|
|
@parent.setter
|
|
def parent(self, new_parent):
|
|
self._parent = new_parent
|
|
|
|
@property
|
|
def cycle(self) -> int:
|
|
return self._cycle
|
|
|
|
@cycle.setter
|
|
def cycle(self, new_cycle):
|
|
self._cycle = new_cycle
|
|
|
|
# TODO: not sure needed?
|
|
@property
|
|
def cycle_count(self) -> int:
|
|
return self._cycle_count
|
|
|
|
@cycle_count.setter
|
|
def cycle_count(self, new_cycle_count):
|
|
self._cycle_count = new_cycle_count
|
|
|
|
@property
|
|
def cycle_next(self) -> str:
|
|
return self._cycle_next
|
|
|
|
@cycle_next.setter
|
|
def cycle_next(self, new_cycle_next):
|
|
self._cycle_next = new_cycle_next
|
|
|
|
@property
|
|
def cycle_next_uuid(self) -> str:
|
|
return self._cycle_next_uuid
|
|
|
|
@cycle_next_uuid.setter
|
|
def cycle_next_uuid(self, new_cycle_next_uuid):
|
|
self._cycle_next_uuid = new_cycle_next_uuid
|
|
|
|
@property
|
|
def device(self) -> dict:
|
|
return self._device
|
|
|
|
@device.setter
|
|
def device(self, new_device):
|
|
self._device = new_device
|
|
|
|
@property
|
|
def event(self) -> list:
|
|
return self._event
|
|
|
|
@event.setter
|
|
def event(self, new_event):
|
|
self._event = new_event
|
|
|
|
@property
|
|
def trigger(self) -> list:
|
|
return self._trigger
|
|
|
|
@trigger.setter
|
|
def trigger(self, new_trigger):
|
|
self._trigger = new_trigger
|
|
|
|
@property
|
|
def parameter_set(self) -> list:
|
|
return self._parameter_set
|
|
|
|
@parameter_set.setter
|
|
def parameter_set(self, new_parameter_set):
|
|
self._parameter_set = new_parameter_set
|
|
|
|
@property
|
|
def condition(self) -> list:
|
|
return self._condition
|
|
|
|
@condition.setter
|
|
def condition(self, new_condition):
|
|
self._condition = new_condition
|
|
|
|
@property
|
|
def action(self) -> list:
|
|
return self._action
|
|
|
|
@action.setter
|
|
def action(self, new_action):
|
|
self._action = new_action
|
|
|
|
@property
|
|
def status(self) -> str:
|
|
return self._status
|
|
|
|
@status.setter
|
|
def status(self, new_status):
|
|
self._status = new_status
|
|
|
|
@property
|
|
def next(self) -> str:
|
|
return self._next
|
|
|
|
@next.setter
|
|
def next(self, new_next):
|
|
self._next = new_next
|
|
|
|
@property
|
|
def instruction_list(self) -> List:
|
|
return self._instruction_list
|
|
|
|
@property
|
|
def start_time(self) -> List:
|
|
return self._start_time
|
|
|
|
@property
|
|
def end_time(self) -> List:
|
|
return self._end_time
|
|
|
|
@property
|
|
def button_trigger(self) -> List:
|
|
return self._button_trigger
|
|
|
|
@button_trigger.setter
|
|
def button_trigger(self, button_trigger):
|
|
self._button_trigger = button_trigger
|
|
|
|
def new_start_time(self):
|
|
self._start_time.append(time())
|
|
|
|
def new_end_time(self):
|
|
self._end_time.append(time())
|
|
|
|
def get_parameter_set_by_device(self, device):
|
|
return [parameter_set for parameter_set in self.parameter_set.values() if device == parameter_set['target']]
|
|
|
|
def get_parameter(self, name_or_value, device):
|
|
name_list = []
|
|
value_list = []
|
|
for parameter in self.get_parameter_set_by_device(device):
|
|
for key, value in parameter.items():
|
|
if key != 'target':
|
|
name_list.append(key)
|
|
value_list.append(str(value))
|
|
|
|
return '|'.join(name_list) if name_or_value == 'name' else '|'.join(value_list)
|
|
|
|
def run(self):
|
|
print(self._name, 'run at', datetime.now())
|
|
self._status = 1
|
|
self._start_time.append(time())
|
|
|
|
def start(self):
|
|
self.status = 1
|
|
|
|
def stop(self):
|
|
self.status = 2
|
|
|
|
def reset(self):
|
|
self.status = -1
|
|
# self.status = 0
|
|
|
|
def get_match_action_list(self, match_condition_list):
|
|
return map(lambda condition: [x for x in self._action_list if condition.id in x.get_condition_list()], match_condition_list)
|
|
|
|
def get_match_action(self, condition_id):
|
|
return [action for action in self._action_list if condition_id in action.condition]
|
|
|
|
def do_action(self, action):
|
|
for instruction in action.get_instruction_list():
|
|
self._instruction_list.append(instruction)
|
|
|
|
def check_condition(self, **kwargs):
|
|
kwargs['task_start_time'] = self._start_time
|
|
return [condition for condition in self._condition_list if condition.match_or_not(**kwargs)]
|
|
|
|
def get_task_info(self, action):
|
|
_type = action.type
|
|
if _type == 'stop':
|
|
_type = 'interrupt'
|
|
|
|
return {
|
|
'device': action.target,
|
|
'parameter': self.get_parameter_set_by_device(action.target),
|
|
'file_name': self._name,
|
|
'parent': self.parent,
|
|
'instruction': _type
|
|
}
|
|
|
|
def as_json(self):
|
|
return {
|
|
'id': self.id,
|
|
'name': self.name,
|
|
'parent': self.parent,
|
|
'type': self.type,
|
|
'uuid': self.uuid,
|
|
'cycle': self.cycle,
|
|
'cycle_count': self.cycle_count,
|
|
'cycle_next': self.cycle_next,
|
|
'cycle_next_uuid': self.cycle_next_uuid,
|
|
'device': self.device,
|
|
'event': self.event,
|
|
'trigger': self.trigger,
|
|
'parameter_set': self.parameter_set,
|
|
'condition': self.condition,
|
|
'action': self.action,
|
|
'status': self.status,
|
|
'next': self.next,
|
|
}
|