示例#1
0
 def __fetch_to_object(self, fetchresult, return_one=False):
     """
     fetch[0]: id_championnat
     fetch[1]: id_equipe
     fetch[2]: id_equipe_exterieur
     fetch[3]: id_match
     fetch[4]: date_match
     fetch[5]: commentaire_match
     fetch[6]: isplayed_match
     :param fetchresult:
     :param return_one:
     :return:
     """
     liste = []
     try:
         if len(fetchresult) > 0:
             for fetch in fetchresult:
                 obj = Match(fetch[1],
                             fetch[2],
                             fetch[4],
                             fetch[5],
                             fetch[6])
                 obj.id = fetch[3]
                 liste.append(obj)
             return liste if not return_one else liste[0]
         else:
             return None
     except Exception as ex:
         DAOException(self, ex)
示例#2
0
def register_player(contest_id, user_id):
	contest = Contest.objects(id = contest_id)[0]
	player_list = PlayerList.objects(contestId = contest_id)[0]
	user_id_to_substitute = player_list.userIds[contest.currentPlayers]
	player_list.userIds[contest.currentPlayers] = user_id
	player_list.save()
	match_list = get_match_list_by_contest_id(contest_id)
	contest.currentPlayers += 1
	contest.save()
	for i in Match.objects(player1Id = user_id_to_substitute):
		if not i.id in match_list.matches: 
			print "OK!"
			continue
		print "YEAH"
		i.player1Id = user_id
		i.save()

	print "HAHA"
	for i in Match.objects(player2Id = user_id_to_substitute):
		if not i.id in match_list.matches:
			print "OK!"
			continue
		print "YEAH"
		i.player2Id = user_id
		i.save()
	if contest.format == "Single Round-Robin":
		graph1 = get_graph_by_contest_id(contest_id)
		for i in graph1.items:
			if i.playerId == user_id_to_substitute:
				i.playerId = user_id
				break
		graph1.save()
示例#3
0
    def push_loop_preventing_drop_rules(self, sw, table_number):

        for h_id in self.network_graph.host_ids:

            # Get concerned only with hosts that are directly connected to this sw
            h_obj = self.network_graph.get_node_object(h_id)
            if h_obj.sw.node_id != sw:
                continue

            # Get a vanilla flow
            flow = self.create_base_flow(sw, table_number, 100)
            action_list = []

            # Compile match with in_port and destination mac address
            if self.network_graph.controller == "ryu":
                flow["match"]["in_port"] = h_obj.switch_port.port_number
                flow["match"]["eth_dst"] = h_obj.mac_addr

            elif self.network_graph.controller == "onos":

                flow_match = Match(is_wildcard=True)
                flow_match["ethernet_type"] = 0x0800
                mac_int = int(h_obj.mac_addr.replace(":", ""), 16)
                flow_match["ethernet_destination"] = int(mac_int)
                flow_match["in_port"] = int(h_obj.switch_port.port_number)

                flow["selector"]["criteria"] = flow_match.generate_match_raw(
                    self.network_graph.controller,
                    flow["selector"]["criteria"])

            # Make and push the flow
            self.populate_flow_action_instruction(flow, action_list, True)
            self.push_flow(sw, flow)
示例#4
0
    def push_host_vlan_tagged_packets_drop_rules(self, sw,
                                                 host_vlan_tagged_drop_table):

        for h_id in self.network_graph.host_ids:

            # Get concerned only with hosts that are directly connected to this sw
            h_obj = self.network_graph.get_node_object(h_id)
            if h_obj.sw.node_id != sw:
                continue

            # Get a vanilla flow
            flow = self.create_base_flow(sw, host_vlan_tagged_drop_table, 100)
            action_list = []

            if self.network_graph.controller == "ryu":
                flow["match"]["in_port"] = h_obj.switch_port.port_number
                flow["match"]["vlan_vid"] = self.network_graph.graph.node[sw][
                    "sw"].synthesis_tag

            elif self.network_graph.controller == "onos":
                flow_match = Match(is_wildcard=True)
                flow_match["ethernet_type"] = 0x0800
                flow_match["in_port"] = int(h_obj.switch_port.port_number)
                flow_match["vlan_id"] = self.network_graph.graph.node[sw][
                    "sw"].synthesis_tag

                flow["selector"]["criteria"] = flow_match.generate_match_raw(
                    self.network_graph.controller,
                    flow["selector"]["criteria"])

            # Make and push the flow
            self.populate_flow_action_instruction(flow, action_list, True)
            self.push_flow(sw, flow)
