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 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 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 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 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 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 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 test_bulk_import_new_measurements(client):
measurement = Measurement(timestamp=datetime.datetime(
2017, 1, 1, 1, tzinfo=pendulum.timezone("Europe/Berlin")),
nodeId='test_node')
measurement.save()
# One entry is older than the latest entry so it should not be imported
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 == 1
assert db.session.query(Measurement).count() == 2
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 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 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 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 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 post(self):
try:
data = self.reqparse.parse_args()
measurement = Measurement(**data)
user = User.objects(email="*****@*****.**").first()
measurement.user = user
measurement.save()
return measurement.to_dict(), 201
except BadRequest as e:
abort(400, message=e.data.get("message"))
except (NotUniqueError, ValidationError) as e:
abort(400, message=str(e))
except Exception as e:
abort(500, message=str(e))
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='*****@*****.**').modify(
upsert=True,
new=True,
set__email='*****@*****.**',
set__name='Jorge',
set__surname='Galvis')
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 post(self):
try:
data = self.reqparse.parse_args()
measurement = Measurement(**data)
user = User.objects(email='*****@*****.**').first()
measurement.user = user
measurement.save()
return measurement.to_dict(), 201
except BadRequest as e:
app.logger.error(e)
abort(400, message=e.data.get('message'))
except (NotUniqueError, ValidationError) as e:
app.logger.error(e)
abort(400, message=str(e))
except Exception as e:
app.logger.error(e)
abort(500, message=str(e))
def add_item(self, data: dict):
new_data = ResultSchema(unknown=EXCLUDE).load(data)
server_id = new_data.get("server").get("id")
server = None
if server_id:
server = (self.db_session.query(Server).filter(
Server.id == server_id).one_or_none())
if server_id and not server:
server_data = new_data.pop("server")
server = Server(**server_data)
self.db_session.add(server)
new_data["server"] = server
new_obj = Measurement(**new_data)
self.db_session.add(new_obj)
self.db_session.commit()
return new_obj
def add_measurement_for_ingredient(ingredient, recipe_data):
""" Add Recipe ingredients measurements in a recipe to the database """
try:
recipe_id = recipe_data.get('id', None)
ingredient_id = ingedient.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 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 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 updateGram(slug):
data = requests.get('https://cardiogr.am/heart/cardiograms/%s?no-cache=1' %
slug).json()
line = data['cardiogram']['cards'][0]['song']['lines']['heartRate'][
'_line']
slug = data['cardiogram']['vanityUrl']
start = data['cardiogram']['start']
end = data['cardiogram']['end']
gram_exists = False if Gram.query.filter_by(slug=slug).count() == 0 else 1
if not gram_exists:
gram = Gram(slug=slug,
start=datetime.fromtimestamp(start / 1000),
end=datetime.fromtimestamp(end / 1000))
status_msg = 'Nov Cardiogram shranjen.'
else:
gram = Gram.query.filter_by(slug=slug).first()
ms = Measurement.query.with_parent(gram).all()
for m in ms:
m.delete()
db.session.commit()
status_msg = 'Cardiogram posodobljen.'
for l in line:
time = datetime.fromtimestamp(l['start'] / 1000)
heart_rate = l['value']
m = Measurement(time=time, heart_rate=heart_rate, gram=gram)
db.session.add(gram)
db.session.commit()
return status_msg
def add_measurement():
measurement = Measurement(request.form['measurement'])
db.session.add(measurement)
db.session.commit()
return redirect(url_for('manage_static_data'))
