def user_trip_update_activity(trip_id):
"""Allow user to update an activity for a unique trip."""
user_id = session.get("user_id")
user_trip_to_update = UserTrip.query.filter_by(trip_id=trip_id).first()
print "This is the trip: ", user_trip_to_update
if user_id and user_trip_to_update:
if request.form:
print request.form.get("category")
old_trip_activity_query = Activity.query.filter_by(
category=request.form.get("category"),
description=request.form.get("description")).first()
print "This is the old activity via query: ", old_trip_activity_query
old_trip_activity_query.category = (request.form.get("category"))
print "This is the old category: ", old_trip_activity_query.category
old_trip_activity_query.description = (
request.form.get("description"))
print "This is the old description: ", old_trip_activity_query.description
new_activity = Activity(
category=request.form.get("category"),
description=request.form.get("description"),
trip_id=trip_id)
db.session.add(new_activity)
db.session.commit()
flash('You have successfully updated an activity for this trip.')
print "Trip activity update has been committed to db", new_activity
return redirect("/user/" + str(trip_id))
def save_activity():
"""Save recipe and movie user chose to the database and user's profile"""
### FROM random_recipe_and_movie_results.html
user_id = session.get("user_id")
if user_id:
recipe_id = session.get("recipe_id")
movie_id = session.get("movie_id")
date_today = (datetime.today() -
timedelta(hours=8)).strftime("%Y-%m-%d")
activity = Activity.query.filter_by(user_id=user_id,
movie_id=movie_id,
recipe_id=recipe_id).first()
if not activity:
new_entry = Activity(user_id=user_id,
movie_id=movie_id,
recipe_id=recipe_id,
date=date_today)
db.session.add(new_entry)
db.session.commit()
flash("Activity successfully saved!", 'alert-success')
return ('', 204)
def get_activity():
"""Process adding a new activity."""
user = User.query.get(session["user_id"])
# Get form variables
activity = request.form["activity"]
unit = request.form["unit"]
act_exists = Activity.query.filter_by(act_name=activity, act_unit=unit).first()
if act_exists:
flash("Activity already exists")
if not act_exists:
new_act = Activity(act_name=activity, act_unit=unit)
user.activities.append(new_act)
db.session.add(new_act)
db.session.commit()
flash(f"Activity {activity} added.")
print(act_exists)
return redirect("/activity")
def load_activities():
"""Load chidlren from c.user into database."""
print("activities")
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate children
# Read a.user file and insert data
for row in open("data/a.user"):
row = row.rstrip()
activity_id, activity_name, for_parents, for_children = row.split("|")
for_parents = bool(for_parents)
for_children = bool(for_children)
activity = Activity(activity_id=activity_id,
activity_name=activity_name,
for_parents=for_parents,
for_children=for_children)
# We need to add to the session or it won't ever be stored
db.session.add(activity)
# commit our work
db.session.commit()
def register_process():
"""Process registration."""
# Get form variables
email = request.form["email"]
password = request.form["password"]
username = request.form["username"]
user_exists = User.query.filter_by(email=email).first()
if user_exists:
flash(f"""User {email} already exists.
Please log in, you don't need to register! :)""")
return redirect("/")
new_user = User(email=email, password=password, username=username)
for act_name, act_unit in Activity.DEFAULT_ACTIVITIES:
activity = Activity(act_name=act_name, act_unit=act_unit)
new_user.activities.append(activity)
db.session.add(new_user)
db.session.commit()
flash(f"User {email} added. Now please log in.")
return redirect("/")
def add_points(update: Update, context):
points = update.message.text
try:
int(points)
except:
# Telegram clients will display a reply interface to the user
# (act as if the user has selected the bot’s message and tapped ‘Reply’)
force_reply = ForceReply(force_reply=True, selective=True)
update.message.reply_text(
f'{points} is not a number. Please enter number 😊',
reply_markup=force_reply)
return POINTS
else:
context.user_data[POINTS] = points
update.message.reply_text(
f'Ok. Activity {context.user_data[ACTIVITY]} gives {context.user_data[POINTS]} points 😎',
quote=False)
# Saving activity to the database
act = Activity(activity_name=context.user_data[ACTIVITY],
points=context.user_data[POINTS],
author_user_id=update.effective_user.id,
leaderboard_id=update.effective_chat.id)
act.save_activity()
# Get new user input
return wait_for_input(update, context)
def create_activity(itinerary_id,
activity_name,
address,
lat,
lng,
activity_day=None,
activity_time=None,
activity_note=None):
"""Create and return a new activity."""
activity = Activity(
itinerary_id=itinerary_id,
activity_name=activity_name,
address=address,
#place_id=place_id,
lat=lat,
lng=lng,
activity_day=activity_day,
activity_time=activity_time,
activity_note=activity_note,
)
db.session.add(activity)
db.session.commit()
return activity
def load_activities():
"""Load activities from activities.csv into database"""
print "Activities"
# Delete all rows in table, so if we need to run this a second time,
# we won't be adding duplicate categories
Activity.query.delete()
# Read category.csv file and insert data
for row in open("seed_data/activities.csv"):
row = row.rstrip()
act_id, cat_id, eb_cat_id, name, act_type, eb_format_id, sub_cat, mu_id, img_url = row.split(
",")
activity = Activity(act_id=act_id,
cat_id=cat_id,
eb_cat_id=eb_cat_id,
name=name,
act_type=act_type,
eb_format_id=eb_format_id,
sub_cat=sub_cat,
mu_id=mu_id,
img_url=img_url)
# Need to add to session to store
db.session.add(activity)
# Commit my work
db.session.commit()
def load_activities():
"""Retrieve activities information from recreation.gov and load into database. Refers to Activity."""
# if there's an existing table, delete and reload it
Activity.query.delete()
# returns a dictionary with a list of dictionaries nested
results = json.load(
urllib.urlopen(
'https://ridb.recreation.gov/api/v1/activities/?apikey={}'.format(
key)))
# returns a list of dictionaries
activities = results[u'RECDATA']
# line is a dictionary
for line in activities:
activity_id = line[u'ActivityID']
activity_name = line[u'ActivityName'].lower()
activity = Activity(activity_id=activity_id,
activity_name=activity_name)
db.session.add(activity)
db.session.commit()
def add_activity():
new_activity = Activity(**request.json)
db.session.add(new_activity)
db.session.commit()
return jsonify(new_activity.to_dict())
def create_activity(title, user): # pass grade and subject here...
"""Create and return a new movie."""
activity = Activity(title = title, user = user)
db.session.add(activity)
db.session.commit()
return activity
def create_activity(activity_name):
"""Create and return a new activity."""
activity = Activity(activity_name=activity_name)
db.session.add(activity)
db.session.commit()
return activity
def create_activity(activity_name, min_cost, max_cost, min_age, max_age, location, effort_rating, keywords, activity_description):
"""Create and return a new activity."""
activity = Activity(activity_name=activity_name,min_cost=min_cost, max_cost=max_cost, min_age=min_age, max_age=max_age, location=location, effort_rating=effort_rating, keywords=keywords, activity_description=activity_description)
db.session.add(activity)
db.session.commit()
return activity
def create_signup_activity(youtify_user_model):
target = simplejson.dumps({})
actor = simplejson.dumps(get_youtify_user_struct(youtify_user_model))
m = Activity(owner=youtify_user_model,
verb='signup',
actor=actor,
target=target,
type='outgoing')
m.put()
def load_activities():
print "Activities"
Activity.query.delete()
with open('seed_data/activities.csv', 'rb') as activities_csvfile:
activities = csv.reader(activities_csvfile, delimiter=',')
for a in activities:
category_id, name = a
db_activity = Activity(category_id=category_id, activity_name=name)
db.session.add(db_activity)
db.session.commit()
def create_activity(dog_id, activity_type, activity_date, activity_month,
activity_time, activity_duration, activity_note):
activity = Activity(dog_id=dog_id,
activity_type=activity_type,
activity_date=activity_date,
activity_month=activity_month,
activity_time=activity_time,
activity_duration=activity_duration,
activity_note=activity_note)
db.session.add(activity)
db.session.commit()
return activity
def create_external_subscribe_activity(youtify_user_model,
external_user_model):
target = simplejson.dumps(
get_external_user_subscription_struct(external_user_model))
actor = simplejson.dumps(get_youtify_user_struct(youtify_user_model))
m = Activity(owner=youtify_user_model,
verb='external_subscribe',
actor=actor,
target=target,
type='outgoing')
m.put()
for relation in FollowRelation.all().filter('user2 =',
youtify_user_model.key().id()):
m = Activity(owner=YoutifyUser.get_by_id(relation.user1),
verb='external_subscribe',
actor=actor,
target=target,
type='incoming')
m.put()
def create_follow_activity(owner, other_user):
""" owner started following other_user
Both owner and other_user gets a new activity
"""
target = simplejson.dumps(get_youtify_user_struct(other_user))
actor = simplejson.dumps(get_youtify_user_struct(owner))
m = Activity(owner=owner,
verb='follow',
actor=actor,
target=target,
type='outgoing')
m.put()
m = Activity(owner=other_user,
verb='follow',
actor=actor,
target=target,
type='incoming')
m.put()
def create_flattr_activity(youtify_user_model, thing_id, thing_title):
target = simplejson.dumps({
'thing_id': thing_id,
'thing_title': thing_title,
})
actor = simplejson.dumps(get_youtify_user_struct(youtify_user_model))
m = Activity(owner=youtify_user_model,
verb='flattr',
actor=actor,
target=target,
type='outgoing')
m.put()
for relation in FollowRelation.all().filter('user2 =',
youtify_user_model.key().id()):
m = Activity(owner=YoutifyUser.get_by_id(relation.user1),
verb='flattr',
actor=actor,
target=target,
type='incoming')
m.put()
def create_subscribe_activity(youtify_user_model, playlist_model):
""" user subscribed to playlist
Both user and playlists owner gets a new activity
"""
target = simplejson.dumps(
get_playlist_struct_from_playlist_model(playlist_model))
actor = simplejson.dumps(get_youtify_user_struct(youtify_user_model))
m = Activity(owner=youtify_user_model,
verb='subscribe',
actor=actor,
target=target,
type='outgoing')
m.put()
m = Activity(owner=playlist_model.owner,
verb='subscribe',
actor=actor,
target=target,
type='incoming')
m.put()
def load_activities():
"""Load activity ideas into database"""
# Delete rows in table to prevent duplicates if file run again
Activity.query.delete()
for row in open("activities.txt"):
row = row.rstrip().split("|")
activity, description, img = row
activity = Activity(
activity=activity,
description=description,
img=img,
)
db.session.add(activity)
db.session.commit()
def display_activity():
""" Activity Page """
activity_query = request.form["activity_query"]
playlist_name = request.form["playlist_name"]
# Processes form data from HTML
user_id = session.get('logged_user')['username']
token = session.get('access_token')
new_activity = Activity(activity_name=activity_query, user_id=user_id)
db.session.add(new_activity)
db.session.commit()
activity_id = new_activity.activity_id
# Seed activities table
auth_header = session['auth_header']
# Generates authorization headers
spotify_user_id = spotifyutils.get_spotify_user_id(auth_header)
# Find logged user's spotify account
playlist_id = spotifyutils.create_playlist(auth_header, spotify_user_id, playlist_name, activity_id)
# Creates empty playlist that is stored as a playlist object locally and pushes to user's Spotify account
playlists_ids = spotifyutils.search_spotify_playlists(activity_query)
# API call to query Spotify's playlists based off user's inputted activity
# returns list of playlist uris; NONE ARE STORED
spotifyutils.search_playlists_tracks(playlists_ids, playlist_id)
# API call to respective playlist ids; seeds locally
playlist_uri = spotifyutils.seed_spotify_playlist(auth_header, playlist_id)
# Pushes songs to playlist on user's Spotify account
playlist_view_src = {'playlist':"https://open.spotify.com/embed/user/"+spotify_user_id+"/playlist/"+playlist_uri}
# iframe/spotify widget passed into HTML via jinja
user_playlists = spotifyutils.users_playlists(user_id)
return jsonify(playlist_view_src)
def user_trip_add_activity(trip_id):
"""Allow user to add activities for a unique trip."""
user_id = session.get("user_id")
user_trip_to_update = UserTrip.query.filter_by(trip_id=trip_id).first()
print "This is the trip: ", user_trip_to_update
if user_id and user_trip_to_update:
if request.form:
new_activity = Activity(
category=request.form.get("category"),
description=request.form.get("description"),
trip_id=trip_id)
db.session.add(new_activity)
db.session.commit()
flash('You have successfully added an activity to this trip.')
print "Trip activity has been committed to db", new_activity
return redirect("/user/" + str(trip_id))
def log_new_activity():
user = session.get("user")
item_id = request.form["item_id"]
timestamp = datetime.now()
item = Item.query.get(item_id)
if item:
new_activity = Activity(user_id=user['id'], item_id=item_id, date_logged=timestamp)
#TODO: Error Handling
db.session.add(new_activity)
db.session.commit()
else:
return "Error: Item ID not found"
list_url = "/list/" + str(item.list_id)
#return jsonify(new_activity)
return redirect(list_url)
def create_activity(strava_activity):
"""Create and return an activity."""
athlete = User.query.filter(
User.strava_id == strava_activity["athlete"]["id"]).first()
date = datetime.strptime(strava_activity["start_date_local"].split("T")[0],
"%Y-%m-%d")
strava_access_token = athlete.strava_access_token
strava_splits = strava_api.get_strava_activities_with_laps(
strava_access_token, strava_activity["id"])
splits = None
if "splits_standard" in strava_splits:
splits = strava_splits["splits_standard"]
new_activity = Activity(
user_id=athlete.id,
strava_activity_id=strava_activity["id"],
date_utc=strava_activity["start_date"],
date_local=strava_activity["start_date_local"],
week_num=date.isocalendar()[1],
weekday=date.isocalendar()[2],
desc=strava_activity["name"],
exercise_type=strava_activity["type"],
distance=strava_activity["distance"],
workout_time=strava_activity["moving_time"],
elev_gain=strava_activity["total_elevation_gain"],
splits=splits,
)
db.session.add(new_activity)
db.session.commit()
return new_activity
def create_activity_in_section(program_name, section_name):
"""Make request to activity endpoint"""
program = Program.query.filter_by(program_name=program_name).first()
if program is not None:
section = Section.query.filter_by(section_name=section_name).first()
if section is not None:
request_data = request_data.get_json()
html_content = request_data['html_content']
question = request_data['question']
multiple_choice_answers = request_data['multiple_choice_answers']
right_answer = request_data['right_answer']
new_activity = Activity(
html_content=html_content,
question=question,
multiple_choice_answers=multiple_choice_answers,
right_answer=right_answer)
db.session.add(new_activity)
db.session.commit()
return jsonify(serialize_activity(activity_dict))
else:
return 'Can not find the section', 404
else:
return 'Can not find the program', 404
def post(self):
json = request.json['activity']
print dateutil.parser.parse(json['date'])
activity = Activity(user_id=json['user'],
work_order=json['work_order'],
date=dateutil.parser.parse(json['date']),
type=json['type'],
note=json['note'])
if not activity.save():
abort(400)
model = {
'activity': {
'id': activity.id,
'work-order': activity.work_order_id,
'user': activity.user_id,
'date': activity.date.isoformat(),
'type': activity.type
}
}
print model
return jsonify(model)
def example_data():
""" Create some sample data. """
#Programs
first_program = Program(
name="Leadership Development Program",
description="Leadership Development Program Description")
second_program = Program(
name="Cognitive Behavioral Therapy",
description="Cognitive Behavioral Therapy Description")
third_program = Program(name="New Parenting",
description="New Parenting Description")
fourth_program = Program(name="Mindful Communication",
description="Mindful Communication Description")
#First program's sections
section_1 = Section(program_id=1,
name="Section 1 Program 1'",
description="Section 1 Program 1 Description",
order_index=1,
image_link="",
is_last=False)
section_2 = Section(program_id=1,
name="Section 2 Program 1'",
description="Section 2 Program 1 Description",
order_index=2,
image_link="",
is_last=False)
section_3 = Section(program_id=1,
name="Section 3 Program 1'",
description="Section 3 Program 1 Description",
order_index=3,
image_link="",
is_last=False)
section_4 = Section(program_id=1,
name="Section 4 Program 1'",
description="Section 4 Program 1 Description",
order_index=4,
image_link="",
is_last=False)
section_5 = Section(program_id=1,
name="Section 5 Program 1'",
description="Section 5 Program 1 Description",
order_index=5,
image_link="",
is_last=False)
section_6 = Section(program_id=1,
name="Section 6 Program 1'",
description="Section 6 Program 1 Description",
order_index=6,
image_link="",
is_last=False)
section_7 = Section(program_id=1,
name="Section 7 Program 1'",
description="Section 7 Program 1 Description",
order_index=7,
image_link="",
is_last=False)
section_8 = Section(program_id=1,
name="Section 8 Program 1'",
description="Section 8 Program 1 Description",
order_index=8,
image_link="",
is_last=False)
section_9 = Section(program_id=1,
name="Section 9 Program 1'",
description="Section 9 Program 1 Description",
order_index=9,
image_link="",
is_last=False)
section_10 = Section(program_id=1,
name="Section 10 Program 1'",
description="Section 10 Program 1 Description",
order_index=10,
image_link="",
is_last=False)
activity_1 = Activity(section_id=1,
html_content="",
question="Question Activity 1")
activity_2 = Activity(section_id=2,
html_content="<html></html>",
question="")
answer_1 = Answer(activity_id=1, answer_text="Activity 1 Answer Text")
db.session.add_all([
first_program, second_program, third_program, fourth_program,
section_1, section_2, section_3, section_4, section_5, section_6,
section_7, section_8, section_9, section_10, activity_1, activity_2,
answer_1
])
db.session.commit()