示例#5
0
def create_match(message):
    app.logger.info("TRYING TO CREATE A NEW MATCH")
    match = Match(server_config, message['whites'], message['blacks'],
                  message['wt'], message['bt'], message['wi'], message['bi'])
    manager.add(match)
    emit('receive-new-match',
         match.get_reduced_status(),
         room=accountant.get_cpanel())
示例#6
0
def new():
    if request.method == 'GET':
        return make_response(render_template('Theme/form_component.html'))
    elif request.method == 'POST':
        app.logger.info("CREATING MATCH FOR W:" + request.json['white_name'] +
                        " B:" + request.json['black_name'])
        match = Match(server_config, request.json['white_name'],
                      request.json['black_name'])
        manager.add(match)
        return json.dumps(match.get_reduced_status())
示例#7
0
文件: game.py 项目: vdsbenoit/baden
def validate_game_collection():
    """
    To perform AFTER the method model.service.set_player_codes() is called
    Assert the game setup complies with the following constraints:
        - a team cannot play against itself
        - a team cannot play against another team more one than once
        - a team cannot play a game more than once
        - a team cannot play two matches at the same time
        - a game cannot have the same hash as another game
    """
    duel_set_list = list()
    for time in range(1, len(Match.objects().distinct('time')) + 1):
        player_list = list()
        for m in Match.objects(time=time):
            players = m.players_number
            players_set = {players[0], players[1]}
            assert (players[0] not in player_list
                    ), "Team {} plays two games at time {}".format(
                        players[0], time)
            assert (players[1] not in player_list
                    ), "Team {} plays two games at time {}".format(
                        players[1], time)
            assert (
                players[0] != players[1]
            ), "Player {} plays against itself in game {} at time {}".format(
                players[0], m.game_number, time)
            assert (players_set not in duel_set_list
                    ), "Team {} already played against team {}".format(
                        players[0], players[1])
            player_list.append(players[0])
            player_list.append(players[1])
            duel_set_list.append(players_set)

    hash_list = list()

    for g in Game.objects():
        game_hash = g.hash
        assert game_hash not in hash_list, "Hash {} is used twice".format(
            game_hash)
        hash_list.append(game_hash)

        player_list = list()
        matches = Match.objects(game_number=g.number)
        for m in matches:
            players = m.players_number
            assert (
                players[0]
                not in player_list), "Team {} plays twice the game {}".format(
                    players[0], g.number)
            assert (
                players[1]
                not in player_list), "Team {} plays twice the game {}".format(
                    players[1], g.number)
            player_list.append(players[0])
            player_list.append(players[1])
示例#8
0
def get_score(team_code):
    """
    Get the score of a given team
    :param team_code: a team code
    :return: a tuple (score, victories, evens, defeats)
    """
    evens = Match.objects(players_code=team_code, even=True).count()
    victories = Match.objects(winner=team_code).count()
    defeats = Match.objects(loser=team_code).count()
    score = victories * 2 + evens
    return score, victories, evens, defeats
示例#9
0
def round_deserializer(reloaded_round):
    reload_round = Round(reloaded_round["round_number"],
                         reloaded_round["start_time"],
                         reloaded_round["end_time"])
    for match in reloaded_round["matches"]:
        player1 = player_deserializer(match["player1"])
        player2 = player_deserializer(match["player2"])
        reload_match = Match(player1, player2)
        reload_match.score_player1 = match["score_player1"]
        reload_match.score_player2 = match["score_player2"]
        reload_round.add_reload_match(reload_match)
    return reload_round
