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