def mutate(cls, root, info,
name, division_id, school_id=None):
user = get_current_user()
if not user:
raise GraphQLError("Invalid user!")
if not school_id:
school_id = user.school_id
school_id = localize_id(school_id)
division_id = localize_id(division_id)
school = School.get_query(info).get(school_id)
division = Division.get_query(info).get(division_id)
if not school:
raise GraphQLError("Invalid school ID!")
if not division:
raise GraphQLError("Invalid division ID")
if not user.isSchoolAdmin(school):
raise GraphQLError("Not an admin for the given school!")
if not division:
raise GraphQLError("Invalid division!")
if division not in school.divisions:
raise GraphQLError(
"Your school does not have access to this division!"
" Reach out to an admin to fix this.")
# create the team
new_team = TeamModel(name, school_id, division_id)
db.session.add(new_team)
db.session.commit()
return CreateTeamMutation(team=new_team)
def resolve_student_contest_attendance(root, info, contest_id, student_id):
return ContestAttendance.get_query(info).get({
'contest_id':
localize_id(contest_id),
'student_id':
localize_id(student_id)
})
def resolve_simple_score_by_contest(root, info, contest_id, student_id):
contest_id = localize_id(contest_id)
student_id = localize_id(student_id)
scores = Score.get_query(info).filter_by(student_id=student_id).filter(
ScoreModel.question.has(contest_id=contest_id)).all()
return map((lambda score: {
'question_num': score.question.question_num,
'points_awarded': score.points_awarded
}), scores)
def mutate(cls, root, info, studentInfo):
user = get_current_user()
print(studentInfo)
studentInfo = clean_input(studentInfo)
# at this point, IDs have been localized.
if not studentInfo.get('school_id'):
studentInfo['school_id'] = user.school_id
if (user.school_id != studentInfo.get('school_id')
and not user.isAdmin()) or not user.isApproved():
raise GraphQLError("Not enough permissions!")
school = School.get_query(info).get(
localize_id(studentInfo.get('school_id'))
)
division = Division.get_query(info).get(
localize_id(studentInfo.get('current_division_id'))
)
if not school:
raise GraphQLError("Invalid school!")
if not division:
raise GraphQLError("Invalid division!")
if not user.isSchoolAdmin(school):
raise GraphQLError("Not an admin for this school!")
if division not in school.divisions:
raise GraphQLError("Invalid division for given school!")
is_alternate = False
if studentInfo.get('is_alternate'):
if studentInfo.get('current_team_id'):
raise GraphQLError(
"Cannot be on a team and an alternate at the same time!")
alternate_limit = division.alternate_limit
n = StudentDivisionAssociationModel.query.filter_by(
division_id=division.id,
is_alternate=True
).filter(
StudentDivisionAssociationModel.student.has(
school_id=school.id
)
).count()
if (n >= alternate_limit):
raise GraphQLError("Too many alternates already!")
is_alternate = True
studentInfo.pop('is_alternate')
student = StudentModel(**studentInfo)
db.session.add(student)
db.session.commit()
division_assoc = StudentDivisionAssociationModel(
student_id=student.id,
division_id=student.current_division_id,
team_id=student.current_team_id,
is_alternate=is_alternate,
)
db.session.add(division_assoc)
db.session.commit()
return CreateStudentMutation(student=student,
id=student.id)
def resolve_student_is_alternate(root, info, contest_id, student_id):
contest_id = localize_id(contest_id)
student_id = localize_id(student_id)
contest = Contest.get_query(info).get(contest_id)
if not contest:
raise GraphQLError("Invalid contest!")
return StudentDivisionAssociation.get_query(info).filter_by(
division_id=contest.division_id,
student_id=student_id,
is_alternate=True).first() is not None
def mutate(cls, root, info, student_id, contest_id):
user = get_current_user()
student_id = localize_id(student_id)
contest_id = localize_id(contest_id)
student = Student.get_query(info).get(student_id)
contest = Contest.get_query(info).get(contest_id)
partially_validate_score_entry(info, user, student, contest)
scores = db.session.query(ScoreModel).filter_by(
student_id=student_id,
).filter(ScoreModel.question.has(
contest_id=contest_id))
scores.delete(synchronize_session='fetch')
db.session.commit()
return DeleteScoreMutation(True)
def mutate(cls, root, info, id, **kwargs):
query = SchoolGrouping.get_query(info)
id = localize_id(id)
schoolGrouping = query.get(id)
fields = clean_input(kwargs)
update_model_with_dict(schoolGrouping, fields)
db.session.add(schoolGrouping)
db.session.commit()
return UpdateSchoolGroupingMutation(schoolGrouping=schoolGrouping)
def mutate(cls, root, info, id, **kwargs):
query = Division.get_query(info)
id = localize_id(id)
divisionToModify = query.get(id)
fields = clean_input(kwargs)
update_model_with_dict(divisionToModify, fields)
db.session.add(divisionToModify)
db.session.commit()
return UpdateDivisionMutation(division=divisionToModify)
def mutate(cls, root, info, scores, student_id, contest_id):
user = get_current_user()
student_id = localize_id(student_id)
contest_id = localize_id(contest_id)
student = Student.get_query(info).get(student_id)
contest = Contest.get_query(info).get(contest_id)
partially_validate_score_entry(info, user, student, contest)
attendance = ContestAttendance.get_query(info).get(
{"student_id": student.id, "contest_id": contest.id}
)
team_id = attendance.team_id
# dealing with whether team is provided, and that
# attendance/alternate confirmation rules have bene followed
# is the duty of the attendance setting mutation
return UpdateScoreMutation(
update_scores(student, contest, user,
team_id, scores))
def mutate(cls, root, info, school_id, code=None):
user = get_current_user()
query = RegistrationCode.get_query(info)
if (code and query.get(code)):
raise GraphQLError("Code not unique!")
else:
newCode = RegistrationCodeModel(localize_id(school_id), user.id,
code)
db.session.add(newCode)
db.session.commit()
return CodeCreationMutation(newCode)
def mutate(cls, root, info, id,
name=None, school_id=None, division_id=None):
user = get_current_user()
if (school_id):
school_id = localize_id(school_id)
id = localize_id(id)
if (division_id):
division_id = localize_id(division_id)
school = School.get_query(info).get(school_id)
division = Division.get_query(info).get(division_id)
# get the team
team = Team.get_query(info).get(id)
if not user:
raise GraphQLError("Invalid user!")
if not team:
raise GraphQLError("Invalid team!")
if school_id and not school:
raise GraphQLError("Invalid school ID!")
if division_id and not division:
raise GraphQLError("Invalid division ID")
if school_id and not user.isSchoolAdmin(school):
raise GraphQLError("Not an admin for the given school!")
if division_id and division not in school.divisions:
raise GraphQLError(
"Your school does not have access to this division!"
" Reach out to an admin to fix this.")
if team.school_id != school.id and not user.isAdmin():
raise GraphQLError("You cannot modify another school's team!")
if name:
team.name = name
if school_id:
if user.isAdmin() or team.school_id == school_id:
team.school_id = school_id
else:
raise GraphQLError("Cannot change a team\'s"
" school unless you are a coach")
if division_id:
team.division_id = division_id
db.session.add(team)
db.session.commit()
return UpdateTeamMutation(team=team)
def resolve_viewer_attendees_by_contest(root, info, contest_id, **kwargs):
user = get_current_user()
contest = Contest.get_query(info).get(localize_id(contest_id))
if not contest:
raise GraphQLError("Invalid contest provided!")
return Student.get_query(info).filter_by(
school_id=user.school_id).filter(
StudentModel.attendance.any(
contest_id=contest.id, attended=True)).order_by(
StudentModel.current_team_id.desc(),
func.lower(StudentModel.last),
func.lower(StudentModel.first),
).all()
def resolve_viewer_students_by_contest(root, info, contest_id, **kwargs):
user = get_current_user()
contest = Contest.get_query(info).get(localize_id(contest_id))
if not contest:
raise GraphQLError("Invalid contest provided!")
return Student.get_query(info).filter_by(
current_division_id=contest.division_id,
school_id=user.school_id).join(
StudentDivisionAssociationModel,
StudentModel.current_division_assoc).order_by(
StudentModel.current_team_id.desc(),
StudentDivisionAssociationModel.is_alternate.desc(),
func.lower(StudentModel.last),
func.lower(StudentModel.first),
).all()
def mutate(cls, root, info,
name, start_time, division_id,
team_size=5, question_count=6, questions=None):
new_contest = ContestModel(name=name,
start_time=start_time,
question_count=question_count,
team_size=team_size
)
new_contest.division_id = localize_id(division_id)
# either use the provided questions, or generate them:
if (not questions):
# if not provided, use default values..
# at this point the query is error safe
db.session.add(new_contest)
db.session.commit()
for question_num in range(1, question_count+1):
new_question = QuestionModel(
contest_id=new_contest.id,
question_num=question_num,
question_value=1)
db.session.add(new_question)
db.session.commit()
db.session.commit()
else:
question_inputs = [None] * question_count
for question in questions:
if (question.question_num not in range(1, question_count+1)):
raise GraphQLError("Invalid Question number provided!")
question_inputs[question.question_num-1] = question
for i in range(0, question_count):
# check if any of the questions are missing
if not question_inputs[i]:
raise GraphQLError("Missing question number " + str(i+1))
db.session.add(new_contest)
db.session.commit()
for question in questions:
# if the questions arent missing
# we can just use their non-altered version
new_question_object = QuestionModel(
new_contest.id,
question.question_num,
question.question_string,
question.question_value)
db.session.add(new_question_object)
db.session.commit()
return CreateContestMutation(new_contest)
def resolve_student(root, info, id):
query = Student.get_query(info)
return query.get(localize_id(id))
def mutate(cls, root, info,
student_id, contest_id, attended, team_id=None):
user = get_current_user()
student_id = localize_id(student_id)
contest_id = localize_id(contest_id)
team_id = localize_id(team_id)
student = Student.get_query(info).get(student_id)
contest = Contest.get_query(info).get(contest_id)
team = Team.get_query(info).get(team_id)
if not user:
raise GraphQLError("Invalid user!")
if not student:
raise GraphQLError("Invalid student!")
if not contest:
raise GraphQLError("Invalid contest!")
if not user.isSchoolAdmin(student.school):
raise GraphQLError("Not an admin for given school!")
school = student.school
if contest.division not in school.divisions:
raise GraphQLError(
"This contest is not available to the given school!")
if student.current_division != contest.division:
raise GraphQLError(
"This student cannot participate in the given contest!")
if team_id and not attended:
raise GraphQLError(
"You cannot be absent while substituting in for a team!")
if not team_id:
return UpdateContestAttendanceMutation(
attendance=update_attendance(
info,
coach_id=user.id,
contest_id=contest_id,
student_id=student_id,
attended=attended,
team_id=team_id
)
)
# if not attended:
# # do not allow changing to "not attended if scores exist"
# scores = db.session.query(ScoreModel).filter_by(
# student_id=student_id,
# ).filter(ScoreModel.question.has(
# contest_id=contest_id))
# if scores and scores.count() <= 0:
# raise GraphQLError("Remove scores first!")
if not team:
raise GraphQLError("Invalid team!")
if team.school != school:
raise GraphQLError("You don't control this team!")
if attended and not student.current_team_id:
division_assoc = StudentDivisionAssociationModel.query.filter_by(
student_id=student.id,
division_id=contest.division_id).first()
if not division_assoc or not division_assoc.is_alternate:
raise GraphQLError("Student not an alternate!")
for student in team.current_students:
if not ContestAttendance.get_query(info).filter_by(
contest_id=contest_id,
student_id=student.id
).first():
raise GraphQLError("Update regular students status first!")
# end loop
participants = ContestAttendance.get_query(info).filter_by(
contest_id=contest_id,
team_id=team_id,
attended=True
)
if (participants.count() >= contest.team_size and
not participants.filter_by(student_id=student_id).first()):
raise GraphQLError("This team already has too many participants!")
return UpdateContestAttendanceMutation(
attendance=update_attendance(
info,
coach_id=user.id,
contest_id=contest_id,
student_id=student_id,
attended=attended,
team_id=team_id
)
)
def mutate(cls, root, info, studentInfo, id):
user = get_current_user()
query = Student.get_query(info)
studentInfo = clean_input(studentInfo)
id = localize_id(id)
studentToModify = query.get(id)
if not studentToModify:
raise GraphQLError("Invalid student!")
if 'school_id' not in studentInfo.keys():
studentInfo['school_id'] = studentToModify.school_id
# at this point, IDs have been localized.
if (user.school_id != studentInfo.get('school_id')
and not user.isAdmin()) or not user.isApproved():
raise GraphQLError("Not enough permissions!")
school = School.get_query(info).get(
studentInfo.get('school_id')
)
division = Division.get_query(info).get(
studentInfo.get('current_division_id')
)
if not school:
raise GraphQLError("School not provided!")
if not division:
division = studentToModify.current_division
if division not in school.divisions:
raise GraphQLError("Invalid division for given school!")
if not user.isSchoolAdmin(school):
raise GraphQLError("Not an admin for this school!")
is_alternate = False
if studentInfo.get('is_alternate'):
if studentInfo.get('current_team_id') or (
(not studentInfo.get('current_team_id')) and
studentToModify.current_team):
raise GraphQLError(
"An alternate cannot actively be on a team!")
alternate_limit = division.alternate_limit
n = StudentDivisionAssociationModel.query.filter_by(
division_id=division.id,
is_alternate=True
).filter(
StudentDivisionAssociationModel.student.has(
school_id=school.id
),
StudentDivisionAssociationModel.student_id != id
).count()
if (n >= alternate_limit):
raise GraphQLError("Too many alternates already!")
is_alternate = True
student = studentToModify
if len(studentInfo) != 0:
update_model_with_dict(studentToModify, studentInfo)
db.session.commit()
# confirmation
studentToModify = query.get(id)
student = studentToModify
# you can only have one associated with current_division_id
old_assoc = StudentDivisionAssociationModel.query.get({
'student_id': student.id,
'division_id': student.current_division_id})
if not old_assoc:
division_assoc = StudentDivisionAssociationModel(
student_id=student.id,
division_id=student.current_division_id,
team_id=student.current_team_id,
is_alternate=is_alternate,
)
db.session.add(division_assoc)
db.session.commit()
else:
old_assoc.is_alternate = is_alternate
db.session.add(old_assoc)
db.session.commit()
return UpdateStudentMutation(student=studentToModify,
id=id)
def resolve_user(root, info, id):
query = User.get_query(info)
return query.get(localize_id(id))
def resolve_school_grouping(root, info):
query = SchoolGrouping.get_query(info)
return query.get(localize_id(id))
def resolve_contest(root, info, id):
return Contest.get_query(info).get(localize_id(id))
def resolve_season(root, info, id):
query = Season.get_query(info)
return query.get(localize_id(id))
def season_exists(field, value, error):
id = localize_id(value)
if not SeasonModel.query.get(id):
error(field, 'Season with id doesnt exist: {}'.format(id))
def mutate(cls, root, info, student_ids, team_id):
user = get_current_user()
team = Team.get_query(info).get(team_id)
if not team:
raise GraphQLError("Invalid Team ID!")
school = team.school
division = team.division
if not user.isSchoolAdmin(team.school):
raise GraphQLError("Not admin for given team!")
students = []
for student_id in student_ids:
student_id = localize_id(student_id)
student = Student.get_query(info).get(student_id)
if not student or student.school != school:
raise GraphQLError("Cannot control student!")
if (student.current_division_id != team.division_id):
raise GraphQLError("Wrong division!")
students.append(student)
if (len(students) > division.team_size):
raise GraphQLError("Too many team members!")
removed_students = list(filter(
lambda student: student not in students,
team.current_students))
added_students = list(filter(
lambda student: student not in team.current_students,
students))
for student in added_students:
if (student.current_team):
raise GraphQLError("Student already on team!")
for student in (added_students+removed_students):
print(len(student.current_scores))
if (len(student.current_scores) != 0):
raise GraphQLError(
"Student already has scores entered!"
" Remove them or contact an admin.")
division_assoc = StudentDivisionAssociationModel. \
query.filter_by(
student_id=student.id, division_id=division.id
).first()
if (division_assoc.is_alternate):
raise GraphQLError(
"Student is already a designated alternate!"
" Remove their alternate status first.")
# if no errors raised so far,we can update
for student in removed_students:
student.current_team_id = None
if team in student.teams:
division_assoc = StudentDivisionAssociationModel. \
query.filter_by(
student_id=student.id, division_id=division.id
).first()
division_assoc.team_id = None
db.session.add(division_assoc)
db.session.commit()
db.session.add(student)
db.session.commit()
for student in added_students:
student.current_team_id = team.id
division_assoc = StudentDivisionAssociationModel. \
query.filter_by(
student_id=student.id, division_id=division.id
).first()
division_assoc.team_id = team.id
db.session.add(division_assoc)
db.session.commit()
db.session.add(student)
db.session.commit()
return SetTeamMembersMutation(team)
def resolve_school(root, info, id):
query = School.get_query(info)
return query.get(localize_id(id))
def resolve_division(root, info, id):
query = Division.get_query(info)
return query.get(localize_id(id))
def successor_exists(field, value, error):
id = localize_id(value)
if not DivisionModel.query.get(id):
error(field, 'Successor with id doesnt exist: {}'.format(id))
