def test_week_activity_distance_end_week():
# has an entry on the exact last day of the week
iso_date = '2020-06-18T21:58:33.302785-07:00'
my_date = datetime.strptime(iso_date, '%Y-%m-%dT%H:%M:%S.%f%z').date()
_, start_week, end_week = charting.get_week_bookends(my_date)
activity = Activity(id=1,
type=1,
title='title',
duration=25,
distance=10.1,
iso_timestamp='2020-06-15T21:58:33.302785-07:00')
activity_1 = Activity(id=2,
type=2,
title='title',
duration=32,
distance=5.25,
iso_timestamp='2020-06-21T05:58:33.302785-07:00')
activities = [activity, activity_1]
week_duration = charting.calc_daily_duration_per_exercise_type(
activities, start_week, end_week, sum_by='distance')
assert len(week_duration) == 6
assert len(week_duration[1]) == 7
assert week_duration[1] == [10.1, 0, 0, 0, 0, 0, 0]
assert week_duration[2] == [0, 0, 0, 0, 0, 0, 5.25]
def test_week_activity_distance_into_next_week():
# has an entry for the day after the end of week, should not be counted
iso_date = '2020-06-18T21:58:33.302785-07:00'
my_date = datetime.strptime(iso_date, '%Y-%m-%dT%H:%M:%S.%f%z').date()
_, start_week, end_week = charting.get_week_bookends(my_date)
activity = Activity(id=1,
type=1,
title='title',
duration=25,
distance=10,
iso_timestamp='2020-06-15T21:58:33.302785-07:00')
activity_1 = Activity(id=2,
type=2,
title='title',
duration=32,
distance=5,
iso_timestamp='2020-06-22T05:58:33.302785-07:00')
activities = [activity, activity_1]
week_duration = charting.calc_daily_duration_per_exercise_type(
activities, start_week, end_week, sum_by='distance')
assert len(week_duration) == 6
assert len(week_duration[1]) == 7
assert week_duration[1] == [10, 0, 0, 0, 0, 0, 0]
assert week_duration[2] == [0, 0, 0, 0, 0, 0, 0]
def test_week_activity_distance_two_activity_diff_types():
iso_date = '2020-06-18T21:58:33.302785-07:00'
my_date = datetime.strptime(iso_date, '%Y-%m-%dT%H:%M:%S.%f%z').date()
start_week = charting.get_start_week_date(my_date)
activity = Activity(id=1,
type=1,
title='title',
duration=25,
distance=10,
iso_timestamp='2020-06-15T21:58:33.302785-07:00')
activity_1 = Activity(id=2,
type=2,
title='title',
duration=32,
distance=5,
iso_timestamp='2020-06-17T05:58:33.302785-07:00')
activities = [activity, activity_1]
week_duration = charting.calc_daily_duration_per_exercise_type(
activities, start_week, sum_by='distance')
assert len(week_duration) == 6
assert len(week_duration[1]) == 7
assert week_duration[1] == [10, 0, 0, 0, 0, 0, 0]
assert week_duration[2] == [0, 0, 5, 0, 0, 0, 0]
def test_return_chart_dataset():
iso_date = '2020-06-18T21:58:33.302785-07:00'
my_date = datetime.strptime(iso_date, '%Y-%m-%dT%H:%M:%S.%f%z').date()
start_week = charting.get_start_week_date(my_date)
activity = Activity(id=1,
type=1,
title='title',
duration=25,
iso_timestamp='2020-06-15T21:58:33.302785-07:00')
activity_1 = Activity(id=2,
type=2,
title='title',
duration=32,
iso_timestamp='2020-06-17T05:58:33.302785-07:00')
activity_2 = Activity(id=3,
type=2,
title='title',
duration=32,
iso_timestamp='2020-06-15T05:58:33.302785-07:00')
activities = [activity, activity_1, activity_2]
chart_dataset = charting.get_chart_dataset(activities, start_week)
assert len(chart_dataset) == 2
def test_calc_weekly_totals():
iso_date = '2020-06-18T21:58:33.302785-07:00'
my_date = datetime.strptime(iso_date, '%Y-%m-%dT%H:%M:%S.%f%z').date()
_, start_week, _ = charting.get_week_bookends(my_date)
activities = [
Activity(id=1,
type=1,
title='title',
duration=20,
iso_timestamp='2020-06-16T04:58:33.302785+05:00'),
Activity(id=2,
type=4,
title='title',
distance=10,
duration=15,
iso_timestamp='2020-06-17T04:58:33.302785+05:00'),
Activity(id=3,
type=1,
title='title',
duration=34,
iso_timestamp='2020-06-18T04:58:33.302785+05:00'),
Activity(id=4,
type=3,
title='title',
duration=25,
iso_timestamp='2020-06-19T04:58:33.302785+05:00')
]
total_count_all_activities, total_count_by_exercise_type, \
total_duration_all_activities, total_duration_by_exercise_type, \
total_distance_all_activities, total_distance_by_exercise_type = \
charting.calc_weekly_totals(activities, start_week)
assert total_count_all_activities == 4
assert total_count_by_exercise_type == {1: 2, 2: 0, 3: 1, 4: 1, 5: 0, 6: 0}
assert total_duration_all_activities == 94
assert total_distance_all_activities == 10
assert total_duration_by_exercise_type == {
1: 54,
2: 0,
3: 25,
4: 15,
5: 0,
6: 0
}
assert total_distance_by_exercise_type == {
1: 0,
2: 0,
3: 0,
4: 10,
5: 0,
6: 0
}
def victory(quiz_id):
user = _get_user()
last_attempt = Answer.query.filter_by(user=user).order_by(
Answer.id.desc()).first().attempt
last_score = Score.query.filter_by(user=user).order_by(
Score.id.desc()).first()
attempt = last_score.attempt if last_score else 0
current_quiz = Quiz.query.filter_by(id=user.quiz_id).first()
current_topic = current_quiz.topic
if user.streak_start_date is None or user.last_score_age > 36:
user.streak_start_date = datetime.datetime.utcnow()
# Make True to allow reloading victory
# if True:
if last_attempt > attempt:
final_score = calculate_score(quiz_id, user)
user.total_score += final_score
Score(score=final_score,
user=user,
quiz_id=quiz_id,
attempt=last_attempt)
# Activity feed
Activity(user=user,
body_html="%s finished %s in the %s skill" %
(user.username, current_quiz.name, current_topic.name),
public=True)
if current_topic.quizzes[-1] == current_quiz:
Activity(user=user,
body_html="%s finished the %s skill" %
(user.username, current_topic.name),
public=True)
# Don't update user.quiz _id if this is a redo
if user.quiz_id <= quiz_id:
user.quiz_id += 1
else:
return redirect(url_for('quiz.ask', id=user.quiz_id))
return render_template(
'quiz/quiz_victory.html',
title="Quiz",
id=user.quiz_id,
score=final_score,
day_names=day_names(),
daily_scores=daily_scores(),
current_topic=current_topic,
)
def importactivity():
form = ImportActivityForm()
if request.method == "POST":
if form.validate_on_submit():
f = request.files['file']
fstring = f.read().decode("utf-8")
csv_dicts = [{k: v
for k, v in row.items()}
for row in csv.DictReader(fstring.splitlines(),
skipinitialspace=True)]
_imported = 0
for r in csv_dicts:
a_t = current_user.activitytypes.filter(
ActivityType.name == r['activity']).first()
if a_t is None:
# TODO: Imports ActivityType as non NSFW make user choose
a_t = ActivityType(name=r['activity'],
user_id=current_user.id)
db.session.add(a_t)
db.session.commit()
a = Activity(activitytype_id=a_t.id,
user_id=current_user.id,
timestamp=datetime.datetime.strptime(
r['date'], "%Y-%m-%d"))
db.session.add(a)
_imported += 1
db.session.commit()
flash('Imported {} activities.'.format(_imported))
else:
flash('Failed to add activity type.')
return render_template('import.html', form=form)
def open_gate(self, gate, user_id, command='open'):
"""Handle gate opening via web interface.
"""
if command == 'open':
requests.get(gate.uri_open, timeout=1)
elif command == 'close':
requests.get(gate.uri_close, timeout=1)
else:
return None
requests.get(gate.uri_nvr, timeout=1)
snapshot = self.save_snapshot(gate.id)
a = Activity()
a.gate = gate.id
a.snapshot = snapshot
a.command = command
a.success = True
a.user = user_id
a.meta = {'tags': ['web'] if command == 'open' else ['close', 'web']}
db.session.add(a)
db.session.commit()
return a.success
def test_save_completed_activity_strava_integration_off(
test_client_csrf, init_database, activate_strava_sync,
add_strava_athlete):
""" mock the strava APA and check it is not called"""
assert flask.current_app.config["CALL_STRAVA_API"] is True
u = User.query.filter_by(username=conftest.TEST_USER_USERNAME).first()
load_activity = Activity.query.filter_by(user_id=u.id).first()
assert load_activity is None
strava_athlete = StravaAthlete.query.filter_by(user_id=u.id).first()
strava_athlete.is_active = 0
db.session.commit()
with patch('flask_login.utils._get_user') as current_user:
current_user.return_value.id = u.id
current_user.return_value.get_id.return_value = u.id
with patch('app.services.strava.create_activity') as mock_strava:
mock_strava.return_value = True
activity_date = datetime.utcnow() - timedelta(days=1, hours=7)
activity_date_str = activity_date.strftime('%d/%m/%Y %H:%M')
activity_utc_time = utils.get_utc_from_local_time(
activity_date, 'UTC')
activity = Activity(type=1,
title='title',
duration=20,
timestamp=activity_utc_time,
user_id=u.id)
routes.save_completed_activity(activity, activity_date, 'UTC')
load_activity = Activity.query.filter_by(user_id=u.id).first()
assert load_activity.user_id == u.id
assert load_activity.type == 1
assert load_activity.title == 'title'
assert load_activity.duration == 20
assert mock_strava.called is False
def activities_insert():
"""Lê form, instancia objeto e persiste no BD com SQLAlchemy"""
message = "Novo cadastro incluído com sucesso"
if request.method == "POST":
id_status = request.form["id_status"]
id_activity_type = request.form["id_activity_type"]
id_customer = request.form["id_customer"]
id_sales_person = request.form["id_sales_person"]
id_product = request.form["id_product"]
planned_date = convert_to_date(request.form["planned_date"])
done_date = convert_to_date(
request.form["done_date"]) if request.form["done_date"] else None
description = request.form["description"]
if int(id_customer) == 0:
message = "É necessário selecionar um cliente."
elif int(id_sales_person) == 0:
message = "É necessário selecionar um vendedor responsável pela atividade."
else:
activity = Activity(id_status, id_activity_type, id_customer, id_sales_person, id_product, \
planned_date, done_date, description)
db.session.add(activity)
db.session.commit()
#Atualiza badge de atividades pendentes no menu principal
update_count_activities()
flash(message)
return redirect(url_for("activities_index"))
def test_get_activity_scores_in_class(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
score = 50
activity_id = 2
activity_result = Activity_Results(activity_id=activity_id,
score=score,
class_id=u.current_class)
db.session.add(activity_result)
db.session.commit()
student_activity = Student_Activity(
activity_instance_id=activity_result.activity_instance_id,
student_id=u.user_id)
db.session.add(student_activity)
db.session.commit()
activities = newClass.get_activity_scores_in_class().all()
students = newClass.get_all_students_in_class().all()
language = newClass.get_language()
games_class = newClass.get_games_played_by_class(students)
self.assertEqual(len(games_class), 2)
self.assertEqual("French", language)
self.assertEqual(len(activities), 1)
self.assertEqual(activities[0], activity_result)
def addactivity(username: str, childname: str):
logger.debug('AddActivity. Request.method %s', request.method)
if not current_user.is_authenticated:
return redirect(url_for('main.login'))
user = User.query.filter_by(username=current_user.username).first_or_404()
child1 = Child.query.filter_by(childname=childname,
parentid=user.id).first_or_404()
form = RegisterationFormActivity()
form.childid = child1.id
if form.validate_on_submit():
logger.debug('Add activity %s', form.activity.data)
logger.debug('childname %s, childid %d', childname, child1.id)
logger.debug(current_user)
activity = Activity(activity=form.activity.data,
points=form.points.data,
childid=child1.id)
db.session.add(activity)
db.session.commit()
return redirect(
url_for('main.child',
childname=childname,
username=current_user.username))
return render_template('addactivity.html', title='AddActivity', form=form)
def test_get_completed_courses_in_class(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
score = 50
activity_id = 2
activity_result = Activity_Results(activity_id=activity_id,
score=score,
class_id=u.current_class)
db.session.add(activity_result)
db.session.commit()
student_activity = Student_Activity(
activity_instance_id=activity_result.activity_instance_id,
student_id=u.user_id)
db.session.add(student_activity)
db.session.commit()
level = Student_Class_Level(user_id=u.user_id,
class_id=u.current_class,
level=1)
db.session.add(level)
db.session.commit()
u.freeze_stats()
completed_course = u.get_completed_courses_in_class(u.current_class) #
self.assertEqual(len(completed_course), 1)
def edit_prepared_activity(activity_day, prepared_activity):
if current_user.id != 1:
return redirect(url_for('not_allowed'))
recent_activities = Activity.query.order_by(desc('id')).limit(10)
day = Day.query.get(activity_day)
prepared_activity = Activity.query.get(prepared_activity)
activities = day.activities
form = ActivityCreationForm(request.form)
if request.method == "POST":
new_activity = Activity(name=form.name.data,
prehours=form.hours.data,
preminutes=form.minutes.data,
completion=0,
planned_progress=form.progress.data,
day_id=day.id,
made_progress="",
hours=0,
minutes=0)
db.session.add(new_activity)
db.session.commit()
return redirect(url_for('edit_activities', activity_day=activity_day))
elif request.method == 'GET':
form.name.data = prepared_activity.name
form.minutes.data = prepared_activity.preminutes
form.hours.data = prepared_activity.prehours
form.progress.data = prepared_activity.made_progress
return render_template('prepared_activity.html',
activities=activities,
day=day,
form=form,
recent_activities=recent_activities,
prepared_activity=prepared_activity)
def login():
form = LoginForm()
if form.validate_on_submit():
user_by_email = User.query.filter_by(email=form.email.data).first()
user_by_username = User.query.filter_by(
username=form.email.data).first()
user = user_by_email or user_by_username
if user is not None and \
user.verify_password(form.password.data):
login_user(user.seen())
# Flask-Principal: Create an Identity object and signal that the identity has changed,
# which triggers on_identify_changed() and on_identify_loaded(). Identity() takes a unique ID.
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
return redirect(
request.args.get('next') or url_for('dashboard.dashboard'))
if datetime.utcnow() - user.last_seen > timedelta(days=7):
Activity(user=user,
body_html="%s logged in." % user.username,
public=True)
return render_template(
'auth/login.html',
title="Please sign in",
form=form,
)
def index():
# get activities from strava
activities_json = get_my_activities_json()
for item in activities_json:
if db.session.query(Activity).filter_by(
id=item["id"]).scalar() is None:
act = Activity(id=item["id"],
distance=item["distance"],
start_date=datetime.strptime(
item["start_date_local"], '%Y-%m-%dT%H:%M:%SZ'),
bike=item["gear"]["name"],
elapsed_time=item["elapsed_time"],
moving_time=item["moving_time"])
db.session.add(act)
db.session.commit()
n_acts = db.session.query(Activity).count()
activities = pd.read_sql(db.session.query(Activity).statement, db.engine)
return render_template('index.html',
title="Justin's Strava Playground",
n_acts=n_acts,
activities=activities)
def test_get_doodles(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
doodle = Doodles(foreign_answer="test",
foreign_guess="test",
location="location")
db.session.add(doodle)
db.session.commit()
student_doodle = Student_Doodles(user_id=u.user_id,
doodle_id=doodle.doodle_id)
class_doodle = Class_Doodles(class_id=u.current_class,
doodle_id=doodle.doodle_id)
db.session.add_all([student_doodle, class_doodle])
db.session.commit()
doodles = u.get_doodles().all()
self.assertTrue(len(doodles) == 1)
def post():
if request.method == 'POST':
a = Activity(request.form['title'], request.form['description'])
db_session.add(a)
db_session.commit()
return redirect(url_for('.detail', id=a.id))
else:
return render_template('activity/post.html')
def delete_post(user, post_id):
post = Post.query.get_or_404(post_id)
db.session.delete(post)
db.session.flush()
activity = Activity(verb='delete', object=post)
db.session.add(activity)
db.session.commit()
return True
def add_post(user, message):
post = Post(user_id=user.id, message=message)
db.session.add(post)
db.session.flush()
activity = Activity(verb='create', object=post)
db.session.add(activity)
db.session.commit()
return post
def create_activity(item, mt, id_string):
act = Activity()
act.name = item['name']
act.polyline = item['map']['summary_polyline']
act.url = f'https://www.strava.com/activities/{item["id"]}'
act.mountains.append(mt)
act.activity_id = id_string
act.date = item['start_date']
return act
def upload_activity():
session = db.session
prj = open('xls/activities.csv', encoding='utf-8-sig')
for line in prj:
row = Activity(activity=line)
row.created_by_fk = '1'
row.changed_by_fk = '1'
session.add(row)
session.commit()
def new_activity() -> str:
activity: str = request.json['activity']
user_id: int = request.json['userId']
new_scrum_activity: Activity = Activity(activity=activity, user_id=user_id)
db.session.add(new_scrum_activity)
db.session.commit()
result = activity_schema.dump(new_scrum_activity)
return jsonify(result.data)
def test_activity_logging(self):
s = Student(first_name='billy')
act1 = Activity(activity_name='nap')
act_entry1 = ActivityLog(student_id=s.student_id, activity_id=act1.activity_id)
s.activity.append(act_entry1)
act1.student.append(act_entry1)
act_entry2 = ActivityLog(student_id=s.student_id, activity_id=act1.activity_id)
s.activity.append(act_entry2)
act1.student.append(act_entry2)
self.assertTrue(len(s.activity) == 2)
def add_activity(itinerary_id):
form = ActivityForm()
if form.validate_on_submit():
activity = Activity(itinerary_id=itinerary_id,
name=form.name.data,
description=form.description.data)
db.session.add(activity)
db.session.commit()
print("dONE")
return redirect(url_for('itinerary', itinerary_id=itinerary_id))
return render_template('add_activity.html', form=form)
def post_activity(user_id):
data = request.json
activity = Activity(user_id=user_id,
title=data['title'],
description=data['description'],
distance=float(data['distance']),
time=float(data['time']),
gpx_file=data['gpx_file'])
db.session.add(activity)
db.session.commit()
return 'Done', 201
def init_activity():
for each_record in activity_init:
print(Activity.find_by_name(each_record['name']))
if Activity.find_by_name(each_record['name']) == None:
category_id_for_new_record = (Category.find_by_category(
each_record['category_name']).id)
new_record = Activity(name=each_record['name'],
category_id=category_id_for_new_record,
username_id=current_user.id)
Activity.save_to_db(new_record)
return render_template('habit.html')
def get_activity(current_user, activity_id):
"""
Return an activity object for the supplied activity id.
:param current_user: User
:param activity_id: Activity Id
:return:
"""
try:
activity = Activity(int(activity_id))
return response_for_activity(activity.json)
except ValueError:
return response('failed', "Activity not found", 404)
def insert_one(self, activity):
new_activity = Activity()
if "activity" in activity:
new_activity.activity = activity["activity"]
if "user_id" in activity:
new_activity.user = User.objects.get(pk=activity["user_id"])
new_activity.save()
return False if new_activity.pk is None else new_activity
def add_activity():
form = AddActivityForm()
templates = os.listdir('app/templates/activity_templates')
form.template.choices = [(n, templates[n]) for n in range(len(templates))]
if form.validate_on_submit():
act = Activity(name=form.name.data,
password=form.password.data,
owner=current_user.id,
template=templates[int(form.template.data)])
db.session.add(act)
db.session.commit()
return redirect(url_for('index'))
return render_template('add_activity.html', form=form)
