def html_atpro_clear_mqtt_subscriber_log():
logger.network_logger.debug(
"** HTML Clear - MQTT Subscriber Log - Source: " +
str(request.remote_addr))
logger.clear_mqtt_subscriber_log()
return get_html_atpro_index(
run_script="SelectNav('mqtt-subscriber-view-data-stream');")
def html_atpro_db_downloads():
if request.method == "POST":
request_ip = str(request.remote_addr)
button_pressed = str(request.form.get("button-function"))
return _button_functions(button_pressed, request_ip)
return get_html_atpro_index(
run_script="SelectNav('sensor-system', skip_menu_select=true);")
def atpro_delete_log(url_path):
if url_path == "primary":
logger.network_logger.info("** Primary Sensor Log Deleted by " +
str(request.remote_addr))
logger.clear_primary_log()
elif url_path == "network":
logger.network_logger.info("** Network Sensor Log Deleted by " +
str(request.remote_addr))
logger.clear_network_log()
elif url_path == "sensors":
logger.network_logger.info("** Sensors Log Deleted by " +
str(request.remote_addr))
logger.clear_sensor_log()
return get_html_atpro_index(
"SelectNav('sensor-logs', skip_menu_select=true);")
def html_atpro_sensor_settings_database_management():
if request.method == "POST":
upload_db_folder = uploaded_databases_folder + "/"
try:
db_full_path = upload_db_folder + sanitize_text(request.form.get("db_selected"))
if sanitize_text(request.form.get("db_backups")) == "download_backup_db":
backup_db_folder = file_locations.database_backup_folder + "/"
db_selected_name = sanitize_text(request.form.get("DatabaseBackupSelection"))
db_full_path = backup_db_folder + db_selected_name
if db_selected_name in app_cached_variables.zipped_db_backup_list:
return send_file(db_full_path, as_attachment=True, attachment_filename=db_selected_name)
elif sanitize_text(request.form.get("db_management")) == "rename_db":
old_name = db_full_path.split("/")[-1]
new_name = get_clean_db_name(str(request.form.get("rename_db")))
new_db_full_path = upload_db_folder + new_name
os.rename(db_full_path, new_db_full_path)
uploaded_db_filenames = get_list_of_filenames_in_dir(uploaded_databases_folder)
app_cached_variables.uploaded_databases_list = uploaded_db_filenames
msg = "Database renamed from " + old_name + " to " + new_name
return get_message_page("Database Renamed", msg, page_url="sensor-system", skip_menu_select=True)
elif sanitize_text(request.form.get("db_management")) == "shrink_db":
selected_database = sanitize_text(request.form.get("SQLDatabaseSelection"))
return _vacuum_database(selected_database)
elif sanitize_text(request.form.get("db_management")) == "delete_db":
os.remove(db_full_path)
uploaded_db_filenames = get_list_of_filenames_in_dir(uploaded_databases_folder)
app_cached_variables.uploaded_databases_list = uploaded_db_filenames
msg = sanitize_text(request.form.get("db_selected")) + " Database has been deleted"
return get_message_page("Database Deleted", msg, page_url="sensor-system", skip_menu_select=True)
elif sanitize_text(request.form.get("db_management")) == "delete_backup_db":
db_full_path = file_locations.database_backup_folder + "/" + str(request.form.get("db_selected"))
os.remove(db_full_path)
backup_db_zip_filenames = get_list_of_filenames_in_dir(file_locations.database_backup_folder)
app_cached_variables.zipped_db_backup_list = backup_db_zip_filenames
msg = str(request.form.get("db_selected")) + " Database backup has been deleted"
return get_message_page("Database Backup Deleted", msg, page_url="sensor-system", skip_menu_select=True)
return get_html_atpro_index(run_script="SelectNav('sensor-system');")
except Exception as error:
return_text2 = "HTML Database Management Error: " + str(error)
logger.network_logger.error(return_text2)
msg_name = "Database Management Error"
return get_message_page(msg_name, str(error), page_url="sensor-system", skip_menu_select=True)
return render_template(
"ATPro_admin/page_templates/system/system-db-management.html",
UploadedDBOptionNames=_get_drop_down_items(app_cached_variables.uploaded_databases_list),
BackupDBOptionNames=_get_drop_down_items(app_cached_variables.zipped_db_backup_list)
)
def check_sensor_status_sensor_control(address_list):
"""
Uses provided remote sensor IP or DNS addresses (as a list) and checks if it's online.
Returns a flask rendered template with results as an HTML page.
"""
text_insert = ""
threads = []
for address in address_list:
threads.append(
Thread(target=get_remote_sensor_check_and_delay,
args=[address, True]))
start_and_wait_threads(threads)
address_responses = []
while not data_queue.empty():
address_responses.append(data_queue.get())
data_queue.task_done()
address_responses = sorted(address_responses, key=lambda i: i['address'])
for response in address_responses:
new_address = response["address"]
port = "10065"
if check_for_port_in_address(new_address):
new_address, port = get_ip_and_port_split(new_address)
elif len(new_address.split(":")) > 1:
new_address = "[" + new_address + "]"
response_time = response["response_time"]
background_colour = get_html_response_bg_colour(response_time)
sensor_url_link = "'https://" + new_address + ":" + port + "/'"
text_insert += "<tr><th width='160px'><span style='color: white; background-color: " + background_colour + \
";'>" + response_time + " Seconds</span></th>\n<th width='250px'>" + \
response["sensor_hostname"] + "</th>\n<th><a target='_blank' href=" + sensor_url_link + ">" + \
response["address"] + "</a></th></tr>\n"
status_page = render_template(
"ATPro_admin/page_templates/remote_management/online-status-check.html",
SensorResponse=text_insert.strip())
return get_html_atpro_index(
run_script="SelectActiveMainMenu('sensor-rm');",
main_page_view_content=status_page)
def html_atpro_sensor_control_save_settings():
if request.method == "POST":
ip_list_command = str(request.form.get("ip_list_command"))
selected_ip_list = str(request.form.get("selected_ip_list"))
new_name = get_clean_ip_list_name(
str(request.form.get("ip_list_new_name")))
current_location = file_locations.custom_ip_lists_folder + "/" + selected_ip_list
if ip_list_command == "CreateNewIPList":
CreateIPList(new_name=new_name)
_update_ip_lists(new_name)
elif ip_list_command == "RenameIPList":
new_location = file_locations.custom_ip_lists_folder + "/" + new_name
os.rename(current_location, new_location)
_update_ip_lists(new_name)
elif ip_list_command == "DeleteIPList":
os.remove(current_location)
_update_ip_lists()
return get_html_atpro_index(
run_script=
"SelectNav('rm-ip-list-management', skip_menu_select=true);")
return render_template(
"ATPro_admin/page_templates/remote_management/ip-list-management.html",
IPListsOptionNames=get_rm_ip_lists_drop_down())
def html_atpro_sensor_graphing_live():
if request.method == "POST":
lgc.update_with_html_request(request)
lgc.save_config_to_file()
return get_html_atpro_index(run_script="SelectNav('sensor-graphing-live');")
sensor_address = lgc.graph_sensor_address
if sensor_address is None:
sensor_address = ""
return render_template(
"ATPro_admin/page_templates/graphing-live.html",
GraphSensorAddress=sensor_address,
CheckedEnableSSLVerification=get_html_checkbox_state(lgc.enable_ssl_verification),
CheckedEnablePerformanceMode=get_html_checkbox_state(lgc.enable_performance_mode),
CheckedGPL1=lgc.get_checked_graph_per_line_state(1),
CheckedGPL2=lgc.get_checked_graph_per_line_state(2),
CheckedGPL3=lgc.get_checked_graph_per_line_state(3),
CheckedGPL4=lgc.get_checked_graph_per_line_state(4),
GraphMaxDataPoints=lgc.max_graph_data_points,
GraphIntervalValue=lgc.live_graph_update_interval,
CheckedSensorUptime=get_html_checkbox_state(lgc.live_graph_uptime),
CheckedCPUTemperature=get_html_checkbox_state(lgc.live_graph_cpu_temp),
CheckedEnvTemperature=get_html_checkbox_state(lgc.live_graph_env_temp),
CheckedPressure=get_html_checkbox_state(lgc.live_graph_pressure),
CheckedAltitude=get_html_checkbox_state(lgc.live_graph_altitude),
CheckedHumidity=get_html_checkbox_state(lgc.live_graph_humidity),
CheckedDewPoint=get_html_checkbox_state(lgc.live_graph_dew_point),
CheckedDistance=get_html_checkbox_state(lgc.live_graph_distance),
CheckedGas=get_html_checkbox_state(lgc.live_graph_gas),
CheckedPM=get_html_checkbox_state(lgc.live_graph_particulate_matter),
CheckedLumen=get_html_checkbox_state(lgc.live_graph_lumen),
CheckedColour=get_html_checkbox_state(lgc.live_graph_colours),
CheckedUltraViolet=get_html_checkbox_state(lgc.live_graph_ultra_violet),
CheckedAccelerometer=get_html_checkbox_state(lgc.live_graph_acc),
CheckedMagnetometer=get_html_checkbox_state(lgc.live_graph_mag),
CheckedGyroscope=get_html_checkbox_state(lgc.live_graph_gyro)
)
def html_create_plotly_graph():
generate_plotly_graph(request)
return get_html_atpro_index(run_script="SelectNav('sensor-graphing-db');")
def downloads_direct_rsm(address_list,
download_type="sensors_download_databases"):
"""
Used to initiate Downloads from provided IP or DNS addresses (list).
Function option "download_type" dictates which type of download.
Default = sensors_download_databases
"""
download_command = network_commands.sensor_sql_all_databases_zip
download_type_message = "the SQLite3 Databases Zipped"
add_zipped_database_size = True
add_zipped_logs_size = False
size_type = "MB"
column_download_message = "Uncompressed Main DB Size"
extra_message = "Due to the CPU demands of zipping on the fly, raw Database size is shown here.<br>" + \
"Actual download size will be much smaller. MQTT / Checkin Database Size not shown."
if download_type == app_config_access.sensor_control_config.radio_download_logs:
extra_message = ""
column_download_message = "Zipped Logs Size"
size_type = "KB"
add_zipped_database_size = False
add_zipped_logs_size = True
download_command = network_commands.download_zipped_logs
download_type_message = "Full Logs Zipped"
sensor_download_url = "window.open('https://{{ IPAddress }}/" + download_command + "');"
sensor_download_sql_list = ""
text_ip_and_response = ""
threads = []
for address in address_list:
threads.append(
Thread(target=get_remote_sensor_check_and_delay,
args=[
address, False, add_zipped_database_size,
add_zipped_logs_size
]))
start_and_wait_threads(threads)
address_responses = []
while not data_queue.empty():
address_responses.append(data_queue.get())
data_queue.task_done()
address_responses = sorted(address_responses, key=lambda i: i['address'])
for response in address_responses:
if response["status"] == "OK":
new_address = response["address"].strip()
if check_for_port_in_address(new_address):
address_split = get_ip_and_port_split(new_address)
address_and_port = address_split[0] + ":" + address_split[1]
elif len(new_address.split(":")) > 1:
address_and_port = "[" + new_address + "]:10065"
else:
address_and_port = new_address + ":10065"
response_time = response["response_time"]
background_colour = get_html_response_bg_colour(response_time)
new_download = sensor_download_url.replace("{{ IPAddress }}",
address_and_port)
sensor_download_sql_list += new_download + "\n"
text_ip_and_response += "<tr><th width='160px'><span style='background-color: " + background_colour + \
";'>" + response_time + " Seconds</span></th>\n" + \
"<th width='220'>" + response["download_size"] + " " + size_type + "</th>\n" + \
"<th>" + response["address"] + "</th></tr>"
download_page = render_template(
"ATPro_admin/page_templates/remote_management/direct-sensor-downloads.html",
DownloadTypeMessage=download_type_message,
DownloadURLs=sensor_download_sql_list.strip(),
SensorResponse=text_ip_and_response.strip(),
ColumnDownloadMessage=column_download_message,
ExtraMessage=extra_message)
return get_html_atpro_index(run_script="",
main_page_view_content=download_page)
def html_atpro_index():
return get_html_atpro_index()
def html_atpro_sensor_notes():
if request.method == "POST":
if request.form.get("button_function"):
button_operation = request.form.get("button_function")
if button_operation == "new":
app_cached_variables.notes_total_count += 1
app_cached_variables.note_current = app_cached_variables.notes_total_count
app_cached_variables.cached_notes_as_list.append("New Note")
current_datetime = datetime.utcnow().strftime(
"%Y-%m-%d %H:%M:%S")
new_note_and_datetime = current_datetime + app_cached_variables.command_data_separator + "New Note"
add_note_to_database(new_note_and_datetime)
if app_cached_variables.note_current > app_cached_variables.notes_total_count:
app_cached_variables.note_current = 1
elif button_operation == "save":
note_text = request.form.get("note_text")
if app_cached_variables.notes_total_count > 0:
note_auto_date_times = get_db_note_dates().split(",")
note_custom_date_times = get_db_note_user_dates().split(
",")
primary_note_date_time = note_auto_date_times[
app_cached_variables.note_current - 1]
custom_note_date_time = note_custom_date_times[
app_cached_variables.note_current - 1]
updated_note_and_datetime = primary_note_date_time + app_cached_variables.command_data_separator + \
custom_note_date_time + app_cached_variables.command_data_separator + \
note_text
update_note_in_database(updated_note_and_datetime)
else:
app_cached_variables.notes_total_count += 1
app_cached_variables.note_current = app_cached_variables.notes_total_count
app_cached_variables.cached_notes_as_list.append(note_text)
current_datetime = datetime.utcnow().strftime(
"%Y-%m-%d %H:%M:%S")
new_note_and_datetime = current_datetime + app_cached_variables.command_data_separator + note_text
add_note_to_database(new_note_and_datetime)
app_cached_variables.cached_notes_as_list[
app_cached_variables.note_current - 1] = note_text
elif button_operation == "next":
app_cached_variables.note_current += 1
if app_cached_variables.note_current > app_cached_variables.notes_total_count:
app_cached_variables.note_current = 1
elif button_operation == "back":
app_cached_variables.note_current -= 1
if app_cached_variables.note_current < 1:
app_cached_variables.note_current = app_cached_variables.notes_total_count
elif button_operation == "go":
custom_current_note = request.form.get("current_note_num")
if app_cached_variables.notes_total_count > 0:
app_cached_variables.note_current = int(
custom_current_note)
elif button_operation == "delete":
if app_cached_variables.notes_total_count > 0:
db_note_date_times = get_db_note_dates().split(",")
app_cached_variables.cached_notes_as_list.pop(
app_cached_variables.note_current - 1)
delete_db_note(
db_note_date_times[(app_cached_variables.note_current -
1)])
app_cached_variables.notes_total_count -= 1
app_cached_variables.note_current = 1
return get_html_atpro_index(
run_script="SelectNav('sensor-notes');")
if app_cached_variables.notes_total_count > 0:
selected_note = app_cached_variables.cached_notes_as_list[
app_cached_variables.note_current - 1]
else:
selected_note = "No Notes Found"
return render_template("ATPro_admin/page_templates/notes.html",
CurrentNoteNumber=app_cached_variables.note_current,
LastNoteNumber=str(
app_cached_variables.notes_total_count),
DisplayedNote=selected_note)
def remote_management_main_post(request):
run_command = request.form.get("rsm-run-command")
selected_ip_list = str(request.form.get("selected_ip_list"))
if run_command == "ChangeIPList":
app_config_access.sensor_control_config.selected_ip_list = selected_ip_list
app_config_access.sensor_control_config.change_ip_list()
elif run_command == "SaveSettings":
app_config_access.sensor_control_config.update_with_html_request(
request)
app_config_access.sensor_control_config.save_config_to_file()
elif run_command == "SaveSettings-report-emails":
app_config_access.email_reports_config.update_with_html_request(
request)
app_config_access.email_reports_config.save_config_to_file()
elif run_command == "RunAction":
sc_action = request.form.get("selected_action")
sc_download_type = request.form.get("selected_send_type")
app_config_access.sensor_control_config.update_with_html_request(
request)
ip_list_raw = app_config_access.sensor_control_config.get_raw_ip_addresses_as_list(
)
if len(ip_list_raw) > 0:
if sc_action == app_config_access.sensor_control_config.radio_check_status:
return check_sensor_status_sensor_control(ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_report_combo:
thread_function(_thread_combo_report, args=ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_report_system:
generate_system_report(ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_report_config:
generate_config_report(ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_report_test_sensors:
generate_readings_report(ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_report_sensors_latency:
generate_latency_report(ip_list_raw)
elif sc_action == app_config_access.sensor_control_config.radio_download_reports:
rm_cached_variables.creating_combo_reports_zip = True
logger.network_logger.info(
"Sensor Control - Reports Zip Generation Started")
clear_zip_names()
thread_function(put_all_reports_zipped_to_cache,
args=ip_list_raw)
else:
ip_list = app_config_access.sensor_control_config.get_clean_ip_addresses_as_list(
)
if len(ip_list) < 1:
msg_1 = "All sensors appear to be Offline"
return get_message_page(msg_1, page_url="sensor-rm")
elif sc_action == app_config_access.sensor_control_config.radio_download_databases:
download_sql_databases = app_config_access.sensor_control_config.radio_download_databases
if sc_download_type == app_config_access.sensor_control_config.radio_send_type_direct:
return downloads_direct_rsm(
ip_list, download_type=download_sql_databases)
else:
rm_cached_variables.creating_databases_zip = True
logger.network_logger.info(
"Sensor Control - Databases Zip Generation Started"
)
thread_function(create_all_databases_zipped,
args=ip_list)
elif sc_action == app_config_access.sensor_control_config.radio_download_logs:
clear_zip_names()
if sc_download_type == app_config_access.sensor_control_config.radio_send_type_direct:
download_logs = app_config_access.sensor_control_config.radio_download_logs
return downloads_direct_rsm(
ip_list, download_type=download_logs)
elif sc_download_type == app_config_access.sensor_control_config.radio_send_type_relayed:
rm_cached_variables.creating_logs_zip = True
logger.network_logger.info(
"Sensor Control - Multi Sensors Logs Zip Generation Started"
)
thread_function(create_multiple_sensor_logs_zipped,
args=ip_list)
elif sc_action == app_config_access.sensor_control_config.radio_create_the_big_zip:
logger.network_logger.info(
"Sensor Control - The Big Zip Generation Started")
rm_cached_variables.creating_the_big_zip = True
thread_function(create_the_big_zip, args=ip_list)
else:
return _sensor_addresses_required_msg()
elif run_command == "DownloadRSMReportsZip":
try:
if not rm_cached_variables.creating_combo_reports_zip:
if rm_cached_variables.sc_reports_zip_name != "":
zip_file = rm_cached_variables.sc_in_memory_zip
zip_filename = rm_cached_variables.sc_reports_zip_name
rm_cached_variables.sc_reports_zip_name = ""
return send_file(zip_file,
attachment_filename=zip_filename,
as_attachment=True)
except Exception as error:
logger.network_logger.error("Send Reports Zip Error: " +
str(error))
msg_1 = "Problem loading Zip"
msg_2 = str(error)
return get_message_page(msg_1, msg_2, page_url="sensor-rm")
rm_cached_variables.sc_reports_zip_name = ""
elif run_command == "DownloadRSMDatabasesZip":
if not rm_cached_variables.creating_databases_zip:
if rm_cached_variables.sc_databases_zip_name != "":
try:
if rm_cached_variables.sc_databases_zip_in_memory:
zip_file = rm_cached_variables.sc_in_memory_zip
else:
zip_file = file_locations.html_sensor_control_databases_zip
zip_filename = rm_cached_variables.sc_databases_zip_name
rm_cached_variables.sc_databases_zip_name = ""
rm_cached_variables.sc_databases_zip_in_memory = False
return send_file(zip_file,
attachment_filename=zip_filename,
as_attachment=True)
except Exception as error:
logger.network_logger.error("Send Databases Zip Error: " +
str(error))
rm_cached_variables.sc_databases_zip_name = ""
rm_cached_variables.sc_databases_zip_in_memory = False
msg_1 = "Problem loading Zip"
msg_2 = str(error)
return get_message_page(msg_1, msg_2, page_url="sensor-rm")
elif run_command == "DownloadRSMLogsZip":
try:
if not rm_cached_variables.creating_logs_zip:
if rm_cached_variables.sc_logs_zip_name != "":
zip_file = rm_cached_variables.sc_in_memory_zip
zip_filename = rm_cached_variables.sc_logs_zip_name
rm_cached_variables.sc_logs_zip_name = ""
return send_file(zip_file,
attachment_filename=zip_filename,
as_attachment=True)
except Exception as error:
logger.network_logger.error("Send SC Logs Zip Error: " +
str(error))
msg_1 = "Problem loading Zip"
msg_2 = str(error)
return get_message_page(msg_1, msg_2, page_url="sensor-rm")
rm_cached_variables.sc_logs_zip_name = ""
elif run_command == "DownloadRSMBigZip":
try:
if not rm_cached_variables.creating_the_big_zip:
if rm_cached_variables.sc_big_zip_name != "":
if rm_cached_variables.sc_big_zip_in_memory:
zip_file = rm_cached_variables.sc_in_memory_zip
rm_cached_variables.sc_big_zip_name = ""
rm_cached_variables.sc_big_zip_in_memory = False
else:
zip_file = file_locations.html_sensor_control_big_zip
zip_filename = rm_cached_variables.sc_big_zip_name
return send_file(zip_file,
attachment_filename=zip_filename,
as_attachment=True)
except Exception as error:
logger.network_logger.error("Send Big Zip Error: " + str(error))
msg_1 = "Problem loading Zip"
msg_2 = str(error)
return get_message_page(msg_1, msg_2, page_url="sensor-rm")
rm_cached_variables.sc_big_zip_in_memory = False
return get_html_atpro_index(run_script="SelectNav('sensor-rm');")
def _button_functions(button_pressed, request_ip="N/A"):
try:
if button_pressed == "download-main-db-raw":
logger.network_logger.debug(
"* Download RAW Main SQL Database Accessed by " + request_ip)
sensor_database = file_locations.sensor_database
if os.path.isfile(sensor_database):
sql_filename = _add_host_and_ip_to_filename(
"Sensor_Database", "sqlite")
return send_file(sensor_database,
as_attachment=True,
attachment_filename=sql_filename)
return "Kootnet Sensors main database not found"
elif button_pressed == "download-mqtt-sub-db-raw":
logger.network_logger.debug(
"* Download RAW MQTT SQL Database Accessed by " +
str(request.remote_addr))
mqtt_subscriber_database = file_locations.mqtt_subscriber_database
if os.path.isfile(mqtt_subscriber_database):
sql_filename = _add_host_and_ip_to_filename(
"MQTT_Database", "sqlite")
return send_file(mqtt_subscriber_database,
as_attachment=True,
attachment_filename=sql_filename)
return "Kootnet Sensors MQTT Subscriber database not found"
elif button_pressed == "download-checkin-db-raw":
logger.network_logger.debug(
"* Download RAW Checkin SQL Database Accessed by " +
str(request_ip))
sensor_checkin_database = file_locations.sensor_checkin_database
if os.path.isfile(sensor_checkin_database):
sql_filename = _add_host_and_ip_to_filename(
"Sensors_Checkin_Database", "sqlite")
return send_file(sensor_checkin_database,
as_attachment=True,
attachment_filename=sql_filename)
return "Kootnet Sensors Checkin database not found"
elif button_pressed == "download-main-db-zip":
if not app_cached_variables.creating_zip_main_db:
database_zipped = file_locations.database_zipped
if os.path.isfile(database_zipped):
zip_filename = _add_host_and_ip_to_filename(
"Main_Database", "zip")
logger.network_logger.debug(
"* Download Zipped Main SQL Database Accessed by " +
request_ip)
return send_file(database_zipped,
as_attachment=True,
attachment_filename=zip_filename)
return "Zipped Main SQL database not found, 'Generate New Zip' before trying again."
else:
return "Creating database zip, please try again later ..."
elif button_pressed == "download-mqtt-sub-db-zip":
if not app_cached_variables.creating_zip_mqtt_sub_db:
mqtt_database_zipped = file_locations.mqtt_database_zipped
if os.path.isfile(mqtt_database_zipped):
zip_filename = _add_host_and_ip_to_filename(
"MQTT_Subscriber_Database", "zip")
log_msg = "* Download Zipped MQTT Subscriber SQL Database Accessed by "
logger.network_logger.debug(log_msg + request_ip)
return send_file(mqtt_database_zipped,
as_attachment=True,
attachment_filename=zip_filename)
return "Zipped MQTT Subscriber SQL database not found, 'Generate New Zip' before trying again."
else:
return "Creating database zip, please try again later ..."
elif button_pressed == "download-checkin-db-zip":
if not app_cached_variables.creating_zip_checkin_db:
checkin_database_zipped = file_locations.checkin_database_zipped
if os.path.isfile(checkin_database_zipped):
zip_filename = _add_host_and_ip_to_filename(
"Checkin_Database", "zip")
logger.network_logger.debug(
"* Download Zipped Checkin SQL Database Accessed by " +
request_ip)
return send_file(checkin_database_zipped,
as_attachment=True,
attachment_filename=zip_filename)
return "Zipped Sensor Checkin SQL database not found, 'Generate New Zip' before trying again."
else:
return "Creating database zip, please try again later ..."
elif button_pressed == "create-main-db-zip":
if not app_cached_variables.creating_zip_main_db:
thread_function(_zip_main_db_worker)
elif button_pressed == "create-mqtt-sub-db-zip":
if not app_cached_variables.creating_zip_mqtt_sub_db:
thread_function(_zip_mqtt_sub_db_worker)
elif button_pressed == "create-checkin-db-zip":
if not app_cached_variables.creating_zip_checkin_db:
thread_function(_zip_checkin_db_worker)
except Exception as error:
log_msg = "HTML Database Request Error from " + request_ip + " using command " + button_pressed + ": "
logger.primary_logger.error(log_msg + str(error))
return get_html_atpro_index(
run_script="SelectNav('sensor-system', skip_menu_select=true);")
