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 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 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 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_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 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 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 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 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_devices_child(): form = ObjectIdListForm(request.args) ids = form.ids.data device = Device.objects(id__in=ids).count() if not device: return jsonify(ok=True, msg='not found'), 404 child_interface = Interface.objects(_parent_device__in=ids).count() child_cable = Cable.objects(Q(_start_device__in=ids) | Q(_end_device__in=ids)).count() return jsonify(ok=True, msg={'interface': child_interface, 'cable': child_cable})
def get_account_list(): if (ReqAuthCommon.is_auth_ok(request) == False): abort(401) devices = Device.objects().all() response = JKResponse(1, devices).__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 recover_cables_recycles(ids): cables = Cable.objects(Q(id__in=ids) & Q(is_template=False)) cables.update(is_deleted=False) # 恢复线缆自身 interfaces = [ interface.id for interface in cables.values_list( '_start_interface', '_end_interface')[0] ] devices = [ device.id for device in cables.values_list('_start_device', '_end_interface')[0] ] equipments = [ equipment.id for equipment in cables.values_list( '_start_equipment', '_end_interface')[0] ] Interface.objects(id__in=interfaces).update(is_deleted=False) 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_account_by_id(device_id): if (ReqAuthCommon.is_auth_ok(request) == False): abort(401) devices = Device.objects(device_id=device_id).all() if not devices: return jsonify( ErrResponse(0, CodeConstant.code_no_data, DeviceStrings.device_not_exist).__dict__) response = JKResponse(1, devices).__dict__ return jsonify(response)
def load(self, interface): interface.name = self.name.data interface.type = self.type.data interface.protocol = self.protocol.data interface.location = self.location.data interface.note = self.note.data interface.pcl = self.pcl.data try: parent_device = Device.objects().get(id=self.parentDeviceId.data) parent_equipment = parent_device.parent_equipment except Device.DoesNotExist: raise FormLoadException('设备不存在,id: ' + str(self.parentDeviceId.data)) except Equipment.DoesNotExist: raise FormLoadException('设备所属的装置不存在,设备id: ' + str(self.parentDeviceId.data)) else: interface.parent_device = parent_device.id interface.parent_equipment = parent_equipment.id
def get_user(): devices = Device.objects().all() print devices user = User.objects(name="test2").first() print user #user.update(device=device) #user.update(devices=devices) #print device.devicename #user.update(emdevices=devices) print user.name token = Auth.encode_auth_token(2, 100000) print "token:" + token payload = Auth.decode_auth_token(token) print payload print payload['data']['id'] return jsonify({'userinfo': User.objects.all()}), 201
def append_owner(device_dict): for key in device_dict: device = Device.objects(mac=key).first() if device is not None: if device.owner is not None: device_dict[key].update({'owner': device.owner.display_name})
def delete_equipment(oid, response): Device.objects(_parent_equipment=oid).update(is_deleted=True) Interface.objects(_parent_equipment=oid).update(is_deleted=True) Cable.objects(Q(_start_equipment=oid) | Q(_end_equipment=oid)).update(is_deleted=True) return response
def save_message_to_receiver(sender, message): receiver = Device.objects(device_id=sender.receiver_id).first() receiver.update(add_to_set__messages=[message])
def recover_devices_templates_recycles(ids): Device.objects(Q(id__in=ids) & Q(is_template=True)).update(is_deleted=False) return jsonify(ok=True, msg='success')