def deleteRoom(self, buildingName, roomName): checkData(locals()) print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") not yet tested" print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") table rules_priority not correctly updated" from app.backend.model.room import Room room = Room(roomName = roomName, buildingName = buildingName) room.retrieve() ruleList = room.getRules() triggerList = room.getTriggers() actionList = room.getActions() for rule in ruleList: rule.delete() for trigger in triggerList: room.deleteTrigger(trigger) for action in actionList: room.deleteAction(action) room.delete() return {}
def test2(self): from app.backend.model.room import Room room = Room(buildingName="EEE", roomName="200") ruleList = room.getRules() from app.backend.controller.rulesetChecker import RulesetChecker rulesetChecker = RulesetChecker(ruleList) rulesetChecker.check()
def getConflictingRules(self, roomName, buildingName, ruleBody): checkData(locals()) ruleBody = ruleBody.strip() from app.backend.controller.triggerManager import TriggerManager from app.backend.controller.actionManager import ActionManager triggerManager = TriggerManager() actionManager = ActionManager() room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() ruleList = room.getRules( includeGroupsRules = True, includeDisabled = False) ruleAntecedent = ruleBody.split("then")[0].replace("if", "").strip() ruleConsequent = ruleBody.split("then")[1].strip() newRuleTranslatedTriggers = triggerManager.translateTrigger(ruleAntecedent) newRuleAction, originalModel, parameterValues = actionManager.getActionAndTemplateAndParameterValues(ruleConsequent) conflictingRuleList = [] for rule in ruleList: currentRuleAction, originalModel, parameterValues = actionManager.getActionAndTemplateAndParameterValues(rule.consequent) savedRuleTranslatedTriggers = triggerManager.translateTrigger(rule.antecedent) conflictingAntecedentFound = False for newRuleTrigger in newRuleTranslatedTriggers["triggers"]: for savedRuleTrigger in savedRuleTranslatedTriggers["triggers"]: if "between" not in newRuleTrigger["antecedent"]: if newRuleTrigger["antecedent"] == savedRuleTrigger["antecedent"] and (newRuleAction.category == currentRuleAction.category): conflictingAntecedentFound = True else: # In the case of range based antecedent I cannot just check if it is equal but I have to see the trigger name if newRuleTrigger["trigger"].triggerName == savedRuleTrigger["trigger"].triggerName and (newRuleAction.category == currentRuleAction.category): conflictingAntecedentFound = True if conflictingAntecedentFound: break if conflictingAntecedentFound: break if conflictingAntecedentFound: conflictingRuleList.append({"ruleId" : rule.id, "ruleBody" : rule.getFullRepresentation()}) return {"conflictingRules" : conflictingRuleList}
def getRules(self, roomName, buildingName, username = None, includeGroupsRules = False, orderByPriority = False, includeDisabled = False, categoriesFilter = None, includeTriggerCategory = False): checkData(locals(), ["categoriesFilter"]) if categoriesFilter: checkData(json.loads(categoriesFilter)) room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() ruleList = [] if username: from app.backend.model.user import User user = User(username = username) user.retrieve() ruleList = room.getRules( author = user, includeGroupsRules = includeGroupsRules, includeDisabled = includeDisabled, categoriesFilter = categoriesFilter) else: ruleList = room.getRules( includeGroupsRules = includeGroupsRules, includeDisabled = includeDisabled , categoriesFilter = categoriesFilter) if orderByPriority: ruleList = sorted(ruleList, key=lambda rule: rule.getPriority(), reverse=True) response = [] for rule in ruleList: ruleDict = rule.getDict(buildingName = buildingName, roomName = roomName) if includeTriggerCategory: from app.backend.controller.triggerManager import TriggerManager triggerManager = TriggerManager() triggers = triggerManager.translateTrigger(rule.antecedent)["triggers"] triggersCategory = [] for trigger in triggers: if trigger["trigger"].category not in triggersCategory: triggersCategory.append(trigger["trigger"].category) ruleDict.update({'triggersCategory' : triggersCategory}) response.append(ruleDict) return {"rules" : response}
def __addOrModifyRule(self, priority = None, buildingName = None, roomName = None, authorUuid = None, ruleBody = None, ruleId = None, antecedent = None, consequent = None, enabled = True): checkData(locals()) import time,datetime startTimeMilliseconds = long((time.time() + 0.5) * 1000) if ruleBody: try: antecedent = ruleBody.split("then")[0].replace("if ", "").strip() consequent = ruleBody.split("then")[1].strip() except Exception as e: raise NotWellFormedRuleError("There is a syntax error in the rule you are trying to save") # Detecting rule category (by the rule-consequent) from app.backend.controller.actionManager import ActionManager actionManager = ActionManager() category = actionManager.getAction(consequent).category from app.backend.model.user import User author = User(uuid = authorUuid) author.retrieve() if int(str(priority)) < 0 or int(str(priority)) > author.getMaxRoomPriority(): raise RulePriorityError("You can specify rules for rooms with a priority value between 0 and " + str(author.getMaxRoomPriority()) + ". You inserted " + str(priority)) from app.backend.model.rule import Rule from app.backend.model.room import Room if not ruleId: rule = Rule(priority = priority, category = category, buildingName = buildingName, roomName = roomName, authorUuid = authorUuid, antecedent = antecedent, consequent = consequent, enabled = True) else: rule = Rule(id = ruleId) rule.retrieve() author = rule.getAuthor() rule.antecedent = antecedent rule.consequent = consequent rule.authorUuid = authorUuid rule.authorUuid = authorUuid rule.enabled = enabled editor = rule.getAuthor() if editor.level < rule.getPriority(): raise UserCredentialError("You cannot modify this rule since it has a too high priority for your user level") room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() if not ruleId and not rule.checkIfUnique(): raise DuplicatedRuleError("The submitted rule is already been saved for the considered room.") # excludedRuleId is needed to ignore the rule that the user want to edit excludedRuleId = ruleId if ruleId else None roomRules = room.getRules(author = False, includeGroupsRules = True, excludedRuleId = excludedRuleId) # Checking that a priority is unique over the same category for r in roomRules: if str(r.category) == str(category) and int(r.getPriority()) == int(priority): raise AlredyAssignedPriorityError("In room " + roomName + " the priority " + str(priority) + " has alredy been assigned to another rule with the same category!") temporaryRuleSet = [] temporaryRuleSet.extend(roomRules) temporaryRuleSet.append(rule) #### OPTMIZATION ######################################################################################## # Removing rules with a trigger that is different form the one of the rule I'm trying to insert or modify from app.backend.controller.triggerManager import TriggerManager triggerManager = TriggerManager() newRuleTriggers = triggerManager.translateTrigger(rule.antecedent)["triggers"] for i in range(0, len(temporaryRuleSet)): otherRuleTriggers = triggerManager.translateTrigger(temporaryRuleSet[i].antecedent)["triggers"] deleteRule = False if rule.category == temporaryRuleSet[i].category: for t1 in newRuleTriggers: for t2 in otherRuleTriggers: if t1 == t2: deleteRule = True break; if deleteRule: break; if deleteRule: del temporaryRuleSet[i] #### OPTMIZATION ######################################################################################## for i in range(0, len(temporaryRuleSet)): temporaryRuleSet[i].groupId = None temporaryRuleSet[i].roomName = roomName from app.backend.controller.rulesetChecker import RulesetChecker rulesetChecker = RulesetChecker(temporaryRuleSet) ruleCheckErrorList = rulesetChecker.check() if len(ruleCheckErrorList) == 0: if ruleId: rule.id = ruleId rule.setPriority(priority) from app.backend.commons.console import flash endTimeMilliseconds = long((time.time() + 0.5) * 1000) opTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds flash("RoomRuleVerification [SUCCESS]: roomName = " + str(roomName) +" #rules=" + str(len(temporaryRuleSet)) + " - opTimeMilliseconds:" + str(opTimeMilliseconds)) return room.addRule(rule).getDict() else: from app.backend.commons.console import flash logMessage = "authorUuid = " + str(authorUuid) + ", " logMessage += "buildingName = " + str(buildingName) + ", " logMessage += "roomName = " + str(roomName) + ", " logMessage += "ruleSetDescr = " + str(temporaryRuleSet) + ", " logMessage += "newRule = " + str(rule) flash("RuleValidationError: " + logMessage) endTimeMilliseconds = long((time.time() + 0.5) * 1000) opTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds flash("RoomRuleVerification [FAILED]: roomName = " + str(roomName) +" #rules=" + str(len(temporaryRuleSet)) + " - opTimeMilliseconds:" + str(opTimeMilliseconds)) raise RuleValidationError(ruleCheckErrorList)
def test0(self): from app.backend.commons.database import Database from app.backend.model.building import Building from app.backend.model.group import Group from app.backend.model.room import Room from app.backend.model.user import User from app.backend.model.rule import Rule print "Starting test..." print "Cleaning database..." database = Database() database.open() database.executeWriteQuery("TRUNCATE TABLE buildings") database.executeWriteQuery("TRUNCATE TABLE groups") database.executeWriteQuery("TRUNCATE TABLE rooms") database.executeWriteQuery("TRUNCATE TABLE users") database.executeWriteQuery("TRUNCATE TABLE users_rooms") database.executeWriteQuery("TRUNCATE TABLE rooms_groups") database.executeWriteQuery("TRUNCATE TABLE rules") database.close() print "Testing model..." building = Building(buildingName = "CSE", label = "Computer Science", description = "This is a nice place") building.store() building = Building(buildingName = "CSE", label = "Computer Science", description = "This is a great place") building.store() building = Building(buildingName = "CSE") building.retrieve() print building group = Group(buildingName = "CSE", description = "Questo gruppo eheh") group.store() print group group = Group(id=1, buildingName = "CSE") group.retrieve() print group group = Group(id=1, buildingName = "CSE", description = "we ciao ciao") group.store() group = Group(id=1, buildingName = "CSE") group.retrieve() print group room = Room(roomName = "200", buildingName = "CSE", description = "Bella 3333") room.store() room = Room(roomName = "200", buildingName = "CSE") room.retrieve() print room print "room.getBuilding() test" print room.getBuilding() user = User(username = "******", email = "*****@*****.**", password = "******", personName = "Alessandro Nacci", level = 10) user.store() room.addUser(user) print "user.getRooms() test" for room in user.getRooms(): print room print "group.addRoom(room) test" group.addRoom(room) print group print "User test 1" user = User(username = "******") user.retrieve() print user print "User test 2" user = User(username = "******", password="******") user.retrieve() print user print "User test 3" user = User(uuid = 1) user.retrieve() print user rule = Rule(priority = 1, category = "ELECTRICT222", buildingName = "CSE", groupId = 1, roomName = "200", authorUuid = 1, antecedent = "the ligjt is on", consequent = "turn off the light", enabled = 1, deleted = 0) rule.store() rule = Rule(id = 1) rule.retrieve() print rule print rule.getBuilding() print rule.getGroup() print rule.getAuthor() print "test group.getRules()" ruleList = group.getRules() for r in ruleList: print r print "test room.getRules()" ruleList = room.getRules() for r in ruleList: print r print "test room.getRules(author)" ruleList = room.getRules(author = user, includeGroupsRules = None) for r in ruleList: print r print "test room.getRules(includeGroupsRules)" ruleList = room.getRules(includeGroupsRules = True) for r in ruleList: print r print "test user.getCreatedRules()" ruleList = user.getCreatedRules() for r in ruleList: print r group.deleteRoom(room) room.deleteUser(user) rule.delete() user.delete() group.delete() building.delete() room.delete() user = User(username = "******") user.retrieve()