def getActionAndTemplateAndParameterValues(self, ruleConsequent): checkData(locals()) actions = Actions() actionList = actions.getAllActions() for action in actionList: # A action.ruleConsequent is represented as set of templates models: # Example "template1 | template2 | template2" models = action.ruleConsequent.split('|') for model in models: parameterNumber = model.count("@val") originalModel = model.strip() model = model.replace("@val","(.+)").strip() matchObj = re.match( model, ruleConsequent, re.M|re.I) if matchObj: parameterValues = {} for i in range(0,parameterNumber): parameterValues[str(i)] = matchObj.group(i + 1) return (action, originalModel, parameterValues) raise NotWellFormedRuleError("Impossible to find any action corresponding to the following rule consequent > " + ruleConsequent)
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 translateAction(self, ruleConsequent, getDict = False): checkData(locals()) actions = Actions() action, originalTemplate, parameterValues = self.getActionAndTemplateAndParameterValues(ruleConsequent) translationTemplate = actions.translateTemplate('Z3', originalTemplate) translatedParams = {} for key,value in parameterValues.iteritems(): translatedParams[key] = self.__translateParameters(action.category, value) translation = translationTemplate for i in range(0,len(parameterValues.keys())): value = translatedParams[str(i)] translation = translation.replace("@val", value, 1) if not getDict: return translation, action, translatedParams else: result = {} result["translation"] = translation result["action"] = action.getDict() result["translatedParams"] = translatedParams return result
def getInfo(self, buildingName): checkData(locals()) building = Building(buildingName = buildingName) building.retrieve() return building.getDict()
def setNotificationAsUnread(self, notificationId): checkData(locals()) notification = Notification(id = notificationId) notification.setAsUnread() return {}
def getTriggerAndTemplateAndParameterValues(self, ruleAntecedent): checkData(locals()) triggers = Triggers() triggerList = triggers.getAllTriggers() for trigger in triggerList: # A trigger.ruleAntecedent is represented as set of templates models: # Example "template1 | template2 | template2" # Where each template can be like # "it is between %d AM and %d AM | it is between %d AM and %d PM | it is between %d PM and %d AM | it is between %d PM and %d PM" models = trigger.ruleAntecedent.split('|') for model in models: parameterNumber = model.count("@val") originalModel = model.strip() model = model.replace("@val","(.+)").strip() matchObj = re.match( model, ruleAntecedent, re.M|re.I) if matchObj: parameterValues = {} for i in range(0,parameterNumber): parameterValues[str(i)] = matchObj.group(i + 1) return (trigger, originalModel, parameterValues) raise NotWellFormedRuleError("Impossible to find any trigger corresponding to the following rule consequent > " + ruleAntecedent)
def storeFeedback(self, authorUuid, alternativeContact = None, score = None, message = None): checkData(locals()) feedback = Feedback(authorUuid = authorUuid, alternativeContact = alternativeContact, score = score, message = message) feedback.store() return feedback.getDict()
def addRoom(self, groupId, roomName, buildingName): checkData(locals()) group = Group(buildingName = buildingName, id = groupId) group.retrieve() from app.backend.model.room import Room room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() if group.crossRoomsValidation: print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") This part of the method as not been tested" # In this case we have to check that the room doesn't belong to another CrossRoomValidatioGroup from app.backend.model.building import Building building = Building(buildingName = buildingName) building.retrieve() crvgList = building.getCrossRoomValidationGroups(roomName = roomName, validationCategories = group.crossRoomsValidationCategories) if len(crvgList) > 0: raise WrongBuildingGroupRipartitionError("A room can belong to only one cross validation group per category. Room " + str(roomName) + " in already in group " + str(crvgList[0])) group.addRoom(room) return room.getDict()
def login(self, username, password): checkData(locals()) if len(password) == 0 or len(username) == 0: raise MissingInputDataError("Insert username and password!") from app.backend.controller.usersManager import UsersManager usersManager = UsersManager() try: user = usersManager.getUser(username, password) sessionKey = self.__generateSessionKey() userUuid = user.uuid expireTimestamp = datetime.datetime.now() + datetime.timedelta(days=1) session = Session(sessionKey = sessionKey, userUuid = userUuid, expireTimestamp = expireTimestamp) try: session.store() sessionData = {"sessionKey" : sessionKey, "userUuid" : userUuid} return sessionData except SessionCreationError as e: raise e else: return None except UserNotFoundError as e: raise e else: return None
def getCrossRoomValidationGroups(self, buildingName, roomName = None, validationCategories = None): checkData(locals()) building = Building(buildingName = buildingName) building.retrieve() return building.getCrossRoomValidationGroups(roomName = roomName, validationCategories = validationCategories)
def deleteRule(self, ruleId, buildingName, roomName, editorUuid): checkData(locals()) room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() from app.backend.model.rule import Rule rule = Rule(id = ruleId) rule.retrieve() from app.backend.model.user import User editor = User(uuid = editorUuid) editor.retrieve() author = User(uuid = rule.authorUuid) author.retrieve() # If this room is not related to a room, I cannot modify it from this method if not rule.roomName: raise UserCredentialError("You cannot modify this group related rule.") # If this rule is not about this building if rule.buildingName != buildingName: raise UserCredentialError("You cannot modify the rule of another building.") if author.uuid != editor.uuid: if not rule.groupId and not rule.getRoom().roomName in list(r.roomName for r in editor.getRooms()): raise UserCredentialError("You cannot modify a rule of a room you do not own.") #if rule.getRoom() not in editor.getRooms(): # raise UserCredentialError("You cannot modify a rule of a room you do not own.") if rule.groupId: from app.backend.model.group import Group group = Group(buildingName = buildingName, id = groupId) group.retrieve() if not group: raise UserCredentialError("You cannot delete a rule of a room you do not own.") if not group.crossRoomsValidation: raise UserCredentialError("You cannot delete a rule you do not own.") if not group.id in list(g.id for g in editor.getGroups()): raise UserCredentialError("You cannot delete a rule belonging to a group you do not own.") if not rule.getRoom().roomName in list(r.roomName for r in group.getRooms()): raise UserCredentialError("You cannot delete a rule belonging to room that does not belongs to a group you do not own.") if editor.level < rule.getPriority(): raise UserCredentialError("You cannot modify this rule since it has a too high priority for your user level") room.deleteRule(rule) return {}
def __init__(self, buildingName = None, startDate = None, numberOfDays = None, roomFilter = None): checkData(locals()) self.buildingName = buildingName self.startDate = startDate self.numberOfDays = numberOfDays self.roomFilter = roomFilter
def getRuleInfo(self, buildingName = None, roomName = None, ruleId = None): checkData(locals()) from app.backend.model.rule import Rule rule = Rule(id = ruleId, buildingName = buildingName, roomName = roomName) rule.retrieve() return rule.getDict(buildingName = None, roomName = None)
def getRoomList(self, username): checkData(locals()) print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") : not yet tested" user = User(username = username) user.retrieve() return user.getRooms()
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 getAllBuildings(self): checkData(locals()) buildings = Buildings() buildingList = [] for building in buildings.getAllBuildings(): buildingList.append(building.getDic()) return {"buildings" : buildingList}
def setRulePriority(self, buildingName, roomName, ruleId, rulePriority): checkData(locals()) from app.backend.model.rule import Rule rule = Rule(id = ruleId, buildingName = buildingName, roomName = roomName) rule.retrieve() rule.setPriority(buildingName = buildingName, roomName = roomName, priority = rulePriority) return rule.getDict(buildingName = buildingName, roomName = roomName)
def getRooms(self, groupId, buildingName): checkData(locals()) group = Group(buildingName = buildingName, id = groupId) group.retrieve() roomList = [] for room in group.getRooms(): roomList.append(room.getDict()) return {"rooms" : roomList}
def getTriggers(self, buildingName = None, groupId = None): checkData(locals()) from app.backend.model.triggers import Triggers triggers = Triggers() triggerList = [] for trigger in triggers.getAllTriggers(): triggerList.append(trigger.getDict()) return {"triggers" : triggerList}
def addRoom(self, roomName, buildingName, description): checkData(locals()) from app.backend.model.room import Room room = Room(roomName = roomName, buildingName = buildingName, description = description) building = Building(buildingName = buildingName) building.retrieve() return building.addRoom(room).getDict()
def getActions(self, buildingName = None, groupId = None): checkData(locals()) from app.backend.model.actions import Actions actions = Actions() actionList = [] for action in actions.getAllActions(): actionList.append(action.getDict()) return {"actions" : actionList}
def sendNotificationByEmail(self, recipientUuid, messageSubject, messageText): checkData(locals()) from app.backend.model.user import User recipientUser = User(uuid = recipientUuid) recipientUser.retrieve() recipient = recipientUser.email subject = "[BuldingRules Notification] " + messageSubject message = messageText self.__send_message(recipient = recipient, subject = subject, message = message)
def getUnassignedRooms(self, buildingName): checkData(locals()) building = Building(buildingName = buildingName) building.retrieve() roomList = [] for room in building.getUnassignedRooms(): roomList.append(room.getDict()) return {"rooms" : roomList}
def getTriggerCategories(self): checkData(locals()) triggers = Triggers() triggerList = triggers.getAllTriggers() categories = [] for trigger in triggerList: if trigger.category not in categories: categories.append(trigger.category) return categories
def __init__(self, buildingName = None, roomName = None, occupancyTimeRangeFrom = None, occupancyTimeRangeTo = None, roomTemperature = None, externalTemperature = None, weather = None, currentDate = None): checkData(locals()) self.buildingName = buildingName self.roomName = roomName self.occupancyTimeRangeFrom = occupancyTimeRangeFrom self.occupancyTimeRangeTo = occupancyTimeRangeTo self.roomTemperature = roomTemperature self.externalTemperature = externalTemperature self.weather = weather self.currentDate = currentDate
def getRules(self, groupId, buildingName): checkData(locals()) group = Group(buildingName = buildingName, id = groupId) group.retrieve() ruleList = group.getRules() response = [] for rule in ruleList: response.append(rule.getDict()) return {"rules" : response}
def enableRule(self, ruleId, buildingName, roomName, editorUuid): checkData(locals()) room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() from app.backend.model.rule import Rule rule = Rule(id = ruleId) rule.retrieve() return self.editRule(ruleId = rule.id, priority = rule.getPriority(), buildingName = buildingName, roomName = roomName, editorUuid = editorUuid, groupId = rule.groupId, ruleBody = None, antecedent = rule.antecedent, consequent = rule.consequent, enabled = True)
def getBuildingList(self, username): checkData(locals()) user = User(username = username) user.retrieve() response = [] buildingList = user.getBuildings() for building in buildingList: response.append(building.getDict()) return {"buildings" : response}
def checkUserBinding(self, buildingName, username): checkData(locals()) from app.backend.model.user import User building = Building(buildingName = buildingName) building.retrieve() user = User(username = username) user.retrieve() building.checkUserBinding(user)
def getActionCategories(self): checkData(locals()) actions = Actions() actionList = actions.getAllActions() categories = [] for action in actionList: if action.category not in categories: categories.append(action.category) return categories