Example #1
0
def stream(request, game_id, round_id, thread_id, message_id):
    thread = Thread.get_by_uid(thread_id)
    since = Activity.get_by_uid(message_id)

    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method != 'GET':
        return HttpResponse('Method Not Allowed', status=405)

    activities = Activity.get_activities(request.user,
                                         thread,
                                         since=since)
    return json(list(activities.run()))
Example #2
0
 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)
Example #3
0
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)
Example #4
0
def iap_activation():
    """In-app purchase activation."""
    data = request.get_json()

    user_id = data.get('user', {}).get('id')
    user = User.get(user_id) if user_id is not None else None
    if user is not None:
        user.iap_receipt = data.get('receipt', None)
        user.active = True
        user.promo_id = None
        user.promo_timestamp = None
        user.stripe_customer = None
        if user.stripe_subscription:
            try:
                stripe.Subscription.delete(user.stripe_subscription)
            except:
                pass
        Activity.activate(user.id, 399, True)
    return jsonify({"done": True})
Example #5
0
 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
Example #6
0
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
Example #7
0
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)
Example #8
0
 def test_get_misspelled_words(self):
     u = User(username='******',
              email='*****@*****.**',
              role="Student",
              current_class="test")
     newClass = Class("test", "test", 2019, "French", "Class")
     a = Activity()
     a.populate_table()
     db.session.add_all([u, newClass])
     db.session.commit()
     misspelled_word = Misspelled_Word(class_id=u.current_class,
                                       user_id=u.user_id,
                                       word="Hello",
                                       translated_word="Bonjour")
     db.session.add(misspelled_word)
     db.session.commit()
     user_mispelled = u.get_misspelled_words(u.current_class).all()
     class_mispelled = newClass.get_misspelled_words().all()
     self.assertEqual(len(user_mispelled), 1)
     self.assertEqual(len(class_mispelled), 1)
Example #9
0
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)
Example #10
0
 def test_get_students_new_vocab(self):
     u = User(username='******',
              email='*****@*****.**',
              role="Student",
              current_class="test")
     newClass = Class("test", "test", 2019, "French", "Class")
     a = Activity()
     a.populate_table()
     db.session.add_all([u, newClass])
     db.session.commit()
     newVocab = Student_Vocab(english="hello",
                              translation="bonjour",
                              user_id=u.user_id,
                              class_id=u.current_class,
                              activity_id=14)
     db.session.add(newVocab)
     db.session.commit()
     vocab = u.get_students_new_vocab(u.current_class).all()
     class_vocab = newClass.get_class_new_vocab()
     self.assertEqual(len(vocab), 1)
     self.assertEqual(len(class_vocab), 1)
Example #11
0
 def test_class_stats(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()
     studentsInClass = newClass.get_all_students_in_class().all()
     students_with_averages, class_average = newClass.get_students_with_average(
         studentsInClass)
     activities = newClass.get_activity_scores_in_class().all()
     highest_activity, lowest_activity, barData = newClass.get_activity_averages_in_class(
         activities)
     filename, averages = newClass.get_class_distribution_chart(
         students_with_averages)
     self.assertEqual(class_average, 50)
     self.assertEqual(highest_activity[0], "Numbers")
     self.assertEqual(lowest_activity[0], "Numbers")
     self.assertEqual(highest_activity[1], 50)
     self.assertEqual(lowest_activity[1], 50)
     self.assertEqual(len(averages), 1)
     self.assertEqual(averages[0], 50)
Example #12
0
def activities(request, game_id, round_id, thread_id):
    thread = Thread.get_by_uid(thread_id)
    if thread is None:
        raise Http404

    if not thread.profile_can_view(request.profile):
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        return json(list(Activity.get_activities(request.user, thread)))

    # no POSTs here, return 404
    raise Http404
Example #13
0
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)
Example #14
0
 def test_get_incorrect_letters(self):
     u = User(username='******',
              email='*****@*****.**',
              role="Student",
              current_class="test")
     newClass = Class("test", "test", 2019, "French", "Class")
     a = Activity()
     a.populate_table()
     db.session.add_all([u, newClass])
     db.session.commit()
     for guessChar, wordChar in zip("hillo", "hello"):
         if guessChar != wordChar:
             incorrect_character = Incorrect_Character(
                 class_id=u.current_class,
                 user_id=u.user_id,
                 incorrect_letter=guessChar,
                 correct_letter=wordChar)
             db.session.add(incorrect_character)
             db.session.commit()
     incorrect = u.get_incorrect_letters(u.current_class).all()
     self.assertEqual(len(incorrect), 1)
     self.assertEqual(
         len(newClass.get_incorrect_letters_by_students().all()), 1)
