def chat(recipient):
chat_user = User.query.filter_by(username=recipient).first_or_404()
this_chat = current_user.mychats().filter(
or_(Chats.user1 == chat_user.id,
Chats.user2 == chat_user.id)).first() #Get chat if exists
if (this_chat): # Check if chat exists, if not make session None
session['chat_session'] = [this_chat.id, chat_user.id]
messages = this_chat.msgs.order_by(Messages.timestamp.asc())
for msg in this_chat.msgs.order_by(Messages.timestamp.desc()).limit(
current_user.unread_msgs(this_chat.id)
): #Get all the unread msgs and change its flag
if (msg.author != current_user):
msg.reciever_read = True
current_user.add_notification('unread_chats',
current_user.unread_chats())
db.session.commit()
return render_template('chat.html',
chat_user=chat_user,
title="Chat with " + recipient,
messages=messages)
else:
session['chat_session'] = ['None', chat_user.id]
return render_template('chat.html',
chat_user=chat_user,
title="Chat with " + recipient,
messages='None')
def messages():
current_user.last_message_read_time = datetime.utcnow()
db.session.commit()
current_user.add_notification('unread_message_count', 0)
messages = current_user.messages_received.order_by(
Message.timestamp.desc())
return render_template('message.html', messages=messages)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification(current_app.config['UNREAD_MESSAGE_COUNT'],
0)
db.session.commit()
page = _get_page_num()
messages = current_user.received_messages\
.order_by(Message.timestamp.desc())\
.paginate(page, current_app.config['POSTS_PER_PAGE'], False)
next_url, prev_url = _get_paginate_url(messages, 'main.messages')
pager = {
'next_url': next_url,
'prev_url': prev_url,
'total': messages.total,
'page': page,
'page_count':
ceil(messages.total / current_app.config['POSTS_PER_PAGE'])
}
return render_template('messages.html',
pager=pager,
messages=messages.items)
def messages():
current_user.add_notification('unread_message_count',
current_user.new_messages_count())
db.session.commit()
page = request.args.get('page', 1, type=int)
q = current_user.threads.filter(Thread.messages != None).order_by(
Thread.last_updated.desc())
threads = q.all()[:current_app.config['POSTS_PER_PAGE']]
threadIDs = []
for thread in threads:
members = User.query.filter(
User.threads.any(Thread.id == thread.id)).all()
if len(members) == 2 and current_user in members:
members.remove(current_user)
threadIDs.append(members[0].username)
else:
threadIDs.append(thread.id)
threads = q.paginate(page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('messages.messages', page=threads.next_num) \
if threads.has_next else None
prev_url = url_for('messages.messages', page=threads.prev_num) \
if threads.has_prev else None
return render_template('messages/messages.html',
threadIDs_threads=zip(threadIDs, threads.items),
next_url=next_url,
prev_url=prev_url)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
form = EditProfileForm(current_user.username)
if form.validate_on_submit():
current_user.username = form.username.data
current_user.about_me = form.about_me.data
db.session.commit()
flash(_('Your changes have been saved.'))
return redirect(url_for('main.user', username=username))
elif request.method == 'GET':
form.username.data = current_user.username
form.about_me.data = current_user.about_me
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.messages', page=messages.next_num) \
if messages.has_next else None
prev_url = url_for('main.messages', page=messages.prev_num) \
if messages.has_prev else None
return render_template('messages.html',
user=current_user,
messages=messages.items,
form=form,
next_url=next_url,
prev_url=prev_url)
def view_messages():
teacher = Teacher.query.filter_by(
teacher_full_name=current_user.teacher_full_name
).first()
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
TeacherMessage.timestamp.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for(
'teacher.view_messages',
page=messages.next_num,
_anchor="messages") \
if messages.has_next else None
prev_url = url_for(
'teacher.view_messages',
page=messages.prev_num,
_anchor="messages") \
if messages.has_prev else None
return render_template(
'teacher/private_messages/view_private_messages.html',
messages=messages.items,
title='View Private Messages',
next_url=next_url,
prev_url=prev_url,
teacher=teacher
)
def index():
current_user.add_notification('new_post_added', 0)
db.session.commit()
form = PostForm()
comment_form = CommentForm()
if form.validate_on_submit():
post = Post(title=form.title.data,
body=form.post.data,
author=current_user)
current_user.notify_followers("new_post_added", 1)
db.session.add(post)
db.session.commit()
flash(_("Your post is now live!"), "success")
return redirect(url_for("main.index"))
page = request.args.get("page", 1, type=int)
posts = current_user.followed_posts().paginate(
page, current_app.config["POSTS_PER_PAGE"], False)
next_url = url_for("main.index",
page=posts.next_num) if posts.has_next else None
prev_url = url_for("main.index",
page=posts.prev_num) if posts.has_prev else None
return render_template(
"index.html",
title="Home",
posts=posts.items,
form=form,
comment_form=comment_form,
user=current_user,
next_url=next_url,
prev_url=prev_url,
)
def inbox():
current_user.last_inbox_read_time = datetime.utcnow()
current_user.add_notification('unread_inbox_message_count', 0)
db.session.commit()
messages = current_user.get_messages_from_inbox() or [] # nanti dibuat paginate?
if not messages:
flash('Your inbox is empty.', 'info') # info
return render_template('inbox.html', title='Inbox', messages=messages)
def reject_user(username):
if current_user.is_admin:
User.query.filter_by(username=username, is_active=False).delete()
db.session.commit()
current_user.add_notification('registration_request',
current_user.new_requests())
db.session.commit()
return jsonify(message='Utente rimosso')
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification("unread_message_count", 0)
db.session.commit()
page = request.args.get("page", 0, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc()).group_by(Message.sender_id)
return render_template("publisher/messages.html", messages=messages)
def notifs():
current_user.last_notifs_read_time = datetime.utcnow()
current_user.add_notification('unread_notifs_count', 0)
db.session.commit()
comments = current_user.comments_received.filter(
Comment.commenter_id != current_user.id).order_by(
Comment.created_utc.desc()).all()
return render_template('users/notifs.html', comments=comments)
def bookings():
current_user.last_booking_read_time = datetime.utcnow()
current_user.add_notification("unread_booking_count", 0)
db.session.commit()
bookings = (Booking.query.join(
Listing, (Listing.id == Booking.listing_id)).filter(
Listing.publisher_id == current_user.id).order_by(
Booking.createdAt.desc()).all())
return render_template("publisher/bookings.html", bookings=bookings)
def view_messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_messages', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
current_user_messages = current_user.messages_received.order_by(
Message.date_read.desc())
return render_template('user/view_messages.html',
current_user_messages=current_user_messages)
def message():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('uread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc())
threads = Thread.query.order_by(Thread.date_created.desc()).all()
return render_template('messages.html', messages=messages, threads=threads)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
pagination = current_user.messages_received.order_by(Message.timestamp.desc()) \
.paginate(page, current_app.config['POSTS_PER_PAGE'], False)
messages = pagination.items
return render_template('messages.html', messages=messages, pagination=pagination, endpoint='main.messages')
def messages():
current_user.last_message_read_time=datetime.utcnow()
current_user.add_notification('unread_message_count',0)
db.session.commit()
page=request.args.get('page',1,type=int)
messages=current_user.messages_received.order_by(Message.timestamp.desc()).paginate(page,current_app.config['POSTS_PER_PAGE'],False)
next_url=url_for('main.messages',page=messages.next_num) if messages.has_next else None
prev_url=url_for('main.messages',page=messages.prev_num) if messages.has_prev else None
return render_template('messages.html',messages=messages.items,next_url=next_url,prev_url=prev_url)
def messages_read(token):
msg = Message.query.filter_by(token=token).first()
if msg:
msg.readStatus()
current_user.add_notification('unopened_messages',
current_user.unread_messages())
db.session.add(msg)
db.session.commit()
return render_template('message_view.html', message=msg)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification("unread_message_count", 0)
db.session.commit()
messages = current_user.messages_received.order_by(
Message.timestamp.desc())
pagination = paginate_posts(messages,
redirect_to="main.messages",
paginate_item="messages")
return render_template("messages.html", **pagination)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
messages = current_user.messages_received
messages_out = current_user.messages_sent
return render_template('user/messages.html',
messages=messages,
messages_out=messages_out)
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc()
).paginate(page, 5, False)
return render_template('messages.html', messages=messages)
def accept_user(username):
if current_user.is_admin:
user = User.query.filter_by(username=username, is_active=False).first()
if user is None:
return jsonify(message='Username errato o mancante')
else:
user.is_active = True
db.session.commit()
current_user.add_notification('registration_request',
current_user.new_requests())
db.session.commit()
return jsonify(message='Utente accettato')
def like_action(id, action):
post = Post.query.filter_by(id=id).first_or_404()
if action == 'like':
current_user.like_post(post)
current_user.add_notification(
current_user.username + ' just liked your post',
current_user.has_liked_post(post))
db.session.commit()
if action == 'unlike':
current_user.unlike_post(post)
db.session.commit()
return redirect(request.referrer)
def notifications(page_num):
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification("unread_message_count", 0)
db.session.commit()
messages = current_user.messages_received.order_by(
Message.timestamp.desc()).paginate(
page=page_num,
per_page=current_app.config["ELEMENTS_PER_PAGE"],
error_out=False)
return render_template("users/notifications.html", messages=messages)
def messages():
'''allows the user to view private messages which have been sent to them'''
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit() #resets the users unseen message count back to zero
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
return render_template('messages.html',
messages=messages.items,
pages=messages.pages)
def dialog(recipient, timestamp=None):
user = User.query.filter_by(username=recipient).first_or_404()
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
# mind last seen message
if timestamp:
timestamp = datetime.strptime(timestamp, '%Y-%m-%d %H:%M:%S.%f')
else:
timestamp = datetime(1970, 1, 1)
# get all dialog messages
messages = Message.query.filter_by(
author=user, recipient=current_user).union(
Message.query.filter_by(
author=current_user, recipient=user)).filter(
Message.timestamp > timestamp).order_by(
Message.timestamp.asc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.messages',
page=messages.next_num) if messages.has_next else None
prev_url = url_for('main.messages',
page=messages.prev_num) if messages.has_prev else None
if not user.get_room(current_user):
room = Room(author=current_user, recipient=user)
db.session.add(room)
db.session.commit()
session['name'] = current_user.username
session['room'] = current_user.get_room(user).id
if request.path.split('/')[-1] == 'chat':
return render_template('_chat.html',
title=_('Send Message'),
recipient=recipient,
messages=messages.items,
room=session['room'],
name=session['name'])
else:
return render_template('dialog.html',
title=_('Send Message'),
recipient=recipient,
messages=messages.items,
room=session['room'],
name=session['name'])
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
messages = current_user.messages_received.order_by(
Message.timestamp.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.messages', page=messages.next_num) \
if messages.has_next else None
prev_url = url_for('main.messages', page=messages.prev_num) \
if messages.has_prev else None
return render_template('messages.html', messages=messages.items,
next_url=next_url, prev_url=prev_url)
def follow(username):
user = User.query.filter_by(username=username).first()
if user is None:
flash('Invalid user!', 'warning')
return redirect(url_for('main.home'))
if current_user.is_following(user):
flash('You are already following this user!', 'warning')
return redirect(url_for('.account', username=user.username))
current_user.follow(user)
current_user.add_notification(name=user.username + ' just followed you',
data=current_user.follow(user))
db.session.commit()
flash('You are now following %s.' % user.username, 'success')
return redirect(url_for('main.account', username=user.username))
def messages():
current_user.last_message_read_time = datetime.utcnow()
current_user.add_notification('unread_message_count', 0)
current_user.add_notification('new_message', {'state': 0})
db.session.commit()
form = MessageForm()
page = request.args.get('page', 1, type=int)
per_page = current_app.config['POSTS_PER_PAGE']
messages = current_user.messages_received.union(
current_user.messages_sent).order_by(Message.timestamp.desc())
# messages = current_user.messages_received.order_by(
# Message.timestamp.desc()).paginate(
# page, per_page, False)
messages_dict = OrderedDict()
for message in messages:
if message.author.id == current_user.id:
if message.recipient.id not in messages_dict.keys():
messages_dict[message.recipient.id] = {
'username': message.recipient.username,
'messages': [message],
'pagination': 0
}
else:
messages_dict[message.recipient.id]['messages'].append(message)
else:
if message.author.id not in messages_dict.keys():
messages_dict[message.author.id] = {
'username': message.author.username,
'messages': [message],
'pagination': 0
}
else:
messages_dict[message.author.id]['messages'].append(message)
## No pagination for this new version of messages page
# if page == 1:
# first_this_page = 1
# last_this_page = len(messages.items)
# else:
# first_this_page = ((page - 1) * per_page) + 1
# last_this_page = first_this_page + len(messages.items) - 1
# pagination = Pagination(page=page, total=messages.total, search=False, per_page=per_page, bs_version=4,
# display_msg=_('displaying %(first_this_page)d - %(last_this_page)d records of %(total)d',
# first_this_page=first_this_page, last_this_page=last_this_page,
# total=messages.total))
# return render_template('messages.html', title=_('Messages'),
# messages=messages.items, pagination=pagination)
return render_template('messages.html',
title=_('Messages'),
form=form,
messages=messages_dict.items())
def alerts():
current_user.add_notification('unread_alerts_count',
current_user.new_alerts_count())
db.session.commit()
page = request.args.get('page', 1, type=int)
threads = current_user.threads.filter(Thread.alerts != None).order_by(
Thread.last_updated.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('messages.alerts', page=threads.next_num) \
if threads.has_next else None
prev_url = url_for('messages.alerts', page=threads.prev_num) \
if threads.has_prev else None
return render_template('messages/alerts.html',
threads=threads.items,
next_url=next_url,
prev_url=prev_url)
def view_message(thread_id: str):
current_user.add_notification('unread_message_count',
current_user.new_messages_count())
db.session.commit()
form = MessageForm()
if isint(thread_id):
thread = current_user.threads.filter_by(id=thread_id).first_or_404()
else:
recipient = User.query.filter_by(username=thread_id).first_or_404()
thread = recipient.threads.intersect(current_user.threads).first()
if not thread:
thread = Thread()
db.session.add(thread)
recipient.add_thread(thread)
recipient.add_notification('unread_message_count',
recipient.new_messages_count())
current_user.add_thread(thread)
db.session.commit()
return redirect(
url_for('messages.view_message', thread_id=recipient.username))
recipients = User.query.filter(User.id != current_user.id).filter(
User.threads.any(Thread.id == thread.id)).all()
for message in thread.messages:
if not message.get_read_time(current_user):
message.set_read_time(current_user, datetime.utcnow())
if form.validate_on_submit():
thread.last_updated = datetime.utcnow()
for recipient in recipients:
msg = Message(sender=current_user,
thread=thread,
body=form.message.data)
db.session.add(msg)
msg.add_recipient(recipient)
recipient.add_notification('unread_message_count',
recipient.new_messages_count())
db.session.commit()
flash('Your message has been sent.')
return redirect(url_for('messages.view_message', thread_id=thread.id))
return render_template('messages/view_message.html',
thread=thread,
recipients=recipients,
form=form)
def view_messages():
"""Render view message page."""
current_user.LastMessageReadTime = datetime.utcnow()
current_user.add_notification('unread_message', 0)
db.session.commit()
page = request.args.get('page', 1, type=int)
messages = current_user.MessageReceived.order_by(
UserMessages.Timestamp.desc()).paginate(page,
app.config['POSTS_PER_PAGE'],
False)
next_url = url_for('view_messages', page=messages.next_num) \
if messages.has_next else None
prev_url = url_for('view_messages', page=messages.prev_num) \
if messages.has_prev else None
return render_template('view_messages.html',
messages=messages.items,
next_url=next_url,
prev_url=prev_url)
