def get(self, contest_id: int, problem_id: int, run_id: int):
contest_visibility = db.session.query(Contest.protocol_visibility) \
.filter_by(id=contest_id).join(Statement) \
.join(StatementProblem) \
.filter(StatementProblem.problem_id == problem_id) \
.one_or_none()
if contest_visibility is None:
raise BadRequest('Неправильный ID протокола или задачи')
contest_visibility = contest_visibility and contest_visibility[0]
if contest_visibility is ContestProtocolVisibility.INVISIBLE:
raise NotFound('Просмотр протокола для этой посылки недоступен')
context, status = internal_rmatics.get_full_run_protocol(run_id, current_user.id)
if status > 299:
return jsonify(context, status_code=status)
# TODO: NFRMTCS-192: нужен контекст,
# TODO: чтобы нельзя было смотреть любой протокол, найдя открытый воркшоп
protocol = self._remove_fields_from_full_protocol(context)
if contest_visibility is ContestProtocolVisibility.FIRST_BAD_TEST:
protocol = self._remove_all_after_bad_test(protocol)
return jsonify(protocol, status_code=status)
def get(self, course_module_id):
course_module = db.session.query(CourseModule) \
.filter(CourseModule.id == course_module_id) \
.filter(CourseModule.visible == 1) \
.one_or_none()
if course_module is None:
raise NotFound(f'Cannot find course module id #{course_module_id}')
contest = course_module.instance
if not isinstance(contest, Statement):
raise BadRequest('This resource is not implemented yet')
problems_statement_problems = db.session.query(Problem, StatementProblem) \
.join(StatementProblem, StatementProblem.problem_id == Problem.id) \
.filter(StatementProblem.statement_id == contest.id) \
.filter(StatementProblem.hidden == 0) \
.options(Load(Problem).load_only('id', 'name')) \
.options(Load(StatementProblem).load_only('rank'))
problems = []
# Yes it is ugly but I think its better than rewrite query
for problem, sp in problems_statement_problems.all():
problem.rank = sp.rank
problems.append(problem)
contest.problems = problems
contest_schema = ContestSchema()
response = contest_schema.dump(contest)
return jsonify(response.data)
def get(self, workshop_id):
# Get first as only one WorkshopConnection may exist due to unique constraints
workshop_connection: WorkshopConnection = db.session.query(WorkshopConnection) \
.filter(WorkshopConnection.workshop_id == workshop_id,
WorkshopConnection.user_id == current_user.id,
# Allow view workshops only for user with ACCEPTED (students)
# or PROMOTED (teacher or workshop owners) status
WorkshopConnection.status.in_((WorkshopConnectionStatus.ACCEPTED,
WorkshopConnectionStatus.PROMOTED)),
# Workshop should be active and visible
WorkShop.status == WorkshopStatus.ONGOING) \
.options(joinedload(WorkshopConnection.workshop)
.joinedload(WorkShop.contests)
.joinedload(Contest.statement)) \
.one_or_none()
if workshop_connection is None:
raise NotFound(f'Сбор с id #{workshop_id} не найден')
workshop_serializer: WorkshopSchema = WorkshopSchema(exclude=[
'contests.statement.problems',
])
response: MarshalResult = workshop_serializer.dump(workshop_connection.workshop)
return jsonify(response.data)
def post(self):
args = parser.parse(self.post_args, request)
# prevent equal-None filter query
email, username = args.get('email'), args.get('username')
if not any((email, username)):
raise BadRequest()
user_q = db.session.query(User)
if email is not None:
user_q = user_q.filter(User.email == email)
elif username is not None:
user_q = user_q.filter(User.username == username)
user = user_q.one_or_none()
# if user not found or user has no valid email
if user is None or user.email is None or user.email == '':
raise BadRequest(
'Запрос не выполнен. Или пользователь с такими '
'данными не найден, или у найденого пользователя нет email')
payload = {'user_id': user.id}
token = tokenizer.pack(payload)
text = f"Ссылка для сброса пароля: {current_app.config.get('APP_URL')}/auth/change-password?token={token}"
msg = Message('Сброс пароля', to=user.email, text=text)
try:
gmail.send(msg)
except Exception as e: # TODO: handle smtplib errors
current_app.logger.exception(
'Unable to send reset password message to', user.email)
return jsonify({})
def get(self, workshop_id):
args = parser.parse(self.get_args, request, error_status_code=400)
if not self._ensure_permissions(workshop_id):
raise NotFound(
f'Результаты сбора #{workshop_id} не найдены или у пользователя нет приглашения на него'
)
monitor: WorkshopMonitor = db.session.query(WorkshopMonitor) \
.filter(WorkshopMonitor.workshop_id == workshop_id) \
.first_or_404()
if not current_user.is_teacher and monitor.is_disabled_for_students():
raise NotFound(
f'Результаты сбора #{workshop_id} не найдены или у пользователя нет приглашения на него'
)
contests = self._get_contests(workshop_id)
users = self._get_users(monitor, args.get('group_id'))
user_ids = [user.id for user in users]
results = []
for contest in contests:
raw_data = self._get_raw_data_by_contest(monitor, user_ids,
contest)
data = self._prepare_data(monitor, contest, raw_data)
results.append({'contest_id': contest.id, 'results': data})
monitor_data = MonitorData(contests, users, results, monitor.type.name)
data = monitor_schema.dump(monitor_data)
return jsonify(data.data)
def post(self):
args = parser.parse(self.post_args, request)
username, password = args['username'], args['password']
user = db.session.query(User) \
.filter(User.username == username) \
.filter(User.deleted.isnot(True)) \
.options(joinedload(User.roles)) \
.one_or_none()
if user is None:
raise exc.NotFound('User with this username does not exist')
is_password_valid = User.check_password(user.password_md5, password)
if not is_password_valid:
current_app.logger.warning(f'user_email={args["username"]} '
f'has failed to log in')
raise exc.Forbidden('Invalid password')
current_app.logger.debug(f'user_email={args["username"]} has logged in')
token = generate_refresh_token(user)
refresh_token = RefreshToken(token=token, user_id=user.id)
db.session.add(refresh_token)
db.session.commit()
user_serializer = UserAuthSerializer()
user.refresh_token = token
user_data = user_serializer.dump(user)
return jsonify(user_data.data)
def get(self, run_id: int):
user_id = g.user['id']
context, status = internal_rmatics.get_full_run_protocol(
run_id, user_id)
protocol = self._remove_fields_from_full_protocol(context)
return jsonify(protocol, status_code=status)
def post(self):
args = parser.parse(self.post_args, request)
db.session.query(RefreshToken).filter_by(
user_id=current_user.id, token=args.get('refresh_token')).delete()
db.session.commit()
current_app.logger.debug(f'user_id={current_user.id} has logged out')
return jsonify({}, 200)
def post(self):
args = parser.parse(self.post_args, request)
user = db.session.query(User). \
filter_by(id=g.payload.get('user_id')). \
one_or_none()
if user:
user.password_md5 = User.hash_password(args.get('password'))
db.session.commit()
return jsonify({})
def post(self, problem_id):
user_id = g.user['id']
args = parser.parse(self.post_args, request)
file = parser.parse_files(request, 'file', 'file')
content, status = internal_rmatics.send_submit(file,
user_id,
problem_id,
args['statement_id'],
args['lang_id'])
return jsonify(content, status_code=status)
def get(self, problem_id):
problem = db.session.query(Problem) \
.options(joinedload(Problem.ejudge_problem)) \
.get(problem_id)
if problem is None:
raise NotFound(f'Problem with id #{problem_id} is not found')
problem_serializer = ProblemSchema()
response = problem_serializer.dump(problem)
return jsonify(response.data)
def get(self, contest_id, problem_id):
check_contest_availability(
contest_id,
NotFound(f'Задача с id #{problem_id} не найдена '
'или у вас недостаточно прав для ее просмотра'))
args = parser.parse(self.get_args, request, error_status_code=400)
# set current authorized user to args
args['user_id'] = current_user.id
content, status = internal_rmatics.get_runs_filter(
problem_id, contest_id, args)
return jsonify(content, status_code=status)
def get(self, run_id):
"""
Returns List[Comment] for current authorized user for requested run_id
"""
# if provided run_id not not found, return []
comments = db.session.query(Comment) \
.filter(Comment.py_run_id == run_id,
Comment.user_id == current_user.id) \
.options(joinedload(Comment.author_user)) \
.order_by(Comment.date.desc()) \
.all()
comment_schema = CommentSchema(many=True)
response = comment_schema.dump(comments)
return jsonify(response.data)
def get(self, contest_id, problem_id):
check_contest_availability(
contest_id,
NotFound(f'Задача с id #{problem_id} не найдена '
'или у вас недостаточно прав для ее просмотра'))
problem = db.session.query(EjudgeProblem).filter_by(
id=problem_id).one_or_none()
if problem is None:
raise NotFound(f'Задача с id #{problem_id} не найдена '
'или у вас недостаточно прав для ее просмотра')
problem_serializer = ProblemSchema()
response = problem_serializer.dump(problem)
return jsonify(response.data)
def post(self):
args = parser.parse(self.post_args, request)
token = args.get('refresh_token')
user = self._validate_token(token)
if user is None:
current_app.logger.warning(f'Someone has sent invalid refresh token')
raise exc.Forbidden('Refresh token has been expired')
excludes = ('refresh_token',)
serializer = UserAuthSerializer(exclude=excludes)
user_data = serializer.dump(user)
current_app.logger.debug(f'user_id={user.id} '
f'user_email={user.email} token has '
f'been refreshed')
return jsonify(user_data.data)
def post(self, contest_id, problem_id):
cc = check_contest_availability(
contest_id,
NotFound(f'Задача с id #{problem_id} не найдена '
'или у вас недостаточно прав для ее просмотра'))
args = parser.parse(self.post_args, request)
check_contest_languages(
cc.contest, args.get('lang_id'),
Forbidden('На выбранном языке нельзя решать '
'задачи из этого контеста. Пожалуйста, '
'используйте другой язык'))
file = request.files.get('file')
if file is None:
raise BadRequest('Файл решения не предоставлен')
content, status = internal_rmatics.send_submit(file, current_user.id,
problem_id, contest_id,
args['lang_id'])
return jsonify(content, status_code=status)
def get(self, contest_id):
contest: Contest = db.session.query(Contest) \
.options(joinedload(Contest.languages)) \
.options(joinedload(Contest.statement)) \
.options(joinedload(Contest.workshop)) \
.get(contest_id)
if contest is None:
raise NotFound(
f'Не удалость найти модуль контеста с ID #{contest_id}')
user_id = current_user.id
self._check_workshop_permissions(user_id, contest.workshop)
cc, is_created = get_or_create(ContestConnection,
user_id=user_id,
contest_id=contest.id)
if not current_user.is_teacher and not contest.is_available(cc):
raise Forbidden('Контест не найден или не открыт')
contest.statement.problems = self._load_problems(contest.statement_id)
if not contest.languages:
contest.languages = db.session.query(Language).all()
cc.contest = contest
cc_schema = ContestConnectionSchema()
response = cc_schema.dump(cc)
if is_created is True:
# Allow modify contest object without
# saving changes
db.session.expunge(contest)
db.session.commit()
return jsonify(response.data)
def post(self, workshop_id: int):
args = parser.parse(self.post_args, request)
workshop = db.session.query(WorkShop) \
.filter_by(id=workshop_id,
status=WorkshopStatus.ONGOING,
access_token=args.get('token')) \
.one_or_none()
if workshop is None:
raise NotFound(f'Сбор не найден')
wc, is_created = get_or_create(WorkshopConnection,
user_id=current_user.id,
workshop_id=workshop_id)
wc_schema = WorkshopConnectionSchema()
response = wc_schema.dump(wc)
if is_created is True:
db.session.commit()
return jsonify(response.data)
def get(self, problem_id):
args = parser.parse(self.get_args, request, error_status_code=400)
content, status = internal_rmatics.get_runs_filter(problem_id, args, is_admin=False)
return jsonify(content, status_code=status)
def get(self, run_id):
user_id = g.user['id']
context, status = internal_rmatics.get_run_source(run_id, user_id)
return jsonify(context, status_code=status)
def jsonify_http_exception(exception: HTTPException):
"""Convert raised werkzeug.exceptons.* into JSON.
Additional doc: http://flask.pocoo.org/snippets/83/
"""
return jsonify(exception.description, exception.code)
def jsonify_unknown_exception(exception: Exception):
"""Convert any other exception to JSON."""
current_app.logger.exception('Unhandled exception has been raised!')
return jsonify(DEFAULT_MESSAGE, 500)
def get(self, run_id):
context, status = internal_rmatics.get_run_source(run_id, current_user.id)
if status == 404:
raise NotFound('Посылка не найдена')
return jsonify(context, status_code=status)