def import_templates(request, project_id):
f = request.FILES.get('data_file', None)
form_data = TemplateImportForm(request.POST)
if not form_data.is_valid():
return JsonResponse({'result': False, 'message': form_data.errors})
override = form_data.clean()['override']
r = read_template_data_file(f)
if not r['result']:
return JsonResponse(r)
templates_data = r['data']['template_data']
# check again and authenticate
check_info = TaskTemplate.objects.import_operation_check(
templates_data, project_id)
perms_tuples = []
if override:
if check_info['new_template']:
project = Project.objects.get(id=project_id)
perms_tuples.append(
(project_resource,
[project_resource.actions.create_template.id], project))
if check_info['override_template']:
templates_id = [
template_info['id']
for template_info in check_info['override_template']
]
templates = TaskTemplate.objects.filter(id__in=templates_id,
project_id=project_id,
is_deleted=False)
for template in templates:
perms_tuples.append(
(task_template_resource,
[task_template_resource.actions.edit.id], template))
else:
project = Project.objects.get(id=project_id)
perms_tuples.append(
(project_resource, [project_resource.actions.create_template.id],
project))
batch_verify_or_raise_auth_failed(principal_type='user',
principal_id=request.user.username,
perms_tuples=perms_tuples)
try:
result = TaskTemplate.objects.import_templates(templates_data,
override, project_id)
except Exception as e:
logger.error(traceback.format_exc(e))
return JsonResponse({
'result':
False,
'message':
'invalid flow data or error occur, please contact administrator'
})
return JsonResponse(result)
def export_templates(request, project_id):
try:
template_id_list = json.loads(request.GET.get('template_id_list'))
except Exception:
return JsonResponse({
'result': False,
'message': 'invalid template_id_list'
})
if not isinstance(template_id_list, list):
return JsonResponse({
'result': False,
'message': 'invalid template_id_list'
})
templates = TaskTemplate.objects.filter(id__in=template_id_list,
project_id=project_id,
is_deleted=False)
perms_tuples = [(task_template_resource,
[task_template_resource.actions.view.id], t)
for t in templates]
batch_verify_or_raise_auth_failed(principal_type='user',
principal_id=request.user.username,
perms_tuples=perms_tuples)
# wash
try:
templates_data = json.loads(
json.dumps(TaskTemplate.objects.export_templates(
template_id_list, project_id),
sort_keys=True))
except TaskTemplate.DoesNotExist:
return JsonResponse({
'result': False,
'message': 'Invalid template id list'
})
except FlowExportError as e:
return JsonResponse({'result': False, 'message': e.message})
digest = hashlib.md5(
json.dumps(templates_data, sort_keys=True) +
settings.TEMPLATE_DATA_SALT).hexdigest()
file_data = base64.b64encode(
json.dumps({
'template_data': templates_data,
'digest': digest
},
sort_keys=True))
filename = 'bk_sops_%s_%s.dat' % (project_id, time_now_str())
response = HttpResponse()
response['Content-Disposition'] = 'attachment; filename=%s' % filename
response['mimetype'] = 'application/octet-stream'
response['Content-Type'] = 'application/octet-stream'
response.write(file_data)
return response
def test_batch_verify_or_raise_auth_failed__pass(self):
shortcuts.batch_verify_or_raise_auth_failed(
principal_type=self.principal_type,
principal_id=self.principal_id,
perms_tuples=self.perms_tuples,
scope_id=self.scope_id,
status=self.status)
shortcuts.verify_or_return_insufficient_perms.assert_called_once_with(
self.principal_type, self.principal_id, self.perms_tuples,
self.scope_id)
def test_batch_verify_or_raise_auth_failed__failed(self):
try:
shortcuts.batch_verify_or_raise_auth_failed(
principal_type=self.principal_type,
principal_id=self.principal_id,
perms_tuples=self.perms_tuples,
scope_id=self.scope_id,
status=self.status)
except AuthFailedException as e:
self.assertEqual(e.permissions, self.permissions)
self.assertEqual(e.status, self.status)
shortcuts.verify_or_return_insufficient_perms.assert_called_once_with(
self.principal_type, self.principal_id, self.perms_tuples,
self.scope_id)
def fast_create_task(request, project_id):
try:
params = json.loads(request.body)
except Exception:
return JsonResponse({
'result': False,
'message': 'invalid json format'
})
project = request.project
logger.info('apigw fast_create_task info, project_id: {project_id}, params: {params}'.format(
project_id=project.id,
params=params))
if not request.is_trust:
perms_tuples = [(project_resource, [project_resource.actions.fast_create_task.id], project)]
batch_verify_or_raise_auth_failed(principal_type='user',
principal_id=request.user.username,
perms_tuples=perms_tuples,
status=200)
try:
pipeline_tree = params['pipeline_tree']
pipeline_node_name_handle(pipeline_tree)
pipeline_tree.setdefault('gateways', {})
pipeline_tree.setdefault('constants', {})
pipeline_tree.setdefault('outputs', [])
draw_pipeline(pipeline_tree)
validate_web_pipeline_tree(pipeline_tree)
except Exception as e:
message = u'invalid param pipeline_tree: %s' % e.message
logger.exception(message)
return JsonResponse({
'result': False,
'message': message
})
try:
pipeline_instance_kwargs = {
'name': name_handler(params['name'], TASK_NAME_MAX_LENGTH),
'creator': request.user.username,
'pipeline_tree': pipeline_tree,
'description': params.get('description', '')
}
except (KeyError, ValueError) as e:
return JsonResponse({
'result': False,
'message': u'invalid params: %s' % e.message
})
try:
pipeline_instance = TaskFlowInstance.objects.create_pipeline_instance(
template=None,
**pipeline_instance_kwargs
)
except PipelineException as e:
message = u'create pipeline instance error: %s' % e.message
logger.exception(message)
return JsonResponse({
'result': False,
'message': message
})
taskflow_kwargs = {
'project': project,
'pipeline_instance': pipeline_instance,
'template_source': ONETIME,
'create_method': 'api',
}
if params.get('category') in [cate[0] for cate in TASK_CATEGORY]:
taskflow_kwargs['category'] = params['category']
# 职能化任务，新建后进入职能化认领阶段
if params.get('flow_type', 'common') == 'common_func':
taskflow_kwargs['flow_type'] = 'common_func'
taskflow_kwargs['current_flow'] = 'func_claim'
# 常规流程，新建后即可执行
else:
taskflow_kwargs['flow_type'] = 'common'
taskflow_kwargs['current_flow'] = 'execute_task'
task = TaskFlowInstance.objects.create(**taskflow_kwargs)
return JsonResponse({
'result': True,
'data': {
'task_id': task.id,
'task_url': task.url,
'pipeline_tree': task.pipeline_tree
}})
def create_task(request, template_id, project_id):
try:
params = json.loads(request.body)
except Exception:
return JsonResponse({
'result': False,
'message': 'invalid json format'
})
project = request.project
template_source = params.get('template_source', PROJECT)
logger.info('apigw create_task info, template_id: {template_id}, project_id: {project_id}, params: {params}'.format(
template_id=template_id,
project_id=project.id,
params=params))
# 兼容老版本的接口调用
if template_source in {BUSINESS, PROJECT}:
try:
tmpl = TaskTemplate.objects.select_related('pipeline_template').get(id=template_id,
project_id=project.id,
is_deleted=False)
if not request.is_trust:
verify_or_raise_auth_failed(principal_type='user',
principal_id=request.user.username,
resource=task_template_resource,
action_ids=[task_template_resource.actions.create_task.id],
instance=tmpl,
status=200)
except TaskTemplate.DoesNotExist:
result = {
'result': False,
'message': 'template[id={template_id}] of project[project_id={project_id} , biz_id{biz_id}] '
'does not exist'.format(template_id=template_id,
project_id=project.id,
biz_id=project.bk_biz_id)}
return JsonResponse(result)
else:
try:
tmpl = CommonTemplate.objects.select_related('pipeline_template').get(id=template_id,
is_deleted=False)
if not request.is_trust:
perms_tuples = [(project_resource, [project_resource.actions.use_common_template.id], project),
(common_template_resource, [common_template_resource.actions.create_task.id], tmpl)]
batch_verify_or_raise_auth_failed(principal_type='user',
principal_id=request.user.username,
perms_tuples=perms_tuples,
status=200)
except CommonTemplate.DoesNotExist:
result = {
'result': False,
'message': 'common template[id={template_id}] does not exist'.format(template_id=template_id)
}
return JsonResponse(result)
try:
params.setdefault('flow_type', 'common')
params.setdefault('constants', {})
params.setdefault('exclude_task_nodes_id', [])
jsonschema.validate(params, APIGW_CREATE_TASK_PARAMS)
except jsonschema.ValidationError as e:
logger.warning(u"apigw create_task raise prams error: %s" % e)
message = 'task params is invalid: %s' % e
return JsonResponse({'result': False, 'message': message})
app_code = getattr(request.jwt.app, settings.APIGW_APP_CODE_KEY)
if not app_code:
message = 'app_code cannot be empty, make sure api gateway has sent correct params'
return JsonResponse({'result': False, 'message': message})
pipeline_instance_kwargs = {
'name': params['name'],
'creator': request.user.username,
}
if 'description' in params:
pipeline_instance_kwargs['description'] = params['description']
try:
result, data = TaskFlowInstance.objects.create_pipeline_instance_exclude_task_nodes(
tmpl, pipeline_instance_kwargs, params['constants'], params['exclude_task_nodes_id'])
except PipelineException as e:
return JsonResponse({'result': False, 'message': e.message})
if not result:
return JsonResponse({'result': False, 'message': data})
task = TaskFlowInstance.objects.create(
project=project,
pipeline_instance=data,
category=tmpl.category,
template_id=template_id,
create_method='api',
create_info=app_code,
flow_type=params.get('flow_type', 'common'),
current_flow='execute_task' if params.get('flow_type', 'common') == 'common' else 'func_claim',
)
return JsonResponse({
'result': True,
'data': {
'task_id': task.id,
'task_url': task.url,
'pipeline_tree': task.pipeline_tree
}})
def collect(request, project_id):
template_id = request.POST.get('template_id')
template_list = json.loads(request.POST.get('template_list', '[]'))
if template_id:
method = request.POST.get('method', 'add')
try:
template = TaskTemplate.objects.get(pk=template_id,
project_id=project_id,
is_deleted=False)
except TaskTemplate.DoesNotExist:
return JsonResponse({
'result':
False,
'message':
'flow[id=%s] does not exist' % template_id
})
verify_or_raise_auth_failed(
principal_type='user',
principal_id=request.user.username,
resource=task_template_resource,
action_ids=[task_template_resource.actions.view.id],
instance=template)
ctx = template.user_collect(request.user.username, method)
return JsonResponse(ctx)
if template_list:
if len(template_list) > 10:
return JsonResponse({
'result':
False,
'message':
u"template list must not larger than 10"
})
user_model = get_user_model()
user = user_model.objects.get(username=request.user.username)
try:
templates = TaskTemplate.objects.filter(pk__in=template_list,
project_id=project_id,
is_deleted=False)
perms_tuples = [(task_template_resource,
[task_template_resource.actions.view.id], t)
for t in templates]
batch_verify_or_raise_auth_failed(
principal_type='user',
principal_id=request.user.username,
perms_tuples=perms_tuples)
collected_template = user.tasktemplate_set.filter(
project_id=project_id)
user.tasktemplate_set.remove(*collected_template)
user.tasktemplate_set.add(*templates)
except Exception as e:
message = u"collect template error: %s" % e
ctx = {'result': False, 'message': message}
else:
ctx = {'result': True, 'data': ''}
return JsonResponse(ctx)
else:
try:
user_model = get_user_model()
user = user_model.objects.get(username=request.user.username)
collected_template = user.tasktemplate_set.filter(
project_id=project_id)
user.tasktemplate_set.remove(*collected_template)
except Exception as e:
message = u"collect template error: %s" % e
ctx = {'result': False, 'message': message}
else:
ctx = {'result': True, 'data': ''}
return JsonResponse(ctx)