Example #15
0
    def load_activity(self):
        self.activity = Activity(
            start_time=pytz.utc.localize(
                self.activity_data.get_value('start_time') + self.tz_offset),
            elapsed_time=self.activity_data.get_value('total_elapsed_time'),
            start_position_lat=self.activity_data.get_value(
                'start_position_lat'),
            start_position_long=self.activity_data.get_value(
                'start_position_long'),
            timer_time=self.activity_data.get_value('total_timer_time'),
            distance=self.activity_data.get_value('total_distance'),
            strides=self.activity_data.get_value('total_strides'),
            speed=self.activity_data.get_value('enhanced_avg_speed'),
            max_speed=self.activity_data.get_value('enhanced_max_speed'),
            calories=self.activity_data.get_value('total_calories'),
            ascent=self.activity_data.get_value('total_ascent'),
            descent=self.activity_data.get_value('total_descent'),
            lap_count=self.activity_data.get_value('num_laps'),
            heart_rate=self.activity_data.get_value('avg_heart_rate'),
            max_heart_rate=self.activity_data.get_value('max_heart_rate'),
            cadence=self.activity_data.get_value('avg_running_cadence'),
            max_cadence=self.activity_data.get_value('max_running_cadence'),
            aerobic_training_effect=self.activity_data.get_value(
                'total_training_effect'),
            anaerobic_training_effect=self.activity_data.get_value(
                'total_anaerobic_training_effect'),
            max_power=0,
            power=0)

        for r in self.records:
            if r.power > self.activity.max_power:
                self.activity.max_power = r.power
            self.activity.power += r.power

        self.activity.power /= len(self.records)

        self.activity.save()
Example #16
0
def test_week_activity_duration_two_activity_same_day():
    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=1,
                          title='title',
                          duration=32,
                          iso_timestamp='2020-06-15T05:58:33.302785-07:00')

    activities = [activity, activity_1]

    week_duration = charting.calc_daily_duration_per_exercise_type(
        activities, start_week)
    assert len(week_duration) == 6
    assert len(week_duration[1]) == 7
    assert week_duration[1] == [57, 0, 0, 0, 0, 0, 0]
Example #17
0
def add():
    form_category = AddCategory()
    form_activity = AddActivity()
    all_cat = Category.json_all()

    if form_category.validate_on_submit(
    ) and form_category.submit_new_category.data:
        a_category = Category(category=form_category.category_name.data,
                              username_id=current_user.id)
        Category.save_to_db(a_category)
        # print(f'well done, we changed {form_category.name} into {form_category.category_name.data}')
        return render_template('add.html',
                               form_activity=form_activity,
                               form_category=form_category)
    if form_activity.validate_on_submit(
    ) and form_activity.submit_new_activity.data:
        try:
            a_activity = Activity(name=form_activity.activity_name.data,
                                  category_id=form_activity.category_id.data,
                                  username_id=current_user.id)
            # if form_activity.box.data:
            #     a_activity.category_id = form_activity.activity_category_id.data
            Activity.save_to_db(a_activity)
            flash(f'well done, we added {form_activity.activity_name.data}')
            return render_template('add.html',
                                   form_activity=form_activity,
                                   form_category=form_category,
                                   added_activity=True)
        except:
            return render_template('add.html',
                                   form_activity=form_activity,
                                   form_category=form_category,
                                   added_activity=True)
    return render_template('add.html',
                           form_activity=form_activity,
                           form_category=form_category)
