def list_all_rules():
offset = 0
limit = 50
totalCount = 1
allRules = deque()
while(offset < totalCount):
try:
result = StorageManagerService.get_data(group=Storage.STORAGE_RULE, limit=limit, offset=offset)
result = ValueParser.get_dict(result)
rules = ValueParser.get_list(result["data"])
totalCount = int(result["totalRecord"])
offset += limit
if rules:
for rule in rules:
rule = ValueParser.get_dict(rule.get("appDataValue"))
allRules.append(rule)
except Exception as e:
Logger.log_debug("Storage.list_all_rules err: " + str(e))
break
return allRules
def delete_favorited_scene(self, sceneId):
'''
sceneId - must be a favorited scene.
'''
with self.__fav_lock:
try:
favSort = self.__sceneController.get_favsort_of(sceneId)
except Exception as e:
raise AutomationException(11092, "prevSceneId does not belongs to any scene - " + \
"prevSceneId provided: " + str(sceneId) + ", error: " + str(e))
else:
if favSort is None:
raise AutomationException(13000, "sceneId does not belongs to any favorited scene - " + \
"sceneId provided: " + str(sceneId))
# This method raise error and rollback automatically if failed, or commit once succeed.
try:
self.__sceneController.delete_favorited_scene(sceneId)
self.__sceneController.commit()
except Exception as e:
self.__sceneController.rollback()
Logger.log_error("SceneService.delete_favorited_scene failed to delete favorited scene, ex:", str(e))
raise AutomationException(13002, "unexpected error: " + str(e))
#Broadcast event
self.__broadcast_message__scene_updated(sceneId)
self.__broadcast_message__favorited_scene_deleted(sceneId)
def __add_scheduler(ruleId, kbxMethodIdentifier, second, minute, hour, dayOfMonth, month, dayOfWeek):
'''
second="0", minute="*", hour="*", dayOfMonth="*", month="*", dayOfWeek="*"
'''
try:
uniqueName = "_".join([kbxMethodIdentifier, second, minute, hour, dayOfMonth, month, dayOfWeek])
schedulerName = hash(uniqueName)
if schedulerName not in TimerModule.SCHEDULER_ID_TRACKER:
SchedulerService.add_cron_job(str(schedulerName),
kbxTargetAppId=AppInfo.get_app_id(),
kbxTargetMethod="scheduler_callback",
kbxTargetModule="timer_module",
second=second,
minute=minute,
hour=hour,
dayOfMonth=dayOfMonth,
month=month,
dayOfWeek=dayOfWeek,
kbxTargetParams={"kbxMethodIdentifier":kbxMethodIdentifier},
store=False)
TimerModule.SCHEDULER_ID_TRACKER[schedulerName] = [ruleId]
TimerModule.RULE_ID_SCHEDULER_TRACKER[ruleId] = [schedulerName]
Logger.log_debug("Added Timer:", schedulerName, uniqueName)
else:
TimerModule.SCHEDULER_ID_TRACKER[schedulerName].append(ruleId)
TimerModule.RULE_ID_SCHEDULER_TRACKER[ruleId].append(schedulerName)
except Exception as e:
Logger.log_warning("Failed to add timer:", e)
def delete_favorited_scene(self, sceneId):
'''
sceneId - must be a favorited scene.
'''
with self.__fav_lock:
try:
favSort = self.__sceneController.get_favsort_of(sceneId)
except Exception as e:
raise AutomationException(11092, "prevSceneId does not belongs to any scene - " + \
"prevSceneId provided: " + str(sceneId) + ", error: " + str(e))
else:
if favSort is None:
raise AutomationException(13000, "sceneId does not belongs to any favorited scene - " + \
"sceneId provided: " + str(sceneId))
# This method raise error and rollback automatically if failed, or commit once succeed.
try:
self.__sceneController.delete_favorited_scene(sceneId)
self.__sceneController.commit()
except Exception as e:
self.__sceneController.rollback()
Logger.log_error(
"SceneService.delete_favorited_scene failed to delete favorited scene, ex:",
str(e))
raise AutomationException(13002, "unexpected error: " + str(e))
#Broadcast event
self.__broadcast_message__scene_updated(sceneId)
self.__broadcast_message__favorited_scene_deleted(sceneId)
def __update_scene(scene):
try:
# Fire scene update start event
sceneId = scene["sceneId"]
sceneName = scene["sceneName"]
# Add methods to subscribe list
methodIds = [
kbxMethod["kbxMethodId"]
for kbxMethod in scene["execution"]
]
self.__methodController.add(methodIds)
# Update "scene" base table
self.__sceneController.update(scene)
self.__sceneController.commit()
except Exception as e:
self.__sceneController.rollback()
self.__broadcast_message__scene_update_failed(
sceneId, sceneName)
Logger.log_error("SceneService __update_scene failed:", e,
"-- rolledback")
else:
# Broadcast message: completed updating a scene
self.__broadcast_message__scene_updated(sceneId)
def initialize(self):
currentVersion = self.get_user_version()
for updateToVersion, (__runOnce, __run) in enumerate(
zip(self.__runOnce, self.__run),
1): # First version = 1, not 0.
if updateToVersion > currentVersion:
# Performs run once function call on later versions only.
try:
__runOnce("/".join(
(Database.RESOURCE_PATH, str(updateToVersion))))
except Exception as e:
Logger.log_error("Error on updating to version",
updateToVersion, "ex:", e)
raise Exception(
"Failed to initialize database: error on run-once function for version "
+ str(updateToVersion))
# Executes all custom functions
try:
__run()
except Exception as e:
Logger.log_error("Error on version", updateToVersion,
"function execution, ex:", e)
raise Exception(
"Failed to initialize database: error on run-everytime function for version "
+ str(updateToVersion))
else:
del (self.__runOnce)
del (self.__run)
self.set_user_version(updateToVersion)
def __day_of_week(self, request):
try:
dows = request.get_value(
TimerModule._PARAM_DOW.get_kbx_param_name())
execTime = request.get_arg(AppConstants.KEY_CONDITION_TIMESTAMP)
execTime = datetime.datetime.fromtimestamp(execTime)
execDow = execTime.isoweekday() % 7
response = bool(execDow in dows)
if not response:
raise AutomationException(11800)
self.send_response({}, request.requestId)
except AutomationException as ae:
Logger.log_error("TimerModule day_of_week failed on comparison:",
str(ae))
self.send_response({}, request.requestId, ae.get_error_code(),
ae.get_error_message())
except Exception as e:
Logger.log_error(
"TimerModule day_of_week failed on comparison (unexpected):",
str(e))
ae = AutomationException(11099, str(e))
self.send_response({}, request.requestId, ae.get_error_code(),
ae.get_error_message())
def db_3_update(self, resourcePath):
''' convert all "rgb" to "hsb" '''
from com.cloudMedia.theKuroBox.sdk.util.colorUtils import ColorUtils
for idCol, tableName in [("reId", "rule_execution"), ("seId", "scene_execution")]:
toBeUpdateds = deque()
rows = self.__con.execute('SELECT "' + idCol + '", "kbxMethodParams" ' + \
'FROM "' + tableName + '" ' + \
'WHERE "kbxMethodParams" LIKE ?', ('%"r"%', )).fetchall()
for row in rows:
methodRow = dict(row)
kbxMethodParams = methodRow["kbxMethodParams"]
for kbxMethodParam in kbxMethodParams:
kbxParamCurrentValue = kbxMethodParam["kbxParamCurrentValue"]
if isinstance(kbxParamCurrentValue, dict):
if not {"r", "g", "b"}.difference(kbxParamCurrentValue):
hsbDict = ColorUtils.rgb_to_hsb(kbxParamCurrentValue["r"],
kbxParamCurrentValue["g"],
kbxParamCurrentValue["b"])
kbxMethodParam["kbxParamCurrentValue"] = hsbDict
toBeUpdateds.append(methodRow)
for methodRow in toBeUpdateds:
self.__con.execute('UPDATE "' + tableName + '" SET "kbxMethodParams"=? WHERE "' + idCol + '"=?',
(methodRow["kbxMethodParams"], methodRow[idCol]))
Logger.log_info("Database v3 update: RGB -> HSB (%i entries from %s migrated)" % (len(toBeUpdateds), str(tableName)))
Logger.log_info("Database v3 update completed")
def __on_record_deleted(self, kbxMethodId, kbxMethodEvent, kbxMethodIdentifier):
result = self.__db.execute('SELECT COUNT(kbxMethodId) AS "total" FROM "event" WHERE "kbxMethodEvent"=?', (kbxMethodEvent,)).fetchall()
if result[0]["total"] == 0:
try:
self.on_event_deleted(kbxMethodEvent)
except Exception as e:
Logger.log_warning("EventController.__on_record_added ex:", e, "- tag:", kbxMethodEvent)
def commit(self):
with self.__rlock:
try:
return self.__con.commit()
except Exception as e:
Logger.log_error("Database.commit ex:", e)
traceback.print_exc()
def __date_time_range(self, request):
try:
dtVal = request.get_value(
TimerModule._PARAM_DT_RANGE.get_kbx_param_name())
startDateTime = dtVal.get_start_date_time()
endDateTime = dtVal.get_end_date_time()
execTime = request.get_arg(AppConstants.KEY_CONDITION_TIMESTAMP)
execTime = int(execTime)
if execTime > endDateTime:
# Allow a time delta of 59 seconds
response = bool(abs(execTime - endDateTime) <= 59)
else:
response = bool(startDateTime <= execTime <= endDateTime)
if not response:
raise AutomationException(11800)
self.send_response({}, request.requestId)
except AutomationException as ae:
Logger.log_error(
"TimerModule date_time range failed on comparison:", str(ae))
self.send_response({}, request.requestId, ae.get_error_code(),
ae.get_error_message())
except Exception as e:
Logger.log_error(
"TimerModule date_time range failed on comparison (unexpected):",
str(e))
ae = AutomationException(11099, str(e))
self.send_response({}, request.requestId, ae.get_error_code(),
ae.get_error_message())
def handle_time_range(ruleId, methodParams):
with TimerModule.SCHEDULER_LOCK:
keyName = TimerModule._PARAM_TIME_RANGE.get_kbx_param_name()
tVal = TimerModule.__get_arg(keyName, methodParams)
if tVal is not None:
try:
tVal = TimerModule._PARAM_TIME_RANGE.cast(tVal)
startTime = tVal.get_start_time()
except Exception as e:
Logger.log_warning("Invalid time range value, val:", tVal,
"ex:", e)
return
else:
# Backward compatible to daily_task.
kbxTime = KBXTime(kbxParamName="time")
try:
startTime = kbxTime.cast(
TimerModule.__get_arg("time", methodParams))
except Exception as e:
Logger.log_warning("Invalid time range value (old), val:",
tVal, "ex:", e)
return
# Add scheduler
TimerModule.__add_scheduler(ruleId, "time_range",
str(startTime.get_second()),
str(startTime.get_minute()),
str(startTime.get_hour()), "*", "*",
"*")
def __update_rule(rule):
try:
# Fire rule update start event
ruleId = rule["ruleId"]
# Add methods to subscribe list
methodIds = [kbxMethod["kbxMethodId"] for kbxMethod in rule["condition"] + rule["execution"]]
self.__methodController.add(methodIds)
# Update "rule" base table
self.__ruleController.update(rule)
self.__ruleController.commit()
except Exception as e:
self.__ruleController.rollback()
self.__broadcast_message__rule_update_failed(ruleId, ruleName)
Logger.log_error("RuleService __update_rule failed:", e, "-- rolledback")
else:
self.__triggerController.register_listener(ruleId, rule["trigger"])
# Process for Timer Module
TimerModule.delete_scheduler(ruleId)
timerModuleHandlers = {TimerModule.METHOD_ID_DATE_TIME_RANGE:TimerModule.handle_date_time_range,
TimerModule.METHOD_ID_DAY_OF_WEEK:TimerModule.handle_dow,
TimerModule.METHOD_ID_TIME_RANGE:TimerModule.handle_time_range}
for kbxMethod in rule["condition"]:
kbxMethodId = kbxMethod["kbxMethodId"]
timerModuleHandler = timerModuleHandlers.get(kbxMethodId, None)
if timerModuleHandler is not None:
timerModuleHandler(ruleId, kbxMethod["kbxMethodParams"])
# Broadcast message: completed updating a rule
self.__broadcast_message__rule_updated(ruleId)
def __date_time_range(self, request):
try:
dtVal = request.get_value(TimerModule._PARAM_DT_RANGE.get_kbx_param_name())
startDateTime = dtVal.get_start_date_time()
endDateTime = dtVal.get_end_date_time()
execTime = request.get_arg(AppConstants.KEY_CONDITION_TIMESTAMP)
execTime = int(execTime)
if execTime > endDateTime:
# Allow a time delta of 59 seconds
response = bool(abs(execTime - endDateTime) <= 59)
else:
response = bool(startDateTime <= execTime <= endDateTime)
if not response:
raise AutomationException(11800)
self.send_response({}, request.requestId)
except AutomationException as ae:
Logger.log_error("TimerModule date_time range failed on comparison:", str(ae))
self.send_response({}, request.requestId, ae.get_error_code(), ae.get_error_message())
except Exception as e:
Logger.log_error("TimerModule date_time range failed on comparison (unexpected):", str(e))
ae = AutomationException(11099, str(e))
self.send_response({}, request.requestId, ae.get_error_code(), ae.get_error_message())
def rollback(self):
with self.__rlock:
try:
return self.__con.rollback()
except Exception as e:
Logger.log_error("Database.rollback ex:", e)
traceback.print_exc()
def rollback(self):
with self.__rlock:
try:
return self.__con.rollback()
except Exception as e:
Logger.log_error("Database.rollback ex:", e)
traceback.print_exc()
def __broadcast_message__favorited_scene_added(self, sceneId, prevSceneId):
eventTag = AppConstants.EVENT_FAVORITED_SCENE_ADDED
eventData = {"sceneId": sceneId, "prevSceneId": prevSceneId}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Favorited scene added/updated: Id", sceneId,
"prevId:", prevSceneId)
def commit(self):
with self.__rlock:
try:
return self.__con.commit()
except Exception as e:
Logger.log_error("Database.commit ex:", e)
traceback.print_exc()
def list_groups(self, language, section, parentId=None):
try:
def sort_group_list(value):
name = value.get("kbxGroupLabel")
if name is None:
return ""
else:
return str(name).lower()
unknownGroupDict = {}
unknownGroupId = self.__get_group_ids()
parentId = AppConstants.GROUP_ID_AUTOMATION if parentId is None else parentId
result = SharedMethod.list_shared_method_groups(kbxGroupParentId=parentId, kbxMethodTag=section,
enableTagCount=True, language=language)
groupList = result["groupList"]
# Level 1 groups which contain of SERVICES and LOCATIONS.
if parentId == AppConstants.GROUP_ID_AUTOMATION:
services = deque()
groups = deque()
for groupDict in groupList:
kbxGroupId = groupDict["kbxGroupId"]
# Add indicator for UI
groupDict["kbxGroupHasChild"] = True
# Reordering
if kbxGroupId == AppConstants.GROUP_ID_NOTIFICATION:
groupDict["kbxGroupDesc"] = KBXLang("group_notification_" + section)
services.appendleft(groupDict)
elif kbxGroupId == AppConstants.GROUP_ID_SERVICE:
groupDict["kbxGroupDesc"] = KBXLang("group_service_" + section)
services.append(groupDict)
elif kbxGroupId == unknownGroupId:
#append the group dict
unknownGroupDict = groupDict
else:
groups.append(groupDict)
groups = sorted(groups, key=sort_group_list)
if len(unknownGroupDict) > 0:
groups.append(unknownGroupDict)
services.extend(groups)
groupList = services
parentGroup = None
# Level 2 groups which are DEVICES or SERVICES.
else:
parentGroup = SharedMethod.get_shared_method_group_by_id(kbxGroupId=parentId, language=language)
return parentGroup, groupList
except Exception as e:
Logger.log_error("APIService.list_groups ex:", e)
raise AutomationException(11601, "Unexpected error - " + str(e))
def __broadcast_message__scene_update_started(self,
sceneId,
sceneName=None):
eventTag = AppConstants.EVENT_SCENE_UPDATE_STARTED
eventData = {"sceneId": sceneId, "newSceneName": sceneName}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Scene Start Update:", sceneName)
def on_group_icon_change(*args, **kwargs):
with self.__lock___group_icon_change:
for callback in self.__group_icon_change_callbacks:
try:
callback(*args, **kwargs)
except Exception as e:
Logger.log_warning("GroupController.listen_to_group_icon_change.on_group_icon_change callback ex:", e)
def kbx_method_after_delete(self, kbxMethodId, kbxGroupId):
if Util.is_empty(kbxGroupId):
return
self.__delete_kbx_group_if_necessary(kbxGroupId)
try:
Database.KBX_METHOD_AFTER_DELETE(kbxMethodId)
except Exception as e:
Logger.log_warning("Database.KBX_METHOD_AFTER_DELETE raised error:", e)
def on_method_status_change(*args, **kwargs):
with self.__lock___method_status_change:
for callback in self.__method_status_change_callbacks:
try:
callback(*args, **kwargs)
except Exception as e:
Logger.log_warning("MethodController.listen_to_method_status_change.on_method_status_change callback ex:", e)
def post_system_connected(self):
super().post_system_connected()
Logger.log_info("post_system_connected starts...")
DebugModule.DEBUG_POST_SYSTEM_CONNECTED.append(time.time())
self.__automationModule.start()
Logger.log_info("post_system_connected ends...")
def post_system_connected(self):
super().post_system_connected()
Logger.log_info("post_system_connected starts...")
DebugModule.DEBUG_POST_SYSTEM_CONNECTED.append(time.time())
self.__automationModule.start()
Logger.log_info("post_system_connected ends...")
def enable_rule(self, ruleId, enabled):
self.__check_rule_process_status(ruleId)
try:
self.__ruleController.enable(ruleId, enabled)
self.__ruleController.commit()
except Exception as e:
self.__ruleController.rollback()
Logger.log_error("RuleService enable_rule ex:", e, "-- rolled back")
else:
self.__broadcast_message__rule_updated(ruleId)
def __get_arg(keyName, methodParams):
'''
Method to parse out corresponding value from methodParams.
'''
for methodParam in methodParams:
if methodParam.get(AppConstants.ARG_NAME) == keyName:
return methodParam.get(AppConstants.ARG_CURRENT_VALUE)
else:
Logger.log_warning("Unable to find value:", keyName)
return None
def kbx_method_after_delete(self, kbxMethodId, kbxGroupId):
if Util.is_empty(kbxGroupId):
return
self.__delete_kbx_group_if_necessary(kbxGroupId)
try:
Database.KBX_METHOD_AFTER_DELETE(kbxMethodId)
except Exception as e:
Logger.log_warning(
"Database.KBX_METHOD_AFTER_DELETE raised error:", e)
def __get_arg(keyName, methodParams):
'''
Method to parse out corresponding value from methodParams.
'''
for methodParam in methodParams:
if methodParam.get(AppConstants.ARG_NAME) == keyName:
return methodParam.get(AppConstants.ARG_CURRENT_VALUE)
else:
Logger.log_warning("Unable to find value:", keyName)
return None
def __on_shared_method_updated(self, eventObject):
'''
Triggered based on event broadcasted by system app.
'''
try:
kbxMethod = json.loads(eventObject["eventData"]) # eventData = kbxMethod
self.update(kbxMethod)
except Exception as e:
Logger.log_error("MethodController.__on_shared_method_updated ex:", e)
traceback.print_exc()
def __scheduler_callback(self, request):
self.send_response({}, request.requestId)
try:
self.send_system_event(
TimerModule.EVENT_TAG, "".join(
("{\"kbxMethodIdentifier\":\"",
str(request.get_arg("kbxMethodIdentifier")), "\"}")))
except Exception as e:
Logger.log_warning(
"Timer Module failed to process scheduler callback:", str(e))
def __on_record_deleted(self, kbxMethodId, kbxMethodEvent,
kbxMethodIdentifier):
result = self.__db.execute(
'SELECT COUNT(kbxMethodId) AS "total" FROM "event" WHERE "kbxMethodEvent"=?',
(kbxMethodEvent, )).fetchall()
if result[0]["total"] == 0:
try:
self.on_event_deleted(kbxMethodEvent)
except Exception as e:
Logger.log_warning("EventController.__on_record_added ex:", e,
"- tag:", kbxMethodEvent)
def on_group_icon_change(*args, **kwargs):
with self.__lock___group_icon_change:
for callback in self.__group_icon_change_callbacks:
try:
callback(*args, **kwargs)
except Exception as e:
Logger.log_warning(
"GroupController.listen_to_group_icon_change.on_group_icon_change callback ex:",
e)
def enable_rule(self, ruleId, enabled):
self.__check_rule_process_status(ruleId)
try:
self.__ruleController.enable(ruleId, enabled)
self.__ruleController.commit()
except Exception as e:
self.__ruleController.rollback()
Logger.log_error("RuleService enable_rule ex:", e,
"-- rolled back")
else:
self.__broadcast_message__rule_updated(ruleId)
def __on_shared_method_group_updated(self, eventObject):
'''
Triggered based on event broadcasted by system app.
'''
try:
eventData = json.loads(eventObject["eventData"])
self.update(eventData) # eventData = kbxGroup
except Exception as e:
Logger.log_error(
"GroupController.__on_shared_method_group_updated ex:", e)
traceback.print_exc()
def on_method_status_change(*args, **kwargs):
with self.__lock___method_status_change:
for callback in self.__method_status_change_callbacks:
try:
callback(*args, **kwargs)
except Exception as e:
Logger.log_warning(
"MethodController.listen_to_method_status_change.on_method_status_change callback ex:",
e)
def delete_rule(self, ruleId):
self.__check_rule_process_status(ruleId)
try:
self.__ruleController.delete(ruleId)
self.__ruleController.commit()
except Exception as e:
self.__ruleController.rollback()
Logger.log_error("RuleService delete_rule ex:", e, "-- rolled back")
else:
self.__broadcast_message__rule_deleted(ruleId)
self.__triggerController.unregister_listener(ruleId)
TimerModule.delete_scheduler(ruleId)
def set_favorited_scene(self, sceneId, prevSceneId=None):
'''
sceneId - can be either favorited/non-favorited scene, but must be a valid scene id.
prevSceneId - must be another favorited scene or error is raised.
Both updating and executing doesn't blocks a scene from adding to/removing from favorited list.
'''
with self.__fav_lock:
# Validation for sceneId.
if not self.__sceneController.has(sceneId):
raise AutomationException(
11092,
"sceneId does not belongs to any scene - sceneId provided: "
+ str(sceneId))
# Because UI display in reversed order, hence their prevSceneId == our nextSceneId
nextSceneId = prevSceneId or None
# Get favSort before sceneId of nextSceneId
if nextSceneId is None:
maxFavSort = self.__sceneController.get_largest_favsort_num(
) # If len of favorited list is 0, maxFavSort = 0
# favSort stores number to be assigned to sceneId.
favSort = maxFavSort + 1
else:
try:
# favSort stores number to be assigned to sceneId.
# current favSort of prevSceneId will becomes favSort of sceneId.
favSort = self.__sceneController.get_favsort_of(
nextSceneId)
except Exception as e:
raise AutomationException(11092, "prevSceneId does not belongs to any scene - " + \
"prevSceneId provided: " + str(nextSceneId) + ", error: " + str(e))
else:
if favSort is None:
raise AutomationException(13000, "prevSceneId does not belongs to any favorited scene - " + \
"prevSceneId provided: " + str(nextSceneId) + ", error: " + str(e))
# Update favSort of the scene
try:
self.__sceneController.update_favorited_scene(sceneId, favSort)
self.__sceneController.commit()
except Exception as e:
self.__sceneController.rollback()
Logger.log_error(
"SceneService.set_favorited_scene failed to update favorited scene, ex:",
str(e))
raise AutomationException(13001, "unexpected error: " + str(e))
# Broadcast events
self.__broadcast_message__scene_updated(sceneId)
self.__broadcast_message__favorited_scene_added(
sceneId, prevSceneId)
def __on_shared_method_deleted(self, eventObject):
'''
Triggered based on event broadcasted by system app.
'''
try:
eventData = json.loads(eventObject["eventData"])
kbxMethodId = eventData["kbxMethodId"]
self.delete(kbxMethodId)
except Exception as e:
Logger.log_error("MethodController.__on_shared_method_deleted ex:",
e)
traceback.print_exc()
def __add_scene_execution_result(self, serUrl, serStartTime, serEndTime, sceneName, sceneProtected, sceneId, execution, language):
try:
SceneExecutionResultService.instance().add_scene_execution_result(serUrl=serUrl,
serStartTime=serStartTime,
serEndTime=serEndTime,
sceneName=sceneName,
sceneProtected=sceneProtected,
sceneId=sceneId,
execution=execution,
language=language)
except Exception as e:
Logger.log_error("SceneService.__add_scene_execution_result ex:", e)
def reset(self):
result = self.__db.execute('SELECT DISTINCT "kbxMethodEvent" FROM "event"').fetchall()
for row in result:
kbxMethodEvent = row["kbxMethodEvent"]
try:
self.on_event_deleted(kbxMethodEvent)
except Exception as e:
Logger.log_warning("EventController.reset on_event_removed ex:", e, "- tag:", kbxMethodEvent)
self.__db.close()
self.__init__()
def __broadcast_message__rule_updated(self, ruleId):
try:
rule = self.__ruleController.get_summary(ruleId)
except Exception as e:
Logger.log_error("RuleService.__broadcast_message__rule_updated get_summary ex:", e)
return
eventTag = AppConstants.EVENT_RULE_UPDATED
eventData = rule
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Rule Updated:", rule["ruleName"])
def __broadcast_message__scene_updated(self, sceneId):
try:
scene = self.__sceneController.get_summary(sceneId)
except Exception as e:
Logger.log_error("SceneService.__broadcast_message__scene_updated get_summary ex:", e)
scene = None
eventTag = AppConstants.EVENT_SCENE_UPDATED
eventData = {"sceneId":sceneId, "newSceneSummary":scene}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Scene Updated:", scene["sceneName"])
def __on_shared_method_group_deleted(self, eventObject):
'''
Triggered based on event broadcasted by system app.
'''
try:
eventData = json.loads(eventObject["eventData"])
kbxGroupId = eventData["kbxGroupId"]
self.delete(kbxGroupId)
except Exception as e:
Logger.log_error("GroupController.__on_shared_method_group_deleted ex:", e)
traceback.print_exc()
def delete_rule(self, ruleId):
self.__check_rule_process_status(ruleId)
try:
self.__ruleController.delete(ruleId)
self.__ruleController.commit()
except Exception as e:
self.__ruleController.rollback()
Logger.log_error("RuleService delete_rule ex:", e,
"-- rolled back")
else:
self.__broadcast_message__rule_deleted(ruleId)
self.__triggerController.unregister_listener(ruleId)
TimerModule.delete_scheduler(ruleId)
def handle_dow(ruleId, methodParams):
with TimerModule.SCHEDULER_LOCK:
keyName = TimerModule._PARAM_DOW.get_kbx_param_name()
dowVal = TimerModule.__get_arg(keyName, methodParams)
try:
dowVal = TimerModule._PARAM_DOW.cast(dowVal)
except Exception as e:
Logger.log_warning("Invalid day of week value, val:", dowVal, "ex:", e)
return
# Add scheduler
dayOfWeek = ",".join((str(d) for d in dowVal))
TimerModule.__add_scheduler(ruleId, "day_of_week", "0", "0", "0", "*", "*", dayOfWeek)
def __broadcast_message__scene_update_failed(self, sceneId, sceneName=None):
'''
sceneName - For debugging purpose.
'''
try:
scene = self.__sceneController.get_summary(sceneId)
except Exception:
scene = None
eventTag = AppConstants.EVENT_SCENE_UPDATE_FAILED
eventData = {"sceneId": sceneId, "oldSceneSummary":scene}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Scene Update Failed:", sceneName)
def __broadcast_message__rule_update_failed(self, ruleId, ruleName=None):
'''
ruleName - For debugging purpose.
'''
try:
rule = self.__ruleController.get_summary(ruleId)
except Exception:
rule = None
eventTag = AppConstants.EVENT_RULE_UPDATE_FAILED
eventData = {"ruleId": ruleId, "oldRuleSummary":rule}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Rule Update Failed:", ruleName)
def __broadcast_message__rule_update_failed(self, ruleId, ruleName=None):
'''
ruleName - For debugging purpose.
'''
try:
rule = self.__ruleController.get_summary(ruleId)
except Exception:
rule = None
eventTag = AppConstants.EVENT_RULE_UPDATE_FAILED
eventData = {"ruleId": ruleId, "oldRuleSummary": rule}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Rule Update Failed:", ruleName)
def __broadcast_message__rule_updated(self, ruleId):
try:
rule = self.__ruleController.get_summary(ruleId)
except Exception as e:
Logger.log_error(
"RuleService.__broadcast_message__rule_updated get_summary ex:",
e)
return
eventTag = AppConstants.EVENT_RULE_UPDATED
eventData = rule
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Rule Updated:", rule["ruleName"])
def __broadcast_message__scene_updated(self, sceneId):
try:
scene = self.__sceneController.get_summary(sceneId)
except Exception as e:
Logger.log_error(
"SceneService.__broadcast_message__scene_updated get_summary ex:",
e)
scene = None
eventTag = AppConstants.EVENT_SCENE_UPDATED
eventData = {"sceneId": sceneId, "newSceneSummary": scene}
self.__broadcast_message(eventTag, eventData)
Logger.log_info("Scene Updated:", scene["sceneName"])
def __signal_scheduler_add_cron_job(ruleId, hour, minute):
try:
SchedulerService.add_cron_job(jobName=str(ruleId),
kbxTargetAppId=AppInfo.get_app_id(),
kbxTargetMethod="on_trigger_callback",
kbxTargetModule="controller_module",
kbxTargetParams={"ruleId":ruleId},
store=False,
hour=str(hour),
minute=str(minute))
self.__registeredRuleIds.add(ruleId)
except SystemException as e:
Logger.log_debug(e)
def __parse_section(self, section):
'''
Convert if/then into correlated automation tags.
'''
section = str(section).lower()
mapDict = {AppConstants.SECTION_CONDITION:AppConstants.TAG_CONDITION,
AppConstants.SECTION_EXECUTION:AppConstants.TAG_ACTION}
try:
return mapDict[section]
except:
Logger.log_error("__parse_section ex: given value(%s), type(%s), allowed values(%s)" % (str(section), str(type(section)), str(mapDict.keys())))
raise AutomationException(11097, "section param must be either value from " + str(mapDict.keys())) # invalid parameter
def handle_dow(ruleId, methodParams):
with TimerModule.SCHEDULER_LOCK:
keyName = TimerModule._PARAM_DOW.get_kbx_param_name()
dowVal = TimerModule.__get_arg(keyName, methodParams)
try:
dowVal = TimerModule._PARAM_DOW.cast(dowVal)
except Exception as e:
Logger.log_warning("Invalid day of week value, val:", dowVal,
"ex:", e)
return
# Add scheduler
dayOfWeek = ",".join((str(d) for d in dowVal))
TimerModule.__add_scheduler(ruleId, "day_of_week", "0", "0", "0",
"*", "*", dayOfWeek)
def delete_scheduler(ruleId):
with TimerModule.SCHEDULER_LOCK:
try:
schedulerNames = TimerModule.RULE_ID_SCHEDULER_TRACKER.pop(ruleId, set({}))
for schedulerName in schedulerNames:
TimerModule.SCHEDULER_ID_TRACKER[schedulerName].remove(ruleId)
if not TimerModule.SCHEDULER_ID_TRACKER[schedulerName]:
SchedulerService.remove_job(str(schedulerName))
del(TimerModule.SCHEDULER_ID_TRACKER[schedulerName])
Logger.log_debug("Removed Timer:", schedulerName)
except Exception as e:
Logger.log_warning("Failed to remove timer:", e)
def handle_date_time_range(ruleId, methodParams):
with TimerModule.SCHEDULER_LOCK:
keyName = TimerModule._PARAM_DT_RANGE.get_kbx_param_name()
dtVal = TimerModule.__get_arg(keyName, methodParams)
try:
dtVal = TimerModule._PARAM_DT_RANGE.cast(dtVal)
except Exception as e:
Logger.log_warning("Invalid date time range value, val:", dtVal, "ex:", e)
return
# Add scheduler
startDateTime = dtVal.get_start_date_time()
dtObj = startDateTime.get_date_time_obj()
weekday = dtObj.isoweekday() % 7
TimerModule.__add_scheduler(ruleId, "date_time_range", str(dtObj.second), str(dtObj.minute), str(dtObj.hour), str(dtObj.day), str(dtObj.month), str(weekday))
