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 __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 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 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 __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 __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 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 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))