Esempio n. 1
0
def test_get_bike_stats_only_end_date(mongodb):
    end_date = datetime.strptime('2017-10-17T00:00:00Z', '%Y-%m-%dT%H:%M:%SZ')
    end_date = end_date.replace(tzinfo=pytz.UTC)
    stra = strava(mongodb=mongodb)
    stats = stra.get_bike_stats(1,'3',end_date=end_date)
    assert stats.meters_distance > 0
    assert stats.records == 9
Esempio n. 2
0
def update_athlete(athlete):
    capture_datetime = timezone.now()
    capture_timestamp = int(capture_datetime.strftime('%s'))

    logger.debug("Starting update for athlete {}. Capture datetime = {} timestamp = {}".format(athlete.id, capture_datetime.strftime('%c'), capture_timestamp))

    mongoh = mongohelper()
    collection = mongoh.get_collection('raw_activities')

    token = athlete.strava_api_token
    stravahelper = strava(token)
    after_timestamp = None
    if athlete.last_strava_sync:
        filters = [
            {'field': 'athlete.id', 'query': athlete.strava_id}
        ]
        max_record = stravahelper.aggregate_activities_mongo(filters, {
            '_id': None,
            'max_start_date': {'$max': '$start_date'},
        })

        record = None
        for agg in max_record:
            if not record:
                record = agg

        if record:
            after_timestamp = int(record['max_start_date'].strftime('%s'))
        else:
            after_timestamp = capture_timestamp - 604800

    logger.debug("After dbstring = {} timestamp = {}".format(athlete.last_strava_sync.strftime('%c'), after_timestamp))

    activities = stravahelper.get_athlete_activities_api(after=after_timestamp)

    for activity in activities:
        activity['_id'] = activity['id']
        activity['capture_timestamp'] = capture_timestamp
        activity['start_date'] = datetime.strptime(activity['start_date'],'%Y-%m-%dT%H:%M:%SZ')
        activity['strava_api_version'] = 3
        collection.replace_one({'_id': activity['id']}, activity, upsert=True)

    athlete.last_strava_sync = capture_datetime

    bikes,shoes = stravahelper.get_athlete_gear_api()

    for api_bike in bikes:
        db_bike = bike()
        db_bike.strava_id = api_bike.id
        db_bike.athlete = athlete
        db_bike.primary = api_bike.primary
        db_bike.name = api_bike.name
        db_bike.description = api_bike.description
        db_bike.resource_state = api_bike.resource_state
        db_bike.brand_name = api_bike.brand_name
        db_bike.model_name = api_bike.model_name
        db_bike.frame_type = api_bike.frame_type
        db_bike.save()

    athlete.save()
Esempio n. 3
0
def index(request):
    primary_bike_id = ''
    bikes = request.user.gear_set.all()
    for bike in bikes:
        if bike.primary:
            primary_bike_id = bike.strava_id

    gear_id = request.POST.get('gear_id', primary_bike_id)
    before = request.POST.get('before')
    after = request.POST.get('after')
    if before and after:
        before = datetime.datetime.strptime(before, '%Y-%m-%d') + timedelta(hours=23, minutes=59, seconds=59)
        after = datetime.datetime.strptime(after, '%Y-%m-%d') + timedelta(hours=23, minutes=59, seconds=59)
    else:
        before = datetime.datetime.today().replace(hour=23, minute=59, second=59, microsecond=0)
        after = before - timedelta(days=7)

    stra = strava()
    filters = [
        {'field': 'athlete.id', 'query': request.user.strava_id},
        {'field': 'start_date', 'query': {'$lt': before, '$gte': after}},
        {'field': 'gear_id', 'query': gear_id},
    ]
    activities = stra.aggregate_activities_mongo(filters, {
        '_id': None,
        'distance': {'$sum': '$distance'},
        'elapsed_time': {'$sum': '$moving_time'},
        'elevation': {'$sum': '$total_elevation_gain'},
        'average_speed': {'$avg': '$average_speed'},
        'kilojoules': {'$sum': '$kilojoules'},
    })

    template_fields = {
        'bikes': bikes,
        'gear_id':gear_id,
        'before':before.strftime('%Y-%m-%d'),
        'after':after.strftime('%Y-%m-%d'),
        'distance': unithelper.miles(unit('m')(0)),
        'time': unithelper.hours(unit('s')(0)),
        'elevation': unithelper.meters(unit('m')(0)),
        'avg_speed': unithelper.mph(unit('m')(0)/unit('s')(1)),
        'kjs': 0,
    }
    activity = None
    for agg in activities:
        if not activity:
            activity = agg

    if activity:
        merge_dict = template_fields.copy()
        merge_dict.update({
            'distance': unithelper.miles(unit('m')(activity['distance'])),
            'time': unithelper.hours(unit('s')(activity['elapsed_time'])),
            'elevation': unithelper.meters(unit('m')(activity['elevation'])),
            'avg_speed': unithelper.mph(unit('m')(activity['average_speed'])/unit('s')(1)),
            'kjs': activity['kilojoules'],
        })
        template_fields = merge_dict

    return render_to_response('strava/templates/strava_index.html', template_fields, context_instance=RequestContext(request))
