def serialize(self, attributes=None):
if not attributes:
attributes = ('statement_id', )
serialized = attrs_to_dict(self, *attributes)
user = getattr(g, 'user', None)
if user and self.run.user.id == user.id:
serialized.update(
attrs_to_dict(self, *PynformaticsRun.AUTHOR_ATTRS))
return serialized
def serialize(self, attributes=None):
if not attributes:
attributes = (
'run_id',
'contest_id',
'create_time',
'lang_id',
'prob_id',
'score',
'size',
'status',
'problem_id',
)
serialized = attrs_to_dict(self, *attributes)
if 'create_time' in attributes:
serialized['create_time'] = str(serialized['create_time'])
if 'problem_id' in attributes:
serialized['problem_id'] = self.problem.id
serialized.update(self.get_pynformatics_run().serialize())
user = getattr(g, 'user', None)
if not user or user.ejudge_id != self.user.ejudge_id:
serialized['user'] = self.user.serialize()
return serialized
def serialize(self):
return attrs_to_dict(
self,
'id',
'name',
'content',
)
def serialize(self):
return attrs_to_dict(
self,
'start',
'duration',
'statement_id',
)
def serialize(self, attributes=None):
if attributes is None:
attributes = (
'id',
'user',
'problem_id',
'statement_id',
'score',
'status',
'language_id',
'create_time',
'ejudge_run_id',
'ejudge_contest_id',
)
if hasattr(g, 'user') and g.user.id == self.user_id:
attributes = (
*attributes,
'source',
)
serialized = attrs_to_dict(self, *attributes)
if 'create_time' in attributes:
serialized['create_time'] = str(self.create_time)
if 'user' in attributes:
serialized['user'] = self.user.serialize()
return serialized
def update(self, user):
if not self.json:
self.json = {}
if str(user.id) not in self.json:
self.json[str(user.id)] = {
**attrs_to_dict(user, 'firstname', 'lastname'),
}
def serialize(self, course_module_id=None):
serialized = attrs_to_dict(
self,
'id',
'course_id',
'name',
)
if course_module_id:
serialized['url'] = Book.url(course_module_id)
return serialized
def serialize(self, attributes=None):
if not attributes:
attributes = (
'name',
'description',
'owner_id',
'visible',
)
serialized = attrs_to_dict(self, *attributes)
return serialized
def serialize(self):
serialized = attrs_to_dict(
self,
'id',
'course_id',
'name',
'type',
'reference',
'summary',
)
serialized['type'] = self.type_
return serialized
def serialize_run(run):
serialized = attrs_to_dict(
run,
'run_id',
'contest_id',
'create_time',
'score',
'status'
)
serialized['create_time'] = serialized['create_time'].isoformat()
serialized['problem_id'] = run.problem.id
return serialized
def serialize(self):
serialized = attrs_to_dict(
self,
'id',
'course_id',
'module',
'section_id',
'visible',
)
if self.instance:
serialized['type'] = self.instance.MODULE_TYPE
if self.instance.MODULE_TYPE == 'STATEMENT':
serialized['instance'] = attrs_to_dict(
self.instance,
'id',
'name',
)
elif self.instance.MODULE_TYPE in ['BOOK', 'MONITOR']:
serialized['instance'] = self.instance.serialize(course_module_id=self.id)
else:
serialized['instance'] = self.instance.serialize()
return serialized
def serialize(self, attributes=None):
if not attributes:
attributes = (
'id',
'name',
'olympiad',
'settings',
'time_start',
'time_stop',
'virtual_olympiad',
'virtual_duration',
'course_module_id',
'course',
'require_password',
)
serialized = attrs_to_dict(self, *attributes)
if 'course' in attributes and self.course:
serialized['course'] = self.course.serialize()
serialized['course_module_id'] = getattr(self.course_module, 'id',
None)
if 'require_password' in attributes:
if self.course:
serialized['require_password'] = self.course.require_password()
else:
serialized['require_password'] = False
user = getattr(g, 'user', None)
if self.olympiad or self.virtual_olympiad:
if not user:
return serialized
try:
participant = self.participants.filter_by(
user_id=user.id).one()
except NoResultFound:
return serialized
serialized['participant'] = participant.serialize()
serialized['problems'] = {
rank: {
'id': statement_problem.problem.id,
'name': statement_problem.problem.name,
}
for rank, statement_problem in self.StatementProblems.items()
if statement_problem.problem and not statement_problem.hidden
}
return serialized
def test_simple(self):
ejudge_run = EjudgeRun(
run_id=2,
user=self.users[0],
problem=self.problems[0],
run_uuid='some string',
score=10,
status=7,
lang_id=27,
test_num=3,
create_time=datetime.datetime(2018, 3, 24, 9, 51, 30),
last_change_time=datetime.datetime(2018, 3, 24, 9, 51, 31),
)
db.session.add(ejudge_run)
db.session.flush()
run = Run.from_ejudge_run(ejudge_run)
db.session.add(run)
db.session.flush()
assert_that(
attrs_to_dict(
run,
'user_id',
'problem_id',
'statement_id',
'score',
'ejudge_run_id',
'ejudge_contest_id',
'ejudge_score',
'ejudge_status',
'ejudge_language_id',
'ejudge_test_num',
'ejudge_create_time',
'ejudge_last_change_time',
),
has_entries({
'user_id': self.users[0].id,
'problem_id': self.problems[0].id,
'score': ejudge_run.score,
'ejudge_run_id': ejudge_run.run_id,
'ejudge_contest_id': ejudge_run.contest_id,
'ejudge_score': ejudge_run.score,
'ejudge_status': ejudge_run.status,
'ejudge_language_id': ejudge_run.lang_id,
'ejudge_test_num': ejudge_run.test_num,
'ejudge_create_time': ejudge_run.create_time,
'ejudge_last_change_time': ejudge_run.last_change_time,
}))
def serialize(self):
serialized = attrs_to_dict(
self,
'id',
'full_name',
'short_name',
)
serialized['require_password'] = self.require_password()
if not self.require_password():
serialized['sections'] = [
section.serialize() for section in self.sections.all()
if section.visible
]
return serialized
def serialize(self, attributes=None):
if attributes is None:
attributes = (
'id',
'user_id',
'problem_id',
'source',
'language_id',
)
serialized = attrs_to_dict(self, *attributes)
if 'user_id' in attributes:
serialized['user_id'] = self.user.id
if 'problem_id' in attributes:
serialized['problem_id'] = self.problem.id
return serialized
def serialize(self):
serialized = attrs_to_dict(
self,
'id',
'course_id',
'section',
'summary',
'sequence',
'visible',
)
serialized['modules'] = [
module.serialize()
for module in self.modules.filter_by(visible=True).all()
]
return serialized
def serialize(self, attributes=None):
if not attributes:
attributes = (
'id',
'firstname',
'lastname',
'active_virtual',
'ejudge_id',
)
serialized = attrs_to_dict(self, *attributes)
if 'active_virtual' in attributes: # TODO Убрать во внешний сериалайзер
participant = self.get_active_participant()
if participant:
serialized['active_virtual'] = participant.serialize()
else:
serialized.pop('active_virtual')
return serialized
def check_request(
self,
username=None,
password=None,
moodle_user_id=None,
moodle_session=None,
status_code=200,
message=None,
):
response = self.send_request(
username=username,
password=password,
moodle_user_id=moodle_user_id,
moodle_session=moodle_session,
)
if status_code != 200:
assert_that(
response.json,
has_entries({
'code': status_code,
'message': message,
}))
return
# В ответе должна быть информация о пользователе
assert_that(
response.json,
has_entries(
**attrs_to_dict(self.user, 'id', 'firstname', 'lastname')))
# В сессии должен быть id пользователя
with self.client.session_transaction() as session:
assert_that(session, has_entries({
'user_id': self.user.id,
}))
def serialize(self, attributes=None):
if attributes is None:
attributes = ('group_id', 'creator_id', 'redirect', 'disabled',
'url')
serialized = attrs_to_dict(self, *attributes)
return serialized
def serialize(self, attributes=None):
if attributes is None:
attributes = ('id', )
serialized = attrs_to_dict(self, *attributes)
return serialized
