def load_team_participation_years( global_config, team_number=None):
    session = DbSession.open_db_session(global_config['db_name'] + global_config['this_season'])
    
    if team_number is None:
        global_config['logger'].debug( 'Loading Team Participation Info For All FRC Teams' )
        
        teams = session.query(DataModel.TeamInfo).all()
    
        for team in teams:
            if team.first_competed is None:
                print 'Getting participation years for FRC%d' % team.team
                url_str = '/api/v2/team/frc%d/years_participated' % team.team
                team_data = TbaIntf.get_from_tba_parsed(url_str)
                if len(team_data) > 0:
                    team.first_competed = team_data[0]
                    team.last_competed = team_data[-1]
                
                    session.commit()
    else:
        team = session.query(DataModel.TeamInfo).filter(DataModel.TeamInfo.team==int(team_number)).first()
        if team:
            url_str = '/api/v2/team/frc%s/years_participated' % team_number
            team_data = TbaIntf.get_from_tba_parsed(url_str)
            if len(team_data) > 0:
                team.first_competed = team_data[0]
                team.last_competed = team_data[-1]
                session.commit()

    session.remove()
            
    return
def load_event_info(global_config, year_str):
    
    session = DbSession.open_db_session(global_config['db_name'] + global_config['this_season'])
    
    if year_str.lower() == 'all':
        # get all events since the beginning of time
        year = 1992
        done = False
        while not done: 
            url_str = '/api/v2/events/%d' % year
            events_data = TbaIntf.get_from_tba_parsed(url_str)
            
            if len(events_data) == 0:
                done = True
            else:
                for event_data in events_data:
                    #print 'Event: %s' % event_data['key']
                    DataModel.addOrUpdateEventInfo(session, event_data)
                year += 1
    else:
        url_str = '/api/v2/events/%s' % year_str
        events_data = TbaIntf.get_from_tba_parsed(url_str)
        
        for event_data in events_data:
            print 'Event: %s' % event_data['key']
            DataModel.addOrUpdateEventInfo(session, event_data)
            
    session.commit()
    session.remove()
def get_events_json(global_config, year, type=None):
        
        global_config['logger'].debug( 'GET Event Info Json' )    
        
        url_str = '/api/v3/events/%s' % year
        try:
            event_data = TbaIntf.get_from_tba(url_str)
            if type != None:
                event_json = json.loads(event_data)
                result = []
                result.append('[')
                for event in event_json:
                    event_name = event['name']
                    event_type_words = type.split(' ')
                    type_match = False
                    for word in event_type_words:
                        if event_name.find(word) != -1:
                            type_match = True
                        else:
                            type_match = False
                            break
                    if type_match == True:
                        result.append(json.dumps(event))
                        result.append(',')
                if result[-1] == ',':
                    result = result[:-1]
                result.append(']\n')
                event_data = ''.join(result)
        except:
            event_data = ''
            pass
        return event_data
def load_team_info( global_config, name=None):
    session = DbSession.open_db_session(global_config['db_name'] + global_config['this_season'])
    
    if name is None:
        global_config['logger'].debug( 'Loading Team Info For All FRC Teams' )
        page = 0
        done = False
        while not done: 
            url_str = '/api/v2/teams/%d' % (page)
            teams_data = TbaIntf.get_from_tba_parsed(url_str)
            if len(teams_data) == 0:
                done = True
            else:
                for team_data in teams_data:
                    DataModel.setTeamInfoFromTba(session, team_data)
                page += 1
    else:
        global_config['logger'].debug( 'Loading Team Info For FRC Team %s' % name )
        '''
        url_str = '/api/v2/team/frc%s/%s' % (team_str,query_str)
        for page in range(0,14): 
            teams_data = TbaIntf.get_from_tba_parsed(url_str)
            for team_data in teams_data:
                setTeamInfoFromTba(session, team_data)
        '''
    session.remove()
def get_district_rankings_json(global_config, year, type):
        
        global_config['logger'].debug( 'GET District Rankings Json' )
        
        competition = global_config['this_competition']+year
        
        url_str = '/api/v3/district/%s%s/rankings' % (year,type.lower())

        result = []
        result.append('{ "district" : "%s",\n' % (type.upper()))

        try:
            rankings = TbaIntf.get_from_tba_parsed(url_str)
       
            # rankings is now a list of lists, with the first element of the list being the list of column headings
            # take the list of columngs and apply to each of the subsequent rows to build the json response
            result.append('  "last_updated": "%s",\n' % time.strftime('%c'))
            headings = [ 'Rank', 'Points', 'Team', 'Event 1', 'Event 2', 'Age Points' ]
    
            result.append('  "columns" : [\n')

            for heading in headings:
                result.append('    { "sTitle": "%s" }' % heading)
                result.append(',\n')
            if len(headings)>0:
                result = result[:-1]
            result.append(' ],\n')
            result.append('  "rankings" : [\n')

            for team_rank in rankings:
                result.append('       [ ')
                result.append( '"%s", ' % str(team_rank['rank']) )
                result.append( '"%s", ' % str(team_rank['point_total']) )
                result.append( '"%s", ' % get_team_hyperlink( competition, str(team_rank['team_key']).lstrip('frc') ) )
                                                            
                for event in team_rank['event_points']:
                    result.append( '"%s", ' % str(event['total']) )
                    
                if len(team_rank['event_points']) == 1:
                    result.append( '"-", ' )
                elif len(team_rank['event_points']) == 0:
                    result.append( '"-", "-", ' )
                    
                result.append( '"%s" ' % str(team_rank['rookie_bonus']) )
                result.append('],\n')

            if result[-1] == '],\n':
                result = result[:-1]
            result.append(']\n')
            result.append('] }\n')
            rank_data = ''.join(result)
        except:
            rank_data = ''
            pass
        return rank_data
