Python Team.query方法代码示例

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def _create_or_get_team(team_name):
    logging.info('create_or_get_team: {}'.format(team_name))
    team = Team.query().filter(Team.name == team_name).get()
    if not team:
        team = Team(name = team_name)
    logging.info('returning {}'.format(team))
    return team

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def display_teams():
    sort_order = request.query.get('sort')

    teams = Team.query().order(-Team.elo, Team.name).fetch(100)
    data_list = []
    for team in teams:
        data_list.append(_get_team_win_loss(team))

    data_list = _sort_data_list(sort_order, data_list)

    template_values = {
        'headers': _add_sort_order_to_headers('/teams/', ['Team', 'ELO', 'Games', 'Wins', 'Percentage']),
        'data_list': data_list
    }
    return respond(JINJA_ENV.get_template('data_view.html'), template_values)

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def delete_team():
    team_name = request.query.get('team')
    team = Team.query().filter(Team.name == team_name).get()
    to_delete = []
    if team:
        to_delete.append(team.key)

    gamesA = Game.query().filter(Game.team_a == team_name)
    for game in gamesA:
        to_delete.append(game.key)

    gamesB = Game.query().filter(Game.team_b == team_name)
    for game in gamesB:
        to_delete.append(game.key)

    logging.info('about to delete {} obj'.format(len(to_delete)))
    ndb.delete_multi(to_delete)

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
    def get(self):
        now_hour = datetime.datetime.now().hour
        eligible_teams = []
        for team in Team.query().order(Team.ranked_last_match):
            if team.ranked_start_hour is None or team.ranked_end_hour is None:
                continue
            if not is_hour_in_start_end_time_range_adjusted_for_timezone_offset_issue(team.ranked_start_hour, team.ranked_end_hour, now_hour):
                continue
            if Player.query(Player.team == team.key, Player.doing == None).count() > 0: # Be aware that Player.doing == None will bug if you removed doing manually in dev console
                eligible_teams.append(team)

        while len(eligible_teams) >= 2:
            match = TeamMatch(type="TeamRanked")
            players = match.setup_team_match([eligible_teams.pop(), eligible_teams.pop()])
            for player in players:
                player.doing = match.key
                player.put()
                websocket_notify_player("Player_MatchFound", player.key, None, match.get_data())

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def recompute_elos():
    logging.info("fetching teams and making lookup")
    teams = Team.query().fetch(100)
    team_lookup = {}
    team_keys = []
    for team in teams:
        team_keys.append(team.key)
        team.elo = 1400
        team_lookup[team.name] = team

    logging.info('interating through games')
    games = Game.query()
    for game in games:
        _update_elo_with_teams(team_lookup[game.team_a], team_lookup[game.team_b], game.winner)

    logging.info('putting teams')
    ndb.put_multi(teams)
    logging.info('done')

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def display_team():
    sort_order = request.query.get('sort')
    team_name = request.query.get('team')
    team = Team.query().filter(Team.name == team_name).get()
    if not team:
        abort(404, 'team not found')

    data_list = []
    for map in MAPS:
        data_list.append(_get_team_map_win_loss(team, map))


    data_list = _sort_data_list(sort_order, data_list)

    template_values = {
        'headers': _add_sort_order_to_headers('/team/', ['Map', 'Games', 'Wins', 'Percentage'], {'team' :team_name}),
        'data_list': data_list,
        'color': 3
    }

    return respond(JINJA_ENV.get_template('data_view.html'), template_values)

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
def goog_auth_response_page():
    flow = client.flow_from_clientsecrets(
        CLIENT_SECRETS,
        scope=['https://www.googleapis.com/auth/plus.me', 'https://www.googleapis.com/auth/userinfo.email'],
        redirect_uri= flask.url_for('goog_auth_response.goog_auth_response_page', _external=True),
        login_hint='yelp.com',
    )

    error = request.args.get('error', '')
    auth_code  = request.args.get('code', '')

    if error:
        return str(error)
    elif auth_code:
        # creds' Class: oauth2client.client.OAuth2Credentials
        credentials = flow.step2_exchange(auth_code)

        # Get User Info from GPlus.
        http_auth = credentials.authorize(httplib2.Http())
        plus_service = discovery.build('plus', 'v1', http=http_auth)
        goog_request = plus_service.people().get(userId='me')
        result = goog_request.execute(http=http_auth)
        result['creds'] = credentials.to_json()

        # Check if we have user, or make new user.
        gplus_id = int(credentials.id_token['sub'])
        gplus_email = str(credentials.id_token['email'])

        if gplus_email.find('@yelp.com') == -1:
            return "You must use a @yelp.com email."

        seconds_til_expire = credentials.token_response['expires_in']
        current_time = time.mktime(datetime.now().timetuple())
        expire_time = current_time + seconds_til_expire

        stored_access_token = session.get('gplus_access_token')
        stored_gplus_id = session.get('gplus_id')
        stored_expire_time = session.get('goog_auth_expire_time')

        # Update session info with newest expire time/creds.
        session['gplus_access_token'] = credentials.access_token
        session['gplus_id'] = gplus_id
        session['goog_auth_expire_time'] = expire_time
        session['photo_url'] = result['image']['url']

        if (
                stored_access_token is not None and
                gplus_id == stored_gplus_id and
                stored_expire_time and
                current_time < stored_expire_time
        ):
            # User was connected, redirect to projects (or fill-in-user info?)
            return redirect(flask.url_for('projects.main'))
        else:
            # If user doesn't exist, make new user.
            stored_user = User.query(User.gplus_id == str(gplus_id)).get()
            if stored_user is None:
                # Create a new user.
                new_user = User(
                    gplus_id=str(gplus_id),
                    gplus_email=gplus_email,
                    admin=1,
                    first_name=result['name']['givenName'],
                    last_name=result['name']['familyName'],
                    photo_url=result['image']['url'],
                    team=Team.query(Team.type == 'Yelp Consumer').get().key
                )
                new_user_key = new_user.put()
                session["user_id"] = new_user_key.id()
                # REDIR to fill_out_your_info or project page?
                return redirect(flask.url_for('projects.main'))
            else:
                session["user_id"] = stored_user.key.id()
                # User exists! Show project page (or fill_out_info if missing info?).
                return redirect(flask.url_for('projects.main'))

        response = make_response(json.dumps(result), 200)
        response.headers['Content-Type'] = 'application/json'
        return response

# 需要导入模块: from models import Team [as 别名]
# 或者: from models.Team import query [as 别名]
 def get(self):
     set_json_response(self.response, [team.get_data() for team in Team.query()])