def unlike(data):
print(f"Unlike {data}")
current_user = db.get_user(
{"username": session.get("username")}, {"likes": 1, "matched": 1}
)
unlikes = db.get_user(
{"username": data["to"]}, {"liked": 1, "matched": 1, "notifications": 1}
)
if data["to"] in current_user["likes"]:
current_user["likes"].remove(data["to"])
unlikes["liked"].remove(session.get("username"))
if current_user["matched"] and data["to"] in current_user["matched"]:
current_user["matched"].remove(data["to"])
unlikes["matched"].remove(session.get("username"))
db.update_likes(
current_user["_id"],
{"likes": current_user["likes"], "matched": current_user["matched"]},
)
db.update_likes(
unlikes["_id"], {"liked": unlikes["liked"], "matched": unlikes["matched"]}
)
# sid = logged_in_users[data["to"]]
# if sid:
# socket.emit("Unlike", {"from": session.get("username")}, room=sid)
unlikes["notifications"].append(session.get("username") + " has unliked you.")
db.update_likes(unlikes["_id"], {"notifications": unlikes["notifications"]})
def view_profile(user_id):
id = ObjectId(user_id)
current_user = db.get_user({"username": session.get("username")})
user = db.get_user({"_id": id})
online_users = list(logged_in_users.keys())
bio = html.unescape(user['bio'])
user['bio'] = bio
return render_template("user/view_profile.html",
logged_in=session.get('username'),
user=user,
online_users=online_users,
current_user=current_user)
def liked_back(data):
print(f"Debug")
like_back = db.get_user(
{"username": session.get("username")},
{"username": 1, "likes": 1, "matched": 1, "rooms": 1},
)
liked = db.get_user(
{"username": data["to"]},
{"username": 1, "liked": 1, "matched": 1, "rooms": 1, "notifications": 1},
)
room = secrets.token_hex(16)
like_back["likes"].append(liked["username"])
liked["liked"].append(like_back["username"])
# add to the matched array.
like_back["matched"].append(liked["username"])
liked["matched"].append(like_back["username"])
# add a unique room to this twos matched
like_back["rooms"][liked["username"]] = room
liked["rooms"][like_back["username"]] = room
db.update_likes(
like_back["_id"],
{
"likes": like_back["likes"],
"matched": like_back["matched"],
"rooms": like_back["rooms"],
},
)
db.update_likes(
liked["_id"],
{
"liked": liked["liked"],
"matched": liked["matched"],
"rooms": liked["rooms"],
},
)
sid = logged_in_users.get(data["to"])
if sid:
socket.emit("matched", {"from": session.get("username")}, room=sid)
liked["notifications"].append(
session.get("username") + " has liked back. You can now chat"
)
db.update_likes(liked["_id"], {"notifications": liked["notifications"]})
print(data)
def login():
errors = []
details = {
'username': '',
'password': ''
}
if request.method == 'POST':
details['username'] = request.form.get('username')
details['password'] = request.form.get('password')
user = db.get_user({'username': details['username']}, {'password': 1})
print(user)
if not user:
errors.append("Incorrect username or password")
elif not bcrypt.checkpw(details['password'].encode('utf-8'), user['password']):
errors.append('Incorrect username or password')
if not errors:
session['username'] = details['username']
flash('Successful login', 'success')
return redirect( url_for('home') )
for error in errors:
flash(error, 'danger')
return render_template('login.html', details=details)
def flirt(username):
flirter = db.get_user({'username':session.get('username')}, {'flirts': 1, 'username' : 1})
print("flirter", flirter)
flirtee = db.get_user({'username':username}, {'flirted': True, 'username' : 1})
print('flirtee', flirtee)
# Flirted is used for people who have liked you.
flirtee['flirted'].append(session.get('username'))
print("flirtee", flirtee)
# Flirts is for users who you have like
flirter['flirts'].append(flirtee['username'])
db.update_flirts(flirter['_id'], {'flirts': flirter['flirts']})
db.update_flirts(flirtee['_id'], {'flirted': flirtee['flirted']})
return redirect( url_for('users') )
def reset_password():
errors = []
if request.method == 'GET':
user_id = ObjectId(request.args.get('jrr'))
if request.method == 'POST':
user_id = ObjectId(request.args.get('jrr'))
user = db.get_user({'_id': user_id})
password = request.form.get('password')
password_repeat = request.form.get('password_repeat')
if not re.match('[A-Za-z0-9]', password):
errors.append(
'The password must have an uppercase, lowercase and a digit')
if password_repeat != password:
errors.append('The two passwords do not match')
if not errors:
salt = bcrypt.gensalt()
user['password'] = bcrypt.hashpw(password.encode('utf-8'), salt)
db.update_user(user['_id'], user)
return redirect(url_for('auth.login'))
for error in errors:
flash(error, 'danger')
return render_template('auth/reset_password.html')
def login():
errors = []
user_info = {'username': '', 'password': ''}
if request.method == 'POST':
user_info['username'] = html.escape(request.form.get('username'))
user_info['password'] = html.escape(request.form.get('password'))
user = db.get_user({'username': user_info['username']})
if not user:
errors.append("Incorrect username or password")
elif not user['email_confirmed']:
errors.append('Please check your email for confirmation')
elif not bcrypt.checkpw(user_info['password'].encode('utf-8'),
user['password']):
errors.append('Incorrect username or password')
if not errors:
session['username'] = user_info['username']
flash('Successful login', 'success')
if not user_info['username'] in logged_in_users:
logged_in_users[user_info['username']] = ''
calculate_popularity(user)
return redirect(url_for('main.users'))
for error in errors:
flash(error, 'danger')
return render_template('auth/login.html', user_info=user_info)
def wrapper(*args, **kwargs):
print(session['username'])
user = db.get_user({'username':session.get('username')})
if user['completed'] == 0:
flash("Please finish your profile first", 'info')
return redirect( url_for('profile', next=request.url))
return f(*args, **kwargs)
def search_username():
global filter_users
if request.method == "POST":
username = request.form.get('username')
print(username)
current_user = db.get_user({'username': session.get('username')})
blocked = current_user["blocked"]
filter_users = list(
db.users({
'_id': {
'$nin': blocked
},
'completed': 1,
'username': username
}))
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=filter_users,
current_user=current_user,
search=True,
)
return redirect(url_for("main.users"))
def search_fame():
global filter_users
if request.method == "POST":
print("Debug 1", request.form.get("fame"))
fame = request.form.get("fame")
if not fame.isnumeric():
flash("invalid input for age search", "danger")
return redirect(url_for("main.users"))
current_user = db.get_user({"username": session.get("username")})
blocked = current_user["blocked"]
users = db.users({
"_id": {
"$nin": blocked
},
"gender": {
"$ne": current_user['gender']
},
"completed": 1
})
fame = int((fame.replace(" ", "")).split(",")[0])
filter_users = filter_fame(users, fame)
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=filter_users,
current_user=current_user,
search=True,
)
return redirect(url_for("main.users"))
def chat():
users = db.users()
current_user = db.get_user({'username': session.get('username')},
{'matched': 1})
return render_template('chat/chat.html',
logged_in=session.get('username'),
users=users,
current_user=current_user)
def block_user(b_id):
current_user = db.get_user({"username": session.get("username")})
ob_id = ObjectId(b_id)
current_user["blocked"].append(ob_id)
db.update_user(current_user["_id"], current_user)
return redirect(url_for("main.users"))
def like(data):
liker = db.get_user(
{"username": session.get("username")}, {"username": 1, "likes": 1}
)
liked = db.get_user(
{"username": data["to"]}, {"username": 1, "likes": 1, "liked": 1, "notifications": 1}
)
liker["likes"].append(liked["username"])
liked["liked"].append(liker["username"])
db.update_likes(liker["_id"], {"likes": liker["likes"]})
db.update_likes(liked["_id"], {"liked": liked["liked"]})
calculate_popularity(liked)
# sid = logged_in_users.get(data["to"])
# if sid:
# socket.emit("flirt", {"from": session.get("username")}, room=sid)
liked["notifications"].append(session.get("username") + " liked you")
db.update_likes(liked["_id"], {"notifications": liked["notifications"]})
def logout():
user = db.get_user({'username': session.get('username')})
user['last-seen'] = datetime.utcnow()
db.update_user(user)
# logged_in_users.pop(session.pop('username'), None)
return "the use is logged out"
def send_registration_email(receiver,
subject='email confirmation',
text=None,
html=None):
""" send and Auth email for account registration
ARGS:
reciever: string. username of the new account the email is sent to
subject : string. subject of the verification email "email confirmation by default"
text : string. the email body
returns: nothing.
uses the smtplib.SMTP_SSL() as a server to send a verification email
to a newly registered user.
"""
user = db.get_user({'username': receiver}, {'username': 1, 'email': 1})
port = 465
password = '******'
senders_email = "*****@*****.**"
receivers_email = user['email']
message = MIMEMultipart("alternative")
message["Subject"] = subject
message["From"] = senders_email
message["To"] = receivers_email
if not text:
text = """\
Hello lover!!,{}
Welcome to Matcha.
Don't keep your soulmate waiting, click the link and confirm your registration:
http://localhost:5000/confirm?jrr={}""".format(user['username'],
user['_id'])
if not html:
html = """\
<html>
<body>
<p>Hello lovera!!,{}<br>
Welcome to Matcha.<br>
Don't keep your soulmate waiting, click the link and confirm your registration:
<a href="http://localhost:5000/confirm?jrr={}">Confirm Email</a>
</p>
</body>
</html>
""".format(user['username'], user['_id'])
_html = MIMEText(html, "html")
plain = MIMEText(text, "plain")
message.attach(_html)
message.attach(plain)
email_body = ssl._create_unverified_context()
with smtplib.SMTP_SSL("smtp.gmail.com", port,
context=email_body) as server:
server.login(senders_email, password)
server.sendmail(senders_email, receivers_email, message.as_string())
def logout():
user = db.get_user({'username': session.get('username')}, {'last-seen': 1})
user['last-seen'] = datetime.utcnow()
# db.update_likes(user['_id'], {'last-seen': user['last-seen']})
db.update_user(user['_id'], {'last-seen': user['last-seen']})
logged_in_users.pop(session.pop("username"), None)
# session.pop('username')
return redirect(url_for('main.home'))
def wrapper(*args, **kwargs):
user = db.get_user({'username': session.get('username')})
if user is None:
return redirect( url_for('auth.login', next=request.url))
if user['completed'] == 0:
flash("you must first complete your profile", 'danger')
return redirect( url_for('profile.profile', next=request.url))
if not user['gallery']:
flash("you must add 4 images to your gallery", 'danger')
return redirect( url_for('profile.profile', next=request.url))
return f(*args, **kwargs)
def home():
posts = (db.get_posts())
user = db.get_user({'username': test_user})
# get notifications and merge them to the dictionary
notifications = db.get_notifications(
user['id']) # Does the fetchall function get all
if isinstance(notifications, tuple):
notifications = {}
user['notifications'] = notifications
for post in posts:
for key, value in post.items():
if key == 'author':
post[key] = db.get_user({'id': post[key]})
if key == 'title' or key == 'content':
post[key] = html.unescape(value)
print('posts', posts)
return render_template('home.html',
logged_in_user='******',
posts=posts,
current_user=user)
def users():
# Get the logged in user
user = db.get_user({'username': test_user})
print(user)
# Get the users blocked lisg
# Filter out all the users that dont match the sexual preference.
# Filter out the users in the blocked list. ! This can be done in the backend.. maybe?
# Assign to the valid users global variable.
# render the page
return 'This is the user page'
def view_user_profile(data):
print("recieving the data")
viewed_user = db.get_user({"_id": ObjectId(data["viewed"])})
viewer = db.get_user({"_id": ObjectId(data["viewer"])}, {"username": 1})
if (
data["viewer"] in viewed_user["views"]
or viewer["_id"] in viewed_user["blocked"]
):
return False
if viewed_user["username"] in logged_in_users:
socket.emit(
"notif_view",
{"from": viewer["username"]},
sid=logged_in_users[viewed_user["username"]],
)
if viewed_user['username'] != viewer['username']:
viewed_user["notifications"].append(viewer["username"] + " has viewed you profile")
viewed_user["views"].append(data["viewer"])
db.update_likes(
viewed_user["_id"],
{"views": viewed_user["views"], "notifications": viewed_user["notifications"]},
)
print("Debug: views", data)
def profile():
user = db.get_user({'username' : session.get('username')})
errors = []
if request.method == 'POST':
if request.form.get('submit') == 'update':
username = request.form.get('username')
email = request.form.get('email')
firstname = request.form.get('firstname')
lastname = request.form.get('lastname')
image_file = request.files.get('image')
if user['username'] != username and db.get_user({'username': username}):
errors.append("The username is already taken please chose another")
else:
user['username'] = username
session['username'] = username
if user['email'] != email and db.get_user({'email' : email}):
errors.append("The email is already taken please chose another one")
else:
user['email'] = email
user['firstname'], user['lastname'] = firstname, lastname
if image_file:
pic_name = save_picture(image_file)
user['image_name'] = pic_name
if not errors:
db.update_user(user['_id'], user)
return redirect( url_for('profile') )
for error in errors:
flash(error, 'danger')
return render_template('profile.html', logged_in=session.get('username'), user=user)
def confirm():
errors = []
if request.method == 'GET':
jrr = request.args.get('jrr')
user = db.get_user({'_id': jrr})
print('[ user stuff ]', user)
if user:
# update flirts
pass
else:
errors.append('Incorrect username or password')
# flash errors to the screen
return '\n'.join(errors)
def send_mail(reciever, subject='email confirmation', text=None, html=None):
user = db.get_user({'username' : reciever}, {'username' :1 , 'email': 1})
# Check if the reciever is a username.
# Set up the user information.
port = 465
password = '******'
sender_email = "*****@*****.**"
receiver_email = user['email']
message = MIMEMultipart("alternative")
message["Subject"] = subject
message["From"] = sender_email
message["To"] = receiver_email
if not text:
text = """\
Hi,{}
Welcome to Matcha.
Copy the URL below to confirm your email:
http://127.0.0.1:5000/confirm?jrr={}""".format(user['username'],user['_id'])
if not html:
html = """\
<html>
<body>
<p>Hi,{}<br>
Welcome to Matcha.<br>
Click the link below to confirm your email:
<a href="http://127.0.0.1:5000/confirm?jrr={}">Confirm Email</a>
</p>
</body>
</html>
""".format(user['username'],user['_id'])
# Turn these into plain/html MIMEText objects
part1 = MIMEText(text, "plain")
part2 = MIMEText(html, "html")
# Add HTML/plain-text parts to MIMEMultipart message
# The email client will try to render the last part first
message.attach(part1)
message.attach(part2)
# Create secure connection with server and send email
email_context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", port, context=email_context) as server:
server.login(sender_email, password)
server.sendmail(sender_email, receiver_email, message.as_string())
def new_post():
user = db.get_user({'username':session.get('username')})
post = {
'author': user,
'title': '',
'content': '',
'date_posted': ''
}
if request.method == 'POST':
post['title'] = request.form.get('title')
post['content'] = request.form.get('content')
post['date_posted'] = datetime.utcnow()
db.add_post(post)
return redirect( url_for('home') )
return render_template('create_post.html', logged_in=session.get('username'))
def search_interest():
global filter_users
if request.method == "POST":
interest = []
if request.form.get("Traveling"):
interest.append(request.form.get("Traveling"))
if request.form.get("Animals"):
interest.append(request.form.get("Animals"))
if request.form.get("Technology"):
interest.append(request.form.get("Technology"))
if request.form.get("Sky-diving"):
interest.append(request.form.get("Sky-diving"))
if request.form.get("Movies"):
interest.append(request.form.get("Movies"))
if request.form.get("Music"):
interest.append(request.form.get("Music"))
if request.form.get("Cooking"):
interest.append(request.form.get("Cooking"))
if request.form.get("Sports"):
interest.append(request.form.get("Sports"))
if request.form.get("Gaming"):
interest.append(request.form.get("Gaming"))
current_user = db.get_user({"username": session.get("username")})
blocked = current_user["blocked"]
users = db.users({
"_id": {
"$nin": blocked
},
"gender": {
"$ne": current_user['gender']
},
"completed": 1
})
filter_users = filter_interest(users, interest)
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=filter_users,
current_user=current_user,
search=True,
)
return redirect(url_for("main.users"))
def sort_age(value):
global filter_users
current_user = db.get_user({"username": session.get("username")})
if value == "Sort_d":
sorted_users = filter_users[:]
for i in range(len(sorted_users)):
for k in range(len(sorted_users)):
if sorted_users[i]["age"] > sorted_users[k]["age"]:
sorted_users[i], sorted_users[k] = sorted_users[
k], sorted_users[i]
[print(user["username"], user["age"]) for user in sorted_users]
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=sorted_users,
current_user=current_user,
search=True,
)
if value == "Sort_a":
sorted_users = filter_users[:]
for i in range(len(sorted_users)):
for k in range(len(sorted_users)):
if sorted_users[i]["age"] < sorted_users[k]["age"]:
sorted_users[i], sorted_users[k] = sorted_users[
k], sorted_users[i]
[print(user["username"], user["age"]) for user in sorted_users]
a_sorted_users = sorted_users
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=a_sorted_users,
current_user=current_user,
search=True,
)
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=filter_users,
current_user=current_user,
search=True,
)
return redirect(url_for("main.users"))
def confirm():
errors = []
if request.method == 'GET':
user_id = ObjectId(request.args.get('jrr'))
user = db.get_user({'_id': user_id})
if user:
db.update_likes(user_id, {'email_confirmed': 1})
flash('Email confirmed', 'success')
return redirect(url_for('auth.login'))
else:
errors.append("Incorrect username or password")
for error in errors:
flash(error, 'danger')
return redirect(url_for('auth.login'))
def search_location():
global filter_users
print("Debug location ", request.form.get("location"))
if request.method == "POST":
location = request.form.get("location")
current_user = db.get_user({"username": session.get("username")})
blocked = current_user["blocked"]
users = db.users({"_id": {"$nin": blocked}, "completed": 1})
filter_users = filter_location(users, location)
return render_template(
"user/users.html",
logged_in=session.get("username"),
users=filter_users,
current_user=current_user,
search=True,
)
return redirect(url_for("main.users"))
def login():
errors = []
details = {'username': '', 'password': ''}
if request.method == 'POST':
details['username'] = html.escape(request.form.get('username'))
details['password'] = html.escape(request.form.get('password'))
# details['password'] = details['password'].encode('utf-8')
print(details['password'], "Why is this here")
user = db.get_user({'username': details['username']})
# print(details["email_confirmed"])
# Check if the user actually exists
if not user:
errors.append('Incorrect username or password: '******'email_confirmed']):
# errors.append('Please check your email for confirmation')
if (not user) and not bcrypt.checkpw(
details['password'].encode('utf-8'),
user['password'].encode('urf-8')):
errors.append('Incorrect username or password')
if not errors:
session['username'] = details['username']
flash('Successful login', 'success')
if not details['username'] in logged_in_users:
logged_in_users[details['username']] = ''
calculate_fame(user)
return redirect(url_for('main.home'))
# flash errors
for error in errors:
flash(error, 'danger')
return render_template("auth/login.html", details=details)
def forgot_password():
errors = []
user_info = {'username': ''}
if request.method == 'POST':
username = request.form.get('username')
user = db.get_user({'username': username})
if not username:
errors.append('The username cannot be empty')
if not re.match('^[A-Za-z][A-Za-z0-9]{2,49}$', username):
errors.append('Invalid username')
if not user:
errors.append(
'No such user found, please register an account, peasant')
if not errors:
subject = 'Forgot Password'
text = """\
Hi,{}
Welcome to Matcha.
Copy the URL below to reset your password:
http://localhost:5000/reset_password?jrr={}""".format(
user['username'], user['_id'])
html = """\
<html>
<body>
<p>Hi,{}<br>
Welcome to Matcha.<br>
Click the link below to reset your password:
<a href="http://localhost:5000/reset_password?jrr={}">Reset Password</a>
</p>
</body>
</html>
""".format(user['username'], user['_id'])
send_registration_email(username, subject, text, html)
flash('Please check your email to reset your password', 'success')
for error in errors:
flash(error, 'danger')
return render_template('auth/forgot_password.html', user_info=user_info)
