def batch_bind_customer_to_device(customer_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(customer_id,
error_message='The "customer_id" can not be empty.')
customer = DccaCustomer.query_by_id(customer_id)
empty_check(customer,
error_message='The customer not exists or cannot accessable.')
check_json(request)
device_ids = get_json(request).get('device_ids', [])
devices = Host.batch_bind_customer(device_ids, customer)
data = []
success = set()
try:
for device in devices:
data.append(device.as_dict(schema=DeviceShortSchema))
success.add(device.id)
session.add(device)
session.commit()
except Exception:
raise DCCAException('Fail to bind customer to devices')
results = OrderedDict()
results['customer'] = customer.as_dict(schema=CustomerSchema)
results['devices'] = data
results['failure'] = list(set(device_ids) - success)
return jsonify(results)
def create_device_group():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
check_json(request)
name = get_json(request).get('name')
desc = get_json(request).get('description')
customer = get_json(request).get('customer')
if desc is None:
desc = ''
empty_check(name, error_message='Name cannot be empty')
DccaDeviceGroup.is_name_taken(name, ctx.current_user)
group = DccaDeviceGroup(name, description=desc, customer=customer)
try:
session.add(group)
session.commit()
except Exception:
raise DCCAException('Fail to create device group')
results = OrderedDict()
results['status'] = 'success'
results['message'] = 'Success to create a group'
results['group'] = group.as_dict(schema=DeviceGroupSchema)
return jsonify(results)
def delete_one_customer(customer_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(customer_id,
error_message='The "customer_id" can not be empty.')
customer = DccaCustomer.query_by_id(customer_id)
empty_check(customer, error_message='Not exist or cannot accessable.')
try:
session.delete(customer)
session.commit()
except Exception:
if IS_DEBUG:
import traceback
traceback.print_exc()
raise DCCAException('Fail to delete customer')
return jsonify({
'status': 'success',
'message': 'Success to delete customer',
'customer': customer.as_dict(schema=CustomerSchema)
})
def query_one_group(group_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
limit = request.args.get('limit') if request.args.get(
'limit') else DEFAULT_GROUP_LIMTI
offset = request.args.get('offset') if request.args.get(
'offset') else DEFAULT_GROUP_OFFSET
empty_check(group_id, error_message='The "group_id" cannot be empty.')
results = OrderedDict()
# workaround it is not a uuid, group id
if group_id and len(str(group_id)) < 32:
devices_group_list = DccaAssHostModel.get_model_deviceid(int(group_id))
r = DccaModel.get_by_id(int(group_id))
if not r:
raise Exception("%s: group or model not found" % (str(group_id)))
results['id'] = r.id
name = "%s-%s-%s-%s" % (r.model, r.type, r.platform, r.vendor)
results['name'] = name
results["description"] = "%s: model group" % name
else:
group = DccaDeviceGroup.get_by_id(group_id, uid)
empty_check(group, error_message='The "group" is not accessable.')
devices_group_list = group.query_bind_devices(limit=limit,
offset=offset)
results['id'] = group_id
results["name"] = group.name
results["description"] = group.desc
results["device"] = OrderedDict()
results["device"]['limit'] = limit
results["device"]['offset'] = offset
results['devices'] = []
total = 0
for device_group in devices_group_list:
device_id = device_group[0]
device = Host.get_id(device_id)
if device:
model_id = Host.get_model_id(device_id)
devices = device.as_dict(schema=DeviceSchema)
devices['status'] = query_one_device_status(devices['name'])
total += 1
results['devices'].append(devices)
if model_id[0]:
model = DccaModel.get_by_id(model_id)
devices['model'] = model.as_dict(schema=ModelSchema)
results['device']['total'] = total
return jsonify(results)
def query_group_devices_statistics():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
limit = request.args.get('limit') if request.args.get(
'limit') else DEFAULT_GROUP_LIMTI_STATISTICS
offset = request.args.get('offset') if request.args.get(
'offset') else DEFAULT_GROUP_OFFSET
filter_name = request.args.get('filter_name')
empty_check(filter_name, error_message='Please pass in filter_name.')
model_id = int(filter_name.split("-")[0])
device_ids = DccaAssHostModel.get_model_deviceid(model_id)
# print(device_ids)
if not device_ids:
return jsonify({})
statistics = OrderedDict()
statistics['by_continent'] = OrderedDict()
statistics['by_continent']['others'] = OrderedDict()
statistics['by_continent']['others']['total'] = 0
statistics['by_status'] = OrderedDict()
for device_id in device_ids:
query_all_location_info_command = query_all_location_info_sql.format(
limit=limit, offset=offset, user_id=uid, device_id=device_id[0])
request.cursor.execute(query_all_location_info_command)
location_items = request.cursor.fetchall()
for loc_item in location_items:
status = query_one_device_status(loc_item[1])["status"]
loc_item = LocationItem._make(loc_item + (status, ))
continent = loc_item.continent
status = loc_item.status
if continent is None:
statistics['by_continent']['others']['total'] += 1
set_status(statistics, continent, status)
elif continent not in statistics['by_continent']:
statistics['by_continent'][continent] = {'total': 1}
set_status(statistics, continent, status)
else:
statistics['by_continent'][continent]['total'] += 1
set_status(statistics, continent, status)
if status is None:
statistics['by_status']['others'] += 1
elif status not in statistics['by_status']:
statistics['by_status'][status] = 1
else:
statistics['by_status'][status] += 1
return jsonify(statistics)
def batch_delete_device_group():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
check_json(request)
group_ids = get_json(request).get('group_ids')
empty_check(group_ids, error_message='The "group_ids" cannot be empty.')
remove_fail_list = []
remove_list = []
results = OrderedDict()
results['groups'] = OrderedDict()
results['groups']['success'] = []
results['groups']['fail'] = []
for group_id in group_ids:
group = DccaDeviceGroup.get_by_id(group_id, uid)
if group:
try:
remove_list.append(group)
group.remove()
session.commit()
except Exception as e:
remove_fail_dict = {'id': group_id, 'message': e}
remove_fail_list.append(remove_fail_dict)
raise DCCAException('Fail to remove device group')
else:
message = 'Fail to remove device group'
remove_fail_dict = {'id': group_id, 'message': message}
remove_fail_list.append(remove_fail_dict)
if len(remove_list) == 0:
results['status'] = "fail"
results['message'] = "Fail to remove device group"
for group_fail in remove_fail_list:
results['groups']['fail'].append(group_fail)
results['groups']['fail_total'] = len(remove_fail_list)
else:
for group in remove_list:
results['status'] = "success"
results['message'] = "Success to remove group"
results['groups']['success'].append(
group.as_dict(schema=DeviceGroupBindSchema))
results['groups']['success_total'] = len(remove_list)
for group_fail in remove_fail_list:
results['groups']['fail'].append(group_fail)
results['groups']['fail_total'] = len(remove_fail_list)
return jsonify(results)
def query_one_customer(customer_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(customer_id,
error_message='The "customer_id" can not be empty.')
customer = DccaCustomer.query_by_id(customer_id)
empty_check(customer, error_message='Not exist or cannot accessable.')
return jsonify(customer.as_dict(schema=CustomerSchema))
def modify_one_group(group_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(group_id, error_message='The "group_id" cannot be empty.')
check_json(request)
name = get_json(request).get('name')
input_valid_check(name, error_message='Invalid characters in name.')
group = DccaDeviceGroup.get_by_id(group_id, uid)
empty_check(group, error_message='The "group" is not accessable.')
desc = get_json(request).get('description')
if not name and not desc:
return jsonify({
'status': 'fail',
'message': 'Empty parameters, not modified'
})
if name:
group.name = name
if desc:
group.desc = desc
elif desc == '':
group.desc = ''
group.updated_at = datetime.utcnow()
try:
session.add(group)
session.commit()
except Exception:
raise DCCAException('Fail to update group')
results = OrderedDict()
results['status'] = 'success'
results['message'] = 'Success to update group'
results['group'] = group.as_dict(schema=DeviceGroupSchema)
return jsonify(results)
def bind_device_to_group(group_id, device_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(group_id, error_message='The "group_id" cannot be empty.')
empty_check(device_id, error_message='The "device_id" cannot be empty')
group = DccaDeviceGroup.get_by_id(group_id, uid)
if group is None:
return jsonify({
'status': 'fail',
'message': "The group_id does not exist"
})
device = Host.get_by_id(device_id)
if device is None:
return jsonify({
'status': 'fail',
'message': "The device_id does not exist"
})
results = OrderedDict()
if not device.has_group(group):
try:
device.groups.append(group)
session.add(device)
session.commit()
except Exception:
raise DCCAException('Fail to bind device to group')
results['status'] = 'success'
results['message'] = 'Success to add device to group'
results['group'] = group.as_dict(schema=DeviceGroupBindSchema)
results['device'] = device.as_dict(schema=DeviceIDSchema)
else:
results['status'] = 'fail'
results[
'message'] = 'This device already exists in the {} group, please do not add it repeatedly'.format(
group.name)
return jsonify(results)
def remove_tasks_by_ids():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
task_ids_str = request.args.get('task_ids')
empty_check(task_ids_str, error_message='The "task_ids" cannot be empty.')
task_ids = task_ids_str.split(',')
tasks = EsTask.query_in(task_ids)
if len(tasks) < len(task_ids):
return jsonify({
'status':
'fail',
'message':
'Not exist or cannot access',
'unauthorized':
list(set(task_ids) - set([t.id for t in tasks]))
})
try:
data = []
for task in tasks:
task.logical_delete = True
task.ended_at = datetime.utcnow()
session.add(task)
data.append(task.as_dict(schema=TaskSchema))
session.commit()
except Exception:
raise DCCAException('Fail to remove task')
return jsonify({
'status': 'success',
'message': 'Success to remove tasks',
'tasks': data
})
def modify_customer(customer_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
check_json(request)
name = get_json(request).get('name')
is_active = get_json(request).get('is_active')
description = get_json(request).get('description')
empty_check(customer_id,
error_message='The "customer_id" can not be empty.')
customer = DccaCustomer.query_by_id(customer_id)
empty_check(customer, error_message='Not exist or cannot accessable.')
if name:
customer.name = name
if is_active is not None:
customer.is_active = is_active
if description:
customer.description = description
customer.updated_at = datetime.utcnow()
try:
session.add(customer)
session.commit()
except Exception:
raise DCCAException('Fail to update customer')
return jsonify({
'status': 'success',
'message': 'Success to update customer',
'customer': customer.as_dict(schema=CustomerSchema)
})
def query_one_task_by_id(task_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(task_id, error_message='The "task_id" cannot be empty.')
task = EsTask.query_by_id(task_id)
if not task:
return jsonify({
'status':
'fail',
'message':
'Task not exist or you are not permitted to access'
})
data = task.as_dict(schema=TaskSchema)
data['status_payload'] = task.as_inst_dict()
data['statistics'] = task.statistics()
return jsonify(data)
def delete_device_group(group_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(group_id, error_message='The "group_id" cannot be empty.')
group = DccaDeviceGroup.get_by_id(group_id, uid)
empty_check(group, error_message='The "group" is not accessable.')
try:
group.remove()
session.commit()
except Exception:
raise DCCAException('Fail to remove device group')
results = OrderedDict()
results['status'] = 'success'
results['message'] = 'Success to remove group'
results['group'] = group.as_dict(schema=DeviceGroupSchema)
return jsonify(results)
def remove_device_from_group(group_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
empty_check(group_id, error_message='The "group_id" cannot be empty.')
check_json(request)
device_ids = get_json(request).get('devices')
empty_check(device_ids, error_message='The "device_ids" cannot be empty')
group = DccaDeviceGroup.get_by_id(group_id, uid)
if group is None:
return jsonify({
'status': 'fail',
'message': "The group_id does not exist"
})
remove_fail_list = []
remove_list = []
for device_id in device_ids:
device = Host.get_by_id(device_id)
if device is None:
bind_fail_dict = {
'id': device_id,
'message': 'The device_id does not exist'
}
remove_fail_list.append(bind_fail_dict)
else:
if device.has_group(group):
try:
group.devices.remove(device)
session.commit()
remove_list.append(device)
except Exception as e:
bind_fail_dict = {'id': device_id, 'message': e}
remove_fail_list.append(bind_fail_dict)
raise DCCAException('Fail to bind device to group')
else:
message = 'This device already exists in the {} group, please do not add it repeatedly'.format(
group.name)
bind_fail_dict = {'id': device_id, 'message': message}
remove_fail_list.append(bind_fail_dict)
results = OrderedDict()
if len(remove_list) == 0:
results['status'] = "fail"
results['message'] = "Fail to unbind device from group"
results['group'] = group.as_dict(schema=DeviceGroupBindSchema)
results['devices'] = {}
else:
results['status'] = "success"
results['message'] = "Success to remove device from group"
results['group'] = group.as_dict(schema=DeviceGroupBindSchema)
results['devices'] = {}
results['devices']['success'] = []
results['devices']['success_total'] = len(remove_list)
for device in remove_list:
results['devices']['success'].append(
device.as_dict(schema=DeviceIDSchema))
results['devices']['fail'] = []
results['devices']['fail_total'] = len(remove_fail_list)
for device_fail in remove_fail_list:
results['devices']['fail'].append(device_fail)
return jsonify(results)
def group_create_tasks():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
check_json(request)
group_id = get_json(request).get('group_id')
task_type = get_json(request).get('type')
payloads = get_json(request).get('payload')
# workaround it is not a uuid, group id
if group_id and len(str(group_id)) < 32:
device_list = DccaAssHostModel.get_model_deviceid(int(group_id))
else:
group = DccaDeviceGroup.get_by_id(group_id, uid)
empty_check(group, error_message='The "group" is not accessable.')
device_list = DccaDeviceGroup.query_bind_model_devices(group_id, uid)
if not device_list or len(device_list) < 1:
return jsonify({
'status': 'fail',
'message': 'There are no devices in this device group'
})
device_list = set(device_list)
device_ids = [device_id[0] for device_id in device_list]
devices = Host.query_in(device_ids)
if len(devices) != len(device_ids):
return jsonify({
'status':
'fail',
'message':
'Not authorized devices exist. Device not exist or cannot access',
'not_authorized_devices':
list(set(device_ids) - set([d.id for d in devices]))
})
if task_type not in list(TASK_TYPE_NAMES.values()):
return jsonify({'status': 'fail', 'message': 'No such kind of task'})
try:
inst_list = []
if task_type == TASK_TYPE_NAMES[TASK_TYPE_APP]:
unauthoried = EsTask.check_da_payload(payloads)
if unauthoried:
return jsonify({
'status': 'fail',
'message':
'Unauthorized application exists, not exist or cannot access.',
'unauthorized': unauthoried
})
task = EsTask.create_da_task(payloads)
session.add(task)
session.flush()
for pl in payloads:
softapp = DccaSoftapp.get(pl['softapp_id'])
del pl['softapp_id']
for device in devices:
inst = task.da_inst(device, softapp, pl)
session.add(inst)
inst_list.append(inst)
session.commit()
elif task_type == TASK_TYPE_NAMES[TASK_TYPE_SOLUTION]:
authed, solution = EsTask.check_ota_payload(payloads)
if not authed:
return jsonify({
'status':
'fail',
'message':
'Solution not exist or cannot access.'
})
task = EsTask.create_ota_task(payloads)
session.add(task)
session.flush()
for device in devices:
inst = task.ota_inst(device, solution)
session.add(inst)
inst_list.append(inst)
session.commit()
else:
return jsonify({
'status': 'fail',
'message': 'No such kind of task'
})
try:
for inst in inst_list:
if inst.task.type == TASK_TYPE_APP:
print(('Start da task: ', inst))
inst.start(APPSERVER_HOST, APPSERVER_PORT)
elif inst.task.type == TASK_TYPE_SOLUTION:
print('Start ota task')
inst.start(MQTT_HOST)
except Exception:
import traceback
traceback.print_exc()
session.rollback()
else:
session.commit()
results = OrderedDict()
results['status'] = 'success'
results['message'] = 'Success to create the task'
results['task'] = task.as_dict(schema=TaskSchema)
return jsonify(results)
except Exception as e:
raise DCCAException(str(e))
def device_save_to_group():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
ctx.current_user = DccaUser.get_by_id(uid)
limit = request.args.get('limit') if request.args.get(
'limit') else DEFAULT_GROUP_LIMTI
offset = request.args.get('offset') if request.args.get(
'offset') else DEFAULT_GROUP_OFFSET
check_json(request)
group_name = get_json(request).get("name")
group_desc = get_json(request).get('description')
customer_id = get_json(request).get('customer')
bind_fail_list = []
bind_list = []
if group_desc is None:
group_desc = ''
customer = DccaCustomer.get_by_id(customer_id)
if customer is None:
customer_id = None
session.commit()
empty_check(group_name, error_message='Name cannot be empty')
DccaDeviceGroup.is_name_taken(group_name, ctx.current_user)
group = DccaDeviceGroup(group_name,
description=group_desc,
customer=customer_id)
try:
session.add(group)
except Exception:
raise DCCAException("Fail to create device group")
devices = get_json(request).get('devices')
if devices:
for device in devices:
device = Host.get_by_id(device)
if device is None:
bind_fail_dict = {
'id': device,
'message': 'The device_id does not exist'
}
bind_fail_list.append(bind_fail_dict)
else:
if not device.has_group(group):
try:
device.groups.append(group)
session.add(device)
session.commit()
bind_list.append(device)
except Exception as e:
bind_fail_dict = {'id': device.id, 'message': e}
bind_fail_list.append(bind_fail_dict)
raise DCCAException('Fail to bind device to group')
else:
message = 'This device already exists in the {} group, please do not add it repeatedly'.format(
group.name)
bind_fail_dict = {'id': device.id, 'message': message}
bind_fail_list.append(bind_fail_dict)
else:
intersection = get_json(request).get('intersection', False)
results = []
condition_items = get_json(request).get('by_condition')
if 'by_condition' in get_json(request) and condition_items:
if not any([x['value'] for x in condition_items]):
devices_by_attr = set()
else:
devices_by_attr = device_attr_filter(request.cursor, uid,
limit, offset,
condition_items)
results.append(devices_by_attr)
else:
devices_by_attr = set()
if 'by_solution' in get_json(request) and get_json(request).get(
'by_solution'):
solution_id = get_json(request).get('by_solution')
devices_by_sol = device_solution_filter(request.cursor, uid, limit,
offset, solution_id)
results.append(devices_by_sol)
else:
devices_by_sol = set()
if intersection:
if results:
devices = list(reduce(lambda x, y: x & y, results))
else:
devices = []
else:
devices = list(devices_by_attr | devices_by_sol)
if len(devices) == 0:
return jsonify({
"status":
"fail",
"message":
"The device that matches the search criteria is empty. Please re-enter."
})
for device in devices:
device = Host.get_by_id(device['id'])
if device is None:
bind_fail_dict = {
'id': device.id,
'message': 'The device_id does not exist'
}
bind_fail_list.append(bind_fail_dict)
else:
if not device.has_group(group):
try:
device.groups.append(group)
session.add(device)
session.commit()
bind_list.append(device)
except Exception as e:
bind_fail_dict = {'id': device.id, 'message': e}
bind_fail_list.append(bind_fail_dict)
raise DCCAException('Fail to bind device to group')
else:
message = 'This device already exists in the {} group, please do not add it repeatedly'.format(
group.name)
bind_fail_dict = {'id': device.id, 'message': message}
bind_fail_list.append(bind_fail_dict)
results = OrderedDict()
if len(bind_list) == 0:
results['status'] = "fail"
results['message'] = "Fail to bind device to group"
results['group'] = group.as_dict(schema=DeviceGroupBindSchema)
results['devices'] = {}
else:
results['status'] = "success"
results['message'] = "Success to add device to group"
results['group'] = group.as_dict(schema=DeviceGroupBindSchema)
results['devices'] = {}
results['devices']['success'] = []
results['devices']['success_total'] = len(bind_list)
for device in bind_list:
results['devices']['success'].append(
device.as_dict(schema=DeviceIDSchema))
results['devices']['fail'] = []
results['devices']['fail_total'] = len(bind_fail_list)
for device_fail in bind_fail_list:
results['devices']['fail'].append(device_fail)
return jsonify(results)
