def new(following_id):
follower = User.get_by_id(current_user.id)
following = User.get_by_id(following_id)
if following.is_public:
r = Relationship(follower=follower,
following=following,
is_approved=True)
else:
r = Relationship(follower=follower,
following=following,
is_approved=False)
if r.save():
if following.is_public:
flash(f"You are now following {following.name}.")
return redirect(url_for('users.show', username=following.username))
else:
flash(f"A follow request has been sent to {following.name}.")
rq_job = app.task_queue.enqueue(
'tasks.' + 'send_follow_request_email', following, follower,
url_for('relationships.index'))
task = Task(redis_job_id=rq_job.get_id(),
name='send_follow_request_email',
description='Send user a follow request email.',
relationship=r)
task.save()
return redirect(url_for('users.show', username=following.username))
else:
return render_template(
'users/show.html',
user=following,
photos=Image.select().where(Image.user_id == following.id),
errors=r.errors)
def create():
fan_id = current_user.id
idol_id = request.form.get('idol_id')
idol = User.get_by_id(idol_id)
#Check if fan has previously requested to follow this idol.
follower = Relationship.get_or_none(Relationship.idol == idol_id,
Relationship.fan == fan_id)
#if they have, flash a message letting them know they have submitteed a request and redirect them to user proifle. Otherwise create a database entry.
if follower:
flash(
f" You've already submitted a follow request to {idol.username} ")
return redirect(url_for('users.show', username=idol.username))
else:
follower = Relationship(fan=fan_id, idol=idol_id)
if follower.save():
flash(f"You have submitted a request to follow {idol.username}")
status = approval_email(fan=current_user, idol=idol)
print(f'Email request sent:{status}')
return redirect(url_for('users.show', username=idol.username))
else:
flash(f"Something went wrong")
def handle_request():
follower_id = request.form['follower_id']
idol_id = request.form['idol_id']
follower = User.get_by_id(follower_id)
request_type = request.form['request_type']
# Change privacy setting
if request_type == 'accept_request':
query = Relationship.get_or_none(
Relationship.follower_id == follower_id,
Relationship.idol_id == idol_id)
approve_request = Relationship.update(approve=True).where(
Relationship.id == query)
approve_request.execute()
flash(f"You have approved {follower.username}'s request.")
return render_template('home.html')
elif request_type == 'cancel_request':
breakpoint()
result = Relationship.get_or_none(
Relationship.follower_id == follower_id,
Relationship.idol_id == idol_id)
delete_request = result.delete_instance()
flash(f"You have denied {follower.username}'s request. ")
return render_template('home.html')
def follow(self, target_user):
from models.relationship import Relationship
if target_user.private:
new_r = Relationship(following_id=self.id,
followed_id=target_user.id,
pending=True)
else:
new_r = Relationship(following_id=self.id,
followed_id=target_user.id,
pending=False)
return new_r.save()
def approval(self, target_user, approval):
from models.relationship import Relationship
if approval == 'approve':
r = Relationship.get_or_none(followed=self, following=target_user)
r.pending = False
r.save()
return True
else:
r = Relationship.get_or_none(followed=self, following=target_user)
r.delete_instance()
return False
def follow(id):
user = User.select().where(User.id == id).get()
fan_id = current_user.id
idol_id = request.form.get('idol_id')
idol = User.get_by_id(idol_id)
follower = Relationship(fan=fan_id, idol=idol_id)
follower.save()
flash("Successfully followed", 'success')
return render_template('users/profile.html', user=user)
def update_approval(id):
relationship_id = request.form['relationship_id']
approval_status = request.form['approval_status']
print('*******')
print(approval_status)
entry = Relationship.get_by_id(relationship_id)
if approval_status == "Approve":
print('executing update')
q = Relationship.update(approved=True).where(
Relationship.id == relationship_id)
q.execute()
elif approval_status == "Reject":
print('executing delete')
entry.delete_instance()
return redirect(url_for('followers.edit_approval', id=id))
def show_profile(id_or_username, is_profile):
# Get user by id or username
if id_or_username.isdigit():
user = User.get_or_none(User.id==id_or_username)
else:
user = User.get_or_none(User.username==id_or_username)
# Render page if user exist
if user:
# Get list of images
images = user.images
# Get list of fans
approve_fans = User.select().join(Relationship, on=(Relationship.fan_id==User.id)).where(Relationship.idol_id==user.id, Relationship.status=="approve")
pending_fans = User.select().join(Relationship, on=(Relationship.fan_id==User.id)).where(Relationship.idol_id==user.id, Relationship.status=="pending")
# Get list of idols
approve_idols = User.select().join(Relationship, on=(Relationship.idol_id==User.id)).where(Relationship.fan_id==user.id, Relationship.status=="approve")
pending_idols = User.select().join(Relationship, on=(Relationship.idol_id==User.id)).where(Relationship.fan_id==user.id, Relationship.status=="pending")
# Check has follow
if current_user.is_authenticated:
relationship = Relationship.get_or_none(Relationship.fan_id==current_user.id, Relationship.idol_id==user.id)
# Get count of images, fans and idols
total = {
"images": len(images),
"fans": len(approve_fans),
"idols": len(approve_idols)
}
return render_template('users/show.html', user=user, images=images, relationship=relationship, total=total)
else:
flash('User not exist', 'alert alert-danger')
return redirect(url_for('home'))
def index():
if current_user.is_authenticated:
# Get profiles of other users
# Method 1: With N+1 issue
# profiles = []
# users = User.select().where(User.id!=current_user.id).order_by(User.id.asc())
# for user in users:
# images = user.images
# relationship = Relationship.get_or_none(Relationship.fan_id==current_user.id, Relationship.idol_id==user.id)
# profiles.append({
# "user": user,
# "images": images,
# "relationship": relationship
# })
# return render_template('users/index.html', users=users, profiles=profiles)
# Method 2: Without N+1 issue
profiles_wo_np1 = []
users_wo_np1 = User.select().where(User.id!=current_user.id).order_by(User.id.asc()).prefetch(Image) # same effect as Image.select().where(Image.user<<users)
for user in users_wo_np1:
relationship = Relationship.get_or_none(Relationship.fan_id==current_user.id, Relationship.idol_id==user.id)
profiles_wo_np1.append({
"user": user,
"images": user.images,
"relationship": relationship
})
return render_template('users/index.html', users=users_wo_np1, profiles=profiles_wo_np1)
else:
return redirect(url_for('sessions.new'))
def delete(id):
idol = User.get_by_id(id)
relationship = Relationship.delete().where(
Relationship.fan == current_user.id, Relationship.idol == idol.id)
relationship.execute()
flash(f"Successfully unfollowed {idol.username}.", "primary")
return redirect(url_for('users.show', username=idol.username))
def show(username):
user = User.get(User.username == username)
relationship = Relationship.get_or_none(
Relationship.idol == user.id, Relationship.fan == current_user.id)
return render_template('users/show.html',
user=user,
relationship=relationship)
def has_requests(self):
from models.relationship import Relationship
# Returns list of pending follow request for current_user
return Relationship.select().join(
User, on=(User.id == Relationship.following_id)).where(
Relationship.is_approved == False,
Relationship.following_id == self.id)
def is_approved(self, user_id):
from models.relationship import Relationship
# Return boolean if relationship between current_user and approved user is approved
return Relationship.select(Relationship.is_approved).join(
User, on=(User.id == Relationship.following_id)).where(
Relationship.follower_id == user_id,
Relationship.following_id == self.id).first().is_approved
def remove_friend(to_username):
ref = request.referrer
logged_user = User.objects.filter(username=session.get('username')).first()
fetchNotifications(logged_user)
toUser = User.objects.filter(username=to_username).first()
if toUser:
rel = Relationship.get_relationship(logged_user, toUser)
if rel == "FRIENDS_PENDING" or rel == "FRIENDS_APPROVED" or rel == "REVERSE_FRIENDS_PENDING":
rel = Relationship.objects.filter(fromUser=logged_user,
toUser=toUser).delete()
reverse_rel = Relationship.objects.filter(
fromUser=toUser, toUser=logged_user).delete()
notification = Notification.objects.filter(
fromUser=toUser.username, toUser=logged_user.username).first()
if notification != None:
nlist = session.get('notifications')
nlist.remove(notification)
session['notifications'] = nlist
notification.delete()
if ref:
return redirect(ref)
else:
return redirect(
url_for('user_app.profile', username=toUser.username))
else:
abort(404)
def show(username):
user = User.get(User.username == username)
if not current_user.is_authenticated:
followed = None
else:
followed = Relationship.get_or_none(
Relationship.fan == current_user.id, Relationship.idol == user.id)
return render_template('users/show.html', user=user, followed=followed)
def get_simple_relationship_drawer(self, username):
relationship = Relationship.objects(
between_users=[self.username, username]).first()
if relationship is None:
relationship = Relationship.objects(
between_users=[username, self.username]).first()
return {
"id": str(self.id),
"username": self.username,
"gender": self.gender,
"display_name": self.display_name,
"profile_url": self.profile_url,
"location": self.location,
"last_online": str(self.last_online),
"relationship":
"Friend" if relationship in self.friends else "Normal"
}
def reject(id):
fan = User.get_by_id(id)
follower = Relationship.delete().where(
Relationship.fan == id, Relationship.idol == current_user.id)
if follower.execute():
flash(f"You reject {fan.username}'s following request.", 'primary')
return redirect(url_for('users.show', username=current_user.username))
else:
flash(f'Failed to approve request,try again later.', 'danger')
return render_template('fanidols/show.html')
def toggle_follow(id):
online_user = User.get_or_none(User.id == current_user.id)
target_user = User.get_or_none(User.id == id)
search_r = Relationship.get_or_none(followed=target_user,
following=online_user)
if search_r:
online_user.unfollow(target_user)
else:
online_user.follow(target_user)
return redirect(url_for('users.show', username=target_user.username))
def approved(id):
fan = User.get_by_id(id)
follower = Relationship.update(approved=True).where(
Relationship.fan == id, Relationship.idol == current_user.id)
if follower.execute():
flash(f'{fan.username} now is your follower.', 'primary')
return redirect(url_for('users.show', username=current_user.username))
else:
flash(f'Failed to approve request,try again later.', 'danger')
return render_template('fanidols/show.html')
def approve(fan_id):
if current_user.is_authenticated:
fan = User.get_or_none(User.id == fan_id)
idol = User.get_or_none(User.id == current_user.id)
if fan and idol:
relationship = Relationship.get_or_none(Relationship.fan == fan,
Relationship.idol == idol)
if relationship and relationship.status == "pending":
if Relationship.update(status="approve").where(
Relationship.id == relationship.id).execute():
flash('Approve follower successful', 'alert alert-success')
else:
flash('Approve follower failed', 'alert alert-danger')
else:
flash('Profile has not been followed', 'alert alert-danger')
else:
flash('Unfollow profile failed', 'alert alert-danger')
return redirect(url_for('relationship.show_fan'))
else:
flash('Log in required', 'alert alert-danger')
return redirect(url_for('home'))
def follow_user():
follower_username = request.form['follower_username']
idol_username = request.form['idol_username']
# Get ID and add to DB
follower_id = User.get_or_none(User.username == follower_username)
idol_id = User.get_or_none(User.username == idol_username)
# If user profile = Public, then add follower and approve
if idol_id.private == False:
add_follower = Relationship(follower_id=follower_id,
idol_id=idol_id,
approve=True)
flash(f'You have followed {idol_username}')
# If user profile = Private, then add follower but don't approve
elif idol_id.private == True:
add_follower = Relationship(follower_id=follower_id,
idol_id=idol_id,
approve=False)
flash(f'A friend request has been sent to {idol_username}')
add_follower.save()
return render_template('home.html')
def unfollow_user():
follower_username = request.form['follower_username']
idol_username = request.form['idol_username']
request_type = request.form['request_type']
idol_id = User.get(User.username == idol_username)
result = Relationship.get_or_none(
current_user.id == Relationship.follower_id,
Relationship.idol_id == idol_id.id)
# Delete record where Relationship.id = result
query = Relationship.get_by_id(result)
query.delete_instance()
if request_type == 'cancel_request':
flash(f'You have cancelled your request to follow {idol_username}')
elif request_type == 'unfollower_user':
flash(f'You have unfollowed {idol_username}')
return render_template('home.html')
def process_message(message):
fromUser = message.fromUser
friends = Relationship.objects.filter(fromUser=fromUser,
rel_type=Relationship.FRIENDS,
status=Relationship.APPROVED)
for friend in friends:
rel = Relationship.get_relationship(friend.toUser, message.toUser)
if rel != "BLOCKED":
feed = Feed(user=friend.toUser, message=message).save()
return True
def block(to_username):
ref = request.referrer
logged_user = User.objects.filter(username=session.get('username')).first()
fetchNotifications(logged_user)
toUser = User.objects.filter(username=to_username).first()
if toUser:
rel = Relationship.get_relationship(logged_user, toUser)
if rel == "FRIENDS_PENDING" or rel == "FRIENDS_APPROVED" or rel == "REVERSE_FRIENDS_PENDING":
rel = Relationship.objects.filter(fromUser=logged_user,
toUser=toUser).delete()
reverse_rel = Relationship.objects.filter(
fromUser=toUser, toUser=logged_user).delete()
Relationship(fromUser=logged_user,
toUser=toUser,
rel_type=Relationship.BLOCKED,
status=Relationship.APPROVED).save()
if ref:
return redirect(ref)
else:
return redirect(
url_for('user_app.profile', username=toUser.username))
else:
abort(404)
def reject(user_id):
follower = User.get_by_id(user_id)
r = Relationship.get(Relationship.follower_id == user_id,
Relationship.following_id == current_user.id)
try:
if Task.get(Task.relationship_id == r.id):
t = Task.get(Task.relationship_id == r.id)
t.delete_instance()
except:
pass
r.delete_instance()
flash(f"You have rejected {follower.name}'s follow request.")
return redirect(url_for('users.show', username=current_user.username))
def follow(idol_id):
if current_user.is_authenticated:
fan = User.get_or_none(User.id == current_user.id)
idol = User.get_or_none(User.id == idol_id)
if fan and idol:
relationship = Relationship(fan=fan, idol=idol)
if not relationship.is_exist():
if idol.private:
# send_email(f"{fan.username} has followed you on nextagram! Approve follow request to allow profile view.")
pass
else:
relationship.status = "approve"
if relationship.save():
flash('Follow profile successful', 'alert alert-success')
return redirect(
url_for('users.show', id_or_username=idol.username))
else:
flash('Profile has been followed', 'alert alert-danger')
else:
flash('Follow profile failed', 'alert alert-danger')
return redirect(url_for('users.show', id_or_username=idol.username))
else:
flash('Log in required', 'alert alert-danger')
return redirect(url_for('home'))
def index():
if current_user.is_authenticated:
idols = (Relationship.select(Relationship.idol).where(
Relationship.fan == current_user.id,
Relationship.approved == True))
images = (
Image.select().where((Image.user.in_(idols))
| (Image.user == current_user.id)).order_by(
Image.created_at.desc()))
return render_template('users/index.html', images=images)
else:
return render_template('sessions/new.html')
def approve(user_id):
follower = User.get_by_id(user_id)
r = Relationship.get(Relationship.follower_id == user_id,
Relationship.following_id == current_user.id)
r.is_approved = True
if r.save():
flash(f"You have approved {follower.name}'s follow request.")
return redirect(url_for('users.show', username=follower.username))
else:
return render_template(
'users/show.html',
user=current_user,
photos=Image.select().where(Image.user_id == current_user.id),
errors=r.errors)
def unblock(toUsername):
ref = request.referrer
logged_user = User.objects.filter(username=session.get('username')).first()
fetchNotifications(logged_user)
toUser = User.objects.filter(username=toUsername).first()
if toUser:
rel = Relationship.get_relationship(logged_user, toUser)
if rel == "BLOCKED":
rel = Relationship.objects.filter(fromUser=logged_user,
toUser=toUser).delete()
if ref:
return redirect(ref)
else:
return redirect(
url_for('user_app.profile', username=toUser.username))
else:
abort(404)
def destroy(following_id):
following = User.get_by_id(following_id)
r = Relationship.get(Relationship.follower_id == current_user.id,
Relationship.following_id == following_id)
try:
if Task.get(Task.relationship_id == r.id):
t = Task.get(Task.relationship_id == r.id)
t.delete_instance()
except:
pass
r.delete_instance()
flash(f"You have unfollowed {following.name}.")
return render_template(
'users/show.html',
user=following,
photos=Image.select().where(Image.user_id == following.id))
