def download_all_sql_databases_zipped(): logger.network_logger.debug( "* Download Zip of All Databases Accessed by " + str(request.remote_addr)) zip_name = _get_net_and_host_name_str("All_Databases", ".zip") try: return_names = [ app_cached_variables.hostname + "_Main_Database.sqlite", app_cached_variables.hostname + "_Checkin_Database.sqlite", app_cached_variables.hostname + "_MQTT_Sub_Database.sqlite" ] return_files = [ get_file_content(file_locations.sensor_database, open_type="rb"), get_file_content(file_locations.sensor_checkin_database, open_type="rb"), get_file_content(file_locations.mqtt_subscriber_database, open_type="rb") ] return_zip = zip_files(return_names, return_files) return send_file(return_zip, attachment_filename=zip_name, as_attachment=True) except Exception as error: logger.primary_logger.error("* Download All Databases Zip: " + str(error)) return_zip = "Error Creating Zip on " + app_cached_variables.ip + " - " + app_cached_variables.hostname return send_file(return_zip + " - " + str(error), attachment_filename=zip_name + ".txt", as_attachment=True)
def _change_program_version(new_version): ks_version_file = get_file_content( original_source_dir + "operations_modules/software_version.py") control_version_file_content = get_file_content( original_source_dir + "extras/deb_package_files/DEBIAN/control") new_ks_version_file = "" for line in ks_version_file.split("\n"): if line.split("=")[0].strip() == "version": new_ks_version_file += f'version = "{new_version.get_version_string()}"\n' else: new_ks_version_file += f"{line}\n" new_ks_version_file = new_ks_version_file.strip() + "\n" write_file_to_disk( original_source_dir + "operations_modules/software_version.py", new_ks_version_file) new_control_version = "" for line in control_version_file_content.split("\n"): if line.split(":")[0].strip() == "Version": nv = f"Version: {new_version.major_version}.{new_version.feature_version}-{new_version.minor_version}\n" new_control_version += nv else: new_control_version += f"{line}\n" new_control_version = new_control_version.strip() + "\n" write_file_to_disk( original_source_dir + "extras/deb_package_files/DEBIAN/control", new_control_version)
def send_db_graph_emails(email_address_list): generate_plotly_graph(None, graph_config=app_config_access.email_db_graph_config) sleep(5) while server_plotly_graph_variables.graph_creation_in_progress: sleep(5) date_time = datetime.utcnow().strftime("%Y-%m-%d_%H:%M") filename = app_cached_variables.hostname + "_" + date_time + "_KS_Graph" message = get_new_email_message("Kootnet Sensor Graph - " + app_cached_variables.hostname) message.attach( MIMEText(_get_default_email_body_text("Plotly Graph"), "plain")) try: zipped_graph = zip_files([filename + ".html"], [ get_file_content(app_config_access.email_db_graph_config. plotly_graph_saved_location, open_type="rb") ]) payload = MIMEBase("application", "zip") payload.set_payload(zipped_graph.read()) encoders.encode_base64(payload) payload.add_header("Content-Disposition", "attachment", filename=filename + ".zip") message.attach(payload) except Exception as error: logger.network_logger.error("Graph Email did not send: " + str(error)) payload = MIMEText("\n\nError Generating Zip of Plotly Graph\n\n", "plain") message.attach(payload) for email_address in email_address_list: send_email(email_address, message)
def _zip_checkin_db_worker(): app_cached_variables.creating_zip_checkin_db = True sql_filename = _add_host_and_ip_to_filename("Checkin_Database", "sqlite") zip_content = get_file_content(file_locations.sensor_checkin_database, open_type="rb") _zip_db(file_locations.checkin_database_zipped, sql_filename, zip_content) app_cached_variables.creating_zip_checkin_db = False
def _enable_psm5003_serial(): logger.sensors_logger.debug("Enabling Serial for Pimoroni PSM5003") try: serial_disabled = True boot_config_lines = get_file_content("/boot/config.txt").split( "\n") new_config = "" for line in boot_config_lines: if line.strip() == "dtoverlay=pi3-miniuart-bt": serial_disabled = False new_config += line + "\n" if serial_disabled: logger.sensors_logger.info( "Serial not enabled for PSM5003 - Enabling") logger.primary_logger.warning( "You must reboot the System before the PSM5003 will function properly" ) os.system( "raspi-config nonint set_config_var enable_uart 1 /boot/config.txt" ) os.system("raspi-config nonint do_serial 1") time.sleep(0.5) new_config = new_config.strip() new_config += "\n\n# Kootnet Sensors Addition\ndtoverlay=pi3-miniuart-bt\n" write_file_to_disk("/boot/config.txt", new_config) except Exception as error: logger.sensors_logger.error( "Pimoroni PSM5003 Enable Serial - Failed: " + str(error))
def load_from_file(self): try: ip_list_content = get_file_content(self.ip_list_location).strip() ip_list = ip_list_content.split("\n") self.sensor_ip_dns1 = ip_list[0].split("=")[0].strip() self.sensor_ip_dns2 = ip_list[1].split("=")[0].strip() self.sensor_ip_dns3 = ip_list[2].split("=")[0].strip() self.sensor_ip_dns4 = ip_list[3].split("=")[0].strip() self.sensor_ip_dns5 = ip_list[4].split("=")[0].strip() self.sensor_ip_dns6 = ip_list[5].split("=")[0].strip() self.sensor_ip_dns7 = ip_list[6].split("=")[0].strip() self.sensor_ip_dns8 = ip_list[7].split("=")[0].strip() self.sensor_ip_dns9 = ip_list[8].split("=")[0].strip() self.sensor_ip_dns10 = ip_list[9].split("=")[0].strip() self.sensor_ip_dns11 = ip_list[10].split("=")[0].strip() self.sensor_ip_dns12 = ip_list[11].split("=")[0].strip() self.sensor_ip_dns13 = ip_list[12].split("=")[0].strip() self.sensor_ip_dns14 = ip_list[13].split("=")[0].strip() self.sensor_ip_dns15 = ip_list[14].split("=")[0].strip() self.sensor_ip_dns16 = ip_list[15].split("=")[0].strip() self.sensor_ip_dns17 = ip_list[16].split("=")[0].strip() self.sensor_ip_dns18 = ip_list[17].split("=")[0].strip() self.sensor_ip_dns19 = ip_list[18].split("=")[0].strip() self.sensor_ip_dns20 = ip_list[19].split("=")[0].strip() except Exception as error: logger.network_logger.warning("IP List: " + str(error)) self.save_list_to_file()
def charts_min_js_fun(): global charts_min_js charts_min_js_loc = file_locations.program_root_dir + "/http_server/extras/chart.min.js" if charts_min_js is None: charts_min_js = get_file_content(charts_min_js_loc) return_response = make_response(charts_min_js) return_response.headers["Cache-Control"] = "public, max-age=432000" return return_response
def jquery_min_js_fun(): global jquery_min_js jquery_min_js_loc = file_locations.program_root_dir + "/http_server/extras/jquery-3.6.0.min.js" if jquery_min_js is None: jquery_min_js = get_file_content(jquery_min_js_loc) return_response = make_response(jquery_min_js) return_response.headers["Cache-Control"] = "public, max-age=432000" return return_response
def _zip_mqtt_sub_db_worker(): app_cached_variables.creating_zip_mqtt_sub_db = True sql_filename = _add_host_and_ip_to_filename("MQTT_Subscriber_Database", "sqlite") zip_content = get_file_content(file_locations.mqtt_subscriber_database, open_type="rb") _zip_db(file_locations.mqtt_database_zipped, sql_filename, zip_content) app_cached_variables.creating_zip_mqtt_sub_db = False
def sensor_unit_help(): global help_index_page if help_index_page is None: help_index_page = get_file_content(documentation_root_dir + "/index.html") return_response = make_response(help_index_page) return_response.headers["Cache-Control"] = "public, max-age=432000" return return_response
def fav_icon_func(): global fav_icon_file_content fav_icon_loc = file_locations.program_root_dir + "/http_server/templates/ATPro_admin/assets/AT-pro-logo.png" if fav_icon_file_content is None: fav_icon_file_content = get_file_content(fav_icon_loc, open_type="rb") return_response = make_response( send_file(BytesIO(fav_icon_file_content), mimetype="image/jpeg")) return_response.headers["Cache-Control"] = "public, max-age=432000" return return_response
def upgrade_python_pip_modules(python_location=None): requirements_file_location = file_locations.program_root_dir + "/requirements.txt" hardware_requirements_location = file_locations.program_root_dir + "/requirements_hw_sensors.txt" all_python_modules_list = [] if app_cached_variables.pip_ready_for_upgrades and app_cached_variables.sensor_ready_for_upgrade: if os.path.isfile(file_locations.program_root_dir + "/requirements.txt"): requirements_text = get_file_content(requirements_file_location).strip() all_python_modules_list = requirements_text.split("\n") if app_cached_variables.running_with_root and running_on_pi(): if os.path.isfile(file_locations.program_root_dir + "/requirements_hw_sensors.txt"): requirements_text = get_file_content(hardware_requirements_location).strip() all_python_modules_list = all_python_modules_list + requirements_text.split("\n") app_cached_variables.pip_ready_for_upgrades = False if python_location is not None: _pip_upgrades_thread([all_python_modules_list, python_location]) else: thread_function(_pip_upgrades_thread, args=[all_python_modules_list, python_location]) else: logger.network_logger.warning("Unable to start Python Module Upgrades - already running")
def _get_zipped_logs(): try: return_names = [ app_cached_variables.hostname + "_" + os.path.basename(file_locations.primary_log), app_cached_variables.hostname + "_" + os.path.basename(file_locations.network_log), app_cached_variables.hostname + "_" + os.path.basename(file_locations.sensors_log) ] return_files = [ get_file_content(file_locations.primary_log, open_type="rb"), get_file_content(file_locations.network_log, open_type="rb"), get_file_content(file_locations.sensors_log, open_type="rb") ] return zip_files(return_names, return_files) except Exception as error: logger.primary_logger.error("* Unable to Zip Logs: " + str(error)) return None
def _add_pip_modules_to_list(requirements_locations_list): modules_list = [] for requirements_location in requirements_locations_list: if os.path.isfile(requirements_location): requirements_text = get_file_content(requirements_location).strip() for requirement in requirements_text.split("\n"): requirement = requirement.strip() if requirement[0] != "#": modules_list.append(requirement) return modules_list
def _init_config_variables(self): """ Sets configuration settings from file, saves default if missing. """ try: if self.check_config_file_exists(): self.set_config_with_str(get_file_content(self.config_file_location)) except Exception as error: log_msg = "Error setting variables from " log_msg2 = "Saving Default Configuration for " logger.primary_logger.warning(log_msg + str(self.config_file_location) + " - " + str(error)) logger.primary_logger.warning(log_msg2 + str(self.config_file_location)) self.save_config_to_file()
def upgrade_config_load_and_save(configuration_creation_class, upgrade_msg=True, new_location=None): """ Creates configuration class, loads the config and saves it without logging. """ new_config_instance = configuration_creation_class(load_from_file=False) if new_location is not None: new_config_instance.config_file_location = new_location try: old_config_text = get_file_content(new_config_instance.config_file_location) new_config_instance.set_config_with_str(old_config_text) new_config_instance.save_config_to_file() if upgrade_msg: logger.primary_logger.info(" ** Configuration " + new_config_instance.config_file_location + " Upgraded") except Exception as error: log_msg = " ***** Configuration " + new_config_instance.config_file_location logger.primary_logger.error(log_msg + " Upgrade Failed: " + str(error))
def _zip_and_delete_database(database_location, db_save_name): """ Creates a zip of linked database in the database backup folder then deletes the original database. """ filename_start = app_cached_variables.ip.split(".")[-1] + app_cached_variables.hostname + "_" sql_filename = filename_start + db_save_name + ".sqlite" zip_filename = filename_start + str(datetime.utcnow().strftime("%Y-%m-%d_%H_%M_%S")) + db_save_name + ".zip" zip_full_path = file_locations.database_backup_folder + "/" + zip_filename try: zip_content = get_file_content(database_location, open_type="rb") zip_files([sql_filename], [zip_content], save_type="save_to_disk", file_location=zip_full_path) os.remove(database_location) 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 return True except Exception as error: print(str(error)) 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 return False
def upgrade_beta_34_x_to_35_x(): reset_live_graph_config(log_reset=False) reset_database_graph_config(log_reset=False) reset_upgrade_config(log_reset=False) reset_checkin_config(log_reset=False) reset_urls_config(log_reset=False) reset_email_reports_config(log_reset=False) reset_email_db_graphs_config(log_reset=False) reset_flask_login_credentials() reset_email_config() sensor_offsets_config = CreateSensorOffsetsConfiguration( load_from_file=False) new_primary_config = CreatePrimaryConfiguration(load_from_file=False) try: old_primary_config_string = get_file_content( file_locations.primary_config).strip() old_primary_config_list = old_primary_config_string.split("\n")[1:] new_primary_config.web_portal_port = int( old_primary_config_list[0].split("=")[0].strip()) new_primary_config.enable_debug_logging = int( old_primary_config_list[1].split("=")[0].strip()) sensor_offsets_config.enable_temp_offset = int( old_primary_config_list[2].split("=")[0].strip()) sensor_offsets_config.temperature_offset = float( old_primary_config_list[3].split("=")[0].strip()) sensor_offsets_config.enable_temperature_comp_factor = int( old_primary_config_list[4].split("=")[0].strip()) sensor_offsets_config.temperature_comp_factor = float( old_primary_config_list[5].split("=")[0].strip()) new_primary_config.utc0_hour_offset = float( old_primary_config_list[6].split("=")[0].strip()) new_primary_config.update_configuration_settings_list() new_primary_config.save_config_to_file() sensor_offsets_config.update_configuration_settings_list() sensor_offsets_config.save_config_to_file() successful_upgrade_message("Primary & Sensor Offsets") except Exception as error: logger.primary_logger.warning( "Primary & Sensor Offsets Config Upgrade: " + str(error)) new_primary_config.save_config_to_file() sensor_offsets_config.save_config_to_file()
def _check_sensor_id(): """ Checks for Sensor Checkin ID file, if missing, creates one. The Sensor ID is Randomly Generated and used to track Software Usage and Online History of Sensors. """ try: if not os.path.isfile(file_locations.sensor_id): random_id = ''.join([ random.choice(string.ascii_letters + string.digits) for _ in range(32) ]) write_file_to_disk(file_locations.sensor_id, random_id) else: random_id = get_file_content(file_locations.sensor_id).strip() except Exception as error: logger.primary_logger.error("Problem Creating Sensor ID: " + str(error)) random_id = "Error" app_cached_variables.tmp_sensor_id = "KS" + random_id
def html_atpro_sensor_settings_mqtt_broker(): if request.method == "POST": app_config_access.mqtt_broker_config.update_with_html_request(request) app_config_access.mqtt_broker_config.save_config_to_file() if app_config_access.mqtt_broker_config.enable_mqtt_broker: if check_mqtt_broker_server_running(): return_text = "MQTT Broker Service Re-Started" restart_mqtt_broker_server() else: return_text = "MQTT Broker Service Starting" start_mqtt_broker_server() else: return_text = "MQTT Broker Service Stopped" stop_mqtt_broker_server() return get_message_page("MQTT Broker Settings Updated", return_text, page_url="sensor-settings") mosquitto_configuration = "listener 1883\nallow_anonymous true" if os.path.isfile(file_locations.mosquitto_configuration): mosquitto_configuration = get_file_content(file_locations.mosquitto_configuration) return render_template( "ATPro_admin/page_templates/settings/settings-mqtt-broker.html", BrokerServerChecked=get_html_checkbox_state(check_mqtt_broker_server_running()), BrokerMosquittoConfig=mosquitto_configuration )
def html_request_to_config_wifi(html_request): """ Takes the provided HTML wireless settings and creates a new WPA Supplicant string and returns it. """ logger.network_logger.debug( "Starting HTML WiFi Configuration Update Check") if html_request.form.get("ssid1") is not None: wifi_template = get_file_content( file_locations.wifi_config_file_template) wifi_country_code = "CA" if len(html_request.form.get("country_code")) == 2: wifi_country_code = html_request.form.get("country_code").upper() wifi_ssid1 = html_request.form.get("ssid1") wifi_security_type1 = html_request.form.get("wifi_security1") wifi_psk1 = html_request.form.get("wifi_key1") if wifi_security_type1 == "wireless_wpa": wifi_security_type1 = wifi_type_secured if wifi_psk1 is not "": wifi_template = wifi_template.replace( "{{ WirelessPSK1 }}", 'psk="' + wifi_psk1 + '"') else: wifi_psk1 = app_cached_variables.wifi_psk wifi_template = wifi_template.replace( "{{ WirelessPSK1 }}", 'psk="' + wifi_psk1 + '"') else: wifi_security_type1 = "None" wifi_template = wifi_template.replace("{{ WirelessPSK1 }}", "") wifi_template = wifi_template.replace("{{ WirelessCountryCode }}", wifi_country_code) wifi_template = wifi_template.replace("{{ WirelessSSID1 }}", wifi_ssid1) wifi_template = wifi_template.replace("{{ WirelessKeyMgmt1 }}", wifi_security_type1) return wifi_template return ""
<title>Kootnet Sensors</title> <meta http-equiv="X-UA-Compatible" content="IE=edge"> </head> <body style='background-color: black;'> <h2 style='text-decoration: underline; color: red;'>Report Not Found</h3> <p style='color: white;'>No report found, please generated the report first</p> </body> </html> """ html_combo_report = default_report html_system_report = default_report html_config_report = default_report html_readings_report = default_report html_latency_report = default_report html_pure_css = get_file_content(html_report_pure_css).strip() html_pure_css_menu = get_file_content(html_pure_css_menu).strip() html_report_css = get_file_content(html_report_css).strip() html_report_js = get_file_content(html_report_js).strip() html_report_combo = get_file_content(file_locations.html_combo_report).strip() html_report_combo = html_report_combo.replace("{{ ReportCSSStyles }}", html_report_css) html_report_combo = html_report_combo.replace("{{ PureCSS }}", html_pure_css) html_report_combo = html_report_combo.replace("{{ PureCSSHorizontalMenu }}", html_pure_css_menu) html_report_start = get_file_content(html_report_all_start).strip() html_report_start = html_report_start.replace("{{ ReportCSSStyles }}", html_report_css) html_report_end = get_file_content(html_report_all_end).strip()
from operations_modules.app_generic_disk import get_file_content from operations_modules.sqlite_database import sql_execute_get_data, write_to_sql_database, get_clean_sql_table_name, \ get_sql_element, get_sqlite_tables_in_list, get_one_db_entry from configuration_modules import app_config_access from http_server.server_http_auth import auth from http_server.flask_blueprints.atpro.atpro_generic import get_message_page from http_server.flask_blueprints.sensor_checkin_server import check_sensor_checkin_columns html_atpro_sensor_check_ins_routes = Blueprint( "html_atpro_sensor_check_ins_routes", __name__) db_loc = file_locations.sensor_checkin_database db_v = app_cached_variables.database_variables checkin_temp_location = file_locations.program_root_dir + "/http_server/templates/ATPro_admin/page_templates/" checkin_temp_location += "sensor_checkins/sensor-checkin-table-entry-template.html" checkin_table_entry_template = get_file_content(checkin_temp_location).strip() updating_checkin_info_html_msg = "<h3><strong><a style='color: red;'>Updating Information, please wait ...</a></strong></h3>" checkin_table_failed = "<h3><strong><a style='color: red;'>Sensor Checkins List Generation Failed</a></strong></h3>" @html_atpro_sensor_check_ins_routes.route("/atpro/sensor-checkin-view") @auth.login_required def html_atpro_sensor_checkin_main_view(): sensor_count = len(get_sqlite_tables_in_list(db_loc)) app_cached_variables.checkins_db_sensors_count = sensor_count if os.path.isfile(db_loc): db_size_mb = get_file_size(db_loc, round_to=3) else: db_size_mb = 0.0 enabled_text = "<span style='color: red;'>Disabled</span>"
from operations_modules.app_generic_functions import get_file_size, adjust_datetime, thread_function from operations_modules.app_generic_disk import get_file_content from operations_modules.sqlite_database import get_sqlite_tables_in_list, get_clean_sql_table_name, get_one_db_entry from configuration_modules import app_config_access from sensor_modules import sensor_access from http_server.server_http_auth import auth from http_server.flask_blueprints.atpro.atpro_generic import get_html_atpro_index html_atpro_mqtt_subscriber_routes = Blueprint( "html_atpro_mqtt_subscriber_routes", __name__) db_loc = file_locations.mqtt_subscriber_database db_v = app_cached_variables.database_variables mqtt_sub_tet_location = file_locations.program_root_dir + "/http_server/templates/ATPro_admin/page_templates/" mqtt_sub_tet_location += "mqtt-subscriber-table-entry-template.html" mqtt_sub_table_entry_template = get_file_content(mqtt_sub_tet_location).strip() generating_mqtt_table_html = "<h3><strong><a style='color: red;'>Generating Table, please wait ...</a></strong></h3>" @html_atpro_mqtt_subscriber_routes.route( "/atpro/mqtt-subscriber-view-data-stream") @auth.login_required def html_atpro_mqtt_subscriber_data_stream_view(): mqtt_subscriber_log = file_locations.mqtt_subscriber_log max_entries = app_config_access.mqtt_subscriber_config.mqtt_page_view_max_entries mqtt_subscriber_log_content = logger.get_sensor_log( mqtt_subscriber_log, max_lines=max_entries).strip() if mqtt_subscriber_log_content == "": mqtt_subscriber_log_content = _mqtt_sub_entry_to_html("") else: new_return = ""
def atpro_raw_config_urls(url_path): if url_path == "config-software-ver": config_name = "<i class='fas fa-code-branch'></i> Software Versions" module_version_text = "This will be removed\n" + \ kootnet_version + "=Kootnet Sensors\n" + \ python_version_str + "=Python\n" + \ str(flask_version) + "=Flask\n" + \ str(gevent_version) + "=Gevent\n" + \ str(greenlet_version) + "=Greenlet\n" + \ str(requests_version) + "=Requests\n" + \ str(plotly_version) + "=Plotly Graphing\n" return _config_to_html_view(config_name, "NA", module_version_text) elif url_path == "config-main": config_name = "<i class='fas fa-clipboard-check'></i> Main Configuration" config_content = app_config_access.primary_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.primary_config, config_content) elif url_path == "config-urls": config_name = "<i class='fas fa-link'></i> URLs Configuration" config_content = app_config_access.urls_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.urls_configuration, config_content) elif url_path == "config-upgrades": config_name = "<i class='fas fa-arrow-circle-up'></i> Upgrades Configuration" config_content = remove_line_from_text( app_config_access.upgrades_config.get_config_as_str(), [3, 4]) return _config_to_html_view(config_name, file_locations.upgrades_config, config_content) elif url_path == "config-is": config_name = "<i class='fas fa-microchip'></i> Installed Sensors" config_content = app_config_access.installed_sensors.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.installed_sensors_config, config_content) elif url_path == "config-sensor-offsets": config_name = "<i class='fas fa-sliders-h'></i> Sensor Offsets" config_content = app_config_access.sensor_offsets.get_config_as_str() return _config_to_html_view(config_name, file_locations.sensor_offsets_config, config_content) elif url_path == "config-display": config_name = "<i class='fas fa-tv'></i> Display" config_content = app_config_access.display_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.display_config, config_content) elif url_path == "config-cs": config_name = "<i class='fas fa-satellite-dish'></i> Sensor Checkins" config_content = app_config_access.checkin_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.checkin_configuration, config_content) elif url_path == "config-ir": config_name = "<i class='fas fa-database'></i> Interval Recording" config_content = app_config_access.interval_recording_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.interval_config, config_content) elif url_path == "config-high-low": config_name = "<i class='fas fa-database'></i> High/Low Trigger Recording" config_content = app_config_access.trigger_high_low.get_config_as_str() return _config_to_html_view(config_name, file_locations.trigger_high_low_config, config_content) elif url_path == "config-variance": config_name = "<i class='fas fa-database'></i> Variance Trigger Recording" config_content = app_config_access.trigger_variances.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.trigger_variances_config, config_content) elif url_path == "config-reports-email": config_name = "<i class='far fa-envelope'></i> Email Reports" config_content = app_config_access.email_reports_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.email_reports_config, config_content) elif url_path == "config-db-graphs-email": config_name = "<i class='far fa-envelope'></i> Email Database Graphs" config_content = app_config_access.email_db_graph_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.email_db_graph_config, config_content) elif url_path == "config-email": config_name = "<i class='far fa-envelope'></i> Email" config_content = remove_line_from_text( app_config_access.email_config.get_config_as_str(), [5, 6]) return _config_to_html_view(config_name, file_locations.email_config, config_content) elif url_path == "config-mqtt-b": config_name = "<i class='fas fa-broadcast-tower'></i> MQTT Broker" config_content = app_config_access.mqtt_broker_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.mqtt_broker_config, config_content) elif url_path == "config-mqtt-p": config_name = "<i class='fas fa-broadcast-tower'></i> MQTT Publisher" config_content = remove_line_from_text( app_config_access.mqtt_publisher_config.get_config_as_str(), [5, 6]) return _config_to_html_view(config_name, file_locations.mqtt_publisher_config, config_content) elif url_path == "config-mqtt-s": config_name = "<i class='fas fa-broadcast-tower'></i> MQTT Subscriber" config_content = remove_line_from_text( app_config_access.mqtt_subscriber_config.get_config_as_str(), [5, 6]) return _config_to_html_view(config_name, file_locations.mqtt_subscriber_config, config_content) elif url_path == "config-osm": config_name = "<i class='fas fa-plus-circle'></i> Open Sense Map" config_content = remove_line_from_text( app_config_access.open_sense_map_config.get_config_as_str(), [2]) return _config_to_html_view(config_name, file_locations.osm_config, config_content) elif url_path == "config-wu": config_name = "<i class='fas fa-plus-circle'></i> Weather Underground" config_content = remove_line_from_text( app_config_access.weather_underground_config.get_config_as_str(), [4, 5]) return _config_to_html_view(config_name, file_locations.weather_underground_config, config_content) elif url_path == "config-luftdaten": config_name = "<i class='fas fa-plus-circle'></i> Luftdaten" config_content = app_config_access.luftdaten_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.luftdaten_config, config_content) elif url_path == "config-networking": config_name = "<i class='fas fa-network-wired'></i> Networking (dhcpcd.conf)" if running_with_root and not app_config_access.primary_config.demo_mode: config_content = get_file_content( file_locations.dhcpcd_config_file) else: config_content = "Access Denied" if app_config_access.primary_config.demo_mode: config_content = config_content + " - Demo Mode Enabled" return _config_to_html_view(config_name, file_locations.dhcpcd_config_file, config_content, split_by_line=False) elif url_path == "config-wifi": config_name = "<i class='fas fa-wifi'></i> WiFi" if running_with_root and not app_config_access.primary_config.demo_mode: config_content = get_file_content(file_locations.wifi_config_file) else: config_content = "Access Denied" if app_config_access.primary_config.demo_mode: config_content = config_content + " - Demo Mode Enabled" return _config_to_html_view(config_name, file_locations.wifi_config_file, config_content, split_by_line=False) elif url_path == "config-sc": config_name = "<i class='fas fa-project-diagram'></i> Remote Management Configuration" config_content = app_config_access.sensor_control_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.html_sensor_control_config, config_content) elif url_path == "config-live-graph": config_name = "<i class='fas fa-chart-line'></i> Live Graphing" config_content = app_config_access.live_graphs_config.get_config_as_str( ) return _config_to_html_view(config_name, file_locations.live_graphs_config, config_content) elif url_path == "config-db-graph": config_name = "<i class='fas fa-chart-bar'></i> Database Graphing - Plotly" config_content = app_config_access.db_graphs_config.get_config_as_str() return _config_to_html_view(config_name, file_locations.db_graphs_config, config_content) return "<h3>Error</h3>"
def update_cached_variables(): """ Updates app_cached_variables.py variables. """ global first_run if first_run: first_run = False thread_function(_update_ks_info_table_data) demo_mode = app_config_access.primary_config.demo_mode if not app_cached_variables.running_with_root: click_msg = "Without root access, the following functions will be unavailable - " click_msg += "Hardware Sensors, Network Configurations, Upgrade & Power commands" icon = "fas fa-exclamation-triangle" notification_short_msg = "Warning: Not running with root<br>Click Here for more information" atpro_notifications.add_custom_message(notification_short_msg, click_msg=click_msg, icon=icon) if demo_mode: click_msg = "In Demo mode, there are no login prompts and the following functions will be unavailable - " click_msg += "Network Configurations, SSL, Change Login, Upgrade & Power commands" notification_short_msg = "Info: Running in Demo mode<br>Click Here for more information" atpro_notifications.add_custom_message(notification_short_msg, click_msg=click_msg) if default_http_flask_user == app_cached_variables.http_flask_user and not demo_mode: if verify_password_to_hash(default_http_flask_password): atpro_notifications.manage_default_login_detected() if app_cached_variables.current_platform == "Linux": try: os_release_content_lines = get_file_content( "/etc/os-release").split("\n") os_release_name = "" for line in os_release_content_lines: name_and_value = line.split("=") if name_and_value[0].strip() == "PRETTY_NAME": os_release_name = name_and_value[1].strip()[1:-1] app_cached_variables.operating_system_name = str(os_release_name) except Exception as error: logger.sensors_logger.error("Error caching OS Name: " + str(error)) app_cached_variables.operating_system_name = "NA" if app_cached_variables.operating_system_name[:8] == "Raspbian": try: if app_cached_variables.running_with_root: wifi_config_lines = get_file_content( file_locations.wifi_config_file).split("\n") else: wifi_config_lines = "" app_cached_variables.wifi_country_code = network_wifi.get_wifi_country_code( wifi_config_lines) app_cached_variables.wifi_ssid = network_wifi.get_wifi_ssid( wifi_config_lines) app_cached_variables.wifi_security_type = network_wifi.get_wifi_security_type( wifi_config_lines) app_cached_variables.wifi_psk = network_wifi.get_wifi_psk( wifi_config_lines) except Exception as error: logger.primary_logger.warning( "Error checking WiFi configuration: " + str(error)) try: dhcpcd_config_lines = get_file_content( file_locations.dhcpcd_config_file).split("\n") if not network_ip.check_for_dhcp(dhcpcd_config_lines): app_cached_variables.ip = network_ip.get_dhcpcd_ip( dhcpcd_config_lines) app_cached_variables.ip_subnet = network_ip.get_subnet( dhcpcd_config_lines) app_cached_variables.gateway = network_ip.get_gateway( dhcpcd_config_lines) app_cached_variables.dns1 = network_ip.get_dns( dhcpcd_config_lines) app_cached_variables.dns2 = network_ip.get_dns( dhcpcd_config_lines, dns_server=1) except Exception as error: logger.primary_logger.warning("Error checking dhcpcd.conf: " + str(error)) try: app_cached_variables.total_ram_memory = round( psutil.virtual_memory().total / 1024 / 1024 / 1024, 3) except Exception as error: logger.primary_logger.warning("Error caching total RAM: " + str(error)) try: app_cached_variables.total_disk_space = round( psutil.disk_usage("/").total / 1024 / 1024 / 1024, 2) except Exception as error: logger.primary_logger.warning("Error caching total Disk Space: " + str(error)) last_updated = "" if not os.path.isfile(file_locations.program_last_updated): logger.sensors_logger.debug( "Previous version file not found - Creating version file") write_file_to_disk(file_locations.program_last_updated, "No Update Detected") last_updated_file = get_file_content(file_locations.program_last_updated) last_updated_lines = last_updated_file.split("\n") for line in last_updated_lines: last_updated += str(line) app_cached_variables.program_last_updated = last_updated.strip() app_cached_variables.zipped_db_backup_list = get_names_list_from_dir( file_locations.database_backup_folder) app_cached_variables.uploaded_databases_list = get_names_list_from_dir( file_locations.uploaded_databases_folder) _update_cached_sensor_reboot_count() _update_cached_note_variables() _update_cached_ip() _update_cached_hostname()