def get_paper_info(paper_id):
paper = Paper.query.get_or_404(paper_id)
if not paper.if_has_access(current_user):
abort(403)
current_user.set_conference_id(paper.conference_id)
# flag of the edit
edit_flag = False
if current_user in paper.authors:
edit_flag = True
show_all_submission = request.args.get('re', False)
custom_question_answers = {}
if paper.custom_question_answer:
for ans_obj in paper.custom_question_answer.values():
answer = ans_obj['answer']
if answer:
if isinstance(answer, list):
custom_question_answers[ans_obj['desc']] = ', '.join(
ans_obj['answer'])
else:
custom_question_answers[ans_obj['desc']] = answer
return render_template('paper/paper_info.html', paper=paper,
custom_question_answers=custom_question_answers,
edit_flag=edit_flag,
pdf_url=current_app.config['PDF_URL'],
show_all_submission=show_all_submission)
def test1_merge_account(self):
with self.client as c:
response = c.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
self.assertTrue(response.status_code == 200, msg="Login failed.")
current_user.set_conference_id(2)
response = c.get(url_for('auth.settings'))
self.assertTrue(response.status_code == 200, msg='settting page')
response = c.post(
url_for('auth.settings'),
data={
'merge_form-email':
'*****@*****.**',
'merge_form-password':
'******',
'merge_form-submit':
'Merge this account into your current account'
},
follow_redirects=True)
self.assertTrue(
'[email protected] has been merged into you account' in
response.get_data(as_text=True))
def test1_submit_paper(self):
with self.client as c:
response = c.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
self.assertTrue(response.status_code == 200, msg="Login failed.")
current_user.set_conference_id(2)
response = c.get(
url_for('conference.conference_submission_add',
conference_id=2))
self.assertTrue(response.status_code == 200,
msg="Add Submission ICIS2015")
response = c.post(url_for('paper.uploadfile'),
data={
'paper': (StringIO('my file contents'),
'hello world.pdf')
})
self.assertTrue(response.status_code == 201, msg="Upload file")
response = c.post(url_for('conference.conference_submission_add',
conference_id=2),
data=self.paper_1,
follow_redirects=True)
self.assertTrue(Paper.query.order_by(
Paper.id.desc()).first().title == self.paper_1['title'],
msg="Upload paper")
def test2_switch_account(self):
with self.client as c:
response = c.post(url_for('auth.login'),
data={
'email': '*****@*****.**',
'password': '******'
},
follow_redirects=True)
self.assertTrue(response.status_code == 200, msg="Login failed.")
current_user.set_conference_id(2)
user = User.query.filter_by(email='*****@*****.**').first()
response = c.get(url_for('auth.switch_user', user_id=user.id),
follow_redirects=True)
self.assertTrue('Switched to ' +
user.email in response.get_data(as_text=True))
def edit_review(paper_id):
"""Add review for a paper."""
# Code copy pasted from /review code.
success_flag = False
paper = Paper.query.get_or_404(paper_id)
delegation_flag = paper.if_has_subreview(current_user)
if not (paper.reviewers.filter_by(
id=current_user.id).first() or delegation_flag):
abort(403)
# current_user can review the paper
if current_user.curr_conf_id != paper.conference_id:
current_user.set_conference_id(paper.conference_id)
form = ReviewForm()
custom_questions = OrderedDict()
for k, v in current_user.curr_conf.review_questions.items():
if v['include'] is True and v.get('deleted', False) is False:
custom_questions[k] = v
dynamic = WTFormsDynamicFields()
for id, question in custom_questions.items():
if question['ques_type'] != 1:
dynamic.add_field(id, question['desc'], StringField)
else:
# handle multi select
dynamic.add_field(
id, question['desc'], SelectMultipleField,
choices=[(option, option) for option in question['options']],
coerce=unicode)
if question['require']:
dynamic.add_validator(
id, required, message='This field is required')
# form.process(request.form)
if delegation_flag:
review = Review.query.filter(
Review.paper_id == paper_id,
DelegateReview.delegator_id == current_user.id,
DelegateReview.review_id == Review.id).first()
else:
review = paper.reviews.filter_by(reviewer_id=current_user.id).first()
if review:
form.evaluation.data = review.evaluation
form.confidence.data = review.confidence
form.review_body.data = review.review_body
form.confidential_remarks.data = review.confidential_comments
if request.method == 'POST':
form = dynamic.process(ReviewForm, request.form)
if form.validate_on_submit():
custom_question_answer = OrderedDict()
for id, question in custom_questions.items():
custom_question_answer[id] = {
'answer': form.__dict__.get(id + '_1').data if
form.__dict__.get(id + '_1') else '',
'ques_type': question['ques_type'],
'desc': question['desc']
}
# reviewer cannot review same paper more than once
paper = Paper.query.filter_by(id=paper_id).first()
if not review:
review_flag = 'submitted'
review = Review(
paper_id=paper_id,
conference_id=paper.conference.id,
reviewer_id=current_user.id,
evaluation=form.evaluation.data,
confidence=form.confidence.data,
review_body=form.review_body.data,
confidential_comments=form.confidential_remarks.data,
custom_question_answer=custom_question_answer)
db.session.add(review)
# check review delegation
delegation = DelegateReview.query.filter_by(
paper_id=review.paper_id, delegatee_id=current_user.id,
status='Accepted').first()
if delegation:
delegation.review_id = review.id
delegation.status = 'Submitted'
db.session.add(delegation)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
flash(e.message, 'error')
return redirect(url_for('review.edit_review',
paper_id=paper_id))
if delegation:
# send notification to delegator
send_email(
delegation.delegator.email,
current_user.full_name + ' submitted a new review',
'email/review_delegate_new_review',
reply_to=current_user.email,
paper=paper,
delegation_id=delegation.id)
else:
# update review
review_flag = 'updated'
review.evaluation = form.evaluation.data
review.confidence = form.confidence.data
review.review_body = form.review_body.data
review.confidential_comments = form.confidential_remarks.data
review.custom_question_answer = custom_question_answer
db.session.add(review)
db.session.commit()
success_flag = True
send_email(current_user.email,
'A review has been ' + review_flag,
'email/review_update',
paper=paper)
add_event(current_user.full_name + '(' + str(current_user.id) +
') ' + review_flag + ' the review on paper: (' +
str(paper.id) + ') ' + paper.title,
review.to_json_log(),
conference_id=paper.conference_id,
paper_id=paper.id,
review_id=review.id,
type='review_new' if review_flag == 'submitted' else
'review_update')
else:
flash('Problem Validating Form', 'error')
# comments = ReviewComment.query.filter_by(review_id=review.id).order_by(
# ReviewComment.timestamp).all() if review else []
return render_template('review/review_add.html',
form=form,
pdf_url=current_app.config['PDF_URL'],
configuration=paper.track.configuration if
paper.track.configuration.get(
'allow_review_config')
else paper.conference.configuration,
paper=paper, review=review,
delegation_flag=delegation_flag,
success_flag=success_flag,
# comments=comments,
current_time=datetime.utcnow(),
review_answer=review.custom_question_answer if
review else {})
def edit_paper_info(paper_id):
"""Edit paper info."""
paper = Paper.query.get_or_404(paper_id)
# only author or uploader can edit paper
conference = paper.conference
allow_edit_author = False
if current_user.curr_conf_id != conference.id:
current_user.set_conference_id(conference.id)
if not (current_user.id == paper.uploader_id or
current_user in paper.authors or
current_user.is_chair(conference)):
flash('Only authors and uploader can edit this paper', 'error')
abort(403)
else:
allow_edit_author = current_user.is_chair(
conference) or conference.configuration.get(
'allow_edit_paper_author')
if conference.configuration.get('submission_types', False):
setattr(PaperForm,
'submission_type',
SelectField('Submission type *',
coerce=str,
choices=[
(type, type) for type in
conference.configuration.get(
'submission_types').split(',')],
default=paper.submission_type))
else:
# remove the submission_type
if hasattr(PaperForm, 'submission_type'):
delattr(PaperForm, 'submission_type')
form = PaperForm()
tracks = conference.tracks.filter_by(status=True).all()
if len(tracks) == 1:
form.track_id.choices = [
(track.id, track.name) for track in tracks]
else:
form.track_id.choices = [
(track.id, track.name) for track in tracks
if not track.default]
# withdraw_form = WithdrawForm()
dynamic = WTFormsDynamicFields()
dynamic.add_field('author_sendnotification', '', BooleanField)
dynamic.add_field('author_email', 'Email *', StringField)
dynamic.add_field('author_firstname', 'First Name *', StringField)
dynamic.add_field('author_lastname', 'Last Name *', StringField)
dynamic.add_field('author_organization', 'Organization *', StringField)
dynamic.add_field('author_country', 'Country *', StringField)
dynamic.add_field('author_website', 'Website', StringField)
dynamic.add_validator('author_email', required,
message='This field is required')
dynamic.add_validator('author_email', email,
message='This field is required')
dynamic.add_validator('author_firstname', required,
message='This field is required')
dynamic.add_validator('author_lastname', required,
message='This field is required')
dynamic.add_validator('author_organization',
required, message='This field is required')
dynamic.add_validator('author_country', required,
message='This field is required')
for id, question in conference.submission_questions.items():
if question['include'] is True and \
question.get('deleted', False) is False:
if question['ques_type'] != 1:
dynamic.add_field(id, question['desc'], StringField)
else:
# handle multi select
dynamic.add_field(
id,
question['desc'],
SelectMultipleField,
choices=[
(option, option) for option
in question['options']],
coerce=str)
if question['require']:
dynamic.add_validator(
id, required, message='This field is required')
if not paper.is_editable(current_user):
return render_template('paper/paper_info_edit.html', form=form,
user=current_user, paper=paper,
pdf_url=current_app.config['PDF_URL'],
submission_closed=True,
allow_edit_author=allow_edit_author)
if request.method == 'POST':
form = dynamic.process(PaperForm, request.form)
if len(tracks) == 1:
form.track_id.choices = [
(track.id, track.name) for track in tracks]
else:
form.track_id.choices = [
(track.id, track.name) for track in tracks if
not track.default]
if form.validate_on_submit():
custom_question_answer = OrderedDict()
for id, question in conference.submission_questions.\
items():
custom_question_answer[id] = {
'answer':
form.__dict__.get(id + '_1').data if
form.__dict__.get(id + '_1') else '',
'ques_type': question['ques_type'],
'desc': question['desc']
}
# filename field now contains ALL papers
if form.filename.data == '':
flash('There is no file for the paper!', 'error')
return redirect(
url_for('paper.edit_paper_info', paper_id=paper.id))
new_docs = form.filename.data.split(',')[:-1]
# files that can be seen by author and chairs
files_on_record = paper.files.filter_by(
status=UserDocStatus.RECEIVED).all()
for old_file in files_on_record:
if str(old_file.id) not in new_docs:
# if doc.uploader_id != current_user.id:
# flash('You cannot delete file not uploaded by you',
# 'error')
# return render_template(
# 'paper/paper_info_edit.html',
# form=form, user=current_user,
# paper=paper,
# pdf_url=current_app.config['PDF_URL'],
# submission_closed=False,
# withdraw_form=withdraw_form)
# else:
old_file.status = UserDocStatus.DELETED
db.session.add(old_file)
# db.session.commit()
paper_files = UserDoc.query.filter(
UserDoc.id.in_(new_docs)).all()
for f in paper_files:
paper.files.append(f)
# update the paper's title, abstract, keywords and comment
paper.title = form.title.data
paper.abstract = form.abstract.data
paper.keywords = form.keywords.data
paper.comment = form.comment.data
if conference.configuration.get('submission_types', False):
paper.submission_type = form.submission_type.data
paper.custom_question_answer = custom_question_answer
# Turn the dynamic form's data into a dict so we can iterate
# over it easie
form_dict = form.__dict__
if allow_edit_author:
i = 1
while form_dict.get('author_email_' + str(i)):
first_name = form_dict.get(
'author_firstname_' + str(i)).data
last_name = form_dict.get(
'author_lastname_' + str(i)).data
if not check_name(first_name, last_name):
flash('Some fields have problems. Please check.',
'error')
return render_template(
'paper/paper_info_edit.html',
form=form, user=current_user,
paper=paper,
pdf_url=current_app.config['PDF_URL'],
submission_closed=False,
allow_edit_author=allow_edit_author)
i += 1
# update the paper's author list
# empty the list first
paper.authors = []
paper.authors_list = []
i = 1
while form_dict.get('author_email_' + str(i)):
cur_email = form_dict.get(
'author_email_' + str(i)).data
user = User.query.filter_by(email=cur_email).first()
if user is not None:
if user.primary_id:
# add to primary account
user = user.primary_user
if conference.configuration.get(
'submission_limit'):
if not user.can_submit_paper(conference.id):
flash(user.full_name +
' has reached mixmum number of \
submissions', 'error')
return redirect(
url_for('paper.edit_paper_info',
paper_id=paper.id))
paper.authors.append(user)
else:
# add new user if the author doesn't exsit in
# database
pwd = User.generate_pwd()
first_name = form_dict.get(
"author_firstname_" + str(i)).data
last_name = form_dict.get(
"author_lastname_" + str(i)).data
user = User(email=cur_email,
password=pwd,
first_name=first_name,
last_name=last_name,
country=form_dict.get(
'author_country_' + str(i)).data,
website=form_dict.get(
'author_website_' + str(i)).data,
organization=form_dict.get(
'author_organization_' + str(i)
).data,
confirmed=True
)
db.session.add(user)
db.session.commit()
paper.authors.append(user)
if form_dict.get(
'author_sendnotification_' + str(i)):
send_email(cur_email,
'A paper with you as an author has \
been updated',
'email/new_account_coauthor_update',
reply_to=paper.uploader.email,
user=user,
title=form.title.data,
password=pwd)
author = Author(email=cur_email,
user_id=user.id,
first_name=form_dict.get(
'author_firstname_' + str(i)).data,
last_name=form_dict.get(
'author_lastname_' + str(i)).data,
country=form_dict.get(
'author_country_' + str(i)).data,
website=form_dict.get(
'author_website_' + str(i)).data,
organization=form_dict.get(
'author_organization_' + str(i)
).data)
paper.authors_list.append(author)
db.session.add(author)
# db.session.commit()
# send email to inform author
if form_dict.get("author_sendnotification_" + str(i)):
send_email(cur_email,
'A paper with you as an author has been \
updated',
'email/update_notification',
reply_to=paper.uploader.email,
user=user,
title=form.title.data,
conference=conference.name)
i += 1
# commit after loop
paper.record_updated_time()
try:
db.session.add(paper)
db.session.commit()
except Exception:
db.session.rollback()
flash('Operation failed. Please try again or \
contact custom service',
'error')
return redirect(
url_for('paper.get_paper_info', paper_id=paper.id))
flash('Successfully update paper information', 'info')
add_event(current_user.full_name +
'(' + str(current_user.id) + ')' +
' updated paper: (' + str(paper.id) + ') ' +
paper.title,
paper.to_json_log(),
conference_id=paper.conference_id,
paper_id=paper.id,
type='paper_update')
return redirect(
url_for('paper.get_paper_info', paper_id=paper.id))
else:
flash(form.errors, 'error')
return redirect(url_for('paper.edit_paper_info',
paper_id=paper.id))
# fill out the form
form.title.data = paper.title
form.abstract.data = paper.abstract
form.keywords.data = paper.keywords
form.comment.data = paper.comment
return render_template('paper/paper_info_edit.html',
form=form, user=current_user, paper=paper,
submission_closed=False,
pdf_url=current_app.config['PDF_URL'],
allow_edit_author=allow_edit_author)