Example #18
0
def create_activity():
    # res = json.loads(request.data)
    res = request.get_json()
    # activity = reqparse.RequestParser()
    # activity.add_argument('title',type=str,required=True,help='title must be provide')
    # activity.add_argument('status',type=int,required=True,help='status must be provide')
    # activity.add_argument('link',type=str,required=True,help='link must be provide')
    # activity.add_argument('main_img',type=str,required=True,help='main_img must be provide')
    # activity.add_argument('sort',type=int,required=True,help='sort must be provide')
    # try:
    #     args = activity.parse_args()
    # except Exception as e:
    #     print(e)
    # print(args['title'])
    # print(res['title'],res['status'],res['link'],res['main_img'],res['sort'])
    try:
        if not all([res['title'], str(res['status']), res['link'], res['main_img'], res['sort']]):
            print((111))
            return jsonify(status=-2, errmsg='参数错误')
    except Exception as e:
        print((222))
        return jsonify(status=-2, errmsg='参数错误')
    newid = 'HD' + str(Activity.query.count() + 1).zfill(6)
    data = Activity(
        activityid=newid,
        title=res['title'],
        tag=res.get('tag', ''),
        link=res['link'],
        main_img=res['main_img'],
        sort=res['sort'],
        status=res['status']
    )
    try:
        db.session.add(data)
        db.session.commit()

        data = {
            'status': '0',
            'msg': 'success'
        }
    except Exception as e:
        db.session.rollback()
        print(e)
        data = {
            'status': '-2',
            'msg': 'Fail'
        }
    return jsonify(data)
Example #19
0
    def handle_open(self, endpoint, content):
        """Handle the opening of a gate by an endpoint.
        """
        if endpoint[0].type == 'openalpr':
            code, success, meta = self.read_openalpr(endpoint, content)

        else:
            code, success, meta = self.read_generic(endpoint, content)

        if code == '':
            return False

        access = Access.query.filter(
            Access.code == code, Access.endpoint == endpoint[0].id).first()
        snapshot = self.save_snapshot(endpoint[4])

        a = Activity()
        a.endpoint = endpoint[0].id
        a.code = code
        a.meta = meta
        a.snapshot = snapshot

        if 'tags' not in a.meta:
            a.meta['tags'] = []

        # TODO: handle valid from/to timestamps
        if access and success:
            # Send gate open command
            requests.get(endpoint[1], timeout=1)

            a.success = True
            a.access = access.id

        # Send NVR trigger
        requests.get(endpoint[2], timeout=1)

        db.session.add(a)
        db.session.commit()

        return a.success
Example #20
0
def addactivity():
    form = AddActivityForm()
    form.activitytype.choices = [(type.id, type.name)
                                 for type in current_user.activitytypes]
    if request.method == "POST":
        if form.validate_on_submit():
            a = Activity(activitytype_id=form.activitytype.data,
                         user_id=current_user.id,
                         timestamp=form.date.data)
            db.session.add(a)
            db.session.commit()
            flash('Activity added!')
            return redirect(url_for('index'))
        else:
            flash('Failed to add activity.')
    return render_template('add.html', form=form, what="Activity")
Example #21
0
    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
