def get(self, project_db):
SetupProjectDatabase.init(project_db)
try:
m = Project_config.get()
return {
"has_weather":
climate.Weather_sta_cli.select().count() > 0
and climate.Weather_wgn_cli.select().count() > 0,
"input_files_dir":
utils.full_path(project_db, m.input_files_dir),
"input_files_last_written":
utils.json_encode_datetime(m.input_files_last_written),
"swat_last_run":
utils.json_encode_datetime(m.swat_last_run)
}
except Project_config.DoesNotExist:
abort(404,
message="Could not retrieve project configuration data.")
def put(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args_reflect(change.Codes_sft, project_db)
if change.Codes_sft.select().count() > 0:
result = self.save_args(change.Codes_sft, args, id=1)
else:
result = self.save_args(change.Codes_sft, args, is_new=True)
if result > 0:
return 200
abort(400, message='Unable to update calibration codes.')
except change.Codes_sft.DoesNotExist:
abort(404, message='Could not find calibration codes in database.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db, id):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('exco_om_exc', project_db)
m = Exco_om_exc.get(Exco_om_exc.id == id)
result = save_exco_om_exc(m, args)
if result > 0:
return 200
abort(400, message='Unable to update om exco properties {id}.'.format(id=id))
except IntegrityError as e:
abort(400, message='Exco om properties name must be unique.')
except Exco_om_exc.DoesNotExist:
abort(404, message='Exco om properties {id} does not exist'.format(id=id))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db, id):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('cntable_lum', project_db)
m = Cntable_lum.get(Cntable_lum.id == id)
result = save_cntable_lum(m, args)
if result > 0:
return 200
abort(400, message='Unable to update curve number table {id}.'.format(id=id))
except IntegrityError as e:
abort(400, message='Curve number table name must be unique.')
except Cntable_lum.DoesNotExist:
abort(404, message='Curve number table {id} does not exist'.format(id=id))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def get(self, project_db):
SetupProjectDatabase.init(project_db)
if Rout_unit_con.select().count() > 0:
m = Rout_unit_con.select(
fn.Max(Rout_unit_con.lat).alias('n'),
fn.Min(Rout_unit_con.lat).alias('s'),
fn.Max(Rout_unit_con.lon).alias('e'),
fn.Min(Rout_unit_con.lon).alias('w')).scalar(as_tuple=True)
return {'n': m[0], 's': m[1], 'e': m[2], 'w': m[3]}
elif Chandeg_con.select().count() > 0: # Quick fix for lte
m = Chandeg_con.select(
fn.Max(Chandeg_con.lat).alias('n'),
fn.Min(Chandeg_con.lat).alias('s'),
fn.Max(Chandeg_con.lon).alias('e'),
fn.Min(Chandeg_con.lon).alias('w')).scalar(as_tuple=True)
return {'n': m[0], 's': m[1], 'e': m[2], 'w': m[3]}
else:
return {'n': 0, 's': 0, 'e': 0, 'w': 0}
def put(self, project_db, id):
table = change.Water_balance_sft
item_table = change.Water_balance_sft_item
description = 'Calibration'
parser = reqparse.RequestParser()
parser.add_argument('id', type=int, required=False, location='json')
parser.add_argument('name', type=str, required=True, location='json')
parser.add_argument('items', type=list, required=False, location='json')
args = parser.parse_args(strict=False)
try:
SetupProjectDatabase.init(project_db)
result = self.save_args(table, args, id=id)
if args['items'] is not None:
items = []
for c in args['items']:
items.append({
'water_balance_sft_id': id,
'name': c['name'],
'surq_rto': c['surq_rto'],
'latq_rto': c['latq_rto'],
'perc_rto': c['perc_rto'],
'et_rto': c['et_rto'],
'tileq_rto': c['tileq_rto'],
'pet': c['pet'],
'sed': c['sed'],
'orgn': c['orgn'],
'orgp': c['orgp'],
'no3': c['no3'],
'solp': c['solp']
})
item_table.delete().where(item_table.water_balance_sft_id == id).execute()
lib.bulk_insert(project_base.db, item_table, items)
return 200
except IntegrityError as e:
abort(400, message='{item} save error. '.format(item=description) + str(e))
except table.DoesNotExist:
abort(404, message='{item} {id} does not exist'.format(item=description, id=id))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def post(self, project_db):
args = get_landuse_args()
try:
SetupProjectDatabase.init(project_db)
m = Landuse_lum()
result = save_landuse_args(self, m, args)
if result > 0:
return 200
abort(400,
message='Unable to update channel properties {id}.'.format(
id=id))
except IntegrityError as e:
abort(400, message='Channel properties name must be unique.')
except Plant_ini.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['plnt_com_name']))
except Management_sch.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['mgt_name']))
except Cntable_lum.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['cn2_name']))
except Cons_prac_lum.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['cons_prac_name']))
except Urban_urb.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['urban_name']))
except Ovn_table_lum.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['ov_mann_name']))
except Tiledrain_str.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['tile_name']))
except Septic_str.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['sep_name']))
except Filterstrip_str.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['vfs_name']))
except Grassedww_str.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['grww_name']))
except Bmpuser_str.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['bmp_name']))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('exco_om_exc', project_db, True)
param_dict = {}
for key in args.keys():
if args[key] is not None and key != 'selected_ids':
param_dict[key] = args[key]
query = Exco_om_exc.update(param_dict).where(Exco_om_exc.id.in_(args['selected_ids']))
result = query.execute()
if result > 0:
return 200
abort(400, message='Unable to update exco om properties.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def get(self, project_db, sort, reverse, page, items_per_page):
table = change.Plant_gro_sft
list_name = 'calibrations'
SetupProjectDatabase.init(project_db)
total = table.select().count()
sort_val = SQL(sort)
if reverse == 'true':
sort_val = SQL(sort).desc()
m = table.select().order_by(sort_val).paginate(int(page), int(items_per_page))
ml = []
for v in m:
d = model_to_dict(v, recurse=True)
d['items'] = len(v.items)
ml.append(d)
return {'total': total, list_name: ml}
def post(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('om_water_ini', project_db)
m = Om_water_ini()
result = save_om_water(m, args)
if result > 0:
return model_to_dict(m), 201
abort(
400,
message='Unable to update organic mineral water {id}.'.format(
id=id))
except IntegrityError as e:
abort(400, message='Organic mineral water name must be unique.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db):
SetupProjectDatabase.init(project_db)
args = get_recallrec_args(True)
try:
param_dict = {}
if args['rec_typ'] is not None:
param_dict['rec_typ'] = args['rec_typ']
con_table = Recall_con
con_prop_field = Recall_con.rec_id
prop_table = Recall_rec
con_param_dict = {}
if args['wst_name'] is not None:
con_param_dict['wst_id'] = self.get_id_from_name(Weather_sta_cli, args['wst_name'])
if args['elev'] is not None:
con_param_dict['elev'] = args['elev']
con_result = 1
if (len(con_param_dict) > 0):
con_query = con_table.update(con_param_dict).where(con_table.id.in_(args['selected_ids']))
con_result = con_query.execute()
if con_result > 0:
result = 1
if (len(param_dict) > 0):
prop_ids = con_table.select(con_prop_field).where(con_table.id.in_(args['selected_ids']))
query = prop_table.select().where(prop_table.id.in_(prop_ids))
sim = Time_sim.get_or_create_default()
for m in query:
update_recall_rec(project_base.db, m, m.id, sim, args['rec_typ'])
query2 = prop_table.update(param_dict).where(prop_table.id.in_(prop_ids))
result = query2.execute()
if result > 0:
return 200
abort(400, message='Unable to update routing unit properties.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db):
SetupProjectDatabase.init(project_db)
args = get_res_args(True)
try:
param_dict = {}
if args['init_name'] is not None:
param_dict['init_id'] = self.get_id_from_name(
Initial_res, args['init_name'])
if args['rel_name'] is not None:
param_dict['rel_id'] = self.get_id_from_name(
D_table_dtl, args['rel_name'])
if args['hyd_name'] is not None:
param_dict['hyd_id'] = self.get_id_from_name(
Hydrology_wet, args['hyd_name'])
if args['sed_name'] is not None:
param_dict['sed_id'] = self.get_id_from_name(
Sediment_res, args['sed_name'])
if args['nut_name'] is not None:
param_dict['nut_id'] = self.get_id_from_name(
Nutrients_res, args['nut_name'])
query = Wetland_wet.update(param_dict).where(
Wetland_wet.id.in_(args['selected_ids']))
result = query.execute()
if result > 0:
return 200
abort(400, message='Unable to update wetland .')
except Initial_res.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['init_name']))
except D_table_dtl.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['rel_name']))
except Hydrology_wet.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['hyd_name']))
except Sediment_res.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['sed_name']))
except Nutrients_res.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['nut_name']))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def get(self, project_db, id):
SetupProjectDatabase.init(project_db)
table = change.Calibration_cal
description = 'Calibration'
try:
m = table.get(table.id == id)
item = model_to_dict(m, recurse=True, backrefs=True, max_depth=1)
obj_options = []
parm_type = m.cal_parm.obj_typ
obj_typ = table_mapper.cal_to_obj.get(parm_type, None)
if obj_typ is not None:
obj_table = table_mapper.obj_typs.get(obj_typ, None)
if obj_table is not None:
t = obj_table.select(obj_table.id, obj_table.name).order_by(obj_table.name)
obj_options = [{'value': v.id, 'text': v.name} for v in t]
return {'item': item, 'obj_options': obj_options}
except table.DoesNotExist:
abort(404, message='{description} {id} does not exist'.format(description=description, id=id))
def post(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('aquifer_aqu', project_db)
result = self.save_args(Aquifer_aqu,
args,
is_new=True,
lookup_fields=['init'])
if result > 0:
return 200
abort(400,
message='Unable to update aquifer properties {id}.'.format(
id=id))
except IntegrityError as e:
abort(400, message='Aquifer properties name must be unique.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def base_get(self,
project_db,
id,
table,
description,
back_refs=False,
max_depth=1):
SetupProjectDatabase.init(project_db)
try:
m = table.get(table.id == id)
if back_refs:
d = model_to_dict(m, backrefs=True, max_depth=max_depth)
self.get_obj_name(d)
return d
else:
return model_to_dict(m, recurse=False)
except table.DoesNotExist:
abort(404,
message='{description} {id} does not exist'.format(
description=description, id=id))
def post(self, project_db):
SetupProjectDatabase.init(project_db)
args = get_hyd_args()
try:
e = Hydrology_hyd.get(Hydrology_hyd.name == args['name'])
abort(400, message='Hydrology name must be unique. A hydrology with this name already exists.')
except Hydrology_hyd.DoesNotExist:
try:
m = Hydrology_hyd()
result = save_hyd(m, args)
if result > 0:
return model_to_dict(m), 201
abort(400, message='Unable to update hydrology properties {id}.'.format(id=id))
except IntegrityError as e:
abort(400, message='Hydrology properties name must be unique.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def __init__(self,
file_name,
table_name,
db_file,
delete_existing=False,
related_id=0,
ignore_id_col=True):
self.__abort = False
SetupProjectDatabase.init(db_file)
self.file_name = file_name
self.table = table_mapper.types.get(table_name, None)
self.table_name = table_name
self.delete_existing = delete_existing
self.related_id = related_id
self.ignore_id_col = ignore_id_col
if self.table is None:
sys.exit(
"Table '{table}' does not exist.".format(table=table_name))
def put(self, project_db, id):
args = get_soil_plant_args()
try:
SetupProjectDatabase.init(project_db)
m = Soil_plant_ini.get(Soil_plant_ini.id == id)
m.name = args['name']
m.sw_frac = args['sw_frac']
m.nutrients_id = self.get_id_from_name(Nutrients_sol,
args['nutrients_name'])
m.pest_id = self.get_id_from_name(Pest_hru_ini, args['pest_name'])
m.path_id = self.get_id_from_name(Path_hru_ini, args['path_name'])
m.hmet_id = self.get_id_from_name(Hmet_hru_ini, args['hmet_name'])
m.salt_id = self.get_id_from_name(Salt_hru_ini, args['salt_name'])
result = m.save()
if result > 0:
return 200
abort(400,
message='Unable to update soil plant {id}.'.format(id=id))
except IntegrityError as e:
abort(400, message='Soil plant properties name must be unique.')
except Soil_plant_ini.DoesNotExist:
abort(404,
message='Soil plant properties {id} does not exist'.format(
id=id))
except Nutrients_sol.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['nutrients_name']))
except Pest_hru_ini.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['pest_name']))
except Path_hru_ini.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['path_name']))
except Hmet_hru_ini.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['hmet_name']))
except Salt_hru_ini.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['salt_name']))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put_con(self, project_db, id, prop_name, con_table, prop_table):
args = self.get_con_args(prop_name)
try:
SetupProjectDatabase.init(project_db)
params = {
'name': args['name'],
'area': args['area'],
'lat': args['lat'],
'lon': args['lon'],
'elev': args['elev'],
}
params['{}_id'.format(prop_name)] = self.get_id_from_name(
prop_table, args['{}_name'.format(prop_name)])
if args['wst_name'] is not None:
params['wst_id'] = self.get_id_from_name(
climate.Weather_sta_cli, args['wst_name'])
result = con_table.update(params).where(
con_table.id == id).execute()
if result > 0:
return 200
abort(400, message='Unable to update Hru {id}.'.format(id=id))
except IntegrityError:
abort(400, message='Name must be unique.')
except con_table.DoesNotExist:
abort(404, message='Object {id} does not exist'.format(id=id))
except prop_table.DoesNotExist:
abort(400,
message=self.__invalid_name_msg.format(
name=args['{}_name'.format(prop_name)]))
except climate.Weather_sta_cli.DoesNotExist:
abort(
400,
message=self.__invalid_name_msg.format(name=args['wst_name']))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db, id):
args = get_routingunit_args()
try:
SetupProjectDatabase.init(project_db)
m = Rout_unit_rtu.get(Rout_unit_rtu.id == id)
m.name = args['name']
m.description = args['description']
if args['dlr_name']:
m.dlr_id = self.get_id_from_name(Delratio_del,
args['dlr_name'])
if args['topo_name']:
m.topo_id = self.get_id_from_name(Topography_hyd,
args['topo_name'])
if args['field_name']:
m.field_id = self.get_id_from_name(Field_fld,
args['field_name'])
result = m.save()
if result > 0:
return 200
abort(400,
message='Unable to update routing unit properties {id}.'.
format(id=id))
except IntegrityError as e:
abort(400, message='Routing unit properties name must be unique.')
except Rout_unit_rtu.DoesNotExist:
abort(404,
message='Routing unit properties {id} does not exist'.format(
id=id))
except Topography_hyd.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['topo_name']))
except Delratio_del.DoesNotExist:
abort(400, message=invalid_name_msg.format(name=args['dlr_name']))
except Field_fld.DoesNotExist:
abort(400,
message=invalid_name_msg.format(name=args['field_name']))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def get(self, project_db, sort, reverse, page, items_per_page):
table = Plant_ini
list_name = 'plants'
SetupProjectDatabase.init(project_db)
total = table.select().count()
sort_val = SQL(sort)
if reverse == 'true':
sort_val = SQL(sort).desc()
m = table.select().order_by(sort_val).paginate(int(page),
int(items_per_page))
ml = [{
'id': v.id,
'name': v.name,
'rot_yr_ini': v.rot_yr_ini,
'description': v.description,
'num_plants': len(v.plants)
} for v in m]
return {'total': total, list_name: ml}
def get(self, project_db, sort, reverse, page, items_per_page):
table = Management_sch
list_name = 'mgt_sch'
SetupProjectDatabase.init(project_db)
total = table.select().count()
sort_val = SQL(sort)
if reverse == 'true':
sort_val = SQL(sort).desc()
m = table.select().order_by(sort_val).paginate(int(page),
int(items_per_page))
ml = [{
'id': v.id,
'name': v.name,
'num_ops': len(v.operations),
'num_auto': len(v.auto_ops)
} for v in m]
return {'total': total, list_name: ml}
def get(self, project_db, sort, reverse, page, items_per_page):
table = Ls_unit_def
list_name = 'ls_units'
SetupProjectDatabase.init(project_db)
total = table.select().count()
sort_val = SQL(sort)
if reverse == 'true':
sort_val = SQL(sort).desc()
m = table.select().order_by(sort_val).paginate(int(page),
int(items_per_page))
ml = [{
'id': v.id,
'name': v.name,
'area': v.area,
'num_elements': len(v.elements)
} for v in m]
return {'total': total, list_name: ml}
def put(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('cntable_lum', project_db, True)
remove_spaces = ['description', 'treat', 'cond_cov']
param_dict = {}
for key in args.keys():
if args[key] is not None and key != 'selected_ids':
param_dict[key] = utils.remove_space(args[key]) if key in remove_spaces else args[key]
query = Cntable_lum.update(param_dict).where(Cntable_lum.id.in_(args['selected_ids']))
result = query.execute()
if result > 0:
return 200
abort(400, message='Unable to update curve number tables.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def post(self, project_db):
try:
SetupProjectDatabase.init(project_db)
args = self.get_args('graze_ops', project_db)
result = self.save_args(Graze_ops,
args,
is_new=True,
lookup_fields=['fert'])
if result > 0:
return 201
abort(
400,
message='Unable to update graze operation {id}.'.format(id=id))
except IntegrityError as e:
abort(400,
message='Graze operation name must be unique. ' + str(e))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def post(self, project_db):
args = get_con_out_args()
SetupProjectDatabase.init(project_db)
try:
m = Delratio_con_out()
m.order = args['order']
m.obj_typ = args['obj_typ']
m.obj_id = args['obj_id']
m.hyd_typ = args['hyd_typ']
m.frac = args['frac']
m.delratio_con_id = args['delratio_con_id']
result = m.save()
if result > 0:
return model_to_dict(m), 201
abort(400, message='Unable to create delratio outflow.')
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
def put(self, project_db, id):
try:
SetupProjectDatabase.init(project_db)
args = get_hyd_args()
m = Hydrology_hyd.get(Hydrology_hyd.id == id)
result = save_hyd(m, args)
if result > 0:
return 200
abort(400,
message='Unable to update hydrology properties {id}.'.format(
id=id))
except IntegrityError as e:
abort(400, message='Hydrology properties name must be unique.')
except Hydrology_hyd.DoesNotExist:
abort(404,
message='Hydrology properties {id} does not exist'.format(
id=id))
except Exception as ex:
abort(400, message="Unexpected error {ex}".format(ex=ex))
