def home(request):
"""
Controller for the app home page.
"""
can_define_boundary = has_permission(request, 'block_map')
boundaryEndpoint = app.get_custom_setting('Boundary Geoserver Endpoint')
boundaryWorkspace = app.get_custom_setting('Boundary Workspace Name')
boundaryLayer = app.get_custom_setting('Boundary Layer Name')
boundaryMovement = app.get_custom_setting('Boundary Movement')
boundaryColor = app.get_custom_setting('Boundary Color')
boundaryWidth = app.get_custom_setting('Boundary Width')
nameViews = app.get_custom_setting('Views Names')
logoInst = app.get_custom_setting('InstitutionLogo')
context = {
"geoEndpoint": boundaryEndpoint,
"geoWorkspace": boundaryWorkspace,
"geoLayer": boundaryLayer,
"geoMovement": boundaryMovement,
"geoColor": boundaryColor,
"geoWidth": boundaryWidth,
'can_delete_hydrogroups': has_permission(request,
'delete_hydrogroups'),
'can_block_map': has_permission(request, 'block_map'),
'views_names': nameViews,
'logo_institucion': logoInst
}
return render(request, 'water_data_explorer/home.html', context)
def simulations(request):
"""
controller for the instructions page
"""
# list of reservoirs to choose from for the simulation
options = [(reservoir, reservoirs[reservoir]) for reservoir in reservoirs]
options.sort()
res_list = SelectInput(
display_text='',
name='reservoir',
multiple=False,
options=options,
select2_options={
'placeholder': 'Choose A Reservoir',
'allowClear': True
},
)
context = {
'admin': has_permission(request, 'update_data'),
'urls': generate_app_urls(request, reservoirs),
'res_list': res_list,
'youtubelink': App.youtubelink
}
return render(request, 'reservoirs/simulations.html', context)
def delete_group(request):
list_response = {}
can_delete_permission = has_permission(request, "delete_hydrogroups")
if can_delete_permission:
list_catalog = {}
list_groups = {}
SessionMaker = app.get_persistent_store_database(Persistent_Store_Name,
as_sessionmaker=True)
session = SessionMaker()
#print(request.POST)
if request.is_ajax() and request.method == 'POST':
groups = request.POST.getlist('groups[]')
list_groups['groups'] = groups
list_response['groups'] = groups
i = 0
arrayTitles = []
for group in groups:
hydroservers_group = session.query(Groups).filter(
Groups.title == group)[0].hydroserver
for server in hydroservers_group:
title = server.title
arrayTitles.append(title)
i_string = str(i)
list_catalog[i_string] = title
i = i + 1
hydroservers_group = session.query(Groups).filter(
Groups.title == group).first()
session.delete(hydroservers_group)
session.commit()
session.close()
list_response['hydroservers'] = arrayTitles
return JsonResponse(list_response)
def hydrograph(request, hydrograph_id):
"""
Controller for the Hydrograph Page.
"""
hydrograph_plot = create_hydrograph(hydrograph_id)
context = {
'hydrograph_plot': hydrograph_plot,
'can_add_dams': has_permission(request, 'add_dams')
}
return render(request, 'dam_inventory/hydrograph.html', context)
def reportar(request):
"""
controller for the reporting page
"""
context = {
'admin': has_permission(request, 'update_data'),
'urls': generate_app_urls(request, reservoirs),
'youtubelink': App.youtubelink
}
return render(request, 'embalses/reportar.html', context)
def instructions(request):
"""
controller for the instructions page
"""
context = {
'admin': has_permission(request, 'update_data'),
'urls': generate_app_urls(request, reservoirs),
'youtubelink': App.youtubelink
}
return render(request, 'reservoirs/instructions.html', context)
def home(request):
"""
controller for the home page
"""
# The map on this page is handled entirely using leaflet and javascript
context = {
'admin': has_permission(request, 'update_data'),
'urls': generate_app_urls(request, reservoirs),
'youtubelink': App.youtubelink
}
return render(request, 'reservoirs/home.html', context)
def list_wells(request):
"""
Show all wells in a table view.
"""
wells = get_all_wells()
table_rows = []
for well in wells:
hydrograph_id = get_hydrograph(well.id)
well_id = well.id
if hydrograph_id:
url = reverse('well_inventory:hydrograph',
kwargs={'hydrograph_id': hydrograph_id})
well_hydrograph = format_html(
'<a class="btn btn-primary" href="{}">Hydrograph Plot</a>'.
format(url))
else:
well_hydrograph = format_html(
'<a class="btn btn-primary disabled" title="No hydrograph assigned" '
'style="pointer-events: auto;">Hydrograph Plot</a>')
if well_id == request.user.id:
url = reverse('well_inventory:delete_well',
kwargs={'well_id': well.id})
well_delete = format_html(
'<a class="btn btn-danger" href="{}">Delete Well</a>'.format(
url))
else:
url = reverse('well_inventory:delete_well',
kwargs={'well_id': well.id})
well_delete = format_html(
'<a class="btn btn-danger" href="{}">Delete Well</a>'.format(
url))
table_rows.append((well.name, well.owner, well.river, well.date_built,
well_hydrograph, well_delete))
wells_table = DataTableView(
column_names=('Well Number', 'Owner', 'Aquifer', 'Date Built',
'Depth to GW Hydrograph', 'Manage'),
rows=table_rows,
searching=False,
orderClasses=False,
lengthMenu=[[10, 25, 50, -1], [10, 25, 50, "All"]],
)
context = {
'wells_table': wells_table,
'can_add_wells': has_permission(request, 'add_wells')
}
return render(request, 'well_inventory/list_wells.html', context)
def list_dams(request):
"""
Show all dams in a table view.
"""
dams = get_all_dams()
table_rows = []
for dam in dams:
hydrograph_id = get_hydrograph(dam.id)
if hydrograph_id:
url = reverse('dam_inventory:hydrograph',
kwargs={'hydrograph_id': hydrograph_id})
dam_hydrograph = format_html(
'<a class="btn btn-primary" href="{}">Hydrograph Plot</a>'.
format(url))
else:
dam_hydrograph = format_html(
'<a class="btn btn-primary disabled" title="No hydrograph assigned" '
'style="pointer-events: auto;">Hydrograph Plot</a>')
if dam.user_id == request.user.id:
url = reverse('dam_inventory:delete_dam',
kwargs={'dam_id': dam.id})
dam_delete = format_html(
'<a class="btn btn-danger" href="{}">Delete Dam</a>'.format(
url))
else:
dam_delete = format_html(
'<a class="btn btn-danger disabled" title="You are not the creator of the dam" '
'style="pointer-events: auto;">Delete Dam</a>')
table_rows.append((dam.name, dam.owner, dam.river, dam.date_built,
dam_hydrograph, dam_delete))
dams_table = DataTableView(
column_names=('Name', 'Owner', 'River', 'Date Built', 'Hydrograph',
'Manage'),
rows=table_rows,
searching=False,
orderClasses=False,
lengthMenu=[[10, 25, 50, -1], [10, 25, 50, "All"]],
)
context = {
'dams_table': dams_table,
'can_add_dams': has_permission(request, 'add_dams')
}
return render(request, 'dam_inventory/list_dams.html', context)
def export(request):
"""
Controller for the Export page.
"""
start_date_input = DatePicker(
name='start_date',
display_text='Start Date',
autoclose=True,
format='MM d, yyyy',
start_date='8/24/2020',
start_view='decade',
today_button=True,
attributes={'class': 'date-input'},
)
end_date_input = DatePicker(
name='end_date',
display_text='End Date',
autoclose=True,
format='MM d, yyyy',
start_date='8/24/2020',
start_view='decade',
today_button=True,
)
cancel_button = Button(
display_text='Cancel',
name='cancel-button',
icon='glyphicon glyphicon-remove',
style='danger',
href=reverse('project_inventory:home')
)
submit_button = Button(
display_text='Submit',
name='submit-button',
style='success',
icon='glyphicon glyphicon-plus',
href=reverse('project_inventory:home')
)
context = {
'start_date_input': start_date_input,
'end_date_input': end_date_input,
'cancel_button': cancel_button,
'submit_button':submit_button,
'can_add_projects': has_permission(request, 'add_projects')
}
return render(request, 'project_inventory/export.html', context)
def reservoirviewer(request, name):
"""
controller for the reservoir specific page template. The code does 2 functions in this order:
- This calls the gethistoricaldata method which takes a long time to read 35 years of daily data
- Calls getdates to populate the next available forecast dates in the simulation tables
"""
for reservoir in reservoirs:
if reservoirs[reservoir] == name:
name = reservoir
App.currentpage = name
break
context = {
'admin': has_permission(request, 'update_data'),
'urls': generate_app_urls(request, reservoirs),
'name': name,
'youtubelink': App.youtubelink
}
return render(request, 'reservoirs/reservoir.html', context)
def list_dams(request):
"""
Show all dams in a table view.
"""
dams = get_all_dams()
table_rows = []
for dam in dams:
table_rows.append((dam.name, dam.owner, dam.river, dam.date_built))
dams_table = DataTableView(
column_names=('Name', 'Owner', 'River', 'Date Built', 'Hydrograph'),
rows=table_rows,
searching=False,
orderClasses=False,
lengthMenu=[[10, 25, 50, -1], [10, 25, 50, "All"]],
)
context = {
'dams_table': dams_table,
'can_add_dams': has_permission(request, 'add_dams')
}
return render(request, 'dam_inventory/list_dams.html', context)
def add_facility(request):
"""
Controller for the Add Facility page.
"""
print("In the controller")
# Default Values
facility_id = ''
project = ''
est_cost = ''
const_year = ''
location = ''
category = ''
description = ''
priority = ''
est_year = ''
const_cost = ''
debt_checked = False
recur_checked = False
# Errors
facility_id_error = ''
project_error = ''
est_cost_error = ''
const_year_error = ''
location_error = ''
category_error = ''
description_error = ''
priority_error = ''
est_year_error = ''
const_cost_error = ''
# Handle form submission
if request.POST and 'add-button' in request.POST:
print("In the first if")
# Get values
has_errors = False
facility_id = request.POST.get('facility_id', None)
location = request.POST.get('geometry', None)
# project = (request.POST.get(str(i) + '_add_project_project_name', None))
# est_cost = (request.POST.get(str(i) + '_add_project_project_estcost', None))
# est_year = (request.POST.get(str(i) + '_add_project_project_estyear', None))
# const_cost = (request.POST.get(str(i) + '_add_project_project_constcost', None))
# const_year =(request.POST.get(str(i) + '_add_project_project_constyear', None))
# category = (request.POST.get(str(i) + '_add_project_project_category', None))
# priority = (request.POST.get(str(i) + '_add_project_project_priority', None))
# description = (request.POST.get(str(i) + '_add_project_project_description', None))
# debt_checked = (request.POST.get(str(i) + '_add_project_debt_checkbox', None))
# recur_checked = (request.POST.get(str(i) + '_add_project_recur_checkbox', None))
project = (request.POST.get('project', None))
est_cost = (request.POST.get('est_cost', None))
est_year = (request.POST.get('est_year', None))
const_cost = (request.POST.get('const_cost', None))
const_year = (request.POST.get('const_year', None))
category = (request.POST.get('category', None))
priority = (request.POST.get('priority', None))
description = (request.POST.get('description', None))
debt_checked = (request.POST.get('debt_checkbox', None))
recur_checked = (request.POST.get('recur_checkbox', None))
# Validate
if not facility_id:
has_errors = True
facility_id_error = 'Facility ID is required.'
if not project:
has_errors = True
project_error = 'Project Name is required.'
if not est_cost:
has_errors = True
est_cost_error = 'Cost is required.'
if not const_year:
has_errors = True
const_year_error = 'Planned Year is required.'
if not category:
has_errors = True
category_error = 'Category is required.'
if not description:
has_errors = True
description_error = 'Description is required.'
if not priority:
has_errors = True
priority_error = 'Priority is required.'
if not est_year:
has_errors = True
est_year_error = 'Estimate Year is required.'
if not const_cost:
has_errors = True
const_cost_error = 'Construction Cost is required.'
if not location:
has_errors = True
location_error = 'Location is required.'
if not has_errors:
print("No Errors")
# Get value of max_projects custom setting
max_projects = app.get_custom_setting('max_projects')
# Query database for count of projects
Session = app.get_persistent_store_database('primary_db',
as_sessionmaker=True)
session = Session()
num_projects = session.query(Project).count()
# Only add the project if custom setting doesn't exist or we have not exceed max_projects
if not max_projects or num_projects < max_projects:
add_new_project(row_id=(num_projects + 1),
location=location,
facility_id=facility_id,
project=project,
est_cost=est_cost,
const_year=const_year,
category=category,
description=description,
priority=priority,
est_year=est_year,
const_cost=const_cost,
debt_checkbox_val=debt_checked,
recur_checkbox_val=recur_checked)
print("Project Added")
else:
messages.warning(
request,
'Unable to add project "{0}", because the inventory is full.'
.format(facility_id))
else:
messages.error(request, "Please fix errors.")
return redirect(reverse('project_inventory:home'))
# Define form gizmos
facility_id_input = TextInput(display_text='Facility ID',
name='facility_id',
initial=facility_id,
error=facility_id_error)
project_input = TextInput(display_text='Project Name',
name='project',
initial=project,
error=project_error)
est_cost_input = TextInput(display_text='Estimated Cost',
name='est_cost',
attributes={
'id': 'est_cost',
'type': 'number'
},
initial=est_cost,
error=est_cost_error)
description_input = TextInput(display_text='Description',
name='description',
initial=description,
error=description_error)
const_cost_input = TextInput(display_text='Construction Cost',
name='const_cost',
attributes={
'id': 'const_cost',
'type': 'number'
},
initial=const_cost,
error=const_cost_error)
est_year_input = TextInput(display_text='Estimate Year',
name='est_year',
attributes={
'id': 'est_year',
'type': 'number'
},
initial=est_year,
error=est_year_error)
const_year_input = TextInput(name='const_year',
display_text='Construction Year',
attributes={
'id': 'const_year',
'type': 'number'
},
initial=const_year,
error=const_year_error)
category_input = SelectInput(display_text='Category',
name='category',
multiple=False,
options=[('Water', 'Water'),
('Wastewater', 'Wastewater'),
('Stormwater', 'Stormwater'),
('Facilities', 'Facilities'),
('Golf', 'Golf'),
('Transportation', 'Transportation')
],
initial=['Water'],
error=category_error)
priority_input = SelectInput(display_text='Priority',
name='priority',
multiple=False,
options=[('One', '1'), ('Two', '2'),
('Three', '3'), ('Four', '4'),
('Five', '5')],
initial=['One'],
error=priority_error)
view_center = [-103.28, 47.8]
initial_view = MVView(projection='EPSG:4326',
center=view_center,
zoom=12.5)
drawing_options = MVDraw(controls=['Modify', 'Delete', 'Move', 'Point'],
initial='Point',
output_format='GeoJSON',
point_color='#FF0000')
location_input = MapView(
height='300px',
width='100%',
basemap=[
'OpenStreetMap'
# 'CartoDB',
# {'CartoDB': {'style': 'dark'}},
# 'Stamen',
# 'ESRI'
],
draw=drawing_options,
view=initial_view)
add_button = Button(display_text='Add',
name='add-button',
icon='glyphicon glyphicon-plus',
style='success',
attributes={'form': 'add-project-form'},
submit=True)
cancel_button = Button(display_text='Cancel',
name='cancel-button',
href=reverse('project_inventory:home'))
context = {
'facility_id_input': facility_id_input,
'project_input': project_input,
'est_cost_input': est_cost_input,
'const_year_input': const_year_input,
'est_year_input': est_year_input,
'category_input': category_input,
'description_input': description_input,
'priority_input': priority_input,
'const_cost_input': const_cost_input,
'location_input': location_input,
'location_error': location_error,
'add_button': add_button,
'cancel_button': cancel_button,
'can_add_projects': has_permission(request, 'add_projects')
}
return render(request, 'project_inventory/add_facility.html', context)
def site_handler(request, site_name):
"""
Main controller for the dams page.
"""
gen_urls(request)
site_name = site_name.replace('_', " ")
# Get config
site_config = config(site_name)
comids = site_config['comids']
forecasteddata = gettabledates(comids)
historyname = site_name
if (site_config['custom_history_name']):
historyname = site_config['custom_history_name']
data = gethistoricaldata(historyname)
min_level = [[data[0][0], site_config['min_level']],
[data[-1][0], site_config['min_level']]]
max_level = [[data[0][0], site_config['max_level']],
[data[-1][0], site_config['max_level']]]
timeseries_plot = TimeSeries(height='500px',
width='500px',
engine='highcharts',
title=site_name,
y_axis_title='Niveles de agua',
y_axis_units='m',
series=[{
'name': 'Historico',
'data': data
}, {
'name': 'Nivel Minimo de Operacion',
'data': min_level,
'type': 'line',
'color': '#660066'
}, {
'name': 'Nivel Maximo de Operacion',
'data': max_level,
'type': 'line',
'color': '#FF0000'
}],
y_min=site_config['ymin'])
outflow_edit = TableView(
column_names=('Dia', 'Caudal de Salida (cms)',
'Tiempo de salida (horas)'),
rows=[
(forecasteddata[0], '0', '0'),
(forecasteddata[1], '0', '0'),
(forecasteddata[2], '0', '0'),
(forecasteddata[3], '0', '0'),
(forecasteddata[4], '0', '0'),
(forecasteddata[5], '0', '0'),
(forecasteddata[6], '0', '0'),
],
hover=True,
striped=True,
bordered=True,
condensed=True,
editable_columns=(False, 'Outflow', 'Time'),
row_ids=['day1', 'day2', 'day3', 'day4', 'day5', 'day6', 'day7'],
classes="outflowtable")
calculate = Button(display_text='Calcular Niveles del Embalse',
name='calculate',
style='',
icon='',
href='',
submit=False,
disabled=False,
attributes={"onclick": "calculatelevels()"},
classes='calcbut')
outflow_button = Button(display_text='Ingresar caudales de salida',
name='dimensions',
style='',
icon='',
href='',
submit=False,
disabled=False,
attributes={"onclick": "outflowmodal()"},
classes='outflow_button')
context = {
'site_urls': gen_urls(request),
'name': site_name,
'timeseries_plot': timeseries_plot,
'outflow_button': edit_passthrough(request, outflow_button),
'calculate': calculate,
'outflow_edit': outflow_edit,
'show_edit': has_permission(request, 'update_data')
}
return render(request, 'reservoir_management/site_renderer.html', context)
def reportar(request):
"""
Controller for the app home page.
"""
#these are the different inputs on the reportar page of the app
dam_input = SelectInput(
display_text='Seleccionar una presa',
name='dam',
multiple=False,
original=True,
options=[('Sabana Yegua', 'Sabana Yegua'), ('Sabaneta', 'Sabaneta'),
('Hatillo', 'Hatillo'), ('Tavera-Bao', 'Tavera-Bao'),
('Moncion', 'Moncion'), ('Rincon', 'Rincon'),
('Jiguey', 'Jiguey'), ('Valdesia', 'Valdesia'),
('Rio Blanco', 'Rio Blanco'), ('Pinalito', 'Pinalito'),
('Maguaca', 'Maguaca'), ('Chacuey', 'Chacuey')],
attributes={"onchange": "get_min_max_operating_levels()"},
)
level_input = TextInput(
display_text='Nivel de Agua',
name='levelinput',
placeholder='Niveles de Operacion: Min-358 Max-396.4',
)
today = datetime.datetime.now()
year = str(today.year)
month = str(today.strftime("%B"))
day = str(today.day)
date = month + ' ' + day + ', ' + year
date_input = DatePicker(name='dateinput',
display_text='Dia',
autoclose=True,
format='MM d, yyyy',
start_date='2/15/2014',
start_view='month',
today_button=True,
initial=date)
data = getrecentdata()
table_view = TableView(
column_names=('Tiempo', 'Tavera-Bao', 'Moncion', 'Rincon', 'Hatillo',
'Jiguey', 'Valdesia', 'S. Yegua', 'Sabaneta',
'Rio Blanco', 'Pinalito', 'Maguaca', 'Chacuey'),
rows=data,
hover=True,
striped=True,
bordered=True,
condensed=True)
message_box = MessageBox(
name='sampleModal',
title='Resumen de Entradas',
message='',
dismiss_button='Regresar',
affirmative_button='Proceder',
width=400,
affirmative_attributes='onclick=append();',
)
download_button = Button(
display_text='Descargar Datos',
name='download',
style='',
icon='',
href=
'file:///C:/Users/student/tethysdev/tethysapp-reservoir_management/tethysapp/reservoir_management/workspaces/app_workspace/DamLevel_DR_BYU 2018.xlsx',
submit=False,
disabled=False,
attributes={"onclick": "outflowmodal()"},
classes='outflow_button')
context = {
'site_urls': gen_urls(request),
'dam_input': dam_input,
'level_input': level_input,
'date_input': date_input,
'table_view': table_view,
'message_box': message_box,
'download_button': download_button,
'show_edit': has_permission(request, 'update_data')
}
return render(request, 'reservoir_management/reportar.html', context)
def edit_passthrough(request, button_to_show):
#Can Set output data. Only allowed for admins
if (has_permission(request, 'update_data')):
return button_to_show
else:
return False
def home(request):
return render(
request, 'reservoir_management/home.html', {
'site_urls': gen_urls(request),
'show_edit': has_permission(request, 'update_data')
})
def add_well(request):
"""
Controller for the Add Well page.
"""
# Default Values
name = ''
owner = 'USGS'
river = ''
date_built = ''
location = ''
# Errors
name_error = ''
owner_error = ''
river_error = ''
date_error = ''
location_error = ''
# Handle form submission
if request.POST and 'add-button' in request.POST:
# Get values
has_errors = False
name = request.POST.get('name', None)
owner = request.POST.get('owner', None)
river = request.POST.get('river', None)
date_built = request.POST.get('date-built', None)
location = request.POST.get('geometry', None)
# Validate
if not name:
has_errors = True
name_error = 'Name is required.'
if not owner:
has_errors = True
owner_error = 'Owner is required.'
if not river:
has_errors = True
river_error = 'Aquifer is required.'
if not date_built:
has_errors = True
date_error = 'Date Built is required.'
if not location:
has_errors = True
location_error = 'Location is required.'
if not has_errors:
add_new_well(location=location,
name=name,
owner=owner,
river=river,
date_built=date_built)
return redirect(reverse('well_inventory:home'))
messages.error(request, "Please fix errors.")
# Define form gizmos
name_input = TextInput(display_text='Name',
name='name',
initial=name,
error=name_error)
owner_input = SelectInput(display_text='Owner',
name='owner',
multiple=False,
options=[('USGS', 'USGS'),
('Reclamation', 'Reclamation'),
('Army Corp', 'Army Corp'),
('Other', 'Other')],
initial=owner,
error=owner_error)
river_input = TextInput(display_text='Aquifer',
name='river',
placeholder='e.g.: Colorado Plateaus',
initial=river,
error=river_error)
date_built = DatePicker(name='date-built',
display_text='Date Built',
autoclose=True,
format='MM d, yyyy',
start_view='decade',
today_button=True,
initial=date_built,
error=date_error)
initial_view = MVView(projection='EPSG:4326',
center=[-98.6, 39.8],
zoom=3.5)
drawing_options = MVDraw(controls=['Modify', 'Delete', 'Move', 'Point'],
initial='Point',
output_format='GeoJSON',
point_color='#FF0000')
location_input = MapView(height='300px',
width='100%',
basemap='OpenStreetMap',
draw=drawing_options,
view=initial_view)
add_button = Button(display_text='Add',
name='add-button',
icon='glyphicon glyphicon-plus',
style='success',
attributes={'form': 'add-well-form'},
submit=True)
cancel_button = Button(display_text='Cancel',
name='cancel-button',
href=reverse('well_inventory:home'))
context = {
'name_input': name_input,
'owner_input': owner_input,
'river_input': river_input,
'date_built_input': date_built,
'location_input': location_input,
'location_error': location_error,
'add_button': add_button,
'cancel_button': cancel_button,
'can_add_wells': has_permission(request, 'add_wells'),
}
return render(request, 'well_inventory/add_well.html', context)
def home(request):
"""
Controller for the app home page.
"""
# Get list of wells and create wells MVLayer:
wells = get_all_wells()
features = []
lat_list = []
lng_list = []
for well in wells:
lat_list.append(well.latitude)
lng_list.append(well.longitude)
well_feature = {
'type': 'Feature',
'geometry': {
'type': 'Point',
'coordinates': [well.longitude, well.latitude],
},
'properties': {
'id': well.id,
'name': well.name,
'owner': well.owner,
'river': well.river,
'date_built': well.date_built
}
}
features.append(well_feature)
# Define GeoJSON FeatureCollection
wells_feature_collection = {
'type': 'FeatureCollection',
'crs': {
'type': 'name',
'properties': {
'name': 'EPSG:4326'
}
},
'features': features
}
style = {
'ol.style.Style': {
'image': {
'ol.style.Circle': {
'radius': 10,
'fill': {
'ol.style.Fill': {
'color': '#d84e1f'
}
},
'stroke': {
'ol.style.Stroke': {
'color': '#ffffff',
'width': 1
}
}
}
}
}
}
# Create a Map View Layer
wells_layer = MVLayer(source='GeoJSON',
options=wells_feature_collection,
legend_title='Wells',
layer_options={'style': style},
feature_selection=True)
# Define view centered on well locations
try:
view_center = [
sum(lng_list) / float(len(lng_list)),
sum(lat_list) / float(len(lat_list))
]
except ZeroDivisionError:
view_center = [-98.6, 39.8]
view_options = MVView(projection='EPSG:4326',
center=view_center,
zoom=4.5,
maxZoom=18,
minZoom=2)
well_inventory_map = MapView(height='100%',
width='100%',
layers=[wells_layer],
basemap='OpenStreetMap',
view=view_options)
add_well_button = Button(display_text='Add Well',
name='add-well-button',
icon='glyphicon glyphicon-plus',
style='success',
href=reverse('well_inventory:add_well'))
context = {
'well_inventory_map': well_inventory_map,
'add_well_button': add_well_button,
'can_add_wells': has_permission(request, 'add_wells')
}
return render(request, 'well_inventory/home.html', context)
def assign_hydrograph(request):
"""
Controller for the Add Hydrograph page.
"""
# Get wells from database
Session = app.get_persistent_store_database('primary_db',
as_sessionmaker=True)
session = Session()
all_wells = session.query(Well).all()
# Defaults
well_select_options = [(well.name, well.id) for well in all_wells]
selected_well = None
hydrograph_file = None
# Errors
well_select_errors = ''
hydrograph_file_error = ''
# Case where the form has been submitted
if request.POST and 'add-button' in request.POST:
# Get Values
has_errors = False
selected_well = request.POST.get('well-select', None)
if not selected_well:
has_errors = True
well_select_errors = 'Well is Required.'
# Get File
if request.FILES and 'hydrograph-file' in request.FILES:
# Get a list of the files
hydrograph_file = request.FILES.getlist('hydrograph-file')
if not hydrograph_file and len(hydrograph_file) > 0:
has_errors = True
hydrograph_file_error = 'Hydrograph File is Required.'
if not has_errors:
# Process file here
success = assign_hydrograph_to_well(selected_well,
hydrograph_file[0])
# Provide feedback to user
if success:
messages.info(request, 'Successfully assigned hydrograph.')
else:
messages.info(
request, 'Unable to assign hydrograph. Please try again.')
return redirect(reverse('well_inventory:home'))
messages.error(request, "Please fix errors.")
well_select_input = SelectInput(display_text='Well',
name='well-select',
multiple=False,
options=well_select_options,
initial=selected_well,
error=well_select_errors)
add_button = Button(display_text='Add',
name='add-button',
icon='glyphicon glyphicon-plus',
style='success',
attributes={'form': 'add-hydrograph-form'},
submit=True)
cancel_button = Button(display_text='Cancel',
name='cancel-button',
href=reverse('well_inventory:home'))
context = {
'well_select_input': well_select_input,
'hydrograph_file_error': hydrograph_file_error,
'add_button': add_button,
'cancel_button': cancel_button,
'can_add_wells': has_permission(request, 'add_wells')
}
session.close()
return render(request, 'well_inventory/assign_hydrograph.html', context)
def ecmwf(request):
# Can Set Default permissions : Only allowed for admin users
can_update_default = has_permission(request, 'update_default')
if(can_update_default):
defaultUpdateButton = Button(
display_text='Save',
name='update_button',
style='success',
attributes={
'data-toggle': 'tooltip',
'data-placement': 'bottom',
'title': 'Save as Default Options for WS'
})
else:
defaultUpdateButton = False
# Check if we need to hide the WS options dropdown.
hiddenAttr = ""
if app.get_custom_setting('show_dropdown') and app.get_custom_setting('default_model_type') and app.get_custom_setting('default_watershed_name'):
hiddenAttr = "hidden"
default_model = app.get_custom_setting('default_model_type')
init_model_val = request.GET.get('model', False) or default_model or 'Select Model'
init_ws_val = app.get_custom_setting('default_watershed_name') or 'Select Watershed'
model_input = SelectInput(display_text='',
name='model',
multiple=False,
options=[('Select Model', ''), ('ECMWF-RAPID', 'ecmwf')],
initial=[init_model_val],
classes=hiddenAttr,
original=True)
# Retrieve a geoserver engine and geoserver credentials.
geoserver_engine = app.get_spatial_dataset_service(
name='main_geoserver', as_engine=True)
geos_username = geoserver_engine.username
geos_password = geoserver_engine.password
my_geoserver = geoserver_engine.endpoint.replace('rest', '')
watershed_list = [['Select Watershed', '']] # + watershed_list
res2 = requests.get(my_geoserver + 'rest/workspaces/' + app.get_custom_setting('workspace') +
'/featuretypes.json', auth=HTTPBasicAuth(geos_username, geos_password), verify=False)
for i in range(len(json.loads(res2.content)['featureTypes']['featureType'])):
raw_feature = json.loads(res2.content)['featureTypes']['featureType'][i]['name']
if 'drainage_line' in raw_feature and any(n in raw_feature for n in app.get_custom_setting('keywords').replace(' ', '').split(',')):
feat_name = raw_feature.split('-')[0].replace('_', ' ').title() + ' (' + \
raw_feature.split('-')[1].replace('_', ' ').title() + ')'
if feat_name not in str(watershed_list):
watershed_list.append([feat_name, feat_name])
# Add the default WS if present and not already in the list
if default_model == 'ECMWF-RAPID' and init_ws_val and init_ws_val not in str(watershed_list):
watershed_list.append([init_ws_val, init_ws_val])
watershed_select = SelectInput(display_text='',
name='watershed',
options=watershed_list,
initial=[init_ws_val],
original=True,
classes=hiddenAttr,
attributes={'onchange': "javascript:view_watershed();"+hiddenAttr}
)
zoom_info = TextInput(display_text='',
initial=json.dumps(app.get_custom_setting('zoom_info')),
name='zoom_info',
disabled=True)
# Retrieve a geoserver engine and geoserver credentials.
geoserver_engine = app.get_spatial_dataset_service(
name='main_geoserver', as_engine=True)
my_geoserver = geoserver_engine.endpoint.replace('rest', '')
geoserver_base_url = my_geoserver
geoserver_workspace = app.get_custom_setting('workspace')
region = app.get_custom_setting('region')
extra_feature = app.get_custom_setting('extra_feature')
layer_name = app.get_custom_setting('layer_name')
geoserver_endpoint = TextInput(display_text='',
initial=json.dumps([geoserver_base_url, geoserver_workspace,
region, extra_feature, layer_name]),
name='geoserver_endpoint',
disabled=True)
context = {
"base_name": base_name,
"model_input": model_input,
"watershed_select": watershed_select,
"zoom_info": zoom_info,
"geoserver_endpoint": geoserver_endpoint,
"defaultUpdateButton": defaultUpdateButton
}
return render(request, '{0}/ecmwf.html'.format(base_name), context)
def add_dam(request):
"""
Controller for the Add Dam page.
"""
# Default Values
name = ''
owner = 'Reclamation'
river = ''
date_built = ''
location = ''
# Errors
name_error = ''
owner_error = ''
river_error = ''
date_error = ''
location_error = ''
# Handle form submission
if request.POST and 'add-button' in request.POST:
# Get values
has_errors = False
name = request.POST.get('name', None)
owner = request.POST.get('owner', None)
river = request.POST.get('river', None)
date_built = request.POST.get('date-built', None)
location = request.POST.get('geometry', None)
# Validate
if not name:
has_errors = True
name_error = 'Name is required.'
if not owner:
has_errors = True
owner_error = 'Owner is required.'
if not river:
has_errors = True
river_error = 'River is required.'
if not date_built:
has_errors = True
date_error = 'Date Built is required.'
if not location:
has_errors = True
location_error = 'Location is required.'
if not has_errors:
# Get value of max_dams custom setting
max_dams = app.get_custom_setting('max_dams')
# Query database for count of dams
Session = app.get_persistent_store_database('primary_db',
as_sessionmaker=True)
session = Session()
num_dams = session.query(Dam).count()
user_id = request.user.id
# Only add the dam if custom setting doesn't exist or we have not exceed max_dams
if not max_dams or num_dams < max_dams:
add_new_dam(location=location,
name=name,
owner=owner,
river=river,
date_built=date_built,
user_id=user_id)
else:
messages.warning(
request,
'Unable to add dam "{0}", because the inventory is full.'.
format(name))
new_num_dams = session.query(Dam).count()
if new_num_dams > num_dams:
channel_layer = get_channel_layer()
async_to_sync(channel_layer.group_send)("notifications", {
"type": "dam_notifications",
"message": "New Dam"
})
return redirect(reverse('dam_inventory:home'))
messages.error(request, "Please fix errors.")
# Define form gizmos
name_input = TextInput(display_text='Name',
name='name',
initial=name,
error=name_error)
owner_input = SelectInput(display_text='Owner',
name='owner',
multiple=False,
options=[('Reclamation', 'Reclamation'),
('Army Corp', 'Army Corp'),
('Other', 'Other')],
initial=owner,
error=owner_error)
river_input = TextInput(display_text='River',
name='river',
placeholder='e.g.: Mississippi River',
initial=river,
error=river_error)
date_built = DatePicker(name='date-built',
display_text='Date Built',
autoclose=True,
format='MM d, yyyy',
start_view='decade',
today_button=True,
initial=date_built,
error=date_error)
initial_view = MVView(projection='EPSG:4326',
center=[-98.6, 39.8],
zoom=3.5)
drawing_options = MVDraw(controls=['Modify', 'Delete', 'Move', 'Point'],
initial='Point',
output_format='GeoJSON',
point_color='#FF0000')
location_input = MapView(height='300px',
width='100%',
basemap='OpenStreetMap',
draw=drawing_options,
view=initial_view)
add_button = Button(display_text='Add',
name='add-button',
icon='glyphicon glyphicon-plus',
style='success',
attributes={'form': 'add-dam-form'},
submit=True)
cancel_button = Button(display_text='Cancel',
name='cancel-button',
href=reverse('dam_inventory:home'))
context = {
'name_input': name_input,
'owner_input': owner_input,
'river_input': river_input,
'date_built_input': date_built,
'location_input': location_input,
'location_error': location_error,
'add_button': add_button,
'cancel_button': cancel_button,
'can_add_dams': has_permission(request, 'add_dams')
}
return render(request, 'dam_inventory/add_dam.html', context)
def home(request):
"""
Controller for the app home page.
"""
# Get list of dams and create dams MVLayer:
dams = get_all_dams()
features = []
lat_list = []
lng_list = []
for dam in dams:
lat_list.append(dam.latitude)
lng_list.append(dam.longitude)
dam_feature = {
'type': 'Feature',
'geometry': {
'type': 'Point',
'coordinates': [dam.longitude, dam.latitude],
},
'properties': {
'id': dam.id,
'name': dam.name,
'owner': dam.owner,
'river': dam.river,
'date_built': dam.date_built
}
}
features.append(dam_feature)
# Define GeoJSON FeatureCollection
dams_feature_collection = {
'type': 'FeatureCollection',
'crs': {
'type': 'name',
'properties': {
'name': 'EPSG:4326'
}
},
'features': features
}
style = {
'ol.style.Style': {
'image': {
'ol.style.Circle': {
'radius': 10,
'fill': {
'ol.style.Fill': {
'color': '#d84e1f'
}
},
'stroke': {
'ol.style.Stroke': {
'color': '#ffffff',
'width': 1
}
}
}
}
}
}
# Create a Map View Layer
dams_layer = MVLayer(source='GeoJSON',
options=dams_feature_collection,
legend_title='Dams',
layer_options={'style': style},
feature_selection=True)
# Define view centered on dam locations
try:
view_center = [
sum(lng_list) / float(len(lng_list)),
sum(lat_list) / float(len(lat_list))
]
except ZeroDivisionError:
view_center = [-98.6, 39.8]
view_options = MVView(projection='EPSG:4326',
center=view_center,
zoom=4.5,
maxZoom=18,
minZoom=2)
dam_inventory_map = MapView(height='100%',
width='100%',
layers=[dams_layer],
basemap='OpenStreetMap',
view=view_options)
add_dam_button = Button(display_text='Add Dam',
name='add-dam-button',
icon='glyphicon glyphicon-plus',
style='success',
href=reverse('dam_inventory:add_dam'))
message_box = MessageBox(
name='notification',
title='',
dismiss_button='Nevermind',
affirmative_button='Refresh',
affirmative_attributes=
'onClick=window.location.href=window.location.href;')
context = {
'dam_inventory_map': dam_inventory_map,
'message_box': message_box,
'add_dam_button': add_dam_button,
'can_add_dams': has_permission(request, 'add_dams')
}
return render(request, 'dam_inventory/home.html', context)
def assign_hydrograph(request, user_workspace):
"""
Controller for the Add Hydrograph page.
"""
# Get dams from database
Session = app.get_persistent_store_database('primary_db',
as_sessionmaker=True)
session = Session()
all_dams = session.query(Dam).filter(Dam.user_id == request.user.id)
# Defaults
dam_select_options = [(dam.name, dam.id) for dam in all_dams]
selected_dam = None
hydrograph_file = None
# Errors
dam_select_errors = ''
hydrograph_file_error = ''
# Case where the form has been submitted
if request.POST and 'add-button' in request.POST:
# Get Values
has_errors = False
selected_dam = request.POST.get('dam-select', None)
if not selected_dam:
has_errors = True
dam_select_errors = 'Dam is Required.'
# Get File
if request.FILES and 'hydrograph-file' in request.FILES:
# Get a list of the files
hydrograph_file = request.FILES.getlist('hydrograph-file')
if not hydrograph_file and len(hydrograph_file) > 0:
has_errors = True
hydrograph_file_error = 'Hydrograph File is Required.'
if not has_errors:
# Process file here
hydrograph_file = hydrograph_file[0]
success = assign_hydrograph_to_dam(selected_dam, hydrograph_file)
# Remove csv related to dam if exists
for file in os.listdir(user_workspace.path):
if file.startswith("{}_".format(selected_dam)):
os.remove(os.path.join(user_workspace.path, file))
# Write csv to user_workspace to test workspace quota functionality
full_filename = "{}_{}".format(selected_dam, hydrograph_file.name)
with open(os.path.join(user_workspace.path, full_filename),
'wb+') as destination:
for chunk in hydrograph_file.chunks():
destination.write(chunk)
destination.close()
# Provide feedback to user
if success:
messages.info(request, 'Successfully assigned hydrograph.')
else:
messages.info(
request, 'Unable to assign hydrograph. Please try again.')
return redirect(reverse('dam_inventory:home'))
messages.error(request, "Please fix errors.")
dam_select_input = SelectInput(display_text='Dam',
name='dam-select',
multiple=False,
options=dam_select_options,
initial=selected_dam,
error=dam_select_errors)
add_button = Button(display_text='Add',
name='add-button',
icon='glyphicon glyphicon-plus',
style='success',
attributes={'form': 'add-hydrograph-form'},
submit=True)
cancel_button = Button(display_text='Cancel',
name='cancel-button',
href=reverse('dam_inventory:home'))
context = {
'dam_select_input': dam_select_input,
'hydrograph_file_error': hydrograph_file_error,
'add_button': add_button,
'cancel_button': cancel_button,
'can_add_dams': has_permission(request, 'add_dams')
}
session.close()
return render(request, 'dam_inventory/assign_hydrograph.html', context)
