def update_template(tid):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
name = get_json(request).get('name')
desc = get_json(request).get('desc')
body = get_json(request).get('body')
if len(tid) < 5:
raise DCCAException('Error: invalid parameter for "id"')
try:
t = update_one_tasktmplt(request.cursor, uid, tid, name, desc, body)
request.conn.commit()
if t and 'name' in t:
r = {
"status": "success",
"message": "update template successfully"
}
r.update(t)
return jsonify(r)
except Exception as e:
raise DCCAException(f"Error: update_template: {str(e)}")
def get_one_template(tid):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
if len(tid) < 5:
raise DCCAException('Error: invalid parameter for "id"')
try:
r = get_one_tasktmplt_by_id(request.cursor, uid, tid)
return jsonify(r)
except Exception as e:
raise DCCAException(f"Error: get template: {str(e)}")
def handler_audit_view(audit_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
action = get_json(request).get('action')
is_admin = True if request.headers.get('admin', False) == 'true' else False
if not is_admin:
return {
'status': 'fail',
'message': 'Unauthorized, administrator is assumed to access this.'
}
request.cursor.execute(query_one_audit, (audit_id, ))
audit = request.cursor.fetchone()
audit = AuditsShort._make(audit)
if action == 'accept':
approved = True
model_id = audit.approve_item
if audit.to_public:
is_public = True
else:
is_public = False
other_device = check_device_bind_model(request.cursor, uid,
model_id)
if other_device:
return jsonify({
"status":
"fail",
"message":
"Someone else's device is bound to this model and the operation fails."
})
status = True
try:
request.cursor.execute(update_model_sql, (is_public, model_id))
request.conn.commit()
except Exception:
raise DCCAException("Fail to update the model")
else:
approved = False
status = True
try:
request.cursor.execute(update_audit_sql, (approved, status, audit_id))
request.conn.commit()
except Exception:
raise DCCAException("Fail to update audit")
return jsonify({"status": "success", "message": "Operate successfully"})
def handle_the_in_store_request(request_id):
"""
Admin can approve user's request
"""
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
approve = get_json(request).get('approve')
is_admin = True if request.headers.get('admin', False) == 'true' else False
if not is_admin:
return jsonify({
'status': 'fail',
'message': 'Not admin, have no access permission'
})
request.cursor.execute(query_req_info_sql, (request_id, ))
req_info = request.cursor.fetchone()
if not req_info:
return jsonify({'status': 'fail', 'message': 'Request not exist.'})
app_id = req_info[0]
try:
request.cursor.execute(update_apply_status_sql,
(approve, AUDIT_REQUEST_STATUS, request_id))
except Exception:
raise DCCAException('Fail to update apply status')
tof = 'True' if approve else 'False'
try:
request.cursor.execute(update_in_store_status_sql, (tof, app_id))
except Exception:
raise DCCAException('Fail to update device status')
try:
request.cursor.execute(update_app_permission_sql, (tof, app_id))
request.conn.commit()
except Exception:
raise DCCAException('Fail to update app permission')
approve_status = 'approve' if approve else 'deny'
return jsonify({
'status': 'success',
'message': f'Success to {approve_status} the request'
})
def update_password(conn, cursor, user_id, password):
password, salt = encrypt_with_random_salt(password)
try:
cursor.execute(update_password_sql, (password, salt, user_id))
conn.commit()
except Exception:
raise DCCAException('Fail to update user\' password')
def remove_tag_from_application(app_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
tag_name = get_json(request).get('name')
check_tag_name(tag_name)
check_application_id(app_id)
remove_tag_from_app_cmd = remove_tag_from_app_sql.format(
application_id=app_id, tag_name=tag_name)
try:
request.cursor.execute(remove_tag_from_app_cmd)
except Exception:
raise DCCAException('Fail to remove tag from application')
request.conn.commit()
return jsonify({
'status':
'success',
'message':
'Success to remove tag "{}" from application'.format(tag_name)
})
def attach_tag_to_applications(app_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
tag_name = get_json(request).get('name')
check_tag_name(tag_name)
tag_id = query_tag(request.cursor, tag_name)
if not tag_id:
tag_id = create_tag(request.cursor, tag_name)
attach_tag_to_app_cmd = attach_tag_to_app_sql.format(app_id=app_id,
tag_id=tag_id)
try:
request.cursor.execute(attach_tag_to_app_cmd)
except Exception:
raise DCCAException('Fail to attach tag to application!')
request.conn.commit()
return jsonify({
'status':
'success',
'message':
'Success attached "{}" to application'.format(tag_name)
})
def create_vendor():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
is_admin = True if request.headers.get('admin') == 'true' else False
if not is_admin:
return jsonify({
'status': 'fail',
'message': NOT_ADMIN_CANNOT_CREATE_MSG
})
check_json(request)
name = get_json(request).get("name")
is_public = get_json(request).get("is_public") or False
if not name:
raise InvalidInputException("vendor name is empty.")
new_item = DccaVendor(name, is_public)
try:
status = DccaVendor.create_one(new_item)
except Exception:
raise DCCAException("Create vendor failed")
return jsonify(status)
def remove_vendor():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
is_admin = True if request.headers.get('admin') == 'true' else False
ids = get_json(request).get("ids")
if not ids:
return jsonify({
'status': 'fail',
'message': 'The "vendor_ids" can not be empty'
})
if not is_admin:
return jsonify({
'status': 'fail',
'message': NOT_ADMIN_CANNOT_CREATE_MSG
})
try:
status = DccaVendor.delete(ids)
except Exception:
raise DCCAException("Delete vendor failed")
return jsonify(status)
def remove_one_common_service(service_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
if not service_id:
return jsonify({
'status': 'fail',
'message': 'Service ID cannot be empty.'
})
if not is_service_owner(request.cursor, user_id=uid,
service_id=service_id):
return jsonify({
'status':
'fail',
'message':
'Not the service owner or the service cannot access.'
})
try:
remove_one_service(request.cursor, service_id)
request.conn.commit()
except Exception as e:
raise DCCAException(
make_error_msg(IS_DEBUG,
'Exception, fail to remove common service.',
str(e)))
return jsonify({
'status': 'success',
'message': 'Success to remove common service'
})
def modify_common_service(service_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
name = get_json(request).get('name')
url = get_json(request).get('url')
port = get_json(request).get('port')
access_token = get_json(request).get('access_token')
if not is_service_owner(request.cursor, user_id=uid,
service_id=service_id):
return jsonify({
'status':
'fail',
'message':
'Not the service owner or the service cannot access.'
})
try:
update_service(request.cursor, name, url, port, access_token,
service_id)
request.conn.commit()
except Exception as e:
raise DCCAException(
make_error_msg(IS_DEBUG,
'Exception, fail to update common service.',
str(e)))
return jsonify({
'status': 'success',
'message': 'Success to update the commont service'
})
def create_common_service():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
name = get_json(request).get('name')
url = get_json(request).get('url')
port = get_json(request).get('port')
access_token = get_json(request).get('access_token')
try:
service_id = create_service(request.cursor,
name,
url,
port,
access_token,
user_id=uid)
request.conn.commit()
except Exception as e:
raise DCCAException(
make_error_msg(IS_DEBUG,
'Exception, fail to create common service', str(e)))
return jsonify({
'status': 'success',
'message': 'Success to create service ID',
'id': service_id
})
def create_model_view():
"""
Create a model
"""
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
model = get_json(request).get('model')
_type = get_json(request).get('type')
platform = get_json(request).get('platform')
vendor = get_json(request).get('vendor')
if not check_is_oxm(request.cursor, user_id=uid):
return jsonify({
'status': 'fail',
'message': 'Only OXM can create model'
})
if check_model_exist(request.cursor, model, _type, platform, vendor):
return jsonify({
'status': 'fail',
'message': 'Model already exist, pick another one.'
})
if exceed_model_max_limit(request.cursor, user_id=uid):
return jsonify({
'status': 'fail',
'message': 'Exceed the max limit model can create'
})
try:
model_id = create_model(request.cursor, model, _type, platform, vendor, user_id=uid)
request.conn.commit()
return jsonify({
'status': 'success',
'message': 'Success to create model',
'model_id': model_id
})
except Exception as e:
error_msg = 'Exception, fail to create model.'
if IS_DEBUG:
raise DCCAException(error_msg + ' =>' + str(e))
else:
raise DCCAException(error_msg)
def check_permission(permission):
if permission not in ['private', 'public']:
raise DCCAException("invalid permission type")
if permission == 'public':
return True
else:
return False
def remove_object_from_bucket(bucket, key):
s3 = boto3.client('s3')
try:
s3.delete_object(Bucket=bucket, Key=key)
except Exception as e:
err_msg = "Fail to delete solution image from S3. {}".format(str(e))
raise DCCAException(err_msg)
def as_dict(objects=None, schema=None, many=False):
if not objects or not schema:
raise DCCAException("objects or schema is empty!")
if many:
results = schema(many=True).dump(objects)
else:
results = schema().dump(objects)
return results.data
def delete_model():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
model_id = get_json(request).get('model_id')
if not check_model_owner(request.cursor, model_id, user_id=uid):
return jsonify({
'status': 'fail',
'message': 'You are not the owner, refuse to access. Or model not exist'
})
if binding_to_devices(request.cursor, model_id):
device_names = bind_to_device_ids(request.cursor, model_id)
return jsonify({
'status': 'fail',
'message': 'This model has been binded to other devices, remove them first.the currently bound device is {}'.format(
device_names)
})
if binding_to_solutions(request.cursor, model_id):
solution_names = query_solution_name(request.cursor, model_id, user_id=uid)
return jsonify({
'status': 'fail',
'message': 'This model has been binded to other solutions, permamently remove them first.The solution for this model binding is {}'.format(
solution_names)
})
# Not my wish that model binds to dcca_ass_host_model
if binding_to_ass_host_model(request.cursor, model_id):
device_ids = bind_to_device_ids(request.cursor, model_id)
device_names = []
for device_id in device_ids:
device_names.append(query_device_name(request.cursor, device_id, user_id=uid))
return jsonify({
'status': 'fail',
'message': 'This model has been binded to some devices, permamently remove them before remove.The device currently binding this model is {}'.format(
device_ids)
})
try:
request.cursor.execute(delete_model_by_id_sql, (model_id,))
request.conn.commit()
return jsonify({
'status': 'success',
'message': 'Success to delete model. ID: {}'.format(model_id)
})
except Exception:
raise DCCAException('Error happened when delete model #3')
def create_tags(cursor, tag_names):
if not tag_names:
return []
try:
create_tags_command = create_tags_sql.format(
names=",".join(["('%s')" % i for i in tag_names]))
cursor.execute(create_tags_command)
result = cursor.fetchall()
tag_ids = [i[0] for i in result]
return tag_ids
except Exception:
raise DCCAException("create tag filed.")
def get_login():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
try:
username, email = query_user_name(request.cursor, uid)
request.conn.commit()
result = get_docker_login_cmd(username, email)
return jsonify(result)
except Exception as e:
raise DCCAException(str(e))
def get_template_list():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
limit = request.args.get('limit') if request.args.get('limit') else 100
offset = request.args.get('offset') if request.args.get('offset') else 0
ftname = request.args.get('filter_name', "")
try:
r = get_tasktmplt_list(request.cursor, uid, limit, offset, ftname)
return jsonify(r)
except Exception as e:
raise DCCAException(f"Error: get template list {str(e)}")
def del_template():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
tid = get_json(request).get('ids')
if len(tid) < 1 or not isinstance(tid, list):
raise DCCAException('Error: invalid parameter for "ids"')
if len(tid[0]) > 40:
raise DCCAException('Error: invalid id, too long')
try:
r = del_one_tasktmplt(request.cursor, uid, tid)
request.conn.commit()
if not r:
raise DCCAException("%s seems not existing" % tid)
r = {"status": "success", "message": "delete template successfully"}
return jsonify(r)
except Exception as e:
raise DCCAException(f"Error: delete template: {str(e)}")
def bind_solution_with_tags(cursor, solution_id, tag_ids):
if not tag_ids:
return []
values = ",".join(["(%s,%s)" % (solution_id, i) for i in tag_ids])
create_solution_command = create_solution_tags_sql.format(values=values)
try:
cursor.execute(create_solution_command)
result = cursor.fetchall()
ids = [i[0] for i in result]
return ids
except Exception:
raise DCCAException("bind tag to solution filed.")
def publish_message(
self,
mqtt_host,
payload,
):
try:
topic = self._mqtt_req_topic()
publish.single(topic,
json.dumps(payload),
qos=2,
hostname=mqtt_host)
self.status = constants.OTA_TASK_CODE_START
except Exception:
raise DCCAException('Fail to public message to device.')
def update_solution_certificate(cursor, user_id, update_items):
for name, value in list(update_items.items()):
_condition = "{}=%s ".format(name)
update_sql = 'UPDATE dcca_certificates SET {} WHERE user_id=%s ;'.format(
_condition)
try:
cursor.execute(update_sql, (
value,
user_id,
))
except Exception:
raise DCCAException(
'Exception, fail to update certificate, invalid {}'.format(
name))
def create_template():
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
name = get_json(request).get('name', "")
desc = get_json(request).get('desc', "")
body = get_json(request).get('body', "")
taskid = get_json(request).get('task_id', "")
if len(name.strip()) < 1:
raise DCCAException('Error: invalid parameter for "name"')
try:
if len(body) > 0:
t = create_one_tasktmplt(request.cursor, uid, name, desc, body)
request.conn.commit()
elif len(str(taskid)) > 0:
t = create_template_from_task(request.cursor, uid, es_version,
name, desc, taskid)
request.conn.commit()
else:
raise DCCAException("body or task_id is required")
if t and 'name' in t:
r = {
"status": "success",
"message": "create template successfully"
}
r.update(t)
return jsonify(r)
else:
raise DCCAException("%s" % str(t))
except Exception as e:
raise DCCAException(f"Error: create_template: {str(e)}")
def get_app_eventlog(app_name):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
headers = {
'User-Agent': 'kubectl/v1.7.0 (linux/amd64) kubernetes/d3ada01',
'Accept': '*/*'
}
res = RESOURCE_GET_APP_EVENT.format(dns=_DNS, port=APPSERVER_PORT, uid=uid, app_name=app_name)
resp = requests.get(res, headers=headers, cert=certs, verify=False, timeout=10)
if resp.status_code > 210:
raise DCCAException("app response error: %s" % resp.status_code)
return jsonify(resp.content.decode("utf-8"))
def query_app_version(app_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
if not check_app_owner(request.cursor, app_id, uid, include_store=True):
if not check_app_in_store(request.cursor, app_id):
return jsonify({'status': 'fail', 'message': MSG_NOT_APP_OWNER})
try:
request.cursor.execute(query_image_versions_sql, (app_id, ))
results = request.cursor.fetchall()
versions = [version[0] for version in results]
data = {'versions': versions}
return jsonify(data)
except Exception:
raise DCCAException('Error: get version by id')
def remove_docker_image_view(app_id, image_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
if not check_image_owner(request.cursor, app_id, image_id, uid):
return jsonify({'status': 'fail', 'message': MSG_NOT_APP_OWNER})
try:
remove_docker_image(request.cursor, image_id)
request.conn.commit()
except Exception:
raise DCCAException('Fail to remove docker image')
return jsonify({
'status': 'success',
'message': 'Success to remove docker image.'
})
def create_app_document_temp(app_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
documents = get_json(request).get('documents')
if not check_app_owner(request.cursor, app_id, uid):
return jsonify({'status': 'fail', 'message': MSG_NOT_APP_OWNER})
try:
request.cursor.execute(update_app_doc_sql, (documents, app_id))
request.conn.commit()
except Exception:
raise DCCAException('Exception: fail to update documents')
return jsonify({
'status': 'success',
'message': 'Success to update APP documents'
})
def apply_for_store(app_id):
uid, err = get_oemid(request=request)
if err is not None:
return jsonify(UNAUTH_RESULT)
check_json(request)
comments = get_json(request).get('comments')
if not check_app_owner(request.cursor, app_id, uid):
return jsonify({'status': 'fail', 'message': MSG_NOT_APP_OWNER})
try:
request.cursor.execute(apply_app_sql, (uid, comments, app_id))
request.conn.commit()
except Exception:
raise DCCAException('Fail to apply for public request')
return jsonify({
'status': 'success',
'message': 'Success to make a shown in store request'
})