Example #22
0
def activities():
    if request.method == 'GET':
        activity = db.session.query(Activity).all()
        if activity is None:
            return jsonify(status='empty')
        a_list = [i.return_dict() for i in activity]
        return jsonify(status='ok', result=a_list)
    elif request.method == 'POST':
        data = request.values
        if data:
            if data.get('acid'):
                acid = data.get('acid')
                activity = Activity.query.filter_by(acid=acid).first()
                activity.actype = data.get('actype')
                activity.vol_time = data.get('vol_time')
                activity.ac_place = data.get('ac_place')
                activity.subject = data.get('title')
                finish_time = data.get('finish_time').encode('utf8')
                start_time = data.get('start_time').encode('utf8')
                activity.introduce = data.get('introduce')
                activity.required_stus = data.get('required_stus')
                activity.finish_time = ' '.join(finish_time.split('T')) + ':00'
                activity.start_time = ' '.join(start_time.split('T')) + ':00'

            else:
                acid = int(time.time())
                actype = data.get('actype')
                vol_time = data.get('vol_time')
                ac_place = data.get('ac_place')
                subject = data.get('title')
                finish_time = data.get('finish_time').encode('utf8')
                start_time = data.get('start_time').encode('utf8')
                introduce = data.get('introduce')
                required_stus = data.get('required_stus')
                finish_time = ' '.join(finish_time.split('T'))+':00'
                start_time = ' '.join(start_time.split('T'))+':00'
                activity = Activity(acid=acid, actype=actype, vol_time=vol_time,
                                    ac_place=ac_place, subject=subject,
                                    finish_time=finish_time, start_time=start_time,
                                    introduce=introduce, required_stus=required_stus)
            db.session.add(activity)
            db.session.commit()
            return jsonify(status='ok')
        return jsonify(status='fail')
Example #23
0
def challenge_done(current_user):
    random_challenge = None
    currentuser = current_user.uuid
    # generates new random challeng
    while True:
        query = db.session.query(Challenge.cid)
        challenges = query.all()

        # random challenge
        random_challenge = random.choice(challenges)

        activity = db.session.query(Activity.cid).filter(
            Activity.user_id == int(currentuser),
            Activity.cid == random_challenge.cid).first()

        if activity is None:
            break

    # generates unique id for activity.
    activityid = (uuid.uuid4().int & (1 << 29) - 1)

    #get current activity.
    for a in Activity.query.filter_by(user_id=currentuser,
                                      chal_status=4).all():
        a.set_status(2)  # set current activity to done
        a.set_point(3)  # 3 points for each activity completed
        a.set_current(False)  # not current anymore

    # add a new activity for this user.
    active = Activity(activity_id=activityid,
                      cid=random_challenge.cid,
                      user_id=int(currentuser),
                      current=True,
                      chal_status=4)

    db.session.add(active)
    db.session.commit()

    # update user last activity
    update_last_activity(currentuser)

    print('Done execute')
    sys.stdout.flush()
Example #24
0
def manual_entry():
    if request.method == 'POST':
        if manual_entry_data_check(request.form['mountain'], request.form['date']):
            act = Activity()
            act.name = request.form['act_name']
            act.polyline = None
            act.url = '/view/' + act.name
            mt = find_mountain(request.form['mountain'])
            act.mountains.append(mt)
            act.activity_id = None
            act.date = convert_date(request.form['date'])
            current_user.activities.append(act)
            act.description = request.form['description']
            db.session.commit()

            flash("Peak Saved!")
            return redirect(url_for('index'))
        else:
            flash("Invalid Data")

    return render_template('manual_entry.html', title="Manual Entry", mt_list=appforms.mountain_choices())
Example #25
0
def challenge_skip(current_user):

    random_challenge = None
    currentuser = current_user.uuid

    # generates new random challeng
    while True:
        query = db.session.query(Challenge.cid)
        challenges = query.all()

        # random challenge
        random_challenge = random.choice(challenges)

        activity = db.session.query(Activity.cid).filter(
            Activity.user_id == int(currentuser),
            Activity.cid == random_challenge.cid).first()

        if activity is None:
            break

    # generates a unique id for activity.
    activityid = (uuid.uuid4().int & (1 << 29) - 1)

    #delete current activity
    db.session.query(Activity).filter(
        Activity.chal_status != 2, Activity.user_id == currentuser).delete()

    # add a new activity for this user.
    active = Activity(activity_id=activityid,
                      cid=random_challenge.cid,
                      user_id=int(currentuser),
                      current=True,
                      chal_status=4)

    db.session.add(active)
    db.session.commit()

    # update the user last activity.
    update_last_activity(currentuser)

    print('Skip executed')
    sys.stdout.flush()
