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 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 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 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 getActions(self, roomName, buildingName):
checkData(locals())
room = Room(buildingName = buildingName, roomName = roomName)
room.retrieve()
actionList = room.getActions( )
response = []
for action in actionList:
response.append(action.getDict())
return {"actions" : response}
def getGroups(self, roomName, buildingName):
checkData(locals())
room = Room(buildingName = buildingName, roomName = roomName)
room.retrieve()
groupList = room.getGroups( )
response = []
for group in groupList:
response.append(group.getDict())
return {"groups" : response}
def getUsers(self, roomName, buildingName):
checkData(locals())
room = Room(buildingName = buildingName, roomName = roomName)
room.retrieve()
userList = room.getUsers( )
response = []
for user in userList:
response.append(user.getDict())
return {"users" : response}
def getUnassignedRooms(self): from app.backend.model.room import Room query = "SELECT * FROM rooms where (room_name,building_name) NOT IN (SELECT room_name,building_name FROM users_rooms) AND building_name='@@building_name@@'" database = Database() database.open() query = self.__replaceSqlQueryToken(query) queryResult = database.executeReadQuery(query) database.close() roomList = [] for roomRecord in queryResult: room = Room(roomName = roomRecord[0], buildingName = self.buildingName) room.retrieve() roomList.append(room) return roomList
def getRooms(self):
print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") : non yet tested"
from app.backend.model.room import Room
query = "SELECT room_name FROM rooms WHERE building_name = '@@building_name@@';"
database = Database()
database.open()
query = self.__replaceSqlQueryToken(query)
queryResult = database.executeReadQuery(query)
database.close()
roomList = []
for roomRecord in queryResult:
room = Room(roomName = roomRecord[0], buildingName = self.buildingName)
room.retrieve()
roomList.append(room)
return roomList
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 getRooms(self): from app.backend.model.room import Room database = Database() database.open() query = "SELECT * FROM rooms_groups WHERE group_id = '@@id@@' AND building_name = '@@building_name@@';" query = self.__replaceSqlQueryToken(query) queryResult = database.executeReadQuery(query) database.close() roomList = [] for record in queryResult: buildingName = record[1] roomName = record[2] room = Room(roomName = roomName, buildingName = buildingName) room.retrieve() roomList.append(room) return roomList
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()
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 getInfo(self, roomName, buildingName): checkData(locals()) room = Room(buildingName = buildingName, roomName = roomName) room.retrieve() return room.getDict()
def getRoom(self): from app.backend.model.room import Room room = Room(roomName = self.roomName, buildingName = self.buildingName) room.retrieve() return room
def sendNotification(self, userUuid = None, buildingName = None, groupId = None, roomName = None, messageSubject = None, messageText = None):
checkData(locals())
if not messageSubject:
raise NewNotificationMissingInputError("messageSubject is mandatory to send a new notification")
if not messageText:
raise NewNotificationMissingInputError("messageText is mandatory to send a new notification")
if not userUuid and not buildingName:
raise NewNotificationMissingInputError("You have to specify at least one recipient to send a new notification")
if buildingName and not roomName and not groupId:
raise NewNotificationMissingInputError("You cannot send a notification to an entire building. You have to specify at least a room or a group.")
if not buildingName and not roomName and not groupId:
raise NewNotificationMissingInputError("You have to specify at least one recipient to send a new notification.")
recipientUuidList = []
if userUuid:
recipientUuidList.append(userUuid)
if buildingName and roomName:
from app.backend.model.room import Room
room = Room(buildingName = buildingName, roomName = roomName)
room.retrieve()
for user in room.getUsers():
recipientUuidList.append(user.uuid)
# managing rooms insid a cross validation group
for group in room.getGroups():
if group.crossRoomsValidation:
for gRoom in group.getRooms():
for user in gRoom.getUsers():
recipientUuidList.append(user.uuid)
if buildingName and groupId:
from app.backend.model.group import Group
from app.backend.model.room import Room
group = Group(buildingName = buildingName, id = groupId)
group.retrieve()
for room in group.getRooms():
for user in room.getUsers():
recipientUuidList.append(user.uuid)
# Removing duplicate Id
recipientUuidList = list(set(recipientUuidList))
for recipientUuid in recipientUuidList:
notification = Notification(recipientUuid = recipientUuid, messageSubject = messageSubject, messageText = messageText)
notification.store()
return {}