示例#10
0
 def update_scores(self, match):
     """
     Update score of both Match and Player table
     Args:
         match: match to update
     """
     while True:
         response = self.select.write_score_menu(match)
         if input_validators.is_valid_write_score_menu_response(response):
             break
     Match.update_score_match(self, match, response, self.match_table)
     Player.update_score_player(self, match, response, self.player_table)
示例#11
0
 def search(self, password=None, **kwargs):
     login_page = request_login("match", password, 2)
     if login_page:
         return login_page
     page = get_html("search.html")
     warning = ""
     len_kwargs = len([k for k, v in kwargs.items() if v != ""])
     if kwargs:
         if len_kwargs > 1:
             try:
                 time = None
                 game_number = None
                 if kwargs["time"]:
                     time = int(kwargs["time"])
                 if kwargs["game_number"]:
                     game_number = int(kwargs["game_number"])
                 if kwargs["team1_code"] and kwargs["team2_code"]:
                     match = Match.objects(players_code__all=[
                         kwargs["team1_code"], kwargs["team2_code"]
                     ]).get()
                 else:
                     team_code = kwargs.get("team1_code") or kwargs.get(
                         "team2_code") or None
                     if team_code:
                         if time:
                             match = Match.objects(
                                 time=time, players_code=team_code).get()
                         else:
                             match = Match.objects(
                                 game_number=game_number,
                                 players_code=team_code).get()
                     else:
                         match = Match.objects(
                             time=time, game_number=game_number).get()
             except ValueError:
                 warning = "Le numéro doit être un nombre"
                 log.error(
                     "{} tried to search a match with an non-integer value)"
                     .format(str(cherrypy.request.remote.ip)))
             except (DoesNotExist, Exception):
                 warning = "Aucun match ne correspond à la recherche"
                 log.error(
                     "{} tried to search a match but it was not found (time={}, game_number={}, team1_code={}, team2_code={})"
                     .format(str(cherrypy.request.remote.ip),
                             kwargs.get("time", ""),
                             kwargs.get("game_number", ""),
                             kwargs.get("team1_code", ""),
                             kwargs.get("team2_code", "")))
             else:
                 return self.match(mid=match.id)
         else:
             warning = "Minimum 2 champs sont nécessaires pour trouver un match"
     return page.replace("{warning}", warning)
示例#12
0
def get_all_schedules():
    schedules = list()
    highest_time_game_number = Match.objects(
        time=model.match.get_match_quantity()).first().game_number
    for match in Game.objects(number=highest_time_game_number).get().matches:
        schedules.append(match.schedule)
    return schedules
 def get_new(id_team_home,
             id_team_outside,
             datetime=None,
             comment=None,
             isplayed=False):
     obj = Match(id_team_home, id_team_outside, datetime, comment, isplayed)
     return obj
示例#14
0
def get_matches(team_code):
    """
    Get list of matches for a given team
    :param team_code: team code
    :return: Match QuerySet ordered in time
    """
    return Match.objects(players_code=team_code).order_by('time')
def prepare_flow_specifications(measurement_rates=None, tests_duration=None):

    flow_specs = []

    flow_match = Match(is_wildcard=True)
    flow_match["ethernet_type"] = 0x0800
    switch_hosts = ["7e", "e5", "66", "38"]

    configured_rate = 50

    # for src_host, dst_host in permutations(switch_hosts, 2):
    # for src_host, dst_host in [("7e", "38"),
    #                            ("38", "7e"),
    #                            ("66", "e5"),
    #                            ("e5", "66")]:
    #

    for src_host, dst_host in [("e5", "7e"), ("7e", "e5")]:
        if src_host == dst_host:
            continue

        # measurement_rates = []
        fs = FlowSpecification(src_host_id=src_host,
                               dst_host_id=dst_host,
                               configured_rate=configured_rate,
                               flow_match=flow_match,
                               measurement_rates=measurement_rates,
                               tests_duration=tests_duration,
                               delay_budget=None)

        flow_specs.append(fs)

    return flow_specs
