def test_UniqueBuildingName(self):
building1 = Building(name = 'Parrish')
building2 = Building(name = 'Parrish')
db.session.add(building1)
db.session.add(building2)
with self.assertRaises(Exception) as context:
uniqueBuildingNameException()
self.assertTrue('Building names not unique' in str(context.exception))
def import_data(self):
buildings = pd.read_csv(
os.path.join(self.raw_data_directory, 'FacilityBuildings.csv'))
meters = pd.read_csv(
os.path.join(self.raw_data_directory, 'FacilityMeters.csv'))
meter_readings = pd.read_csv(
os.path.join(self.raw_data_directory, 'FacilityMeterReadings.csv'))
meter_reading_objects = []
for index, row in meter_readings.iterrows():
meter_id = row['fkFacilityMeterId']
meter_reading_date = row['MeterReadingDate'].split('-')
meter_usage_kwh = row['MeterUsageKwH']
block_co2 = row['BlockCO2']
block_cost = row['BlockCost']
year = int(meter_reading_date[0])
month = int(meter_reading_date[1])
day = int(meter_reading_date[2])
mr_date = date(year=year, month=month, day=day)
meter_reading = MeterReading(meter_reading_date=mr_date,
meter_usage_kwh=meter_usage_kwh,
block_co2=block_co2,
block_cost=block_cost,
meter_id=meter_id)
meter_reading_objects.append(meter_reading)
meter_objects = []
meter_counter = 1
for index, row in meters.iterrows():
name = row['FacilityMeterName']
building_id = row['fkFacilityBuildingId']
meter = Meter(id=meter_counter, name=name, building_id=building_id)
for meter_reading_object in meter_reading_objects:
if meter_reading_object.meter_id == meter.id:
meter.meter_readings.append(meter_reading_object)
meter_objects.append(meter)
meter_counter += 1
building_objects = []
building_counter = 1
for index, row in buildings.iterrows():
name = row['FacilityBuildingName']
building = Building(id=building_counter, name=name)
for meter in meter_objects:
if meter.building_id == building.id:
building.meters.append(meter)
building_objects.append(building)
building_counter += 1
self.objects = building_objects
def test_BuildingAndStudySpaceRelationship(self):
building = Building(name = 'Parrish')
space = StudySpace(name = 'Shane Lounge', lat = 12.34, \
long = -75.12, building = building)
space2 = StudySpace(name = 'Parlor West', lat = 12.34, \
long = -75.12, building = building)
self.assertTrue(building.studySpaces.all()[0].name == 'Shane Lounge')
self.assertTrue(space.building.name == 'Parrish')
self.assertTrue(building.studySpaces.all()[1].name == 'Parlor West')
self.assertTrue(space2.building.name == 'Parrish')
def test_PostAndStudySpaceRelationship(self):
building = Building(name = 'Parrish')
space = StudySpace(name = 'Shane Lounge', lat = 12.34, \
long = -75.12, building = building)
u = User(username='******', email = "*****@*****.**")
post = Post(body = "hi", building = "Parrish", author = u, studySpace = space)
post2 = Post(body = "hello", building = "Parrish", author = u, studySpace = space)
self.assertTrue(post.studySpace.name == "Shane Lounge")
self.assertTrue(post2.studySpace.name == "Shane Lounge")
self.assertTrue(len(space.post.all()) == 2)
def make_buildings():
for file in ["UMDBuildings.json", "UCLABuildings.json", "UPennBuildings.json"]:
with open(file) as json_source:
data = json.loads(json_source.read())
school_id = School.query.filter_by(name=data['school']).first().id
for building in data['buildings']:
b = Building(name=building, school_id=school_id)
db.session.add(b)
db.session.commit()
def import_data(self):
room_coords = pd.read_csv(
os.path.join(self.raw_data_directory, 'room_coords.csv'))
building = Building(id=0, name='CSB')
for index, row in room_coords.iterrows():
floor_level = row['floor_level']
top = row['top']
left = row['left']
text = row['text']
building.rooms.append(
Room(name=text,
floor_level=floor_level,
coord_top=top,
coord_left=left))
self.objects.append(building)
def building_create(street_id):
form = PlaceForm()
if form.validate_on_submit():
find_building = Building.query.filter_by(name=form.name.data,
street_id=street_id).first()
if find_building is not None:
flash('Сооружение с таким именем уже существует', 'danger')
return redirect(url_for('.building_view', street_id=street_id))
building = Building(name=form.name.data, street_id=street_id)
db.session.add(building)
db.session.commit()
flash('Новое сооружение добавлено', 'success')
return redirect(url_for('.building_view', street_id=street_id))
parent_street = Street.query.options(joinedload('city')).get(street_id)
title = 'Добавление строения по адресу {}, {}'.format(
parent_street.city.name, parent_street.name)
return render_template('place/form.html', form=form, title=title)
def test_BuildingFields(self):
building = Building(name = 'Cornell Library')
self.assertTrue(building.name == 'Cornell Library')
def setup_demo_server(meraki_server):
output = False
if meraki_server.name == "Meraki HQ" and "live-map.meraki.com" in meraki_server.demo_server_url:
filename = "meraki/meraki-hq-san-francisco.json"
try:
filename = os.path.join(app.static_folder, 'server_config/{}'.format(filename))
with open(filename) as data_file:
server_info = json.load(data_file)
db_session.query(Campus).delete()
campuses = []
counter_campus = 0
meraki_location_system = LocationSystem(meraki_server.name)
meraki_location_system.campuses = campuses
meraki_server.location_system = meraki_location_system
for campus in server_info["campuses"]:
counter_buildings = 0
counter_floors = 0
counter_zones = 0
counter_campus += 1
name = campus["name"]
campus_uid = campus["aesUid"]
output = True
campus_uid = campus["aesUid"]
db_campus = Campus(campus_uid, name, buildings=None)
campuses.append(db_campus)
db_campus.location_system = meraki_location_system
db_campus.location_system_id = meraki_location_system.id
db_session.add(db_campus)
server_buildings = campus["buildingList"]
if server_buildings:
for b in server_buildings:
counter_buildings += 1
name = b["name"]
building_uid = b["aesUid"]
object_version = b["objectVersion"]
db_building = Building(db_campus.aes_uid, building_uid, object_version, name, floors=None)
db_session.add(db_building)
server_floors = b["floorList"]
if server_floors:
for f in server_floors:
counter_floors += 1
name = f["name"]
aes_uid = f["aesUid"]
calibration_model_id = 0
object_version = 0
floor_length = f["dimension"]["length"]
floor_width = f["dimension"]["width"]
floor_height = f["dimension"]["height"]
floor_offset_x = f["dimension"]["offsetX"]
floor_offset_y = f["dimension"]["offsetY"]
floor_unit = f["dimension"]["unit"]
image_name = f["image"]["imageName"]
image_zoom_level = f["image"]["zoomLevel"]
image_width = f["image"]["width"]
image_height = f["image"]["height"]
image_size = f["image"]["size"]
image_max_resolution = f["image"]["maxResolution"]
image_color_depth = f["image"]["colorDepth"]
treated_floor_name = ''.join(e for e in name if e.isalnum())
#filename = os.path.join(app.static_folder, 'maps/meraki-hq/{}.png'.format(treated_floor_name))
map_path = url_for('static', filename='maps/meraki-hq/{}.png'.format(treated_floor_name))
db_floor = Floor(db_building.aes_uid, aes_uid, calibration_model_id, object_version,
name, floor_length, floor_width,
floor_height, floor_offset_x, floor_offset_y, floor_unit,
image_name, image_zoom_level, image_width,
image_height, image_size, image_max_resolution, image_color_depth, map_path=map_path)
db_session.add(db_floor)
server_zones = f["zones"]
# skipping the zones for now
server_gps_markers = f["gpsMarkers"]
for gps_marker in server_gps_markers:
gps_marker_name = gps_marker["name"]
gps_marker_latitude = gps_marker["geoCoordinate"]["latitude"]
gps_marker_longitude = gps_marker["geoCoordinate"]["longitude"]
gps_marker_unit = gps_marker["geoCoordinate"]["unit"]
db_gps_marker = GPSMarker(db_floor.aes_uid, gps_marker_name, gps_marker_latitude, gps_marker_longitude, gps_marker_unit)
db_session.add(db_gps_marker)
print (
"{} has {} buildings, {} floors, {} zones".format(db_campus.name, counter_buildings, counter_floors,
counter_zones))
output = True
except Exception as e:
traceback.print_exc()
db_session.rollback()
output = False
return output
def validate_cmx_server(cmx_server):
output = True
api = get_api_cmx(cmx_server)
# TODO get servers timezone and add it to db (would have to create another column on the table)
server_info = None
try:
server_info = api.get_all_maps()
except:
file_path = None
filename = None
url = cmx_server.url
if 'msesandbox.cisco.com:8081' in url:
filename = 'DevNet.json'
elif '10.97.40.43' in url or '10.97.20.218' in url:
# TODO get file path for JSON that contains CENU info
filename = 'CENU.json'
if filename:
filename = os.path.join(app.static_folder,
'server_config/{}'.format(filename))
with open(filename) as data_file:
server_info = json.load(data_file)
if server_info:
try:
db_session.query(Campus).delete()
campuses = []
counter_campus = 0
cmx_location_system_name = cmx_server.name
cmx_location_system = LocationSystem(cmx_location_system_name)
cmx_location_system.campuses = campuses
cmx_server.location_system = cmx_location_system
for campus in server_info["campuses"]:
counter_buildings = 0
counter_floors = 0
counter_zones = 0
counter_campus += 1
name = campus["name"]
campus_uid = campus["aesUid"]
db_campus = Campus(campus_uid, name, buildings=None)
campuses.append(db_campus)
db_campus.location_system = cmx_location_system
db_campus.location_system_id = cmx_location_system.id
db_session.add(db_campus)
server_buildings = campus["buildingList"]
if server_buildings:
for b in server_buildings:
counter_buildings += 1
name = b["name"]
building_uid = b["aesUid"]
object_version = b["objectVersion"]
db_building = Building(db_campus.aes_uid,
building_uid,
object_version,
name,
floors=None)
db_session.add(db_building)
server_floors = b["floorList"]
if server_floors:
for f in server_floors:
counter_floors += 1
name = f["name"]
aes_uid = f["aesUid"]
calibration_model_id = f["calibrationModelId"]
floor_length = f["dimension"]["length"]
floor_width = f["dimension"]["width"]
floor_height = f["dimension"]["height"]
floor_offset_x = f["dimension"]["offsetX"]
floor_offset_y = f["dimension"]["offsetY"]
floor_unit = f["dimension"]["unit"]
image_name = f["image"]["imageName"]
image_zoom_level = f["image"]["zoomLevel"]
image_width = f["image"]["width"]
image_height = f["image"]["height"]
image_size = f["image"]["size"]
image_max_resolution = f["image"][
"maxResolution"]
image_color_depth = f["image"]["colorDepth"]
db_floor = Floor(
db_building.aes_uid, aes_uid,
calibration_model_id, object_version, name,
floor_length, floor_width, floor_height,
floor_offset_x, floor_offset_y, floor_unit,
image_name, image_zoom_level, image_width,
image_height, image_size,
image_max_resolution, image_color_depth)
db_session.add(db_floor)
server_zones = f["zones"]
if server_zones:
for z in server_zones:
counter_zones += 1
name = z["name"]
zone_type = z["zoneType"]
coordinates = z["zoneCoordinate"]
zone_xs = []
zone_ys = []
zone_zs = []
for coordinate in coordinates:
zone_xs.append(coordinate["x"])
zone_ys.append(coordinate["y"])
zone_zs.append(coordinate["z"])
zone_center_x = sum(zone_xs) / len(
zone_xs)
zone_center_y = sum(zone_ys) / len(
zone_ys)
zone_center_z = sum(zone_zs) / len(
zone_zs)
db_zone = Zone(db_floor.aes_uid, name,
zone_type,
zone_center_x,
zone_center_y,
zone_center_z)
db_session.add(db_zone)
print("{} has {} buildings, {} floors, {} zones".format(
db_campus.name, counter_buildings, counter_floors,
counter_zones))
output = download_floor_images(api)
except:
traceback.print_exc()
output = False
else:
output = False
return output