def getFirstFreeUserSlot(self):
print "TODO REMOVE THIS METHOD - NEEDED ONLY FOR THE EXPERIMENTS"
userList = []
database = Database()
query = "SELECT * FROM users WHERE password='******' LIMIT 1;"
database.open()
queryResult = database.executeReadQuery(query)
database.close()
if len(queryResult) == 0:
raise UserNotFoundError("No more slots available for new users. Thanks for your help! See ya!")
for record in queryResult:
uuid = record[0]
username = record[1]
email = record[2]
password = record[3]
personName = record[4]
level = record[5]
registrationTimestamp = datetime.datetime.now()
user = User(uuid = uuid, username = username, email = email, password = password, personName = personName, level = level, registrationTimestamp = registrationTimestamp)
user.store()
return user
def getTodayToken(self, userUuid):
user = User(uuid=userUuid)
user.retrieve()
days = []
for i in range(0, 7):
days.append((user.registrationTimestamp + timedelta(days=i)).strftime("%Y-%m-%d"))
today = str(time.strftime("%Y-%m-%d"))
if today not in days:
raise UnknownError(
"Today is not enabled for to use by the MTurk service. All the actions performed today will not be paid!"
)
day = days.index(today)
userRules = user.getCreatedRules()
createdRulesCount = 0
editedRulesCount = 0
for rule in userRules:
if str(rule.creationTimestamp).startswith(today):
createdRulesCount += 1
elif str(rule.lastEditTimestamp).startswith(today):
editedRulesCount += 1
userActionsCount = createdRulesCount + editedRulesCount
result = {}
requiredUserActions = [10, 8, 7, 5, 4, 3, 2]
# requiredUserActions = [2, 8, 7, 5 , 4, 3, 2]
if userActionsCount >= requiredUserActions[day]:
result["taskCompleted"] = True
result["message"] = "You completed your today task!"
result["token"] = self._getTokenFromDb(userUuid=userUuid, day=day)
else:
result["message"] = (
"You have still to perform "
+ str(requiredUserActions[day] - userActionsCount)
+ " actions on the rule sets!"
)
result["taskCompleted"] = False
result["currentDay"] = day + 1
result["serverDatetime"] = str(time.strftime("%Y-%m-%d %H:%M:%S"))
if day == 6 and result["taskCompleted"]:
result["experimentCompleted"] = True
else:
result["experimentCompleted"] = False
return {"mturk-status": result}
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 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 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 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 editRule(self, ruleId = None, priority = None, buildingName = None, groupId = None, authorUuid = None, ruleBody = None): from app.backend.model.rule import Rule oldRule = Rule(id = ruleId) oldRule.retrieve() from app.backend.model.user import User author = User(uuid = authorUuid) author.retrieve() result = self.__addOrModifyRule(ruleId = ruleId, priority = priority, buildingName = buildingName, groupId = groupId, authorUuid = authorUuid, ruleBody = ruleBody) from app.backend.controller.notificationsManager import NotificationsManager notifications = NotificationsManager() messageSubject = "Rule modified in building " + str(buildingName) + " group " + str(groupId) messageText = "The user " + str(author.username) + " edited (or tried to edit) the rule <<" + str(oldRule.getFullRepresentation()) + ">>. The new rule is <<" + str(ruleBody) + ">>" notifications.sendNotification(buildingName = buildingName, groupId = groupId, messageSubject = messageSubject, messageText = messageText) return result
def getNotifications(self, userUuid, username, automaticallySetAsRead = True):
checkData(locals())
from app.backend.model.user import User
user = User(username = username)
user.retrieve()
if str(userUuid) != str(user.uuid):
raise UserCredentialError("You cannot other users' notifications!")
notifications = Notifications()
notificationList = []
for notification in notifications.retrieveNotifications(userUuid = userUuid):
if automaticallySetAsRead: notification.setAsRead()
notificationList.append(notification.getDict())
return {"notifications" : notificationList}
def getGroups(self, buildingName, username = None):
checkData(locals())
building = Building(buildingName = buildingName)
building.retrieve()
groupList = []
if username:
from app.backend.model.user import User
user = User(username = username)
user.retrieve()
for buildingGroup in building.getGroups():
for userGroup in user.getGroups():
if buildingGroup.buildingName == userGroup.buildingName and buildingGroup.id == userGroup.id:
groupList.append(userGroup.getDict())
else:
for group in building.getGroups():
groupList.append(group.getDict())
return {"groups" : groupList}
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 getInfo(self, username = None, uuid = None):
checkData(locals())
if username:
user = User(username = username)
user.retrieve()
return user.getDict()
elif uuid:
user = User(uuid = uuid)
user.retrieve()
return user.getDict()
else:
raise MissingInputDataError("You need to specify at least the username or the uuid to gather user information")
def register(self, creatorUuid, newUserUsername, newUserPassword, newUserEmail, newUserPersonName, newUserLevel):
checkData(locals())
creatorUser = User(uuid = creatorUuid)
creatorUser.retrieve()
if creatorUser.level != 0:
raise UserCredentialError("Only root user can create new users")
try:
user = User(username = newUserUsername)
user.retrieve()
raise UsernameNotAvailableError("The username " + newUserUsername + " has been alredy assigned")
except UserNotFoundError as e:
if not(newUserUsername and newUserPassword and newUserEmail and newUserPersonName and newUserLevel):
raise MissingInputDataError("Some input data are missing to register a new user")
user = User(username = newUserUsername, password = newUserPassword, email = newUserEmail, personName = newUserPersonName, level = newUserLevel)
user.store()
return user.getDict()
def registerTemporary(self, newUserUsername, newUserPassword, newUserEmail, newUserPersonName, newUserLevel = 10):
checkData(locals())
try:
user = User(username = newUserUsername)
user.retrieve()
raise UsernameNotAvailableError("The username " + newUserUsername + " has been alredy assigned")
except UserNotFoundError as e:
if not(newUserUsername and newUserPassword and newUserEmail and newUserPersonName and newUserLevel):
raise MissingInputDataError("Some input data are missing to register a new user")
users = Users()
freeUserSlot = users.getFirstFreeUserSlot()
freeUserSlot.username = newUserUsername
freeUserSlot.password = newUserPassword
freeUserSlot.email = newUserEmail
freeUserSlot.personName = newUserPersonName
freeUserSlot.store()
return freeUserSlot.getDict()
def getUsers(self): from app.backend.model.user import User database = Database() database.open() query = "SELECT * FROM users_rooms WHERE room_name = '@@room_name@@' AND building_name = '@@building_name@@';" query = self.__replaceSqlQueryToken(query) queryResult = database.executeReadQuery(query) database.close() userList = [] for record in queryResult: uuid = record[2] user = User(uuid = uuid) user.retrieve() userList.append(user) return userList
def getRooms(self, buildingName, username = None):
checkData(locals())
building = Building(buildingName = buildingName)
building.retrieve()
roomList = []
if username:
from app.backend.model.user import User
user = User(username = username)
user.retrieve()
for buildingRoom in building.getRooms():
for userRoom in user.getRooms():
if buildingRoom.buildingName == userRoom.buildingName and buildingRoom.roomName == userRoom.roomName:
roomList.append(userRoom.getDict())
else:
for room in building.getRooms():
roomList.append(room.getDict())
return {"rooms" : 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 editRule(self, ruleId, priority, buildingName, roomName, editorUuid, groupId, ruleBody = None, antecedent = None, consequent = None, enabled = True):
checkData(locals())
if not ruleBody:
if not antecedent: raise MissingInputDataError("")
if not consequent: raise MissingInputDataError("")
if ruleBody and antecedent: raise TooManyInputParametersError("")
if ruleBody and consequent: raise TooManyInputParametersError("")
from app.backend.model.rule import Rule
oldRule = Rule(id = ruleId)
oldRule.retrieve()
from app.backend.model.user import User
author = User(uuid = oldRule.authorUuid)
author.retrieve()
editor = User(uuid = editorUuid)
editor.retrieve()
writePermission = False
errorMessage = ""
# If this room is not related to a room, I cannot modify it from this method
if not oldRule.roomName:
raise UserCredentialError("You cannot modify this group related rule.")
# If this rule is not about this building
if oldRule.buildingName != buildingName:
raise UserCredentialError("You cannot modify the rule of another building.")
if author.uuid != editor.uuid:
if not groupId and not oldRule.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 oldRule.getRoom() not in editor.getRooms():
# raise UserCredentialError("You cannot modify a rule of a room you do not own.")
if groupId:
from app.backend.model.group import Group
group = Group(buildingName = buildingName, id = groupId)
group.retrieve()
if not group:
raise UserCredentialError("You cannot modify a rule of a room you do not own.")
if not group.crossRoomsValidation:
raise UserCredentialError("You cannot modify a rule you do not own.")
if not group.id in list(g.id for g in editor.getGroups()):
raise UserCredentialError("You cannot modify a rule belonging to a group you do not own.")
if not oldRule.getRoom().roomName in list(r.roomName for r in group.getRooms()):
raise UserCredentialError("You cannot modify a rule belonging to room that does not belongs to a group you do not own.")
if editor.level < oldRule.getPriority():
raise UserCredentialError("You cannot modify this rule since it has a too high priority for your user level")
authorUuid = editorUuid
result = self.__addOrModifyRule(ruleId = ruleId, priority = priority, buildingName = buildingName, roomName = roomName, authorUuid = authorUuid, ruleBody = ruleBody, antecedent = antecedent, consequent = consequent, enabled = enabled)
from app.backend.controller.notificationsManager import NotificationsManager
notifications = NotificationsManager()
messageSubject = "Rule modified in building " + str(buildingName) + " room " + str(roomName)
messageText = "The user " + str(editor.username) + " edited (or tried to edit) the rule <<" + str(oldRule.getFullRepresentation()) + ">>. The new rule is <<" + str(ruleBody) + ">>"
notifications.sendNotification(buildingName = buildingName, roomName = roomName, messageSubject = messageSubject, messageText = messageText)
return result
def getAuthor(self): from app.backend.model.user import User author = User(uuid = self.authorUuid) author.retrieve() return author
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 getUser(self, username, password = None): checkData(locals()) user = User(username = username, password = password) user.retrieve() return user
def __addOrModifyRule(self, priority = None, buildingName = None, groupId = None, authorUuid = None, ruleBody = None, ruleId = None):
checkData(locals())
import time,datetime
startTimeMilliseconds = long((time.time() + 0.5) * 1000)
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")
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.getMaxGroupPriority():
raise RulePriorityError("You can specify rules for groups 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.group import Group
if not ruleId:
rule = Rule(priority = priority, category = category, buildingName = buildingName, groupId = groupId, 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
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")
group = Group(buildingName = buildingName, id = groupId)
group.retrieve()
if not ruleId and not rule.checkIfUnique():
raise DuplicatedRuleError("The submitted rule is already been saved for the considered group.")
# excludedRuleId is needed to ignore the rule that the user want to edit
excludedRuleId = ruleId if ruleId else None
ruleCheckErrorList = []
groupRoomList = group.getRooms()
for room in groupRoomList:
groupRules = group.getRules(excludedRuleId = excludedRuleId)
# Checking that a priority is unique over the same category
for r in groupRules:
if str(r.category) == str(category) and int(r.getPriority()) == int(priority):
raise AlredyAssignedPriorityError("In group " + str(groupId) + " the priority " + str(priority) + " has alredy been assigned to another rule with the same category!")
temporaryRuleSet = []
temporaryRuleSet.extend(room.getRules(author = False, includeGroupsRules = True, excludedRuleId = False, excludeCrossRoomValidationRules = True))
temporaryRuleSet.extend(groupRules)
temporaryRuleSet.append(rule)
from app.backend.controller.rulesetChecker import RulesetChecker
rulesetChecker = RulesetChecker(temporaryRuleSet)
ruleCheckErrorList.extend(rulesetChecker.check())
if len(ruleCheckErrorList) == 0:
if ruleId: #if i'm in edit mode
rule.id = ruleId
rule.setPriority(priority)
# Disabling rules in all the groups rooms since they have to be validated again
for room in groupRoomList:
from app.backend.controller.notificationsManager import NotificationsManager
notifications = NotificationsManager()
messageSubject = "Group " + str(groupId) + " changed your room " + str(room.roomName) + " policy."
messageText = "Some rules in group " + str(groupId) + " have been changed."
notifications.sendNotification(buildingName = buildingName, roomName = room.roomName, messageSubject = messageSubject, messageText = messageText)
#for r in room.getRules(includeGroupsRules = False, excludeCrossRoomValidationRules = True):
# r.disable()
from app.backend.commons.console import flash
endTimeMilliseconds = long((time.time() + 0.5) * 1000)
opTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds
flash("GroupsRuleVerification [SUCCESS]: groupId = " + str(groupId) +" #rules=" + str(len(temporaryRuleSet)) + " - opTimeMilliseconds:" + str(opTimeMilliseconds))
return group.addRule(rule).getDict()
else:
from app.backend.commons.console import flash
logMessage = "authorUuid = " + str(authorUuid) + ", "
logMessage += "buildingName = " + str(buildingName) + ", "
logMessage += "gropuId = " + str(groupId) + ", "
logMessage += "ruleSetDescr = " + str(temporaryRuleSet) + ", "
logMessage += "newRule = " + str(rule)
flash("RuleValidationError: " + logMessage)
endTimeMilliseconds = long((time.time() + 0.5) * 1000)
opTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds
flash("GroupsRuleVerification [FAILED]: groupId = " + str(groupId) +" #rules=" + str(len(temporaryRuleSet)) + " - opTimeMilliseconds:" + str(opTimeMilliseconds))
raise RuleValidationError(ruleCheckErrorList + " Error in room " + room.roomName)
