def test_last_weight_entry(self):
'''
Tests that the last weight entry is correctly returned
'''
self.user_login('test')
user = User.objects.get(pk=2)
entry = WeightEntry()
entry.creation_date = datetime.datetime.today()
entry.user = user
entry.weight = 100
entry.save()
self.assertEqual(user.userprofile.weight, 100)
entry.weight = 150
entry.save()
self.assertEqual(user.userprofile.weight, 150)
def parse_weight_csv(request, cleaned_data):
try:
dialect = csv.Sniffer().sniff(cleaned_data['csv_input'])
except csv.Error:
dialect = 'excel'
# csv.reader expects a file-like object, so use StringIO
parsed_csv = csv.reader(six.StringIO(cleaned_data['csv_input']), dialect)
weight_list = []
error_list = []
for row in parsed_csv:
try:
parsed_date = datetime.datetime.strptime(
row[0], cleaned_data['date_format'])
parsed_weight = decimal.Decimal(row[1].replace(',', '.'))
weight_list.append(
WeightEntry(creation_date=parsed_date,
weight=parsed_weight,
user=request.user))
except (ValueError, IndexError, decimal.InvalidOperation):
error_list.append(row)
return (weight_list, error_list)
def fitbitComplete(request):
code = request.GET.get('code')
# print(code)
fitConnect = Fitbit()
token = fitConnect.GetAccessToken(code)
headers = {
'Authorization': 'Bearer %s' % token['access_token']
}
final_url = 'https://' + fitConnect.API_SERVER + '/1/user/-/body/weight/date/today/30d.json'
try:
resp = requests.get(final_url, headers=headers)
data = resp.json()
print(data)
for content_data in data['body-weight']:
weight = WeightEntry()
weight.user = request.user
weight.weight=content_data['value']
weight.date = dateutil.parser.parse(content_data['dateTime'])
try:
weight.save()
except Exception as e:
pass
except Exception as e:
pass
return HttpResponseRedirect(reverse('core:dashboard'))
def add_excersise(request, response_activity, weight):
entry = WeightEntry()
entry.weight = weight
entry.user = request.user
entry.date = datetime.date.today()
entry.save()
messages.success(
request, _('Successfully synced weight data.'))
if not ExerciseCategory.objects.filter(name='Fitbit'):
fitbit_category = ExerciseCategory()
fitbit_category.name = 'Fitbit'
fitbit_category.save()
for detail in response_activity.json()['activities']:
name = detail['name']
description = detail['description']
exercise = Exercise()
exercise.name_original = name
exercise.name = name
exercise.category = ExerciseCategory.objects.get(
name='Fitbit')
exercise.description = description
exercise.language = Language.objects.get(
short_name='en')
exercise.save()
def test_last_weight_entry(self):
'''
Tests that the last weight entry is correctly returned
'''
self.user_login('test')
user = User.objects.get(pk=2)
entry = WeightEntry()
entry.date = datetime.datetime.today()
entry.user = user
entry.weight = 100
entry.save()
self.assertEqual(user.userprofile.weight, 100)
entry.weight = 150
entry.save()
self.assertEqual(user.userprofile.weight, 150)
def user_bodyweight(self, weight):
'''
Create a new weight entry as needed
'''
if (not WeightEntry.objects.filter(user=self.user).exists() or
(datetime.date.today() -
WeightEntry.objects.filter(user=self.user).latest().creation_date
> datetime.timedelta(days=3))):
entry = WeightEntry()
entry.weight = weight
entry.user = self.user
entry.creation_date = datetime.date.today()
entry.save()
# Update the last entry
else:
entry = WeightEntry.objects.filter(user=self.user).latest()
entry.weight = weight
entry.save()
return entry
def user_bodyweight(self, weight):
'''
Create a new weight entry as needed
'''
if (not WeightEntry.objects.filter(user=self.user).exists()
or (datetime.date.today()
- WeightEntry.objects.filter(user=self.user).latest().date
> datetime.timedelta(days=3))):
entry = WeightEntry()
entry.weight = weight
entry.user = self.user
entry.date = datetime.date.today()
entry.save()
# Update the last entry
else:
entry = WeightEntry.objects.filter(user=self.user).latest()
entry.weight = weight
entry.save()
return entry
def parse_weight_csv(request, cleaned_data):
try:
dialect = csv.Sniffer().sniff(cleaned_data['csv_input'])
except csv.Error:
dialect = 'excel'
# csv.reader expects a file-like object, so use StringIO
parsed_csv = csv.reader(io.StringIO(cleaned_data['csv_input']),
dialect)
distinct_weight_entries = []
entry_dates = set()
weight_list = []
error_list = []
MAX_ROW_COUNT = 1000
row_count = 0
# Process the CSV items first
for row in parsed_csv:
try:
parsed_date = datetime.datetime.strptime(row[0], cleaned_data['date_format'])
parsed_weight = decimal.Decimal(row[1].replace(',', '.'))
duplicate_date_in_db = WeightEntry.objects.filter(date=parsed_date,
user=request.user).exists()
# within the list there are no duplicate dates
unique_among_csv = parsed_date not in entry_dates
# there is no existing weight entry in the database for that date
unique_in_db = not duplicate_date_in_db
if unique_among_csv and unique_in_db and parsed_weight:
distinct_weight_entries.append((parsed_date, parsed_weight))
entry_dates.add(parsed_date)
else:
error_list.append(row)
except (ValueError, IndexError, decimal.InvalidOperation):
error_list.append(row)
row_count += 1
if row_count > MAX_ROW_COUNT:
break
# Create the valid weight entries
for date, weight in distinct_weight_entries:
weight_list.append(WeightEntry(date=date,
weight=weight,
user=request.user))
return (weight_list, error_list)
def calculate(request):
'''
Calculates the BMI
'''
data = []
form = BmiForm(request.POST, instance=request.user.userprofile)
if form.is_valid():
form.save()
# Create a new weight entry as needed
if (not WeightEntry.objects.filter(user=request.user).exists()
or (datetime.date.today()
- WeightEntry.objects.filter(user=request.user).latest().creation_date
> datetime.timedelta(1))):
entry = WeightEntry()
entry.weight = form.cleaned_data['weight']
entry.user = request.user
entry.creation_date = datetime.date.today()
entry.save()
# Update the last entry
else:
entry = WeightEntry.objects.filter(user=request.user).latest()
entry.weight = form.cleaned_data['weight']
entry.save()
bmi = request.user.userprofile.calculate_bmi()
result = {'bmi': '{0:.2f}'.format(bmi),
'weight': form.cleaned_data['weight'],
'height': request.user.userprofile.height}
data = json.dumps(result, cls=helpers.DecimalJsonEncoder)
# Return the results to the client
return HttpResponse(data, 'application/json')
def test_demo_data_body_weight(self):
"""
Tests that the helper function that creates demo data filters out
existing dates for the weight entries
"""
self.client.get(reverse('core:dashboard'))
self.assertEqual(self.count_temp_users(), 2)
user = User.objects.get(pk=4)
temp = []
for i in range(1, 5):
creation_date = datetime.date.today() - datetime.timedelta(days=i)
entry = WeightEntry(user=user,
weight=80 + 0.5 * i + random.randint(1, 3),
date=creation_date)
temp.append(entry)
WeightEntry.objects.bulk_create(temp)
create_demo_entries(user)
# Body weight
self.assertEqual(WeightEntry.objects.filter(user=user).count(), 19)
for user in userlist:
new_entries = []
print(' - generating for {0}'.format(user.username))
existing_entries = [
i.date for i in WeightEntry.objects.filter(user=user)
]
# Weight entries
for i in range(1, args.number_weight):
creation_date = datetime.date.today() - datetime.timedelta(days=i)
if creation_date not in existing_entries:
entry = WeightEntry(user=user,
weight=args.base_weight + 0.5 * i +
random.randint(1, 3),
date=creation_date)
new_entries.append(entry)
# Bulk-create the weight entries
WeightEntry.objects.bulk_create(new_entries)
# Nutrition Generator
if hasattr(args, 'number_nutrition_plans'):
print("** Generating {0} nutrition plan(s) per user".format(
args.number_nutrition_plans))
if args.add_to_user:
userlist = [User.objects.get(pk=args.add_to_user)]
else:
userlist = [i for i in User.objects.all()]
def create_demo_entries(user):
"""
Creates some demo data for temporary users
"""
# (this is a bit ugly and long...)
language = load_language()
#
# Workout and exercises
#
setting_list = []
weight_log = []
workout = Workout(user=user, name=_('Sample workout'))
workout.save()
monday = DaysOfWeek.objects.get(pk=1)
wednesday = DaysOfWeek.objects.get(pk=3)
day = Day(training=workout, description=_('Sample day'))
day.save()
day.day.add(monday)
day2 = Day(training=workout, description=_('Another sample day'))
day2.save()
day2.day.add(wednesday)
# Biceps curls with dumbbell
if language.short_name == 'de':
exercise = Exercise.objects.get(pk=26)
else:
exercise = Exercise.objects.get(pk=81)
day_set = Set(exerciseday=day, sets=4, order=2)
day_set.save()
setting = Setting(set=day_set, exercise=exercise, reps=8, order=1)
setting.save()
# Weight log entries
for reps in (8, 10, 12):
for i in range(1, 8):
log = WorkoutLog(user=user,
exercise=exercise,
workout=workout,
reps=reps,
weight=18 - reps + random.randint(1, 4),
date=datetime.date.today() -
datetime.timedelta(weeks=i))
weight_log.append(log)
# French press
if language.short_name == 'de':
exercise = Exercise.objects.get(pk=25)
else:
exercise = Exercise.objects.get(pk=84)
day_set = Set(exerciseday=day, sets=4, order=2)
day_set.save()
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=8, order=1))
# Weight log entries
for reps in (7, 10):
for i in range(1, 8):
log = WorkoutLog(user=user,
exercise=exercise,
workout=workout,
reps=reps,
weight=30 - reps + random.randint(1, 4),
date=datetime.date.today() -
datetime.timedelta(weeks=i))
weight_log.append(log)
# Squats
if language.short_name == 'de':
exercise = Exercise.objects.get(pk=6)
else:
exercise = Exercise.objects.get(pk=111)
day_set = Set(exerciseday=day, sets=4, order=3)
day_set.save()
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=10, order=1))
# Weight log entries
for reps in (5, 10, 12):
for i in range(1, 8):
log = WorkoutLog(user=user,
exercise=exercise,
workout=workout,
reps=reps,
weight=110 - reps + random.randint(1, 10),
date=datetime.date.today() -
datetime.timedelta(weeks=i))
weight_log.append(log)
# Crunches
if language.short_name == 'de':
exercise = Exercise.objects.get(pk=4)
else:
exercise = Exercise.objects.get(pk=91)
day_set = Set(exerciseday=day, sets=4, order=4)
day_set.save()
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=30, order=1))
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=99, order=2))
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=35, order=3))
# Leg raises, supersets with crunches
if language.short_name == 'de':
exercise = Exercise.objects.get(pk=35)
else:
exercise = Exercise.objects.get(pk=126)
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=30, order=1))
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=40, order=2))
setting_list.append(
Setting(set=day_set, exercise=exercise, reps=99, order=3))
Setting.objects.bulk_create(setting_list)
# Save all the log entries
WorkoutLog.objects.bulk_create(weight_log)
#
# (Body) weight entries
#
temp = []
existing_entries = [i.date for i in WeightEntry.objects.filter(user=user)]
for i in range(1, 20):
creation_date = datetime.date.today() - datetime.timedelta(days=i)
if creation_date not in existing_entries:
entry = WeightEntry(user=user,
weight=80 + 0.5 * i + random.randint(1, 3),
date=creation_date)
temp.append(entry)
WeightEntry.objects.bulk_create(temp)
#
# Nutritional plan
#
plan = NutritionPlan()
plan.user = user
plan.language = language
plan.description = _('Sample nutrional plan')
plan.save()
# Breakfast
meal = Meal()
meal.plan = plan
meal.order = 1
meal.time = datetime.time(7, 30)
meal.save()
# Oatmeal
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8197)
else:
ingredient = Ingredient.objects.get(pk=2126)
mealitem = MealItem()
mealitem.meal = meal
mealitem.ingredient = ingredient
mealitem.order = 1
mealitem.amount = 100
mealitem.save()
# Milk
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8198)
else:
ingredient = Ingredient.objects.get(pk=154)
mealitem = MealItem()
mealitem.meal = meal
mealitem.ingredient = ingredient
mealitem.order = 2
mealitem.amount = 100
mealitem.save()
# Protein powder
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8244)
else:
ingredient = Ingredient.objects.get(pk=196)
mealitem = MealItem()
mealitem.meal = meal
mealitem.ingredient = ingredient
mealitem.order = 3
mealitem.amount = 30
mealitem.save()
#
# 11 o'clock meal
meal = Meal()
meal.plan = plan
meal.order = 2
meal.time = datetime.time(11, 0)
meal.save()
# Bread, in slices
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8225)
unit = None
amount = 80
else:
ingredient = Ingredient.objects.get(pk=5370)
unit = IngredientWeightUnit.objects.get(pk=9874)
amount = 2
mealitem = MealItem()
mealitem.meal = meal
mealitem.ingredient = ingredient
mealitem.weight_unit = unit
mealitem.order = 1
mealitem.amount = amount
mealitem.save()
# Turkey
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8201)
else:
ingredient = Ingredient.objects.get(pk=1643)
mealitem = MealItem()
mealitem.meal = meal
mealitem.order = 2
mealitem.ingredient = ingredient
mealitem.amount = 100
mealitem.save()
# Cottage cheese
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8222) # TODO: check this!
else:
ingredient = Ingredient.objects.get(pk=17)
mealitem = MealItem()
mealitem.meal = meal
mealitem.ingredient = ingredient
mealitem.order = 3
mealitem.amount = 50
mealitem.save()
# Tomato, one
if language.short_name == 'de':
ingredient = Ingredient.objects.get(pk=8217)
unit = None
amount = 120
else:
ingredient = Ingredient.objects.get(pk=3208)
unit = IngredientWeightUnit.objects.get(pk=5950)
amount = 1
mealitem = MealItem()
mealitem.meal = meal
mealitem.weight_unit = unit
mealitem.ingredient = ingredient
mealitem.order = 4
mealitem.amount = amount
mealitem.save()
#
# Lunch (leave empty so users can add their own ingredients)
meal = Meal()
meal.plan = plan
meal.order = 3
meal.time = datetime.time(13, 0)
meal.save()
#
# Workout schedules
#
# create some empty workouts to fill the list
workout2 = Workout(
user=user, name=_('Placeholder workout nr {0} for schedule').format(1))
workout2.save()
workout3 = Workout(
user=user, name=_('Placeholder workout nr {0} for schedule').format(2))
workout3.save()
workout4 = Workout(
user=user, name=_('Placeholder workout nr {0} for schedule').format(3))
workout4.save()
schedule = Schedule()
schedule.user = user
schedule.name = _('My cool workout schedule')
schedule.start_date = datetime.date.today() - datetime.timedelta(weeks=4)
schedule.is_active = True
schedule.is_loop = True
schedule.save()
# Add the workouts
step = ScheduleStep()
step.schedule = schedule
step.workout = workout2
step.duration = 2
step.order = 1
step.save()
step = ScheduleStep()
step.schedule = schedule
step.workout = workout
step.duration = 4
step.order = 2
step.save()
step = ScheduleStep()
step.schedule = schedule
step.workout = workout3
step.duration = 1
step.order = 3
step.save()
step = ScheduleStep()
step.schedule = schedule
step.workout = workout4
step.duration = 6
step.order = 4
step.save()
#
# Add two more schedules, to make the overview more interesting
schedule = Schedule()
schedule.user = user
schedule.name = _('Empty placeholder schedule')
schedule.start_date = datetime.date.today() - datetime.timedelta(weeks=15)
schedule.is_active = False
schedule.is_loop = False
schedule.save()
step = ScheduleStep()
step.schedule = schedule
step.workout = workout2
step.duration = 2
step.order = 1
step.save()
schedule = Schedule()
schedule.user = user
schedule.name = _('Empty placeholder schedule')
schedule.start_date = datetime.date.today() - datetime.timedelta(weeks=30)
schedule.is_active = False
schedule.is_loop = False
schedule.save()
step = ScheduleStep()
step.schedule = schedule
step.workout = workout4
step.duration = 2
step.order = 1
step.save()
def fitbit(request):
'''
method driving fitbit integration
'''
template_data = {}
fitbit_id = os.getenv('CLIENT_ID')
fitbit_secret_key = os.getenv('SECRET_KEY')
callback_url = os.getenv('CALLBACK_URL')
fitbit_scope = 'weight'
url_params = '&response_type=code&scope={}&redirect_uri={}'.format(
fitbit_scope, callback_url)
fitbit_url = 'https://www.fitbit.com/oauth2/authorize?client_id={}'.format(
fitbit_id)
get_fitbit = fitbit_url + url_params
if 'code' in request.GET:
# get the code returned from the
code = request.GET.get('code', '')
client_secret = '{}:{}'.format(fitbit_id, fitbit_secret_key)
# Convert client secret key to bytes then to base64 for fitbit token
client_secret = client_secret.encode('utf-8')
b64_code = base64.b64encode(client_secret).decode('utf-8')
# custom headers for fitbit
headers = {
'Authorization': 'Basic {}'.format(b64_code),
'Content-Type': 'application/x-www-form-urlencoded'
}
# parameters for fitbit api request
params = {
'client_id': fitbit_id,
'client_secret': fitbit_secret_key,
'code': code,
'grant_type': 'authorization_code',
'redirect_uri': callback_url
}
# retrieve fitbit access_token
post_fitbit = requests.post('https://api.fitbit.com/oauth2/token',
params,
headers=headers).json()
if 'access_token' in post_fitbit:
headers['Authorization'] = 'Bearer {}'.format(
post_fitbit["access_token"])
user_id = post_fitbit['user_id']
period = '1w'
base_date = datetime.datetime.today().strftime('%Y-%m-%d')
# get request to retrieve weight data for the user
get_weight_params = '/body/log/weight/date/{}/{}.json'.format(
base_date, period)
get_weight_url = 'https://api.fitbit.com/1/user/{}'.format(user_id)
get_weight = get_weight_url + get_weight_params
get_weight_data = requests.get(get_weight, headers=headers).json()
print('-----wqertyuioertyu', get_weight_data)
# save fitbit data into the database
if 'weight' in get_weight_data:
try:
for weight in get_weight_data['weight']:
weight_entry = WeightEntry()
weight_entry.user = request.user
weight_entry.weight = weight['weight']
weight_entry.date = weight['date']
weight_entry.save()
messages.success(request,
_('Successfully added weight data.'))
except IntegrityError as e:
messages.success(request, _('Weight data already added.'))
template_data.update({'fit_link': get_fitbit})
return render(request, 'user/fitbit.html', template_data)