Example #6
0
def getTeamInfo(session, team):
    team_list = session.query(TeamInfo).filter(TeamInfo.team==team)
    
    # should only be one team in the list
    team_info = team_list.first()
    if not team_info:
        url_str = '/api/v2/team/frc%d' % team
        try:
            team_data = TbaIntf.get_from_tba_parsed(url_str)

            team_info = setTeamInfoFromTba(session, team_data)
            
        except:
            team_info = None
            
    return team_info
def get_team_event_list_from_tba(global_config, team, season):
    
    global_config['logger'].debug( 'GET Team Event List TBA' )

    result = []
        
    url_str = '/api/v2/team/frc%s/%s/events' % (team,season)
        
    try:
        event_dict = TbaIntf.get_from_tba_parsed(url_str)
        for event in event_dict:
            comp = WebCommonUtils.map_event_code_to_comp(event['event_code'], season)
            result.append(comp)
    except:
        pass

    return result
def get_event_results_page(global_config, year, event_code):
        
        global_config['logger'].debug( 'GET Event Standings Page' )

        page = ''
            
        url_str = '/api/v2/event/%s%s' % (year,event_code.lower())
        try:
            event_data = TbaIntf.get_from_tba_parsed(url_str)
                        
            page += '<ul>'
            page += '<li>Name: %s</li>' % event_data['name']
            page += '<li>Code: %s</li>' % event_data['event_code'].upper()
            page += '<li>Start Date: %s</li>' % event_data['start_date']
            page += '<li>End Date: %s</li>' % event_data['end_date']
            page += '<li>Location: %s</li>' % event_data['location']
            page += '</ul>'
            
            page += '<br>'
            page += '<a href="/eventstandings/%s%s">Rankings</a>' % (year,event_code)
            page += '<br>'

            try:        
                first_url_str = 'http://www2.usfirst.org/%scomp/events/%s/matchresults.html' % (year,event_code.upper())
                rank_data = urllib2.urlopen(first_url_str).read()
                
                page += '<br>Qualification Round Match Results<br><br>'
                page += insert_results_table(rank_data, event_code, 2)
                page += '<br>'
                page += '<br>'
                page += '<br>Elimination Round Match Results<br><br>'
                page += insert_results_table(rank_data, event_code, 3)
                
            except:
                page += 'No Results At This Time'
        except:
            pass
        
        page += '</body>'
        page += '</html>'
                
        return page
Example #9
0
def get_team_list_json_from_tba(global_config, comp):
    
    global_config['logger'].debug( 'GET Team List For Competition From TBA %s', comp )

    result = []
    result.append('{ "teams" : ')
    
    event_code = WebCommonUtils.map_comp_to_event_code(comp)
    season = WebCommonUtils.map_comp_to_season(comp)
    
    url_str = '/api/v2/event/%s%s/teams' % (season,event_code.lower())
    try:
        # retrieve the string itself as a formatted json string
        event_data = TbaIntf.get_from_tba(url_str)
    except:
        event_data = '[ ]'

    result.append( event_data )
    result.append('  }\n')
    return ''.join(result)
def get_district_events_json(global_config, year, type):
        
        global_config['logger'].debug( 'GET District Event Info Json' )    
        
        url_str = '/api/v3/district/%s%s/events' % (year,type.lower())
        try:
            event_data = TbaIntf.get_from_tba(url_str)
            if type != None:
                event_json = json.loads(event_data)
                result = []
                result.append('[')
                for event in event_json:
                    result.append(json.dumps(event))
                    result.append(',')
                if result[-1] == ',':
                    result = result[:-1]
                result.append(']\n')
                event_data = ''.join(result)
        except:
            event_data = ''
            pass
        return event_data
def get_event_json_from_tba( query_str, api_version='v3' ):
    url_str = '/api/%s/event/%s' % (api_version,query_str)
    event_data = TbaIntf.get_from_tba(url_str)
    return event_data
def get_team_data_from_tba(team_str, query_str):
    
    url_str = '/api/v3/team/frc%s/%s' % (team_str,query_str)
    team_data = TbaIntf.get_from_tba_parsed(url_str)
    return team_data    
Example #13
0
def get_event_json_from_tba( query_str ):
    url_str = '/api/v2/event/%s' % (query_str)
    event_data = TbaIntf.get_from_tba(url_str)
    return event_data