def login_route():
if request.method == 'GET':
form = LoginForm()
return render_template("login.html",
title="Login Page",
form=form,
successful=True)
elif request.method == 'POST':
form = LoginForm()
username = form.username.data
password = crypto.hash_password(form.password.data)
user = User.query.filter_by(username=username,
password=password).first()
if user:
user.last_login = timestamp()
user.last_login_ip = request.remote_addr
user.language = get_cookie('language', user.language)
db.session.add(user)
db.session.commit()
login_user(user, remember=form.remember.data, force=True)
next_page = get_arg_or_none('next')
return redirect(next_page) if next_page else redirect(
url_for('index_route'))
else:
flash(gettext("Incorrect login!"), "danger")
return render_template("login.html",
title="Login Page",
form=form,
successful=True)
else:
abort(403)
def register_route():
if request.method == 'GET':
form = RegistrationForm()
return render_template("register.html",
title="Register Page",
form=form)
elif request.method == 'POST':
form = RegistrationForm()
if form.validate_on_submit():
username = form.username.data
password = crypto.hash_password(form.password.data)
email = form.email.data
register_time = timestamp(),
last_login = register_time
user = User(username=username,
password=password,
email=email,
register_time=register_time,
last_login=last_login,
last_login_ip=request.remote_addr,
city=form.city.data)
db.session.add(user)
db.session.commit()
login_user(user, force=True)
flash(
gettext(
'Account created! Please fill additional information.'),
'success')
return redirect(url_for('profile_route', action='edit'))
else:
return render_template("register.html",
title="Register Page",
form=form)
else:
abort(403)
def add(user_id: int, chat_id: int):
if ChatNotification.get_or_none(user_id, chat_id) is None:
tmp = ChatNotification(user_id=user_id,
chat_id=chat_id,
time=timestamp())
db.session.add(tmp)
db.session.commit()
def add_member(self, user):
from libs.models.GroupMember import GroupMember
if user.id not in self.get_members():
new_row = GroupMember(user_id=user.id,
group_id=self.id,
time=timestamp())
db.session.add(new_row)
db.session.commit()
def add_member(self, id: int, is_group=True):
from libs.models.ChatMember import ChatMember
if id not in [i.id for i in self.get_members()]:
new = ChatMember(user_id=id,
chat_id=self.id,
is_group=is_group,
time=timestamp())
db.session.add(new)
db.session.commit()
def handle_new_group_chat(msg):
name = msg.get('name')
group_id = int(msg.get('group_id'))
chat = Chat(name=name, admin_id=current_user.id, time=timestamp(), group_id=group_id)
db.session.add(chat)
db.session.commit()
chat_member = ChatMember(user_id=current_user.id, chat_id=chat.id, is_group=True)
db.session.add(chat_member)
db.session.commit()
emit('new_group_chat_ack', 'ack', room=sessions.get_or_404(current_user.id))
def add(type: InvitationType,
recipient_id: int,
referrer_id: int,
expiration_time=None) -> int:
if len(
Invitation.query.filter(
(Invitation.recipient_id == recipient_id)
& (Invitation.referrer_id == referrer_id)
& (Invitation.type == type)
& ((Invitation.expiration_time == None) |
(Invitation.expiration_time > timestamp()))).all()) > 0:
return -1
invitation = Invitation(type=type,
recipient_id=recipient_id,
referrer_id=referrer_id,
creation_time=timestamp(),
expiration_time=expiration_time)
db.session.add(invitation)
db.session.commit()
return invitation.id
def add(first_id: int, second_id: int):
if second_id < first_id:
first_id, second_id = second_id, first_id
if Friend.query.filter_by(first_id=first_id,
second_id=second_id).first() is not None:
return
record = Friend(first_id=first_id,
second_id=second_id,
time=timestamp())
db.session.add(record)
db.session.commit()
def add_member(self, user):
from libs.models.EventMember import EventMember
res = EventMember.query.filter_by(event_id=self.id,
user_id=user.id).first()
if res is not None:
return
new_member = EventMember(event_id=self.id,
user_id=user.id,
time=timestamp())
db.session.add(new_member)
db.session.commit()
class ChatMember(db.Model):
__tablename__ = 'chat_members'
user_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
chat_id = db.Column(db.BigInteger,
db.ForeignKey('chats.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, default=timestamp())
is_group = db.Column(db.Boolean, default=False)
deleted = db.Column(db.TIMESTAMP, default=None)
__table_args__ = (db.PrimaryKeyConstraint('user_id', 'chat_id'), )
def __eq__(self, other):
return self.user_id == other.user_id and self.chat_id == other.chat_id
def __repr__(self):
return f"ChatMember: {self.user}, {self.chat}"
@staticmethod
def get_private_chat(first_id, second_id):
first_id = int(first_id)
second_id = int(second_id)
first_chats = ChatMember.query.filter_by(user_id=first_id,
is_group=False).all()
second_chats = ChatMember.query.filter_by(user_id=second_id,
is_group=False).all()
chat = []
for i in first_chats:
for j in second_chats:
if i.chat_id == j.chat_id:
chat.append(i)
if len(chat) > 1:
return chat
elif len(chat) == 1:
return chat[0].chat
else:
return None
@staticmethod
def get_user_chats(user_id):
user_id = int(user_id)
return [
i.chat for i in list(
filter(
lambda x: x.deleted is None or
(x.chat.last_message is not None and x.deleted < x.chat.
last_message.time),
ChatMember.query.filter_by(user_id=user_id).all()))
]
def group_chats_route():
# TODO permissions to show
action = get_arg_or_400('action')
if action == 'all':
group_id = get_arg_or_400('id', to_int=True)
chats = Chat.query.filter_by(group_id=group_id, deleted=None).all()
return render_template("group_chats.html",
chats=chats,
group=Group.get_or_404(group_id),
notification=current_user.get_notifications())
chat_id = get_arg_or_400('chat_id', to_int=True)
chat = Chat.get_or_404(chat_id)
if action == 'delete':
chat.deleted = timestamp()
members = ChatMember.query.filter_by(chat_id=chat_id).all()
for member in members:
member.deleted = timestamp()
db.session.commit()
return redirect(request.referrer)
elif action == 'show':
group = Group.get_or_404(chat.group_id)
chat.add_member(id=current_user.id)
ChatNotification.remove(user_id=current_user.id, chat_id=chat_id)
return render_template("chat.html",
group=group,
chat=chat,
current_user=current_user,
messages=chat.get_history())
elif action == 'add_members':
abort(400)
else:
abort(400)
class EventMember(db.Model):
__tablename__ = "event_members"
event_id = db.Column(db.BigInteger,
db.ForeignKey('events.id'),
nullable=False)
user_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, default=timestamp())
__table_args__ = (db.PrimaryKeyConstraint('event_id', 'user_id'), )
def __repr__(self):
return f"Event {self.event_id}: {self.user}"
class GroupMember(db.Model):
user_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
group_id = db.Column(db.BigInteger,
db.ForeignKey('groups.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, nullable=False, default=timestamp())
__tablename__ = "group_members"
__table_args__ = (db.PrimaryKeyConstraint('user_id', 'group_id'), )
def __repr__(self):
return f"GroupMember: {self.user} -> {self.group}"
class ChatNotification(db.Model):
__tablename__ = 'notifications'
user_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
chat_id = db.Column(db.BigInteger,
db.ForeignKey('chats.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, default=timestamp())
__table_args__ = (db.PrimaryKeyConstraint('user_id', 'chat_id'), )
def __repr__(self):
return f"ChatNotification: {self.user}, {self.chat}, time = {self.time}"
@staticmethod
def get_or_404(user_id: int, chat_id: int):
notification = ChatNotification.query.filter_by(
user_id=user_id, chat_id=chat_id).first()
if notification is None:
abort(404)
return notification
@staticmethod
def get_or_none(user_id: int, chat_id: int):
return ChatNotification.query.filter_by(user_id=user_id,
chat_id=chat_id).first()
@staticmethod
def get_notifications(user_id: int):
return ChatNotification.query.filter_by(user_id=user_id).all()
@staticmethod
def remove(user_id: int, chat_id: int):
ChatNotification.query.filter_by(user_id=user_id,
chat_id=chat_id).delete()
db.session.commit()
@staticmethod
def add(user_id: int, chat_id: int):
if ChatNotification.get_or_none(user_id, chat_id) is None:
tmp = ChatNotification(user_id=user_id,
chat_id=chat_id,
time=timestamp())
db.session.add(tmp)
db.session.commit()
class Friend(db.Model):
__tablename__ = "friends"
first_id = db.Column(db.BigInteger,
db.ForeignKey("users.id"),
nullable=False)
second_id = db.Column(db.BigInteger,
db.ForeignKey("users.id"),
nullable=False)
time = db.Column(db.TIMESTAMP, nullable=False, default=timestamp())
__table_args__ = (db.PrimaryKeyConstraint('first_id', 'second_id'), )
@staticmethod
def add(first_id: int, second_id: int):
if second_id < first_id:
first_id, second_id = second_id, first_id
if Friend.query.filter_by(first_id=first_id,
second_id=second_id).first() is not None:
return
record = Friend(first_id=first_id,
second_id=second_id,
time=timestamp())
db.session.add(record)
db.session.commit()
@staticmethod
def remove(first_id: int, second_id: int):
if second_id < first_id:
first_id, second_id = second_id, first_id
if Friend.query.filter_by(first_id=first_id,
second_id=second_id).first() is None:
return
record = Friend.query.filter_by(first_id=first_id,
second_id=second_id).first()
db.session.delete(record)
db.session.commit()
def __repr__(self):
return f"Friend: {self.first} <-> {self.second}"
class Message(db.Model):
__tablename__ = 'messages'
id = db.Column(db.BigInteger, nullable=False, primary_key=True, autoincrement=True)
chat_id = db.Column(db.BigInteger, db.ForeignKey('chats.id'), nullable=False)
user_id = db.Column(db.BigInteger, db.ForeignKey('users.id'), nullable=False)
time = db.Column(db.TIMESTAMP, default=timestamp())
is_read = db.Column(db.Boolean, default=False)
content = db.Column(db.JSON, default=json.dumps({'photos': [], 'audios': [], 'videos': [], 'map_pins': []}))
text = db.Column(db.VARCHAR(1000), default="")
chat_last_msg_rel = db.relationship(
'Chat',
backref='last_message',
lazy=True,
primaryjoin="Message.id==Chat.last_msg_id"
)
@staticmethod
def get_or_404(id: int):
message = Message.query.get(id)
if message is None:
abort(404)
return message
@staticmethod
def get_or_none(id: int):
return Message.query.get(id)
@staticmethod
def has_id(id: int) -> bool:
return Message.query.get(id) is None
@staticmethod
def get_history(chat_id: int, limit: int = 50):
return Message.query.filter_by(chat_id=chat_id).order_by(Message.time).limit(limit).all()
def __repr__(self):
return f"Message: from {self.user.username}: {self.text} || {'+' if self.is_read else '-'}"
def handle_msg(msg):
text = msg.get('text')
# current_user - от кого пришло сообщение
try:
user_id = int(msg.get('user_id'))
chat_id = int(msg.get('chat_id'))
except TypeError as e:
logging.error(e)
return
# TODO добавить контент
message = Message(id=get_rand(), chat_id=chat_id, user_id=user_id,
time=timestamp(), text=text)
members = Chat.get_or_404(chat_id).get_members()
for i in members:
if i.id != user_id:
ChatNotification.add(chat_id=chat_id, user_id=i.id)
db.session.add(message)
db.session.commit()
chat = Chat.get_or_404(chat_id)
if chat is not None and not chat.deleted:
members = chat.get_members()
chat.update_last_msg(message)
for user in members:
if user.id != user_id:
session = sessions.get_or_404(user.id)
if session:
emit(
'message',
json.dumps({
'text': text,
'message_id': message.id,
'username': User.get_or_404(user_id).username,
'chat_id': chat_id, 'user_id': user_id
}),
room=session
)
else:
abort(404)
def get_all_for_group(group_id: int) -> list:
return Invitation.query\
.filter((Invitation.type == InvitationType.TO_GROUP)
& (Invitation.recipient_id == group_id)
& ((Invitation.expiration_time == None) | (Invitation.expiration_time > timestamp()))).all()
class User(db.Model, UserMixin):
# from libs.Group import Group
# from libs.GroupMember import GroupMember
from libs.models.Friend import Friend
from libs.models.Chat import Chat
from libs.models.EventMember import EventMember
from libs.models.PlayTime import PlayTime
from libs.models.UserVideos import UserVideos
# from libs.ChatMember import ChatMember
# from libs.ChatNotification import ChatNotification
# from libs.Message import Message
# from libs.Event import Event
# from libs.EventMember import EventMember
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), nullable=True)
last_name = db.Column(db.String(40), nullable=True)
age = db.Column(db.Integer)
gender = db.Column(db.String, nullable=True)
sport = db.Column(db.ARRAY(db.String))
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
register_time = db.Column(db.TIMESTAMP, default=timestamp())
last_login = db.Column(db.TIMESTAMP, nullable=False, default=timestamp())
image_file = db.Column(db.String, nullable=False, default='default.jpg')
last_login_ip = db.Column(db.String)
language = db.Column(db.String, nullable=False, default="en")
city = db.Column(db.String(50), nullable=True)
groups_rel = db.relationship('Group', backref='admin', lazy=True)
members_rel = db.relationship('GroupMember', backref='user', lazy=True)
friends_rel_1 = db.relationship('Friend',
backref='first',
lazy=True,
primaryjoin="User.id==Friend.first_id")
friends_rel_2 = db.relationship('Friend',
backref='second',
lazy=True,
primaryjoin="User.id==Friend.second_id")
chat_admin_rel = db.relationship('Chat', backref='admin', lazy=True)
chat_member_rel = db.relationship('ChatMember', backref='user', lazy=True)
message_rel = db.relationship('Message', backref='user', lazy=True)
notification_rel = db.relationship('ChatNotification',
backref='user',
lazy=True)
event_member_rel = db.relationship('EventMember',
backref='user',
lazy=True)
event_rel = db.relationship('Event', backref='creator', lazy=True)
play_time_rel = db.relationship('PlayTime', backref='user', lazy=True)
user_sport_videos_rel = db.relationship('UserVideos',
backref='user',
lazy=True)
__tablename__ = "users"
def __repr__(self):
return f"User {self.id}: {self.username}, {self.name}, {self.last_name}, {self.gender})"
@staticmethod
def get_or_404(id: int):
user = User.query.get(int(id))
if user is None:
abort(404)
return user
@staticmethod
def get_or_none(id: int):
return User.query.get(int(id))
def friend_add(self, friend_id: int):
from libs.models.Friend import Friend
Friend.add(self.id, int(friend_id))
def friend_remove(self, friend_id: int):
from libs.models.Friend import Friend
Friend.remove(self.id, int(friend_id))
def friends_get(self) -> list:
from libs.models.Friend import Friend
first = Friend.query.filter_by(first_id=self.id).all()
first_set = set(map(lambda y: User.get_or_none(y.second_id), first))
second = Friend.query.filter_by(second_id=self.id).all()
second_set = set(map(lambda y: User.get_or_none(y.first_id), second))
return list(first_set.union(second_set))
def get_groups(self):
return [
i.group
for i in GroupMember.query.filter_by(user_id=self.id).all()
]
def get_chats(self):
from libs.models.ChatMember import ChatMember
return list(
filter(lambda x: x.deleted is None, [
i.chat for i in
ChatMember.query.filter(ChatMember.user_id == self.id
and ChatMember.deleted is None).all()
]))
def get_notifications(self):
from libs.models.ChatNotification import ChatNotification
return [i.chat for i in ChatNotification.get_notifications(self.id)]
def is_notified(self):
return len(self.get_notifications()) != 0
def get_events(self):
from libs.models.EventMember import EventMember
return [
i.event
for i in EventMember.query.filter_by(user_id=self.id).all()
]
def get_invitations(self):
from libs.models.Invitation import Invitation
return Invitation.query.filter_by(recipient_id=self.id).all()
def has_invitations(self):
return len(list(filter(lambda i: not i.read,
self.get_invitations()))) > 0
class Invitation(db.Model):
__tablename__ = "invitation"
# TODO relationship with Users
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
type = db.Column(db.Integer, nullable=False)
recipient_id = db.Column(db.Integer, nullable=False)
referrer_id = db.Column(db.Integer, nullable=False)
creation_time = db.Column(db.TIMESTAMP,
nullable=False,
default=timestamp())
expiration_time = db.Column(db.TIMESTAMP, nullable=True)
read = db.Column(db.Boolean, default=False)
def __repr__(self):
return f"Invitation: {self.type}, '{self.referrer_id}', '{self.expiration_time}')"
@staticmethod
def get_or_404(id: int):
invitation = Invitation.query.get(id)
if invitation is None:
abort(404)
return invitation
@staticmethod
def get_or_none(id: int):
return Invitation.query.get(id)
def is_expired(self):
return self.expiration_time is not None and self.expiration_time > timestamp(
)
def get_referrer(self):
from libs.models.User import User
from libs.models.Group import Group
from libs.models.Event import Event
if self.type in EVENTS_FROM_USER:
return User.get_or_404(self.referrer_id)
elif self.type == InvitationType.FROM_GROUP:
return Group.get_or_404(self.referrer_id)
elif self.type == InvitationType.FROM_EVENT:
return Event.get_or_404(self.referrer_id)
else:
return None
def get_recipient(self):
from libs.models.User import User
from libs.models.Group import Group
from libs.models.Event import Event
if self.type == InvitationType.FRIEND or \
self.type == InvitationType.FROM_EVENT or \
self.type == InvitationType.FROM_GROUP:
return User.get_or_404(self.recipient_id)
elif self.type == InvitationType.TO_GROUP:
return Group.get_or_404(self.recipient_id)
elif self.type == InvitationType.TO_EVENT:
return Event.get_or_404(self.recipient_id)
@staticmethod
def add(type: InvitationType,
recipient_id: int,
referrer_id: int,
expiration_time=None) -> int:
if len(
Invitation.query.filter(
(Invitation.recipient_id == recipient_id)
& (Invitation.referrer_id == referrer_id)
& (Invitation.type == type)
& ((Invitation.expiration_time == None) |
(Invitation.expiration_time > timestamp()))).all()) > 0:
return -1
invitation = Invitation(type=type,
recipient_id=recipient_id,
referrer_id=referrer_id,
creation_time=timestamp(),
expiration_time=expiration_time)
db.session.add(invitation)
db.session.commit()
return invitation.id
@staticmethod
def get_all_for_event(event_id: int) -> list:
return Invitation.query.filter(
(Invitation.type == InvitationType.TO_EVENT)
& (Invitation.recipient_id == event_id)
& ((Invitation.expiration_time == None)
| (Invitation.expiration_time > timestamp()))).all()
@staticmethod
def get_all_from_event(event_id: int) -> list:
return Invitation.query.filter(
(Invitation.type == InvitationType.FROM_EVENT)
& (Invitation.referrer_id == event_id)
& ((Invitation.expiration_time == None)
| (Invitation.expiration_time > timestamp()))).all()
@staticmethod
def get_all_for_group(group_id: int) -> list:
return Invitation.query\
.filter((Invitation.type == InvitationType.TO_GROUP)
& (Invitation.recipient_id == group_id)
& ((Invitation.expiration_time == None) | (Invitation.expiration_time > timestamp()))).all()
def accept(self):
from libs.models.User import User
from libs.models.Group import Group
from libs.models.Event import Event
if self.is_expired():
pass
elif self.type == InvitationType.FRIEND:
referrer: User = self.get_referrer()
referrer.friend_add(self.recipient_id)
elif self.type == InvitationType.FROM_GROUP:
referrer: Group = self.get_referrer()
recipient: User = self.get_recipient()
referrer.add_member(recipient)
elif self.type == InvitationType.FROM_EVENT:
referrer: Event = self.get_referrer()
recipient: User = self.get_recipient()
referrer.add_member(recipient)
elif self.type == InvitationType.TO_GROUP:
referrer: User = self.get_referrer()
recipient: Group = self.get_recipient()
recipient.add_member(referrer)
elif self.type == InvitationType.TO_EVENT:
referrer: User = self.get_referrer()
recipient: Event = self.get_recipient()
recipient.add_member(referrer)
db.session.delete(self)
db.session.commit()
def reject(self):
db.session.delete(self)
db.session.commit()
class Chat(db.Model):
from libs.models.ChatMember import ChatMember
from libs.models.ChatNotification import ChatNotification
from libs.models.Message import Message
__tablename__ = 'chats'
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
name = db.Column(db.VARCHAR(100), nullable=True)
admin_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, default=timestamp())
last_msg_id = db.Column(db.BigInteger,
db.ForeignKey('messages.id'),
nullable=True)
group_id = db.Column(db.BigInteger,
db.ForeignKey('groups.id'),
nullable=True) # is_group
deleted = db.Column(db.TIMESTAMP, nullable=True, default=None)
chat_member_rel = db.relationship('ChatMember', backref='chat', lazy=True)
message_rel = db.relationship('Message',
backref='chat',
lazy=True,
primaryjoin="Chat.id==Message.chat_id")
notification_rel = db.relationship('ChatNotification',
backref='chat',
lazy=True)
def __repr__(self):
return f"{'GroupChat' if self.group_id else 'Chat'}: {self.name}, {self.admin}" + \
" deleted" if self.deleted else ""
@staticmethod
def get_or_404(id: int):
chat = Chat.query.get(id)
if chat is None:
abort(404)
return chat
@staticmethod
def get_or_none(id: int):
return Chat.query.get(id)
def get_history(self):
from libs.models.Message import Message
return Message.get_history(self.id)
def get_members(self):
from libs.models.ChatMember import ChatMember
return [
i.user for i in ChatMember.query.filter_by(chat_id=self.id,
deleted=None).all()
]
def add_member(self, id: int, is_group=True):
from libs.models.ChatMember import ChatMember
if id not in [i.id for i in self.get_members()]:
new = ChatMember(user_id=id,
chat_id=self.id,
is_group=is_group,
time=timestamp())
db.session.add(new)
db.session.commit()
def update_last_msg(self, message):
self.last_msg_id = message.id
db.session.commit()
def get_new_messages(self, user_id=None):
from libs.models.Message import Message
if user_id is None:
return Message.query.filter_by(chat_id=self.id,
is_read=False).all()
else:
return list(
filter(
lambda x: x.user_id != user_id,
Message.query.filter_by(chat_id=self.id,
is_read=False).all()))
elif action == 'new':
new_event_form = EditEventForm(groups=filter_not_none(current_user.get_groups()))
if new_event_form.validate_on_submit():
closed = new_event_form.closed.data
name = new_event_form.name.data
description = new_event_form.description.data
sport = new_event_form.sport.data
group_id = new_event_form.assigned_group.data
group_id = None if group_id == "None" or group_id is None else int(group_id)
recurring = new_event_form.recurring.data
new_event = Event(
name=name,
description=description,
sport=sport,
group_id=group_id,
creation_time=timestamp(),
creator_id=current_user.id,
closed=closed,
recurring=recurring
)
db.session.add(new_event)
db.session.commit()
new_event_member = EventMember(event_id=new_event.id, user_id=current_user.id, time=timestamp())
db.session.add(new_event_member)
db.session.commit()
return redirect(url_for('event_route', action='show', event_id=new_event.id))
else:
return render_template("new_event.html", form=new_event_form, map=get_loc_map())
elif action == 'search':
search_event_form = SearchEventForm()
name = search_event_form.name.data
def chats_route():
action = get_arg_or_400('action')
if action == 'show':
chat_id = get_arg_or_none('chat_id', to_int=True)
user_id = get_arg_or_none('user_id', to_int=True) # С кем чат
if user_id is None:
if chat_id is None:
return redirect(url_for('chat', action='all'))
chat = Chat.get_or_404(chat_id)
if chat.deleted is not None:
redirect(url_for('chats_route', action='all'))
members = chat.get_members()
if len(members) > 2:
return redirect(url_for('group_chats_route', action='show', chat_id=chat_id, group_id=chat.group_id))
elif len(members) < 2:
user_id = 'Deleted'
else:
user_id = members[0].id if members[0].id != current_user.id else members[1].id
return redirect(url_for("chats_route", action='show', chat_id=chat_id, user_id=user_id))
if chat_id is None:
chat = ChatMember.get_private_chat(current_user.id, user_id)
if chat is None:
chat = Chat(admin_id=current_user.id, time=timestamp())
db.session.add(chat)
db.session.commit()
chat_id = chat.id
chat.add_member(current_user.id, is_group=False)
chat.add_member(user_id, is_group=False)
db.session.commit()
history = []
elif chat.deleted is not None:
return redirect(url_for('chats_route', action='all'))
else:
return redirect(url_for("chats_route", action='show', chat_id=chat.id, user_id=user_id))
else:
history = Chat.get_or_404(int(chat_id)).get_history()
ChatNotification.remove(user_id=current_user.id, chat_id=chat_id)
members = Chat.get_or_404(chat_id).get_members()
if user_id not in list(map(lambda x: x.id, members)):
abort(404)
user_id = members[0].id if members[0].id != current_user.id else members[1].id
return render_template(
"chat.html",
user_id=user_id,
current_user=current_user,
chat_name=User.get_or_404(user_id).username,
chat=Chat.get_or_404(chat_id),
messages=history
)
elif action == 'all':
chats = ChatMember.get_user_chats(current_user.id)
for i in chats:
if i.name is None:
members = i.get_members()
for u in members:
if u is not None and u.id != current_user.id:
i.name = u.username
return render_template(
"my_chats.html",
notifications=current_user.get_notifications(),
current_user=current_user,
chats=chats
)
elif action == 'delete':
chat_id = get_arg_or_400('chat_id', to_int=True)
if chat_id is None:
return redirect(url_for('chats_route', action='all'))
chat_id = int(chat_id)
chat_member = ChatMember.query.filter_by(chat_id=chat_id, user_id=current_user.id).first()
if chat_member is None:
return redirect(request.referrer)
chat_member.deleted = timestamp()
db.session.commit()
if not current_user.is_notified():
socketIO.emit("clear_message", {}, room=current_user.id)
if chat_member.is_group:
return redirect(request.referrer)
return redirect(url_for('chats_route', action='all'))
else:
abort(400)
class Event(db.Model):
from libs.models.EventPlayTimes import EventPlayTimes
__tablename__ = "events"
id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
name = db.Column(db.VARCHAR(100), nullable=False)
description = db.Column(db.VARCHAR(300), nullable=True)
sport = db.Column(db.VARCHAR(50), nullable=False)
group_id = db.Column(db.BigInteger,
db.ForeignKey('groups.id'),
nullable=True)
creation_time = db.Column(db.TIMESTAMP, default=timestamp())
creator_id = db.Column(db.BigInteger,
db.ForeignKey('users.id'),
nullable=False)
time = db.Column(db.TIMESTAMP, nullable=True)
closed = db.Column(db.Boolean, default=False)
recurring = db.Column(db.Boolean, default=False)
event_members_rel = db.relationship('EventMember',
backref='event',
lazy=True)
event_play_time_rel = db.relationship('EventPlayTimes',
backref='event',
lazy=True)
def __repr__(self):
return f"Event {self.id}: {self.name}, {self.sport}"
@staticmethod
def get_or_404(id: int):
event = Event.query.get(id)
if event is None:
abort(404)
return event
@staticmethod
def get_or_none(id: int):
return Event.query.get(id)
def add_member(self, user):
from libs.models.EventMember import EventMember
res = EventMember.query.filter_by(event_id=self.id,
user_id=user.id).first()
if res is not None:
return
new_member = EventMember(event_id=self.id,
user_id=user.id,
time=timestamp())
db.session.add(new_member)
db.session.commit()
def get_members(self):
from libs.models.EventMember import EventMember
return [
i.user
for i in EventMember.query.filter_by(event_id=self.id).all()
]
def remove_member(self, user):
from libs.models.EventMember import EventMember
res = EventMember.query.filter_by(event_id=self.id,
user_id=user.id).first()
if res is not None:
db.session.delete(res)
db.session.commit()
def delete(self):
from libs.models.EventMember import EventMember
if self is None:
return
for i in EventMember.query.filter_by(event_id=self.id).all():
db.session.delete(i)
db.session.commit()
db.session.delete(self)
db.session.commit()
def get_all_from_event(event_id: int) -> list:
return Invitation.query.filter(
(Invitation.type == InvitationType.FROM_EVENT)
& (Invitation.referrer_id == event_id)
& ((Invitation.expiration_time == None)
| (Invitation.expiration_time > timestamp()))).all()
def group_route():
if not GROUPS_ENABLED:
abort(403)
if request.method == 'GET':
action = get_arg_or_400('action')
if action == 'my':
return render_template('my_groups.html',
groups=current_user.get_groups())
elif action == 'new':
new_group_form = NewGroupFrom()
return render_template('new_group.html',
form=new_group_form,
groups=current_user.get_groups())
elif action == 'search':
search_group_form = SearchGroupForm()
sport = get_arg_or_none('sport')
if sport is None:
groups = Group.query.limit(30).all()
else:
groups = Group.get_by_sport(sport)
return render_template("search_group.html",
query=groups,
form=search_group_form)
elif action == 'accept_invitation' or action == 'reject_invitation':
group_id = get_arg_or_400('group_id')
group: Group = Group.get_or_404(group_id)
if current_user.id != group.admin_id:
abort(403)
invitation = Invitation.get_or_404(get_arg_or_400('id'))
if action == 'accept_invitation':
invitation.accept()
else:
invitation.reject()
return redirect(
url_for("group_route", action='invitations', id=group_id))
group_id = get_arg_or_400('id', to_int=True)
group = Group.get_or_404(group_id)
members = group.get_members()
is_member = current_user in members
events = group.get_events()
is_group_admin = group.admin_id == current_user.id
if not is_member:
is_member = None
if action == 'delete' and is_group_admin:
group.delete()
return redirect(url_for('group_route', action='my'))
elif action == 'edit' and is_group_admin:
edit_group_form = NewGroupFrom(closed=group.closed,
name=group.name,
sport=group.sport)
return render_template('edit_group.html',
form=edit_group_form,
group=group)
elif action == 'show':
return render_template('group.html',
group=group,
members=members,
is_member=is_member,
events=events,
is_group_admin=is_group_admin)
elif action == 'invitations':
group_invitations: List[Invitation] = Invitation.get_all_for_group(
group_id)
return render_template("group_invitations.html",
invitations=group_invitations,
group_id=group_id)
elif action == 'join':
if current_user not in members:
if group.closed:
Invitation.add(type=InvitationType.TO_GROUP,
recipient_id=group.id,
referrer_id=current_user.id)
flash(gettext("Invitation sent!"), "success")
else:
new_row = GroupMember(user_id=current_user.id,
group_id=group.id,
time=timestamp())
db.session.add(new_row)
db.session.commit()
members.append(current_user)
is_member = True
return render_template('group.html',
group=group,
members=members,
is_member=is_member,
events=events,
is_group_admin=is_group_admin)
elif action == 'leave':
if current_user in members:
row = GroupMember.query.filter_by(user_id=current_user.id,
group_id=group.id).first()
db.session.delete(row)
db.session.commit()
members.remove(current_user)
is_member = None
return render_template('group.html',
group=group,
members=members,
is_member=is_member,
events=events,
is_admin=is_group_admin)
else:
abort(403)
else:
action = get_arg_or_400('action')
if action == 'edit':
group_id = get_arg_or_400('id', to_int=True)
group = Group.get_or_404(group_id)
edit_group_form = NewGroupFrom(current_group=group)
if edit_group_form.validate_on_submit():
group.closed = edit_group_form.closed.data
group.name = edit_group_form.name.data
group.sport = edit_group_form.sport.data
db.session.add(group)
db.session.commit()
return redirect(
url_for('group_route', action='show', id=group_id))
else:
return render_template('edit_group.html',
form=edit_group_form,
group=group)
elif action == 'new':
new_group_form = NewGroupFrom()
if new_group_form.validate_on_submit():
group = Group(admin_id=current_user.id,
name=new_group_form.name.data,
sport=new_group_form.sport.data,
closed=new_group_form.closed.data)
db.session.add(group)
db.session.commit()
new_row = GroupMember(user_id=current_user.id,
group_id=group.id,
time=timestamp())
db.session.add(new_row)
db.session.commit()
return redirect(
url_for('group_route', action='show', id=group.id))
else:
return render_template('new_group.html',
form=new_group_form,
groups=current_user.get_groups())
elif action == 'search':
search_group_form = SearchGroupForm()
name = search_group_form.name.data
sport = search_group_form.sport.data
groups = Group.query.filter(Group.name.ilike(f"%{name}%")). \
filter(Group.sport == sport if sport != "None" else Group.sport == Group.sport).all()
return render_template("search_group.html",
query=groups,
form=search_group_form)
else:
abort(400)
def is_expired(self):
return self.expiration_time is not None and self.expiration_time > timestamp(
)