Example #26
0
def add_activity():
    param = request.json
    title = param.get('title')
    patch_img_url = param.get('patch_img_url')
    content_url = param.get('content_url')
    poster_url = param.get('poster_url')
    enroll_start_at = param.get('enroll_start_at')
    enroll_stop_at = param.get('enroll_stop_at')
    status = param.get('status')

    if title is None:
        return response(None, ResponseCodeEnum.miss_param)

    activity_id = getRandString('ac_', 16)
    activity = Activity(activity_id, title, patch_img_url, content_url,
                        poster_url, enroll_start_at, enroll_stop_at, status)
    db.session.add(activity)
    db.session.commit()

    return response()
Example #27
0
def test_week_activity_duration_single_activity_start_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 = 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')
    activities = [activity]

    week_duration = charting.calc_daily_duration_per_exercise_type(
        activities, start_week)
    assert len(week_duration) == 6
    assert len(week_duration[1]) == 7
    assert week_duration[1] == [25, 0, 0, 0, 0, 0, 0]
    for i in range(2, 6):
        assert week_duration[i] == [0, 0, 0, 0, 0, 0, 0]
Example #28
0
def todolist():
    form = ActivityForm()
    if form.validate_on_submit():
        activity = Activity(body=form.activity.data, author=current_user)
        db.session.add(activity)
        db.session.commit()
        flash(_l('Your activity is now live!'))
        return redirect(url_for('main.todolist'))
    page = request.args.get('page', 1, type=int)
    cases = current_user.followed_activity().paginate(
        page, 10, False)
    
    
    next_url = url_for('main.todolist', page=cases.next_num) \
        if cases.has_next else None
    prev_url = url_for('main.todolist', page=cases.prev_num) \
        if cases.has_prev else None
    return render_template('todolist.html', title='Todo list', form=form,
                           activity=cases.items, next_url=next_url,
                           prev_url=prev_url)
Example #29
0
def test_week_activity_null_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,
                        iso_timestamp='2020-06-15T21:58:33.302785-07:00')

    activities = [activity]

    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] == [0, 0, 0, 0, 0, 0, 0]
Example #30
0
def logrun():
    if not current_user.is_authenticated:
        return redirect(url_for('login'))

    form = LogRunForm()

    if form.validate_on_submit():
        run = Activity(date=form.date.data,
                       walk_miles=form.walk.data,
                       run_miles=form.run.data,
                       total_miles=form.walk.data + form.run.data,
                       type=form.type.data,
                       shoe=form.shoe.data,
                       user_id=current_user.id)
        db.session.add(run)
        db.session.commit()

        return redirect(url_for('logrun'))

    return render_template('logrun.html', title='Log Run', form=form)
Example #31
0
 def test_insertion(self):
     conn = engine.connect()
     insertion = Activity(
         date='20160704',
         steps=10000,
         user_id='1',
         total_sleep=8,
         resting_hr=60,
         step_week_slope=1,
         sleep_week_slope=1,
         hr_week_slope=1,
         curr_health_score=60,
         health_score_in_week=65
     )
     db.session.add(insertion)
     db.commit()
     s = db.select()
     result = conn.execute(s)
     for row in result:
         print row
     self.assertEqual(result, 200)
Example #32
0
def test_week_activity_distance_positive_timezone():
    # has an entry for a timezone ahead of UTC
    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-15T04:58:33.302785+05:00')

    activities = [activity]

    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]