示例#16
0
    def create_first_round(self):
        new_round = Round.create_round()
        serialized_round = vars(new_round)
        new_matchs_id = []
        self.round_table.insert(serialized_round)
        list_of_players_by_ranking = self.list_of_players_by_ranking()
        Play = Query()
        for i in range(4):
            new_match = Match.create_match(
                self.player_table.get(
                    Play.ranking == list_of_players_by_ranking[0][i]["ranking"]
                ).doc_id,
                self.player_table.get(
                    Play.ranking == list_of_players_by_ranking[1][i]["ranking"]
                ).doc_id,
            )
            serialized_match = vars(new_match)
            self.match_table.insert(serialized_match)
            new_matchs_id.append(self.match_table.all()[-1].doc_id)
        list_of_rounds = self.tournament_table.all()[-1]["rounds"]
        list_of_rounds.append(self.round_table.all()[-1].doc_id)
        self.round_table.update(
            {"list_of_match": new_matchs_id},
            doc_ids=[self.round_table.all()[-1].doc_id],
        )
        self.tournament_table.update(
            {"rounds": list_of_rounds},
            doc_ids=[self.tournament_table.all()[-1].doc_id],
        )
        self.warning.round_create(str(self.round_table.all()[-1]["current_round"]))
        self.table.matchs()

        return self.manage_tournament()
示例#17
0
def set_player_codes():
    """
    Set players codes in all the Match objects
    """
    for match in Match.objects():
        for number in match.players_number:
            match.players_code.append(Team.objects(number=number).get().code)
        match.save()
示例#18
0
文件: team.py 项目: vdsbenoit/baden
def set_matches():
    modified_teams = list()
    for t in Team.objects():
        for m in Match.objects(players_code=t.code).order_by('time'):
            t.matches.append(m)
        modified_teams.append(t)
    for t in modified_teams:
        t.save()
示例#19
0
def get_opponent_code(game_number, team_code):
    """
    Get the opponent of a given player at a given game
    :param game_number: the game number
    :param team_code: the player code
    :return: the opponent code
    """
    match = Match.objects(game_number=game_number,
                          players_code=team_code).get()
    for p in match.players_code:
        if p != team_code:
            return p
示例#20
0
    def deserializer(name):
        db = TinyDB("db_tournament.json", indent=4)
        tournaments = db.table("Tournaments")
        tournament = Query()

        tournament = tournaments.search(tournament.name == name)[0]
        reload_tournament = Tournament(
            tournament["name"],
            tournament["time control"],
            tournament["place"],
            tournament["date"],
            tournament["description"],
        )

        for player in tournament["players"]:
            reload_player = Player(
                player["first name"],
                player["last name"],
                player["elo"],
                player["date of birth"],
                player["player's gender"],
                player["score"],
                player["opponent list"],
            )
            reload_tournament.add_player(reload_player)

        for round in tournament["rounds"]:
            reload_round = Round(round["number"])
            for match in round["matchs"]:
                player1 = Player(
                    match["player1"]["first name"],
                    match["player1"]["last name"],
                    match["player1"]["elo"],
                    match["player1"]["date of birth"],
                    match["player1"]["player's gender"],
                    match["player1"]["score"],
                    match["player1"]["opponent list"],
                )
                player2 = Player(
                    match["player2"]["first name"],
                    match["player2"]["last name"],
                    match["player2"]["elo"],
                    match["player2"]["date of birth"],
                    match["player2"]["player's gender"],
                    match["player2"]["score"],
                    match["player2"]["opponent list"],
                )
                reload_match = Match(player1, player2, match["score player 1"],
                                     match["Score player 2"])
                reload_round.add_reload_match(reload_match)
            reload_tournament.add_round(reload_round)
        return reload_tournament
    def instanciation_matchs(self, i):
        """ Fonction qui instancie les matchs du tournoi à partir du .json """
        round_table = self.tournament_progress.serialized_rounds[i]
        round_matchs = round_table["Round Matchs"]

        for s_match in round_matchs:
            print(s_match)
            m = Match(
                player1=s_match["Player1"],
                player2=s_match["Player2"],
                score1=s_match["Score1"],
                score2=s_match["Score2"],
            )

            self.tournament_progress.rounds[i].add_match(m.player1, m.player2)
