def check_new_issue():
req = requests.get(url='http://www.themagpi.com/mps_api/mps-api-v1.php?mode=list_issues')
json_issues = json.loads(req.text)
last_issue = json_issues['data'][0]
gcm = GCM(app_keys['gcm'])
data = {}
data['id'] = last_issue['title']
data['editorial'] = last_issue['editorial'].encode('utf8')
data['title'] = last_issue['title']
data['link'] = last_issue['pdf']
data['image'] = last_issue['cover']
data['date'] = last_issue['date']
devices, next_curs, more = Device.query().fetch_page(10)
while next_curs:
for device in devices:
try:
gcm.plaintext_request(registration_id=device.id_gcm, data=data)
except GCMNotRegisteredException:
pass
except GCMInvalidRegistrationException:
pass
except GCMUnavailableException:
pass
devices, next_curs, more = Device.query().fetch_page(10, start_cursor=next_curs)
return jsonify( { 'status' : 'success' } ) , 200
def get_device_info() -> Response:
"""
Return data about the target device
"""
token = request.headers.get('Token')
session = Session.find(token)
if session is None:
return make_response({
"error": "token does not exists"
})
device_id = request.form.get("id")
response = dict
if device_id:
device_list = [Device.get_by_id(device_id)]
else:
device_list = Device.get_by_owner(session.owner) # TODO check if .all() returns list, else fix to list
if not device_list:
return make_response({
"error": "no devices found"
})
for device in device_list:
if session.owner == device.owner:
response.update({device.id: device.as_private_simple_dict()})
else:
response.update({device.id: device.as_public_simple_dict()})
return make_response(response)
def test_send_message(self):
headers = {'Device-ID': 'BLABLA'}
# Without sending the data we expect a BadRequest response
response = self.client.post("/send", headers=headers)
self.assert400(response)
# Since the device isn't in the database we expect a 404
headers['Content-Type'] = 'application/json'
response = self.client.post("/send",
headers=headers,
data='{"message": "test"}')
self.assert404(response)
Device(device_id=headers['Device-ID'], receiver_id='TEST').save()
Device(device_id='TEST', receiver_id=headers['Device-ID']).save()
response = self.client.post("/send",
headers=headers,
data='{"message": "test"}')
self.assert200(response)
inserted_message = Device.objects(device_id='TEST').first().messages[0]
self.assertIsNotNone(inserted_message)
self.assertEqual(inserted_message.message, 'test')
headers.pop('Content-Type', None)
response = self.client.get('/ping',
headers={
'Firmware-Version': '1',
'Device-ID': 'TEST'
})
self.assert200(response)
try:
data = json.loads(response.data)
self.assertEqual(data['message'], 'test')
except ValueError:
self.assertTrue(False, 'No json is returned from the ping request')
def test_device_not_found(self):
response = self.client.get('/ping',
headers={
'Firmware-Version': '1',
'Device-ID': 'ABC'
})
self.assert404(response)
device = Device(device_id='ABC', receiver_id='CBA').save()
response = self.client.get('/ping',
headers={
'Firmware-Version': '1',
'Device-ID': device.device_id
})
self.assert200(response)
try:
data = json.loads(response.data)
self.assertFalse('message' in data)
except ValueError:
self.assertTrue(False, "The ping request didn't return json")
device.messages = [Message(message='This is a test')]
device.save()
response = self.client.get('/ping',
headers={
'Firmware-Version': '1',
'Device-ID': device.device_id
})
self.assert200(response)
try:
data = json.loads(response.data)
self.assertEqual(data['message'], 'This is a test')
except ValueError:
self.assertTrue(False, "The ping request didn't return json")
def post(self):
data = dict()
args = post_parser.parse_args()
try :
appVersion = AppVeriosn()
minv, recentv = appVersion.getLatestVersion()
deviceModel = Device()
device = deviceModel.getDeviceByDeviceId(args)
if args['token'] == device.token.token and datetime.now() < device.token.expiry:
fb_url = "https://graph.facebook.com/me?access_token="+device.token.fb_token+"&fields=id,email,first_name,last_name,name,gender"
res = requests.get(fb_url)
if res.status_code == 200 :
device.token.updateToken(device.token.id, False)
data['token'] = device.token.token
data['min'] = minv
data['recent'] = recentv
userModel = User()
user = userModel.getUserById({'id' : device.user_id})
user = sqlAlchemyObjToDict(user)
data.update(user)
else:
raise ErrorWithCode(401, 'Facebook access token is not valid.')
else:
raise ErrorWithCode(401, 'Token is invalid.')
return marshal(data, resource_fields), 200
except Exception, e:
data['message'] = str(e)
return data, e.code if hasattr(e, 'code') else 500
def validateToken(token):
deviceModel = Device()
device = deviceModel.getDevice({'token': token})
if device is None:
raise ValueError("This is an invalid token.")
data = dict()
data['device'] = device
return data
def run(self):
self.register_routes()
self.database_connect()
# Fake data because of quick prototype :)
Device(device_id="test1234", receiver_id="test").save()
Device(device_id="test", receiver_id="test1234").save()
self.app.run(debug=True, host='0.0.0.0', port=8888)
return self.app
def handleBatteryUpdate(item):
device = Device.get_device(item['device_id'])
if not device:
device = Device(item['device_id'], item['recorded_at'])
db.session.add(device)
battery_status = item['data']['value']
recorded_at = item['recorded_at']
return device.update_battery_status(battery_status, recorded_at)
def patch_device(device_id):
assert(request.headers['Content-Type'] == 'application/json')
updated_device = request.json
f = Device().toFullDict()
g = copy(f)
for k in f:
if k in updated_device:
g[k] = updated_device[k]
print("updating ", device_id, " to ", g)
device = device_repo.patch_device(device_id, Device(**g))
return jsonify(device.toFullDict())
def update_account():
if (ReqAuthCommon.is_auth_ok(request) == False):
abort(401)
req_data = ReqDeviceCommon.is_patch_param_ok(request)
if (req_data == False):
return jsonify(
ErrResponse(0, CodeConstant.code_null_param,
AuthStrings.missing_param).__dict__)
device_id = req_data[DeviceConstant.device_id]
device = Device.objects(device_id=device_id).first()
if not device:
return jsonify(
ErrResponse(0, CodeConstant.code_no_data,
DeviceStrings.device_not_exist).__dict__)
device_name = device.device_name
if DeviceConstant.device_name in req_data:
device_name = req_data[DeviceConstant.device_name]
device_type = device.device_type
if DeviceConstant.device_type in req_data:
device_type = req_data[DeviceConstant.device_type]
online = device.online
if DeviceConstant.online in req_data:
online = req_data[DeviceConstant.online]
last_online = device.last_online
if DeviceConstant.last_online in req_data:
last_online = req_data[DeviceConstant.last_online]
user_id = device.user_id
if DeviceConstant.user_id in req_data:
user_id = req_data[DeviceConstant.user_id]
location = device.location
if DeviceConstant.location in req_data:
location = req_data[DeviceConstant.location]
device.update(device_name=device_name,\
device_type=device_type,\
online=online,\
last_online=last_online,\
user_id=user_id,\
update_time=time.mktime(datetime.now().timetuple()))
device = Device.objects(device_id=device_id).first()
response = JKResponse(1, device).__dict__
return jsonify(response)
def connect_device():
mac = request.form['scanned']
user = current_user
# add device into database if not added before
if not Device.objects(mac=mac).first():
device = Device(mac=mac, owner=User.objects(email=user.email).first())
device.save()
result = app.hub.connectDevice(mac)
return json.dumps({'success': result}), 200, {
'ContentType': 'application/json'
}
def computedevice(request):
"""HTTP Cloud Function.
Parameters:
request (flask.Request): The request object.
if in query string the x and y are present as valid coordinates it will process that point
otherwise if no args are passed in the query string it will process the standard points
(0,0), (100, 100), (15,10) and (18, 18).
<http://flask.pocoo.org/docs/1.0/api/#flask.Request>
Returns:
A json array compose by the strings:
“Best link station for point x,y is x,y with power z”
Or
“No link station within reach for point x,y”
"""
# All the print are logged automatically on stackdriver
x_args = request.args.get('x')
y_args = request.args.get('y')
if not x_args or not y_args:
print('the query string is not in the expected format or is empty', request)
devices_to_process = [
Device(0, 0),
Device(100, 100),
Device(15, 10),
Device(18, 18)
]
else:
try:
x = float(x_args)
y = float(y_args)
except ValueError as vError:
print('the x and y params inputs are not valid coordinates', vError)
return 'the X and Y inputs are not valid coordinates (float)'
else:
devices_to_process = [Device(x, y)]
results = []
for device_to_process in devices_to_process:
max_power, station_point = compute.process_suitable_link(
device_to_process)
if (max_power > 0):
result = f'Best link station for point {device_to_process.get_x()},{device_to_process.get_y()} is {station_point[0]},{station_point[1]} with power {max_power}'
else:
result = f'No link station within reach for point {device_to_process.get_x()},{device_to_process.get_y()}'
print(result)
results.append(result)
# flask.jsonify doesn't allow to serialize list
# https://github.com/pallets/flask/issues/170
return make_response(dumps(results))
def recover_interfaces_recycles(ids):
interfaces = Interface.objects(Q(id__in=ids) & Q(is_template=False))
interfaces.update(is_deleted=False) # 恢复接口自身
devices = [
device.id for device in interfaces.values_list('_parent_device')
]
equipments = [
equipment.id
for equipment in interfaces.values_list('_parent_equipment')
]
Device.objects(id__in=devices).update(is_deleted=False)
Equipment.objects(id__in=equipments).update(is_deleted=False)
return jsonify(ok=True, msg='success')
def get(self):
devices = Device.get_all_devices()
result = []
if devices:
for device in devices:
result.append(json.loads(device_schema.dumps(device)))
return result, 200
def update_device(id):
data = request.get_json()
device = Device.find_by_id(id)
if not device:
return {
'message':
f'No se encuentra el medidor con el ID [{id}] especificado'
}, 404
socketid = None
if 'socketid' in data:
socketid = data['socketid']
device.brand = data['brand']
device.model = data['model']
device.serial = data['serial']
device.socketid = socketid
try:
device.save_to_db()
except Exception:
return {
"message": "ocurrio un error en la actualización del medidor."
}, 500
return device.json(), 201
def get_devices():
form = SearchForm(request.args)
query = Device.objects(is_deleted=False, is_template=False)
if form.searchKey.data:
search_key = form.searchKey.data
query = query.filter(Q(name__contains=search_key) | Q(note__contains=search_key))
return build_order_by(query, form.orderBy.data), 200
if form.name.data:
query = query.filter(name__contains=form.name.data)
if form.note.data:
query = query.filter(note__contains=form.note.data)
if form.type.data:
query = query.filter(type=form.type.data)
if form.location.data:
query = query.filter(location=form.location.data)
if form.sn.data:
query = query.filter(sn=form.sn.data)
if form.manufacturer.data:
query = query.filter(manufacturer=form.manufacturer.data)
if form.system.data:
query = query.filter(system=form.system.data)
if form.createUserId.data:
query = query.filter(_create_user=form.createUserId.data)
if form.parentEquipmentId.data:
query = query.filter(_parent_equipment=form.parentEquipmentId.data)
if form.createdAtStart.data:
query = query.filter(created_at__gte=form.createdAt.data)
if form.createdAtEnd.data:
query = query.filter(created_at__lte=form.createdAtEnd.data)
current_user.update(inc__search_num=1)
return build_order_by(query, form.orderBy.data)
def test_device_100_100(self):
max_power, station_point = self.compute.process_suitable_link(
Device(100, 100))
self.assertEqual(
max_power,
0,
msg='there is not a most suitable link to device(100, 100)')
def get_child(oid):
device = Device.objects(id=oid).count()
if not device:
return jsonify(ok=True, msg='not found'), 404
child_interface = Interface.objects(_parent_device=oid).count()
child_cable = Cable.objects(Q(_start_device=oid) | Q(_end_device=oid)).count()
return jsonify(ok=True, msg={'interface': child_interface, 'cable': child_cable})
def delete_device() -> Response:
"""
Delete device by id
"""
token = request.headers.get('Token')
session = Session.find(token)
if session is None:
return make_response({
"error": "token does not exists"
})
device_id = request.form.get("id")
device = Device.get_by_id(device_id)
if device_id:
if session.owner != device.owner:
return make_response({
"error": "permission denied"
})
device.delete()
else:
return make_response({
"error": "id missing, or not existing"
})
return make_response({
# TODO response needed? Or is missing response allowed?
})
def modify_password():
if not ReqAuthCommon.is_auth_ok(request):
abort(401)
req_data = ReqDeviceCommon.is_post_param_ok(request)
if not req_data:
return jsonify(
ErrResponse(0, CodeConstant.code_null_param,
AuthStrings.missing_param).__dict__)
# if Device.objects(mac_addr=req_data[DeviceConstant.mac_addr]):
# return jsonify(ErrResponse(0, CodeConstant.code_already_exist, DeviceStrings.device_is_exist).__dict__)
#
# count = Device.objects().all().count()+1
# device = Device(mac_addr=req_data[DeviceConstant.mac_addr], device_id=0).save();
# device.update(set__device_id=count)
#
# device_name = None
# if DeviceConstant.device_name in req_data:
# device_name = req_data[DeviceConstant.device_name]
#
# device_type = None
# if DeviceConstant.device_type in req_data:
# device_type = req_data[DeviceConstant.device_type]
#
# device.update(device_name=device_name, device_type=device_type, online=False)
#
response = JKResponse(1, Device.objects().first()).__dict__
return jsonify(response)
def register_device(json_req, user):
device_type = json_req['deviceType']
device_desc = json_req['deviceDescription']
device_code = json_req['deviceCode']
fcm_id = json_req['fcmID']
if device_type not in (ANDROID, IOS, OTHERS):
raise ValueError('Invalid deviceType')
if fcm_id and fcm_id.strip():
fcm_id = fcm_id.strip()
else:
raise ValueError('Invalid FCM ID')
user_id = user.UserID
device = db_session.query(Device).filter_by(DeviceType=device_type,
UserID=user_id).first()
if device:
device.DeviceDesc = device_desc
device.DeviceCode = device_code
device.FcmID = fcm_id
db_session.commit()
else:
new_device = Device(DeviceType=device_type,
DeviceDesc=device_desc,
DeviceCode=device_code,
UserID=user_id,
FcmID=fcm_id)
db_session.add(new_device)
db_session.commit()
return jsonify(status=1, message='success')
def test__model__device__check_access__device_owner(self):
device = Device.create("the-user", True)
actual_result = device.check_access("the-user")
self.assertEqual(True, actual_result)
mock.m.contact_microservice.assert_not_called()
def starter_device(data: dict, user: str) -> dict:
"""
Creates a device for starters
:param data: The given data
:param user: The user uuid.
:return: the response
"""
count: int = wrapper.session.query(func.count(
Device.uuid)).filter_by(owner=user).scalar()
if count > 0:
return already_own_a_device
performance: tuple = calculate_power(hardware["start_pc"])
device: Device = Device.create_starter_device(user, True)
Workload.create(device.uuid, performance)
create_hardware(hardware["start_pc"], device.uuid)
m.contact_microservice("service", ["device_init"], {
"device_uuid": device.uuid,
"user": device.owner
})
return device.serialize
def index():
"""
Method associated to both routes '/' and '/index' and accepts
post requests for when a user logs in. Updates the user of
the session to the person who logged in. Also populates 3 tables for game invites, games in progress, and
games finished by the logged in user (if there is one).
"""
if request.method == "POST":
return redirect('/index')
matchingDevices = controller.getDevicesWithQuery("CardioCare")
print Device(matchingDevices[0])
results = [Device(device) for device in matchingDevices]
return render_template("index.html", results=results)
def associate_device(self, device, system):
if device is None:
abort(400)
try:
curr_system = device.system_key.get()
except AttributeError:
curr_system = None
if system is None:
abort(400, 'Invalid system.')
if curr_system is not None:
abort(401, 'Device already associated.')
if not Owner.is_owner_of(current_user, system):
abort(401)
device.system_key = system.key
device.put()
devices = DeviceModel.from_system_key(system.key)
if device not in devices:
devices.append(device)
return system, devices
def add_device():
device_data = devices_schema.load(request.json)
for device in device_data:
new_device = Device(**device)
db.session.add(new_device)
db.session.commit()
return jsonify({"Devices added": len(device_data)})
def create_fixtures(self):
"""Create a device with two sensors."""
self.device1 = Device(name="ToF-1")
self.sensor1 = Sensor(name="S-1", device=self.device1)
self.sensor2 = Sensor(name="S-2", device=self.device1)
self.session.add_all([self.device1, self.sensor1, self.sensor2])
self.session.commit()
def recover_devices_recycles(ids):
devices = Device.objects(Q(id__in=ids) & Q(is_template=False))
devices.update(is_deleted=False)
equipments = [equipment.id for equipment in devices.values_list('_parent_equipment')]
Equipment.objects(id__in=equipments).update(is_deleted=False)
return jsonify(ok=True, msg='success')
def handleLocationUpdate(item):
device = Device.get_device(item['device_id'])
if not device:
device = Device(item['device_id'], item['recorded_at'])
db.session.add(device)
recorded_at = item['recorded_at']
data = item['data']
geometry = data['geometry']
location_type = geometry['type']
longitude = geometry['coordinates'][0]
latitude = geometry['coordinates'][1]
altitude = geometry['coordinates'][2]
return device.update_location(location_type, longitude, latitude, altitude,
recorded_at)
def get_users_meta():
data = Device.objects(is_deleted=False, is_template=False).fields(id=1, name=1, _parent_equipment=1).all()
meta = [{
'id': str(item.id),
'name': item.name,
'parentEquipmentId': str(item._parent_equipment.id) if item._parent_equipment else None
} for item in data]
return jsonify(ok=True, data=meta)
def get_device_by_device_id(device_id):
"""
Get the device by the device_id from the database or return None if it doesn't exist
:param device_id:
:return:
"""
return Device.objects(device_id=device_id).first()
def register():
device = Device(key=Device.generate_key(request.json['id']))
device.id_gcm = request.json['id_gcm']
device.os = request.json['os']
device.language = request.json['language']
device.put()
return jsonify( { 'status' : 'success' } ) , 200
