示例#1
0
def createPlayerShotokan(request, tournament_id):
    template = loader.get_template('shotokanCreatePlayer.html')

    if request.method == 'POST':
        form = ShotokanPlayerCreateForm(request.POST)

        if form.is_valid():
            player = Player(
                name=form.cleaned_data.get('name'),
                surname=form.cleaned_data.get('surname'),
                team_id=Team.objects.get(name=form.cleaned_data.get('teams')),
                acceptedbycoachteam=True,
                acceptedbyplayer=True)
            player.save()

            player_tournament = PlayerTournament(
                player_id=player,
                tournament_id=Tournament.objects.get(pk=tournament_id),
                acceptedbymanager=True,
                acceptedbycoach=True)
            player_tournament.save()

            return redirect('/shotokanPlayers/%s/' % tournament_id)
    else:
        form = ShotokanPlayerCreateForm()

    context = RequestContext(request, {
        'form': form,
    })
    return HttpResponse(template.render(context))
def populate_players_model():
    # Loop through the top level dictionary
    for team, value in premier_league_players_dictionary.items():

        # Loop through the players in each team
        for player_name, val in value['squad_players'].items():

            # Create a new player instance for each player
            player_entry = Player(club=Club.objects.get(club=team),
                                  player=player_name,
                                  club_name=team,
                                  position=val['position'],
                                  nationality=val['nationality'])
            player_entry.save()
示例#3
0
def login_player(request):
    t = str(time.time())
    player_name = request.POST["player_name"]
    request.session["player_name"] = player_name
    request.session["mode"] = request.POST["mode"]
    request.session["room_id"] = None
    if request.POST["mode"] == "solo":
        player = Player(name=player_name, created_at=t)
        player.save()
        request.session["player_id"] = list(
            Player.objects.all().filter(created_at=t).values("id"))[0]["id"]
    elif request.POST["mode"] == "multi":
        room_name = request.POST["room_name"]
        room_id = list(
            Room.objects.all().filter(name=room_name).values())[0]["id"]
        room_num = list(
            Room.objects.all().filter(name=room_name).values())[0]["num"]
        player_num = len(
            list(Player.objects.all().filter(room_id=room_id).values()))
        if player_num >= room_num:
            return HttpResponse("false")
        request.session["room_id"] = room_id
        player = Player(name=player_name, created_at=t)
        player.save()
        request.session["player_id"] = list(
            Player.objects.all().filter(created_at=t).values("id"))[0]["id"]
        obj = Player.objects.get(id=request.session["player_id"])
        obj.room_id = room_id
        obj.save()
    # return HttpResponseRedirect("/mode/solo")
    return HttpResponse("true")
示例#4
0
def register(request):
	error = {'username': '', 'email': '', 'password2': ''}
	if request.method == 'POST':
		form = RegisterForm(request.POST)
		error = form.errors
		if form.is_valid():
			confirm = User.objects.create_user(username = form.cleaned_data['username'], email = form.cleaned_data['email'], password = form.cleaned_data['password2'])
			confirm.save
			u = User.objects.get(username = form.cleaned_data['username'])
			foreign = Player(username = u, email = form.cleaned_data['email'], totalgame = 0, totalwin = 0, times_today = 0, percent = 0, money = 100, user_id = u.id, last_reg = date.today())
			foreign.save()
			return HttpResponseRedirect('/login/')
	else:
		form = RegisterForm()
	return render_to_response('register.html', {'error_user': error.get('username'), 'error_email': error.get('email'), 'error_password': error.get('password2')})
示例#5
0
 def create_player(self, **kwargs):
     kwargs = merge_args(
         {
             'bid': randint(0, 1e9),
             'region': Region.EU,
             'realm': 1,
             'mode': Mode.TEAM_1V1,
             'season': self.season,
             'race': Race.ZERG,
             'name': uniqueid(12),
             'clan': uniqueid(32),
             'tag': uniqueid(6)
         }, **kwargs)
     self.player = Player(**kwargs)
     self.player.save()
     return self.player
    def save_players(self, players):
        print('Saving players found')
        # Initially, we need to map the team for any player
        for player in players:
            player['team'] = self.get_club_id_from_name(player['team'])

        Player.objects.bulk_create(
            [Player(**player) for player in players if player['team']])
示例#7
0
def add_player():
    player = Player(
        name=flask.request.form['name'],
        # is_alive=flask.request.form['is_alive'],
        is_alive=True,
        role=flask.request.form['role'],
    )
    db.session.add(player)
    db.session.commit()
    return flask.redirect(flask.url_for('show_players'))
