コード例 #1
0
    def get_team(self):
        """See docstring in class TeamLoader."""

        if not os.path.exists(os.path.join(os.path.dirname(self.path),
                                           "contest.yaml")):
            logger.critical("File missing: \"contest.yaml\"")
            return None

        team_code = os.path.basename(self.path)
        logger.info("Loading parameters for team %s.", team_code)

        conf = load_yaml_from_path(
            os.path.join(os.path.dirname(self.path), "contest.yaml"))

        args = {}

        conf = load(conf, None, "teams")

        for team in conf:
            if team["code"] == team_code:
                conf = team
                break
        else:
            logger.critical("The specified team cannot be found.")
            return None

        load(conf, args, "code")
        load(conf, args, "name")

        logger.info("Team parameters loaded.")

        return Team(**args)
コード例 #2
0
    def post(self):
        fallback_page = self.url("teams", "add")

        try:
            attrs = dict()

            self.get_string(attrs, "code")
            self.get_string(attrs, "name")

            assert attrs.get("code") is not None, \
                "No team code specified."

            # Create the team.
            team = Team(**attrs)
            self.sql_session.add(team)

        except Exception as error:
            self.service.add_notification(
                make_datetime(), "Invalid field(s)", repr(error))
            self.redirect(fallback_page)
            return

        if self.try_commit():
            # Create the team on RWS.
            self.service.proxy_service.reinitialize()

        # In case other teams need to be added.
        self.redirect(fallback_page)
コード例 #3
0
ファイル: ContestConfig.py プロジェクト: ioi-germany/cms
    def _maketeam(self, teamname):
        team = self.teams[teamname]

        teamdb = Team(code=team.code,
                      name=team.name)

        return teamdb
コード例 #4
0
ファイル: improved_imoj.py プロジェクト: jcioi/ioi-cms
    def get_team(self):
        # due to the terrible AddUser script
        conf_path = os.path.dirname(self.path)
        name = os.path.basename(self.path)

        if not exists(conf_path):
            logger.critical("cannot find config file")
            return None

        logger.info("loading parameters for team \"%s\"", name)

        conf = load_yaml(conf_path)
        candidates = [u for u in conf['teams'] if u['code'] == name]

        if len(candidates) == 0:
            logger.critical("cannot find specified team")
            return None
        if len(candidates) > 1:
            logger.critical("multiple teams found with the same code")
            return None

        item = candidates[0]

        # default values
        team = {}

        assign(team, item, 'code')
        assign(team, item, 'name')

        return Team(**item)
コード例 #5
0
ファイル: databasemixin.py プロジェクト: jcioi/ioi-cms
 def get_team(cls, **kwargs):
     """Create a team"""
     args = {
         "code": unique_unicode_id(),
         "name": unique_unicode_id(),
     }
     args.update(kwargs)
     team = Team(**args)
     return team
コード例 #6
0
ファイル: AddTeam.py プロジェクト: yangkf1985/cms
def add_team(code, name):
    logger.info("Creating the team in the database.")
    team = Team(code=code, name=name)
    try:
        with SessionGen() as session:
            session.add(team)
            session.commit()
    except IntegrityError:
        logger.error("A team with the given code already exists.")
        return False

    logger.info("Team added.")
    return True
