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( )