def register_device():
form = DeviceRegistrationForm()
if form.validate_on_submit():
if form.photo.data == None:
# photo_name = ''
device = Device(deviceId=form.deviceId.data,
devicename=form.devicename.data,
name=form.name.data, dept_code=form.dept_code.data,
device_function=form.device_function.data,
device_bg=form.device_bg.data)
else:
photo_name = photos.save(form.photo.data)
# file_url = photos.url(photo_name)
device = Device(deviceId=form.deviceId.data,
devicename=form.devicename.data,
name=form.name.data, dept_code=form.dept_code.data,
device_function=form.device_function.data,
device_bg=form.device_bg.data, photo=photo_name)
db.session.add(device)
db.session.commit()
flash('Congratulations, your Nameplate is in the system!\nThe URL of your nameplate: /device/'+str(form.deviceId.data))
new_device_info = Device.query.filter_by(deviceId=form.deviceId.data).first_or_404()
# bg_pic=background_dictionary[deviceId.device_bg]
return render_template('new_device.html', deviceId=new_device_info)
return render_template('register_device.html', title='Add New Device', form=form)
def test_duplicate_name(self):
d1 = Device(name='d1')
d2 = Device(name='d2')
db.session.add(d1)
db.session.add(d2)
db.session.commit()
self.assertTrue(d2.name == 'd2')
def test_add_device(self):
p = Project(name="project1", path="path/project1")
db.session.add(p)
db.session.commit()
d1 = Device(adb_sn="sn_1",
constructor="constructeur1",
model="model1",
imei="imei1",
status="Not Configured")
d2 = Device(adb_sn="sn_2",
constructor="constructeur2",
model="model2",
imei="imei2",
status="Not Configured")
db.session.add(d1)
db.session.add(d2)
db.session.commit()
p.add_device([d1, d2])
db.session.commit()
self.assertEqual(p.devices.count(), 2)
p.delete_device(d2)
db.session.commit()
self.assertEqual(p.devices.count(), 1)
def test_insert(self):
# empty
exists = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNone(exists)
# new device
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
exists = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNotNone(exists)
# not all required attributes
device = Device(id='dev_id_wrong', device_class='PSI')
self.assertRaises(OperationalError, self.DM.insert, device, Device)
def create_device():
print(request.json)
sn = request.json.get('sn')
name = request.json.get('name')
img = request.json.get('img')
type = request.json.get('type')
device = Device(sn=sn,name=name,img=img,type=type,)
static_folder = current_app.config['STATIC_FOLDER']
user_dir = os.path.join(static_folder, 'user_folder', f"{g.current_user.uid}")
tmp_file_path = os.path.join(user_dir, img)
if not os.path.exists(tmp_file_path):
return jsonify({'success':False,'error_code':-1,'errmsg':f'文件{tmp_file_path}不存在'})
db.session.add(device)
try:
db.session.commit()
dst_dir = os.path.join(static_folder, 'deviceimg', f"{device.id}")
dst_file_path = os.path.join(dst_dir, img)
os.makedirs(dst_dir,exist_ok=True)
shutil.move(tmp_file_path,dst_file_path)
shutil.rmtree(user_dir)
except Exception as e:
db.session.rollback()
logging.error(f'添加数据库发生错误,已经回退:{e}')
return jsonify({'success': False, 'error_code': -123, 'errmsg': '数据库插入错误，请查看日志'})
return jsonify({'success':True,
'error_code':0,
})
def import_devices():
# We don't have the 'original' ddb with emails so we create a single user who takes it all
user = User(email="*****@*****.**")
user.set_password("topsecret")
db.session.add(user)
with open(os.path.join(basepath, "ressources/ddb.txt")) as csvfile:
csvreader = csv.DictReader(csvfile, delimiter=",", quotechar="'")
for row in csvreader:
device_type = {"F": DeviceType.FLARM, "I": DeviceType.ICAO, "O": DeviceType.OGN}[row["#DEVICE_TYPE"]]
address = row["DEVICE_ID"]
aircraft_type_name = row["AIRCRAFT_MODEL"]
registration = row["REGISTRATION"]
cn = row["CN"]
show_track = row["TRACKED"] == "Y"
show_identity = row["IDENTIFIED"] == "Y"
aircraft_category = AircraftCategory.coerce(row["AIRCRAFT_TYPE"])
aircraft_type = AircraftType.query.filter_by(name=aircraft_type_name).one_or_none()
if not aircraft_type:
aircraft_type = AircraftType(name=aircraft_type_name, category=aircraft_category)
Device(device_type=device_type, aircraft_type=aircraft_type, address=address, registration=registration, cn=cn, show_track=show_track, show_identity=show_identity, user=user)
db.session.commit()
def sync():
'''Showing all logger'''
url = "https://prinus.net/api/sensor"
username = os.environ['PRINUS_USER']
password = os.environ['PRINUS_PASS']
response = requests.get(url, auth=(username, password))
devices = Device.query.all()
raw = response.json()
sn_list = [key['sn'] for key in raw]
for dev in devices:
if dev.sn in sn_list:
sn_list.remove(dev.sn)
# update device and lokasi in pbase, and
# send new device and lokasi to pweb
for sn in sn_list:
# update device
device = Device(sn=f"{sn}")
db.session.add(device)
db.session.commit()
# send post data
try:
post_url = f"{os.environ['PWEB_URL']}/api/device"
post_data = {'sn': f"{sn}", 'id': device.id}
res = requests.post(post_url, data=post_data)
result = res.json()
print(result)
except Exception as e:
print(e)
return redirect(url_for('logger.index'))
def handle_mqtt_message(client, userdata, message):
app.logger.info(message.topic + ' ' + message.payload.decode())
match = hydro_json_re.match(message.topic)
if match:
name = match.group(1)
data = json.loads(message.payload.decode())
dev = Device.query.filter_by(name=name).first()
if not dev:
dev = Device(name=name)
db.session.add(dev)
db.session.commit()
log = Log(
device=dev.id,
session=dev.cur_session,
bat_v=data['bat_v'],
temp_f=data['temp_f'],
light_vis=data['light_vis'],
light_ir=data['light_ir'],
light_uv=data['light_uv'],
accel_x=data['accel_x'],
accel_y=data['accel_y'],
accel_z=data['accel_z'],
tilt=data['tilt'],
wifi_conn_fail=data['wifi_conn_fail'],
mqtt_conn_fail=data['mqtt_conn_fail'],
last_run_time=data['last_run_time']
)
db.session.add(log)
db.session.commit()
def device_register(request):
success = False
message = ''
try:
name = request.POST.get('name', None)
device_type = request.POST.get('device_type', None)
address = request.POST.get('address', None)
install_date = request.POST.get('install_date', None)
install_time = request.POST.get('install_time', None)
latitude = request.POST.get('latitude', None)
longitude = request.POST.get('longitude', None)
project_id = request.POST.get('project_id', None)
owner_id = request.POST.get('owner_id', None)
device_type_obj = DeviceType.objects.get(id=int(device_type))
project_id_obj = Project.objects.get(id=int(project_id))
owner_id_obj = User.objects.get(id=int(owner_id))
device = Device(name=name,
device_type=device_type_obj,
address=address,
install_date=install_date,
install_time=install_time,
latitude=latitude,
longitude=longitude,
project_id=project_id_obj,
owner_id=owner_id_obj)
device.save()
success = True
except e:
message = str(e)
print(str(e))
res = {'success': success, 'message': message}
response = HttpResponse(json.dumps(res), content_type="application/json")
return response
def post(self):
"""
Add sensor
"""
data = request.json
if len(Device.search().query(
'term', **{
'mqtt_account.username': data['mqtt_account']['username']
}).execute()) != 0:
abort(400, error='MQTT username already exist.')
sensor = Device(device_type='sensor',
pos_x=data['pos_x'],
pos_y=data['pos_y'],
radius=data['radius'])
sensor.hash_key(data['key'])
data['mqtt_account']['clients_topic'] = 'bluetooth/sensor/' + data[
'mqtt_account']['username'] + '/from_clients'
data['mqtt_account']['device_topic'] = 'bluetooth/sensor/' + data[
'mqtt_account']['username'] + '/from_device'
sensor.set_mqtt_account(data['mqtt_account'])
sensor.meta.id = 'sensor_' + str(Device.search().count() + 1)
sensor.save()
return sensor.to_dict(include_id=True), 201
def test_save_value(self):
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
self.DM._store_permanent()
# empty
exists = Value.query.filter_by(id='dev_id_23').first()
self.assertIsNone(exists)
# new value
value = Value(id=1,
time=now(),
value=23,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None)
self.DM.save_value(value)
result = Value.query.filter_by(var_id='od').first()
self.assertEqual(result, value)
# new value with non-existing variable
value = Value(id=2,
time=now(),
value=32,
dev_id='dev_id_23',
var_id='new_var',
attribute=1,
note=None)
self.DM.save_value(value)
result = Value.query.filter_by(var_id='new_var').first()
self.assertEqual(result, value)
# check variables
self.assertIn('new_var', set(self.DM.load_variables()))
def create_device(id):
if g.current_user.id != id:
abort(403)
user = User.query.get_or_404(id)
devices = Device.query.all()
data = request.get_json() or {}
if 'name' not in data or 'device_type' not in data:
return bad_request('must include name and device_type fields')
#TODO:Find a way to get specific users devices and check for reoccuring names
for i in devices:
if g.current_user == i.owner:
if i.name == data['name']:
return bad_request('Please choose a different name')
#Sets owner for device
device = Device(owner=User.query.get(id))
device.date_reg = datetime.utcnow()
#TODO: Set comments for certain device types
device.comment = 'NA'
device.from_dict(data, new_device=True)
db.session.add(device)
db.session.commit()
response = jsonify(device.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_device', id=user.id)
return response
def add_device():
form = AddDeviceForm()
if form.validate_on_submit():
address = form.address.data.upper()
device = Device.query.filter_by(address=address).one_or_none()
if device is None:
device = Device(address=address, user=current_user)
db.session.commit()
return redirect(url_for("main.edit_device", device_id=device.id))
else:
if device.user == current_user:
flash(_("You already own this device"), category="warning")
return redirect(url_for("main.my_devices"))
else:
device_claim = DeviceClaim.query.\
filter_by(device_id=device.id).\
filter_by(claimer=current_user).one_or_none()
if device_claim is None:
flash(_("This device is used by another user"),
category="danger")
return redirect(
url_for("main.claim_device", device_id=device.id))
else:
flash(
_("This device is used by another user, but you already opened a claim"
))
return redirect(url_for("main.my_devices"))
return render_template("form_generator.html",
title=_("Add Device"),
form=form)
def post(self):
image = request.json.get('image')
device_id = request.json.get('device_id')
if image and device_id:
try:
query = ocr_image(device_id, image)
if not query:
return {'success': False, 'error': 'no text found'}
text = convert(query)
if device_exist(device_id):
device = Device.query.filter_by(name=device_id).first()
device.update(text)
else:
device = Device(name=device_id, text=text)
device.save()
send_to_device(device_id, device.page())
return {'success': True}
except:
return {
'success': False,
'error': 'an error has occurred'
}, 500
else:
return {
'success': False,
'error': "'query' or 'device_id' not found"
}, 400
def test_user_device_relationship(self):
user = User()
device = Device()
user.followed_devices.append(device)
self.assertTrue(user in device.following_users)
self.assertTrue(device in user.followed_devices)
def build(self) -> Device:
device = Device(Id=self._id,
Name=self._name,
CallClass=self._callClass,
Parameters=self._parameters)
device.save()
for function in self._functions:
function.save()
device.Functions.add(function)
return device
def test_coprimarykey(self):
u1 = User(email='*****@*****.**', password='******')
u2 = User(email='*****@*****.**', password='******')
db.session.add(u1)
db.session.add(u2)
d1 = Device(name='d1')
d1.users.append(u1)
d1.users.append(u2)
db.session.add(d1)
db.session.commit()
self.assertTrue(d1.users[1].email == '*****@*****.**')
def get_device_claim(self):
owner = User(email='klaus@localhost')
claimer = User(email='kurt@localhost')
device = Device(user=owner, address='DD1234')
device_claim = DeviceClaim(device=device, owner=owner, claimer=claimer)
db.session.add(device_claim)
db.session.commit()
self.assertTrue(device_claim.is_approved is None)
self.assertEqual(device.user, owner)
return device_claim
def add_device():
"""Add device to database
"""
json_obj = json.loads(request.form.get('form_json'))
if Device.query\
.filter_by(designation=json_obj['designation']).first():
flash('please use a different designation')
else:
dev = Device()
if dev.db_check(json_obj):
flash('Added device {0}'.format(json_obj['designation']))
return redirect(url_for('main.get_device_list'))
def device_save_project():
# 设备新增专题
device_code = request.json.get('device_code')
project_id = request.json.get('project_id')
Project.query.get_or_404(project_id)
device = Device.query.filter_by(device_code=device_code).first()
if not device:
device = Device(device_code=device_code, project_id=project_id)
if device.project_id == 0:
device.project_id = project_id
device.save()
return api_success(device.to_dict())
def add_device():
form = AddDevice()
if form.validate_on_submit():
device = Device()
device.name = form.name.data
device.about = form.about.data
device.location = form.location.data
device.user_id = current_user.id
db.session.add(device)
db.session.commit()
return redirect(url_for('main.devices'))
return render_template('main/add_device.html', form=form)
def register_device():
form = DeviceRegistrationForm()
if form.validate_on_submit():
device = Device(deviceId=form.deviceId.data, devicename=form.devicename.data, name=form.name.data, dept_code=form.dept_code.data, device_function=form.device_function.data,device_bg=form.device_bg.data)
db.session.add(device)
db.session.commit()
flash('Congratulations, your device is in the system!\nThe URL your device is localhost:5000/device/'+str(form.deviceId.data))
new_device_info = Device.query.filter_by(deviceId=form.deviceId.data).first_or_404()
bg_pic=background_dictionary[deviceId.device_bg]
return render_template('new_device.html', deviceId=new_device_info, bg_pic=bg_pic)
return render_template('register_device.html', title='Add New Device', form=form)
def import_fakedata():
a1 = AircraftType(name="ASK-13", category=AircraftCategory.SAILPLANE)
a2 = AircraftType(name="ASH-25", category=AircraftCategory.SAILPLANE)
a3 = AircraftType(name="Rhönlärche Ил-32", category=AircraftCategory.SAILPLANE)
a4 = AircraftType(name="Aquila A210", category=AircraftCategory.PLANE)
a5 = AircraftType(name="Concorde", category=AircraftCategory.PLANE)
a6 = AircraftType(name="Eurofox", category=AircraftCategory.ULTRALIGHT)
a7 = AircraftType(name="Gyrocopter", category=AircraftCategory.ULTRALIGHT)
a8 = AircraftType(name="EC 120", category=AircraftCategory.HELICOPTER)
a9 = AircraftType(name="EC 130", category=AircraftCategory.HELICOPTER)
a10 = AircraftType(name="EC 135", category=AircraftCategory.HELICOPTER)
a11 = AircraftType(name="DJI S800", category=AircraftCategory.DRONE)
a12 = AircraftType(name="DJI S900", category=AircraftCategory.DRONE)
a13 = AircraftType(name="DJI S1000", category=AircraftCategory.DRONE)
a14 = AircraftType(name="Balloon", category=AircraftCategory.OTHER)
a15 = AircraftType(name="Paraglider", category=AircraftCategory.OTHER)
a16 = AircraftType(name="UFO", category=AircraftCategory.OTHER)
db.session.add_all([a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16])
u1 = User(email="user1@localhost")
u1.set_password("topsecret1")
Device(address="DD1234", device_type=DeviceType.FLARM, aircraft_type=a1, registration="D-1234", cn="34", user=u1)
Device(address="DD4711", device_type=DeviceType.FLARM, aircraft_type=a2, registration="D-4711", cn="11", user=u1)
u2 = User(email="user2@localhost")
u2.set_password("topsecret2")
Device(address="ABCDEF", device_type=DeviceType.OGN, aircraft_type=a3, registration="D-OTTO", cn="TO", user=u2)
Receiver(name="Koenigsdf", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.TERRA_AB010, rx_filter=RxFilter.CAVITY, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Wank", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.NONE, rx_filter=RxFilter.CBP840, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Arber", antenna=Antenna.WIMO_SPERRTOPF, preamplifier=Preamplifier.NONE, rx_filter=RxFilter.CAVITY, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
Receiver(name="Marmolada", antenna=Antenna.CHINESE_9DB_JPOLE, preamplifier=Preamplifier.SELF_BUILT_WITH_FILTER, rx_filter=RxFilter.NONE, sdr_dongle=SdrDongle.RTLSDR_COM, user=u1)
db.session.add(u1)
db.session.add(u2)
db.session.commit()
def add_device():
id = request.args.get('id')
form = DeviceForm()
if form.validate_on_submit():
device = Device()
device.name = form.name.data
device.describe = form.describe.data
device.location = form.location.data
device.user_id = id
db.session.add(device)
db.session.commit()
return redirect(url_for('main.all_devices', id=id))
return render_template('main/add_device.html', form=form)
def add_shebei():
form = SheBeiFrom()
if form.validate_on_submit():
device = Device()
device.name = form.device_name.data
device.describe = form.device_description.data
device.location = form.device_address.data
device.user_id = current_user.id
db.session.add(device)
db.session.commit()
return redirect(url_for('auth.shebei'))
return render_template('equipment/add-shebei.html', form=form)
def register():
data = request.get_json()
temp_device = db.session.query(Device).filter(
Device.devicename == data['name'])
if (temp_device.count() > 0):
temp_device.first().ipaddress = data['ipaddr']
temp_device.first().updatetime = datetime.datetime.utcnow()
db.session.commit()
return "Updated Device"
d = Device(devicename=data['name'], ipaddress=data['ipaddr'])
db.session.add(d)
db.session.commit()
return "Added New Device"
def test_update(self):
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
dev_from_DB = Device.query.filter_by(id='dev_id_23').first()
self.assertIsNone(dev_from_DB.address)
# get rid of objects in the session
db.session.remove()
device.address = "home"
self.DM.update(device)
dev_from_DB = Device.query.filter_by(id='dev_id_23').first()
self.assertEqual(dev_from_DB.address, "home")
def post(self):
# receive (from app): (query, device_id)
# service:
# check for strange chars in text
# if not strange:
# save text in Device object(device_id)
# send request with page 1 to device
# respond to app: success
# else respond to app: fail
query = request.json.get('query')
device_id = request.json.get('device_id')
if query and device_id:
# todo: check strange text
try:
text = convert(query) # convert to braille data
# save to device
if device_exist(device_id):
device = Device.query.filter_by(name=device_id).first()
device.update(text)
else:
device = Device(name=device_id, text=text)
device.save()
# todo: send request to device with device_id
# request to device: device.page()
send_to_device(device_id, device.page())
# ***** failed *****
# msg = json.dumps(device.page())
# try:
# iothub_messaging = IoTHubMessaging(connection_string)
# iothub_messaging.open(open_complete_callback, 0)
# message = IoTHubMessage(bytearray(msg, 'utf8'))
# iothub_messaging.send_async(device_id, message, send_complete_callback, 1)
# except IoTHubError as iothub_error:
# print("Unexpected error {0}" % iothub_error)
return {'success': True}
except:
return {
'success': False,
'error': 'an error has occurred'
}, 500
else:
return {
'success': False,
'error': "'query' or 'device_id' not found"
}, 400
def test_get_latest_data(self):
# preparations
device = Device(id='dev_id_23', device_class='PSI', device_type='PBR')
self.DM.insert(device, Device)
self.DM._store_permanent()
# store some values
values = [
Value(id=1,
time=now(),
value=23.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=2,
time=now(),
value=24.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=3,
time=now(),
value=25.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=4,
time=now(),
value=26.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None),
Value(id=5,
time=now(),
value=27.0,
dev_id='dev_id_23',
var_id='od',
attribute=1,
note=None)
]
for value in values:
self.DM.save_value(value)
# get last value
result = self.DM.get_latest_data(device.id, 'values')
self.assertEqual(values[4], result)
def fetch_logger():
res = requests.get(URL, auth=bws_sul1)
if res.status_code == 200:
logger = json.loads(res.text)
local_logger = [d.sn for d in Device.query.all()]
if len(local_logger) != len(logger):
for l in logger:
if l.get('sn') not in local_logger:
new_logger = Device(sn=l.get('sn'))
db.session.add(new_logger)
db.session.commit()
print('Tambah:', new_logger.sn)
else:
print(res.status_code)
