def send_question_email(question):
reply_to = current_user.email
submission = get_latest_hepsubmission(
publication_recid=question.publication_recid)
submission_participants = get_submission_participants_for_record(
question.publication_recid)
if submission:
destinations = [current_app.config['ADMIN_EMAIL']]
for submission_participant in submission_participants:
destinations.append(submission_participant.email)
coordinator = User.query.get(submission.coordinator)
if coordinator.id > 1:
destinations.append(coordinator.email)
if len(destinations) > 0:
message_body = render_template('hepdata_theme/email/question.html',
inspire_id=submission.inspire_id,
user_email=reply_to,
site_url=current_app.config.get(
'SITE_URL',
'https://www.hepdata.net'),
message=question.question)
create_send_email_task(
destination=','.join(set(destinations)),
subject="[HEPData] Question for record ins{0}".format(
submission.inspire_id),
message=message_body,
reply_to_address=reply_to)
def notify_publication_update(hepsubmission, record):
destinations = []
coordinator = User.query.get(hepsubmission.coordinator)
if coordinator.id > 1:
destinations.append(coordinator.email)
submission_participants = get_submission_participants_for_record(
hepsubmission.publication_recid)
for participant in submission_participants:
destinations.append(participant.email)
if not destinations:
destinations.append(current_app.config['ADMIN_EMAIL'])
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
message_body = render_template(
'hepdata_theme/email/publication_update.html',
inspire_id=hepsubmission.inspire_id,
title=record['title'],
site_url=site_url,
link=site_url + "/record/ins{0}".format(hepsubmission.inspire_id))
create_send_email_task(
','.join(set(destinations)),
'[HEPData] Record ins{0} has updated publication information from INSPIRE'
.format(hepsubmission.inspire_id), message_body)
def index_submission(self, submission):
participants = []
for sub_participant in get_submission_participants_for_record(submission.publication_recid):
participants.append({'full_name': sub_participant.full_name, 'role': sub_participant.role})
record_information = get_record_contents(submission.publication_recid,
submission.overall_status)
data_count = DataSubmission.query.filter(DataSubmission.publication_recid == submission.publication_recid,
DataSubmission.version == submission.version).count()
if record_information:
collaboration = ','.join(record_information.get('collaborations', []))
self.add_to_index(_id=submission.publication_recid,
title=record_information['title'],
collaboration=collaboration,
recid=submission.publication_recid,
inspire_id=submission.inspire_id,
status=submission.overall_status,
data_count=data_count,
creation_date=submission.created,
last_updated=submission.last_updated,
version=submission.version,
participants=participants,
coordinator=submission.coordinator)
def notify_participants(hepsubmission, record):
destinations = []
coordinator = User.query.get(hepsubmission.coordinator)
if coordinator.id > 1:
destinations.append(coordinator.email)
submission_participants = get_submission_participants_for_record(
hepsubmission.publication_recid)
for participant in submission_participants:
destinations.append(participant.email)
if not destinations:
destinations.append(current_app.config['ADMIN_EMAIL'])
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
message_body = render_template(
'hepdata_theme/email/finalised.html',
article=hepsubmission.publication_recid,
version=hepsubmission.version,
title=record['title'],
site_url=site_url,
link=site_url + "/record/ins{0}?version={1}".format(
hepsubmission.inspire_id, hepsubmission.version))
create_send_email_task(
','.join(set(destinations)),
'[HEPData] Submission {0} has been finalised and is publicly available'
.format(hepsubmission.publication_recid), message_body)
def determine_user_privileges(recid, ctx):
# show_review_area = not show_upload_area
ctx['show_review_widget'] = False
ctx['show_upload_widget'] = False
ctx['is_submission_coordinator_or_admin'] = False
ctx['is_admin'] = False
if current_user.is_authenticated:
user_id = current_user.get_id()
participant_records = get_submission_participants_for_record(recid, user_account=user_id)
for participant_record in participant_records:
if participant_record is not None:
if participant_record.role == 'reviewer' and participant_record.status == 'primary':
ctx['show_review_widget'] = True
if participant_record.role == 'uploader' and participant_record.status == 'primary':
ctx['show_upload_widget'] = True
user = User.query.get(current_user.get_id())
if has_role(user, 'admin'):
ctx['is_submission_coordinator_or_admin'] = True
ctx['is_admin'] = True
else:
matching_records = HEPSubmission.query.filter_by(
publication_recid=recid,
coordinator=current_user.get_id()).count()
if matching_records > 0:
ctx['is_submission_coordinator_or_admin'] = True
ctx['show_upload_widget'] = (
ctx['show_upload_widget'] or ctx[
'is_submission_coordinator_or_admin'])
def send_question_email(question):
reply_to = current_user.email
submission = get_latest_hepsubmission(publication_recid=question.publication_recid)
submission_participants = get_submission_participants_for_record(question.publication_recid)
if submission:
destinations = [current_app.config['ADMIN_EMAIL']]
for submission_participant in submission_participants:
destinations.append(submission_participant.email)
if submission.coordinator > 1:
destinations.append(submission.coordinator.email)
if len(destinations) > 0:
message_body = render_template(
'hepdata_theme/email/question.html',
inspire_id=submission.inspire_id,
user_email=reply_to,
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net'),
message=question.question)
create_send_email_task(destination=','.join(destinations),
subject="[HEPData] Question for record ins{0}".format(submission.inspire_id),
message=message_body, reply_to_address=reply_to)
def send_finalised_email(hepsubmission):
submission_participants = get_submission_participants_for_record(
hepsubmission.publication_recid)
record = get_record_by_id(hepsubmission.publication_recid)
notify_participants(hepsubmission, record, submission_participants)
notify_subscribers(hepsubmission, record)
def send_new_review_message_email(review, message, user):
"""
Sends a message to all uploaders and reviewers to tell them that a
comment has been made on a record.
:param review:
:param message:
:param user:
:return:
"""
submission_participants = get_submission_participants_for_record(
review.publication_recid)
table_information = DataSubmission.query.filter_by(
id=review.data_recid).one()
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
record = get_record_by_id(review.publication_recid)
destinations = [
participant.email for participant in submission_participants
]
full_names = [
participant.full_name for participant in submission_participants
]
message_body = render_template(
'hepdata_theme/email/review-message.html',
name=', '.join(set(full_names)),
actor=user.email,
table_name=table_information.name,
table_message=decode_string(message.message),
article=review.publication_recid,
title=record['title'],
site_url=site_url,
link=site_url + "/record/{0}".format(review.publication_recid),
table_link=site_url + "/record/{0}?table={1}".format(
review.publication_recid, table_information.name.replace(
'+', '%2B')))
create_send_email_task(
','.join(set(destinations)),
'[HEPData] Submission {0} ({1}) has a new review message'.format(
review.publication_recid, table_information.name), message_body)
def get_coordinator_view(recid):
"""
Returns the coordinator view for a record.
:param recid:
"""
hepsubmission_record = get_latest_hepsubmission(publication_recid=recid)
participants = {"reviewer": {"reserve": [], "primary": []},
"uploader": {"reserve": [], "primary": []}}
record_participants = get_submission_participants_for_record(recid)
for participant in record_participants:
if participant.role in participants:
participants[participant.role][participant.status].append(
{"full_name": participant.full_name, "email": participant.email,
"id": participant.id})
return json.dumps(
{"recid": recid,
"primary-reviewers": participants["reviewer"]["primary"],
"reserve-reviewers": participants["reviewer"]["reserve"],
"primary-uploaders": participants["uploader"]["primary"],
"reserve-uploaders": participants["uploader"]["reserve"]})
def prepare_submissions(current_user,
items_per_page=25,
current_page=1,
record_id=None):
"""
Finds all the relevant submissions for a user, or all submissions if the logged in user is a 'super admin'.
:param current_user: User obj
:param items_per_page: maximum number of items to return
:param current_page: page of current set of results (starting at 1)
:return: OrderedDict of submissions
"""
submissions = OrderedDict()
query = _prepare_submission_query(current_user)
if record_id:
query = query.filter(HEPSubmission.publication_recid == record_id)
offset = (current_page - 1) * items_per_page
hepdata_submission_records = query.order_by(
HEPSubmission.last_updated.desc()).limit(items_per_page).offset(
offset).all()
for hepdata_submission in hepdata_submission_records:
if str(hepdata_submission.publication_recid) not in submissions:
coordinator = User.query.get(hepdata_submission.coordinator)
participants = get_submission_participants_for_record(
hepdata_submission.publication_recid,
user_account=current_user.id)
if participants:
current_user_roles = []
for participant in participants:
current_user_roles.append(participant.role)
create_record_for_dashboard(
str(hepdata_submission.publication_recid),
submissions,
current_user,
coordinator=coordinator,
user_role=current_user_roles,
status=hepdata_submission.overall_status)
else:
create_record_for_dashboard(
str(hepdata_submission.publication_recid),
submissions,
current_user,
coordinator=coordinator,
status=hepdata_submission.overall_status)
# we update the counts for the number of data tables in various
# states of review
statuses = ["todo", "attention", "passed"]
for status in statuses:
status_count = DataReview.query.filter_by(
publication_recid=hepdata_submission.publication_recid,
status=status,
version=hepdata_submission.version).count()
if str(hepdata_submission.publication_recid) in submissions:
submissions[str(hepdata_submission.publication_recid
)]["stats"][status] += status_count
return submissions
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)
def test_create_submission(live_server, logged_in_browser):
"""Create submission test"""
browser = logged_in_browser
inspire_id = '1830840'
# First confirm there are no submissions for our inspire id
submissions = HEPSubmission.query.filter_by(inspire_id=inspire_id).all()
assert len(submissions) == 0
# Click "submit"
submit_link = browser.find_element_by_link_text('Submit')
submit_link.click()
# Check we're at the submission page
e2e_assert_url(browser, 'submission.submit_ui')
inspire_details_div = browser.find_element_by_id('inspire_details')
assert "Do you have an Inspire record associated with your submission?" \
in inspire_details_div.text
# Click "Yes" and check continue button appears
browser.find_element_by_id('has_inspire').click()
continue_button = browser.find_element_by_id('continue_btn')
e2e_assert(browser, not continue_button.is_enabled())
# Fill in inspire id and check continue button is now enabled
browser.find_element_by_id('inspire_id').send_keys(inspire_id)
e2e_assert(browser, continue_button.is_enabled())
# Click 'continue'
continue_button.click()
# Wait for inspire details to load
WebDriverWait(browser, 10).until(
EC.presence_of_element_located((By.CSS_SELECTOR, "#inspire-result .publication-info"))
)
# Click continue and wait for animation to finish
browser.find_element_by_id('preview_continue_btn').click()
WebDriverWait(browser, 10).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, "#reviewers_uploaders h4"))
)
# Check for reviewer/uploader form
reviewers_uploaders_title = browser.find_element_by_css_selector('#reviewers_uploaders h4')
assert "Please specify the Uploader and Reviewer for this submission" \
in reviewers_uploaders_title.text
# Fill in uploader/reviewer and submit
browser.find_element_by_id('uploader_name').send_keys('Ursula Uploader')
browser.find_element_by_id('uploader_email').send_keys('*****@*****.**')
browser.find_element_by_id('reviewer_name').send_keys('Rachel Reviewer')
browser.find_element_by_id('reviewer_email').send_keys('*****@*****.**')
# Click continue and wait for animation to finish
browser.find_element_by_id('people_continue_btn').click()
WebDriverWait(browser, 10).until(
EC.visibility_of_element_located((By.CSS_SELECTOR, "#uploader_message h4"))
)
# Add message for uploader
browser.find_element_by_id('uploader-message-input').send_keys('Please could you upload something?')
# Click continue and wait for animation to finish
browser.find_element_by_id('message_continue_btn').click()
submission_state_p = WebDriverWait(browser, 10).until(
EC.text_to_be_present_in_element(
(By.CSS_SELECTOR, "#submission_state p"),
"You are about to create a submission for")
)
# Click continue and wait for animation to finish
browser.find_element_by_id('submit_btn').click()
submission_state_p = WebDriverWait(browser, 10).until(
EC.text_to_be_present_in_element(
(By.CSS_SELECTOR, "#submission_state p"),
"Submission Complete!"
)
)
# Check that submission has been created in DB
submissions = HEPSubmission.query.filter_by(
inspire_id=inspire_id).all()
assert len(submissions) == 1
assert submissions[0].overall_status == 'todo'
assert submissions[0].version == 1
participants = sorted(
get_submission_participants_for_record(submissions[0].publication_recid),
key=lambda p: p.role
)
assert participants[0].role == "reviewer"
assert participants[0].email == "*****@*****.**"
assert participants[0].status == "primary"
assert participants[1].role == "uploader"
assert participants[1].email == "*****@*****.**"
assert participants[1].status == "primary"
