def test_follow_unfollow_methods(self):
#make users
u1 = User(username = '******', password = '******', email = '*****@*****.**')
u2 = User(username = '******', password = '******', email = '*****@*****.**')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
assert u1.unfollow(u2) == None
u = u1.follow(u1)
u2 = u2.follow(u2)
u3 = u2.follow(u1)
db.session.add(u)
db.session.add(u2)
db.session.add(u3)
db.session.commit()
assert u2.follow(u1) == None
assert u1.is_following(u1)
assert u1.followed.count() == 1
assert u1.followed.first().username == 'jer'
assert u2.followers.count() == 1
assert u2.followed.count() == 2
assert u2.followers.first().username == 'shaw'
u1.unfollow(u2)
db.session.commit()
assert u1.is_following(u2) == False
assert u1.followed.count() == 1
assert u2.followers.count() == 1
def update_info():
if request.method == 'POST':
if not request_wants_json():
user = User.find_by_id(g.user.id)
else:
user = User.find_by_id(request.form['uid'])
user.firstname = request.form['firstname']
user.lastname = request.form['lastname']
user.email = request.form['email']
email_user = User.find_by_email(user.email)
if not request_wants_json():
if email_user != None and email_user.id != g.user.id:
flash("Our record shows that you have an account under the given email address already.")
return render_template("users/update_info.html")
else:
if email_user != None and str(email_user.id) != request.form['uid']:
ret = {"result": "Email address already exist."}
return json.dumps(ret)
if len(request.form['gender']) > 0:
user.sex = request.form['gender'][0].upper()
user.location = request.form['location']
user.date_of_birth = request.form['date_of_birth']
user.avatar = request.form['gravatar']
user.about_me = request.form['about-me']
User.save_to_db(user)
if request_wants_json():
ret = {"result": "OK"}
return json.dumps(ret)
flash('Your changes have been made!')
return render_template("users/update_info.html")
def new_measurement(username):
m = json.loads(request.data)
if g.user.is_authenticated() and g.user.username == username:
user = User.find_by_username(username)
dt = datetime.strptime(m["measurement_date"], "%m/%d/%Y %H:%M")
user_measurement = UserMeasurement(
user_id=g.user.id,
type=m["measurement_type"],
value=m["measurement_value"],
unit=m["measurement_unit"],
date=dt,
)
UserMeasurement.save_to_db(user_measurement)
User.add_newsfeed(
user,
"Has added a new measurement "
+ user_measurement.type
+ ": "
+ str(user_measurement.value)
+ " "
+ user_measurement.unit,
)
return user_measurement.to_json()
else:
return json.dumps({"error": "User " + username + " is not logged in"})
def submit_workout():
exercises = request.data
if(len(exercises) == 0):
result = {"Result":"Failure: No JSON Data sent."}
return jsonify(result)
jsonExercises = json.loads(exercises)
name = jsonExercises['name']
description = jsonExercises['description']
level = jsonExercises['level']
isPublic = jsonExercises['isPublic']
if isPublic == 'true':
isPublic = True
else:
isPublic = False
isLikeable = jsonExercises['isLikeable']
if isLikeable == 'true':
isLikeable = True
else:
isLikeable = False
isCommentable = jsonExercises['isCommentable']
if isCommentable == 'true':
isCommentable = True
else:
isCommentable = False
user = g.user
if user.is_anonymous():
user = User.find_by_username("Guest")
else:
user.add_newsfeed("Has added a workout: " + name + "")
if user is None:
user = User.find_by_username("Guest")
if user is None:
user = User(username="******", password="******", email=None, firstname=None, lastname=None, location=None, sex=None, date_of_birth=None, avatar=None, about_me=None, last_seen=None)
User.save_to_db(user)
newWorkout = Workout(user_id=user.id, parent_user_id=user.id, name=name, level=level,
is_public=isPublic, is_likeable=isLikeable, is_commentable=isCommentable, description=description)
Workout.save_to_db(newWorkout)
logging.warning("saving workout")
for exercise in jsonExercises['exercises']:
order = exercise['order']
type = exercise['type']
unit = exercise['unit']
exerciseTag = ExerciseTag.find_by_name(type)
if exerciseTag is None:
exerciseTag = ExerciseTag(type, unit)
ExerciseTag.save_to_db(exerciseTag)
amount = exercise['amount']
additionalInfo = exercise['additionalInfo']
newExercise = Exercise(newWorkout.id, exerciseTag.id, order, amount, additionalInfo)
Exercise.save_to_db(newExercise)
result = {"Result":"Success"}
return jsonify(result)
def test_inserting_duplicate_username(self):
u = User(username = '******', password = "******", email =
'*****@*****.**')
User.save_to_db(u);
u2 = User(username = '******', password = "******", email =
'*****@*****.**')
assert User.save_to_db(u2) == False
assert len(User.all()) == 1
def test_topUser_ieMostFollowers(self):
u1 = User(username = '******', password = "******", email = '*****@*****.**')
u2 = User(username = '******', password = "******", email = '*****@*****.**')
u3 = User(username = '******', password = "******", email = '*****@*****.**')
u4 = User(username = '******', password = "******", email = '*****@*****.**')
u5 = User(username = '******', password = "******", email = '*****@*****.**')
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(u4)
db.session.add(u5)
db.session.commit()
uf1 = u1.follow(u2)
uf2 = u1.follow(u3)
uf3 = u1.follow(u3)
uf4 = u2.follow(u1)
uf5 = u2.follow(u3)
uf6 = u5.follow(u5)
db.session.add(uf1)
db.session.add(uf2)
db.session.add(uf3)
db.session.add(uf4)
db.session.add(uf5)
db.session.commit()
t = u5.top_user()
# This should be 5 ; failing because the way the query is called (self.)
#assert t == '3'
def display_splash_contents():
ret = Workout.getNewest()
nWorkout = ret.to_hash()
ret = User.getNewest()
nuPic = ret.get_avatar(200)
nUser = ret.to_hash()
ret = User.find_by_id(8)
mfPic = ret.get_avatar(200)
mFollowed = ret.to_hash()
w = {"Result":"OK", "nUser":nUser, "nuPic": nuPic,"nWorkout":nWorkout, "mostFollowed":mFollowed, "mfPic":mfPic}
return jsonify(w)
def test_find_all_by_user_id(self):
u = User(username = '******', password = "******", email = '*****@*****.**')
another_user = User(username = '******', password = "******", email = '*****@*****.**')
User.save_to_db(u)
User.save_to_db(another_user)
measurement1 = UserMeasurement(user_id=1, type="distance ran", value=2, unit="miles")
measurement2 = UserMeasurement(user_id=1, type="distance ran", value=5, unit="miles")
measurement3 = UserMeasurement(user_id=2, type="distance ran", value=23, unit="miles")
UserMeasurement.save_to_db(measurement1)
UserMeasurement.save_to_db(measurement2)
UserMeasurement.save_to_db(measurement3)
u_measurements = UserMeasurement.find_all_by_user_id(u.id)
assert len(u_measurements) == 2
def login():
form = LoginForm(csrf_enabled=False)
if g.user is not None and g.user.is_authenticated():
if(request_wants_json()):
return g.user.to_json();
else:
return redirect(url_for('home_index'))
if request.method == 'GET':
return render_template('users/login.html',
title = 'Sign In',
form = form)
elif request.method == 'POST':
if form.validate_on_submit():
login_user(form.user)
flash("Login successful")
session['username'] = form.username.data
user = User.find_by_username(form.username.data)
if(request_wants_json()):
return user.to_json();
else:
return redirect(request.args.get("next") or url_for("home_index"))
else:
if(request_wants_json()):
return form.to_json();
else:
return render_template('users/login.html',
title = 'Sign In',
form = form)
def post_status():
body = request.form['body']
if 'uid' not in request.form:
g.user.add_newsfeed(body)
else:
user = User.find_by_id(request.form['uid'])
user.add_newsfeed(body)
return jsonify(result="success");
def follow_btn():
followee = request.args.get('followee', '', type=int)
state = request.args.get('state', '', type=str)
user = User.find_by_id(followee)
if state.startswith("Follow"):
follower = g.user.follow(user)
User.save_to_db(follower)
if g.user.is_following(user):
return jsonify(result="Unfollow") #g.user successfully followed user. So, we must change the state of the button
else:
return jsonify(resul="error") #we could return 'Follow' to just keep the state. But returning 'error' will say that something went wrong. Could be a database problem.
follower = g.user.unfollow(user)
User.save_to_db(follower)
if not g.user.is_following(user):
return jsonify(result="Follow") #g.user successfully unfollowed user
else:
return jsonify(result="error")
def new_user():
if request.headers['Content-Type'] == 'application/json':
form = RegistrationForm.from_json(request.json, csrf_enabled=False)
else:
form = RegistrationForm()
if request.method == 'GET':
return render_template('users/new.html', form=form)
elif request.method == 'POST':
if form.validate():
user = User(form.username.data,
form.password.data)
User.save_to_db(user)
user = user.follow(user)
User.add_newsfeed(user,"Has joined Lumberjack.")
flash("Registration Successful!")
if request.headers['Content-Type'] == 'application/json':
return user.to_json()
else:
login_user(user);
session['username'] = form.username.data
return redirect(url_for('display_user_profile',
username=user.username))
else:
if request.headers['Content-Type'] == 'application/json':
return form.to_json()
else:
return render_template('users/new.html', form=form)
def all_user_feeds(uid):
user = User.find_by_id(uid)
posts = user.followed_posts().paginate(1, 100, False)
feeds = '{"feed":['
for post in posts.items:
feeds += '{"username":"******",' + '"body":"' + post.body + '",' + '"time":"' + str(post.timestamp) + '",' + '"avatar":"' + post.get_feed_avatar(post.userName, 80) + '"},'
feeds = feeds[:len(feeds)-1]
feeds += "]}"
return feeds
def measurement_summary(username):
user = User.find_by_username(username)
if user != None:
measurements = UserMeasurement.latest_measurement_for_each_type_by_user(user.id)
result = []
for measurement in measurements:
result.append(measurement.to_hash())
return jsonify({"measurements": result})
def validate(self):
valid_form = Form.validate(self)
if not valid_form:
return False
user = User.find_by_username(self.username.data)
if user != None:
self.username.errors.append('Username ' + self.username.data + ' is already taken')
return False
return True
def test_measurement_history_by_user(self):
u = User(username = '******', password = "******", email = '*****@*****.**')
bieber = User(username = '******', password = "******", email = '*****@*****.**')
User.save_to_db(u)
User.save_to_db(bieber)
measurement_list = []
measurement_list.append(UserMeasurement(user_id=1, type="distance ran", value=2, unit="miles", date=datetime.now()))
u_latest_distance_ran =datetime.now() + timedelta(minutes =10)
measurement_list.append(UserMeasurement(user_id=1, type="distance ran", value=5, unit="miles", date=u_latest_distance_ran))
measurement_list.append(UserMeasurement(user_id=1, type="distance ran", value=23, unit="miles",date=datetime.now() + timedelta(minutes =15)))
for measurement in measurement_list:
UserMeasurement.save_to_db(measurement)
u_measurements = UserMeasurement.measurement_history_by_user(u.id, "distance ran")
beiber_measurements = UserMeasurement.measurement_history_by_user(bieber.id, "distance ran")
assert len(u_measurements) == 3
assert len(beiber_measurements) == 0
u_measurements_types = [m.type for m in u_measurements]
assert len(set(u_measurements_types)) == 1
def after_login(resp):
if resp.email is None or resp.email == "":
flash('Invalid login. Please try again.')
redirect(url_for('login'))
user = User.find_by_email(resp.email)
user_name = session['username']
if user is None:
user = User(user_name = user_name, email = resp.email, password = "******")
User.save_to_db(user)
else:
if user.user_name != user_name:
flash('Username does not match open id. Try again.')
return redirect(url_for('login'))
session.pop('username', None)
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = remember_me)
return redirect(request.args.get('next') or url_for('index'))
def user_measurement(username, measurement_type):
if request_wants_json():
user = User.find_by_username(username)
result = []
if user != None:
measurements = UserMeasurement.measurement_history_by_user(user.id, measurement_type)
for measurement in measurements:
result.append(measurement.to_hash())
return jsonify({"measurements": result})
else:
return render_template(
"user_measurements/measurement_history.html", target_user=username, target_measurement=measurement_type
)
def test_find_all(self):
u = User(username = '******', password = "******", email =
'*****@*****.**')
User.save_to_db(u)
u = User(username = '******', password = "******", email =
'*****@*****.**')
User.save_to_db(u)
u = User(username = '******', password = "******", email =
'*****@*****.**')
User.save_to_db(u)
assert len(User.all()) == 3
def test_follow_self(self):
#make users
u1 = User(username = '******', password = '******', email = '*****@*****.**')
u2 = User(username = '******', password = '******', email = '*****@*****.**')
u3 = User(username = '******', password = '******', email = '*****@*****.**')
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
#make users follow themselves
f1 = u1.follow(u1)
f2 = u2.follow(u2)
f3 = u3.follow(u3)
db.session.add(f1)
db.session.add(f2)
db.session.add(f3)
db.session.commit()
#make sure they are following themselves
assert u1.is_following(u1)
assert u2.is_following(u2)
assert u3.is_following(u3)
def get_users():
"""
"""
result = []
userids = []
usernames = []
if 'username' in request.form:
usernames = User.find_all_by_username(request.form['username'])
if usernames is not None:
for username in usernames:
result.append(username.to_hash())
elif 'email' in request.form:
usernames = User.find_all_by_email(request.form['email'])
if usernames is not None:
for username in usernames:
result.append(username.to_hash())
w = {"Result":"OK", "Records": result}
return jsonify(w)
def display_user_profile(username, page=1):
user = User.find_by_username(username)
posts = None
if not request_wants_json():
if user == None:
return render_template("users/user.html", user = user, posts = posts) #user not found
if g.user.is_authenticated() and g.user.id == user.id:
if user.firstname == None or user.firstname == "" or user.lastname == None or user.lastname == "" or user.email == None or user.email == "":
flash("We can't display your profile until you have filled out the form")
return render_template("users/update_info.html")
posts = g.user.followed_posts().paginate(page, 10, False)
else:
if user == None:
return json.dumps({"Error": "User not found."})
return user.to_json()
return render_template("users/user.html", user = user, posts = posts)
def getWorkoutHistory():
results = []
uName = request.args.get('name')
current_user = User.find_by_username(uName)
if current_user is None:
w = {"Result":"BAD"}
return jsonify(w)
completed = WorkoutHistory.get_completed_workouts(current_user.id)
for item in completed:
name = Workout.find_by_id(item.workout_id).name
results.append(item.toHash(name))
w = {"Result":"OK", "Contents":results, "User":current_user.username}
return jsonify(w)
def submit_workout_history():
wName = request.form['wName']
date = request.form['date']
desc = request.form['desc']
user = User.find_by_username(request.form['user'])
workout = Workout.find_single_workout_by_name_(wName)
if(workout == None):
return jsonify(result="errorName", content=" The workout name you have entered may not exist. Please double check the spelling of the workout name. Thank you")
if(date == ""):
return jsonify(result="errorDate", content=" Please enter the date and time of the completed workout")
wh = WorkoutHistory(user.id, workout.id, datetime.strptime(date, "%m/%d/%Y %I:%M:%S %p"), desc, True)
WorkoutHistory.save_to_db(wh)
feed = "comleted "+wName+" on "+date+" - "+desc;
user.add_newsfeed(feed);
return jsonify(result="success");
def validate(self):
valid_form = Form.validate(self)
if not valid_form:
return False
user = User.find_by_username(self.username.data)
if user is None:
#self.username.errors.append('User does not exist!')
flash("User does not exist!", "error")
self.username.errors.append('User does not exist!')
return False
if not user.valid_password(self.password.data):
flash('Invalid password!', "error")
self.password.errors.append('Invalid Password')
return False
self.user = user
return True
def test_get_latest_measurement_for_each_type_by_user(self):
u = User(username = '******', password = "******", email = '*****@*****.**')
bieber = User(username = '******', password = "******", email = '*****@*****.**')
another_user = User(username = '******', password = "******", email = '*****@*****.**')
User.save_to_db(u)
User.save_to_db(another_user)
User.save_to_db(bieber)
measurement_list = []
measurement_list.append(UserMeasurement(user_id=1, type="distance ran", value=2, unit="miles", date=datetime.now()))
u_latest_distance_ran =datetime.now() + timedelta(minutes =10)
measurement_list.append(UserMeasurement(user_id=1, type="distance ran", value=5, unit="miles", date=u_latest_distance_ran))
measurement_list.append(UserMeasurement(user_id=2, type="distance ran", value=23, unit="miles",date=datetime.now() + timedelta(minutes =15)))
measurement_list.append(UserMeasurement(user_id=1, type="height", value=5, unit="cm", date=datetime.now()))
u_latest_height = date=datetime.now() + timedelta(minutes =3)
measurement_list.append(UserMeasurement(user_id=1, type="height", value=5, unit="cm", date=u_latest_height))
u_latest_weight = datetime.now() + timedelta(minutes = 20)
measurement_list.append(UserMeasurement(user_id=1, type="weight", value=23, unit="lbs", date=u_latest_weight))
for measurement in measurement_list:
UserMeasurement.save_to_db(measurement)
u_measurements = UserMeasurement.latest_measurement_for_each_type_by_user(u.id)
assert len(u_measurements) == 3
u_measurements_types = [m.type for m in u_measurements]
assert len(u_measurements_types) == len(set(u_measurements_types))
for m in u_measurements:
if m.type == "distance ran":
u_dist_ran = m
elif m.type == "height":
u_height = m
elif m.type == "weight":
u_weight = m
assert u_dist_ran.date == u_latest_distance_ran
assert u_height.date == u_latest_height
assert u_weight.date == u_latest_weight
def display_user_workout_history (username):
user = User.find_by_username(username)
return render_template("users/workout_history.html", user=user)
def load_user(id):
return User.find_by_id(int(id))
def users_index():
users = User.all()
output = ""
for user in users:
output += user.user_name + "\n"
return output
def get_workouts():
"""
{
"Result":"OK",
"Records":[
{"WorkoutId":1,"Name":"Blah"},
{"WorkoutId":2,"Name":"Lazy bones"},
]
}
"""
result = []
workout_ids = []
workouts = []
if 'workout' in request.form:
workouts = Workout.find_by_name(request.form['workout'])
if workouts is not None:
for workout in workouts:
result.append(workout.to_search_query_hash())
elif 'description' in request.form:
workouts = Workout.find_by_description(request.form['description'])
if workouts is not None:
for workout in workouts:
result.append(workout.to_search_query_hash())
elif 'tag_auto' in request.form:
tags = ExerciseTag.find_all_by_name(request.form['tag_auto'])
if tags is not None:
for tag in tags:
for exercise in tag.exercises:
workout_ids.append(exercise.workOutId)
#remove dupes
workout_ids = set(workout_ids)
for id in workout_ids:
workouts.append(Workout.find_by_id(id))
for workout in workouts:
result.append(workout.to_search_query_hash())
elif 'exercise' in request.form:
tag = ExerciseTag.find_by_name(request.form['exercise'])
if tag is not None:
for exercise in tag.exercises:
workout_ids.append(exercise.workOutId)
#remove dupes
workout_ids = set(workout_ids)
for id in workout_ids:
workouts.append(Workout.find_by_id(id))
for workout in workouts:
result.append(workout.to_search_query_hash())
elif 'author' in request.form:
authors = User.find_all_by_username(request.form['author'])
if authors is not None:
for author in authors:
works = Workout.find_by_userid(author.id)
if works is not None:
for work in works:
workouts.append(work)
for workout in workouts:
result.append(workout.to_search_query_hash())
w = {"Result":"OK", "Records": result}
return jsonify(w)
