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_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 send_cookie_email(submission_participant,
record_information, message=None):
try:
message_body = render_template(
'hepdata_theme/email/invite.html',
name=submission_participant.full_name,
role=submission_participant.role,
title=encode_string(record_information['title'], 'utf-8'),
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net'),
invite_token=submission_participant.invitation_cookie,
message=message)
except UnicodeDecodeError:
message_body = render_template(
'hepdata_theme/email/invite.html',
name=submission_participant.full_name,
role=submission_participant.role,
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net'),
title=None,
invite_token=submission_participant.invitation_cookie,
message=message)
create_send_email_task(submission_participant.email,
"[HEPData] Invitation to be a {0} of record {1} in HEPData".format(
submission_participant.role,
submission_participant.publication_recid), message_body)
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 send_new_review_message_email(review, message, user):
"""
Sends a message to all uploaders to tell them that a
comment has been made on a record
:param hepsubmission:
:param review:
:param user:
:return:
"""
submission_participants = SubmissionParticipant.query.filter_by(
publication_recid=review.publication_recid,
status="primary", role="uploader")
table_information = DataSubmission.query \
.filter_by(id=review.data_recid).one()
record = get_record_by_id(review.publication_recid)
for participant in submission_participants:
message_body = render_template(
'hepdata_theme/email/review-message.html',
name=participant.full_name,
actor=user.email,
table_name=table_information.name,
table_message=message.message,
article=review.publication_recid,
title=record['title'],
link="http://hepdata.net/record/{0}"
.format(review.publication_recid))
create_send_email_task(
participant.email,
'[HEPData] Submission {0} has a new review message.' \
.format(review.publication_recid), message_body)
def send_cookie_email(submission_participant,
record_information,
message=None):
try:
message_body = render_template(
'hepdata_theme/email/invite.html',
name=submission_participant.full_name,
role=submission_participant.role,
title=encode_string(record_information['title']),
site_url=current_app.config.get('SITE_URL',
'https://www.hepdata.net'),
invite_token=submission_participant.invitation_cookie,
message=message)
except UnicodeDecodeError:
message_body = render_template(
'hepdata_theme/email/invite.html',
name=submission_participant.full_name,
role=submission_participant.role,
site_url=current_app.config.get('SITE_URL',
'https://www.hepdata.net'),
title=None,
invite_token=submission_participant.invitation_cookie,
message=message)
create_send_email_task(
submission_participant.email,
"[HEPData] Invitation to be a {0} of record {1} in HEPData".format(
submission_participant.role,
submission_participant.publication_recid), message_body)
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 send_cookie_email(submission_participant,
record_information,
message=None,
version=1):
hepsubmission = get_latest_hepsubmission(
publication_recid=record_information['recid'])
coordinator = User.query.get(hepsubmission.coordinator)
collaboration = _get_collaboration(hepsubmission.coordinator)
message_body = render_template(
'hepdata_theme/email/invite.html',
name=submission_participant.full_name,
role=submission_participant.role,
title=record_information['title'],
site_url=current_app.config.get('SITE_URL', 'https://www.hepdata.net'),
user_account=submission_participant.user_account,
invite_token=submission_participant.invitation_cookie,
status=submission_participant.status,
recid=submission_participant.publication_recid,
version=version,
email=submission_participant.email,
coordinator_email=coordinator.email,
collaboration=collaboration,
message=message)
create_send_email_task(
submission_participant.email,
"[HEPData] Invitation to be {0} {1} of record {2} in HEPData".format(
"an" if submission_participant.role == "uploader" else "a",
submission_participant.role.capitalize(),
submission_participant.publication_recid), message_body)
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 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 notify_subscribers(hepsubmission, record):
subscribers = get_users_subscribed_to_record(hepsubmission.publication_recid)
for subscriber in subscribers:
message_body = render_template(
'hepdata_theme/email/subscriber_notification.html',
article=hepsubmission.publication_recid,
version=hepsubmission.version,
title=record['title'],
link="http://hepdata.net/record/{0}"
.format(hepsubmission.publication_recid))
create_send_email_task(subscriber.get('email'),
'[HEPData] Record update available' \
.format(hepsubmission.publication_recid),
message_body)
def notify_participants(hepsubmission, record, submission_participants):
for participant in submission_participants:
message_body = render_template(
'hepdata_theme/email/finalised.html',
name=participant.full_name,
article=hepsubmission.publication_recid,
version=hepsubmission.version,
title=record['title'],
link="http://hepdata.net/record/{0}"
.format(hepsubmission.publication_recid))
create_send_email_task(participant.email,
'[HEPData] Submission {0} has been finalised and is publicly available' \
.format(hepsubmission.publication_recid),
message_body)
def send_coordinator_request_mail(coordinator_request):
if current_user.is_authenticated:
message_body = render_template(
'hepdata_theme/email/coordinator_request.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')
)
create_send_email_task(current_app.config['ADMIN_EMAIL'],
subject="[HEPData] New Coordinator Request",
message=message_body, reply_to_address=current_user.email)
else:
log.error('Current user is not authenticated.')
def send_coordinator_request_mail(coordinator_request):
if current_user.is_authenticated:
message_body = render_template(
'hepdata_theme/email/coordinator_request.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'))
create_send_email_task(current_app.config['ADMIN_EMAIL'],
subject="[HEPData] New Coordinator Request",
message=message_body,
reply_to_address=current_user.email)
else:
log.error('Current user is not authenticated.')
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 notify_subscribers(hepsubmission, record):
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
subscribers = get_users_subscribed_to_record(
hepsubmission.publication_recid)
for subscriber in subscribers:
message_body = render_template(
'hepdata_theme/email/subscriber_notification.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(
subscriber.get('email'),
'[HEPData] Record update available for submission {0}'.format(
hepsubmission.publication_recid), message_body)
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 send_new_upload_email(recid, user, message=None):
"""
:param recid:
:param user: user object
:param message:
:return:
"""
submission_participants = SubmissionParticipant.query.filter_by(
publication_recid=recid, status="primary", role="reviewer")
if submission_participants.count() == 0:
raise NoReviewersException()
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
record = get_record_by_id(recid)
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/upload.html',
name=participant.full_name,
actor=user.email,
article=recid,
message=message,
invite_token=invite_token,
role=participant.role,
title=record['title'],
site_url=site_url,
link=site_url +
"/record/{0}".format(recid))
create_send_email_task(
participant.email,
'[HEPData] Submission {0} has a new upload available for you to review'
.format(recid), message_body)
def send_new_upload_email(recid, user, message=None):
"""
:param action: e.g. upload or review_message
:param hepsubmission: submission information
:param user: user object
:return:
"""
submission_participants = SubmissionParticipant.query.filter_by(
publication_recid=recid, status="primary", role="reviewer")
if submission_participants.count() == 0:
raise NoReviewersException()
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
record = get_record_by_id(recid)
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/upload.html',
name=participant.full_name,
actor=user.email,
article=recid,
message=message,
invite_token=invite_token,
role=participant.role,
title=record['title'],
site_url=site_url,
link=site_url + "/record/{0}"
.format(recid))
create_send_email_task(participant.email,
'[HEPData] Submission {0} has a new upload available for you to review.'.format(recid),
message_body)
def send_new_review_message_email(review, message, user):
"""
Sends a message to all uploaders to tell them that a
comment has been made on a record
:param hepsubmission:
:param review:
:param user:
:return:
"""
submission_participants = SubmissionParticipant.query.filter_by(
publication_recid=review.publication_recid,
status="primary",
role="uploader")
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)
for participant in submission_participants:
message_body = render_template(
'hepdata_theme/email/review-message.html',
name=participant.full_name,
actor=user.email,
table_name=table_information.name,
table_message=message.message,
article=review.publication_recid,
title=record['title'],
site_url=site_url,
link=site_url + "/record/{0}".format(review.publication_recid))
create_send_email_task(
participant.email,
'[HEPData] Submission {0} has a new review message.' \
.format(review.publication_recid), message_body)
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 _move_files_for_record(rec_id): # pragma: no cover
"""Move data files for given record from old to new location."""
log.debug("Moving files for record %s" % rec_id)
hep_submissions = HEPSubmission.query.filter_by(
publication_recid=rec_id).all()
errors = []
if hep_submissions:
# Need to check both rec_id (for newer submissions) and inspire_id
# (for migrated submissions)
old_paths = [get_old_data_path_for_record(rec_id)]
inspire_id = hep_submissions[0].inspire_id
if inspire_id is not None:
old_paths.append(get_old_data_path_for_record('ins%s' %
inspire_id))
old_paths.append(get_old_data_path_for_record(inspire_id))
log.debug("Checking old paths %s" % old_paths)
old_paths = [path for path in old_paths if os.path.isdir(path)]
new_path = get_data_path_for_record(rec_id)
log.debug("Moving files from %s to %s" % (old_paths, new_path))
os.makedirs(new_path, exist_ok=True)
is_sandbox = hep_submissions[0].overall_status == 'sandbox'
# Find all data resources
resources = _find_all_current_dataresources(rec_id)
for resource in resources:
resource_errors = _move_data_resource(resource,
old_paths,
new_path,
is_sandbox=is_sandbox)
errors.extend(resource_errors)
# Move rest of files in old_paths
for old_path in old_paths:
for dir_name, subdir_list, file_list in os.walk(old_path):
for filename in file_list:
full_path = os.path.join(dir_name, filename)
log.debug("Found remaining file: %s" % full_path)
sub_path = full_path.split(old_path + '/', 1)[1]
new_file_path = os.path.join(new_path, sub_path)
log.debug("Moving %s to %s" % (full_path, new_file_path))
try:
os.makedirs(os.path.dirname(new_file_path),
exist_ok=True)
shutil.move(full_path, new_file_path)
except Exception as e:
errors.append("Unable to move file from %s to %s\n"
"Error was: %s" %
(full_path, new_file_path, str(e)))
# Remove directories, which should be empty
for dirpath, _, _ in os.walk(old_path, topdown=False):
log.debug("Removing directory %s" % dirpath)
try:
os.rmdir(dirpath)
except Exception as e:
errors.append("Unable to remove directory %s\n"
"Error was: %s" % (dirpath, str(e)))
# If there's a zip file from the migration, move that to the new dir too.
if inspire_id is not None:
zip_name = f'ins{inspire_id}.zip'
old_zip_path = os.path.join(current_app.config['CFG_DATADIR'],
zip_name)
if os.path.isfile(old_zip_path):
try:
new_zip_path = os.path.join(new_path, zip_name)
shutil.move(old_zip_path, new_zip_path)
except Exception as e:
errors.append("Unable to move archive file from %s to %s\n"
"Error was: %s" %
(old_zip_path, new_zip_path, str(e)))
else:
errors.append(
"Could not move files for record %s as no matching hepsubmission exists."
% rec_id)
# Send an email with details of errors
if errors:
log.error(errors)
message = "<div>ERRORS moving files for record id %s:<ul><li>\n%s</li></ul></div>" \
% (rec_id, '</li><li>'.join(errors).replace('\n', '<br>'))
create_send_email_task(
current_app.config['ADMIN_EMAIL'],
subject="[HEPData] Errors moving files for record id %s" % rec_id,
message=message,
reply_to_address=current_app.config['ADMIN_EMAIL'])
def clean_remaining_files(synchronous=True): # pragma: no cover
"""
Looks for files in data dir that do not match a known pattern.
For folders that look like a sandbox record (timestamp), check db
and delete.
For everything else, display on the console and send an email.
"""
if _check_for_running_tasks():
# exit as tasks are currently running
return
unknown_files = []
data_dir = current_app.config['CFG_DATADIR']
with os.scandir(data_dir) as entries:
for entry in entries:
log.debug("Checking %s" % entry.path)
recognised = False
if entry.is_dir():
# If dirname has 2 chars it's in our expected format.
if entry.name == 'converted':
recognised = True
elif len(entry.name) == 2:
# Valid dir, but also check subpaths
recognised = True
with os.scandir(entry.path) as subdir_entries:
for sub_entry in subdir_entries:
if not sub_entry.name.isdigit():
unknown_files.append(sub_entry.path)
elif entry.name.isdigit():
# This is probably either a deleted sandbox entry or a hangover from
# a migration from hepdata.cedar.ac.uk that was later deleted
recognised = True
rec_id = int(entry.name)
submission_count = HEPSubmission.query.filter_by(
publication_recid=rec_id).count()
if submission_count == 0:
log.debug("Deleting %s" % entry.path)
shutil.rmtree(entry.path)
else:
log.warning(
"Record id %s is still in old file location" %
entry.name)
if not recognised:
unknown_files.append(entry.path)
if unknown_files:
print(
"The following files/directories were found in %s which were not recognised:"
% data_dir)
for f in unknown_files:
print(" %s" % f)
print(
"These files will remain on the filesystem unless they are manually cleaned up."
)
print("Sending email with this info.")
message = "<div>After moving files, the following files/directories were found in %s which were not recognised:"\
"<ul><li>\n%s</li></ul>" \
"<p>These files will remain on the filesystem unless they are manually cleaned up.</p></div>" \
% (data_dir, '</li><li>'.join(unknown_files))
create_send_email_task(
current_app.config['ADMIN_EMAIL'],
subject="[HEPData] Files remaining in %s after migration" %
data_dir,
message=message,
reply_to_address=current_app.config['ADMIN_EMAIL'])
def process_saved_file(file_path, recid, userid, redirect_url, previous_status):
try:
hepsubmission = get_latest_hepsubmission(publication_recid=recid)
if hepsubmission.overall_status != 'processing' and hepsubmission.overall_status != 'sandbox_processing':
log.error('Record {} is not in a processing state.'.format(recid))
return
errors = process_zip_archive(file_path, recid)
uploader = User.query.get(userid)
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
submission_participant = SubmissionParticipant.query.filter_by(
publication_recid=recid, user_account=userid, role='uploader').first()
if submission_participant:
full_name = submission_participant.full_name
else:
full_name = uploader.email
if errors:
cleanup_submission(recid, hepsubmission.version, []) # delete all tables if errors
message_body = render_template('hepdata_theme/email/upload_errors.html',
name=full_name,
article=recid,
redirect_url=redirect_url.format(recid),
errors=errors,
site_url=site_url)
create_send_email_task(uploader.email,
'[HEPData] Submission {0} upload failed'.format(recid),
message_body)
else:
update_action_for_submission_participant(recid, userid, 'uploader')
message_body = render_template('hepdata_theme/email/upload_complete.html',
name=full_name,
article=recid,
link=redirect_url.format(recid),
site_url=site_url)
create_send_email_task(uploader.email,
'[HEPData] Submission {0} upload succeeded'.format(recid),
message_body)
# Reset the status of the submission back to the previous value.
hepsubmission.overall_status = previous_status
db.session.add(hepsubmission)
db.session.commit()
# Delete any previous upload folders relating to non-final versions
# of this hepsubmission
cleanup_old_files(hepsubmission)
except Exception as e:
# Reset the status and send error emails, unless we're working
# asynchronously and celery is about to retry
if not process_saved_file.request.id \
or process_saved_file.request.retries >= process_saved_file.max_retries:
try:
cleanup_submission(recid, hepsubmission.version, [])
errors = {
"Unexpected error": [{
"level": "error",
"message": "An unexpected error occurred: {}".format(e)
}]
}
uploader = User.query.get(userid)
site_url = current_app.config.get('SITE_URL', 'https://www.hepdata.net')
message_body = render_template('hepdata_theme/email/upload_errors.html',
name=uploader.email,
article=recid,
redirect_url=redirect_url.format(recid),
errors=errors,
site_url=site_url)
create_send_email_task(uploader.email,
'[HEPData] Submission {0} upload failed'.format(recid),
message_body)
log.error("Final attempt of process_saved_file for recid %s failed. Resetting to previous status." % recid)
# Reset the status of the submission back to the previous value.
hepsubmission.overall_status = previous_status
db.session.add(hepsubmission)
db.session.commit()
except Exception as ex:
log.error("Exception while cleaning up: %s" % ex)
else:
log.debug("Celery will retry task, attempt %s" % process_saved_file.request.retries)
raise e