示例#8
0
def add_player():
    player = Player(
        name=flask.request.form['user_name'],
        is_alive=True,
        role="村人",
        user_password=flask.request.form['user_password'],
        group_id=flask.request.form['group_id'],
        group_password=flask.request.form['group_password'],
    )
    db.session.add(player)
    db.session.commit()
    return flask.redirect(flask.url_for('top_view'))
示例#9
0
def register(response):
    if response.method == "POST":
        form = RegistrationForm(response.POST)
        if form.is_valid():
            #*Creating new RegistrationForm object which we will store in our database
            n = form.cleaned_data['username']
            p = Player(name=n)
            p.save()
            response.user.player.add(p)
            #*Logging in by default
            #!Cannot forget to save the form itself because authentication won't work otherwise
            form.save()
            return redirect("/login")
    else:
        form = RegistrationForm()

    if response.user.is_authenticated:
        u = Player.objects.get(id=response.user.id)
        return render(response, "register/register.html", {"form": form, "user": u, "logged_in": True})

    else:
        return render(response, "register/register.html", {"form": form, "logged_in": False})
示例#10
0
def populate_player():
    print('Cargando jugadores...')
    Player.objects.all().delete()
    main_directory = 'info_champ'
    directory = main_directory + '/' + 'players'
    lista = []
    ix = open_dir(directory)
    with ix.searcher() as searcher:
        doc = searcher.documents()
        for row in doc:
            p = Player(idPlayer=row['idPlayer'],
                       name=row['name'],
                       urlPerfil=row['urlPerfil'],
                       ranking=row['ranking'],
                       winrate=row['winrate'])
            listChampion = []
            for id in row['idsChampion'].split(','):
                champion = Champion.objects.get(idChampion=id)
                listChampion.append(champion)
            p.save()
            p.idsChampion.set(listChampion)
            lista.append(p)
    print('Jugadores insertados: ' + str(Player.objects.count()))
    print('---------------------------------------------------------')
