def test_room_init(self):
"""
Tests models.Room.__init__ to ensure that it correctly checks input
"""
for test in self.room_init_test_cases:
if issubclass(test[KEY_EXPECTED_TYPE], Exception):
with self.assertRaises(test[KEY_EXPECTED_TYPE]):
result = models.Room(**test[KEY_INPUT])
else:
result = models.Room(**test[KEY_INPUT])
self.assertTrue(isinstance(result, test[KEY_EXPECTED_TYPE]))
self.assertEqual(result.size, test[KEY_EXPECTED].value)
def post(self):
try:
parser = reqparse.RequestParser()
parser.add_argument('uploader', type=str)
parser.add_argument('address', type=str)
parser.add_argument('contact', type=str)
parser.add_argument('introduction', type=str)
parser.add_argument('latitude', type=float)
parser.add_argument('longitude', type=float)
args = parser.parse_args()
if args['uploader'] is None or not args['uploader']:
return {'Error': 'null data is not allowed'}, 400
if args['address'] is None or not args['address']:
return {'Error': 'null data is not allowed'}, 400
if args['contact'] is None or not args['contact']:
return {'Error': 'null data is not allowed'}, 400
if args['latitude'] is None:
return {'Error': 'null data is not allowed'}, 400
if args['longitude'] is None:
return {'Error': 'null data is not allowed'}, 400
if args['introduction'] is None:
args['introduction'] = ' '
room = models.Room(**args)
db.session.add(room)
db.session.commit()
return {'success': True}, 200
except Exception as e:
print(e)
return {'Error': str(e)}, 400
def create_room():
topic = flask.request.form['topic']
room = models.Room()
room.topic = topic
db.session.add(room)
db.session.commit()
r_id = room.id
return flask.redirect(flask.url_for('room_view', r_id=r_id), code=303)
def create_room():
if not request.is_json:
return error.error_400("Expected JSON")
try:
newRoom = models.Room(roomname=request.json["roomName"])
session.add(newRoom)
session.commit()
except KeyError:
return error.error_400("Missing field in body: 'roomName'")
if newRoom.roomid is None:
return error.error_400("Error adding room to database")
return success.success_200({"roomId": newRoom.roomid})
def createDatabase(self):
"""Create the Required Database Objects"""
session = models.meta.Session()
arSession = self.Session()
#log.setLevel(logging.WARNING)
deploymentName = "archRock"
houseName = self.houseAddress
theDep = session.query(models.Deployment).filter_by(name=deploymentName).first()
log.debug("Checking for existing deployment {0}".format(theDep))
if theDep is None:
#Create a new deployment
theDep = models.Deployment(name=deploymentName)
session.add(theDep)
session.flush()
log.debug("Adding Deployment to database {0}".format(theDep))
#And check for Houses
theHouse = session.query(models.House).filter_by(address=houseName).first()
log.debug("Checking for house {0}".format(theHouse))
if theHouse is None:
theHouse = models.House(address=houseName,
deploymentId = theDep.id)
session.add(theHouse)
session.flush()
log.debug("Adding New House {0}".format(theHouse))
self.theHouse = theHouse
emptyRoom = session.query(models.RoomType).filter_by(name="Unocupied").first()
nodeMap = {}
#Temp storage for <ADDDR> <Node>
addrMap = {}
#We want to setup nodes / Rooms / Locations based on the node_dimension table
log.info("Setting Up Nodes")
nodeQry = arSession.query(Ar_Node)
for item in nodeQry:
#Dont bother with the router
if item.name == "archrock-router":
continue
#Check / Create a node if required
nodeId = int(item.addr[8:],16)
log.debug("{0} {1} {2}".format(item,item.addr,nodeId))
#nodeId = BASE_NODE_ID + item.short_addr
theNode = session.query(models.Node).filter_by(id = nodeId).first()
if theNode is None:
theNode = models.Node(id=nodeId)
session.add(theNode)
session.flush()
log.debug("Creating New Node {0}".format(theNode))
#Next we create a room / Location
roomName = item.name
if not roomName == "":
log.debug("Room Name is {0}".format(roomName))
theRoom = session.query(models.Room).filter_by(name=roomName).first()
if theRoom is None:
theRoom = models.Room(name=roomName,
roomTypeId=emptyRoom.id)
log.debug("Creating Room {0}".format(theRoom))
session.add(theRoom)
session.flush()
#And now we can turn this room into a Location
theLocation = session.query(models.Location).filter_by(houseId=theHouse.id,
roomId = theRoom.id).first()
if theLocation is None:
theLocation = models.Location(houseId = theHouse.id,
roomId = theRoom.id)
session.add(theLocation)
log.debug("Creating Location {0}".format(theLocation))
session.flush()
#Last thing we create a mapping between the node and the Location
nodeMap[item.node_key] = [theNode,theLocation]
addrMap[item.addr] = theNode
#log.debug(nodeMap)
self.nodeMap = nodeMap
#We also need to do mapping for sensor types etc
#theQry = arSession.query(Source)
#Map the Types we are expecting to types from the database
sensorTypeMap = {}
log.info("Mapping Sensor Types")
for sType in ALLOWED_TYPES:
theType = session.query(models.SensorType).filter_by(name=sType[1]).first()
log.debug("AR: {0} Local {1}".format(sType,theType))
sensorTypeMap[sType[0]] = theType
#log.debug(sensorTypeMap)
sensorMap = {}
sQry = arSession.query(Source)
for item in sQry:
thisItem = sensorTypeMap.get(item.source,None)
if thisItem:
sensorMap[item.datasource_key] = sensorTypeMap[item.source]
self.sensorMap = sensorMap
log.setLevel(logging.DEBUG)
log.info("Commtitting Changes")
session.flush()
session.commit()
3: models.Attendee(ucid="lr123"),
}
MOCK_APPOINTMENT_DB_ENTRIES = {
1:
models.Appointment(
room_id=1,
start_time=datetime.datetime(2020, 1, 1, 12, 0, 0),
end_time=datetime.datetime(2020, 1, 1, 13, 0, 0),
organizer_id=1,
attendee_ids=[1, 2, 3],
),
}
MOCK_ROOM_DB_ENTRIES = {
1: models.Room(
room_number=100,
capacity=10,
size=models.RoomSize.MEDIUM,
),
}
MOCK_UNAVAILABLE_DATE_DB_ENTRIES = {
1: models.UnavailableDate(
date=datetime.datetime(2020, 1, 1),
reason=None,
),
2: models.UnavailableDate(
date=datetime.date(2020, 1, 2),
reason="Snow Day",
),
}
MOCK_CHECK_IN_DB_ENTRIES = {
1:
def get_room(self, id):
return models.Room(self.query('SELECT * FROM room JOIN room_category WHERE room.id = %s' % id, one=True))
def get_rooms(self, id):
q = self.query('SELECT * from room JOIN room_category WHERE hid = %s' % id)
if q is None:
q = []
return [models.Room(x) for x in q]
def get_rooms_by_type(self, hotel_id, type):
q = self.query('SELECT * FROM room JOIN room_category WHERE hid = %s AND type="%s"' % (hotel_id, type))
if q is None:
q = []
return [models.Room(x) for x in q]
def seed():
"""Seed the database with sample data."""
import models
# the rooms
room_features = ['Projector', 'TV', 'Webcam', 'Phone Line']
rooms = {
'1560': ['Projector'],
'1561': ['TV', 'Webcam'],
'1562': ['Projector'],
'1563': ['TV'],
'1564': ['Projector'],
'1565': ['TV', 'Webcam'],
'1665': ['TV', 'Webcam'],
'1663': ['TV'],
'1662': ['Projector'],
'1661': ['Projector'],
'1660': ['Projector']
}
feature_dict = {}
for feature in room_features:
f = models.RoomFeature(name=feature)
get_db().add(f)
feature_dict[feature] = f
rooms_dict = {}
for room_number in rooms:
r = models.Room(number=room_number)
for feature in rooms[room_number]:
f = feature_dict[feature]
r.features.append(f)
rooms_dict[room_number] = r
get_db().add(r)
# the types of team
teamtype_dict = {}
teamtype_dict['single'] = models.TeamType(
name='single',
priority=4,
advance_time=7 * 2 # 2 weeks
)
get_db().add(teamtype_dict['single'])
get_db().add(
models.TeamType(
name='other_team',
priority=4,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='class',
priority=3,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='colab_class',
priority=2,
advance_time=7 * 2 # 2 weeks
))
get_db().add(
models.TeamType(
name='senior_project',
priority=1,
advance_time=7 * 2 # 2 weeks
))
# the permissions
perm_names = [
'team.create', 'team.create.elevated', 'team.delete',
'team.delete.elevated', 'team.read', 'team.read.elevated',
'team.update', 'team.update.elevated', 'reservation.create',
'reservation.delete', 'reservation.delete.elevated',
'reservation.read', 'reservation.update',
'reservation.update.elevated', 'room.update.elevated',
'room.create.elevated', 'room.read', 'room.delete.elevated',
'feature.create', 'feature.delete', 'feature.update', 'feature.read',
'role.create', 'role.delete', 'role.update'
]
perm_dict = {}
for perm in perm_names:
p = models.Permission(name=perm)
get_db().add(p)
perm_dict[perm] = p
roles = {
'student': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read'
],
'labbie': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read',
'team.read.elevated'
],
'professor': [
'team.create', 'team.delete', 'team.read', 'team.update',
'reservation.create', 'reservation.delete', 'reservation.read',
'reservation.update', 'room.read', 'feature.read',
'team.create.elevated', 'team.read.elevated'
],
'admin': [
'team.create', 'team.create.elevated', 'team.delete',
'team.delete.elevated', 'team.read', 'team.read.elevated',
'team.update', 'team.update.elevated', 'reservation.create',
'reservation.delete', 'reservation.delete.elevated',
'reservation.read', 'reservation.update',
'reservation.update.elevated', 'room.update.elevated',
'room.create.elevated', 'room.read', 'room.delete.elevated',
'feature.create', 'feature.delete', 'feature.update',
'feature.read', 'role.create', 'role.delete', 'role.update'
]
}
users_dict = {}
for role in roles:
r = models.Role(name=role)
for permission in roles[role]:
p = perm_dict[permission]
r.permissions.append(p)
get_db().add(r)
# seed a user TODO don't do this in production?
u = models.User(name=role, email=role + "@example.com")
u.roles.append(r)
team = models.Team(u.name)
team_type = teamtype_dict['single']
team.team_type = team_type
team.members.append(u)
u.teams.append(team)
users_dict[role] = u
get_db().add(team)
get_db().add(u)
reservation = models.Reservation(
start=datetime.datetime.now() + datetime.timedelta(days=7),
end=datetime.datetime.now() + datetime.timedelta(days=7, hours=1),
team=users_dict['admin'].teams[0],
room=rooms_dict['1660'],
created_by=users_dict['admin'])
get_db().add(reservation)
get_db().commit()
def __init__(self):
self.current_tick = -1
self.room = models.Room(settings)
def createDeployment(self):
"""
Create a new deployment and house etc on the Transfer Database
"""
deploymentName = "archRock"
houseName = self.houseName
session = models.meta.Session()
#Check for deployment
theDep = session.query(models.Deployment).filter_by(name=deploymentName).first()
log.debug("Checking for existing deployment {0}".format(theDep))
if theDep is None:
#Create a new deployment
theDep = models.Deployment(name=deploymentName)
session.add(theDep)
session.flush()
log.debug("Adding Deployment to database {0}".format(theDep))
#And check for Houses
theHouse = session.query(models.House).filter_by(address=houseName).first()
log.debug("Checking for house {0}".format(theHouse))
if theHouse is None:
theHouse = models.House(address=houseName,
deploymentId = theDep.id)
session.add(theHouse)
session.flush()
log.debug("Adding New House {0}".format(theHouse))
self.theHouse = theHouse
#Create a location for this particular node
theRoom = session.query(models.Room).filter_by(name="External").first()
if theRoom is None:
theRoom = models.Room(name="External",roomTypeId=1)
session.add(theRoom)
session.flush()
log.debug("External Room is {0}".format(theRoom))
#theLocation = models.Location(houseId = theHouse.id,roomId = theRoom.id)
theLocation = session.query(models.Location).filter_by(houseId=theHouse.id,
roomId = theRoom.id).first()
log.debug("Checking for existing location {0}".format(theLocation))
if theLocation is None:
theLocation = models.Location(houseId = theHouse.id,
roomId = theRoom.id)
session.add(theLocation)
session.flush()
self.theLocation = theLocation
#Node / Node Type
theNode = session.query(models.Node).filter_by(id=118118).first()
if theNode is None:
theNode = models.Node(id=118118)
session.add(theNode)
session.flush()
log.debug("Node is {0}".format(theNode))
self.theNode = theNode
sensorType = session.query(models.SensorType).filter_by(name="Power").first()
self.avgType = sensorType
log.debug("Sensor is {0}".format(sensorType))
sensorType = session.query(models.SensorType).filter_by(name="Power Min").first()
self.minType = sensorType
sensorType = session.query(models.SensorType).filter_by(name="Power Max").first()
self.maxType = sensorType
session.commit()
