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, }