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_kbx_method(self, request): ''' Update shared method in use manually. ''' # Parameters try: paramKey = "kbxMethodId" kbxMethodId = request.get_value(paramKey) except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result = self.__apiService.update_kbx_method(kbxMethodId) if result is None: methodStatus = "Method Removed" elif result is True: methodStatus = "Method Active" else: methodStatus = "Method Inactive" self.send_response(request.requestId, data={"methodStatus":methodStatus}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def list_favorited_scenes(self, request): # Parameters try: paramKey = "limit" limit = request.get_value(paramKey) limit = 200 if limit is None else limit paramKey = "offset" offset = request.get_value(paramKey) offset = 0 if offset is None else offset except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result, total = self.__sceneService.list_favorited_scene(offset, limit) self.send_response(request.requestId, {"data":result, "total":total}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def execute_scene(self, request): ''' Execute a scene. ''' # Parameters try: paramKey = "sceneId" sceneId = request.get_value(paramKey) paramKey = "serUrl" serUrl = request.get_value(paramKey) paramKey = "language" language = request.get_arg(paramKey) language = AppInfo.DEFAULT_API_LANGUAGE if language is None else language except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__sceneService.execute_scene(sceneId=sceneId, serUrl=serUrl, language=language) self.send_response(request.requestId) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def update_kbx_group(self, request): ''' Update shared method group in use manually. ''' # Parameters try: paramKey = "kbxGroupId" kbxGroupId = request.get_value(paramKey) except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result = self.__apiService.update_kbx_group(kbxGroupId) if result is None: groupStatus = "Group Removed" else: groupStatus = "Group Exists" self.send_response(request.requestId, data={"groupStatus":groupStatus}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def get_scene(self, request): ''' Get single scene detail by scene id. ''' # Parameters try: paramKey = "sceneId" sceneId = request.get_value(paramKey) paramKey = "language" language = request.get_arg("language") language = AppInfo.DEFAULT_API_LANGUAGE if language is None else language except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result = self.__sceneService.get_scene(sceneId=sceneId, language=language) self.send_response(request.requestId, data=result) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def list_methods(self, request): ''' List all methods by groupId(required), section(required) accepts "if/then". ''' # Parameters try: paramKey = "groupId" groupId = request.get_value(paramKey) paramKey = "section" section = request.get_value(paramKey) section = self.__parse_section(section) paramKey = "language" language = request.get_arg(paramKey) language = AppInfo.DEFAULT_API_LANGUAGE if language is None else language except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: methodList, groupDict = self.__apiService.list_methods(section=section, groupId=groupId, language=language) self.send_response(request.requestId, data={"group":groupDict, "data":sorted(methodList, key=lambda method: method.get("kbxMethodSort", 0))}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def enable_rule(self, request): ''' Enable/Disable a rule. ''' # Parameters try: paramKey = "ruleId" ruleId = request.get_value(paramKey) paramKey = "enabled" enabled = request.get_value("enabled") except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__ruleService.enable_rule(ruleId=ruleId, enabled=enabled) self.send_response(request.requestId) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def list_scenes(self, request): ''' List all scene summaries. ''' # Parameters try: paramKey = "limit" limit = request.get_value(paramKey) limit = AppConstants.UPPER_LIMIT if limit is None else limit paramKey = "offset" offset = request.get_value(paramKey) offset = 0 if offset is None else offset except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result, total = self.__sceneService.list_scenes(limit=limit, offset=offset) self.send_response(request.requestId, data={"totalCount":total, "data":result}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def get_scene_execution_result(self, request): ''' Get scene execution result (aggregates details base on preferred language). ''' # Parameters try: paramKey = "serId" serId = request.get_value(paramKey) paramKey = "language" language = request.get_arg(paramKey) language = AppInfo.DEFAULT_API_LANGUAGE if language is None else language except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: serObject = self.__serService.get_scene_execution_result(serId, language) self.send_response(request.requestId, data=serObject) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
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 retry_scene_execution_result_item(self, request): ''' Retry a specific or all items with error sequentially. ''' # Parameters try: paramKey = "serId" serId = request.get_value(paramKey) paramKey = "seriIndex" seriIndex = request.get_value(paramKey) except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: seriIndexes = self.__serService.retry_scene_execution_result_item(serId, seriIndex) self.send_response(request.requestId, data={"serId":serId, "seriIndexes":seriIndexes}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
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 list_scene_execution_results(self, request): ''' List all scene execution results without items. (For debugging) ''' # Parameters try: paramKey = "limit" limit = request.get_value(paramKey) limit = 50 if limit is None else limit paramKey = "offset" offset = request.get_value(paramKey) offset = 0 if offset is None else offset except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result = self.__serService.list_scene_execution_results(offset, limit) self.send_response(request.requestId, {"data":result}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def set_favorited_scene(self, request): # Parameters try: paramKey = "sceneId" sceneId = request.get_value(paramKey) paramKey = "prevSceneId" prevSceneId = request.get_value(paramKey) if sceneId == prevSceneId: raise Exception("sceneId cannot equals to prevSceneId") except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__sceneService.set_favorited_scene(sceneId, prevSceneId) self.send_response(request.requestId, data={"prevSceneId":prevSceneId}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def list_groups(self, request): ''' List all groups, parentId is optional. ''' # Parameters try: paramKey = "parentId" parentId = request.get_value(paramKey) paramKey = "section" section = request.get_value(paramKey) section = self.__parse_section(section) paramKey = "language" language = request.get_arg(paramKey) language = AppInfo.DEFAULT_API_LANGUAGE if language is None else language except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: parentGroup, groupList = self.__apiService.list_groups(section=section, parentId=parentId, language=language) self.send_response(request.requestId, data={"parentGroup":parentGroup, "data": groupList}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def process_method_list(methodList): #=================================================================== # Basic type validation #=================================================================== if not isinstance(methodList, list): Logger.log_error( "RuleService.set_rule: 'condition' and 'execution' must be type of list." ) Logger.log_debug("type:", type(methodList), "value:", methodList) raise AutomationException( 11704, "List is required for both 'condition' and 'execution'") #=================================================================== # Check allowed size, raise error if exceeded. #=================================================================== methodListLen = len(methodList) if methodListLen > AppConstants.MAX_METHOD_SIZE: Logger.log_error( "RuleService.set_rule: 'condition' and 'execution' cannot have more than", AppConstants.MAX_METHOD_SIZE, "items respectively.") raise AutomationException(11705, "Only a maximum of " + \ str(AppConstants.MAX_METHOD_SIZE) + \ " items is allowed for each 'condition' and 'execution' - given size " + \ str(methodListLen), lambda text: str(AppConstants.MAX_METHOD_SIZE).join(text.split(":max_item_size:"))) #=================================================================== # Check if all kbxMethodIds are valid and all kbxMethodParams are list #=================================================================== idValidator = NumberValidator(isRequired=True, decimalPoint=False) if not all([ idValidator.is_valid(eachMethod["kbxMethodId"]) and isinstance(eachMethod["kbxMethodParams"], list) for eachMethod in methodList ]): raise AutomationException( 11704, "'condition' and 'execution' have incorrect data structure." ) #=================================================================== # Check if all kbxParamName and kbxParamCurrentValue exists #=================================================================== paramNameValidator = StringValidator(isRequired=True) for eachMethod in methodList: methodArgs = eachMethod["kbxMethodParams"] for methodArg in methodArgs: if not paramNameValidator.is_valid( methodArg[AppConstants.ARG_NAME]): raise AutomationException( 11704, "'condition' and 'execution' have invalid params structure" ) if not AppConstants.ARG_CURRENT_VALUE in methodArg: methodArg[AppConstants.ARG_CURRENT_VALUE] = None return methodList
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 trigger_rule(self, request): ''' Trigger a rule manually ''' # Parameters try: paramKey = "ruleId" ruleId = request.get_value(paramKey) paramKey = "checkCondition" checkCondition = request.get_value(paramKey) checkCondition = not (checkCondition is False) except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__ruleService.trigger_rule(ruleId=ruleId, checkCondition=checkCondition) self.send_response(request.requestId) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def list_kbx_groups(self, request): ''' List kbx_groups, mostly for debugging purpose. ''' # Parameters try: paramKey = "offset" offset = request.get_value(paramKey) if offset is None: offset = 0 paramKey = "limit" limit = request.get_value(paramKey) if limit is None: limit = 200 except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: result = self.__apiService.list_kbx_groups(offset, limit) kbxGroups = [dict(val) for val in result] self.send_response(request.requestId, data={"kbxGroups":kbxGroups}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def set_rule(self, request): ''' Set rule is the combination of both "update/insert rule". ''' # Parameters try: paramKey = "Process post data" params = Helper.parse_post_data(request.get_post_data()) paramKey = "condition" condition = json.loads(params[paramKey]) if len(condition) == 0: raise Exception("'condition' cannot be empty") paramKey = "execution" execution = json.loads(params[paramKey]) if len(condition) == 0: raise Exception("'execution' cannot be empty") paramKey = "trigger" trigger = json.loads(params[paramKey]) paramKey = "ruleId" ruleId = params.get(paramKey) ruleId = None if Util.is_empty(ruleId) else int(ruleId) paramKey = "ruleName" ruleName = params[paramKey] if Util.is_empty(ruleName): raise Exception("'ruleName' cannot be empty") ruleName = str(ruleName) paramKey = "enabled" boolValidator = KBXBoolean(kbxParamName="boolValidator", kbxParamIsRequired=False) enabled = boolValidator.cast(params.get(paramKey)) enabled = enabled is not False # always True unless False is specified paramKey = "ruleProtected" ruleProtected = boolValidator.cast(params.get(paramKey)) ruleProtected = ruleProtected is True # Always False unless True is specified. except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__ruleService.set_rule(trigger=trigger, condition=condition, execution=execution, ruleId=ruleId, \ ruleName=ruleName, ruleProtected=ruleProtected, enabled=enabled) self.send_response(request.requestId) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
def __verify_scene_updated(self, sceneId): try: statusProcessed = self.__sceneController.get_status_processed( sceneId) if statusProcessed == AppConstants.SCENE_STATUS_UPDATING: raise AutomationException(11903, "edit/execute/delete scene is not allowed when its updating. " + \ "Wait until the update process is completed.") except: raise AutomationException(11902, "Scene ID provided:" + str(sceneId))
def __check_rule_process_status(self, ruleId): try: statusProcessed = self.__ruleController.get_status_processed( ruleId) if statusProcessed != AppConstants.RULE_STATUS_UPDATED: raise AutomationException( 11703, "edit/delete/execute is not allowed on rule update in progress" ) except: raise AutomationException( 11702, "Rule ID provided not found - " + str(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 set_scene(self, request): ''' Set scene is the combination of both "update/insert scene". ''' # Parameters try: paramKey = "Process post data" params = Helper.parse_post_data(request.get_post_data()) paramKey = "execution" execution = json.loads(params[paramKey]) if len(execution) == 0: raise Exception("'execution' cannot be empty") paramKey = "sceneId" sceneId = params.get(paramKey) sceneId = None if Util.is_empty(sceneId) else int(sceneId) paramKey = "sceneName" sceneName = params[paramKey] if Util.is_empty(sceneName): raise Exception("'sceneName' cannot be empty") sceneName = str(sceneName) paramKey = "sceneIcon" sceneIcon = params[paramKey] if Util.is_empty(sceneIcon): raise Exception("'sceneIcon' cannot be empty") sceneIcon = str(sceneIcon) paramKey = "sceneProtected" boolValidator = KBXBoolean(kbxParamName="boolValidator", kbxParamIsRequired=False) sceneProtected = boolValidator.cast(params.get(paramKey)) sceneProtected = sceneProtected is True # Always False unless True is specified. except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: sceneId = self.__sceneService.set_scene(execution=execution, sceneId=sceneId, sceneName=sceneName, \ sceneProtected=sceneProtected, sceneIcon=sceneIcon) self.send_response(request.requestId, data={"sceneId":sceneId}) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
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 __time_range(self, request): try: try: tVal = request.get_value( TimerModule._PARAM_TIME_RANGE.get_kbx_param_name()) startTime = tVal.get_start_time() endTime = tVal.get_end_time() except: # Backward compatible to daily_task kbxTime = KBXTime(kbxParamName="time") startTime = endTime = kbxTime.cast(request.get_arg("time")) execTime = request.get_arg(AppConstants.KEY_CONDITION_TIMESTAMP) execTime = datetime.datetime.fromtimestamp(execTime) execTime = (execTime.hour * 3600) + (execTime.minute * 60) + (execTime.second) if endTime < startTime: checkRange = [(startTime, 86400), (0, endTime + 59)] else: checkRange = [(startTime, endTime + 59)] for startVal, endVal in checkRange: if startVal <= execTime <= endVal: response = True break else: response = False if not response: raise AutomationException(11800) self.send_response({}, request.requestId) except AutomationException as ae: Logger.log_error("TimerModule 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 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 stop_scene(self, sceneId): ''' Stop a scene execution. ''' sceneExecLock = self.__sceneExecLocks.get(sceneId, None) if sceneExecLock is None: raise AutomationException( 11905, "Call stop only after execute_scene is called") else: sceneExecLock.set_stop()
def delete_favorited_scene(self, request): # Parameters try: paramKey = "sceneId" sceneId = request.get_value(paramKey) except Exception as e: self.send_response(request.requestId, data=AutomationException(11097, " - ".join((paramKey, str(e))))) return # Implementations try: self.__sceneService.delete_favorited_scene(sceneId) self.send_response(request.requestId) except Exception as e: if not isinstance(e, AutomationException): traceback.print_exc() e = AutomationException(11099, str(e)) self.send_response(request.requestId, data=e)
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 update_kbx_method(self, kbxMethodId): ''' Returns: None: Method Removed True: Method Active False: Method Inactive ''' hasKBXMethod = self.__apiController.has_kbx_method(kbxMethodId) if not hasKBXMethod: raise AutomationException(11602, "Method ID provided: " + str(kbxMethodId)) try: kbxMethod = SharedMethod.get_shared_method_by_id(kbxMethodId, language=AppInfo.DEFAULT_API_LANGUAGE) except SystemException as se: if se.value["returnValue"] == 1608: self.__methodController.delete(kbxMethodId) return None # None: Method Removed else: raise AutomationException(11601, "Unexpected returnValue when get method: " + str(se)) else: self.__methodController.update(kbxMethod) return kbxMethod["kbxMethodStatus"] == SharedMethod.METHOD_STATUS_ACTIVE # True: Active, False: Inactive
def update_kbx_group(self, kbxGroupId): ''' Returns None: Group Removed True: Group Exists ''' hasKBXGroup = self.__apiController.has_kbx_group(kbxGroupId) if not hasKBXGroup: raise AutomationException(11603, "Group ID provided: " + str(kbxGroupId)) try: kbxGroup = SharedMethod.get_shared_method_group_by_id(kbxGroupId, enableTagCount=False, language=AppInfo.DEFAULT_API_LANGUAGE) except SystemException as se: if se.value["returnValue"] == 1609: self.__groupController.delete(kbxGroupId) return None else: raise AutomationException(11601, "Unexpected returnValue when get method group: " + str(se)) else: self.__groupController.update(kbxGroup) return True
def __time_range(self, request): try: try: tVal = request.get_value(TimerModule._PARAM_TIME_RANGE.get_kbx_param_name()) startTime = tVal.get_start_time() endTime = tVal.get_end_time() except: # Backward compatible to daily_task kbxTime = KBXTime(kbxParamName="time") startTime = endTime = kbxTime.cast(request.get_arg("time")) execTime = request.get_arg(AppConstants.KEY_CONDITION_TIMESTAMP) execTime = datetime.datetime.fromtimestamp(execTime) execTime = (execTime.hour * 3600) + (execTime.minute * 60) + (execTime.second) if endTime < startTime: checkRange = [(startTime, 86400), (0, endTime + 59)] else: checkRange = [(startTime, endTime + 59)] for startVal, endVal in checkRange: if startVal <= execTime <= endVal: response = True break else: response = False if not response: raise AutomationException(11800) self.send_response({}, request.requestId) except AutomationException as ae: Logger.log_error("TimerModule 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 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())