cleanup old files

src/StorageLeaf.py

-import os
-
-from TheCodeLabs_BaseUtils.DefaultLogger import DefaultLogger
-from TheCodeLabs_FlaskUtils.FlaskBaseApp import FlaskBaseApp
-
-from blueprints import Sensors, Measurements
-from logic import Constants
-from logic.BackupService import BackupService
-from logic.DiscoveryService import DiscoveryService
-
-LOGGER = DefaultLogger().create_logger_if_not_exists(Constants.APP_NAME)
-
-
-class StorageLeaf(FlaskBaseApp):
-    def __init__(self, appName: str):
-        super().__init__(appName, os.path.dirname(__file__), LOGGER, serveRobotsTxt=False)
-        databaseSettings = self._settings['database']
-        self._backupService = BackupService(databaseSettings['databasePath'], **databaseSettings['backup'])
-
-        discoverySettings = self._settings['discovery']
-        discoverySettings['apiPort'] = self._settings['server']['port']
-        self._discoveryService = DiscoveryService(**discoverySettings)
-        self._discoveryService.start()
-
-    def _register_blueprints(self, app):
-        app.register_blueprint(Sensors.construct_blueprint(self._settings, self._backupService))
-        app.register_blueprint(Measurements.construct_blueprint(self._settings, self._backupService))
-        return app
-
-
-if __name__ == '__main__':
-    website = StorageLeaf(Constants.APP_NAME)
-    website.start_server()

src/blueprints/Measurements.py

-from typing import Dict
-
-from flask import Blueprint, jsonify, request
-
-from logic.AuthenticationWrapper import require_api_key
-from logic.BackupService import BackupService
-from logic.Parameters import DeviceParameters, SensorParameters, MeasurementParameters
-from logic.RequestValidator import RequestValidator, ValidationError
-from logic.database.Database import Database
-
-
-def construct_blueprint(settings: Dict, backupService: BackupService):
-    measurements = Blueprint('measurements', __name__)
-
-    @measurements.route('/measurements/minMax', methods=['GET'])
-    def get_min_and_max_for_sensor_ids():
-        if 'sensorIds' not in request.args:
-            return jsonify({'message': 'Parameter "sensorIds" missing'}), 400
-
-        if 'startDateTime' not in request.args:
-            return jsonify({'message': 'Parameter "startDateTime" missing'}), 400
-
-        if 'endDateTime' not in request.args:
-            return jsonify({'message': 'Parameter "endDateTime" missing'}), 400
-
-        sensorIds = request.args.get('sensorIds').split(',')
-        startDateTime = request.args.get('startDateTime')
-        endDateTime = request.args.get('endDateTime')
-
-        database = Database(settings['database']['databasePath'], backupService)
-
-        values = []
-        for sensorId in sensorIds:
-            sensorId = int(sensorId)
-            measurementsForSensor = database.measurementAccess.get_all_measurements_for_sensor(sensorId,
-                                                                                               startDateTime,
-                                                                                               endDateTime)
-            for measurement in measurementsForSensor:
-                values.append(float(measurement['value']))
-
-        if values:
-            return jsonify({
-                'min': min(values),
-                'max': max(values)
-            })
-
-        return jsonify({
-            'min': None,
-            'max': None
-        })
-
-    @measurements.route('/measurements', methods=['POST'])
-    @require_api_key(password=settings['api']['key'])
-    def add_multiple_measurements():
-        try:
-            parameters = RequestValidator.validate(request, DeviceParameters.get_values())
-            database = Database(settings['database']['databasePath'], backupService)
-
-            deviceName = parameters[DeviceParameters.DEVICE.value]
-            if not database.deviceAccess.get_device_by_name(deviceName):
-                database.deviceAccess.add_device(deviceName)
-            device = database.deviceAccess.get_device_by_name(deviceName)
-
-            sensors = parameters[DeviceParameters.SENSORS.value]
-            for sensor in sensors:
-                sensorParams = RequestValidator.validate_parameters(sensor,
-                                                                    [SensorParameters.NAME.value,
-                                                                     SensorParameters.TYPE.value,
-                                                                     SensorParameters.VALUE.value],
-                                                                    f'sensor "{sensor}"')
-                sensor = __add_sensor_if_not_exists(database, int(device['id']), sensorParams)
-                database.measurementAccess.add_measurement(int(sensor['id']),
-                                                           sensorParams[SensorParameters.VALUE.value])
-        except ValidationError as e:
-            return e.response, 400
-
-        return jsonify({'success': True})
-
-    def __add_sensor_if_not_exists(database: Database, deviceID: int, sensorParams: Dict) -> Dict[str, str]:
-        sensorName = sensorParams[SensorParameters.NAME.value]
-        sensorType = sensorParams[SensorParameters.TYPE.value]
-        sensor = database.sensorAccess.get_sensor_by_name_and_device_id(deviceID, sensorName)
-        if sensor:
-            return sensor
-
-        database.sensorAccess.add_sensor(deviceID, sensorName, sensorType)
-        return database.sensorAccess.get_sensor_by_name_and_device_id(deviceID, sensorName)
-
-    return measurements