def test_get_activities_response_no_activity_id(self):
Activity(id='tag:instagram.com,2013:123', source=self.source.key,
activity_json=json_dumps({'foo': 'bar'})).put()
Activity(id='tag:instagram.com,2013:456', source=self.source.key,
activity_json=json_dumps({'baz': 'biff'})).put()
other = Instagram.new(actor={'username': '******'}).put()
Activity(id='tag:instagram.com,2013:789', source=other,
activity_json=json_dumps({'boo': 'bah'})).put()
resp = self.source.get_activities_response()
self.assert_equals([{'foo': 'bar'}, {'baz': 'biff'}], resp['items'])
def test_post_merge_comments(self):
source = Instagram.create_new(self.handler, actor={'username': '******'})
# existing activity with one of the two comments in HTML_VIDEO_COMPLETE
existing_activity = copy.deepcopy(HTML_VIDEO_ACTIVITY)
existing_activity['object']['replies'] = {
'totalItems': 1,
'items': [COMMENT_OBJS[0]],
}
activity_key = Activity(
id='tag:instagram.com,2013:789_456',
activity_json=json_dumps(existing_activity)).put()
# send HTML_VIDEO_COMPLETE to /post, check that the response and stored
# activity have both of its comments
resp = app.application.get_response(
'/instagram/browser/post?token=towkin',
method='POST',
text=HTML_VIDEO_COMPLETE)
self.assertEqual(200, resp.status_int, resp.text)
self.assert_equals(HTML_VIDEO_ACTIVITY_FULL, resp.json)
activity = activity_key.get()
self.assert_equals(HTML_VIDEO_ACTIVITY_FULL,
json_loads(activity.activity_json))
def resume_activity(activities, actual_activity, actual_time_entry_start_time):
"""Resume the actual activity."""
current_activity = get_active_window_title()
# Check if theres was a change in the activity
if current_activity != actual_activity:
# Look for if the activity exists
for previus_activity in activities:
if previus_activity.window_title == actual_activity:
break
else:
previus_activity = None
previus_activity_time_entry = TimeEntry(
start_time=actual_time_entry_start_time,
end_time=datetime.now(timezone.utc))
# If not exist the activity, it'll be created
if not previus_activity:
previus_activity = Activity(actual_activity)
activities.append(previus_activity)
# Add the time entry for the activity
previus_activity.add_time_entry(previus_activity_time_entry)
# Set the new actual activity
actual_activity = current_activity
actual_time_entry_start_time = datetime.now(timezone.utc)
return activities, actual_activity, actual_time_entry_start_time
def update_activity():
id = new_activity.get('id')
if not id:
self.abort(400, 'Scraped post missing id')
activity = Activity.get_by_id(id)
if activity:
# we already have this activity! merge in any new comments.
merged_activity = copy.deepcopy(new_activity)
existing_activity = json_loads(activity.activity_json)
# TODO: extract out merging replies
replies = merged_activity.setdefault('object', {}).setdefault(
'replies', {})
gr_source.merge_by_id(
replies, 'items',
existing_activity.get('object',
{}).get('replies',
{}).get('items', []))
replies['totalItems'] = len(replies.get('items', []))
# TODO: merge tags too
activity.activity_json = json_dumps(merged_activity)
else:
activity = Activity(id=id,
source=source.key,
html=self.request.text,
activity_json=json_dumps(new_activity))
# store and return the activity
activity.put()
logging.info(f"Stored activity {id}")
self.output(new_activity)
def add_activity():
if request.method=="GET":
return render_template ('add_activity.html')
name_error=''
author = Teacher.query.filter_by(username=session['username']).first()
completed = False
if request.method=="POST":
activity_name=request.form['name']
learning_goal=request.form['goal']
for_age=request.form['forage']
location=request.form['where']
today=request.form['date']
lesson_plan=request.form['lessonplan']
point_value=request.form['points']
link_to=request.form['link']
if len(activity_name) < 1:
name_error ="Please enter an activity name."
if not name_error:
new_activity=Activity(name=activity_name,completed=completed,goal=learning_goal,forage=for_age,dateadded=today,lessonplan=lesson_plan,points=point_value,link=link_to,author=author,where=location)
db.session.add(new_activity)
db.session.commit()
return render_template ('activity_entry.html')
return render_template('add_activity.html', name_error=name_error)
def add_activity():
""" Add activity to user's list of saved activities """
try:
# Gets form data and checks for activity_id
data = request.form
if data.get('activity_id'):
# If user is logged in, check if they already have saved this activity
if session.get('user_id'):
user_activity = UserActivity.query.filter_by(activity_id=data['activity_id'], user_id=session['user_id']).first()
# If it hasn't already been saved, save it
if user_activity is None:
user_activity = UserActivity(activity_id=data['activity_id'], user_id=session['user_id'])
activity = Activity.query.get(data['activity_id'])
# If the relevant activity does not exist in the DB, create it too
if activity is None:
activity = Activity(**data)
db.session.add(activity)
db.session.commit()
db.session.add(user_activity)
db.session.commit()
else:
# If not logged in, store the id of the current activity and redirect to login
session['temp_activity_id'] = data['activity_id']
return login()
except exc.SQLAlchemyError as e:
# In case of a DB error, roll it back
db.session.rollback()
except Exception as e:
# If an error occurs, returns an error page
return error(e.args)
# Go back to home page
return index()
def module003_course(coursecode):
form = PostForm()
if form.validate_on_submit():
activity = Activity(name=form.name.data,
description=form.description.data,
user_id = current_user.id,
course_code = coursecode,
dead_line = form.deadline.data)
db.session.add(activity)
db.session.commit()
return redirect('/assignment/' + coursecode)
coursesCreated = Course.query.filter(Course.user_id == current_user.id).all()
coursesFollowed = Follow.query.filter(Follow.user_id == current_user.id).all()
activities = Activity.query.filter(Activity.course_code == coursecode).all()
course = Course.query.filter( Course.code == coursecode).first()
coursename = course.name
creator_id = Course.query.filter(Course.code == coursecode).first().user_id
return render_template('module003_activities.html',
coursesFollowed=coursesFollowed,
coursesCreated=coursesCreated,
form=form,
creator_id=creator_id,
activities=activities,
course_code=coursecode,
course_name = coursename,
module="module003"
)
def post(self):
data = json.loads(self.request.body)
user = users.get_current_user()
client_id = data['id']
chat = ndb.Key(urlsafe=client_id[:-8]).get()
if user:
Activity(
user = user,
chat = chat.key).put()
for client in chat.clients:
channel.send_message(
client,
json.dumps(
{"clients":len(chat.clients)+1,
"name": chat.name,
"cursor": False,
"message": []
}
)
)
last_message_when = Message.query_time_from_chat(chat.key)
if last_message_when < (
datetime.datetime.now()-datetime.timedelta(hours=4)):
logging.info('Reset clients in chat {}'.format(chat.key.urlsafe()))
chat.reset_clients()
chat.add_client(client_id)
def test_reactions_wrong_activity_source(self):
Activity(id='tag:fa.ke,2013:123_456', source=self.other_source).put()
resp = self.post(f'reactions?id=tag:fa.ke,2013:123_456&{self.auth}')
self.assertEqual(403, resp.status_code)
self.assertIn(
"tag:fa.ke,2013:123_456 is owned by Key('FakeBrowserSource', '333zzz')",
resp.get_data(as_text=True))
def update_activity():
id = new_activity.get('id')
if not id:
self.error('Scrape error: post missing id')
activity = Activity.get_by_id(id)
if activity:
# we already have this activity! merge in any new comments and likes
merged_activity = copy.deepcopy(new_activity)
merged_obj = merged_activity.setdefault('object', {})
existing_activity = json_loads(activity.activity_json)
existing_obj = existing_activity.get('object', {})
replies = merged_obj.setdefault('replies', {})
gr_source.merge_by_id(
replies, 'items',
existing_obj.get('replies', {}).get('items', []))
replies['totalItems'] = len(replies.get('items', []))
gr_source.merge_by_id(merged_obj, 'tags',
existing_obj.get('tags', []))
activity.activity_json = json_dumps(merged_activity)
else:
activity = Activity(id=id,
source=source.key,
html=request.get_data(as_text=True),
activity_json=json_dumps(new_activity))
# store and return the activity
activity.put()
logger.info(f"Stored activity {id}")
def test_post_merge_comments(self):
key = self.source.put()
gr_facebook.now_fn().MultipleTimes().AndReturn(datetime(1999, 1, 1))
self.mox.ReplayAll()
# existing activity with one of the two comments in MBASIC_ACTIVITIES
existing_activity = copy.deepcopy(MBASIC_ACTIVITIES[1])
existing_activity['object']['replies'] = {
'totalItems':
1,
'items':
[MBASIC_ACTIVITIES_REPLIES[1]['object']['replies']['items'][0]],
}
activity_key = Activity(
id='tag:facebook.com,2013:456',
activity_json=json_dumps(existing_activity)).put()
# send MBASIC_HTML_POST to /post, check that the response and stored
# activity have both of its comments
resp = self.get_response('post', data=MBASIC_HTML_POST)
self.assertEqual(200, resp.status_code, resp.get_data(as_text=True))
self.assert_equals(MBASIC_ACTIVITY, resp.json)
activity = activity_key.get()
self.assert_equals(MBASIC_ACTIVITY,
trim_nulls(json_loads(activity.activity_json)))
def post_Workout():
form = NewWorkout()
data = request.form
workout = Workout(author=current_user.username,
name=data["Title"],
E1=data["Excercise1"],
E2=data["Excercise2"],
E3=data["Excercise3"],
E4=data["Excercise5"],
E5=data["Excercise5"],
S1=data["Sets1"],
S2=data["Sets2"],
S3=data["Sets3"],
S4=data["Sets4"],
S5=data["Sets5"],
R1=data["Reps1"],
R2=data["Reps2"],
R3=data["Reps3"],
R4=data["Reps4"],
R5=data["Reps5"])
activity = Activity(name=current_user.username,
type='w',
topic=data["Title"])
db.session.add(workout)
db.session.add(activity)
db.session.commit()
return redirect(url_for("workouts"))
def start():
user = User.query.filter(
User.token == request.headers.get("X-Auth-Token")).first()
if user is None:
abort(403)
current_activity = get_current_activity(user)
if current_activity is not None:
return jsonify({"start": "success"})
activity = Activity(user.id)
reg_ids = [
relation.gcm for relation in user.relationships
if relation.gcm is not None
]
if len(reg_ids) > 0:
gcm.json_request(registration_ids=reg_ids, data={"logging": "start"})
db.session.add(activity)
db.session.commit()
return jsonify({"start": "success"})
def test_post_merge_comments(self):
# existing activity with two comments
activity = self.activities_no_extras[0]
reply = self.activities[0]['object']['replies']['items'][0]
activity['object']['replies'] = {
'items': [reply, copy.deepcopy(reply)],
'totalItems': 2,
}
activity['object']['replies']['items'][1]['id'] = 'abc'
key = Activity(id=activity['id'],
activity_json=json_dumps(activity)).put()
# scraped activity has different second comment
activity['object']['replies']['items'][1]['id'] = 'xyz'
FakeGrSource.activities = [activity]
resp = self.get_response('post')
self.assertEqual(200, resp.status_int, resp.text)
self.assert_equals(activity, util.trim_nulls(resp.json))
merged = json_loads(key.get().activity_json)
replies = merged['object']['replies']
self.assert_equals(3, replies['totalItems'], replies)
self.assert_equals([reply['id'], 'abc', 'xyz'],
[r['id'] for r in replies['items']])
def add_has_read(isbn, user_id):
try:
book = db.session.query(Book).filter_by(ISBN=isbn).first()
book_id = book.book_id
# update date selection
db.session.add(
HasRead(user_id=user_id,
book_id=book_id,
start_date=datetime.date.today(),
finish_date=datetime.date.today()))
db.session.add(
Activity(user_id=user_id,
action_id=HAS_READ_ACTION_ID,
object_id=BOOK_OBJECT_ID,
date_created=datetime.datetime.now(),
target_id=book_id))
goals = db.session.query(Goal).filter(Goal.user_id == user_id).all()
for goal in goals:
if str(goal.year) in str(datetime.date.today()):
goal.current = goal.current + 1
db.session.commit()
check_achievement(user_id, GOAL_ACH_TYPE)
check_achievement(user_id, READING_ACH_TYPE)
return make_response(jsonify({"success": "Added to bookshelf"}), 201)
except AttributeError:
traceback.print_exc()
return make_response(jsonify({"error": "Failed to add to shelf"}), 404)
def chooseActivity(request):
if request.method == 'POST':
#OK this is super not the way to do this, but oh well
#also, may end up trying to add an activity and not be able to
#super confusing probably, not at all the right way to do things
pvalues = request.POST.copy()
if not request.POST['activity']:
if len(request.POST['add_activity']):
newActivity = Activity(name=request.POST['add_activity'])
newActivity.save(request)
pvalues['activity'] = newActivity.id
aform = ActivityChooseForm(pvalues, request=request)
if aform.is_valid():
aRating = aform.save(commit=False)
aRating.preDateTime = datetime.datetime.now()
aRating.save(request)
rform = ActivityRatingForm(instance=aRating)
pk = aRating.id
redirectURL = '/activity/' + str(pk) + '/rate/'
return redirect(redirectURL)
else:
return render(request, 'activity/choose.html', {'aform': aform})
aform = ActivityChooseForm(request=request)
return render(request, 'activity/choose.html', {'aform': aform})
def activities(activity_id):
if request.method == 'POST':
# validate parameters
json = request.json
if 'name' not in json:
abort(400)
# insert
try:
activity = Activity(name=json['name'])
db.session.add(activity)
db.session.commit()
return ('', 201)
except:
abort(400)
elif request.method == 'GET':
if activity_id is not None:
activities = Activity.query.filter(id=activity_id).all()
return json.dumps(activities)
else:
activities = Activity.query.all()
print(len(activities))
return jsonify(activities)
def rateCivi(request):
civi_id = request.POST.get('civi_id', '')
rating = request.POST.get('rating', '')
account = Account.objects.get(user=request.user)
c = Civi.objects.get(id=civi_id)
try:
prev_act = Activity.objects.get(civi=c, account=account)
except Activity.DoesNotExist:
prev_act = None
try:
activity_data = {
'account': account,
'thread': c.thread,
'civi': c,
}
if rating == "vneg":
c.votes_vneg = c.votes_vneg + 1
vote_val = 'vote_vneg'
elif rating == "neg":
c.votes_neg = c.votes_neg + 1
vote_val = 'vote_neg'
elif rating == "neutral":
c.votes_neutral = c.votes_neutral + 1
vote_val = 'vote_neutral'
elif rating == "pos":
c.votes_pos = c.votes_pos + 1
vote_val = 'vote_pos'
elif rating == "vpos":
# c.votes_vpos = c.votes_vpos + 1
vote_val = 'vote_vpos'
activity_data['activity_type'] = vote_val
c.save()
if prev_act:
prev_act.activity_type = vote_val
prev_act.save()
data = {
'civi_id':prev_act.civi.id,
'activity_type': prev_act.activity_type,
'c_type': prev_act.civi.c_type
}
else:
act = Activity(**activity_data)
act.save()
data = {
'civi_id':act.civi.id,
'activity_type': act.activity_type,
'c_type': act.civi.c_type
}
return JsonResponse({'data' : data})
except Exception as e:
return HttpResponseServerError(reason=str(e))
def recover_password():
if request.method == "POST":
user = User.query.filter_by(email=request.form.get('username')).first()
if user is not None:
# TODO: Implement feature
activity = Activity(description='Request to recovery password', user_id=user.id)
return render_template('recoverpw.html')
def logout():
activity = Activity(description='Logged out of system', user_id=current_user.id)
db.session.add(activity)
db.session.commit()
logout_user()
flash('You have been logged out')
return redirect(url_for('admin.dashboard'))
def create_html_activities(activities):
for k in range(2):
activity_id = generate_random_uuid()
html_activity = Activity(activity_id=activity_id,
activity_type=ActivityEnum.HTML,
description="blahblahblah")
add_and_commit(html_activity)
activities += [activity_id]
def test_get_activities_response_no_activity_id(self):
Activity(id='tag:fa.ke,2013:123',
source=self.source.key,
activity_json=json_dumps({'foo': 'bar'})).put()
Activity(id='tag:fa.ke,2013:456',
source=self.source.key,
activity_json=json_dumps({'baz': 'biff'})).put()
other = FakeBrowserSource.new(self.handler, actor={
'fbs_id': 'other'
}).put()
Activity(id='tag:fa.ke,2013:789',
source=other,
activity_json=json_dumps({'boo': 'bah'})).put()
resp = self.source.get_activities_response()
self.assert_equals([{'foo': 'bar'}, {'baz': 'biff'}], resp['items'])
def create_activity():
token = request.environ['HTTP_AUTHORIZATION']
user_id = Utility.get_payload_from_jwt(token)["id"]
activity_json = request.json
person_id, location, _type, purpose = activity_json['person_id'], activity_json["location"], activity_json["type"], activity_json["purpose"]
new_activity = Activity(user_id, person_id, location, _type, purpose)
db.session.add(new_activity)
db.session.commit()
return jsonify(Resources.data["activity_logged"])
def public_act(request):
ret_data = {}
errors = []
if request.method == 'POST':
if 'user' in request.session:
theme_act = request.POST.get('theme_act', '')
if not theme_act:
errors.append('theme not exist')
class_act = request.POST.get('class_act', '')
date_act = request.POST.get('date_act', '')
time_act = request.POST.get('time_act', '')
num_act = request.POST.get('num_act', '')
address_act = request.POST.get('address_act', '')
detail_act = request.POST.get('detail_act', '')
username = request.session['user']
date_time = date_act + " " + time_act
userid = User.objects.get(name=username).id
now = datetime.datetime.fromtimestamp(
time.mktime(time.strptime(date_time, r"%Y/%m/%d %H:%M:%S")))
datess = str(now)
print datess
try:
a = int(num_act)
except Exception:
ret_data["ret"] = 'no int'
return HttpResponse(json.dumps(ret_data),
content_type='application/json')
print "now is " + str(datess)
if len(errors) > 0:
ret_data['ret'] = 'no theme'
elif not num_act:
ret_data['ret'] = 'no people_count'
else:
pub_data = Activity(category=class_act,
theme=theme_act,
begin_datatime=datess,
people_count=num_act,
details=detail_act,
submit_peopleId=userid,
location=address_act,
joined_peopleId=userid)
#total=len(Activity.objects.all())+1
pub_data.istimeout = 'n'
pub_data.save()
total = pub_data.id
u = User.objects.get(id=userid)
if u.uncompleted_id == '':
u.uncompleted_id = str(total)
else:
u.uncompleted_id += (',' + str(total))
u.save()
ret_data['ret'] = 'ok'
else:
ret_data['ret'] = 'failed'
else:
ret_data['ret'] = 'failed'
return HttpResponse(json.dumps(ret_data), content_type='application/json')
def post(self):
data = request.json
person = Persons.query.filter_by(name=data['person']).first()
activity = Activity(name=data['name'], person = person)
activity.save()
response = {
'person':activity.person.name,
'name': activity.name
}
return response
def newPost():
form = NewPost()
topic = request.args.get('topic')
if form:
data = request.form
newPost = Post(content = data['content'], topic = topic, author = current_user.username)
activity = Activity(name = current_user.username, type = 'p', topic = newPost.topic)
db.session.add(newPost)
db.session.add(activity)
db.session.commit()
return redirect(request.referrer)
return redirect(request.referrer)
def create_question_and_activities_with_answers(activities):
for l in range(2):
activity_id = generate_random_uuid()
qa_activity = Activity(activity_id=activity_id,
activity_type=ActivityEnum.MULTIPLE_CHOICE,
description="Question " + str(l))
add_and_commit(qa_activity)
activities += [activity_id]
# insert a random number of answers for this question
for k in range(random.randint(1, 5)):
insert_answer(k, activity_id)
def activity_controller(id):
name = request.values.get('name')
score = request.values.get('score')
if id:
if request.method == 'GET':
activity = Activity.query.get(id)
if activity:
activity = activity.dto()
if request.values.get('json'):
return json.dumps(dict(activity=activity))
else:
return render_template('activity_view.html', activity=activity)
elif request.method == 'PUT':
activity_item = Activity.query.get(id)
activity_item.name = name
activity_item.score = score
db.session.add(activity_item)
db.session.commit()
return 'updated'
elif request.method == 'DELETE':
activity_item = Activity.query.get(id)
db.session.delete(activity_item)
db.session.commit()
return 'deleted'
else:
return 'Method Not Allowed'
else:
if request.method == 'GET':
activity_list = Activity.query.all()
if activity_list:
entries = [activity.dto() for activity in activity_list]
else:
entries = None
if request.values.get('json'):
return json.dumps(dict(activity=entries))
else:
return render_template('activity.html',
activity_entries=entries,
title="Activity List")
elif request.method == 'POST':
new_activity = Activity(name=name, score=score)
db.session.add(new_activity)
db.session.commit()
if request.values.get('json'):
url = '/activity/json=true'
else:
url = '/activity/'
return redirect(url)
else:
return 'Method Not Allowed'
def addTopic():
form = NewTopic()
if form:
data = request.form
newTopic = Topic(Title = data['title'],content = data['content'])
newPost = Post(content = data['content'],topic = data['title'],author = current_user.username)
activity = Activity(name = current_user.username, type = 't', topic = newPost.topic)
db.session.add(newTopic)
db.session.add(newPost)
db.session.add(activity)
db.session.commit()
return redirect(url_for('allTopics'))
return redirect(url_for('allTopics'))
def add_or_update_activity(project_id, pgm_group, session_id=0, activity_id=0):
"""
Add activity to database or update it if it exists already.
:param project_id: ID of the project Activity is associated with.
:type project_id: Integer
:param pgm_group: The PGM Group number.
:type pgm_group: Integer
:param session_id: ID of the session Activity is associated with.
:type session_id: Integer
:param activity_id: ID of the activity.
:type activity_id: Integer
:returns: Activity ID of the added activity.
:rtype: Integer
"""
project = Project.get_by_id(project_id)
session = Session.get_by_id(session_id) if session_id > 0 else None
_logger().debug('ADD OR UPDATE. Session {0}: {1!r}'.\
format(session_id, session))
if activity_id > 0:
try:
activity = Activity.get_by_id(activity_id)
activity.project_id = project_id
activity.session_id = session_id
except NoResultFound:
activity = Activity(project, session)
else:
activity = Activity(project, session)
activity.active = pgm_group
activity.update()
_logger().debug('ACTIVITY ID : {0} (session_id {1})'.\
format(activity.id, activity.session_id))
return activity.id
