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"