示例#22
0
def reset_match(game_number, team1_code, team2_code):
    """
    Reset the score of a match
    Assert the match exists.
    :param game_number: a game number
    :param team1_code: a team code
    :param team2_code: another team code
    """
    match = Match.objects(game_number=game_number,
                          players_code__all=[team1_code, team2_code]).get()
    match.winner = ""
    match.loser = ""
    match.even = False
    match.recorded = False
    match.save()
    log.info("Match id {} score has been reset".format(match.id))
示例#23
0
def prepare_flow_specifications(measurement_rates, tests_duration, number_of_switches, hps, number_of_RT_flows,
                                number_of_BE_flows, delay_budget, cap_rate):

    flow_specs = []

    flow_match = Match(is_wildcard=True)
    flow_match["ethernet_type"] = 0x0800

    flowlist = list(itertools.product(range(1, number_of_switches+1), range(1, hps+1)))

    # for real-time flows
    # if unique number (e.g. unique flow-per host) required
    # index_list = random.sample(range(len(flowlist)), number_of_RT_flows + 1) # for real-time flows

    # generate random indices (#of_RT_flows)
    index_list = [random.randint(0, len(flowlist) - 1) for i in range(number_of_RT_flows)]

    for i in range(number_of_RT_flows):
        indx = flowlist[index_list[i]]
        rnd = range(1, indx[0]) + range(indx[0]+1, number_of_switches+1)
        nxtindx = (random.choice(rnd), random.randint(1, hps))

        #nxtindx = flowlist[index_list[i+1]]

        forward_flow, reverse_flow = get_forward_reverse_flow(measurement_rates, cap_rate, indx, nxtindx, flow_match,
                                                              delay_budget, tests_duration, "real-time")

        flow_specs.append(forward_flow)
        flow_specs.append(reverse_flow)

    # for best-effort flows
    index_list = random.sample(range(len(flowlist)), number_of_BE_flows + 1)  # for best-effort flows

    for i in range(number_of_BE_flows):
        indx = flowlist[index_list[i]]
        rnd = range(1, indx[0]) + range(indx[0] + 1, number_of_switches + 1)
        nxtindx = (random.choice(rnd), random.randint(1, hps))

        #nxtindx = flowlist[index_list[i + 1]]

        forward_flow, reverse_flow = get_forward_reverse_flow(measurement_rates, cap_rate, indx, nxtindx, flow_match,
                                                              delay_budget, tests_duration, "best-effort")

        flow_specs.append(forward_flow)
        flow_specs.append(reverse_flow)

    return flow_specs
示例#24
0
def prepare_flow_specifications(measurement_rates, tests_duration,
                                delay_budget):

    flow_specs = []

    flow_match = Match(is_wildcard=True)
    flow_match["ethernet_type"] = 0x0800

    h1s2_to_h1s1 = FlowSpecification(src_host_id="h1s2",
                                     dst_host_id="h1s1",
                                     configured_rate=50,
                                     flow_match=flow_match,
                                     measurement_rates=measurement_rates,
                                     tests_duration=tests_duration,
                                     delay_budget=delay_budget)

    h2s2_to_h2s1 = FlowSpecification(src_host_id="h2s2",
                                     dst_host_id="h2s1",
                                     configured_rate=50,
                                     flow_match=flow_match,
                                     measurement_rates=measurement_rates,
                                     tests_duration=tests_duration,
                                     delay_budget=delay_budget)

    h1s1_to_h1s2 = FlowSpecification(src_host_id="h1s1",
                                     dst_host_id="h1s2",
                                     configured_rate=50,
                                     flow_match=flow_match,
                                     measurement_rates=[],
                                     tests_duration=tests_duration,
                                     delay_budget=delay_budget)

    h2s1_to_h2s2 = FlowSpecification(src_host_id="h2s1",
                                     dst_host_id="h2s2",
                                     configured_rate=50,
                                     flow_match=flow_match,
                                     measurement_rates=[],
                                     tests_duration=tests_duration,
                                     delay_budget=delay_budget)

    flow_specs.append(h1s2_to_h1s1)
    flow_specs.append(h2s2_to_h2s1)

    flow_specs.append(h1s1_to_h1s2)
    flow_specs.append(h2s1_to_h2s2)

    return flow_specs
