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')
