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 deleteGroup(self, buildingName, groupId):
checkData(locals())
print "\t\t\t\t\t\t\t\tTODO (" + self.__class__.__name__ + ":" + sys._getframe().f_code.co_name + ") not yet tested"
from app.backend.model.group import Group
group = Group(buildingName = buildingName, id = groupId)
roomList = group.getRooms()
ruleList = group.getRules()
for room in roomList:
group.deleteRoom(room)
for rule in ruleList:
rule.delete()
group.delete()
return {}
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 __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)
