def delete(self, sensortype_id): sensortype = SensorType.query.filter_by(id = sensortype_id).first() if sensortype: SensorType.delete(id = sensortype.id) return jsonify(ApiObjects(sensortype.json())) else: return jsonify(ApiObjects())
def seed_nodetypes(): try: SensorType.create(name = 'battery voltage', unit = 'mV') SensorType.create(name = 'solar voltage', unit = 'mV') SensorType.create(name = 'DHT11 temperature', unit = 'C') SensorType.create(name = 'DHT11 humidity', unit = '%') SensorType.create(name = 'HC SR-04', unit = 'cm') except IntegrityError: db.session.rollback() return 'Seems like the sensortypes have already been created. Session has been rolled back'
def insertSensorType(code, description=None):
"""Insert SensorType or update if already existing"""
sensorType = session.query(SensorType).filter_by(code=code).first()
if sensorType is None:
sensorType = SensorType(code=code, description=description)
session.add(SensorType)
session.commit()
else:
sensorType.description = description
session.commit()
session.rollback()
def post(self):
parser = reqparse.RequestParser(bundle_errors = True)
parser.add_argument('name', type=str, location='form', required=True, help='<str> name required')
parser.add_argument('unit', type=str, location='form', required=True, help='<str> unit required')
args = parser.parse_args()
sensortype = SensorType.create(name = args['name'], unit = args['unit'])
return jsonify(ApiObjects(sensortype.json()))
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 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()
self.init_modules_stub()
# Create enterprise, sensortype and sensor
self.e = Enterprise.Create()
self.e.Update(name="Test Ent", alias=E_ALIAS.upper())
self.e.put()
self.u = User.Create(self.e, phone=TEST_NUM, email=TEST_EMAIL)
self.u.Update(password=PW, level=USER.ACCOUNT_ADMIN)
self.u.put()
self.st = SensorType.Create(self.e)
self.st.Update(alias="geo",
schema=json.dumps({'location': {
'type': 'location'
}}))
self.st.put()
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 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 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 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 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()
#!/usr/bin/env python
import argparse
from sqlalchemy.exc import ProgrammingError
from monitoring.constants import ROLE_ADMIN, ROLE_USER
from models import Keypad, KeypadType, Sensor, SensorType, User, Zone
from monitoring.database import Session
from models import metadata
SENSOR_TYPES = [
SensorType(1, name="Motion", description="Detect motion"),
SensorType(2, name="Tamper", description="Detect sabotage"),
SensorType(3, name="Open", description="Detect opening"),
SensorType(4, name="Break", description="Detect glass break"),
]
session = Session()
def cleanup():
print("Clean up database...")
for table in reversed(metadata.sorted_tables):
print(" - Clear table %s" % table)
try:
session.execute(table.delete())
session.commit()
except ProgrammingError:
session.rollback()
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()
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.tracker = SensorType.Create(self.e)
schema = {
'speed': {
'unit': 'kph'
},
'ign_on': {
'unit': 'boolean'
},
'ign_off': {
'unit': 'boolean'
}
}
self.tracker.Update(name="Tracker 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"
)
self.vehicle_1.put()
# Create alarm
self.ign_on_alarm = Rule.Create(self.e)
self.ign_on_alarm.Update(
name="Ignition On",
sensortype_id=self.tracker.key().id(),
column="ign_on",
trigger=RULE.CEILING,
value2=0,
consecutive_limit=-1,
duration=0)
self.ign_on_alarm.put()
self.ign_off_alarm = Rule.Create(self.e)
self.ign_off_alarm.Update(
name="Ignition Off",
sensortype_id=self.tracker.key().id(),
column="ign_off",
trigger=RULE.CEILING,
value2=0,
consecutive_limit=-1,
duration=0,
spec=json.dumps({'processers': [
{
'analysis_key_pattern': ANALYSIS_KEY_PATTERN,
'expr': '. + SINCE(LAST_ALARM(%d)) / 1000' % self.ign_on_alarm.key().id(),
'column': 'on_secs'
}
]}))
self.ign_off_alarm.put()