コード例 #7
0
def load_participations(path):
    logger.info("Loading...")
    with open(path, 'r') as io:
        data = json.load(io)

    participations = data['participations']
    with SessionGen() as session:
        for entry in participations:
            logger.info('Loading: %s' % (entry))
            contest = Contest.get_from_id(entry['contest_id'], session)
            if contest is None:
                logger.error("  Contest ID %d not found" %
                             (entry['contest_id']))
                session.rollback()
                return False

            userdata = entry['user']
            user = session.query(User).filter(
                User.username == userdata['username']).first()
            if user is None:
                user = User(username=userdata['username'],
                            first_name=userdata['first_name'],
                            last_name=userdata['last_name'],
                            password=build_password(
                                generate_random_password()))
                logger.info('  Creating new user: %s' % (user.username))
                session.add(user)
            else:
                logger.info('  Using existing user: %s (id=%d)' %
                            (user.username, user.id))

            if 'plaintext_password' in userdata:
                logger.info('  * password')
                user.password = build_password(userdata['plaintext_password'],
                                               'plaintext')

            if 'first_name' in userdata:
                logger.info('  * first_name: %s' % (userdata['first_name']))
                user.first_name = userdata['first_name']
            if 'last_name' in userdata:
                logger.info('  * last_name: %s' % (userdata['last_name']))
                user.last_name = userdata['last_name']

            participation = session.query(Participation).join(
                Participation.user).filter(
                    Participation.contest == contest).filter(
                        User.username == user.username).first()
            if participation is None:
                participation = Participation(user=user, contest=contest)
                logger.info(
                    '  Creating new participation for contest_id=%d user=%s' %
                    (contest.id, user.username))
                session.add(participation)
            else:
                logger.info(
                    '  Updating participation: id=%d contest_id=%d user=%s' %
                    (participation.id, participation.contest_id,
                     participation.user.username))

            if 'plaintext_password' in entry:
                logger.info('  * plaintext_password')
                participation.password = build_password(
                    entry['plaintext_password'], 'plaintext')
            if 'ip' in entry:
                logger.info('  * ip: %s' % (entry['ip']))
                participation.ip = [ipaddress.ip_network(entry['ip'])]
            if 'delay_time' in entry:
                logger.info('  * delay_time: %d' % (entry['delay_time']))
                participation.delay_time = datetime.timedelta(
                    seconds=entry['delay_time'])
            if 'extra_time' in entry:
                logger.info('  * extra_time: %d' % (entry['extra_time']))
                participation.extra_time = datetime.timedelta(
                    seconds=entry['extra_time'])
            if 'hidden' in entry:
                logger.info('  * hidden: %s' % (entry['hidden']))
                participation.hidden = entry['hidden']
            if 'unrestricted' in entry:
                logger.info('  * unrestricted: %s' % (entry['unrestricted']))
                participation.unrestricted = entry['unrestricted']

            if 'team' in userdata:
                team = session.query(Team).filter(
                    Team.code == userdata['team']['code']).first()
                if team is None:
                    team = Team(code=userdata['team']['code'],
                                name=userdata['team']['name'])
                    logger.info('  Creating new team: %s' % (team.code))
                    session.add(team)
                else:
                    logger.info('  Using existing team: %s' % (team.code))
                if 'name' in userdata['team']:
                    logger.info('  * name: %s' % (userdata['team']['name']))
                    team.name = userdata['team']['name']
                participation.team = team

        session.commit()

    logger.info("Done.")
    return True
コード例 #8
0
ファイル: contestuser.py プロジェクト: lio-lv/cms
    def post(self, contest_id):
        fallback_page = self.url("contest", contest_id, "users", "import")

        self.contest = self.safe_get_item(Contest, contest_id)

        r_params = self.render_params()
        action = self.get_body_argument('action', 'upload')

        if action == 'upload':
            ignore_existing = self.get_body_argument('ignore_existing', False)
            load_passwords = self.get_body_argument('load_passwords', False)
            try:
                user_csv = self.request.files["users_csv"][0]
                users = CsvUserLoader(None, None, user_csv['body']).read_users()
                processed_users = []
                some_participants_exist = False
                for user in users:
                    username = user['username']
                    result = {
                        'participant': False,
                        'username': username
                    }
                    db_user = self.sql_session.query(User).filter_by(
                        username=username).first()
                    if not db_user:
                        self.application.service.add_notification(
                            make_datetime(),
                            'User missing',
                            '"%s" doesn\'t exist. Import users first.' %
                            username)
                        self.redirect(fallback_page)
                        return
                    result['user_id'] = db_user.id
                    result['team'] = user.get('team')
                    participation = self.sql_session.query(Participation) \
                        .filter(Participation.user == db_user) \
                        .filter(Participation.contest == self.contest) \
                        .first()
                    if participation:
                        result['participant'] = True
                        if not ignore_existing and not some_participants_exist:
                            some_participants_exist = True
                            self.application.service.add_notification(
                                make_datetime(),
                                'User exists', 'Some participants already exist')
                    if load_passwords:
                        result['password'] = \
                            cmscommon.crypto.hash_password(user.get('password'), method='plaintext')
                    else:
                        result['password'] = None
                    processed_users.append(result)
                r_params['users'] = processed_users
                r_params['has_errors'] = \
                    (some_participants_exist and not ignore_existing)
                r_params['load_passwords'] = load_passwords
                self.render('participation_preview.html', **r_params)
                return
            except Exception as error:
                self.application.service.add_notification(
                    make_datetime(), "Bad CSV file", repr(error))
                self.redirect(fallback_page)
                return
        elif action == 'save':
            user_id = self.get_body_arguments('user_id', False)
            teams = self.get_body_arguments('team', False)
            passwords = self.get_body_arguments('password', False)
            for i in range(len(user_id)):
                user = self.safe_get_item(User, user_id[i])
                team = None
                if teams[i]:
                    team_code = ImportParticipantsHandler \
                        .prepare_team_code(teams[i])
                    team = self.sql_session.query(Team) \
                        .filter_by(code=team_code).first()
                    if not team:
                        team = Team(code=team_code, name=teams[i])
                        self.sql_session.add(team)
                password = passwords[i] if passwords else None
                participation = Participation(user=user,
                                              contest=self.contest,
                                              team=team,
                                              password=password)
                self.sql_session.add(participation)
            if self.try_commit():
                # Create the user on RWS.
                self.application.service.proxy_service.reinitialize()
                self.redirect(self.url("contest", contest_id, "users"))
                return
        self.redirect(fallback_page)