示例#11
0
class Db(object):
    """ Helper class to create test data in db. """
    def __init__(self):
        self.db_name = connection.settings_dict['NAME']
        print(self.db_name)
        self.team = None
        self.cache = None
        self.player = None
        self.season = None
        self.ladder = None
        self.ranking = None
        self.ranking_data = None
        self.default_ranking_data__data = {}
        self.clear_defaults()

    def clear_defaults(self):
        self.default_ranking_data__data = {}

    @staticmethod
    def filter(klass, *args, **kwargs):
        return klass.objects.filter(*args, **kwargs)

    @staticmethod
    def count(klass, *args, **kwargs):
        return klass.objects.filter(*args, **kwargs).count()

    @staticmethod
    def get(klass, *args, **kwargs):
        return klass.objects.get(*args, **kwargs)

    @staticmethod
    def objects(klass):
        return klass.objects

    @staticmethod
    def all(klass):
        return klass.objects.all()

    @staticmethod
    def execute(sql):
        cursor = connection.cursor()
        cursor.execute(sql)
        return cursor

    def delete_all(self, keep=None, delete=None):
        for d in (delete or [
                RankingData, RankingStats, Cache, Ranking, Team, Player,
                Ladder, Season
        ]):
            if d not in (keep or []):
                if d == Ranking:
                    cursor = connection.cursor()
                    cursor.execute("update cache set ranking_id = NULL")
                if d == Ladder:
                    cursor = connection.cursor()
                    cursor.execute("update cache set ladder_id = NULL")
                self.all(d).delete()

    def create_season(self, **kwargs):
        kwargs = merge_args(
            {
                'id': 16,
                'start_date': '2013-11-11',
                'end_date': '2014-01-03',
                'name': '2013 Season 6',
                'year': 2013,
                'number': 6,
                'version': Version.HOTS
            }, **kwargs)
        try:
            self.get(Season, id=kwargs['id'])
            raise AssertionError("Season with id %d already exists." %
                                 kwargs['id'])
        except Season.DoesNotExist:
            pass
        self.season = Season(**kwargs)
        self.season.save()
        return self.season

    def create_cache(self, type=Cache.LADDER, members=None, **kwargs):
        data = kwargs.pop('data', None)
        if data is None and members is not None:
            data = gen_ladder_data(members)

        kwargs = merge_args(
            {
                'bid': randint(1, 1e6),
                'url': 'http://bnet/' + uniqueid(10),
                'type': type,
                'region': Region.EU,
                'created': utcnow(),
                'updated': utcnow(),
                'status': 200,
                'retry_count': 0
            }, **kwargs)
        kwargs['data'] = json.dumps(data)

        self.cache = Cache(**kwargs)
        self.cache.save()
        return self.cache

    def create_ladder(self, **kwargs):
        kwargs = merge_args(
            {
                'bid': 1,
                'region': Region.EU,
                'strangeness': Ladder.GOOD,
                'league': League.GOLD,
                'tier': 0,
                'version': Version.HOTS,
                'mode': Mode.TEAM_1V1,
                'season': self.season,
                'first_join': utcnow(),
                'last_join': utcnow(),
                'created': utcnow(),
                'updated': utcnow(),
                'max_points': 20
            }, **kwargs)

        self.ladder = Ladder(**kwargs)
        self.ladder.save()
        return self.ladder

    def create_player(self, **kwargs):
        kwargs = merge_args(
            {
                'bid': randint(0, 1e9),
                'region': Region.EU,
                'realm': 1,
                'mode': Mode.TEAM_1V1,
                'season': self.season,
                'race': Race.ZERG,
                'name': uniqueid(12),
                'clan': uniqueid(32),
                'tag': uniqueid(6)
            }, **kwargs)
        self.player = Player(**kwargs)
        self.player.save()
        return self.player

    def create_team(self, **kwargs):
        kwargs = merge_args(
            dict(region=Region.EU,
                 mode=Mode.TEAM_1V1,
                 season=self.season,
                 version=Version.HOTS,
                 league=League.GOLD,
                 member0=self.player,
                 member1=None,
                 member2=None,
                 member3=None,
                 race0=Race.ZERG,
                 race1=Race.UNKNOWN,
                 race2=Race.UNKNOWN,
                 race3=Race.UNKNOWN), **kwargs)

        self.team = Team(**kwargs)
        self.team.save()
        return self.team

    def create_teams(self, count=1, **kwargs):
        teams = []
        for i in range(count):
            self.create_player(name="%s-%d" % (uniqueid(8), i))
            teams.append(self.create_team(**kwargs))
        return teams

    def get_teams_by_member0_bids(self, *bids, mode=Mode.TEAM_1V1):
        tids = []
        for bid in bids:
            p = self.get(Player, bid=bid)
            tids.append(self.get(Team, member0=p, mode=mode).id)
        return tids

    def create_ranking(self, **kwargs):
        kwargs = merge_args(
            dict(created=utcnow(),
                 data_time=utcnow(),
                 min_data_time=utcnow(),
                 max_data_time=utcnow(),
                 status=Ranking.COMPLETE_WITH_DATA,
                 season=self.season), **kwargs)

        self.ranking = Ranking.objects.create(**kwargs)
        return self.ranking

    def _default_team_rank(self, team_rank):
        """ Update a team_rank dict with defaults. """
        for k, v in self.default_ranking_data__data.items():
            team_rank.setdefault(k, v)
        team_rank.setdefault("team_id", self.team.id)
        team_rank.setdefault("data_time", to_unix(self.ranking.data_time))
        team_rank.setdefault("version", Version.HOTS)
        team_rank.setdefault("region", Region.EU)
        team_rank.setdefault("mode", Mode.TEAM_1V1)
        team_rank.setdefault("league", League.GOLD)
        team_rank.setdefault("tier", 0)
        team_rank.setdefault("ladder_id", self.ladder.id)
        team_rank.setdefault("join_time", to_unix(self.ranking.data_time))
        team_rank.setdefault("source_id", self.cache.id)
        team_rank.setdefault("mmr", 1000)
        team_rank.setdefault("points", 100.0)
        team_rank.setdefault("wins", 10)
        team_rank.setdefault("losses", 10)
        team_rank.setdefault("race0", Race.ZERG)
        team_rank.setdefault("race1", Race.UNKNOWN)
        team_rank.setdefault("race2", Race.UNKNOWN)
        team_rank.setdefault("race3", Race.UNKNOWN)
        team_rank.setdefault("ladder_rank", 1)
        team_rank.setdefault("ladder_count", 1)
        team_rank.setdefault("league_rank", 1)
        team_rank.setdefault("league_count", 1)
        team_rank.setdefault("region_rank", 1)
        team_rank.setdefault("region_count", 1)
        team_rank.setdefault("world_rank", 1)
        team_rank.setdefault("world_count", 1)

    def create_ranking_data(self, raw=True, **kwargs):
        kwargs = merge_args(dict(ranking=self.ranking, updated=utcnow()),
                            kwargs)
        data = kwargs.pop('data', [])
        ranking = kwargs['ranking']

        for team_rank in data:
            self._default_team_rank(team_rank)
            ranking.sources.add(self.get(Cache, pk=team_rank['source_id']))

        self.ranking_data = RankingData.objects.create(**kwargs)
        sc2.save_ranking_data_raw(self.db_name, ranking.id, 0, data, True)
        if not raw:
            cpp = sc2.RankingData(self.db_name, Enums.INFO)
            cpp.load(ranking.id)
            cpp.save_data(ranking.id, ranking.season_id, to_unix(utcnow()))
            cpp.release()

        return self.ranking_data

    def update_ranking_stats(self, ranking_id=None):
        """ Will build ranking stats based of the ranking by calling c++. """
        if ranking_id is None: ranking_id = self.ranking.id
        cpp = sc2.RankingData(self.db_name, Enums.INFO)
        cpp.load(ranking_id)
        cpp.save_stats(ranking_id, to_unix(utcnow()))
        cpp.release()
