def test__one_by_one_import_all():
mock_measurement = Measurement()
mock_measurement.save = MagicMock(return_value=1)
measurements = [mock_measurement, mock_measurement]
inserted_count = Importer._one_by_one_import_all(measurements)
assert inserted_count == 2
def deleteMeasurement():
if not current_user.isAdmin():
flash(constants.NOT_ALLOWED, 'danger')
else:
measurementid = unicode(request.form['measurementid'])
Measurement.delete(Measurement.get(measurementid))
flash(constants.MEASUREMENT_DELETE_SUCCESS, 'success')
return redirect(url_for('manageMeasurements'))
def manageMeasurements():
if request.method == 'GET':
measurements = Measurement.getAll()
users = {}
for user in User.getAll():
users[user.id] = user.username
return render_template('measurements.html', measurements=measurements, users=users)
elif request.method == 'POST':
month = request.form['month']
day = request.form['day']
year = request.form['year']
hour = request.form['hour']
minute = request.form['minute']
second = request.form['second']
ampm = request.form['ampm']
if ampm == 'am' and hour == '12':
hour = '00'
elif ampm == 'pm' and hour != '12':
hour = str(int(hour) + 12)
try:
t = datetime.strptime(' '.join([month, day, year, hour, minute, second]), '%m %d %Y %H %M %S')
except ValueError:
flash(constants.DATE_OUT_OF_RANGE, 'danger')
return redirect(url_for('manageMeasurements'))
# t = request.form['time']
# try:
# t = datetime.strptime(t, '%Y-%m-%dT%H:%M:%S')
# except ValueError:
# try:
# t = datetime.strptime(t, '%Y-%m-%dT%H:%M')
# except ValueError:
# flash(constants.INVALID_DATE, 'danger')
# return redirect(url_for('manageMeasurements'))
ph = float(request.form['ph'])
do = float(request.form['do'])
ec = float(request.form['ec'])
temp = float(request.form['temp'])
try:
if not (0 <= ph <=14):
raise ValueError(constants.INVALID_PH)
if not (0 <= do <= 36):
raise ValueError(constants.INVALID_DO)
if not (0 <= ec):
raise ValueError(constants.INVALID_EC)
except ValueError as e:
flash(e.args[0], 'danger')
return redirect(url_for('manageMeasurements'))
measurement = Measurement.get(t)
if measurement:
flash(constants.TIME_TAKEN, 'danger')
else:
Measurement.create(Measurement(current_user.id, t, ph, do, ec, temp))
flash(constants.MEASUREMENT_CREATE_SUCCESS, 'success')
return redirect(url_for('manageMeasurements'))
def meas_add():
form = MeasForm(request.form, csrf_enabled=False)
if request.method == 'POST' and form.validate():
meas = Measurement(sys=form.sys.data,
dia=form.dia.data,
pulse=form.pulse.data)
meas.put()
return redirect(url_for('meas_add'))
return render_template('meas_form.html', form=form)
def meas_add():
form = MeasForm(request.form, csrf_enabled=False)
if request.method == 'POST' and form.validate():
meas = Measurement(sys=form.sys.data,
dia=form.dia.data,
pulse=form.pulse.data)
meas.put()
return redirect(url_for('meas_add'))
return render_template('meas_form.html', form=form)
def processRows(reader, filename): badSyntax = [] timeTaken = [] date = os.path.splitext(filename)[0] try: datetime.strptime(date, '%m.%d.%y') except ValueError: flash(constants.INVALID_CSV_NAME, 'danger') return for row in reader: if len(row) == 5: t = date + ' ' + row[0] try: t = datetime.strptime(t, '%m.%d.%y %H:%M:%S') except ValueError: try: t = datetime.strptime(t, '%m.%d.%y %H:%M') except ValueError: badSyntax.append(reader.line_num) continue ph = row[1] do = row[2] ec = row[3] temp = row[4] try: ph = float(ph) do = float(do) ec = float(ec) temp = float(temp) if not (0 <= ph <= 14): raise ValueError(constants.INVALID_PH) if not (0 <= do <= 36): raise ValueError(constants.INVALID_DO) if not (0 <= ec): raise ValueError(constants.INVALID_EC) except ValueError: badSyntax.append(reader.line_num) continue measurement = Measurement.get(t) if measurement: timeTaken.append(reader.line_num) continue Measurement.create(Measurement(current_user.id, t, ph, do, ec, temp)) else: badSyntax.append(reader.line_num) flash(constants.CSV_UPLOAD_SUCCESS, 'success') if badSyntax: flash(constants.CSV_BAD_SYNTAX.format(json.dumps(badSyntax)), 'info') if timeTaken: flash(constants.CSV_TIME_TAKEN.format(json.dumps(timeTaken)), 'info')
def post(self):
data = json.loads(self.request.body)
if not (set(data.keys()) == {'timestamp', 'type', 'amount'}):
raise ValueError()
timestamp = datetime.fromtimestamp(data['timestamp'])
measurement = Measurement(timestamp=timestamp,
amount=float(data['amount']),
type=data['type'])
measurement.put()
def test_bulk_import_new_measurements_empyt_db(client):
import_measurements = [
Measurement(timestamp=datetime.datetime(
2017, 1, 1, 0, tzinfo=pendulum.timezone("Europe/Berlin")),
nodeId='test_node'),
Measurement(timestamp=datetime.datetime(
2017, 1, 1, 2, tzinfo=pendulum.timezone("Europe/Berlin")),
nodeId='test_node')
]
insert_count = Importer._bulk_import_new_measurements(import_measurements)
assert insert_count == 2
assert db.session.query(Measurement).count() == 2
def test_filters_old_measurements(client):
# Arrange
timestamp = datetime.now()
Measurement(nodeId="node-1", isemsRevision="1", timestamp=timestamp - timedelta(days=45)).save()
Measurement(nodeId="node-2", isemsRevision="1", timestamp=timestamp).save()
# Act
rv = client.get('/measurements/latest')
# Assert
assert rv.json == {'measurements': [{**base_measurement,
'id': 2,
'nodeId': 'node-2',
'timestamp': timestamp.isoformat()}]}
def consolidate_measurements(identifier, type_):
# aggregate the individual measurements
measurements = Measurement.all(identifier, type_).order(Measurement.timestamp).fetch(keys_only=True)
logging.info('There are %d measurements' % (len(measurements),))
i = 0
if len(measurements) >= BLOCK_SIZE:
measurements = ndb.get_multi(measurements)
for blocknr in range(len(measurements) // BLOCK_SIZE):
blockdata = []
to_delete = []
first, last = datetime.datetime(2999, 12, 31), datetime.datetime(1000, 1, 1)
for mnr in range(BLOCK_SIZE):
measurement = measurements[i]
if not measurement:
return "Odd stuff."
i += 1
ts = measurement.timestamp
blockdata.append((int(time.mktime(ts.timetuple())), measurement.value))
first = min(first, ts)
last = max(last, ts)
to_delete.append(measurement.key)
# Full block, add it
block = MeasurementBlock(identifier=identifier, type=type_,
count=BLOCK_SIZE, first=first, last=last,
values=json.dumps(blockdata))
block.put()
ndb.delete_multi(to_delete)
consolidate_blocks(identifier, type_, 1)
consolidate_blocks(identifier, type_, 2)
return "Ok."
def add_measurement_for_ingredient(ingredient, recipe_data):
"""
Add measurements for corresponding ingredients in a recipe to the db
recipe_data (obj): recipe data from the Spoonacular API
ingredient (obj): ingredient data
Returns the recipe from the db
"""
try:
recipe_id = recipe_data.get('id', None)
ingredient_id = ingredient.get('id', None)
amount = ingredient.get('amount', None)
unit = ingredient.get('unit', None)
new_measurement = Measurement(ingredient_id=ingredient_id,
recipe_id=recipe_id,
amount=amount,
unit=unit)
new_measurement = add_and_commit(new_measurement)
except Exception as e:
db.session.rollback()
# import pdb
# pdb.set_trace()
print('***********************')
print(str(e))
print('***********************')
return recipe_data
def patch(self, id):
try:
measurement = Measurement.objects(id=id).first()
if measurement is not None:
if get_formatted_date(
measurement.created) != get_formatted_date(
get_today_date()):
raise BadRequest(
f'Cannot update a measurement for {get_formatted_date(measurement.created)}'
)
data = self.reqparse.parse_args()
data = normalize_data(data)
measurement.update(**data)
measurement.reload()
return measurement.to_dict(), 200
abort(404, message=f'Measurement ID={id} was not found')
except BadRequest as e:
app.logger.error(e)
raise e
except NotFound as e:
app.logger.error(e)
raise e
except Exception as e:
app.logger.error(e)
abort(500, message=str(e))
def process_data(data):
# first decouple binary data
barr = bytearray(data)
proto = UnicornProto.from_buffer(barr)
print proto.device
for field in proto._fields_:
print field[0], getattr(proto, field[0])
#get device
station, _ = Station.get_or_create(device_id=proto.device, )
# store parsed data into DB
measured = Measurement.create(
station=station,
timestamp=proto.timestamp,
temperature=proto.temperature,
humidity=proto.humidity,
pressure=proto.pressure,
CO2=proto.CO2,
light=proto.light,
snow=proto.snow_intensity,
rain=proto.rain_intensity,
battery=proto.battery,
)
return measured
def image_update():
try:
unit = request.args.get('consumer_unit')
print(unit)
image = request.files['file']
if unit is None or image is None:
return _build_response({'error': 'No unit was specified'}, 400)
costumer = Costumer.query.filter_by(consumer_unit=unit).first()
if costumer is None:
return _build_response({'error': 'Costumer not found'}, 404)
timestamp = str(time.time())
path = image_path + unit + '_' + timestamp + '_' + secure_filename(
image.filename)
image.save(path)
img = Image.open(image) # ABRE A IMG REFERIDA
# TODO: Function to get the measurement value from the image
value = ocr.image_to_string(
img, lang='eng', config='--psm 10'
) # CONVERTE A IMG PARA STRING COM OS PARAMETROS DE LINGUA INGLESA E PSM 10
print(value)
new_measurement = Measurement(value, path, costumer.id)
db.session.add(new_measurement)
db.session.commit()
return _build_response({'success': True}, 200)
except Exception as error:
return _build_response({'error': str(error)}, 500)
def on_get(self, req, resp, name=None):
try:
if name:
result = list(
Measurement.select(
Measurement.timestamp,
Measurement.temperature,
Measurement.pressure,
Measurement.humidity,
Measurement.light,
Measurement.CO2,
Measurement.rain,
Measurement.snow,
Measurement.battery,
Station.name,
Station.id,
).join(Station).where(Station.name == name).order_by(
Measurement.timestamp.desc()).limit(100).dicts())[::-1]
else:
result = list(
Measurement.select(
Measurement.timestamp,
Measurement.temperature,
Measurement.pressure,
Measurement.humidity,
Measurement.light,
Measurement.CO2,
Measurement.rain,
Measurement.snow,
Measurement.battery,
Station.name,
Station.id,
).join(Station).order_by(
Measurement.timestamp.desc()).limit(200).dicts())[::-1]
except Exception as ex:
self.logger.error(ex)
print ex
description = ('Aliens have attacked our base! We will '
'be back as soon as we fight them off. '
'We appreciate your patience.')
raise falcon.HTTPServiceUnavailable('Service Outage', description,
30)
resp.context['result'] = result
resp.status = falcon.HTTP_200
def get(self, id):
"""
Returns a measurement given its ID
"""
measurement = Measurement.objects(id=id).first()
if measurement is not None:
return measurement.to_dict(), 200
self.abort_with_http_code_error(404, f'Measurement ID={id} was not found')
def test_some_data(client):
# Arrange
timestamp = datetime.now()
Measurement(nodeId="node-1", isemsRevision="1", timestamp=timestamp).save()
Measurement(nodeId="node-2", isemsRevision="1", timestamp=timestamp).save()
# Act
rv = client.get('/measurements/latest')
# Assert
assert rv.json == {'measurements': [{**base_measurement,
'id': 1,
'nodeId': 'node-1',
'timestamp': timestamp.isoformat()},
{**base_measurement,
'id': 2,
'nodeId': 'node-2',
'timestamp': timestamp.isoformat()}]}
def getTask(task_id):
mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB')
cursor = mariadb_connection.cursor()
cursor.execute("SELECT * FROM Measurement WHERE ID={}".format(task_id))
entry = cursor.fetchall()
data = Measurement(entry[0][0], entry[0][1], entry[0][2], entry[0][3], entry[0][4], entry[0][5])
closeConnection()
return data.data
def get_reply(measured):
# get last ts from DB
last = Measurement.select().where(
Measurement.station == measured.station,
Measurement.timestamp < measured.timestamp).order_by(
Measurement.timestamp.desc()).first()
ts = int(time.time())
if last:
ts = last.timestamp
return ctypes.c_ulong(ts)
def test_new_measurement():
new_measurement = Measurement(1, '001100', 'a', 'manu12', 110, 111, 101.00)
assert new_measurement.id == 1
assert new_measurement.meas_date == '001100'
assert new_measurement.event_type == 'a'
assert new_measurement.manufacturerID == 'manu12'
assert new_measurement.gluc_value == 110
assert new_measurement.insulin_value == 111
assert new_measurement.carb == 101.00
assert not new_measurement.carb == 86753.29
def get(self, id):
try:
measurement = Measurement.objects(id=id).first()
if measurement is not None:
return measurement.to_dic(), 200
abort(404, message=f'Measurement ID={id} was not found')
except NotFound as e:
raise e
except Exception as e:
abort(500, message=str(e))
def getLatestTask(sensor_id):
mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB')
cursor = mariadb_connection.cursor()
cursor.execute("SELECT * FROM Measurement WHERE Date=( SELECT MAX(Date) FROM Measurement WHERE SensorId={} )".format(sensor_id))
entry = cursor.fetchall()
n = len(entry) - 1
data = Measurement(entry[n][0], entry[n][1], entry[n][2], entry[n][3], entry[n][4], entry[n][5])
closeConnection()
return data.data
def create_measurement(Session):
session = Session()
measurement = Measurement()
cpu_utilization(measurement)
cpu_stats(measurement)
memory_stats(measurement)
swap_stats(measurement)
disk_stats(measurement)
processes(measurement)
session.add(measurement)
session.commit()
def measurement():
measurement = Measurement(request.form['sensor_id'],
request.form['temprature'],
request.form['humidity'],
request.form['distance'])
db.session.add(measurement)
db.session.commit()
return jsonify(Measurement.query.get(measurement.id).json())
def create_measurement():
request_data = request.get_json()
auth = request.headers.get("X-Api-Key")
# For creating measurements you need a valid API key
if auth != app.config["API_KEY"]:
return jsonify({"message":
"ERROR: Unauthorized or missing API key"}), 401
measurement = Measurement(
# "id" : _id,
sensor=request_data["sensor"],
timestamp=dt.datetime.strptime(request_data["timestamp"],
"%Y-%m-%d %H:%M:%S"),
value=request_data["value"],
)
db.session.add(measurement)
db.session.commit()
return jsonify(measurement.serialize()), 201, {
"Location": url_for('get_measurement', _id=measurement.id)
}
def save_measurement(self, name, value):
"""Save the given measure."""
if not self.has_category(name):
raise ValueError(
"Unable to save because the category '{}' does not exist!".
format(name))
category = self._session.query(Category).filter_by(name=name).first()
measurement = Measurement(value=value,
category=category,
timestamp=datetime.now())
self._session.add(measurement)
self._session.commit()
def getTasks(amount):
mariadb_connection = mariadb.connect(user='******', password='******', database='PlantHubDB')
cursor = mariadb_connection.cursor()
all_data = []
cursor.execute("SELECT * FROM Measurement")
all_entries = cursor.fetchall()
for row in all_entries:
entry = Measurement(row[0], row[1], row[2], row[3], row[4], row[5])
all_data.append(entry.data)
closeConnection()
return all_data
def parse_line(cls, line):
parts = line.split(";")
VALID_FIELD_COUNTS = [
18, # without status
19 # with new status field
]
field_count = len(parts)
try:
assert (field_count in VALID_FIELD_COUNTS)
except AssertionError:
print("Assertion failed for line: {}".format(line))
return None
measurement = Measurement(nodeId=parts[0],
isemsRevision=parts[1],
timestamp=datetime.fromtimestamp(
int(parts[2]),
tz=pendulum.timezone("Europe/Berlin")),
openMPPTFirmwareVersion=parts[3],
timeToShutdown=parts[4],
isPowerSaveMode=(parts[5] == "1"),
openCircuitVoltage=parts[6],
mppVoltage=parts[7],
batteryVoltage=parts[8],
batteryChargeEstimate=parts[9],
batteryHealthEstimate=parts[10],
batteryTemperature=parts[11],
lowVoltageDisconnectVoltage=parts[12],
temperatureCorrectedVoltage=parts[13],
rateBatteryCapacity=parts[14],
ratedSolarModuleCapacity=parts[15],
latitude=float(parts[16]),
longitude=float(parts[17]))
if field_count == 19:
measurement.status = int(parts[18], 16)
return measurement
def _bulk_import_new_measurements(cls, measurements):
max_timestamp = Measurement.get_latest_timestamp(
measurements[0].nodeId)
if max_timestamp:
max_timestamp = max_timestamp.replace(
tzinfo=pendulum.timezone("Europe/Berlin"))
new_measurements = [
m for m in measurements if m.timestamp > max_timestamp
]
else:
new_measurements = measurements
db.session.bulk_save_objects(new_measurements)
db.session.commit()
return len(new_measurements)
def setUp(self):
self.h1 = [
'192.168.0.1', '192.168.0.36', '192.168.0.28', '192.168.0.34',
'192.168.0.42', '192.168.0.3'
]
self.h2 = [
'192.168.0.2', '192.168.0.136', '192.168.0.8', '192.168.0.16',
'192.168.0.39', '192.168.0.146', '192.168.0.3'
]
self.h3 = [
'192.168.0.1', '192.168.0.136', '192.168.0.8', '192.168.0.18'
'192.168.0.16', '192.168.0.39', '192.168.0.146', '192.168.0.4'
]
self.p1 = p.Path(hops=self.h1, id=1)
self.p2 = p.Path(hops=self.h2, id=2)
self.p3 = p.Path(hops=self.h3, id=3)
self.p4 = p.Path(hops=self.h1, id=4)
self.m1 = m.Measurement(66, 1476351846113)
self.m2 = m.Measurement(69, 1476351876762)
self.m3 = m.Measurement(62, 1476351898901)
self.m4 = m.Measurement(66, 1476351846113)
def add_static_data(self):
with app.app_context():
category1 = Category('Test Category 1')
category2 = Category('Test Category 2')
db.session.add(category1)
db.session.add(category2)
course1 = Course('Test Course 1')
course2 = Course('Test Course 2')
db.session.add(course1)
db.session.add(course2)
cuisine1 = Cuisine('Test Cuisine 1')
cuisine2 = Cuisine('Test Cuisine 2')
db.session.add(cuisine1)
db.session.add(cuisine2)
country1 = Country('Test Country 1')
country2 = Country('Test Country 2')
db.session.add(country1)
db.session.add(country2)
author_country1 = Country.query.filter_by(
country_name='Test Country 1').first()
author1 = Author('Test Author 1')
author_country1.authors.append(author1)
db.session.add(author_country1)
author_country2 = Country.query.filter_by(
country_name='Test Country 2').first()
author2 = Author('Test Author 2')
author_country2.authors.append(author2)
db.session.add(author_country2)
measurement1 = Measurement('Test Measurement 1')
measurement2 = Measurement('Test Measurement 2')
db.session.add(measurement1)
db.session.add(measurement2)
ingredient1 = Ingredient('Test Ingredient 1')
ingredient2 = Ingredient('Test Ingredient 2')
db.session.add(ingredient1)
db.session.add(ingredient2)
db.session.commit()
def measruements_batch():
try:
json = request.get_json()
userid = json['username']
for entry in json['measurements']:
measurement = Measurement(
int(userid), datetime.fromtimestamp(entry['timestamp']),
int(entry['hr']), float(entry['gsr']), entry['state'],
float(entry['level']))
db.session.add(measurement)
db.session.commit()
return jsonify(success=str(len(json['measurements'])) +
" entries inserted.")
except Exception, e:
return jsonify(error=str(e)), 500
def post(self):
"""
Creates a measurement
"""
data = self.reqparse.parse_args()
measurement = Measurement(**data)
user = User.objects(email='*****@*****.**').first()
measurement.user = user
measurement.save()
return measurement.to_dict(), 201
def fetch_measurements_for_parameter(con, param_name):
cursorObj = con.cursor()
table_name = param_name + "_parameter"
print(table_name)
cursorObj.execute('SELECT * FROM ' + table_name)
rows = cursorObj.fetchall()
print("Finish fetching all rows.")
measurements = []
for row in rows:
row_dict = dict(zip(col_headers, row))
row_dict['parameter'] = param_name
measurement = Measurement(row_dict)
measurements.append(measurement)
print("Finish converting to measurement objects.")
return measurements
def save_measurement():
data = request.get_json()
# db query
registered_user = User.query.filter_by(login=data['login']).first()
if registered_user is None:
return {"message": f"User {data['login']} not found."}, 400
else:
measurement = Measurement(min=data['min'],
max=data['max'],
avg=data['avg'],
gps_longitude=data['gps_longitude'],
gps_latitude=data['gps_latitude'],
user_login=data['login'])
db_session.add(measurement)
db_session.commit()
return {"message": f"Saved successfully."}, 201
def get(self):
datak = memcache.get('metrics')
if datak is None:
tdata = []
measurements = Measurement.query()
for m in measurements:
mdict = m.to_dict()
mdict['timestamp'] = datetime.strftime(mdict['timestamp'], "%Y-%m-%d %H:%M:%S")
if mdict['updated']:
mdict['updated'] = datetime.strftime(mdict['updated'], "%Y-%m-%d %H:%M:%S")
tdata.append(mdict)
datak = self._to_blobstore(tdata)
self.response.headers['Content-Type'] = 'application/zip'
stamp = str(int(time.mktime(memcache.get('updated').timetuple())))
self.send_blob(datak, save_as='metrics-{}.zip'.format(stamp))
def get(self):
# Generate lower bound for timestamp
lower_bound = datetime.now() + timedelta(days=-7)
dosables = Dosable.query(Dosable.timestamp > lower_bound).fetch()
measurements = (Measurement.query(Measurement.timestamp > lower_bound)
.fetch())
parallel_switches = (ParallelSwitch
.query(ParallelSwitch.timestamp > lower_bound).fetch())
# Sort data in each category by type
for data_group in [dosables, measurements, parallel_switches]:
data_group.sort(key=lambda d: d.type)
ret = {
category: {type: [instance.to_json() for instance in instances]
for type, instances
in itertools.groupby(data_group, key=lambda x: x.type)}
for category, data_group in [('dosables', dosables),
('measurements', measurements),
('parallel_switches', parallel_switches)]
}
self.out_json(ret)
def seed():
# Users
user1 = User()
user1.name = 'Daniel'
user1.chest_pain = ''
user1.eck_result = ''
user1.blood_sugar = False
user1.angina = False
user1.age = 21
db.session.add(user1)
user2 = User()
user2.name = 'Bernd'
user2.chest_pain = ''
user2.eck_result = ''
user2.blood_sugar = True
user2.angina = False
user2.age = 67
db.session.add(user2)
# Plans
plan1 = Plan()
plan1.user = user1
db.session.add(plan1)
plan2 = Plan()
plan2.user = user2
db.session.add(plan2)
# Plan entries
for _ in range(10):
entry1 = PlanEntry()
entry1.timestamp = datetime.time(random.randint(0, 23), random.randint(0, 59))
entry1.mandatory = random.randint(0, 1) == 0
entry1.plan = plan1
db.session.add(entry1)
entry2 = PlanEntry()
entry2.timestamp = datetime.time(random.randint(0, 23), random.randint(0, 59))
entry2.mandatory = random.randint(0, 1) == 0
entry2.plan = plan2
db.session.add(entry1)
# Measurements
for _ in range(100):
measurement = Measurement()
measurement.user = user1 if random.randint(0, 1) == 0 else user2
measurement.pulse = random.randint(60, 120)
measurement.systolic = random.randint(100, 130)
measurement.diastolic = random.randint(60, 100)
measurement.timestamp = datetime.datetime(
2016,
1, # Monat
random.randint(1, 31), # Tag (vereinfacht)
random.randint(0, 23), # Stunde
random.randint(0, 59) # Minute
)
db.session.add(measurement)
# Frequency Measurements
for _ in range(1000):
measurement = FrequencyMeasurement()
measurement.user = user1 if random.randint(0, 1) == 0 else user2
measurement.rate = random.randint(60, 120)
measurement.timestamp = datetime.datetime(
2016,
1, # Monat
random.randint(1, 31), # Tag (vereinfacht)
random.randint(0, 23), # Stunde
random.randint(0, 59) # Minute
)
db.session.add(measurement)
db.session.commit()
def _get_earliest(self):
query = Measurement.query()
return query.order(Measurement.timestamp).get().timestamp
def _get_count(self):
query = Measurement.query()
return query.count()
def show_meas():
user = users.get_current_user()
meas_query = Measurement.gql("WHERE user = :curr_user", curr_user=user)
meas_list = meas_query.fetch(10)
return render_template('render_meas.html',
meas_dict=[meas.to_dict() for meas in meas_list])
