class StatementUser(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_olympiad'
id = db.Column(db.Integer, primary_key=True)
statement_id = db.Column('contest_id', db.Integer, db.ForeignKey('moodle.mdl_statements.id'))
user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
class Participant(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_virtualcontest'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
statement_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_statements.id'))
start = db.Column(db.Integer)
duration = db.Column(db.Integer)
user = db.relationship('SimpleUser',
backref=db.backref('pariticipants', lazy='dynamic'))
statement = db.relationship('Statement',
backref=db.backref('participants',
lazy='dynamic'))
def finished(self):
return time.time() >= self.start + self.duration
def serialize(self):
return attrs_to_dict(
self,
'start',
'duration',
'statement_id',
)
class PynformaticsUser(User):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_user_settings'
__mapper_args__ = {'polymorphic_identity': 'pynformaticsuser'}
id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'), primary_key=True)
main_page_settings = db.Column(db.Text)
class Book(CourseModuleInstance, db.Model):
"""
Модуль курса, описывающий книгу
"""
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_book'
__mapper_args__ = {
'polymorphic_identity': 'book',
'concrete': True,
}
MODULE = 18
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column('course', db.Integer)
name = db.Column(db.Unicode(255))
summary = db.Column(MEDIUMTEXT)
@staticmethod
def url(course_module_id):
return f'http://informatics.msk.ru/mod/book/view.php?id={course_module_id}'
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
class Group(db.Model):
__table_args__ = (db.ForeignKeyConstraint(['owner_id'],
['moodle.mdl_user.id']), {
'schema': 'moodle'
})
__tablename__ = 'mdl_ejudge_group'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(100))
description = db.Column(db.Text)
owner_id = db.Column(db.Integer)
visible = db.Column(db.Integer)
owner = db.relationship('SimpleUser',
backref=db.backref('groups', lazy='select'),
lazy='joined')
def serialize(self, attributes=None):
if not attributes:
attributes = (
'name',
'description',
'owner_id',
'visible',
)
serialized = attrs_to_dict(self, *attributes)
return serialized
class Recommendation(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'sis_most_popular_next_problems_recommendations'
id = db.Column(db.Integer, primary_key=True)
problem_id = db.Column(db.Integer)
contest_id = db.Column(db.Integer)
recommended_problem_id = db.Column(db.Integer)
recommended_contest_id = db.Column(db.Integer)
def __init__(self, contest_id, problem_id, recommended_contest_id,
recommended_problem_id):
self.contest_id = contest_id
self.problem_id = problem_id
self.recommended_contest_id = recommended_contest_id
self.recommended_problem_id = recommended_problem_id
def get_by(self, contest_id, problem_id):
try:
return db.session.query(Recommendation).filter_by(
contest_id=int(contest_id), problem_id=int(problem_id))
except:
return None
def __json__(self, request):
return {
'id': self.id,
'problem_id': self.problem_id,
'contest_id': self.contest_id,
'recommended_contest_id': self.lang_id,
'recommended_problem_id': self.test_signature,
}
class Context(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_context'
id = db.Column(db.Integer, primary_key=True)
contextlevel = db.Column(db.Integer)
instanceid = db.Column(db.Integer)
class UserGroup(db.Model):
__table_args__ = (
db.UniqueConstraint('user_id', 'group_id', name='group_id'),
{
'schema': 'moodle'
},
)
__tablename__ = 'mdl_ejudge_group_users'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
group_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_ejudge_group.id'))
user = db.relationship('SimpleUser',
backref=db.backref('user_groups', lazy='select'))
group = db.relationship('Group',
backref=db.backref('user_groups', lazy='select'))
@staticmethod
def create_if_not_exists(user_id, group_id):
user_group = db.session.query(UserGroup).filter_by(
user_id=user_id, group_id=group_id).first()
if user_group:
return None
return UserGroup(user_id=user_id, group_id=group_id)
class Role(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_role'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
shortname = db.Column(db.Unicode(100))
description = db.Column(db.UnicodeText)
sortorder = db.Column(db.Integer)
class UserOAuthProvider(db.Model):
__table_args__ = {'schema': 'pynformatics'}
__tablename__ = 'user_oauth_provider'
user_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_user.id'),
primary_key=True)
provider = db.Column(db.String(255), primary_key=True)
oauth_id = db.Column(db.String(255))
user = db.relationship('SimpleUser',
backref=db.backref('oauth_ids', lazy='dynamic'))
class RoleAssignment(db.Model):
__tablename__ = 'mdl_role_assignments'
__table_args__ = {'schema': 'moodle'}
id = db.Column(db.Integer, primary_key=True)
role_id = db.Column('roleid', db.Integer,
db.ForeignKey('moodle.mdl_role.id'))
context_id = db.Column('contextid', db.Integer,
db.ForeignKey('moodle.mdl_context.id'))
user_id = db.Column('userid', db.Integer,
db.ForeignKey('moodle.mdl_user.id'))
role = db.relationship('Role', lazy='joined')
context = db.relationship('Context', lazy='joined')
class PynformaticsRun(db.Model):
__table_args__ = (
db.ForeignKeyConstraint(
['run_id', 'contest_id'],
['ejudge.runs.run_id', 'ejudge.runs.contest_id'],
),
{
'schema': 'pynformatics'
},
)
__tablename__ = 'run'
run_id = db.Column('run_id',
db.ForeignKey('ejudge.runs.run_id'),
primary_key=True)
contest_id = db.Column('contest_id',
db.ForeignKey('ejudge.runs.contest_id'),
primary_key=True)
statement_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_statements.id'))
source = db.Column(db.Text)
run = db.relationship(
'EjudgeRun',
foreign_keys='[PynformaticsRun.run_id, PynformaticsRun.contest_id]',
backref=db.backref('pynformatics_run', lazy='joined', uselist=False),
lazy='joined')
statement = db.relationship('Statement', backref='pynformatics_runs')
AUTHOR_ATTRS = [
'source',
]
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
class Stars(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_stars'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
title = db.Column(db.Text)
link = db.Column(db.Text)
def __init__(self, user, title, link):
self.link = link
self.title = title
self.user_id = user.id
def __json__(self, request):
return {
'id': self.id,
'user_id': self.user_id,
'title': self.title,
'link': self.link,
}
class StatementProblem(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_statements_problems_correlation'
id = db.Column(db.Integer, primary_key=True)
statement_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_statements.id'))
problem_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_problems.id'))
rank = db.Column('rank', db.Integer)
hidden = db.Column('hidden', db.Integer)
statement = db.relationship('Statement', backref=db.backref('StatementProblems', collection_class=attribute_mapped_collection("rank")))
# reference to the "Keyword" object
problem = db.relationship('Problem', backref=db.backref('StatementProblems'))
def __init__(self, statement_id, problem_id, rank):
self.statement_id = statement_id
self.problem_id = problem_id
self.rank = rank
self.hidden = 0
class GroupInvite(db.Model):
__table_args__ = {'schema': 'pynformatics'}
__tablename__ = 'group_invite'
REDIRECT_COURSE = 'COURSE'
REDIRECT_STATEMENT = 'STATEMENT'
REDIRECT_TYPES = [
REDIRECT_COURSE,
REDIRECT_STATEMENT,
]
id = db.Column(db.Integer, primary_key=True)
group_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_ejudge_group.id'))
creator_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
redirect_type = db.Column(db.Enum(*REDIRECT_TYPES))
instance_id = db.Column(db.Integer)
disabled = db.Column(db.Boolean, default=False)
deleted = db.Column(db.Boolean, default=False)
group = db.relationship('Group', backref='group_invites', lazy='joined')
creator = db.relationship('SimpleUser',
backref='group_invites',
lazy='joined')
@property
def redirect(self):
if self.redirect_type == GroupInvite.REDIRECT_COURSE:
return {'course_id': self.instance_id}
elif self.redirect_type == GroupInvite.REDIRECT_STATEMENT:
return {'statement_id': self.instance_id}
else:
raise NotImplementedError
@property
def url(self):
return encode(self.id)
@staticmethod
def get_by_url(url):
try:
id = decode(url)
except Exception:
raise GroupNotFound
group = db.session.query(GroupInvite).filter_by(id=id).first()
if not group:
raise GroupNotFound
return group
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
class Log(db.Model):
"""
Модель лога действия пользователя.
"""
__table_args__ = {'schema': 'pynformatics'}
__tablename__ = 'log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
instance_id = db.Column(db.Integer)
action_id = db.Column(db.Integer, db.ForeignKey('pynformatics.action.id'))
created_at = db.Column(db.DateTime, default=func.now())
action = db.relationship('Action',
backref=db.backref('logs', lazy='select'),
lazy='joined')
user = db.relationship('SimpleUser',
backref=db.backref('logs', lazy='select'),
lazy='joined')
class Action(db.Model):
__table_args__ = {'schema': 'pynformatics'}
__tablename__ = 'action'
id = db.Column(Integer, primary_key=True, autoincrement=True)
description = db.Column(db.String(255))
@staticmethod
def get_id(description):
'''
Возвращает action_id по описанию действия.
В случае, если такого действия нет, создает его.
'''
description = description.upper()
instance = db.session.query(Action).filter_by(
description=description).first()
if not instance:
instance = Action(description=description)
db.session.add(instance)
db.session.flush([instance])
return instance.id
class Resource(CourseModuleInstance, db.Model):
"""
Модуль курса, описывающий ссылку
"""
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_resource'
__mapper_args__ = {
'polymorphic_identity': 'resource',
'concrete': True,
}
MODULE = 13
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column('course', db.Integer)
name = db.Column(db.Unicode(255))
type_ = db.Column('type', db.Unicode(30))
reference = db.Column(db.Unicode(255))
summary = db.Column(db.UnicodeText())
def serialize(self):
serialized = attrs_to_dict(
self,
'id',
'course_id',
'name',
'type',
'reference',
'summary',
)
serialized['type'] = self.type_
return serialized
class Course(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_course'
id = db.Column(db.Integer, primary_key=True)
full_name = db.Column('fullname', db.Unicode(254))
short_name = db.Column('shortname', db.Unicode(100))
category = db.Column(db.Integer)
password = db.Column(db.Unicode(50))
visible = db.Column(db.Boolean)
def require_password(self):
return bool(self.password)
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
class User(SimpleUser):
__mapper_args__ = {'polymorphic_identity': 'user'}
username = db.Column(db.Unicode(100))
email = db.Column(db.Unicode(100))
city = db.Column(db.Unicode(20))
school = db.Column(db.Unicode(255))
problems_week_solved = db.Column(db.Integer)
@classmethod
def search(cls, filter_func: Callable[[Query], Query], filter_deleted=True):
if filter_deleted:
users_query = filter_func(db.session.query(cls).filter(cls.deleted == False))
else:
users_query = filter_func(db.session.query(cls))
return users_query
@classmethod
def search_by_string(cls, search_string):
def filter_func(query: Query):
if search_string.count(' '):
str1, str2 = search_string.split(' ', 1)
query = query.filter(or_(
and_(cls.firstname.like("%{}%".format(str1)), cls.lastname.like("%{}%".format(str2))),
and_(cls.lastname.like("%{}%".format(str1)), cls.firstname.like("%{}%".format(str2))),
))
else:
query = query.filter(or_(
cls.email.like("%{}%".format(search_string)),
cls.username.like("%{}%".format(search_string)),
cls.firstname.like("%{}%".format(search_string)),
cls.lastname.like("%{}%".format(search_string)),
))
return query
return cls.search(filter_func)
@lazy
def _get_current_olymp(self):
return None
class Label(CourseModuleInstance, db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_label'
__mapper_args__ = {
'polymorphic_identity': 'label',
'concrete': True,
}
MODULE = 9
id = db.Column(db.Integer, primary_key=True)
course = db.Column(db.Integer)
name = db.Column(db.Unicode(255))
content = db.Column(db.UnicodeText)
def serialize(self):
return attrs_to_dict(
self,
'id',
'name',
'content',
)
class CourseModule(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_course_modules'
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column('course', db.Integer,
db.ForeignKey('moodle.mdl_course.id'))
module = db.Column(db.Integer)
instance_id = db.Column('instance', db.Integer)
section_id = db.Column('section', db.Integer,
db.ForeignKey('moodle.mdl_course_sections.id'))
visible = db.Column(db.Boolean)
course = db.relationship('Course',
backref=db.backref('course_modules',
lazy='dynamic'))
section = db.relationship('CourseSection',
backref=db.backref('modules', lazy='dynamic'))
@property
def instance(self):
if not hasattr(self, '_instance'):
instance_class = next(
(subclass
for subclass in CourseModuleInstance.__subclasses__()
if subclass.MODULE == self.module), None)
if not instance_class:
self._instance = None
else:
self._instance = db.session.query(instance_class) \
.filter_by(id=self.instance_id) \
.first()
return self._instance
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
class CourseSection(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_course_sections'
id = db.Column(db.Integer, primary_key=True)
course_id = db.Column('course', db.Integer,
db.ForeignKey('moodle.mdl_course.id'))
section = db.Column(db.Integer)
summary = db.Column(db.Text)
sequence_text = db.Column('sequence', db.Text)
visible = db.Column(db.Boolean)
course = db.relationship('Course',
backref=db.backref(
'sections',
lazy='dynamic',
order_by='CourseSection.section'))
def __init__(self):
self._sequence = None
@property
def sequence(self):
if not getattr(self, '_sequence'):
try:
self._sequence = list(map(int, self.sequence_text.split(',')))
except Exception:
self._sequence = []
return self._sequence
@sequence.setter
def sequence(self, value):
self._sequence = value
self.sequence_text = ','.join(list(map(str, value)))
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
class EjudgeContest(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_ejudge_contest'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
ejudge_id = db.Column(db.Unicode(10))
ejudge_int_id = db.Column(db.Integer,
nullable=False,
primary_key=True,
autoincrement=False)
load_time = db.Column(db.DateTime)
cloned = db.Column(db.Boolean, nullable=False)
def __init__(self, name='', ejudge_int_id=0):
self.name = name
self.ejudge_id = get_contest_str_id(ejudge_int_id)
self.ejudge_int_id = ejudge_int_id
self.load_time = datetime.datetime.now()
self.cloned = False
class Hint(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'sis_hint'
id = db.Column(db.Integer, primary_key=True)
problem_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_problems.id'))
contest_id = db.Column(db.Integer, db.ForeignKey('ejudge.runs.contest_id'))
lang_id = db.Column(db.Integer)
test_signature = db.Column(db.Unicode(255))
comment = db.Column(db.Text)
def __init__(self, problem_id, contest_id, lang_id, test_signature, comment):
self.problem_id = problem_id
self.contest_id = contest_id
self.lang_id = lang_id
self.test_signature = test_signature
self.comment = comment
def get_by(contest_id, problem_id, lang_id, signature):
try: # lang_id is ignored, cause we don't have hints for each language
return db.session.query(Hint) \
.filter(Hint.contest_id == int(contest_id)) \
.filter(Hint.problem_id == int(problem_id)) \
.filter(Hint.test_signature == signature) \
.first()
except:
return None
def __json__(self, request):
return {
'id' : self.id,
'problem_id' : self.problem_id,
'contest_id': self.contest_id,
'lang_id' : self.lang_id,
'test_signature' : self.test_signature,
'comment': self.comment,
}
class ContestsStatistic(db.Model):
__table_args__ = {'schema':'moodle'}
__tablename__ = 'contests_statistic'
contest_id = db.Column(db.Integer, primary_key=True)
submits_count = db.Column(db.Integer)
class SimpleUser(db.Model):
RESET_PASSWORD_LENGTH = 20
__table_args__ = (
db.Index('ej_id', 'ej_id'),
{'schema': 'moodle'}
)
__tablename__ = 'mdl_user'
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.Unicode(100))
lastname = db.Column(db.Unicode(100))
login = db.Column('ej_login', db.Unicode(50))
password = db.Column('ej_password', db.Unicode(50))
deleted = db.Column('deleted', db.Boolean)
ejudge_id = db.Column('ej_id', db.Integer)
problems_solved = db.Column(db.Integer)
password_md5 = db.Column('password', db.Unicode(32))
statement = db.relationship(
'Statement',
secondary=StatementUser.__table__,
backref='StatementUsers1',
lazy='dynamic',
)
statements = association_proxy('StatementUsers2', 'statement')
def get_active_participant(self):
"""
Возвращает последний participant, если он еще не закончен
"""
latest_participant = db.session.query(Participant).filter(
Participant.user_id == self.id
).order_by(
Participant.id.desc()
).first()
if latest_participant and not latest_participant.finished():
return latest_participant
return None
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 reset_password(self):
"""
Генерирует случайный пароль для пользователя и возвращает его
"""
new_password = random_password(self.RESET_PASSWORD_LENGTH)
self.password_md5 = hash_password(new_password)
return new_password
class Problem(db.Model):
__table_args__ = {'schema': 'moodle'}
__tablename__ = 'mdl_problems'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(255))
content = db.Column(db.Text)
review = db.Column(db.Text)
hidden = db.Column(db.Boolean)
timelimit = db.Column(db.Float)
memorylimit = db.Column(db.Integer)
description = db.Column(db.Text)
analysis = db.Column(db.Text)
sample_tests = db.Column(db.Unicode(255))
sample_tests_html = db.Column(db.Text)
sample_tests_json = db.Column(JsonType)
show_limits = db.Column(db.Boolean)
output_only = db.Column(db.Boolean)
pr_id = db.Column(db.Integer,
db.ForeignKey('moodle.mdl_ejudge_problem.id'))
def __init__(self, *args, **kwargs):
super(Problem, self).__init__(*args, **kwargs)
self.hidden = 1
self.show_limits = True
class Comment(db.Model):
__table_args__ = (db.ForeignKeyConstraint(
['run_id', 'contest_id'],
['ejudge.runs.run_id', 'ejudge.runs.contest_id']), {
'schema': 'ejudge'
})
__tablename__ = 'mdl_run_comments'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime)
run_id = db.Column(db.Integer)
contest_id = db.Column(db.Integer)
user_id = db.Column(db.Integer)
author_user_id = db.Column(db.Integer, db.ForeignKey('moodle.mdl_user.id'))
lines = db.Column(db.Text)
comment = db.Column(db.UnicodeText)
is_read = db.Column(db.Boolean)
author_user = db.relationship(
SimpleUser,
backref='simpleuser1',
uselist=False,
lazy=False,
primaryjoin=(author_user_id == SimpleUser.id),
)
run = db.relationship('EjudgeRun', backref='comment', uselist=False)
def __init__(self,
run,
author,
lines='',
comment='',
date=datetime.datetime.now()):
self.date = date
self.run_id = run.run_id
self.user_id = run.user.id
self.contest_id = run.contest_id
self.author_user_id = author.id
self.lines = lines
self.comment = comment
self.is_read = False
def __json__(self, request):
return {
'date': str(self.date),
'id': self.id,
'run_id': self.run_id,
'user_id': self.user_id,
'contest_id': self.contest_id,
'author_user_id': self.author_user_id,
'lines': self.lines,
'comment': self.comment,
'is_read': self.is_read,
'problem_id': self.run.problem.id,
'problem_name': self.run.problem.name
}
@staticmethod
def get_by(run_id, contest_id):
try:
return db.session.query(Comment) \
.filter(Comment.run.run_id == int(run_id)) \
.filter(Comment.contest_id == int(contest_id)) \
.first()
except:
return None
class EjudgeProblem(Problem):
"""
Модель задачи из ejudge
ejudge_prid -- primary key, на который ссылается Problem.pr_id.
После инициализации, соответствтующему объекту Problem проставляется корректный pr_id
contest_id --
ejudge_contest_id -- соответствует contest_id из ejudge
secondary_ejudge_contest_id --
problem_id -- соответствует problem_id из ejudge
short_id -- короткий id (обычно буква)
"""
__table_args__ = (db.Index('ejudge_contest_id_problem_id',
'ejudge_contest_id', 'problem_id'), {
'schema': 'moodle',
'extend_existing': True
})
__tablename__ = 'mdl_ejudge_problem'
__mapper_args__ = {'polymorphic_identity': 'ejudgeproblem'}
ejudge_prid = db.Column('id', db.Integer,
primary_key=True) #global id in ejudge
contest_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=False)
ejudge_contest_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=False)
secondary_ejudge_contest_id = db.Column(db.Integer, nullable=True)
problem_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=False) #id in contest
short_id = db.Column(db.Unicode(50))
ejudge_name = db.Column('name', db.Unicode(255))
@staticmethod
def create(**kwargs):
"""
При создании EjudgeProblem сначала в базу пишет Problem потом EjudgeProblem,
из-за чего pr_id не проставляется
"""
instance = EjudgeProblem(**kwargs)
db.session.add(instance)
db.session.flush([instance])
problem_id = instance.id
ejudge_problem_id = instance.pr_id
db.session.commit()
problem_instance = db.session.query(Problem).filter_by(
id=problem_id).one()
problem_instance.pr_id = ejudge_problem_id
db.session.commit()
return db.session.query(EjudgeProblem).filter_by(id=problem_id).one()
def serialize(self):
if self.sample_tests:
self.generateSamplesJson(force_update=True)
attrs = [
'id',
'name',
'content',
'timelimit',
'memorylimit',
'show_limits',
'sample_tests_json',
'output_only',
]
problem_dict = {
attr: getattr(self, attr, 'undefined')
for attr in attrs
}
# problem_dict['languages'] = context.get_allowed_languages()
return problem_dict
def get_test(self, test_num, size=255):
conf = EjudgeContestCfg(number=self.ejudge_contest_id)
prob = conf.getProblem(self.problem_id)
test_file_name = (prob.tests_dir + prob.test_pat) % int(test_num)
error_str = None
if os.path.exists(test_file_name):
res = read_file_unknown_encoding(test_file_name, size)
else:
res = test_file_name
return res
def get_test_size(self, test_num):
conf = EjudgeContestCfg(number=self.ejudge_contest_id)
prob = conf.getProblem(self.problem_id)
test_file_name = (prob.tests_dir + prob.test_pat) % int(test_num)
return os.stat(test_file_name).st_size
def get_corr(self, test_num, size=255):
conf = EjudgeContestCfg(number=self.ejudge_contest_id)
prob = conf.getProblem(self.problem_id)
corr_file_name = (prob.tests_dir + prob.corr_pat) % int(test_num)
error_str = None
if os.path.exists(corr_file_name):
res = read_file_unknown_encoding(corr_file_name, size)
else:
res = corr_file_name
return res
def get_test_full(self, test_num, size=255):
"""
Возвращает словарь с полной информацией о тесте
"""
test = {}
if self.get_test_size(int(test_num)) <= 255:
test["input"] = self.get_test(int(test_num), size=size)
test["big_input"] = False
else:
test["input"] = self.get_test(int(test_num), size=size) + "...\n"
test["big_input"] = True
if self.get_corr_size(int(test_num)) <= 255:
test["corr"] = self.get_corr(int(test_num), size=size)
test["big_corr"] = False
else:
test["corr"] = self.get_corr(int(test_num), size=size) + "...\n"
test["big_corr"] = True
return test
def get_corr_size(self, test_num):
conf = EjudgeContestCfg(number=self.ejudge_contest_id)
prob = conf.getProblem(self.problem_id)
corr_file_name = (prob.tests_dir + prob.corr_pat) % int(test_num)
return os.stat(corr_file_name).st_size
def get_checker(self):
conf = EjudgeContestCfg(number=self.ejudge_contest_id)
prob = conf.getProblem(self.problem_id)
#generate dir with checker
checker_dir = None
if conf.advanced_layout:
checker_dir = os.path.join(conf.contest_path, "problems",
prob.internal_name)
else:
checker_dir = os.path.join(conf.contest_path, "checkers")
#trying to find checker
find_res = glob.glob(
os.path.join(checker_dir,
"check_{0}.*".format(prob.internal_name)))
check_src = None
checker_ext = None
if find_res:
check_src = open(find_res[0], "r").read()
checker_ext = os.path.splitext(find_res[0])[1]
#if checker not found then try polygon package
downloads_dir = os.path.join(conf.contest_path, "download")
if check_src is None and os.path.exists(downloads_dir):
download_archive_mask = "{0}-*$linux.zip".format(
prob.internal_name)
find_archive_result = glob.glob(
os.path.join(downloads_dir, download_archive_mask))
download_archive_path = find_archive_result[
0] if find_archive_result else None
archive = None
if download_archive_path is not None:
archive = ZipFile(download_archive_path)
if archive is not None:
member_path = None
for file in archive.namelist():
if file.startswith("check."):
member_path = file
break
try:
check_src = archive.open(member_path).read()
checker_ext = os.path.splitext(member_path)[1]
except KeyError:
check_src = None
if check_src is None:
check_src = "checker not found"
return check_src, checker_ext
def generateSamples(self):
res = ""
if self.sample_tests != '':
res = "<div class='problem-statement'><div class='sample-tests'><div class='section-title'>Примеры</div>"
for i in self.sample_tests.split(","):
inp = self.get_test(i, 4096)
if inp[-1] == '\n':
inp = inp[:-1]
corr = self.get_corr(i, 4096)
if corr[-1] == '\n':
corr = corr[:-1]
res += "<div class='sample-test'>"
res += "<div class='input'><div class='title'>Входные данные</div><pre class='content'>"
res += inp
res += "</pre></div><div class='output'><div class='title'>Выходные данные</div><pre class='content'>"
res += corr
res += "</pre></div></div>"
res += "</div></div>"
self.sample_tests_html = res
return self.sample_tests
def generateSamplesJson(self, force_update=False):
if self.sample_tests != '':
if not self.sample_tests_json:
self.sample_tests_json = {}
for test in self.sample_tests.split(','):
if not force_update and test in self.sample_tests_json:
continue
test_input = self.get_test(test, 4096)
test_correct = self.get_corr(test, 4096)
self.sample_tests_json[test] = {
'input': test_input,
'correct': test_correct,
}