示例#12
0
def load_user(user_id):
    return Player()
示例#13
0
def index(request):
    channel_id = '423486275'

    if request.method == 'POST':
        username = request.POST['mc-username']
        print(username)

        # username validation
        for i in username:
            if i.upper() not in string.ascii_uppercase + '0123456789_':
                # raise ValidationError
                raise Exception('Юзернейм неверен.')

        twitch_id = request.POST.get('id')
        obj = Player.objects.get(twitch_id=twitch_id, mc_username=None)
        obj.mc_username = username
        obj.save()
        return render(request, 'thanks.html', context={'username': username})

        # TODO: username at thanks.html

    else:
        if request.GET.get('code'):
            # getting user information
            resp = requests.post('https://id.twitch.tv/oauth2/token',
                                 data={
                                     'client_id':
                                     'geqwz9a4dhcg3wcmv8qsu07p5bb9cx',
                                     'client_secret':
                                     '37cs0vpf6k3l3s71d3e8ios99ql6wi',
                                     'code': request.GET.get('code'),
                                     'grant_type': 'authorization_code',
                                     'redirect_uri': 'http://' + DOMAIN_NAME,
                                 }).json()
            access_token = resp.get('access_token')
            if not access_token:
                return render(request,
                              '500.html',
                              context={
                                  'title':
                                  'Ошибка, попробуйте переавторизоваться.'
                              })
            headers = {
                'Accept': 'application/vnd.twitchtv.v5+json',
                'Client-ID': 'geqwz9a4dhcg3wcmv8qsu07p5bb9cx',
                'Authorization': 'OAuth %s' % access_token
            }
            user_id = requests.get('https://api.twitch.tv/helix/users',
                                   headers={
                                       'Accept':
                                       'application/vnd.twitchtv.v5+json',
                                       'Client-ID':
                                       'geqwz9a4dhcg3wcmv8qsu07p5bb9cx',
                                       'Authorization':
                                       'Bearer %s' % access_token
                                   }).json().get('data')[0].get('id')

            # checking if he is subbed
            resp2 = requests.get(
                'https://api.twitch.tv/kraken/users/%s/subscriptions/%s' %
                (user_id, channel_id),
                headers=headers).json()
            if resp2.get('status') == 404:
                return render(request,
                              'not_subbed.html',
                              context={'debug': str([resp, resp2])})

            obj = Player(twitch_id=user_id, mc_username=None)
            try:
                obj.save()
            except IntegrityError:
                if not Player.objects.filter(twitch_id=user_id,
                                             mc_username=None).exists():
                    return render(
                        request,
                        '500.html',
                        context={'title': 'Ты уже добавлен в вайтлист.'})
            return render(request, 'add.html', context={'twitch_id': user_id})
        return render(request, 'index.html', context={'test_id': channel_id})
示例#14
0
def edit(request):
    if not request.user.is_authenticated():
        return HttpResponseRedirect('/tf2recruiter/openid/')
    
    try:
        player = Player.objects.get(user=request.user)
    except Player.DoesNotExist:
        player = Player()
    
    if request.method == 'POST':
        form = PlayerForm(request.POST, instance=player)
        if form.is_valid():
            player.user=request.user
            player.alias = form.cleaned_data['alias']
            player.seasons = form.cleaned_data['seasons']
            days = ''
            for day in form.cleaned_data['days']:
                days = days + day
            player.days = days
            player.eseaid = form.cleaned_data['eseaid']
            es = ''
            for e in form.cleaned_data['esea']:
                es = es + e
            player.esea = es
            player.save()
            player.classes = form.cleaned_data['classes']
            player.save()
            return HttpResponseRedirect('/tf2recruiter/')
    else:
        form = PlayerForm(instance=player)

    return render_to_response('form.htm', { 'form': form, 'action':'/tf2recruiter/edit', 'user_':request.user}, context_instance=RequestContext(request))
