def update_conference_review_config(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if request.json.get('questions'):
review_questions = OrderedDict()
for question in request.json['questions']:
question_json = {
'ques_type': int(question['ques_type']),
'desc': str(question['desc']),
'require': question['require'],
'include': question['include']
}
if question_json['ques_type'] < 2:
question_json['options'] = [
str(option) for option in question['options']
]
review_questions[question['id']] = question_json
conference.review_questions = review_questions
# if request.json.get('review_acceptance_deadline') and request.json['review_acceptance_deadline'].strip() != '':
# conference.review_deadline = datetime.strptime(
# request.json['review_acceptance_deadline'].strip(), '%Y-%m-%d').date()
if request.json.get('setting'):
configuration = deepcopy(conference.configuration)
for key, value in request.json['setting'].iteritems():
configuration[key] = value
conference.configuration = configuration
try:
db.session.add(conference)
db.session.commit()
return 'Success', 200
except Exception:
return 'Content not acceptable', 406
def update_tickets(id):
conference = Conference.query.get_or_404(id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
for ticket_dict in request.json['update_tickets']:
ticket = conference.registration.tickets.filter_by(
id=ticket_dict['ticket_id']).first()
if ticket:
ticket.name = ticket_dict['ticket_title']
try:
ticket.start_date = datetime.strptime(
ticket_dict['start_date'], "%Y-%m-%d").date()
ticket.end_date = datetime.strptime(ticket_dict['end_date'],
"%Y-%m-%d").date()
except ValueError:
return not_acceptable('Wrong value')
for k, v in sorted(ticket_dict['ticket_price'].iteritems()):
price = ticket.prices.filter_by(currency=k).first()
if price:
price.amount = v
else:
price = TicketPrice(currency=k, amount=v)
ticket.prices.append(price)
db.session.add(price)
db.session.add(ticket)
else:
db.session.rollback()
return not_acceptable('Wrong value')
try:
db.session.commit()
return 'Success', 200
except Exception:
db.session.rollback()
return bad_request('Cannot be updated.')
def add_tickets(id):
conference = Conference.query.get_or_404(id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
response_json = []
# print request.json['num_of_tracks']
for add_ticket in request.json['add_tickets']:
try:
ticket = Ticket(name=add_ticket['name'],
start_date=datetime.strptime(
add_ticket['start_date'], "%Y-%m-%d").date(),
end_date=datetime.strptime(add_ticket['end_date'],
"%Y-%m-%d").date(),
registration_id=conference.registration.id)
# for price in add_ticket['price'].
for k, v in sorted(add_ticket['price'].iteritems()):
price = TicketPrice(currency=k, amount=v)
db.session.add(price)
ticket.prices.append(price)
except ValueError:
return not_acceptable('Wrong value')
try:
db.session.add(ticket)
# must commit every time to get the id
db.session.commit()
response_json.append((add_ticket['ticket_div_id'], ticket.id))
except Exception:
db.session.rollback()
return bad_request('Cannot be added.')
# return the id and name of the tracks
return jsonify(response_json)
def update_conference_submission_config(conference_id):
"""Update submission configuration."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if request.json.get('questions'):
submission_questions = OrderedDict()
for question in request.json['questions']:
question_json = {
'ques_type': int(question['ques_type']),
'desc': str(question['desc']),
'require': question['require'],
'include': question['include']
}
if question_json['ques_type'] < 2:
question_json['options'] = [
str(option) for option in question['options']
]
submission_questions[question['id']] = question_json
conference.submission_questions = submission_questions
if request.json.get('setting'):
configuration = deepcopy(conference.configuration)
for key, value in request.json['setting'].iteritems():
if key == 'submission_types':
value = re.sub(r',(\s+)', ',', value)
configuration[key] = value
conference.configuration = configuration
try:
db.session.add(conference)
db.session.commit()
return 'Success', 200
except Exception:
return 'Content not acceptable', 406
def update_conference_user_profile_img(conference_id, user_id):
"""Return user's info."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
user = User.query.get_or_404(user_id)
if not user.is_joined_conference(conference) or not request.json:
return forbidden('Cannot update avatar')
else:
data_url = request.json["dataUrl"].split(',')[-1]
imgdata = base64.b64decode(data_url)
path = os.path.join(os.path.dirname(os.path.dirname(__file__)),
'static', 'upload', 'avatar',
str(user_id) + '-' + str(conference_id) + '.png')
with open(path, 'wb') as f:
try:
f.write(imgdata)
except Exception:
return forbidden('Cannot update avatar')
jointrack = user.tracks.filter_by(track_id=conference.tracks.filter_by(
default=True).first().id).first()
jointrack.profile['avatar'] = '/' + os.path.join(
'static', 'upload', 'avatar',
str(user_id) + '-' + str(conference_id) + '.png')
db.session.add(jointrack)
db.session.commit()
return 'Success', 202
def add_promo_code(registration_id):
"""Add promocode."""
registration = Registration.query.get_or_404(registration_id)
if not current_user.is_chair(registration.conference):
return forbidden('Not allowed')
try:
validate_promo_code(request.json)
except Exception as e:
return bad_request(e.message)
if not PromoCode.query.filter_by(promo_code=request.json['promo_code'],
registration_id=registration.id).first():
promo_code = PromoCode(
promo_code=str(request.json['promo_code']),
type=request.json['promo_type'],
value=float(request.json['promo_value']),
currency=str(request.json['promo_currency']),
quantity=int(request.json['promo_limit']),
start_date=datetime.strptime(
request.json['promo_start'], "%Y-%m-%d").date(),
end_date=datetime.strptime(
request.json['promo_end'], "%Y-%m-%d").date(),
registration_id=registration.id)
try:
db.session.add(promo_code)
db.session.commit()
except Exception as e:
return bad_request(e.message)
return jsonify(promo_code.to_json()), 201
else:
return bad_request('Promo code must be unique')
def get_ticketsale(conference_id):
"""Return the sales data for chart."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
tickets = conference.registration.tickets.filter(
Ticket.number_of_sold > 0).all()
# get the ticket sale number pie chart for a conference
chart_json = {}
pie_json = {}
types = [ticket.name for ticket in tickets]
nums = [ticket.number_of_sold for ticket in tickets]
pie_json['types'] = types
pie_json['nums'] = nums
chart_json['pie'] = pie_json
# get the ticket sales history for a conference
dates = []
sales = []
for ticket_transaction in conference.registration\
.get_ticket_transactions.order_by(
TicketTransaction.timestamp).all():
date = ticket_transaction.timestamp.date().strftime('%Y/%m/%d')
if date not in dates:
dates.append(date)
sales.append(
ticket_transaction.balance_transaction_amount
if ticket_transaction.balance_transaction_amount > 0 else 0)
else:
sales[dates.index(date)] += ticket_transaction.balance_transaction_amount if \
ticket_transaction.balance_transaction_amount > 0 else 0
linechart_json = {'dates': dates, 'sales': sales}
chart_json['linechart'] = linechart_json
return jsonify(chart_json)
def leave_conference(conference_id, user_id):
"""User leaves a conference."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
user = User.query.get_or_404(user_id)
user.leave_conference(conference)
return 'Success', 201
def delete_tracks():
# get the ids * security problem
track = Track.query.get_or_404(request.json['track_id'])
if not current_user.is_chair(track.conference):
return forbidden('Not allowed')
track.status = False
db.session.add(track)
db.session.commit()
return 'Success', 200
def update_conference_user_profile(conference_id, user_id):
"""Return user's info."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
user = User.query.get_or_404(user_id)
if user.set_conference_profile(conference, request.json):
return 'Success', 200
else:
return forbidden('Not allowed')
def get_user_tracks(id, user_id):
conference = Conference.query.get_or_404(id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
user = User.query.get_or_404(user_id)
tracks = conference.tracks.all()
return jsonify(
{
'tracks': [
track.to_json() for track in tracks if user.is_track_chair(track)]})
def update_track_relation(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
track = conference.tracks.filter_by(id=request.json['track_id']).first()
if not track:
return not_acceptable('Wrong Value')
track.parent_track_id = request.json['parent_track_id']
db.session.add(track)
db.session.commit()
return 'Success', 200
def update_product(id):
product = Product.query.get_or_404(id)
if not current_user.is_chair(product.registration.conference):
return forbidden('Not allowed')
if request.json['update'] == 'status':
product.status = request.json['status']
for option in product.options.all():
option.status = request.json['status']
db.session.add(option)
db.session.add(product)
db.session.commit()
return jsonify(product.to_json())
def update_conference_schedule(short_name):
"""Update conference schedule config."""
conference = Conference.query.filter_by(short_name=short_name).first()
if conference:
if not current_user.is_chair(conference):
return forbidden('Not allowed')
conference_schedule = conference.conference_schedule
conference_schedule.publish = request.json.get('publish')
db.session.add(conference_schedule)
db.session.commit()
return 'Success', 200
else:
return bad_request('Conference not found')
def delete_session(conference_id):
"""Update session."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
session = conference.conference_schedule.sessions.filter_by(
id=request.json['session_id']).first()
session.status = 'Deleted'
if session:
db.session.add(session)
db.session.commit()
return 'Success', 200
else:
not_found('No session was found')
def delete_products(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
product = conference.registration.products.filter_by(
id=request.json['delete_ticket_id']).first()
if product and not product_has_sold(product):
product.status = 'Deleted'
db.session.add(product)
try:
db.session.commit()
except:
return 'Failed', 400
return 'Succeed', 200
def delete_tickets(id):
conference = Conference.query.get_or_404(id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
for ticket_id in request.json['delete_tickets']:
ticket = conference.registration.tickets.filter_by(
id=ticket_id).first()
if ticket:
ticket.status = TicketStatus.DELETED
db.session.add(ticket)
else:
db.session.rollback()
return not_acceptable('Wrong value')
db.session.commit()
return 'Success', 200
def get_conference_paper(conference_id):
conference = Conference.query.get_or_404(conference_id)
if current_user.curr_conf_id == 1 or not current_user.is_chair(conference):
return forbidden('Not allowed')
title = request.args.get('name', '')
if title:
papers = conference.get_papers.filter(
Paper.title.contains(title)).all()
paper_list = [{
'text': paper.title,
'id': paper.id
} for paper in papers]
else:
paper_list = []
return jsonify({'papers': paper_list})
def update_conference_config(conference_id):
"""Update conference configuration."""
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if request.json.get('setting'):
configuration = deepcopy(conference.configuration)
for key, value in request.json['setting'].iteritems():
configuration[key] = value
conference.configuration = configuration
try:
db.session.add(conference)
db.session.commit()
return 'Success', 200
except Exception:
return 'Content not acceptable', 406
def edit_session(conference_id):
"""Update session."""
session_data = request.json['data']
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
session = conference.conference_schedule.sessions.filter_by(
id=session_data['session_id']).first()
if session:
session.start_time = datetime.datetime.strptime(
session_data['start_time'], '%Y-%m-%d %H:%M')
session.end_time = datetime.datetime.strptime(session_data['end_time'],
'%Y-%m-%d %H:%M')
if request.json['operation'] == 'update_session':
session.title = session_data['title']
session.venue = session_data['venue']
session.type = session_data['type']
session.description = session_data['description']
if session_data['type'] != 'regular':
session.speakers = []
if session_data.get('speakers'):
for user_id in session_data['speakers']:
session.speakers.append(User.query.get_or_404(user_id))
session.moderators = []
if session_data.get('moderators'):
for user_id in session_data['moderators']:
session.moderators.append(
User.query.get_or_404(user_id))
if session_data['type'] == 'paper':
if session_data['papers']:
session.paper_sessions = []
for paper_info in session_data['papers']:
paper_session = PaperSession(
paper_id=Paper.query.get_or_404(
paper_info.get('paper_id')).id,
session_id=session.id)
if paper_info.get('discussants'):
for user_id in paper_info['discussants']:
paper_session.discussants.append(
User.query.get_or_404(user_id))
db.session.add(paper_session)
session.paper_sessions.append(paper_session)
db.session.add(session)
db.session.commit()
return jsonify(session.to_json()), 200
def update_registration(conference_id):
registration = Conference.query.get_or_404(conference_id).registration
if not current_user.is_chair(registration.conference):
return forbidden('Not allowed')
configuration_setting = byteify(request.json.get('configuration_setting'))
payout = request.json.get('payout')
if configuration_setting:
temp_configuration_setting = {
'instruction': configuration_setting['instruction'],
'questions': []
}
for q in configuration_setting['questions']:
q['id'] = str(q['id'])
if len(registration.private_question):
# print len(registration.private_question)
# print configuration_setting['questions']
private_questions = OrderedDict()
for i in configuration_setting['questions']:
if i['private'] == "true":
private_questions[str(i['id'])] = i
else:
temp_configuration_setting['questions'].append(i)
registration.private_question = private_questions
else:
temp_configuration_setting['questions'] = configuration_setting[
'questions']
# print '***************'
# configuration_setting['questions'][:-len(registration.private_question)]
# configuration_setting['questions'][-len(registration.private_question):]
registration.configuration_setting = temp_configuration_setting
# print registration.private_question
# else:
# handle no private question
# print configuration_setting['questions']
# temp_configuration_setting['questions'] = configuration_setting['questions']
# registration.configuration_setting = temp_configuration_setting
if payout:
registration.payout = {k: v for d in payout for k, v in d.items()}
registration.payout['status'] = 'Pending'
# registration.payout = temp_payout
db.session.add(registration)
db.session.commit()
# print registration.configuration_setting
# print registration.private_question
return 'Success', 200
def conference_admin(short_name):
conference = Conference.query.filter(
Conference.short_name == short_name).first()
if not conference:
return not_found('Not found')
if not current_user.is_chair(conference):
return forbidden('You do not have the permissions')
papers = conference.get_papers.all()
conference_json = {
'short_name':
conference.short_name,
'submissions':
len(papers),
'accepted':
len(filter(lambda paper: paper.status == PaperStatus.ACCEPTED,
papers)),
'rejected':
len(filter(lambda paper: paper.status == PaperStatus.REJECTED,
papers)),
'under_review':
len(
filter(lambda paper: paper.status == PaperStatus.UNDER_REVIEW,
papers)),
'reviews':
len(Review.query.filter_by(conference_id=conference.id).all())
}
additional_status_list = conference.configuration.get(
'additional_status', '').split(',')
conference_json['add_paper_status'] = {}
for status in additional_status_list:
if status:
conference_json['add_paper_status'][status] = len(
filter(lambda paper: paper.status == status, papers))
review_assignments = db.session.query(paper_reviewer).filter(
paper_reviewer.c.paper_id.in_(map(lambda paper: paper.id,
papers))).all()
conference_json['review_assignments'] = len(review_assignments)
conference_json['no_assignment_paper'] = len(
filter(
lambda paper: paper.id not in map(
lambda assignment: assignment.paper_id, review_assignments),
papers))
# conference_json['no_assignment_paper'] = len()
return jsonify(conference_json)
def update_review_question(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if not request.json:
return bad_request('Empty question list')
else:
review_questions = OrderedDict()
if request.json[0]:
try:
validate_request_json(request.json)
except Exception as e:
return bad_request(e.message)
for question in request.json[::-1]:
question_json = {
'ques_type':
int(question['ques_type']),
'desc':
question['desc'].encode('utf-8'),
'require':
question['require'],
'include':
question['include'],
'id':
question['uuid'] if question.get('uuid', False)
and len(question['uuid']) >= 3 else generate_uuid(),
'numid':
question['numid']
}
if question_json['ques_type'] < 2:
question_json['options'] = [
option.encode('utf-8')
for option in question['options']
]
review_questions[question_json['id']] = question_json
# curr_questions = conference.review_questions
conference.review_questions = review_questions
# conference.review_deadline = datetime.strptime(
# request.json['review_acceptance_deadline'], "%Y-%m-%d").date()
db.session.add(conference)
db.session.commit()
return jsonify(dict(enumerate(review_questions))), 200
def update_registration_question(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if not request.json:
return bad_request('Empty question list')
else:
registration_questions = OrderedDict()
# curr_questions = conference.registration.private_question
# if no of customized question > 0
if request.json[0]:
try:
validate_request_json(request.json)
except Exception as e:
return bad_request(e.message)
for question in request.json[::-1]:
question_json = {
'ques_type':
int(question['ques_type']),
'desc':
question['desc'].encode('utf-8'),
'require':
True,
'include':
True,
'id':
question['uuid'] if question.get('uuid', False)
and len(question['uuid']) >= 3 else generate_uuid(),
'numid':
question['numid']
}
if question_json['ques_type'] < 2:
question_json['options'] = [
option.encode('utf-8')
for option in question['options']
]
registration_questions[question_json['id']] = question_json
conference.registration.private_question = registration_questions
db.session.add(conference)
db.session.commit()
return jsonify(dict(enumerate(registration_questions))), 200
def change_conference_role(conf_id, user_id, role_name):
if role_name == 'PC':
role_name = 'Program Committee'
# elif role_name == 'TC':
# role_name = 'Track Chair'
conference = Conference.query.get_or_404(conf_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
user = User.query.get_or_404(user_id)
role = Role.query.filter_by(name=role_name).first()
if user == current_user:
# cannot change its own role
return bad_request('')
if role:
if user.is_chair(conference) and len(conference.chairs) == 1 and role_name != "Chair":
return 'The conference must have at least one chair', 400
else:
user.update_conference_role(conference, role)
return 'Success', 200
else:
return bad_request('Cannot find the role')
def update_conference(id):
conference = Conference.query.get_or_404(id)
if not request.json:
return 'Bad request', 400
if not current_user.is_chair(conference):
return forbidden('Not allowed')
else:
update_contact = False
if request.json['contact_email'] != conference.contact_email and \
conference.configuration.get('wordpress_activation'):
update_contact = True
subjects = ';'.join(request.json['subjects'])
website = request.json['website'].replace('http://',
'').replace('https://', '')
conference.name = request.json['name']
conference.short_name = request.json['short_name']
conference.website = website
conference.contact_email = request.json['contact_email']
conference.contact_phone = request.json['contact_phone']
conference.address = request.json['address']
conference.city = request.json['city']
conference.state = request.json['state']
conference.country = request.json['country']
conference.start_date = datetime.strptime(request.json['start_date'],
"%Y-%m-%d").date()
conference.end_date = datetime.strptime(request.json['end_date'],
"%Y-%m-%d").date()
conference.timezone = request.json['timezone']
conference.info = request.json['info']
conference.subjects = subjects
conference.tags = request.json['tags']
# conference.featured = request.json['featured']
db.session.add(conference)
db.session.commit()
if update_contact:
wordpress_update_contact(conference)
return 'Success', 200
def edit_transaction():
if not request.json \
or 'ticket_transaction_id' not in request.json\
or 'first_name' not in request.json \
or 'last_name' not in request.json \
or 'email' not in request.json \
or 'affiliation' not in request.json:
return 'Bad request', 400
else:
id = request.json['ticket_transaction_id']
transaction = TicketTransaction.query.get_or_404(id)
if not current_user.is_chair(transaction.registration.conference):
return forbidden('Not allowed')
transaction.attendee_info['First Name'] = request.json['first_name']
transaction.attendee_info['Last Name'] = request.json['last_name']
transaction.attendee_info['Email'] = request.json['email']
transaction.attendee_info['Affiliation'] = request.json['affiliation']
db.session.add(transaction)
db.session.commit()
return jsonify(transaction.to_json())
def delete_review_question(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
if not request.json:
return bad_request('Empty question list')
else:
curr_questions = conference.review_questions
id = str(request.json['numid'])
for uuid, question in curr_questions.items():
if question['numid'] == id:
curr_questions.pop(str(uuid))
questions = OrderedDict()
id = 0
for uuid, question in curr_questions.items():
question['numid'] = str(id)
questions[uuid] = question
id = id + 1
conference.review_questions = questions
db.session.add(conference)
db.session.commit()
return jsonify(dict(enumerate(questions))), 200
def update_payout(conference_id):
conference = Conference.query.get_or_404(conference_id)
if not current_user.is_chair(conference):
return forbidden('Not allowed')
payout = conference.registration.payout
if request.json and payout.status != 'Completed':
payout.account_name = request.json.get('account_name')
payout.street_1 = request.json.get('address_1')
payout.street_2 = request.json.get('address_2')
payout.city = request.json.get('city')
payout.state = request.json.get('state')
payout.country = request.json.get('country')
payout.zipcode = request.json.get('zipcode')
payout.payment_method = request.json.get('payment_method')
payout.bank_name = request.json.get('bank_name')
payout.account_type = request.json.get('account_type')
payout.routing_number = request.json.get('routing_number')
payout.account_number = request.json.get('account_number')
db.session.add(payout)
db.session.commit()
return 'Success', 200
else:
return 'Bad request', 400
def update_promo_code(registration_id):
"""Update promo code."""
registration = Registration.query.get_or_404(registration_id)
if not current_user.is_chair(registration.conference):
return forbidden('Not allowed')
if not request.json.get('promo_code_id', None):
return bad_request('Invalid promo code id.')
promo_code = registration.promo_codes.filter_by(
id=request.json['promo_code_id']).first()
if not promo_code:
return bad_request('Invalid promo code.')
if request.json['action'] == 'disable':
promo_code.status = 'Inactive'
elif request.json['action'] == 'enable':
promo_code.status = 'Active'
elif request.json['action'] == 'edit':
try:
validate_promo_code(request.json['promo_code'])
except Exception as e:
return bad_request(e.message)
promo_code.promo_code = str(request.json['promo_code']['promo_code'])
promo_code.type = request.json['promo_code']['promo_type']
promo_code.currency = str(request.json['promo_code']['promo_currency'])
promo_code.value = float(request.json['promo_code']['promo_value'])
promo_code.quantity = int(request.json['promo_code']['promo_limit'])
promo_code.start_date = datetime.strptime(
request.json['promo_code']['promo_start'], "%Y-%m-%d").date()
promo_code.end_date = datetime.strptime(
request.json['promo_code']['promo_end'], "%Y-%m-%d").date()
else:
return bad_request('Invalid action')
try:
db.session.add(promo_code)
db.session.commit()
except Exception as e:
return bad_request(e.message)
return jsonify(promo_code.to_json())
