def new_user_item():
user_id = g.current_user.id
item_id = request.json.get('itemId')
rating = request.json.get('rating')
comments = request.json.get('comments')
fit = request.json.get('fit')
size = request.json.get('size')
if item_id and user_id:
new_user_item = User_Item(user_id=user_id,
item_id=item_id,
rating=rating,
size=size,
size_in=convert_shoe_size_to_inches(size),
comments=comments,
fit=fit)
db.session.add(new_user_item)
db.session.commit()
shoe_stats(item_id)
else:
abort(500)
return jsonify({
'status': "success",
'message': 'Shoe Added',
'user_item': new_user_item.serialize()
})
def post_match_public():
want_item_id = request.json.get('wantItemId')
size = request.json.get('size')
have_item_id = request.json.get('haveItemId')
if not want_item_id or not size or not have_item_id:
response = jsonify({
'status': 'error',
'message': 'Invalid Request',
})
response.status_code = 400
return response
else:
size_in = convert_shoe_size_to_inches(size)
# get target item information
target_item = Item.query.filter_by(id=want_item_id).first()
results_dict = match_function(have_item_id, size_in, want_item_id)
results = process_results_dict(results_dict)
return jsonify({
'status':
'success',
'message':
'',
'target_item':
target_item.serialize(),
'match_results':
sorted(results, key=lambda k: k['percentage'], reverse=True),
})
def edit_user_item():
user_id = g.current_user.id
user_item_id = request.json.get('userItemId')
rating = request.json.get('rating')
size = request.json.get('size')
comments = request.json.get('comments')
fit = request.json.get('fit')
user_item = User_Item.query.filter_by(id=int(user_item_id)).first()
if user_item and user_item.user_id == user_id:
user_item.rating = rating
user_item.comments = comments
user_item.size_in = convert_shoe_size_to_inches(size)
user_item.size = size
user_item.fit = fit
db.session.commit()
shoe_stats(user_item.item_id)
else:
abort(400)
return jsonify({
'status': "success",
'message': 'Shoe Edited',
'user_item': user_item.serialize()
})
def post_user_details():
invalid_form = False
change_username_error = ""
change_email_error = ""
username = request.json.get('username')
email = request.json.get('email')
street_shoe_size = request.json.get('streetShoeSize')
foot_shape = request.json.get('footShape')
split_shoe_info = request.json.get('splitShoeInfo')
gender = request.json.get('gender')
climbing_boulder = request.json.get('climbingBoulder')
climbing_sport = request.json.get('climbingSport')
climbing_trad = request.json.get('climbingTrad')
# user wants to change street_shoe_size
if street_shoe_size != None and street_shoe_size != '' and street_shoe_size != 0:
g.current_user.street_shoe_size_in = convert_shoe_size_to_inches(
street_shoe_size)
# foot shape, gender, and split shoe are required values
g.current_user.foot_shape = foot_shape
g.current_user.split_shoe_info = split_shoe_info
g.current_user.gender = gender
g.current_user.climbing_boulder = climbing_boulder
g.current_user.climbing_sport = climbing_sport
g.current_user.climbing_trad = climbing_trad
# user wants to change username
if g.current_user.username != username:
if len(username) < 3:
change_username_error = "Invalid username - Username must be at least 3 characters."
invalid_form = True
if not re.match(r"^[a-zA-Z0-9]+$", username):
change_username_error = "Invalid username - Username must only contain letters or numbers."
invalid_form = True
# if username passes 2 test above, run db query
if invalid_form is False:
if User.query.filter(
func.lower(User.username) ==
username.lower()).first() is not None:
change_username_error = "Username already exists."
invalid_form = True
else:
g.current_user.username = username
# user wants to change email
if g.current_user.email != email:
if len(username) < 5:
change_email_error = "Invalid email - Email must be at least 5 characters."
invalid_form = True
if not re.match(r"^[A-Za-z0-9\.\+_-]+@[A-Za-z0-9\._-]+\.[a-zA-Z]*$",
email):
change_email_error = "Invalid email address."
invalid_form = True
# if email passes 2 test above, run db query
if invalid_form is False:
if User.query.filter_by(email=email).first() is not None:
invalid_form = True
change_email_error = "A user with this email already exists."
else:
g.current_user.email = email
if invalid_form is True:
return jsonify({
'status': "error",
'message': 'There was an error changing your account details.',
'username': change_username_error,
'email': change_email_error
})
else:
# make all the changes
db.session.add(g.current_user)
db.session.commit()
new_url = '/profile/' + g.current_user.username + '?changed=1'
return jsonify({
'status': "success",
'message': 'Account details changed successfully.',
'new_url': new_url
})
def post_match_private():
want_item_id = request.json.get('wantItemId')
if not want_item_id:
response = jsonify({
'status': 'error',
'message': 'Invalid Request',
})
response.status_code = 400
return response
else:
# get target item information
target_item = Item.query.filter_by(id=want_item_id).first()
# get list of all of searchers shoes.
users_items = User_Item.query.filter_by(
user_id=g.current_user.id).all()
combined_results_dict = {}
for sshoe in users_items:
if int(sshoe.item_id) != int(want_item_id):
results_dict = match_function(
sshoe.item_id, convert_shoe_size_to_inches(sshoe.size),
want_item_id)
if results_dict:
for user in results_dict:
if user in combined_results_dict:
combined_results_dict[user].update(
results_dict[user])
else:
combined_results_dict[user] = results_dict[user]
results = process_results_dict(combined_results_dict)
# gets recommended sizes per model
groups = defaultdict(list)
for user in combined_results_dict:
for key in combined_results_dict[user]:
groups[combined_results_dict[user][key]['has_item_id']].append(
combined_results_dict[user][key])
grouped_match_users = groups.values()
grouped_results = []
for gusers in grouped_match_users:
most_common_guser_size = Counter(d['recommended_size_in']
for d in gusers).most_common(1)[0]
grouped_results.append({
'shoe':
Item.query.filter_by(
id=gusers[0]['has_item_id']).first().serialize(),
'most_common_size':
convert_shoe_size_to_standards(most_common_guser_size[0])
})
return jsonify({
'status':
'success',
'message':
'',
'target_item':
target_item.serialize(),
'grouped_match_users':
grouped_results,
'street_results':
sorted(match_by_street_shoe_size(target_item),
key=lambda k: k['occurences'],
reverse=True),
'match_results':
sorted(results, key=lambda k: k['percentage'], reverse=True),
})