示例#15
0
def incoming_text(request):
    league_from_number = request.GET.get('league')

    league = None
    if league_from_number:
        league = League.objects.get(shorthand_name=league_from_number)

    number = request.GET.get('From')
    msg = request.GET.get('Body').lower().replace('\n', '')
    sections = msg.split(" ")

    try:
        player = Player.objects.get(phone_number=number)
        if not player.username:
            player.username = msg
            player.save()
            return HttpResponse(createSmsResponse(COMMANDS_MSG))
    except:
        player = Player(phone_number=number)
        player.save()
        if league:
            return HttpResponse(createSmsResponse("Welcome to {0} on Undisputed. Enter your initials.".format(league.name)))
        else:
            return HttpResponse(createSmsResponse("Welcome to Undisputed. Enter your initials."))

    # join undisputed username firstname lastname
    # TODO- all other valid characters, regex check on each section

    if re.match("^me$",msg):
        return handle_me(number)
    # options
    elif re.match("^options$",msg):
        return HttpResponse(createSmsResponse(COMMANDS_MSG))

    elif re.match("^lost to [a-zA-z0-9_]+$", msg) and league_from_number:
        sections = [sections[0], sections[2], "in", league_from_number]
        return handle_win(number, sections, True)

    elif re.match("^beat [a-zA-z0-9_]+$", msg) and league_from_number:
        sections = sections + ["in", league_from_number]
        return handle_win(number, sections)

    # beat opponent1 (and opponent2 with partner )in competition_name
    elif re.match("^beat [a-zA-z0-9_]+ (and [a-zA-z0-9_]+ with [a-zA-z0-9_]+ )?in [a-zA-z0-9_]+$", msg):
        return handle_win(number, sections)

    # competition_name rankings
    elif re.match("^rankings$", msg) and league_from_number:
        sections = [league_from_number] + sections
        return handle_rank(number,sections)

    # competition_name rankings
    elif re.match("^[a-zA-z0-9_]+ rankings$", msg):
        return handle_rank(number,sections)

    # my competition_name stats
    elif re.match("^my stats$", msg) and league_from_number:
        sections = ['my', league_from_number, 'stats']
        return handle_stats(number,sections)

    # my competition_name stats
    elif re.match("^my [a-zA-z0-9_]+( [a-zA-z0-9_]+)? stats$", msg):
        sections = msg.split(" ")

        return handle_stats(number,sections)

     # create solo|partner|partnered league name password
    # TODO: league name multiple words?
    elif re.match("^create (solo|partnered|partner) league [a-zA-Z0-9_]+ [a-zA-Z0-9_]+$", msg):
        return handle_create_league(number, sections)

    # join league_name password (with partner):
    elif re.match("^join [a-zA-Z0-9_]+ [a-zA-Z0-9_]+( with [a-zA-Z ]+)?$",msg):
        return handle_join_league(number, sections)

    else:
        return HttpResponse(createSmsResponse("Not recognized. Text 'options' to view your options."))
示例#16
0
def get_player_info():
	"""Acquires basic info of all current NBA players and stores in DB."""

	player_ids = [p.player_id for p in PlayerID.objects.all()]
	params_ = {'LeagueID' : LEAGUE_ID, 'SeasonType' : SEASON_TYPE}
	Player.objects.all().delete()
	count = 1
	for play_id in player_ids:
		try:
			params_['PlayerID'] = play_id
			request = get(URL, params=params_).json()
			info_list = request['resultSets'][0]['rowSet'][0]

			info = Player()
			info.name = info_list[3]
			info.number = info_list[13]
			info.image = URL_IMAGE % play_id
			info.year_enter_league = info_list[22]
			info.position = info_list[14]
			info.height = info_list[10]
			info.weight = info_list[11]
			info.current_team = '%s %s' % (info_list[20], info_list[17])
			info.player_id = play_id
			info.save()
			print count, info.name
			count += 1
		except Exception, e:
			LOGGER.log(ERROR, 'Player Info Error')
			LOGGER.log(ERROR, 'ID: %d' % play_id)
			LOGGER.log(ERROR, 'Error: %s' % e)