def rwis_get_weather():
qry_data = {}
if request.method == 'POST':
qry_data = request.form
elif request.method == 'GET':
qry_data = request.args
sdate = qry_data.get('start_date')
edate = qry_data.get('end_date')
site_id = qry_data.get('site_id', None)
sen_id = qry_data.get('sen_id', 0)
if not site_id:
return prot.response_fail('site_id is required')
if not sdate or not edate:
return prot.response_fail('starte_date and end_date are required')
try:
sdate = datetime.datetime.strptime(sdate, '%Y-%m-%d %H:%M:%S')
edate = datetime.datetime.strptime(edate, '%Y-%m-%d %H:%M:%S')
except:
return prot.response_fail(
'datetime format must be "yyyy-mm-dd hh:ii:ss"')
if sdate >= edate:
return prot.response_fail(
'end_date must be greater than start_date')
if (edate - sdate).seconds <= 600:
return prot.response_fail(
'time duration must be longer than 10 minutes')
wd = rwis.get_weather(site_id, Period(sdate, edate, 300), sen_id)
return prot.response_success(wd)
def insert_all(self):
json_str = request.form.get('data')
json_str_list = python_json.loads(json_str)
da_instance = self.data_access_class()
obj_list = []
for json_data in json_str_list:
obj = self.json2obj(json_data)
obj_list.append(obj)
try:
model_data = da_instance.insert(obj, autocommit=False)
except exc.IntegrityError:
print('integrity error')
da_instance.rollback()
da_instance.close()
return prot.response_fail("Integrity Error")
except Exception as ex:
print('Unknown error')
print(ex)
da_instance.rollback()
da_instance.close()
return prot.response_fail("Unknown Error")
da_instance.commit()
da_instance.close()
callback = getattr(self, 'on_insert_all_success', None)
if callback:
callback(obj_list)
return prot.response_success()
def tetres_snowroute_update():
id = request.form.get('id')
route_json = request.form.get('data')
snowRouteDA = SnowRouteDataAccess()
ex = snowRouteDA.get_by_id(id)
if not ex:
snowRouteDA.close_session()
return prot.response_invalid_request()
info = json2snri(route_json)
is_updated = snowRouteDA.update(
id, {
'name': info.name,
'description': info.description,
'prj_id': info.prj_id
})
if not is_updated:
return prot.response_fail('fail to update database')
if not snowRouteDA.commit():
return prot.response_fail('fail to update database (commit fail)')
tetresApi.add_actionlog(ActionLogDataAccess.INSERT,
snowRouteDA.get_tablename(),
id,
ActionLogDataAccess.data_description(
ActionLogDataAccess.DT_SNOWROUTE, info),
handled=True,
dbsession=snowRouteDA.get_session())
return prot.response_success(id)
def delete(self):
json_str = request.form.get('ids')
ids = python_json.loads(json_str)
da_instance = self.data_access_class()
has_error = False
deleted_objs = []
for id in ids:
try:
ex = da_instance.get_by_id(id)
deleted = da_instance.delete(id, autocommit=False)
except:
has_error = True
break
if not deleted:
has_error = True
break
else:
deleted_objs.append(ex)
if has_error:
da_instance.rollback()
da_instance.close()
return prot.response_fail("fail to delete items")
da_instance.commit()
da_instance.close()
callback = getattr(self, 'on_delete_success', None)
if callback:
callback(deleted_objs)
return prot.response_success(ids)
def insert_all(self):
if self.requires_auth and not admin_auth.check_auth():
return admin_auth.authenticate()
json_str = request.form.get('data')
json_str_list = python_json.loads(json_str)
# db session is created and share the session with all other database access module
da_instance = self.da_class()
obj_list = []
dict_list = []
for idx, json_data in enumerate(json_str_list):
obj = self.json2obj(json_data)
dict_list.append(obj.get_dict())
obj_list.append(obj)
inserted_ids = da_instance.bulk_insert(dict_list)
if not inserted_ids or not da_instance.commit():
da_instance.close_session()
return prot.response_fail("Fail to add data into database")
tablename = da_instance.get_tablename()
for obj_id in inserted_ids:
insertedObj = da_instance.get_model_by_id(obj_id)
self.add_actionlog(ActionLogDataAccess.INSERT,
tablename,
obj_id,
ActionLogDataAccess.data_description(self.datatype, insertedObj),
handled=False)
da_instance.close_session()
return prot.response_success()
def insert(self):
if self.requires_auth and not admin_auth.check_auth():
return admin_auth.authenticate()
# db session is created and share the session with all other database access module
da_instance = self.da_class()
json_data = request.form.get('data')
obj = self.json2obj(json_data)
# obj.id = da_instance.da_base.get_next_pk()
model_data = da_instance.insert(obj)
if model_data is False or not da_instance.commit():
da_instance.close_session()
return prot.response_fail("Fail to insert data")
inserted_id = model_data.id
self.add_actionlog(ActionLogDataAccess.INSERT,
da_instance.get_tablename(),
model_data.id,
ActionLogDataAccess.data_description(self.datatype, model_data),
handled=False,
dbsession=da_instance.get_session())
da_instance.close_session()
return prot.response_success(obj=inserted_id)
def tetres_client_download_data():
""" Called when the client tries to download the data """
try:
outdir, filename = compress_data()
except Exception as e:
return prot.response_fail(message='Failed to compress data')
return send_file(outdir + '/' + filename, as_attachment=True)
def tetres_admin_route_from_cfg():
file_content = request.form.get('cfgfile')
r = rc.loader.load_from_contents(base64.b64decode(file_content))
if not isinstance(r, Route):
return prot.response_fail(
'fail to load_data route configuration file')
return prot.response_success(r)
def tetres_client_upload_data():
""" Called when the client tries to upload the data """
if 'file' not in request.files:
return prot.response_fail('No file part')
file = request.files['file']
if file.filename == '':
return prot.response_fail('No selected file')
if file and allowed_file(file.filename):
filename = 'data.zip'
filedir = common.DATA_PATH + "/tetres/clientdatafiles"
file.save(os.path.join(filedir, filename))
success = extract_data(filedir, filename)
if success:
return prot.response_success()
else:
return prot.response_fail('Failed to extract data')
return prot.response_fail('Failed to save/extract data')
def tetres_client_upload_file():
""" Called when the client tries to upload a single file """
if 'file' not in request.files:
return prot.response_fail('No file part')
file = request.files['file']
if file.filename == '':
return prot.response_fail('No selected file')
if file and allowed_file(file.filename):
filedir = common.DATA_PATH
path = os.path.join(filedir, file.filename)
success = file.save(path)
if success:
return prot.response_success()
else:
return prot.response_fail('Failed to save file')
return prot.response_fail('Failed to save file')
def _wz_insert_from_wz(wzi):
"""
:type wzi: WorkZoneInfo
"""
if not isinstance(wzi,
WorkZoneInfo) or not wzi.route1 or not wzi.route2:
return prot.response_invalid_request()
wzDA = WorkZoneDataAccess()
wzi.route1.name = 'route1 - %s' % wzi.route1.rnodes[0].corridor.name
wzi.route1.desc = ''
wzi.route2.name = 'route2 - %s' % wzi.route2.rnodes[0].corridor.name
wzi.route2.desc = ''
# wzi.id = wzDA.da_base.get_next_pk()
wzm = wzDA.insert(wzi)
if wzm is False or not wzDA.commit():
return prot.response_fail('fail to save workzone route data (1)')
wzi.id = wzm.id
inserted = _wz_insert_feature(wzi)
if inserted:
inserted_id = wzi.id
tetres_api.add_actionlog(ActionLogDataAccess.INSERT,
wzDA.get_tablename(),
inserted_id,
ActionLogDataAccess.data_description(
ActionLogDataAccess.DT_WORKZONE, wzi),
handled=False,
dbsession=wzDA.get_session())
wzDA.close_session()
return prot.response_success(obj=inserted_id)
else:
# if failed to add features
wzDA.delete(wzm.id)
wzDA.close_session()
return prot.response_fail('fail to save workzone route data (2)')
def insert(self):
json_data = request.form.get('data')
obj = self.json2obj(json_data)
da_instance = self.data_access_class()
try:
model_data = da_instance.insert(obj, autocommit=True)
except exc.IntegrityError:
da_instance.close()
return prot.response_fail("Integrity Error")
except:
da_instance.close()
return prot.response_fail("Unknown Error")
da_instance.close()
callback = getattr(self, 'on_insert_success', None)
if callback:
callback(obj)
return prot.response_success(obj=model_data.id)
def tetres_snowroute_insert():
route_json = request.form.get('data')
info = json2snri(route_json)
snowRouteDA = SnowRouteDataAccess()
ex = snowRouteDA.get_by_name(info.name)
if ex:
snowRouteDA.close_session()
return prot.response_fail('already exist')
route2 = route.opposite_route(info.route1)
cfg2 = info.route1.cfg.clone()
rc.route_config.reverse(cfg2)
route2.cfg = cfg2
info.route2 = route2
info.route1.name = 'route1 - %s' % info.route1.rnodes[0].corridor.name
info.route1.desc = ''
info.route2.name = 'route2 - %s' % info.route2.rnodes[0].corridor.name
info.route2.desc = ''
snrm = snowRouteDA.insert(info)
if not snrm:
snowRouteDA.close_session()
return prot.response_fail('Fail to insert data')
snowRouteDA.commit()
tetresApi.add_actionlog(ActionLogDataAccess.INSERT,
snowRouteDA.get_tablename(),
snrm.id,
ActionLogDataAccess.data_description(
ActionLogDataAccess.DT_SNOWROUTE, snrm),
handled=False,
dbsession=snowRouteDA.get_session())
inserted_id = snrm.id
snowRouteDA.close_session()
return prot.response_success(obj=inserted_id)
def update(self):
if self.requires_auth and not admin_auth.check_auth():
return admin_auth.authenticate()
id = request.form.get('id')
json_data = request.form.get('data')
# db session is created and share the session with all other database access module
da_instance = self.da_class()
obj = self.json2obj(json_data)
exobj = da_instance.get_by_id(id)
if not exobj:
da_instance.close_session()
return prot.response_fail("item does not exist (id={})".format(id))
is_updated = da_instance.update(id, obj.get_dict())
if not is_updated:
da_instance.close_session()
return prot.response_fail("fail to update (id={})".format(id))
if not da_instance.commit():
return prot.response_fail("fail to update (id={})".format(id))
callback = getattr(self, 'on_update_success', None)
if callback:
callback(obj, da_instance.get_session())
exobj = da_instance.get_by_id(id)
self.add_actionlog(ActionLogDataAccess.UPDATE,
da_instance.get_tablename(),
id,
ActionLogDataAccess.data_description(self.datatype, exobj),
self._is_handled(exobj, obj),
dbsession=da_instance.get_session())
da_instance.close_session()
return prot.response_success(obj=id)
def tetres_route_opposite_route():
route_id = request.form.get('id')
da = TTRouteDataAccess()
ttri = da.get_by_id(route_id)
da.close_session()
route_setup(ttri.route)
opposite_route = route.opposite_route(ttri.route)
if not isinstance(opposite_route, Route):
return prot.response_fail(
'fail to load_data route configuration file')
return prot.response_success(opposite_route)
def update(self):
id = request.form.get('id')
json_data = request.form.get('data')
da_instance = self.data_access_class()
obj = self.json2obj(json_data)
updated = da_instance.update(id, obj.get_dict(), autocommit=True)
da_instance.close()
if updated:
callback = getattr(self, 'on_update_success', None)
if callback:
callback(obj)
return prot.response_success(obj=id)
else:
return prot.response_fail("fail to update (id={})".format(id))
def delete(self):
if self.requires_auth and not admin_auth.check_auth():
return admin_auth.authenticate()
json_str = request.form.get('ids')
ids = python_json.loads(json_str)
# db session is created and share the session with all other database access module
da_instance = self.da_class()
deleted_objs = [da_instance.get_by_id(id) for id in ids]
deleted_objs = [v for v in deleted_objs if v]
ex_ids = [v.id for v in deleted_objs if v]
is_deleted = da_instance.delete_items(ex_ids, print_exception=True)
if not is_deleted:
da_instance.close_session()
return prot.response_fail("fail to delete items")
if not da_instance.commit():
return prot.response_fail("fail to delete items")
callback = getattr(self, 'on_delete_success', None)
if callback:
callback(deleted_objs, da_instance.get_session())
for idx, obj_id in enumerate(ex_ids):
deletedObj = deleted_objs[idx]
self.add_actionlog(ActionLogDataAccess.DELETE,
da_instance.get_tablename(),
obj_id,
ActionLogDataAccess.data_description(self.datatype, deletedObj),
handled=True,
dbsession=da_instance.get_session())
da_instance.close_session()
return prot.response_success(ids)
def _wz_insert_from_route(wzi, route_json):
"""
:type wzi: WorkZoneInfo
:type route_json: str
"""
route1 = json2route(route_json)
route2 = route.opposite_route(route1)
if not isinstance(route2, Route):
return prot.response_fail(
'fail to load_data route configuration file')
cfg2 = route1.cfg.clone()
route2.cfg = rc.route_config.reverse(cfg2)
wzi.route1 = route1
wzi.route2 = route2
return _wz_insert_from_wz(wzi)
def tetres_pi_get():
route_id = request.form.get('route_id')
depart_time = request.form.get('depart_time')
weather_type = request.form.get('weather_type', None)
try:
depart_time = datetime.datetime.strptime(depart_time,
'%Y-%m-%d %H:%M')
except:
return prot.response_fail(
'depart_time format must be "%Y-%m-%d %H:%M:00"')
try:
reliabilites, traveltimes = traveltime_info.traveltime_info(
route_id, weather_type, depart_time)
except Exception as ex:
tb.traceback(ex)
return prot.response_fail(
'fail to extract data for the given route')
return prot.response_success({
'reliabilities': reliabilites,
'traveltimes': traveltimes
})
def tetres_admin_xlsx_content_from_route():
route_content = request.form.get('route')
r = json2route(route_content)
try:
tmp_dir = Infra.get_infra().get_path('tmp', create=True)
uid = str(uuid.uuid4())
filepath = os.path.join(tmp_dir, '%s.xlsx' % uid)
if not r.cfg:
r.cfg = route_config.create_route_config(r.rnodes)
rc.writer.write(filepath, r)
with open(filepath, 'rb') as f:
file_content = f.read()
encoded = base64.b64encode(file_content)
return prot.response_success(obj=encoded.decode('utf-8'))
except Exception as ex:
tb.traceback(ex)
return prot.response_fail('fail to write route')
def tetres_user_get_result():
uid = request.form.get('uid')
if not uid:
return prot.response_error('invalid request')
output_path = util.output_path(uid, create=False)
output_filepath = '%s.zip' % output_path
# file is ready
if os.path.exists(output_filepath):
return prot.response_success('file is ready')
# process is runninng
elif os.path.exists(output_path):
return prot.response_fail('process is running')
# invalid uid
else:
return prot.response_error('invalid uid')
def tetres_syscfg_update():
cfginfo_json = request.form.get('cfg', None)
if not cfginfo_json:
return prot.response_invalid_request()
cfginfo = json.loads(cfginfo_json, SystemConfigInfo)
if not cfginfo or not isinstance(cfginfo, SystemConfigInfo):
return prot.response_invalid_request()
for k, v in cfginfo.__dict__.items():
if k.startswith('_'):
continue
if v is None:
return prot.response_invalid_request()
prev_syscfg = systemconfig.set_system_config_info(cfginfo)
if not prev_syscfg:
return prot.response_fail('fail to update configuration')
put_task_to_actionlog(prev_syscfg)
return prot.response_success()
def ncrtes_ts_update():
year = int(request.form.get('year'))
station_id = request.form.get('station_id')
detectors = request.form.get('detectors')
infra = ncrtes.get_infra()
str_detectors = str(detectors)
if not year:
return prot.response_fail('Year Info must be entered.')
if not station_id:
return prot.response_fail('Station Info must be entered.')
if not detectors:
return prot.response_fail('Detectors must be entered.')
station = infra.get_rnode(station_id)
if not station:
return prot.response_fail('Station %s does not exists.' %
station_id)
station_detectors = [det.name for det in station.detectors]
detectors = [x.strip() for x in detectors.split(',')]
for det_name in detectors:
det = infra.get_detector(det_name)
if not det:
return prot.response_fail('Detector %s does not exists.' %
det_name)
if det.name not in station_detectors:
return prot.response_fail(
'Detector %s does not exists on the station.' % det_name)
wsDA = WinterSeasonDataAccess()
wsi = wsDA.get_by_year(year)
if not wsi:
months = get_normal_months_from_year(year)
wsi = itypes.WinterSeasonInfo()
wsi.set_months(months)
wsi.name = 'WinterSeason %s-%s' % (months[0][0], months[-1][0])
wsDA.insert(wsi, autocommit=True)
wsDA.close()
tsDA = TargetStationDataAccess()
ex_tsi = tsDA.get_by_station_id(year, station_id)
tsDA.close()
tlcDA = TargetLaneConfigDataAccess()
ex_tlci = tlcDA.get_by_station_id(year, station_id)
if not ex_tlci:
ex_tlci = itypes.TargetLaneConfigInfo()
ex_tlci.winterseason_id = wsi.id
ex_tlci.station_id = station_id
ex_tlci.detectors = ''
ex_tlci.corridor_name = station.corridor.name
model = tlcDA.insert(ex_tlci, autocommit=True)
ex_tlci.id = model.id
# update normal function
if ex_tsi and ex_tlci.detectors != str_detectors:
target_station = infra.get_rnode(ex_tlci.station_id)
valid_detectors = [
infra.get_detector(det_name) for det_name in detectors
]
normal_months = get_normal_months_from_year(year)
nf, nfi = None, None
try:
nf, nfi = _update_normal_function(target_station,
normal_months,
valid_detectors)
except Exception as ex:
from pyticas.tool import tb
tb.traceback(ex)
# query to update database
ex_tlci.detectors = ','.join(detectors)
updated = tlcDA.update(ex_tlci.id, ex_tlci.get_dict(), autocommit=True)
tlcDA.close()
if updated:
return prot.response_success(obj=ex_tlci.id)
else:
return prot.response_fail("fail to update (id={})".format(
ex_tlci.id))
def tetres_workzone_update():
wz_id = request.form.get('id')
wz_json = request.form.get('data')
wzDA = WorkZoneDataAccess()
exWZObj = wzDA.get_by_id(wz_id)
if not exWZObj:
wzDA.close_session()
return prot.response_invalid_request()
info = json2wzi(wz_json)
route2 = route.opposite_route(info.route1)
cfg2 = info.route1.cfg.clone()
rc.route_config.reverse(cfg2)
route2.cfg = cfg2
info.route2 = route2
info.route1.name = 'route1 - %s' % info.route1.rnodes[0].corridor.name
info.route1.desc = ''
info.route2.name = 'route2 - %s' % info.route2.rnodes[0].corridor.name
info.route2.desc = ''
if not isinstance(info.route2, Route):
wzDA.close_session()
return prot.response_fail(
'fail to load_data route configuration file')
wzgDA = WZGroupDataAccess(session=wzDA.get_session())
is_updated = wzDA.update(wz_id, info.get_dict())
if not is_updated or not wzDA.commit():
wzDA.rollback()
wzDA.close_session()
return prot.response_fail('fail to update database (1)')
is_updated = wzgDA.update_years(exWZObj.wz_group_id)
if not is_updated or not wzgDA.commit():
wzgDA.rollback()
wzgDA.close_session()
return prot.response_fail('fail to update database (2)')
updatedWZObj = wzDA.get_by_id(wz_id)
inserted = _wz_insert_feature(updatedWZObj)
if not inserted:
wzDA.close_session()
return prot.response_fail('fail to update database (3)')
# commit here
# if not wzDA.commit():
# return prot.response_fail('fail to update database (4)')
tetres_api.add_actionlog(ActionLogDataAccess.UPDATE,
wzDA.get_tablename(),
wz_id,
ActionLogDataAccess.data_description(
ActionLogDataAccess.DT_WORKZONE,
updatedWZObj),
handled=_should_be_set_as_handled(
exWZObj, updatedWZObj),
dbsession=wzDA.get_session())
wzDA.close_session()
return prot.response_success(wz_id)
def moe_rwis():
return prot.response_fail('Not Implemented')
