def alerts(request):
print 'inside alerts view method'
context = RequestContext(request)
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
if request.user.groups.filter(name__iexact='admin').exists():
usr = UserFullName.objects.filter(username=request.user)[0]
_registered_alerts = [
ob.as_json() for ob in Alerts.objects.filter(
building__in=request.user.userprofile.authorized_buildings())
]
_alerts = [ob.as_json() for ob in AlertTypes.objects.all()]
_alert_pr = [ob.as_json() for ob in PriorityLevels.objects.all()]
_n_type = [ob.as_json() for ob in NotificationChannels.objects.all()]
active_al = get_notifications()
data = {
'registered_alerts': _registered_alerts,
'alerts': _alerts,
'priority': _alert_pr,
'n_type': _n_type,
'user_full_name': usr,
'active_al': active_al
}
data.update(get_device_list_and_count(request))
return render(request, 'alerts/alarms.html', data)
else:
return HttpResponseRedirect('/home/')
def application_individual(request, app_agent_id):
user_building = request.user.userprofile.authorized_buildings()
try:
running_app = ApplicationRunning.objects.get(app_agent_id=app_agent_id)
app_type = running_app.app_type
except ApplicationRunning.DoesNotExist:
print "Invalid application id"
raise Http404
if app_type.app_name == 'iblc':
return_data = illuminance_based_control(user_building, app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/illuminance_light_control.html',
return_data)
elif app_type.app_name == 'dr_test':
return_data = demand_response_test(app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/demand_response_test.html',
return_data)
elif app_type.app_name == 'fault_detection':
return_data = fault_detection_info(app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/fault_detection.html',
return_data)
elif app_type.app_name == 'thermostat_control':
return_data = thermostat_control_info(user_building, app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/thermostat_control.html',
return_data)
elif app_type.app_name in ['plugload_scheduler', 'lighting_scheduler']:
app_data = running_app.app_data
device_mac = app_data['device_agent_id'].split('_')[-1]
return redirect('view-device-schedule', device_mac)
def notifications(request):
print "Notifications page load"
context = RequestContext(request)
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
if request.user.groups.filter(name__iexact='admin').exists():
Notification.objects.filter(seen=False).update(seen=True)
all_notifications = Notification.objects.all().order_by(
'-dt_triggered')
if len(
all_notifications
) > 100: #TODO limit of how many old notifications to save in Postgresql
Notification.objects.filter(
dt_triggered__lt=all_notifications[99].dt_triggered).delete()
notifications = get_notifications(seen=True)
usr = UserFullName.objects.filter(username=request.user)[0]
data = {"notifications": notifications}
data.update(get_device_list_and_count(request))
# print context
return render(request, 'alerts/notifications.html', data)
else:
return HttpResponseRedirect('/home/')
def gateway_devices(request):
context = RequestContext(request)
buildings = request.user.userprofile.authorized_buildings()
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
if request.user.groups.filter(name='Admin').exists():
data = {"building_list": buildings}
data.update(get_device_list_and_count(request))
return render(request, 'dashboard/gateway_devices.html', data)
else:
return HttpResponseRedirect('/home/')
def gateway_status(request):
context = RequestContext(request)
buildings = request.user.userprofile.authorized_buildings()
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
if request.user.groups.filter(name='Admin').exists():
gateways = IOTGateway.objects.filter(building__in=buildings)
data = {"gateways": gateways}
data.update(get_device_list_and_count(request))
print gateways
return render(request, 'dashboard/gateway_status.html', data)
else:
return HttpResponseRedirect('/home/')
def lighting_schedule(request, mac):
print 'Inside Set Schedule method in Schedule app'
context = RequestContext(request)
user_group = request.user.groups.all().values_list('name', flat=True)
if 'Admin' in user_group or 'Zone Manager' in user_group:
print type(mac)
mac = mac.encode('ascii', 'ignore')
print type(mac)
device_metadata = [ob.device_control_page_info() for ob in DeviceMetadata.objects.filter(mac_address=mac)]
print device_metadata
device_id = device_metadata[0]['agent_id']
device_model = device_metadata[0]['device_model']
device_status = [ob.data_as_json() for ob in Devicedata.objects.filter(agent_id=device_id)]
device_node = device_status[0]['node_id']
device_nickname = device_status[0]['nickname']
node_nickname = device_status[0]['node_nickname']
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
_data = {}
active_schedule = []
disabled_range = __.DISABLED_VALUES_LIGHTING
#Check if schedule file for this device exists
try:
sch_data = schedule_data.objects.get(agent_id=device_id)
_json_data = sch_data.schedule
if device_id in _json_data['lighting']:
print 'device id present'
_data = _json_data['lighting'][device_id]['schedulers']
active_schedule = _json_data['lighting'][device_id]['active']
active_schedule = [str(x) for x in active_schedule]
disabled_range = get_disabled_date_ranges(_data, __.DISABLED_VALUES_LIGHTING)
_data = json.dumps(_data)
_data = json.loads(_data, object_hook=_decode_dict)
except ObjectDoesNotExist:
_json_data = {"lighting": {
device_id: {
"active": ['everyday', 'holiday'],
"inactive": [],
"schedulers": __.LIGHTING_DEFAULT_SCHEDULE
}}}
schedule_data(agent_id=device_id, schedule=_json_data).save()
_data = _json_data['lighting'][device_id]['schedulers']
active_schedule = ['everyday', 'holiday']
disabled_range = get_disabled_date_ranges(_data, __.DISABLED_VALUES_LIGHTING)
return_data = {'device_id': device_id, 'device_zone': device_node, 'zone_nickname': node_nickname, 'mac_address': mac,
'device_nickname': device_nickname, 'schedule': _data,
'disabled_ranges': disabled_range, 'active_schedule': active_schedule}
return_data.update(device_list_side_nav)
return render(request, 'schedule/lighting_schedule.html', return_data)
else:
return HttpResponseRedirect('/home/')
def oauth_main_page(request):
if request.method == 'GET':
device_list_side_nav = get_device_list_and_count(request)
return_data = device_list_side_nav
token_info = oauthToken.objects.all()
return_data.update({'tokens': token_info})
return render(request, "oauth/takeme2oauth.html", return_data)
def bemoss_home(request):
req_context = RequestContext(request)
username = request.user
#template_loader = template_loader.get_template('dashboard/dashboard.html')
return render(request, 'dashboard/dashboard.html',
get_device_list_and_count(request))
def zone_device_listing(request, node_id, device_type):
context = RequestContext(request)
username = request.user
dev_list = get_device_list_and_count(request)
node_id = node_id.lower()
device_type = device_type
if node_id == 'all':
request_node = 'ALL NODES'
elif node_id in dev_list['node_names']:
request_node = dev_list['node_names'][node_id]
else:
return HttpResponse('Bad node name')
if device_type not in dev_list['device_list']['all']['all'].keys():
return HttpResponse('No such device exists')
data = {
'request_node_id': node_id,
'request_deviceType': device_type,
'request_node': request_node
}
data.update(dev_list)
return render(request, 'dashboard/devices.html', data)
def discover_devices(request):
if request.user.groups.filter(name__iexact = 'admin').exists():
context = RequestContext(request)
try:
discovery_status = Miscellaneous.objects.get(key='auto_discovery')
print discovery_status.value
except Miscellaneous.DoesNotExist:
discovery_status = {'value':'not_started'}
hvac = SupportedDevices.objects.filter(device_type_id=1)
lt_loads = SupportedDevices.objects.filter(device_type_id=2)
plugloads = SupportedDevices.objects.filter(device_type_id=3)
sensors = SupportedDevices.objects.filter(device_type_id=4)
power_meters = SupportedDevices.objects.filter(device_type_id=5)
DER=SupportedDevices.objects.filter(device_type_id=6)
camera=SupportedDevices.objects.filter(device_type_id=7)
print lt_loads
print hvac
print power_meters
print plugloads
print sensors
print DER
device_list_side_nav = get_device_list_and_count(request)
return_data = dict()
return_data.update(device_list_side_nav)
devices = {'hvac': hvac, 'lt_loads':lt_loads, 'plugloads':plugloads, 'sensors':sensors, 'power_meters':power_meters, "DER": DER, "camera":camera}
return_data.update(devices)
return_data.update({'discovery_status':discovery_status})
return render(request,'discovery/manual_discovery.html', return_data
)
else:
return HttpResponseRedirect('/home/')
def password_manager(request):
context = RequestContext(request)
PasswordManagerFormSet = modelformset_factory(PasswordsManager, PasswordManagerForm)
user_building = request.user.userprofile.authorized_buildings()[0] #use the first building as assigned building. #TODO add a building dropdown in the UI to let the user chose the building
if request.method == 'POST':
formset = PasswordManagerFormSet(request.POST)
for form in formset:
if form.is_valid():
if form.cleaned_data:
form.cleaned_data['password'] = encrypt_value(form.cleaned_data['password']).encode('utf8')
password_data = form.save(commit=False)
password_data.last_modified = datetime.now()
password_data.building = user_building
password_data.save()
password_manager_data = [ob.data_passwords_manager() for ob in PasswordsManager.objects.filter(building__in=request.user.userprofile.authorized_buildings())]
formset = PasswordManagerFormSet(queryset=PasswordsManager.objects.filter(building__in=request.user.userprofile.authorized_buildings()))
else:
password_manager_data = [ob.data_passwords_manager() for ob in PasswordsManager.objects.filter(building__in=request.user.userprofile.authorized_buildings())]
formset = PasswordManagerFormSet(queryset=PasswordsManager.objects.filter(building__in=request.user.userprofile.authorized_buildings()))
# Allows initial pre-existing data to be rendered into the form.
# When saving, previously saved data need to be treated as old data and ignored.
# formset = PasswordManagerFormSet(initial=[ob.data_passwords_manager() for ob in
# PasswordsManager.objects.all()])
if request.user.is_superuser or request.user.groups.filter(name__iexact = 'admin'):
data = {'formset': formset, 'pwd_data': password_manager_data}
data.update(get_device_list_and_count(request))
return render(request,'discovery/password_manager.html',data)
else:
return HttpResponseRedirect('/home/')
def devicedata_view(request, mac):
if request.method == 'GET':
device_info = DeviceMetadata.objects.get(mac_address=mac)
template = SupportedDevices.objects.filter(
device_model=device_info.device_model).values(
'html_template')[0]['html_template']
context = RequestContext(request)
username = request.session.get('user')
agent_id = device_info.agent_id
_data = _helper.get_page_load_data(agent_id)
device_list_side_nav = get_device_list_and_count(request)
if device_info.vendor_name == "foscam":
all_addresses = device_info.address
local = all_addresses.split(",")[0]
if local == all_addresses:
remote = local
else:
remote = all_addresses.split(",")[1]
device_info.local = local
device_info.remote = remote
device_info.comment = decrypt_value(device_info.password)
weather_info = get_weather_info()
return_data = {
'device_info': device_info,
'device_data': _data,
'weather_info': weather_info
}
return_data.update(device_list_side_nav)
context.update({'return_data': return_data})
return render(request, template, return_data)
def zone_device_listing(request, building_id, device_type):
context = RequestContext(request)
username = request.user
dev_list = get_device_list_and_count(request)
building_id = building_id.lower()
device_type = device_type
try:
if building_id == 'all':
request_building = 'ALL BUILDINGS'
elif int(building_id) in dev_list['building_names']:
request_building = dev_list['building_names'][int(building_id)]
else:
return HttpResponse('Bad building name')
except TypeError: #because building_id is not integer or 'all'
return HttpResponse('Bad building name')
if device_type not in dev_list['device_list']['all']['all'].keys():
return HttpResponse('No such device exists')
data = {
'request_building_id': int(building_id),
'request_deviceType': device_type,
'request_building': request_building
}
data.update(dev_list)
return render(request, 'dashboard/devices.html', data)
def network_status(request):
print 'Network status page load'
context = RequestContext(request)
if request.user.groups.all()[0].name.lower() == 'admin':
return render(request, 'dashboard/network_status.html', get_device_list_and_count(request))
else:
return HttpResponseRedirect('/home/')
def token_delete(request, sp, building_id):
# TODO: Change the HTML file of this function, current model exist critical vulnerability
token = oauthToken.objects.filter(service_provider=sp,
building_id=building_id)
token.delete()
device_list_side_nav = get_device_list_and_count(request)
return_data = device_list_side_nav
return redirect('/oauth')
def returnChartsPage(request, context,mac,data_variables,page,get_weather=False):
'''
:param context: var obtained from RequestContext(request)
:param mac: Device mac ID (table id)
:param data_variables: Dict. Variables in the database that is to be retrieved as value, and varaibles in html as keys
:param page: The html page to be returned to
:param device_type: The device type class
:return: the rendered html page
'''
agent_id = get_agent_id_from_mac(mac)
try:
if not get_weather:
varlist, rs = retrieve(agent_id)
else:
data = retrieve(agent_id, weather_agent=settings.weather_agent)
if data is not None:
varlist, rs=data
else:
varlist, rs = retrieve(agent_id)
except Exception as er:
print er
print 'Cassandra data reading error'
return {}
device_list_side_nav = get_device_list_and_count(request)
data_dict = {}
objects = [ob for ob in DeviceMetadata.objects.filter(mac_address=mac)]
try:
device_nickname = objects[0].nickname
node_name = objects[0].node.node_name
data_dict = {'mac': mac, 'nickname': device_nickname, 'node_name': node_name}
except Exception as er:
print er
print 'get device status failed'
for key,val in data_variables.items():
try:
data_dict[key] = parse_resultset(varlist,val,rs)
except (KeyError, ValueError) as er:
print er
continue
context.update(get_device_list_and_count(request))
data_dict.update(device_list_side_nav)
return render(request, page,data_dict)
def device_status(request):
print 'Device status page load'
context = RequestContext(request)
if request.user.groups.filter(name__iexact = 'admin').exists():
return render(request, 'dashboard/device_status.html', get_device_list_and_count(request))
else:
return HttpResponseRedirect('/home/')
def buildinginfos_display(request):
print 'Device status page load'
context = RequestContext(request)
if request.user.groups.filter(name__iexact='admin').exists():
return render(request, 'buildinginfos/building_info.html',
get_device_list_and_count(request))
else:
return HttpResponseRedirect('/home/')
def node_status(request):
context = RequestContext(request)
if True or request.user.get_profile().group.name.lower() == 'admin':
return render(request, 'dashboard/node_discovery.html',
get_device_list_and_count(request))
else:
return HttpResponseRedirect('/home/')
def application_individual(request, app_agent_id):
try:
running_app = ApplicationRunning.objects.get(app_agent_id=app_agent_id)
app_type = running_app.app_type
except ApplicationRunning.DoesNotExist:
print "Invalid application id"
raise Http404
if app_type.app_name == 'iblc':
return_data = illuminance_based_control(app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/illuminance_light_control.html', return_data)
elif app_type.app_name == 'fault_detection':
return_data = fault_detection_info(app_agent_id)
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/fault_detection.html', return_data)
elif app_type.app_name in ['plugload_scheduler','lighting_scheduler']:
app_data = running_app.app_data
device_mac = app_data['device_agent_id'].split('_')[-1]
return redirect('view-device-schedule',device_mac)
def application_main(request):
# Display the main page of bemoss applications
user_building = request.user.userprofile.authorized_buildings()
apps = ApplicationRunning.objects.filter(building__in=user_building)
return_data = {
'apps': apps,
'fault_detection_preinfo': fault_detection_preinfo(user_building),
'thermostat_control_preinfo': thermostat_control_preinfo(user_building)
}
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/applications.html', return_data)
def discover(request):
print "Discovering devices"
if True or request.user.get_profile().group.name.lower() == 'admin':
req_context = RequestContext(request)
username = request.user
# template_loader = template_loader.get_template('dashboard/dashboard.html')
return render(request, 'dashboard/discovery.html', get_device_list_and_count(request))
else:
return HttpResponseRedirect('/home/')
def user_manager(request):
context = RequestContext(request)
zones = Building_Zone.objects.all()
device_list_side_nav = get_device_list_and_count(request)
context.update(device_list_side_nav)
if request.user.groups.filter(name='Admin').exists():
_users = User.objects.all()
groups = Group.objects.all()
userprofiles = UserProfile.objects.all()
data = {
"users": _users,
'zones': zones,
'groups': groups,
'userprofiles': userprofiles
}
data.update(get_device_list_and_count(request))
print _users
return render(request, 'accounts/user_manager.html', data)
else:
return HttpResponseRedirect('/home/')
def devicedata_view(request, mac):
if request.method == 'GET':
try:
device_info = DeviceMetadata.objects.get(mac_address=mac)
except DeviceMetadata.DoesNotExist:
return HttpResponse('Invalid Devices', status=404)
if device_info.building not in request.user.userprofile.authorized_buildings(
):
return HttpResponse('Unauthorized', status=401)
template = SupportedDevices.objects.filter(
device_model=device_info.device_model).values(
'html_template')[0]['html_template']
context = RequestContext(request)
username = request.session.get('user')
agent_id = device_info.agent_id
#Request a device monitor
vip_publish(sender="ui",
target='basicagent',
topic='onDemandMonitor',
message={'agent_id': agent_id})
_data = _helper.get_page_load_data(agent_id)
device_list_side_nav = get_device_list_and_count(request)
if device_info.vendor_name == "Foscam":
all_addresses = device_info.address
local = 'http://' + all_addresses.split(",")[0]
if local == all_addresses:
remote = local
else:
remote = 'http://' + all_addresses.split(",")[1]
device_info.local = local
device_info.remote = remote
device_info.comment = decrypt_value(
device_info.config.get("password"))
zip_code = device_info.building.zip_code
weather_info = get_weather_info(zip_code)
device_info.username = device_info.config.get(
"username") #put username and password directly into deviceinfo
device_info.password = device_info.config.get("password")
return_data = {
'device_info': device_info,
'device_data': _data,
'weather_info': weather_info
}
return_data.update(device_list_side_nav)
context.update({'return_data': return_data})
return render(request, template, return_data)
def application_main(request):
# Display the main page of bemoss applications
hvac_fault_apps = ApplicationRunning.objects.filter(app_type__app_name='fault_detection')
used_thermostat_ids = []
for app in hvac_fault_apps:
used_thermostat_ids.append(app.app_data['thermostat'])
available_thermostas = DeviceMetadata.objects.filter(approval_status='APR', device_type_id=1).exclude(agent_id__in=used_thermostat_ids)
apps = ApplicationRunning.objects.all()
return_data = {'apps': apps, 'available_thermostats':available_thermostas}
return_data.update(get_device_list_and_count(request))
return render(request, 'applications/applications.html', return_data)
def devicedata_view(request, mac):
if request.method == 'GET':
device_info = DeviceMetadata.objects.get(mac_address=mac)
template = SupportedDevices.objects.filter(device_model=device_info.device_model).values('html_template')[0]['html_template']
context = RequestContext(request)
username = request.session.get('user')
agent_id = device_info.agent_id
_data = _helper.get_page_load_data(agent_id)
device_list_side_nav = get_device_list_and_count(request)
weather_info = get_weather_info()
return_data = {'device_info': device_info, 'device_data': _data, 'weather_info':weather_info}
return_data.update(device_list_side_nav)
context.update({'return_data': return_data})
return render(request, template, return_data)
def bemoss_settings(request):
print 'BEMOSS Settings page load'
context = RequestContext(request)
holidays = [ob.as_json() for ob in Holiday.objects.all()]
print holidays
zip = Miscellaneous.objects.get(key='zipcode')
b_location = zip.value
device_list_side_nav = get_device_list_and_count(request)
data = {'holidays': holidays, 'b_location': b_location}
data.update(device_list_side_nav)
if request.user.groups.filter(name__iexact='admin').exists():
return render(request,'dashboard/bemoss_settings.html',data)
else:
return HttpResponseRedirect('/home/')
def showSchedule(request,device_id):
# return HttpResponse('No schedule yet for: ' + str(device_id) )
user_group = request.user.groups.all().values_list('name', flat=True)
if not ('Admin' in user_group or 'Zone Manager' in user_group):
return HttpResponse("Need to be Admin or Zone-manager", status=401)
mac = device_id.encode('ascii', 'ignore')
device_info = DeviceMetadata.objects.get(mac_address=device_id)
schedule_data, schedule_meta = get_schedule_data(device_id)
device_list_side_nav = get_device_list_and_count(request, user=request.user)
device_metadata = [ob.device_control_page_info() for ob in DeviceMetadata.objects.filter(mac_address=mac)]
# print device_metadata
device_id = device_metadata[0]['agent_id']
device_model = device_metadata[0]['device_model']
device_status = [ob.as_json() for ob in Devicedata.objects.filter(agent_id=device_id)]
device_node = device_status[0]['node_id']
device_nickname = device_status[0]['nickname']
node_nickname = device_status[0]['node_nickname']
disabled_range = get_disabled_date_ranges(schedule_data['schedulers'])
schedule_json = json.dumps(schedule_data['schedulers'],encoding='ascii')
schedule = schedule_data['schedulers']
return_data = {'device_id': device_id, 'device_zone': device_node, 'zone_nickname': node_nickname,
'mac_address': mac,
'device_nickname': device_nickname, 'schedule': schedule,
'schedule_json': json.dumps(schedule),
'disabled_ranges': json.dumps(disabled_range), 'active_schedule': str(schedule_data['active']),
'schedule_meta': schedule_meta}
return_data.update(device_list_side_nav)
if device_info.device_type.device_type == 'HVAC':
return render(request, 'schedule/thermostat_schedule.html', return_data)
elif device_info.device_type.device_type == 'Lighting':
return render(request, 'schedule/lighting_schedule.html', return_data)
elif device_info.device_type.device_type == 'Plugload':
return render(request, 'schedule/plugload_schedule.html', return_data)
def returnChartsPage(request,
context,
mac,
data_variables,
page,
get_weather=False):
'''
:param context: var obtained from RequestContext(request)
:param mac: Device mac ID (table id)
:param data_variables: Dict. Variables in the database that is to be retrieved as value, and varaibles in html as keys
:param page: The html page to be returned to
:param device_type: The device type class
:return: the rendered html page
'''
agent_id = get_agent_id_from_mac(mac)
device = DeviceMetadata.objects.get(agent_id=agent_id)
weather_agent = 'BEMO_WUG' + device.building.zip_code + '_' + str(
device.building.building_id)
weather_table = "B" + str(device.building.building_id) + "_bemossweather"
tablename = getTableName(device.building.building_id, device.device_model)
try:
if not get_weather:
varlist, rs = retrieve(agent_id, tablename=tablename)
else:
data = retrieve(agent_id,
weather_agent=weather_agent,
tablename=tablename,
weather_table=weather_table)
if data is not None:
varlist, rs = data
else:
varlist, rs = retrieve(agent_id, tablename=tablename)
except Exception as er:
print er
print 'Cassandra data reading error'
return HttpResponse("Database fail", status=404)
device_list_side_nav = get_device_list_and_count(request)
data_dict = {}
objects = [ob for ob in DeviceMetadata.objects.filter(mac_address=mac)]
try:
device_nickname = objects[0].nickname
node_name = objects[0].node.node_name
data_dict = {
'mac': mac,
'nickname': device_nickname,
'node_name': node_name
}
except Exception as er:
print er
print 'get device status failed'
for key, val in data_variables.items():
try:
data_dict[key] = parse_resultset(varlist, val, rs)
except (KeyError, ValueError) as er:
print er
continue
context.update(get_device_list_and_count(request))
data_dict.update(device_list_side_nav)
return render(request, page, data_dict)
