def testSensorAPIs(self):
self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id())
self.sensor1.Update(name="Sensor 1")
self.sensor2 = Sensor.Create(self.e, "000-200", self.st.key().id())
db.put([self.sensor1, self.sensor2])
# Test list
params = self.__commonParams()
result = self.get_json("/api/sensor", params)
self.assertTrue(result['success'])
self.assertEqual(len(result['data']['sensors']), 2)
# Test detail
params = self.__commonParams()
params['with_records'] = 10
result = self.get_json("/api/sensor/%s" % "000-100", params)
self.assertTrue(result['success'])
self.assertEqual(result['data']['sensor']['name'], "Sensor 1")
# Test create with alias
params = self.__commonParams()
KN = "00-200"
params['kn'] = KN
params['name'] = "Geo Sensor 1"
params['sensortype_alias'] = "geo"
result = self.post_json("/api/sensor", params)
self.assertTrue(result['success'])
s = Sensor.get_by_key_name(KN, parent=self.e.key())
self.assertIsNotNone(s)
self.assertEqual(s.name, "Geo Sensor 1")
self.assertEqual(s.sensortype.key(), self.st.key())
def delete(self, sensor_id = None): sensor = Sensor.query.filter_by(id = sensor_id).first() if sensor: Sensor.delete(id = sensor.id) return jsonify(ApiObjects(sensor.json())) else: return jsonify(ApiObjects())
def _save_sensor(params):
try:
sensor = Sensor(**params)
sensor.save()
except:
print params
raise
def seed_node(site_id = None, alias = None, latitude = None, longitude = None):
if site_id:
site = Site.query.filter_by(id = site_id).first()
else:
site = Site.create(name = 'Techrice site {}'.format(uuid4().hex))
if not alias:
alias = 'Techrice node {}'.format(uuid4().hex)
node = Node.create(name = alias, site = site, latitude = latitude, longitude = longitude)
solar = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'solar voltage').first(), name = 'vsol')
battery = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'battery voltage').first(), name = 'vbat')
temperature = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'DHT11 temperature').first(), name = 'temperature')
humidity = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'DHT11 humidity').first(), name = 'humidity')
sonar = Sensor.create(node = node, sensortype = SensorType.query.filter_by(name = 'sonar HC SR-04').first(), name = 'sonar')
header = Header.get_header(node_id = node.id)
print header
return {
'node': 'name: {}, id: {}, longitude: {}, latitude: {}'.format(node.name, node.id, node.longitude, node.latitude),
'sensors': map(lambda s: 'name: {}, id: {}'.format(s.name, s.id), node.sensors),
'header' : header
}
def _save_sensor(params):
try:
sensor = Sensor(**params)
sensor.save()
except:
print params
raise
def env_test_01():
admin_user = User(name="Administrator",
role=ROLE_ADMIN,
access_code="1234")
admin_user.add_registration_code("1234")
session.add_all([
admin_user,
User(name="Chuck Norris", role=ROLE_USER, access_code="1111")
])
print(" - Created users")
z1 = Zone(name="No delay", description="Alert with no delay")
z2 = Zone(name="Tamper",
disarmed_delay=0,
away_alert_delay=None,
stay_alert_delay=None,
description="Sabotage alert")
z3 = Zone(name="Away/stay delayed",
away_alert_delay=5,
stay_alert_delay=5,
description="Alert delayed when armed AWAY or STAY")
z4 = Zone(name="Stay delayed",
stay_alert_delay=5,
description="Alert delayed when armed STAY")
z5 = Zone(name="Stay",
stay_alert_delay=None,
description="No alert when armed STAY")
session.add_all([z1, z2, z3, z4, z5])
print(" - Created zones")
session.add_all(SENSOR_TYPES)
print(" - Created sensor types")
s1 = Sensor(channel=0,
sensor_type=SENSOR_TYPES[0],
zone=z3,
description="Garage")
s2 = Sensor(channel=1,
sensor_type=SENSOR_TYPES[2],
zone=z5,
description="Test room")
s3 = Sensor(channel=2,
sensor_type=SENSOR_TYPES[1],
zone=z2,
description="Tamper")
session.add_all([s1, s2, s3])
print(" - Created sensors")
kt1 = KeypadType(1, "DSC", "DSC keybus (DSC PC-1555RKZ)")
kt2 = KeypadType(2, "WIEGAND", "Wiegand keypad")
session.add_all([kt1, kt2])
print(" - Created keypad types")
k1 = Keypad(keypad_type=kt1)
session.add_all([k1])
print(" - Created keypads")
session.commit()
def initialize_database(app, db):
"""Drop and restore database in a consistent state"""
with app.app_context():
db.drop_all()
db.create_all()
first_network = Network(name='First Network', site='DEL18DT')
first_network.sensors.extend([Sensor(name='Bulkhead 5 Water Level', value=50),
Sensor(name='Bulkhead 7 Water Level', value=20),
Sensor(name='Bulkhead 2 Water Level', value=40)])
second_network = Network(name='Second Network', site='DEL23DT')
second_network.sensors.extend([Sensor(name='Rain Sensor Front Level', value=250),
Sensor(name='Rain Sensor Back Level', value=620)])
db.session.add(first_network)
db.session.add(second_network)
db.session.commit()
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_app_identity_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_blobstore_stub()
self.init_modules_stub()
cloudstorage.set_default_retry_params(None)
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {'speed': {'unit': 'kph'}, 'narrative': {'type': 'string'}}
self.spedometer.Update(name="Spedometer", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1")
self.vehicle_1.put()
def testRecordAPIs(self):
self.sensor1 = Sensor.Create(self.e, "000-100", self.st.key().id())
self.sensor1.put()
now = datetime.now()
r1_ts = tools.unixtime(now)
r = Record.Create(tools.unixtime(now), self.sensor1,
{'location': '51.5033640,-0.1276250'})
r2 = Record.Create(
tools.unixtime(now) + 1000, self.sensor1,
{'location': '51.5033640,-0.1276250'})
db.put([r, r2])
# Test list
params = self.__commonParams()
params.update({'sensor_kn': "000-100"})
result = self.get_json("/api/data", params)
self.assertTrue(result['success'])
self.assertEqual(len(result['data']['records']), 2)
# Test detail
params = self.__commonParams()
result = self.get_json("/api/data/%s/%s" % ("000-100", r1_ts), params)
self.assertTrue(result['success'])
_r = result['data']['record']
self.assertEqual(_r['sensor_kn'], "000-100")
self.assertEqual(_r['ts'], r1_ts)
self.assertEqual(
_r['kn'], "%s_%s_%s" %
(self.e.key().id(), self.sensor1.key().name(), int(r1_ts)))
def testAlarmWithPayment(self):
# Create smartphone report sensor
self.smartphone_sensor_type = SensorType.Create(self.e)
schema = {'agreement': {'unit': '1-5 scale'}}
self.smartphone_sensor_type.Update(name="Report Sensor",
schema=json.dumps(schema))
self.smartphone_sensor_type.put()
self.smartphone_sensor = Sensor.Create(
self.e, "1000",
self.smartphone_sensor_type.key().id())
self.smartphone_sensor.Update(
sensortype_id=self.smartphone_sensor_type.key().id(),
name="Smartphone Reports 1",
contacts={"user": self.owner.key().id()})
self.smartphone_sensor.put()
# Create smartphone report rule with payment on any report
PMNT_AMOUNT = 10.0
self.any_report_rule = Rule.Create(self.e)
self.any_report_rule.Update(
name="Any Report",
sensortype_id=self.smartphone_sensor_type.key().id(),
column="agreement",
trigger=RULE.ANY_DATA,
payment_contacts=["user"],
payment_amount=PMNT_AMOUNT,
consecutive_limit=RULE.
ANY, # Deactivate immediately (should be == 1)
duration=0)
self.any_report_rule.put()
self.assertTrue(self.any_report_rule.payments_enabled())
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.any_report_rule.key().id()])
self.process.put()
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.smartphone_sensor)
self.sp.put()
BATCH_SIZE = 3
BATCH_1 = {
'agreement': [random.randint(1, 5) for x in range(BATCH_SIZE)],
}
self.__createNewRecords(BATCH_1,
first_dt=datetime.now(),
sensor=self.smartphone_sensor)
self.__runProcessing()
# This batch should have fired 3 alarms for any report, and created
# 3 payments.
pmnts = Payment.Fetch(self.owner)
self.assertEqual(len(pmnts), 3)
total_payments = BATCH_SIZE * PMNT_AMOUNT
self.assertEqual(total_payments, sum([p.amount for p in pmnts]))
def post(self):
form = SensorCreateForm()
if not form.validate_on_submit():
return form.errors, 422
sensor = Sensor(form.name.data, form.description.data)
db.session.add(sensor)
db.session.commit()
return SensorSerializer(sensor).data, 201
def node_add_sensors(node_id):
"""
Add a Sensor
Registers sensor on nodes
---
tags:
- sensors
definitions:
- schema:
id: Post_Sensor
required:
- id
- type
- pin
properties:
id:
type: integer
description: id of the sensor
type:
type: string
description: type of sensor
enum: ['door','temperature','trigger','led']
pin:
type: integer
description: the gpio pin number the sensor is on
parameters:
- in: body
name: Sensor
description: Sensor object to be added to the hub
schema:
$ref: '#/definitions/Post_Sensor'
responses:
201:
description: Returns the information received about the sensor
"""
payload = request.get_json()
webid = payload.get("id")
sensor = Sensor.get_by_webid(webid)
if sensor:
abort(409)
pin = payload.get('pin')
sensor_type = payload.get('type')
if sensor_type == "door":
sensor_type = "DOOR"
elif sensor_type == "temperature":
sensor_type = "TEMP"
elif sensor_type == "humidity":
sensor_type = "HUMI"
elif sensor_type == "trigger":
sensor_type = "TRIG"
elif sensor_type == "led":
sensor_type = "LED"
else:
abort(400)
sensor = Sensor(node_id, pin, sensor_type, webid=webid)
return json.jsonify({'sensor': {'node_id': node_id, 'pin': pin,
'sensor_type': sensor_type}}), 201
def testGeoFenceAlarm(self):
self.geosensor = SensorType.Create(self.e)
schema = {
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION],
'type': 'latlng'
}
}
self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema))
self.geosensor.put()
# Create off route alarm
self.offroute_alarm = Rule.Create(self.e)
self.offroute_alarm.Update(name="Off Route",
sensortype_id=self.spedometer.key().id(),
column="location",
trigger=RULE.GEOFENCE_OUT,
value_complex=json.dumps(DUMMY_GEOFENCE))
self.offroute_alarm.put()
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.offroute_alarm.key().id()])
self.process.put()
self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.geosensor.key().id())
self.vehicle_2.Update(name="Vehicle Sensor 2")
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.vehicle_2)
self.sp.put()
# Process 8 location datapoints (3 in bounds, 3 out, 2 back in)
BATCH_1 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in ROUTE_DIVERSION]
}
self.__createNewRecords(BATCH_1,
first_dt=datetime.now() -
timedelta(minutes=20),
interval_secs=30)
self.__runProcessing()
# Confirm off-route alarm fired upon datapoint 4, and deactivates on 7 (back in fence)
alarms = Alarm.Fetch(self.vehicle_2, self.offroute_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
first_record_in_alarm = a.first_record
self.assertEqual(a.duration().seconds,
60) # 3 datapoints, 30 second gap
oob_record = ROUTE_DIVERSION[3]
self.assertEqual(first_record_in_alarm.columnValue('location'),
"%s,%s" % (oob_record[0], oob_record[1]))
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.spedometer = SensorType.Create(self.e)
schema = {
'speed': {
'unit': 'kph'
},
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'degrees'
},
'hard_braking': {
'unit': 'boolean'
}
}
self.spedometer.Update(name="Geo Sensor", schema=json.dumps(schema))
self.spedometer.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.spedometer.key().id())
self.vehicle_1.Update(sensortype_id=self.spedometer.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
# Create alarm
self.speeding_alarm = Rule.Create(self.e)
self.speeding_alarm.Update(name="Speeding",
sensortype_id=self.spedometer.key().id(),
column="speed",
trigger=RULE.CEILING,
value2=80.0,
alert_contacts=["owner"],
alert_message=SPEEDING_ALERT_MESSAGE,
duration=0)
self.speeding_alarm.put()
def addSensor(len, index, addr, type, storage):
for i in range(len):
a=Sensor()
a.sensor_index=index[i]
a.storage=storage
a.type=type
a.location=addr[i]
a.save()
def __init__(self, sensor_id, start_time, wait_interval = 60): Process.__init__(self) self.daemon = True self.wait_interval = wait_interval sensor = Sensor.query.filter(Sensor.id == sensor_id).first() if sensor: self.sensor = sensor else: self.sensor = Sensor.create(name = 'started at %s'%datetime.utcnow().ctime()) print '*********** Created new sensor' print self.sensor
def post(self):
args = parser.parse_args()
rpiId = int(args.rpiId)
temp = float(args.temp)
d = list(map(int, args.date.split('-')))
d = date(d[0], d[1], d[2])
t = list(map(int, args.time.split(':')))
t = time(t[0], t[1])
sensor = Sensor(rpiId=rpiId, temp=temp, date=d, time=t)
db.session.add(sensor)
db.session.commit()
return {'status': 'OK'}
def getTask(task_id):
mariadb_connection = mariadb.connect(user='******',
password='******',
database='PlantHubDB')
cursor = mariadb_connection.cursor()
cursor.execute("SELECT * FROM Sensor WHERE ID={}".format(task_id))
entry = cursor.fetchall()
data = Sensor(entry[0][0], entry[0][1], entry[0][2])
closeConnection()
return data.data
def testGeoJsonIn(self):
uri = "/%s/inbox/json/%s" % (self.e.key().id(), TEST_SENSOR_ID)
lat = 1.3
lon = 36.9
MOVE_SIZE = 0.01
MAX_ACCEL = 10
N_POINTS = 10
DELAY_SECS = 1
now = datetime.now() - timedelta(seconds=60)
# Populate dummy data with random moves
data = []
target_accel_mags = []
for x in range(N_POINTS):
now += timedelta(seconds=DELAY_SECS)
lat += (random.random() - 0.5) * MOVE_SIZE
lon += (random.random() - 0.5) * MOVE_SIZE
loc = "%s,%s" % (lat, lon)
ax = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2
ay = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2
az = (random.random() * MAX_ACCEL) - MAX_ACCEL / 2
accel_mag = math.sqrt(pow(ax, 2) + pow(ay, 2) + pow(az, 2))
target_accel_mags.append(accel_mag)
data.append({
'timestamp': tools.unixtime(dt=now), # milliseconds
'location': loc,
'ax': ax,
'ay': ay,
'az': az
})
last_loc = loc
body = json.dumps(data)
response = self.post(uri, body)
self.assertEqual(response.status_int, 200)
content = json.loads(response.normal_body)
self.assertTrue(content['success'])
self.assertEqual(content['data']['count'], N_POINTS)
# Fetch created records from db
records = Record.Fetch(self.geosensor1)
self.assertEqual(len(records), N_POINTS)
last_r = records[0]
self.assertEqual(tools.unixtime(last_r.dt_recorded),
tools.unixtime(now))
accel_mags = [r.columnValue('accel_mag') for r in records]
self.assertListEqual(accel_mags, list(reversed(target_accel_mags)))
# Confirm sensor state update
self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db
self.assertEqual(self.geosensor1.location, db.GeoPt(last_loc))
def sensor(request):
sensor_name = request.GET.get("sensor", "")
value = request.GET.get("value", "")
time = request.GET.get("time", "")
from django.utils.timezone import get_current_timezone
from django.utils import timezone
if len(time) == 0:
time_p = timezone.now()
else:
time_p = datetime.datetime.fromtimestamp(int(time), tz=get_current_timezone())
print time_p
objs = Sensor.objects.filter(name=sensor_name)
sensor = None
if len(objs) > 0:
sensor = objs[0]
else:
sensor = Sensor()
sensor.name = sensor_name
sensor.save()
try:
latest = Value.objects.filter(sensor=sensor).order_by("-pub_date")[0]
# print "latest",str(latest)
if time_p < latest.pub_date:
print "WARNNING: Sensor time should be greater than last in DB"
if latest.value == float(value):
result = "No need to update data for sensor %s" % sensor
print result
HttpResponse(result)
except IndexError:
pass
v = Value(sensor=sensor, pub_date=time_p, value=float(value))
v.save()
return HttpResponse(str(sensor.name) + ":" + str(value))
def create_sensor():
data = request.json
zone = db.session.query(Zone).get(request.json["zoneId"])
sensor_type = db.session.query(SensorType).get(data["typeId"])
sensor = Sensor(
channel=data["channel"],
zone=zone,
sensor_type=sensor_type,
description=data["description"],
)
db.session.add(sensor)
db.session.commit()
return process_ipc_response(IPCClient().update_configuration())
def new():
"""
New sensor form to create a sensor.
"""
form = SensorForm(request.form)
if form.validate_on_submit():
sensor = Sensor(form.name.data, form.attribute.data, form.comment.data,
form.c_1.data, form.c_2.data)
db.session.add(sensor)
db.session.commit()
flash('You have successfully added a new sensor.', 'success')
return redirect(url_for('sensors.view', id=sensor.id))
return render_template('sensors/new.html', form=form)
def testGeoJsonIn(self):
uri = "/%s/inbox/json/%s" % (self.e.key().id(), TEST_SENSOR_ID)
lat = 1.3
lon = 36.9
MOVE_SIZE = 0.01
MAX_ACCEL = 10
N_POINTS = 10
DELAY_SECS = 1
now = datetime.now()
# Populate dummy data with random moves
data = []
target_accel_mags = []
for x in range(N_POINTS):
now += timedelta(seconds=DELAY_SECS)
lat += (random.random()-0.5) * MOVE_SIZE
lon += (random.random()-0.5) * MOVE_SIZE
loc = "%s,%s" % (lat, lon)
ax = (random.random() * MAX_ACCEL) - MAX_ACCEL/2
ay = (random.random() * MAX_ACCEL) - MAX_ACCEL/2
az = (random.random() * MAX_ACCEL) - MAX_ACCEL/2
accel_mag = math.sqrt(pow(ax,2)+pow(ay,2)+pow(az,2))
target_accel_mags.append(accel_mag)
data.append({
'timestamp': tools.unixtime(dt=now), # milliseconds
'location': loc,
'ax': ax,
'ay': ay,
'az': az
})
last_loc = loc
body = json.dumps(data)
response = self.post(uri, body)
self.assertEqual(response.status_int, 200)
content = json.loads(response.normal_body)
self.assertTrue(content['success'])
self.assertEqual(content['data']['count'], N_POINTS)
# Fetch created records from db
records = Record.Fetch(self.geosensor1)
self.assertEqual(len(records), N_POINTS)
last_r = records[0]
self.assertEqual(tools.unixtime(last_r.dt_recorded), tools.unixtime(now))
accel_mags = [r.columnValue('accel_mag') for r in records]
self.assertListEqual(accel_mags, list(reversed(target_accel_mags)))
# Confirm sensor state update
self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db
self.assertEqual(self.geosensor1.location, db.GeoPt(last_loc))
def get_readings_by_date_test():
termometer = Sensor.find("Termometer")
expected_readings_len = 24 - 12 + 1
begin = datetime(2020, 11, 26, 17, 12)
end = datetime(2020, 11, 26, 17, 24)
readings = termometer.get_readings_by_date(begin, end)
if len(readings) != expected_readings_len:
print("get_readings_by_date_test: FAILED")
print(f"Expected outcome {expected_readings_len}, "
f"Actual outcome {len(readings)}")
else:
print("get_readings_by_date_test: PASSED")
def sensor_delete(sensor_id):
"""
Delete a Sensor
---
tags:
- sensors
responses:
200:
description: Returns "Deleted"
"""
sensor = Sensor.get_by_webid(sensor_id)
node = Node.get_by_id(sensor.node_id)
node.remove_sensor(sensor.id)
return json.jsonify({'message': 'Deleted'}), 201
def seed_site(sensors = 1, days = 7, interval_seconds = 3600):
site = Site.create(name = 'seeded_site')
node = Node.create(name = 'seeded_node', site = site, latitude = 35.146623 + random() / 100.0, longitude = 139.9835682 + random() / 100.0)
sensortype = SensorType.create(name = 'HC SR-04', unit = 'cm')
for i in range(sensors):
sensor = Sensor.create(sensortype = sensortype, node = node, name = 'water distance %s'%i)
timestamp = datetime.utcnow() - timedelta(days = 7)
data = loggeobrowngen()
n_readings = 0
while timestamp < datetime.utcnow():
Reading.create(sensor = sensor, value = data.next(), timestamp = timestamp)
timestamp += timedelta(seconds = interval_seconds)
n_readings += 1
data.close()
return {'site': site, 'node': node}
def addsensor():
form = AddSensorForm()
if form.validate_on_submit():
with create_session() as session:
if not check_if_sensor_id_exists(form, session, Sensor):
sensor = Sensor(place_id=form.sensor_place.data,
sensor_id=form.sensor_id.data,
gateway_id=form.sensor_gateway.data)
session.add(sensor)
update_record_status(form, session, Record)
flash("Sensor added successfully", "success")
else:
flash("Sensor ID already registered in database", "error")
return redirect(url_for('sensors'))
return render_template("sensor-add.html", form=form)
def getTasks(amount):
mariadb_connection = mariadb.connect(user='******',
password='******',
database='PlantHubDB')
cursor = mariadb_connection.cursor()
all_data = []
cursor.execute("SELECT * FROM Sensor")
all_entries = cursor.fetchall()
for row in all_entries:
entry = Sensor(row[0], row[1], row[2])
all_data.append(entry.data)
closeConnection()
return all_data
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.register_search_api_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent")
self.e.put()
self.geosensor = SensorType.Create(self.e)
schema = {
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION]
},
'ax': {},
'ay': {
'unit': 'm/s^2',
'type': 'number'
},
'az': {
'unit': 'm/s^2',
'type': 'number'
},
'accel_mag': {
'unit': 'm/2^2',
'label': "Acceleration Magnitude",
'calculation': "SQRT([ax]^2 + [ay]^2 + [az]^2)"
}
}
self.geosensor.Update(name="Geo Sensor", schema=json.dumps(schema))
self.geosensor.put()
self.geosensor1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.geosensor.key().id())
self.geosensor1.Update(sensortype_id=self.geosensor.key().id(),
name="Geo Sensor 1")
self.geosensor1.put()
def post(self):
parser = reqparse.RequestParser(bundle_errors = True)
parser.add_argument('node_id', type=int, location='form', required=True, help='<int> node_id required')
parser.add_argument('sensortype_id', type=int, location='form', required=True, help='<int> sensortype_id required')
parser.add_argument('name', type=int, location='form', required=False, help='<int> sensortype_id optional')
args = parser.parse_args()
node = Node.query.filter_by(id = args['node_id']).first()
if not node:
return jsonify(ApiError('node {} not found'.format(args['node_id'])))
sensortype = SensorType.query.filter_by(id = args['sensortype_id']).first()
if not sensortype:
return jsonify(ApiError('sensortype {} not found'.format(args['sensortype_id'])))
sensor = Sensor.create(node = node, sensortype = sensortype, name = args['name'])
if sensor:
return jsonify(ApiObjects(sensor.json()))
else:
return jsonify(ApiObjects())
def data(temp, hum, pres, pm2_5, pm10, pwd):
if pwd == app.config['PASS']:
now = datetime.now()
sensor_names = ['temp', 'hum', 'pres', 'PM 2.5', 'PM 10']
sensor_units = ['°C', '%', 'hPa', 'μg /m³', 'μg /m³']
values = [temp, hum, pres, pm2_5, pm10]
for (sensor_name, unit, value) in zip(sensor_names, sensor_units,
values):
sensor = Sensor.query.filter_by(name=sensor_name).first()
if sensor is None:
sensor = Sensor(name=sensor_name, unit=unit)
db.session.add(sensor)
db.session.commit()
data = SensorData(date=time.mktime(now.timetuple()), value=value)
sensor.data.append(data)
db.session.add(data)
db.session.commit()
return redirect("/", code=303)
def setUp(self):
self.set_application(tst_app)
self.setup_testbed()
self.init_datastore_stub()
self.init_memcache_stub()
self.init_taskqueue_stub()
self.init_mail_stub()
self.register_search_api_stub()
self.init_urlfetch_stub()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", timezone="Africa/Nairobi")
self.e.put()
self.owner = User.Create(self.e, phone=OWNER_NUM, notify=False)
self.owner.Update(name=OWNER_NAME, currency="KES")
self.owner.put()
self.tracker = SensorType.Create(self.e)
schema = {
'bearing': {
'unit': 'deg'
},
'location': {
'unit': 'deg',
'label': "Location",
'role': [COLUMN.LOCATION],
'type': 'latlng'
}
}
self.tracker.Update(name="Geo Sensor", schema=json.dumps(schema))
self.tracker.put()
self.vehicle_1 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.tracker.key().id())
self.vehicle_1.Update(sensortype_id=self.tracker.key().id(),
name="Vehicle Sensor 1",
contacts={"owner": self.owner.key().id()})
self.vehicle_1.put()
def put_sql(name, value):
"""Connect to sql and put in values."""
session = Session()
sensor = session.query(Sensor).filter(Sensor.name == name).first()
print(sensor)
if sensor:
"""Make timesensor post."""
time_data = SensorTimeData(data=value)
sensor.timedata = sensor.timedata + [time_data]
session.add(time_data)
sensor.value = value
session.add(sensor)
else:
sensor = Sensor(name=name, value=value)
session.add(sensor)
session.commit()
session.close()
def init(db):
try:
db.session.query(SensorType).delete()
db.session.query(Device).delete()
db.session.query(Sensor).delete()
db.session.query(Contact).delete()
db.session.query(Relay).delete()
except:
pass
st_t = SensorType(unit=u'°C',
description=u'Temperatura',
name='temperature')
st_h = SensorType(unit=u'%', description=u'Vlažnost', name='humidity')
st_b = SensorType(unit=u'V', description=u'Baterija', name='battery')
d_zg = Device(description='Zgoraj')
d_sp = Device(description='Spodaj')
zgt = Sensor(sensor_code='ZGT',
description='Temperatura (zgoraj)',
max_possible_value=40,
max_warning_value=33,
min_possible_value=-10,
min_warning_value=20,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=True,
device=d_zg,
type=st_t,
emit_every=5)
zgb = Sensor(sensor_code='ZGB',
description='Baterija (zgoraj)',
max_possible_value=6,
min_possible_value=0,
min_warning_value=3.3,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=True,
device=d_zg,
type=st_b,
emit_every=10)
spb = Sensor(sensor_code='SPB',
description='Baterija (spodaj)',
max_possible_value=6,
min_possible_value=0,
min_warning_value=3.3,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=True,
device=d_sp,
type=st_b,
emit_every=10)
spt = Sensor(sensor_code='SPT',
description='Temperatura (spodaj)',
max_possible_value=40,
max_warning_value=34,
min_possible_value=-10,
min_warning_value=20,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=True,
device=d_sp,
type=st_t,
emit_every=5)
zgh = Sensor(sensor_code='ZGH',
description=u'Vlažnost (zgoraj)',
max_possible_value=100,
max_warning_value=90,
min_possible_value=0,
min_warning_value=10,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=False,
device=d_zg,
type=st_h,
emit_every=5)
sph = Sensor(sensor_code='SPH',
description=u'Vlažnost (spodaj)',
max_possible_value=100,
max_warning_value=90,
min_possible_value=0,
min_warning_value=10,
observable_measurements=3,
observable_alarming_measurements=2,
enable_warnings=False,
device=d_sp,
type=st_h,
emit_every=5)
c = Contact(name='Admin', phone='+123456789', email='admin')
user = User(email='admin')
user.password = '******'
user.ping()
for l in ['A', 'B']:
for i in range(8):
code = '%s%d' % (l, i)
description = 'Rele %s' % code
db.session.add(
Relay(description=description,
switch_on_text='ON',
switch_off_text='OFF'))
db.session.add(zgt)
db.session.add(spt)
db.session.add(zgh)
db.session.add(sph)
db.session.add(spb)
db.session.add(zgb)
db.session.add(c)
db.session.add(user)
db.session.commit()
from external_db import get_all
from models import Sensor, Reading, User, save_external_db_record
# Copy database to local database
readings = get_all()
for reading in readings:
save_external_db_record(reading)
# Grant sudo user all sensors
sensors = Sensor.get()
sudo = User.find("sudo")
for sensor in sensors:
sudo.grant_sensor_access(sensor)
def env_live_01():
session.add_all([
User(name="Administrator", role=ROLE_ADMIN, access_code="1234"),
User(name="Chuck.Norris", role=ROLE_USER, access_code="1111"),
])
print(" - Created users")
z1 = Zone(name="No delay", description="Alert with no delay")
z2 = Zone(name="Away delayed",
away_alert_delay=20,
description="Alert delayed when armed AWAY")
z3 = Zone(name="Stay delayed",
stay_alert_delay=20,
description="Alert delayed when armed STAY")
z4 = Zone(name="Stay",
stay_alert_delay=None,
description="No alert when armed STAY")
z5 = Zone(name="Away/Stay delayed",
away_alert_delay=40,
stay_alert_delay=20,
description="Alert delayed when armed AWAY/STAY")
z6 = Zone(name="Tamper",
disarmed_delay=0,
away_alert_delay=None,
stay_alert_delay=None,
description="Sabotage alert")
session.add_all([z1, z2, z3, z4, z5, z6])
print(" - Created zones")
session.add_all(SENSOR_TYPES)
print(" - Created sensor types")
s1 = Sensor(channel=0,
sensor_type=SENSOR_TYPES[0],
zone=z5,
description="Garage")
s2 = Sensor(channel=1,
sensor_type=SENSOR_TYPES[0],
zone=z5,
description="Hall")
s3 = Sensor(channel=2,
sensor_type=SENSOR_TYPES[2],
zone=z5,
description="Front door")
s4 = Sensor(channel=3,
sensor_type=SENSOR_TYPES[0],
zone=z3,
description="Kitchen")
s5 = Sensor(channel=4,
sensor_type=SENSOR_TYPES[0],
zone=z1,
description="Living room")
s6 = Sensor(channel=5,
sensor_type=SENSOR_TYPES[0],
zone=z4,
description="Children's room")
s7 = Sensor(channel=6,
sensor_type=SENSOR_TYPES[0],
zone=z4,
description="Bedroom")
s8 = Sensor(channel=7,
sensor_type=SENSOR_TYPES[1],
zone=z6,
description="Tamper")
session.add_all([s1, s2, s3, s4, s5, s6, s7, s8])
print(" - Created sensors")
kt1 = KeypadType(1, "DSC", "DSC keybus (DSC PC-1555RKZ)")
session.add_all([kt1])
print(" - Created keypad types")
k1 = Keypad(keypad_type=kt1)
session.add_all([k1])
print(" - Created keypads")
session.commit()
def create_sensor():
sensor = request.get_json()
sos_res = Sensor().create(sensor)
response = make_response(sos_res.text, sos_res.status_code)
response.headers['Content-Type'] = 'application/json; charset=utf-8'
return response
def testStateUpdates(self):
self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db
self.geosensor1.update_state(COLUMN.LOCATION, NBO_LOC)
self.assertEqual(self.geosensor1.location, db.GeoPt(NBO_LOC))
from models import User, Sensor, Reading
from time import sleep
from datetime import datetime, timedelta
import random
sensors = {
"Termometer (mock)": ("Celsius", "Temperature"),
"Hygrometer (mock)": ("%", "Humidity"),
"Manometer (mock)": ("bar", "Pressure")
}
users = ["John", "Alex", "Rob", "Matt"]
for sensor_name, (unit, quantity) in sensors.items():
Sensor.create(sensor_name, quantity)
# For the sake of tests
for sensor_name, (unit, quantity) in sensors.items():
for i in range(120, 180, 1):
t = datetime(2020, 11, 26, 17, i % 60, 0)
Reading.create(str(random.randint(20, 27)),
unit,
Sensor.find(sensor_name).id,
timestamp=t)
# Let's have 4 readings per hour
start_date = datetime.utcnow() - timedelta(days=4)
now = datetime.utcnow()
sampling_interval = timedelta(minutes=15)
for sensor_name, (unit, quantity) in sensors.items():
sample_date = start_date
def create_update_sensor(message, address, signal_strength):
try:
current_time = datetime.datetime.now().replace(microsecond=0)
name = message[0]
float = True if message[1] == 'UP' else False
trip_time = current_time if float else None
battery = int(message[2]) / 10
temperature = int(message[3]) / 10
# delete the sensor if there is data when the same sensor name but different address
sensor = Sensor.query.filter(Sensor.name == name,
Sensor.address != address).first()
if sensor:
db.session.delete(sensor)
db.session.commit()
sensor = Sensor.query.filter_by(address=address).first()
if not sensor:
# does not exist, create one
land = Land.query.filter_by(number=1).first()
sensor = Sensor(name=name,
battery=battery,
float=float,
temperature=temperature,
signal_strength=signal_strength,
land_id=land.id,
address=address,
last_update=current_time,
trip_time=trip_time)
db.session.add(sensor)
db.session.commit()
# add sensor configs for each config page
config_pages = Config.query.all()
for config_page in config_pages:
sensor_config = SensorConfig(sensor_id=sensor.id,
config_id=config_page.id)
db.session.add(sensor_config)
else:
# exists, update the name and the date
sensor.name = name
sensor.status = True
sensor.float = float
sensor.trip_time = trip_time
sensor.battery = battery
sensor.temperature = temperature
sensor.signal_strength = signal_strength
sensor.last_update = current_time
db.session.commit()
return {
'id': sensor.id,
'name': name,
'last_update': str(current_time),
'battery': battery,
'float': float,
'temperature': temperature,
'signal_strength': signal_strength
}, sensor
except Exception as e:
print(e)
print("INVALID DATA FROM SENSORS")
def testStateUpdates(self):
self.geosensor1 = Sensor.get(self.geosensor1.key()) # Refetch from db
self.geosensor1.update_state(COLUMN.LOCATION, NBO_LOC)
self.assertEqual(self.geosensor1.location, db.GeoPt(NBO_LOC))
def testGeoRadiusAlarm(self):
# Create in radius alarm
self.in_radius_alarm = Rule.Create(self.e)
self.in_radius_alarm.Update(
name="In Town",
sensortype_id=self.tracker.key().id(),
column="location",
trigger=RULE.GEORADIUS_IN,
value2=RADIUS, # m
value_complex=json.dumps(RADIUS_CENTER),
alert_contacts=["owner"],
consecutive_limit=RULE.DISABLED,
duration=0)
self.in_radius_alarm.put()
self.process = ProcessTask.Create(self.e)
self.process.Update(rule_ids=[self.in_radius_alarm.key().id()])
self.process.put()
self.vehicle_2 = Sensor.Create(self.e, TEST_SENSOR_ID,
self.tracker.key().id())
self.vehicle_2.Update(name="Vehicle Sensor 2")
# Apply our process to our sensor
self.sp = SensorProcessTask.Create(self.e, self.process,
self.vehicle_2)
self.sp.put()
INTERVAL_SECS = 4
test_data_start = datetime.now() - timedelta(minutes=20)
# Process first data points entering radius
BATCH_1 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in ENTERS_RADIUS]
}
last_record = self.__createNewRecords(BATCH_1,
first_dt=test_data_start,
interval_secs=INTERVAL_SECS)
self.__runProcessing()
# Confirm in-radius alarm fired upon datapoint 4...
alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
# Process second batch of data points exiting radius
BATCH_2 = {
'location':
["%s,%s" % (coord[0], coord[1]) for coord in EXITS_RADIUS]
}
self.__createNewRecords(BATCH_2, interval_secs=INTERVAL_SECS)
self.__runProcessing()
# Confirm we still just have the single alarm record
alarms = Alarm.Fetch(self.vehicle_2, self.in_radius_alarm)
self.assertEqual(len(alarms), 1)
a = alarms[0]
duration_td = a.duration()
self.assertIsNotNone(duration_td)
# 3 datapoints in radius
print a.json()