示例#25
0
def matching(list_sort, turn, tournament):
    """ Cette fonction fait correspondre le joueur 1 avec le jouer 2 le joueur 3 avec
        le joueur 4, et ainsi de suite. Si le joueur 1 a déjà joué contre le joueur 2,
        elle l'associe plutôt au joueur 3.   """
    matches = 0
    while matches < 4:
        player = list_sort[0]
        for opponent in list_sort[1:]:
            current_match = Match(player, opponent)
            if current_match in tournament.matches_list:
                continue
            tournament.add_matches(current_match)
            turn.matches_list.append(current_match)
            list_sort.remove(opponent)
            list_sort.remove(player)
            break
        matches += 1
示例#26
0
def set_even(game_number, team1_code, team2_code):
    """
    Set a match as equally won.
    Assert the match exists.
    :param game_number: a game number
    :param team1_code: a team code
    :param team2_code: another team code
    """
    match = Match.objects(game_number=game_number,
                          players_code__all=[team1_code, team2_code]).get()
    match.winner = ""
    match.loser = ""
    match.even = True
    match.recorded = True
    match.save()
    log.info("Team {} and team {} are equally placed at the game {}".format(
        team1_code, team2_code, game_number))
示例#27
0
def create_match_players(user_id_from, user_id_to):
    user_from = User.query.get(user_id_from)
    user_to = User.query.get(user_id_to)

    if not user_from or not user_to:
        response_object = {
            'status': 'fail',
            'message': 'Usuario no encontrado'
        }
        return response_object, 404

    match = Match(user_from_id=user_id_from, user_to_id=user_id_to)

    save_changes(match)
    response_object = {
        'status': 'success',
        'message': 'Match enviado correctamente.'
    }
    return response_object, 200
示例#28
0
def set_winner(game_number, winner_team_code, loser_team_code):
    """
    Set a team as the winner of a match.
    Assert the match exists.
    :param game_number: a game number
    :param winner_team_code: the winner team code
    :param loser_team_code: the loser team code
    :return: True if the match was updated, False if the match was not found
    """
    if winner_team_code == loser_team_code:
        raise BadenException("Winner and loser team code are identical")
    match = Match.objects(
        game_number=game_number,
        players_code__all=[winner_team_code, loser_team_code]).get()
    match.winner = winner_team_code
    match.loser = loser_team_code
    match.even = False
    match.recorded = True
    match.save()
    log.info("Team {} won the game {} against {}".format(
        winner_team_code, game_number, loser_team_code))
示例#29
0
文件: api.py 项目: vdsbenoit/baden
 def get_game_number(self, team1_code, team2_code):
     if not service.is_team(team1_code):
         log.error(
             "{} unsuccessfully tried to get the game number of team code {} but the opponent team code {} was wrong"
             .format(str(cherrypy.request.remote.ip), team2_code,
                     team1_code))
         return ""
     if not service.is_team(team2_code):
         log.error(
             "{} unsuccessfully tried to get the game number of team code {} but the opponent team code {} was wrong"
             .format(str(cherrypy.request.remote.ip), team1_code,
                     team2_code))
         return ""
     try:
         return str(
             Match.objects(players_code__all=[team1_code, team2_code
                                              ]).get().game_number)
     except DoesNotExist:
         msg = "Les équipes {} et {} ne sont pas censées jouer ensemble".format(
             team1_code, team2_code)
         log.info(msg)
         return "Error: " + msg
