def notify_submission_created(record, coordinator_id, uploader, reviewer):
coordinator = get_user_from_id(coordinator_id)
if not coordinator:
return
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
name = coordinator.email
coordinator_profile = UserProfile.get_by_userid(coordinator_id)
if coordinator_profile:
name = coordinator_profile.full_name
collaboration = _get_collaboration(coordinator_id)
message_body = render_template('hepdata_theme/email/created.html',
name=name,
actor=coordinator.email,
collaboration=collaboration,
uploader=uploader,
reviewer=reviewer,
article=record['recid'],
title=record['title'],
site_url=site_url,
link=site_url +
"/record/{0}".format(record['recid']))
create_send_email_task(
coordinator.email,
'[HEPData] Submission {0} has been created'.format(record['recid']),
message_body)
def get_pending_invitations_for_user(user):
"""
Returns pending invites for upload or review of records.
:param user: User object
:return: array of pending invites
"""
pending_invites = SubmissionParticipant.query.filter(
func.lower(SubmissionParticipant.email) == func.lower(user.email),
or_(SubmissionParticipant.role == 'reviewer',
SubmissionParticipant.role == 'uploader'),
SubmissionParticipant.status == 'primary',
SubmissionParticipant.user_account == None).all()
result = []
for invite in pending_invites:
publication_record = get_record_by_id(invite.publication_recid)
hepsubmission = get_latest_hepsubmission(
publication_recid=invite.publication_recid)
coordinator = get_user_from_id(hepsubmission.coordinator)
result.append({
'title': decode_string(publication_record['title']),
'invitation_cookie': invite.invitation_cookie,
'role': invite.role,
'coordinator': coordinator
})
return result
def respond_coordinator_privileges(request_id, decision):
"""
Handles a request for coordinator privileges.
:return:
"""
if user_is_admin(current_user):
coordinator_request = CoordinatorRequest.query.filter_by(
id=request_id).one()
if coordinator_request:
coordinator_request.in_queue = False
if decision == 'approve':
coordinator_request.approved = True
coordinator_role = Role.query.filter_by(
name='coordinator').one()
if coordinator_role:
user = get_user_from_id(coordinator_request.user)
if user:
user.roles.append(coordinator_role)
db.session.add(user)
send_coordinator_approved_email(coordinator_request)
else:
return render_template(
'hepdata_records/error_page.html',
recid=None,
message=
"Unable to find a user with id {0} in the system.".
format(coordinator_request.user),
errors={})
else:
return render_template(
'hepdata_records/error_page.html',
recid=None,
message=
"Unable to find the role coordinator in the system.",
errors={})
db.session.add(coordinator_request)
db.session.commit()
return redirect(url_for('hep_dashboard.dashboard'))
return render_template('hepdata_records/error_page.html',
recid=None,
message="No request found with that ID.",
errors={})
abort(403)
def query_messages_for_data_review(data_review_record, messages):
if data_review_record.messages:
data_messages = data_review_record.messages
for data_message in data_messages:
current_user_obj = get_user_from_id(data_message.user)
messages.append(
{"message": data_message.message,
"user": current_user_obj.email,
"post_time": data_message.creation_date})
return messages
def process_coordinators(coordinators):
values = []
for coordinator in coordinators:
user = get_user_from_id(coordinator.user)
_coordinator_dict = {'message': coordinator.message, 'id': coordinator.id,
'approved': coordinator.approved,
'in_queue': coordinator.in_queue,
'collaboration': coordinator.collaboration,
'user': {'id': user.id, 'email': user.email}}
values.append(_coordinator_dict)
return values
def process_coordinators(coordinators):
values = []
for coordinator in coordinators:
user = get_user_from_id(coordinator.user)
_coordinator_dict = {'message': coordinator.message, 'id': coordinator.id,
'approved': coordinator.approved,
'in_queue': coordinator.in_queue,
'collaboration': coordinator.collaboration,
'user': {'id': user.id, 'email': user.email}}
values.append(_coordinator_dict)
return values
def query_messages_for_data_review(data_review_record, messages):
if data_review_record.messages:
data_messages = data_review_record.messages
data_messages.sort(key=lambda data_message: data_message.id, reverse=True)
for data_message in data_messages:
current_user_obj = get_user_from_id(data_message.user)
messages.append(
{"message": data_message.message,
"user": current_user_obj.email,
"post_time": data_message.creation_date})
return messages
def test_get_user_from_id(app):
with app.app_context():
user = get_user_from_id(1)
assert (user)
assert (user.email == TEST_EMAIL)
assert (user_is_admin(user))
assert (user_is_admin(None) is False)
assert (user_is_admin_or_coordinator(user))
assert (user_is_admin_or_coordinator(None) is False)
def send_coordinator_approved_email(coordinator_request):
message_body = render_template(
'hepdata_theme/email/coordinator_approved.html',
collaboration=coordinator_request.collaboration,
message=coordinator_request.message,
user_email=current_user.email,
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net'))
user = get_user_from_id(coordinator_request.user)
if user:
create_send_email_task(
user.email,
subject="[HEPData] Coordinator Request Approved",
message=message_body)
def send_coordinator_approved_email(coordinator_request):
message_body = render_template(
'hepdata_theme/email/coordinator_approved.html',
collaboration=coordinator_request.collaboration,
message=coordinator_request.message,
user_email=current_user.email,
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net')
)
user = get_user_from_id(coordinator_request.user)
if user:
create_send_email_task(user.email,
subject="[HEPData] Coordinator Request Approved",
message=message_body)
def respond_coordinator_privileges(request_id, decision):
"""
Handles a request for coordinator privileges.
:return:
"""
if user_is_admin(current_user):
coordinator_request = CoordinatorRequest.query.filter_by(
id=request_id).one()
if coordinator_request:
coordinator_request.in_queue = False
if decision == 'approve':
coordinator_request.approved = True
coordinator_role = Role.query.filter_by(name='coordinator').one()
if coordinator_role:
user = get_user_from_id(coordinator_request.user)
if user:
user.roles.append(coordinator_role)
db.session.add(user)
else:
return render_template('hepdata_records/error_page.html',
recid=None,
message="Unable to find a user with id {0} in the system.".format(
coordinator_request.user),
errors={})
else:
return render_template('hepdata_records/error_page.html', recid=None,
message="Unable to find the role coordinator in the system.",
errors={})
db.session.add(coordinator_request)
db.session.commit()
send_coordinator_approved_email(coordinator_request)
return redirect(url_for('hep_dashboard.dashboard'))
return render_template('hepdata_records/error_page.html', recid=None,
message="No request found with that ID.",
errors={})
abort(403)
def send_coordinator_notification_email(recid, version, user, message=None):
"""
:param recid:
:param user: user object
:param message: message to send
:return:
"""
hepsubmission = get_latest_hepsubmission(publication_recid=recid)
coordinator = get_user_from_id(hepsubmission.coordinator)
if not coordinator:
raise NoParticipantsException()
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
record = get_record_by_id(recid)
name = coordinator.email
coordinator_profile = UserProfile.get_by_userid(hepsubmission.coordinator)
if coordinator_profile:
name = coordinator_profile.full_name
collaboration = _get_collaboration(hepsubmission.coordinator)
message_body = render_template('hepdata_theme/email/passed_review.html',
name=name,
actor=user.email,
collaboration=collaboration,
article=recid,
version=version,
message=message,
title=record['title'],
site_url=site_url,
link=site_url + "/record/{0}".format(recid),
dashboard_link=site_url + "/dashboard")
create_send_email_task(
coordinator.email,
'[HEPData] Submission {0} is ready to be finalised'.format(recid),
message_body)
def get_pending_invitations_for_user(user):
pending_invites = SubmissionParticipant.query.filter(
SubmissionParticipant.email == user.email,
or_(SubmissionParticipant.role == 'reviewer',
SubmissionParticipant.role == 'uploader'),
SubmissionParticipant.user_account == None
).all()
result = []
for invite in pending_invites:
publication_record = get_record_by_id(invite.publication_recid)
hepsubmission = get_latest_hepsubmission(publication_recid=invite.publication_recid)
coordinator = get_user_from_id(hepsubmission.coordinator)
result.append(
{'title': encode_string(publication_record['title'], 'utf-8'),
'invitation_cookie': invite.invitation_cookie,
'role': invite.role, 'coordinator': coordinator})
return result
def test_get_nonexistant_user(app):
with app.app_context():
user = get_user_from_id(5)
assert (user is None)
def send_notification_email(recid,
version,
user,
reviewers_notified,
message=None,
show_detail=True):
"""
:param recid:
:param user: user object
:param reviewers_notified: whether reviewers have already been notified about this upload
:param show_detail: whether to show the status and messages for each data table
:param message:
:return:
"""
submission_participants = get_submission_participants_for_record(
recid, roles=['uploader', 'reviewer'], status='primary')
if len(submission_participants) == 0:
raise NoParticipantsException()
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
record = get_record_by_id(recid)
tables = []
if show_detail:
data_submissions = DataSubmission.query.filter_by(
publication_recid=recid, version=version)
for data_submission in data_submissions:
table_data = {'name': data_submission.name, 'status': 'todo'}
review = DataReview.query.filter_by(publication_recid=recid,
data_recid=data_submission.id,
version=version).first()
if review:
table_data['status'] = review.status
table_data['messages'] = []
for m in review.messages:
table_data['messages'].append({
'user':
get_user_from_id(m.user).email,
'date':
m.creation_date.strftime("%Y-%m-%d at %H:%M UTC"),
'message':
m.message
})
tables.append(table_data)
for participant in submission_participants:
invite_token = None
if not participant.user_account:
invite_token = participant.invitation_cookie
message_body = render_template(
'hepdata_theme/email/submission_status.html',
name=participant.full_name,
actor=user.email,
article=recid,
message=message,
invite_token=invite_token,
role=participant.role,
show_detail=show_detail,
data_tables=tables,
reviewers_notified=reviewers_notified,
title=record['title'],
site_url=site_url,
link=site_url + "/record/{0}".format(recid))
if participant.role == 'reviewer' and not reviewers_notified:
message_subject = '[HEPData] Submission {0} has a new upload available for you to review'.format(
recid)
else:
message_subject = '[HEPData] Notification about submission {0}'.format(
recid)
create_send_email_task(participant.email, message_subject,
message_body)
