X-Git-Url: https://git.toastfreeware.priv.at/chrisu/seepark.git/blobdiff_plain/3dc2b087a5e3cb7952392cb00a4469508af6e019..07f6fd2c6041d6203380a60771ce1cffdc2f68a7:/web/seepark_web.py?ds=sidebyside diff --git a/web/seepark_web.py b/web/seepark_web.py index 5263174..e8b9da1 100644 --- a/web/seepark_web.py +++ b/web/seepark_web.py @@ -1,18 +1,186 @@ -from flask import Flask, render_template, jsonify from random import uniform +import datetime import time import configparser import os -app = Flask(__name__) +import sys +from collections import defaultdict +from flask import Flask, render_template, jsonify, request +import flask.json +from flask_sqlalchemy import SQLAlchemy, inspect + + +app_path = os.path.dirname(os.path.realpath(__file__)) +lib_path = os.path.join(app_path, '..') +sys.path.append(lib_path) +from seeparklib.openweathermap import openweathermap_json, OpenWeatherMapError + + +# https://stackoverflow.com/a/37350445 +def sqlalchemy_model_to_dict(model): + return {c.key: getattr(model, c.key) + for c in inspect(model).mapper.column_attrs} + + +class JSONEncoder(flask.json.JSONEncoder): + def default(self, object): + if isinstance(object, datetime.datetime): + return object.isoformat() + elif isinstance(object, db.Model): + return sqlalchemy_model_to_dict(object) + return super().default(object) + + +def parse_datetime(date_str): + return datetime.datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S') + + +def get_sqlalchemy_database_uri(config): + user = config.get('database', 'user') + pwd = config.get('database', 'password') + host = config.get('database', 'hostname') + db = config.get('database', 'database') + return 'mysql+mysqldb://{}:{}@{}/{}'.format(user, pwd, host, db) + config = configparser.ConfigParser() config.read(os.environ['SEEPARKINI']) -apikey = config.get('openweathermap', 'apikey'); +apikey = config.get('openweathermap', 'apikey') +cityid = config.get('openweathermap', 'cityid') +mainsensor = config.get('temperature', 'mainsensor') + +app = Flask(__name__) +app.json_encoder = JSONEncoder +app.config['SQLALCHEMY_DATABASE_URI'] = get_sqlalchemy_database_uri(config) +app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False +db = SQLAlchemy(app) +db.reflect(app=app) + + +class Sensors(db.Model): + __tablename__ = 'sensors' + + +def select_sensordata(sensor_id, sensor_type, begin, end, mode): + query = Sensors.query + if sensor_id is not None: + query = query.filter(Sensors.sensor_id == sensor_id) + if sensor_type is not None: + query = query.filter(Sensors.value_type == sensor_type) + if begin is not None: + query = query.filter(Sensors.timestamp >= begin) + if end is not None: + query = query.filter(Sensors.timestamp <= end) + if mode == 'consolidated' and begin is None and end is None: + # copied from munin/master/_bin/munin-cgi-graph.in + # interval in seconds for data points + resolutions = dict( + day = 300, + week = 1800, + month = 7200, + year = 86400, + ) + duration = (end - begin).total_seconds() + day = 60 * 60 * 24 + if duration < day: + resolution = resolutions['day'] + elif duration < 7 * day: + resolution = resolutions['week'] + elif duration < 31 * day: + resolution = resolutions['month'] + else: + resolution = resolutions['year'] + # TODO: filter out samples from 'result' + # something like + # select mean(temperature) from sensors where ... group by mod(timestamp, resolution) + # func.avg(...) + # + # from https://stackoverflow.com/questions/4342370/grouping-into-interval-of-5-minutes-within-a-time-range + # SELECT + # timestamp, -- not sure about that + # name, + # count(b.name) + # FROM time a, id + # WHERE … + # GROUP BY + # UNIX_TIMESTAMP(timestamp) DIV 300, name + return query.all() + + +def convert_to_c3(result): + c3result = defaultdict(list) + for row in result: + c3result[row.sensor_id].append(row.value) + dt = row.timestamp.strftime('%Y-%m-%d %H:%M:%S') + c3result[row.sensor_id + '_x'].append(dt) + return c3result + + +def sensordata(sensor_id=None, sensor_type=None): + begin = request.args.get('begin', None, parse_datetime) + end = request.args.get('end', None, parse_datetime) + mode = request.args.get('mode', 'full') + format = request.args.get('format', 'default') + + result = select_sensordata(sensor_id, sensor_type, begin, end, mode) + + if format == 'c3': + return convert_to_c3(result) + return result + + +def currentairtemperature(apikey, cityid): + """Retruns the tuple temperature, datetime (as float, datetime) in case of success, otherwise None, None.""" + try: + url, weatherdata = openweathermap_json(apikey, cityid) + return weatherdata['main']['temp'], datetime.datetime.fromtimestamp(weatherdata['dt']) + except OpenWeatherMapError: + return None, None + + +def currentwatertemperature(sensorid): + result = Sensors.query.filter_by(sensor_id=sensorid).order_by(Sensors.timestamp.desc()).first() + return result.value, result.timestamp + + +@app.route('/api//sensors/') +def sensors(version): + """List all sensors found in the database""" + result = db.session.query(Sensors.sensor_id, Sensors.sensor_name, Sensors.value_type).distinct().all() + return jsonify(result) + + +@app.route('/api//sensor/id/') +def sensorid(version, sensor_id): + """Return all data for a specific sensor + + URL parameters: + begin=, optional, format like "2018-05-19T21:07:53" + end=, optional, format like "2018-05-19T21:07:53" + mode=, optional. return all rows (default) or with lower resolution (for charts) + format=, optional. return result as returned by sqlalchemy (default) or formatted for c3.js + """ + result = sensordata(sensor_id=sensor_id) + return jsonify(result) + + +@app.route('/api//sensor/type/') +def sensortype(version, sensor_type): + """Return all data for a specific sensor type + + URL parameters: + begin=, optional, format like "2018-05-19T21:07:53" + end=, optional, format like "2018-05-19T21:07:53" + mode=, optional. return all rows (default) or with lower resolution (for charts) + format=, optional. return result as returned by sqlalchemy (default) or formatted for c3.js + """ + result = sensordata(sensor_type=sensor_type) + return jsonify(result) + @app.route('/data/', defaults={'timespan': 1}) @app.route("/data/", methods=['GET']) def data(timespan): - granularity = 5 * timespan # (every) minute(s) per day samples = 60/granularity * 24 * timespan # per hour over whole timespan s4m = [] @@ -42,5 +210,14 @@ def data(timespan): @app.route("/") def index(): - return render_template('seepark_web.html', apikey=apikey) + airvalue, airtime = currentairtemperature(apikey, cityid) + watervalue, watertime = currentwatertemperature(mainsensor) + return render_template( + 'seepark_web.html', + apikey=apikey, + watervalue=watervalue, + watertime=watertime, + airvalue=airvalue, + airtime=airtime, + )