示例#30
0
    def synthesize_node_pairs(self, src_hosts, dst_hosts, dst_port=None):

        print "Synthesizing backup paths between host pairs..."

        for i in xrange(len(src_hosts)):

            src_h_obj = self.network_graph.get_node_object(src_hosts[i])
            dst_h_obj = self.network_graph.get_node_object(dst_hosts[i])

            # Ignore installation of paths between switches on the same switch
            if src_h_obj.sw.node_id == dst_h_obj.sw.node_id:
                continue

            print "-----------------------------------------------------------------------------------------------"
            print 'Synthesizing primary and backup paths from', src_hosts[
                i], 'to', dst_hosts[i]
            print "-----------------------------------------------------------------------------------------------"

            flow_match = Match(is_wildcard=True)
            flow_match["ethernet_type"] = 0x0800

            if dst_port:
                flow_match["ip_protocol"] = 6
                flow_match["tcp_destination_port"] = dst_port

            self.synthesize_flow(src_h_obj, dst_h_obj, flow_match)
            print "-----------------------------------------------------------------------------------------------"

        self._identify_reverse_and_balking_intents()
        self.push_switch_changes()

        if "mac_acl" in self.params:
            if self.params["mac_acl"]:
                self.push_mac_acls()

        self.synthesis_lib.save_synthesized_paths(
            self.network_configuration.conf_path)
示例#31
0
def matches():
    if request.method == 'POST':
        teams = get_teams_db()
        match = Match(request.form['team_home'], request.form['team_away'])
        match_id = insert_match_db(match)
        stadiums = get_stadiums_db()
        stadium_id = get_stad_id_with_stad_name(request.form['stadium_name'])
        appointment = Appointment(request.form['appointment_name'], match_id, stadium_id, request.form['start_time'], request.form['end_time'], request.form['match_date'])
        if not request.form['appointment_name']:
            matchs = get_appointments_db()
            return render_template("matches.html", matchs=matchs, teams=teams, stadiums=stadiums, error="Appointment name can not be empty!")
        try:
            insert_appointments_db(appointment)
            flash("Appointment successfully created!")
            matchs = get_appointments_db()
        except psycopg2.errors.UniqueViolation:
            matchs = get_appointments_db()
            return render_template("matches.html", matchs=matchs, teams=teams, stadiums=stadiums, error="Appointment name already exists!")
        return render_template("matches.html", matchs=matchs, teams=teams, stadiums=stadiums)
    if request.method == 'GET':
        teams = get_teams_db()
        matchs = get_appointments_db()
        stadiums = get_stadiums_db()
        return render_template("matches.html", matchs=matchs, teams=teams, stadiums=stadiums)
示例#32
0
def generate_match_list(contest_id):
	contest = get_contest_by_id(contest_id)
	player_list = get_player_list_by_contest_id(contest_id)
	print player_list.userIds
	if contest.format == "Single Round-Robin":
		n = contest.totalPlayers
		if n % 2 == 0:
			matches = []
			for i in range(0, n - 1):
				for j in range(i, n - 1):
					t = (i + j) % (n - 1) + 1
					if i == j:
						player1_id = player_list.userIds[i]
						player2_id = player_list.userIds[n - 1]
					else:
						player1_id = player_list.userIds[i]
						player2_id = player_list.userIds[j]
					match = Match(player1Id = player1_id, player2Id = player2_id, score1 = -1, score2 = -1, day = t)
					match.save()
					matches.append(match)
		else:
			matches = []
			for i in range(0, n):
				for j in range(i, n):
					t = (i + j) % n + 1	
					if i == j:
						player1_id = player_list.userIds[i]
						player2_id = usermanage.get_user_by_name("", "BYE").id
					else:
						player1_id = player_list.userIds[i]
						player2_id = player_list.userIds[j]
					match = Match(player1Id = player1_id, player2Id = player2_id, score1 = -1, score2 = -1, day = t)
					match.save()
					matches.append(match)
		matches.sort(key = lambda Match: Match.day)
		match_list = MatchList(contestId = contest_id, matches = [])
		for i in matches: match_list.matches.append(i.id)
		match_list.save()
示例#33
0
def get_match_by_id(match_id):
	return Match.objects(id = match_id)[0]