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)