def get(self, request, project_id, revision=None):
"""
Get a publication. If a revision is not supplied, return
the "Original" publication. Include the latest version if it
is not being queried.
"""
es_client = new_es_client()
pub = BaseESPublication(project_id=project_id,
revision=revision,
using=es_client)
latest_revision = IndexedPublication.max_revision(
project_id=project_id, using=es_client)
latest_pub_dict = None
if latest_revision > 0 and latest_revision != revision:
latest_pub = BaseESPublication(project_id=project_id,
revision=latest_revision,
using=es_client)
if latest_pub is not None and hasattr(latest_pub, 'project'):
latest_pub_dict = latest_pub.to_dict()
if pub is not None and hasattr(pub, 'project'):
pub_dict = pub.to_dict()
if pub_dict['project']['value']['projectType'] != 'other':
metrics.info('Data Depot',
extra={
'user':
request.user.username,
'sessionId':
getattr(request.session, 'session_key', ''),
'operation':
'listing',
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'info': {
'api': 'agave',
'systemId':
'designsafe.storage.published',
'filePath': project_id,
'query': {}
}
})
if latest_pub_dict:
pub_dict['latestRevision'] = latest_pub_dict
return JsonResponse(pub_dict)
else:
return JsonResponse({
'status': 404,
'message': 'Not found'
},
status=404)
def get(self,
request,
api,
operation=None,
scheme='private',
system=None,
path=''):
metrics.info('Data Depot',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': operation,
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'api': api,
'systemId': system,
'filePath': path,
'query': request.GET.dict()
}
})
if request.user.is_authenticated:
try:
client = get_client(request.user, api)
except AttributeError:
raise resource_unconnected_handler(api)
elif api == 'agave':
client = get_user_model().objects.get(
username='******').agave_oauth.client
else:
return JsonResponse(
{'message': 'Please log in to access this feature.'},
status=403)
try:
response = datafiles_get_handler(api,
client,
scheme,
system,
path,
operation,
username=request.user.username,
**request.GET.dict())
return JsonResponse(response)
except (BoxOAuthException, DropboxAuthError, GoogleAuthError):
raise resource_expired_handler(api)
except HTTPError as e:
return JsonResponse({'message': str(e)},
status=e.response.status_code)
def put(self,
request,
api,
operation=None,
scheme='private',
system=None,
path='/'):
body = json.loads(request.body)
metrics.info('Data Depot',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': operation,
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'api': api,
'scheme': scheme,
'system': system,
'path': path,
'body': body
}
})
client = None
if request.user.is_authenticated:
try:
client = get_client(request.user, api)
except AttributeError:
raise resource_unconnected_handler(api)
try:
response = datafiles_put_handler(api,
request.user.username,
client,
scheme,
system,
path,
operation,
body=body)
except HTTPError as e:
return JsonResponse({'message': str(e)},
status=e.response.status_code)
return JsonResponse(response)
def post(self,
request,
api,
operation=None,
scheme='private',
system=None,
path='/'):
post_files = request.FILES.dict()
post_body = request.POST.dict()
metrics.info('Data Depot',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': operation,
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'api': api,
'scheme': scheme,
'system': system,
'path': path,
'body': post_body
}
})
if request.user.is_authenticated:
try:
client = get_client(request.user, api)
except AttributeError:
raise resource_unconnected_handler(api)
response = datafiles_post_handler(api,
request.user.username,
client,
scheme,
system,
path,
operation,
body={
**post_files,
**post_body
})
return JsonResponse(response)
def put(self, request, format):
body = json.loads(request.body)
metrics.info('Data Depot',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': 'transfer',
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'body': body
}
})
src_client = get_client(request.user, body['src_api'])
dest_client = get_client(request.user, body['dest_api'])
notify(request.user.username, 'transfer',
'Copy operation has started.', 'INFO', {})
try:
if format == 'folder':
resp = transfer_folder(src_client, dest_client, **body)
notify(request.user.username, 'transfer',
'Files were successfully copied.', 'SUCCESS', {})
return JsonResponse({'success': True})
else:
resp = transfer(src_client, dest_client, **body)
notify(request.user.username, 'transfer',
'Files were successfully copied.', 'SUCCESS', {})
return JsonResponse({'success': True})
except Exception as exc:
notify(request.user.username, 'transfer',
'Copy operation has failed.', 'ERROR', {})
logger.info(exc)
raise exc
def call_api(request, service):
"""Serves as agave api for apps, files, systems, meta
:param request: http request from angular service
:returns: JSON response for agave call
"""
if request.user.is_authenticated():
try:
token = request.user.agave_oauth
agave = Agave(api_server=settings.AGAVE_TENANT_BASEURL,
token=token.access_token,
resources=AGAVE_RESOURCES)
if service == 'apps':
appId = request.GET.get('appId')
pems = request.GET.get('pems')
if request.method == 'GET':
if appId:
if pems:
metrics.info(
'agave.apps.listPermissions',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.listPermissions',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'appId': appId
}
})
data = agave.apps.listPermissions(appId=appId)
else:
metrics.info(
'agave.apps.get',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.get',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'appId': appId
}
})
data = agave.apps.get(appId=appId)
lic_type = _app_license_type(appId)
data['license'] = {'type': lic_type}
if lic_type is not None:
_, license_models = get_license_info()
license_model = [
x for x in license_models
if x.license_type == lic_type
][0]
lic = license_model.objects.filter(
user=request.user).first()
data['license']['enabled'] = lic is not None
else:
metrics.info('agave.apps.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.list',
'sessionId':
getattr(request.session,
'session_key', ''),
'user':
request.user.username,
'info': {}
})
data = agave.apps.list(search={
'filter': '*',
'available': True
})
elif request.method == 'POST':
body = json.loads(request.body)
if (appId):
if pems:
username = request.GET.get('username')
metrics.info(
'agave.apps.updatePermissionsForUser',
extra={
'operation':
'agave.apps.updatePermissionsForUser',
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'username': username
}
})
data = agave.apps.updatePermissionsForUser(
appId=appId, username=username, body=body)
else:
metrics.info(
'agave.apps.manage',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.manage',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'appId': appId,
'body': body
}
})
data = agave.apps.manage(appId=appId, body=body)
else:
metrics.info('agave.apps.add',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.add',
'sessionId':
getattr(request.session,
'session_key', ''),
'user':
request.user.username,
'info': {
'body': body
}
})
data = agave.apps.add(body=body)
elif request.method == 'DELETE':
metrics.info('apps DELETE')
if appId:
if pems:
username = request.GET.get('username')
metrics.info(
'agave.apps.deletePermissionsForUser',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.deletePermissionsForUser',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'username': username
}
})
data = agave.apps.deletePermissionsForUser(
appId=appId, username=username)
else:
metrics.info(
'agave.apps.delete',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.apps.delete',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'appId': appId
}
})
data = agave.apps.delete(appId=appId)
elif service == 'files':
system_id = request.GET.get('system_id')
path = request.GET.get('path')
metrics.info('agave.files.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.files.list',
'sessionId':
getattr(request.session, 'session_key', ''),
'user':
request.user.username,
'info': {
'system_id': system_id,
'path': path
}
})
if (system_id and path):
data = agave.files.list(systemId=system_id, filePath=path)
elif service == 'systems':
system_id = request.GET.get('system_id')
public = request.GET.get('isPublic')
type = request.GET.get('type')
roles = request.GET.get('roles')
user_role = request.GET.get('user_role')
if request.method == 'GET':
if system_id:
if roles:
metrics.info(
'agave.systems.listRoles',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.listRoles',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'system_id': system_id
}
})
data = agave.systems.listRoles(systemId=system_id)
elif user_role:
metrics.info(
'agave.systems.getRoleForUser',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.getRoleForUser',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'system_id': system_id
}
})
data = agave.systems.getRoleForUser(
systemId=system_id,
username=request.user.username)
else:
metrics.info(
'agave.systems.get',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.get',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'system_id': system_id
}
})
data = agave.systems.get(systemId=system_id)
else:
if (public):
if (type):
logger.debug('SHOULD BE HERE')
metrics.info(
'agave.systems.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.list public',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'public': public,
'type': type
}
})
data = agave.systems.list(public=public,
type=type)
else:
metrics.info(
'agave.systems.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.list public',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'public': public
}
})
data = agave.systems.list(public=public)
else:
if (type):
metrics.info(
'agave.systems.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.list',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'type': type
}
})
data = agave.systems.list(type=type)
else:
metrics.info(
'agave.systems.list',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.systems.list',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {}
})
data = agave.systems.list()
elif service == 'meta':
uuid = request.GET.get('uuid')
pems = request.GET.get('pems')
query = request.GET.get('q')
if request.method == 'GET':
if pems:
if uuid:
metrics.info(
'agave.meta.listMetadataPermissions',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'user':
request.user.username,
'sessionId':
getattr(request.session, 'session_key',
''),
'operation':
'agave.meta.listMetadataPermissions',
'info': {
'uuid': uuid
}
})
data = agave.meta.listMetadataPermissions(
uuid=uuid)
else:
if uuid:
metrics.info(
'agave.meta.getMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.getMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'uuid': uuid
}
})
data = agave.meta.getMetadata(uuid=uuid)
elif query:
metrics.info(
'agave.meta.listMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'query': query
}
})
data = agave.meta.listMetadata(q=query, limit=0)
else:
metrics.info(
'agave.meta.listMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
})
data = agave.meta.listMetadata()
elif request.method == 'POST':
body = json.loads(request.body)
metrics.info('meta POST body',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'body': body
}
})
if pems:
username = request.GET.get('username')
if username:
metrics.info(
'agave.meta.updateMetadataPermissionsForUser',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'user':
request.user.username,
'sessionId':
getattr(request.session, 'session_key',
''),
'info': {
'uuid': uuid,
'username': username
}
})
data = agave.meta.updateMetadataPermissionsForUser(
body=body, uuid=uuid, username=username)
else:
metrics.info(
'agave.meta.updateMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'user':
request.user.username,
'sessionId':
getattr(request.session, 'session_key',
''),
'info': {
'uuid': uuid
}
})
data = agave.meta.updateMetadata(body=body,
uuid=uuid)
index_or_update_project.apply_async(args=[uuid],
queue='api')
else:
if uuid:
metrics.info(
'agave.meta.updateMetadata uuid',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'user':
request.user.username,
'sessionId':
getattr(request.session, 'session_key',
''),
'info': {
'uuid': uuid
}
})
data = agave.meta.updateMetadata(uuid=uuid,
body=body)
index_or_update_project.apply_async(args=[uuid],
queue='api')
else:
metrics.info(
'agave.meta.addMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'body': body
}
})
data = agave.meta.addMetadata(body=body)
elif request.method == 'DELETE':
if uuid:
if pems:
username = request.GET.get('username')
metrics.info(
'agave.meta.deleteMetadataPermissionsForUser',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'username': username
}
})
data = agave.meta.deleteMetadataPermissionsForUser(
uuid=uuid, username=username)
else:
metrics.info(
'agave.meta.deleteMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key',
''),
'user':
request.user.username,
'info': {
'uuid': uuid
}
})
data = agave.meta.deleteMetadata(uuid=uuid)
elif service == 'sync':
uuid = request.GET.get('uuid')
pems = request.GET.get('pems')
appId = request.GET.get('appId')
query = request.GET.get('q')
ds_admin_client = Agave(api_server=getattr(
settings, 'AGAVE_TENANT_BASEURL'),
token=getattr(settings,
'AGAVE_SUPER_TOKEN'))
if request.method == 'GET':
if appId and pems:
metrics.info(
'ds_admin_client.apps.listPermissions',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'ds_admin_client.apps.listPermissions',
'sessionId':
getattr(request.session, 'session_key', ''),
'user':
'******',
'info': {
'appId': appId
}
})
data = ds_admin_client.apps.listPermissions(
appId=appId)
else:
metrics.info('ds_admin_client.meta.listMetadata',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'ds_admin_client.meta.listMetadata',
'sessionId':
getattr(request.session,
'session_key', ''),
'user':
'******',
'info': {
'query': query
}
})
data = ds_admin_client.meta.listMetadata(q=query)
elif request.method == 'POST':
body = json.loads(request.body)
username = request.GET.get('username')
if pems and username:
metrics.info(
'ds_admin_client.meta.updateMetadataPermissionsForUser',
extra={
'agent':
request.META.get('HTTP_USER_AGENT'),
'ip':
get_client_ip(request),
'operation':
'agave.meta.listMetadata',
'sessionId':
getattr(request.session, 'session_key', ''),
'user':
'******',
'info': {
'body': body,
'uuid': uuid,
'username': username
}
})
data = ds_admin_client.meta.updateMetadataPermissionsForUser(
body=body, uuid=uuid, username=username)
else:
return HttpResponse('Unexpected service: %s' % service,
status=400)
except AgaveException as e:
logger.error(
'Failed to execute {0} API call due to AgaveException={1}'.
format(service, e))
return HttpResponse(json.dumps(e),
content_type='application/json',
status=400)
except HTTPError as e:
try:
json_response = e.response.json()
metrics.info(
'Failed to execute {0} API call due to HTTPError={1}'.
format(service, json_response.get('message')),
extra={
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'operation': 'agave.meta.listMetadata',
'sessionId': getattr(request.session, 'session_key',
''),
'user': request.user.username,
'info': {}
})
logger.error(
'Failed to execute {0} API call due to HTTPError={1}'.
format(service, json_response.get('message')))
return HttpResponse(json.dumps(json_response.get('message')),
content_type='application/json',
status=400)
except Exception as e:
return HttpResponse(json.dumps(e),
content_type='application/json',
status=400)
except Exception as e:
metrics.info(
'Failed to execute {0} API call due to Exception={1}'.format(
service, e),
extra={
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'operation': 'agave.meta.listMetadata',
'sessionId': getattr(request.session, 'session_key', ''),
'user': request.user.username,
'info': {}
})
logger.error(
'Failed to execute {0} API call due to Exception={1}'.format(
service, e),
extra={
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'user': request.user.username
})
return HttpResponse(json.dumps({
'status': 'error',
'message': '{}'.format(e)
}),
content_type='application/json',
status=400)
return HttpResponse(json.dumps(data, cls=DjangoJSONEncoder),
content_type='application/json')
else:
return HttpResponse(json.dumps({
'status':
'error',
'message':
'Invalid credentials. Please login.'
}),
content_type='application/json',
status=400)
def post(self, request):
"""
Create a new Project. Projects and the root File directory for a Project should
be owned by the portal, with roles/permissions granted to the creating user.
1. Create the metadata record for the project
2. Create a directory on the projects storage system named after the metadata uuid
3. Associate the metadata uuid and file uuid
:param request:
:return: The newly created project
:rtype: JsonResponse
"""
# portal service account needs to create the objects on behalf of the user
sa_client = get_service_account_client()
if request.is_ajax():
post_data = json.loads(request.body)
else:
post_data = request.POST.copy()
# create Project (metadata)
metrics.info('projects',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': 'project_create',
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'postData': post_data
}
})
prj_model = project_lookup_model({
'name': 'designsafe.project',
'value': post_data
})
prj = prj_model(value=post_data)
project_uuid = prj.uuid
prj.manager().set_client(sa_client)
prj.save(sa_client)
# create Project Directory on Managed system
metrics.info('projects',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': 'base_directory_create',
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'systemId': Project.STORAGE_SYSTEM_ID,
'uuid': prj.uuid
}
})
project_storage_root = BaseFileResource(sa_client,
Project.STORAGE_SYSTEM_ID, '/')
project_storage_root.mkdir(prj.uuid)
# Wrap Project Directory as private system for project
project_system_tmpl = template_project_storage_system(prj)
project_system_tmpl['storage']['rootDir'] = \
project_system_tmpl['storage']['rootDir'].format(project_uuid)
metrics.info('projects',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': 'private_system_create',
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'id':
project_system_tmpl.get('id'),
'site':
project_system_tmpl.get('site'),
'default':
project_system_tmpl.get('default'),
'status':
project_system_tmpl.get('status'),
'description':
project_system_tmpl.get('description'),
'name':
project_system_tmpl.get('name'),
'globalDefault':
project_system_tmpl.get('globalDefault'),
'available':
project_system_tmpl.get('available'),
'public':
project_system_tmpl.get('public'),
'type':
project_system_tmpl.get('type'),
'storage': {
'homeDir':
project_system_tmpl.get('storage',
{}).get('homeDir'),
'rootDir':
project_system_tmpl.get('storage',
{}).get('rootDir')
}
}
})
sa_client.systems.add(body=project_system_tmpl)
# grant initial permissions for creating user and PI, if exists
metrics.info('projects',
extra={
'user': request.user.username,
'sessionId': getattr(request.session, 'session_key',
''),
'operation': 'initial_pems_create',
'agent': request.META.get('HTTP_USER_AGENT'),
'ip': get_client_ip(request),
'info': {
'collab': request.user.username,
'pi': prj.pi
}
})
if getattr(prj, 'copi', None):
prj.add_co_pis(prj.copi)
elif getattr(prj, 'co_pis', None):
prj.add_co_pis(prj.co_pis)
if getattr(prj, 'team', None):
prj.add_team_members(prj.team)
elif getattr(prj, 'team_members', None):
prj.add_team_members(prj.team_members)
prj._add_team_members_pems([prj.pi])
if request.user.username not in list(
set(prj.co_pis + prj.team_members + [prj.pi])):
# Add creator to project as team member
prj.add_team_members([request.user.username])
# Email collaborators
chain(
tasks.set_project_id.s(prj.uuid).set(queue="api")
| tasks.email_collaborator_added_to_project.s(
prj.uuid, prj.title,
request.build_absolute_uri('{}/projects/{}/'.format(
reverse('designsafe_data:data_depot'), prj.uuid)),
[
u
for u in list(set(prj.co_pis + prj.team_members +
[prj.pi])) if u != request.user.username
], [])).apply_async()
tasks.set_facl_project.apply_async(args=[
prj.uuid,
list(set(prj.co_pis + prj.team_members + [prj.pi]))
],
queue='api')
prj.add_admin('prjadmin')
return JsonResponse(prj.to_body_dict(), safe=False)