def test_aggregate_on_bike(db, django_db_setup, mongodb):
    bike = Component.objects.get(pk=3)
    stra = strava(mongodb=mongodb)
    aggregates = bike.get_aggregates(strava=stra)
    assert aggregates.records == 10
    assert aggregates.meters_distance == 160934.4
    assert aggregates.time == 18000
    assert aggregates.meters_elevation == 5000
    assert aggregates.kjs == 10000
    assert aggregates.meters_per_second_avg_speed > 8.0
Esempio n. 5
0
 def list(self, request):
     stra = strava()
     filters = [
         {'field': 'athlete.id', 'query': int(request.user.strava_id)}
     ]
     activity_cursor = stra.get_activities_mongo(filters)
     activities = []
     for activity in activity_cursor:
         activities.append(activity)
     return Response(activities, status=status.HTTP_200_OK)
def test_aggregate_on_wheelset1(db, django_db_setup, mongodb):
    bike = Component.objects.get(pk=1)
    assert bike.parent_component_set.all().count() > 0
    stra = strava(mongodb=mongodb)
    aggregates = bike.get_aggregates(strava=stra)
    assert aggregates.records == 10
    assert aggregates.meters_distance == 160934.4
    assert aggregates.time == 18000
    assert aggregates.meters_elevation == 5000
    assert aggregates.kjs == 10000
    assert aggregates.meters_per_second_avg_speed > 8.0
def test_aggregate_on_wheelset1_start_date(db, django_db_setup, mongodb):
    start_date = datetime.strptime('2017-10-09T00:00:00Z', '%Y-%m-%dT%H:%M:%SZ')
    start_date = start_date.replace(tzinfo=pytz.UTC)
    bike = Component.objects.get(pk=1)
    stra = strava(mongodb=mongodb)
    aggregates = bike.get_aggregates(strava=stra,start_date=start_date)
    assert aggregates.records == 9
    assert aggregates.meters_distance == 16093.44 * 9
    assert aggregates.time == 1800 * 9
    assert aggregates.meters_elevation == 500 * 9
    assert aggregates.kjs == 1000 * 9
    assert aggregates.meters_per_second_avg_speed > 8.0
def test_aggregate_on_wheelset2(db, django_db_setup, mongodb):
    bike = Component.objects.get(pk=2)
    assert bike.parent_component_set.all().count() == 0
    stra = strava(mongodb=mongodb)
    aggregates = bike.get_aggregates(strava=stra)
    assert aggregates.records == 0
Esempio n. 9
0
def test_get_bike_stats_no_date_limits(mongodb):
    stra = strava(mongodb=mongodb)
    stats = stra.get_bike_stats(1,'3')
    assert stats.meters_distance > 0.0
    assert stats.records == 10
Esempio n. 10
0
def test_get_bike_stats_bike_filter(mongodb):
    stra = strava(mongodb=mongodb)
    stats = stra.get_bike_stats(1,'3')
    assert stats.records == 10
    stats = stra.get_bike_stats(1,'4')
    assert stats.records == 10