def test_team_member_authenticates_just_to_channels_he_belongs(self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel_user = PublicUser(user_id=user_id) channel_user.team_id = team_id channel_user.channel_id = channel_id channel_user.is_channel_creator = False sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user authenticated_user = Authenticator.authenticate_channel(authentication) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(channel_id, authenticated_user.channel_id) self.assertFalse(authenticated_user.is_channel_creator)
def test_app_user_authenticating_to_team_with_role_verifying_authenticates( self): user_id = 0 team_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id def verifying_function(_): return True '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.CREATOR.value team_user.team_id = team_id sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user authenticated_user = Authenticator.authenticate_team( authentication, verifying_function) self.assertEqual(user_id, authenticated_user.id)
def create_bot(cls, bot_data): admin = Authenticator.authenticate_team(bot_data.authentication, UserRoles.is_admin) try: new_client = UserDatabaseClient.add_client() new_bot = Bot( bot_id=new_client.id, name=bot_data.name, callback=bot_data.callback, token=Authenticator.generate(new_client.id) ) BotDatabaseClient.add_bot(new_bot) team_bot = TeamUser( user_id=new_client.id, team_id=admin.team_id, role=TeamRoles.BOT.value ) TeamDatabaseClient.add_team_user(team_bot) DatabaseClient.commit() cls.logger().info(f"Bot #{new_bot.id} created in team {admin.team_id} with callback url {new_bot.callback} " f"by admin {admin.id}.") return SuccessfulUserMessageResponse("Bot created.", UserResponseStatus.OK.value) except IntegrityError as exc: DatabaseClient.rollback() if BotDatabaseClient.get_bot_by_name(bot_data.name) is not None: cls.logger().info(f"Failing to create bot {bot_data.name}. Name already in use.", exc) return BadRequestUserMessageResponse("Name already in use for other bot.", UserResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().info(f"Failing to create bot {bot_data.name}.") return UnsuccessfulClientResponse("Couldn't create bot.")
def test_user_with_same_token_in_database_authenticates(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = User( user_id=user_id, token=token) authenticated_user = Authenticator.authenticate(authentication) self.assertTrue(authenticated_user.id == user_id)
def test_not_user_found_but_bot_found_after_token_decoding_authenticates( self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token bot = Bot(bot_id=0, name="TEST", callback=None, token=None) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = None sys.modules[ "daos.bots"].BotDatabaseClient.get_bot_by_id.return_value = bot authenticated_client = Authenticator.authenticate(authentication) self.assertEqual(0, authenticated_client.id) self.assertEqual("TEST", authenticated_client.name)
def create_channel(cls, creation_data): user = Authenticator.authenticate_team(creation_data.authentication) try: new_client = UserDatabaseClient.add_client() new_channel = Channel( channel_id=new_client.id, team_id=user.team_id, creator=user.id, name=creation_data.name, visibility=creation_data.visibility, description=creation_data.description, welcome_message=creation_data.welcome_message ) ChannelDatabaseClient.add_channel(new_channel) new_channel_user = ChannelUser(user_id=user.id, channel_id=new_channel.channel_id) ChannelDatabaseClient.add_channel_user(new_channel_user) new_chat = Chat(user_id=user.id, chat_id=new_channel.channel_id, team_id=new_channel.team_id) MessageDatabaseClient.add_chat(new_chat) DatabaseClient.commit() channel = ChannelDatabaseClient.get_channel_by_id(new_channel.channel_id) cls.logger().info(f"Channel #{new_channel.channel_id} created in team {new_channel.team_id}.") cls.logger().info(f"User #{user.id} assigned as channel #{new_channel.channel_id} creator.") except IntegrityError: DatabaseClient.rollback() if ChannelDatabaseClient.get_channel_by_name(creation_data.name) is not None: cls.logger().info(f"Failing to create channel {creation_data.name}. Name already in use.") return BadRequestChannelMessageResponse(f"Channel name {creation_data.name} already in use.", TeamResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().error(f"Failing to create channel {creation_data.name}.") return UnsuccessfulChannelMessageResponse("Couldn't create channel.") else: return SuccessfulChannelResponse(channel, TeamResponseStatus.CREATED.value)
def add_forbidden_word(cls, word_data): user = Authenticator.authenticate_team(word_data.authentication, TeamRoles.is_team_moderator) if TeamDatabaseClient.get_forbidden_word_by_word( user.team_id, word_data.word) is not None: cls.logger().debug( f"User #{user.id} attempted to add a forbidden word that already exists ({word_data.word})." ) return BadRequestTeamMessageResponse( "Word already forbidden!", TeamResponseStatus.ALREADY_REGISTERED.value) forbidden_word = ForbiddenWord(word=word_data.word, team_id=user.team_id) try: TeamDatabaseClient.add_forbidden_word(forbidden_word) DatabaseClient.commit() cls.logger().info( f"Word \"{word_data.word}\" forbidden in team #{user.team_id} by user #{user.id}." ) return SuccessfulTeamMessageResponse( "Forbidden word added!", TeamResponseStatus.ADDED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"User #{user.id} couldn't add forbidden word \"{word_data.word}\"." ) return UnsuccessfulTeamMessageResponse( "Couldn't add forbidden word.")
def set_user_offline(cls, user_data): user = Authenticator.authenticate(user_data) user.online = False UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"User #{user.id} set offline.") return SuccessfulUserResponse(user)
def accept_invite(cls, invitation_data): user = Authenticator.authenticate(invitation_data) invite = TeamDatabaseClient.get_team_invite_by_token( invitation_data.invite_token, user.email) if invite is None: return BadRequestTeamMessageResponse( "You weren't invited to this team.", UserResponseStatus.WRONG_CREDENTIALS.value) new_user_team = TeamUser(user_id=user.id, team_id=invite.team_id) try: TeamDatabaseClient.add_team_user(new_user_team) TeamDatabaseClient.delete_invite(invite) DatabaseClient.commit() BotService.tito_welcome(new_user_team.user_id, new_user_team.team_id) cls.logger().info( f"User #{user.id} joined team #{invite.team_id}.") except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"User #{user.id} failed at joining team #{invite.team_id}.") return UnsuccessfulTeamMessageResponse("Couldn't join team.") else: return SuccessfulTeamMessageResponse( "Team joined!", TeamResponseStatus.ADDED.value)
def channels_for_user(cls, user_data): user = Authenticator.authenticate_team(user_data) channels = ChannelDatabaseClient.get_user_channels_by_user_id( user.id, user.team_id, user.role == UserRoles.ADMIN.value) return SuccessfulChannelsListResponse( cls._generate_channels_list(channels))
def test_team_regular_member_authenticating_to_not_belonging_channel_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel = Channel(channel_id=channel_id, team_id=team_id, name="test", creator=None) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = None sys.modules[ "daos.channels"].ChannelDatabaseClient.get_channel_by_id.return_value = channel self.assertRaises(NoPermissionsError, Authenticator.authenticate_channel, authentication)
def delete_forbidden_word(cls, word_data): user = Authenticator.authenticate_team(word_data.authentication, TeamRoles.is_team_moderator) forbidden_word = TeamDatabaseClient.get_forbidden_word_by_id( user.team_id, word_data.word_id) if forbidden_word is None: cls.logger().error( f"User #{user.id} tried to delete forbidden word {word_data.word_id} from team " f"#{user.team_id}, which doesn't exist.") return BadRequestTeamMessageResponse( "Forbidden word not found!", TeamResponseStatus.NOT_FOUND.value) try: TeamDatabaseClient.delete_forbidden_word(forbidden_word) DatabaseClient.commit() cls.logger().info( f"User #{user.id} deleted forbidden word \"{forbidden_word.word}\" from team " f"#{user.team_id}.") return SuccessfulTeamMessageResponse( "Forbidden word removed!", TeamResponseStatus.REMOVED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"User #{user.id} couldn't remove forbidden word \"{forbidden_word.word}\" from team " f"#{user.team_id}.") return UnsuccessfulTeamMessageResponse("Couldn't remove team.")
def test_authenticating_to_non_existing_channel_channel_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = None sys.modules[ "daos.channels"].ChannelDatabaseClient.get_channel_by_id.return_value = None self.assertRaises(ChannelNotFoundError, Authenticator.authenticate_channel, authentication)
def update_information(cls, update_data): user = Authenticator.authenticate_channel(update_data.authentication, TeamRoles.is_channel_creator) channel = ChannelDatabaseClient.get_channel_by_id(user.channel_id) channel.name = \ update_data.updated_channel["name"] if "name" in update_data.updated_channel else channel.name channel.visibility = \ update_data.updated_channel["visibility"] if "visibility" in update_data.updated_channel \ else channel.visibility channel.description = \ update_data.updated_channel["description"] if "description" in update_data.updated_channel \ else channel.description channel.welcome_message = \ update_data.updated_channel["welcome_message"] if "welcome_message" in update_data.updated_channel \ else channel.welcome_message try: ChannelDatabaseClient.update_channel(channel) DatabaseClient.commit() cls.logger().info(f"Channel {channel.channel_id} information updated by user {user.username}.") return SuccessfulChannelResponse(channel, ChannelResponseStatus.UPDATED.value) except IntegrityError: DatabaseClient.rollback() old_channel = ChannelDatabaseClient.get_channel_by_name(update_data.updated_team.get("name")) if old_channel is not None: cls.logger().info(f"Trying to update channel {user.channel_id}'s name with {old_channel.name}, " f"that currently exists.") return BadRequestChannelMessageResponse(f"Name {old_channel.name} is already in use!", TeamResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().error(f"Couldn't update channel {user.channel_id} information.") return UnsuccessfulTeamMessageResponse("Couldn't update channel information!")
def join_channel(cls, registration_data): user = Authenticator.authenticate_team(registration_data.authentication) channel = ChannelDatabaseClient.get_channel_by_id(registration_data.channel_id) if channel is None: cls.logger().info(f"User {user.user_id} attempting to join channel #{registration_data.channel_id}, " f"which does not exist.") return BadRequestChannelMessageResponse("Channel not found.", ChannelResponseStatus.CHANNEL_NOT_FOUND.value) if channel.team_id != user.team_id: cls.logger().info(f"User {user.user_id} from team {user.team_id} attempting to join channel " f"#{channel.channel_id}, but it's in team {channel.team_id}.") return BadRequestChannelMessageResponse("Other team's channel.", ChannelResponseStatus.OTHER_TEAM.value) if channel.visibility == ChannelVisibilities.PRIVATE.value: cls.logger().info( f"User {user.user_id} attempting to join channel #{channel.channel_id}, which is private.") return BadRequestChannelMessageResponse("Private channel!", ChannelResponseStatus.PRIVATE_VISIBILITY.value) try: new_channel_user = ChannelUser(user_id=user.id, channel_id=channel.channel_id) ChannelDatabaseClient.add_channel_user(new_channel_user) new_chat = Chat(user_id=user.id, chat_id=channel.channel_id, team_id=user.team_id) MessageDatabaseClient.add_chat(new_chat) DatabaseClient.commit() cls.logger().info(f"User {user.id} joined channel #{channel.channel_id}.") return SuccessfulChannelResponse(channel, ChannelResponseStatus.JOINED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error(f"User #{user.id} failed at joining channel #{channel.channel_id}.") return UnsuccessfulChannelMessageResponse("Couldn't join channel.")
def _login_app_user(cls, user_data): user = UserDatabaseClient.get_user_by_email(user_data.email) if user: try: if hashing.verify(user_data.password, user.password): cls.logger().debug(f"Generating token for user {user.id}") user.token = Authenticator.generate( user.id, user_data.password) user.online = True UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"User #{user.id} logged in") headers = {"auth_token": user.token} return SuccessfulUserResponse(user, headers) else: cls.logger().info( f"Wrong credentials while attempting to log in user #{user_data.email}" ) return SuccessfulUserMessageResponse( "Wrong email or password.", UserResponseStatus.WRONG_CREDENTIALS.value) except ValueError: cls.logger().info( f"Wrong credentials while attempting to log in user #{user_data.email}" ) return SuccessfulUserMessageResponse( "Wrong email or password.", UserResponseStatus.WRONG_CREDENTIALS.value) else: cls.logger().info(f"User #{user_data.email} not found.") raise UserNotFoundError("User not found.", UserResponseStatus.USER_NOT_FOUND.value)
def team_user_profile(cls, user_data): user = Authenticator.authenticate_team(user_data.authentication) response = UserService.team_user_profile( user_data.user_id, user.team_id, user.team_role == UserRoles.ADMIN.value) return response or BadRequestTeamMessageResponse( "You cannot access to this user's profile", TeamResponseStatus.USER_NOT_MEMBER.value)
def team_users(cls, user_data): user = Authenticator.authenticate_team(user_data) team_users = TeamDatabaseClient.get_all_team_users_by_team_id( user.team_id) cls.logger().info( f"User #{user.id} got {len(team_users)} users from team #{user.team_id}." ) return SuccessfulUsersListResponse(cls._team_users_list(team_users))
def test_admin_user_authenticates_to_every_team(self): user_id = 0 team_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id '''Mocked outputs''' user = User(user_id=user_id, token=token, role=UserRoles.ADMIN.value) sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user authenticated_user = Authenticator.authenticate_team(authentication) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(UserRoles.ADMIN.value, authenticated_user.role)
def search_users(cls, user_data): user = Authenticator.authenticate_team(user_data.authentication) found_users = TeamDatabaseClient.get_all_team_users_by_likely_name( user.team_id, user_data.searched_username) cls.logger().info( f"Found {len(found_users)} users for user #{user.id} with keyword {user.username} ." ) return SuccessfulUsersListResponse(cls._team_users_list(found_users))
def logout_user(cls, user_data): user = Authenticator.authenticate(user_data) user.token = None user.online = False UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"User #{user.id} logged out.") return SuccessfulUserMessageResponse( "User logged out.", UserResponseStatus.LOGGED_OUT.value)
def add_user(cls, add_data): admin = Authenticator.authenticate(add_data.authentication, UserRoles.is_admin) user = UserDatabaseClient.get_user_by_id(add_data.add_user_id) if user is None: cls.logger().info(f"User {add_data.add_user_id} not found.") raise UserNotFoundError("User not found.", UserResponseStatus.USER_NOT_FOUND.value) if user.role == UserRoles.ADMIN.value: cls.logger().warning( f"Admin #{admin.id} trying to add other admin to a team.") return BadRequestTeamMessageResponse( "You cannot add an admin to a team!", TeamResponseStatus.ROLE_UNAVAILABLE.value) if TeamDatabaseClient.get_user_in_team_by_ids( user.id, add_data.authentication.team_id) is not None: cls.logger().info( f"User {add_data.add_user_id} already part of team #{add_data.authentication.team_id}." ) return BadRequestTeamMessageResponse( "This user already belongs to the team.", TeamResponseStatus.ALREADY_REGISTERED.value) previous_invitation = TeamDatabaseClient.get_team_invite( add_data.authentication.team_id, user.email) if previous_invitation is not None: cls.logger().info( f"Deleting old invitation for user {add_data.add_user_id} to team " f"#{add_data.authentication.team_id}.") TeamDatabaseClient.delete_invite(previous_invitation) DatabaseClient.commit() added_user = TeamUser(user_id=add_data.add_user_id, team_id=add_data.authentication.team_id) try: TeamDatabaseClient.add_team_user(added_user) DatabaseClient.commit() BotService.tito_welcome(added_user.user_id, added_user.team_id) cls.logger().info( f"Added user #{added_user.user_id} to team #{added_user.team_id} by admin #{admin.id}." ) return SuccessfulTeamMessageResponse( "User added.", TeamResponseStatus.ADDED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"Couldn't add user #{added_user.user_id} to team #{added_user.team_id}." ) return UnsuccessfulTeamMessageResponse( "Couldn't invite user to team.")
def forbidden_words(cls, user_data): user = Authenticator.authenticate_team(user_data, TeamRoles.is_team_moderator) forbidden_words = TeamDatabaseClient.get_forbidden_words_from_team( user.team_id) cls.logger().info( f"User #{user.id} got {len(forbidden_words)} forbidden words in team #{user.team_id}." ) return SuccessfulForbiddenWordsList( cls._generate_forbidden_words_list(forbidden_words))
def _login_facebook_user(cls, user_data): try: facebook_user = FacebookService.get_user_from_facebook(user_data) user = UserDatabaseClient.get_user_by_facebook_id( facebook_user.facebook_id) if user is not None: cls.logger().info( f"Logging in Facebook user with Facebook ID #{facebook_user.facebook_id}." ) cls.logger().debug(f"Generating token for user {user.id}") user.token = Authenticator.generate(user.id) user.online = True UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"User #{user.id} logged in.") headers = {"auth_token": user.token} return SuccessfulUserResponse(user, headers) else: cls.logger().info( f"Creating new Facebook user with Facebook ID #{facebook_user.facebook_id}." ) new_client = UserDatabaseClient.add_client() new_user = User(user_id=new_client.id, facebook_id=facebook_user.facebook_id, username=facebook_user.username, email=facebook_user.email, first_name=facebook_user.first_name, last_name=facebook_user.last_name, profile_pic=facebook_user.profile_pic, role=UserRoles.USER.value, token=Authenticator.generate(new_client.id)) UserDatabaseClient.add_user(new_user) DatabaseClient.commit() cls.logger().info(f"User #{new_client.id} logged in.") headers = {"auth_token": new_user.token} return SuccessfulUserResponse(new_user, headers) except FacebookWrongTokenError: cls.logger().info( f"Failing to logging in user with Facebook token #{user_data.facebook_token}." ) return UnsuccessfulClientResponse("Couldn't perform login.")
def test_user_with_different_token_in_database_throws_exception(self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token '''Mocked outputs''' user = User(user_id=user_id, token="DIFFERENT-TOKEN") sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user self.assertRaises(WrongTokenError, Authenticator.authenticate, authentication)
def test_not_user_nor_bot_found_after_token_decoding_throws_exception( self): user_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = None sys.modules[ "daos.bots"].BotDatabaseClient.get_bot_by_id.return_value = None self.assertRaises(UserNotFoundError, Authenticator.authenticate, authentication)
def get_preview_messages(cls, user_data): user = Authenticator.authenticate_team(user_data) db_direct_messages = MessageDatabaseClient.get_direct_messages_previews(user.id, user.team_id) db_channel_messages = MessageDatabaseClient.get_channel_messages_previews(user.id, user.team_id) direct_messages = cls._generate_direct_chats_list(db_direct_messages, user.id, user.team_id) channel_messages = cls._generate_channel_chats_list(db_channel_messages, user.team_id) total_messages = direct_messages + channel_messages total_messages.sort(key=lambda msg: msg.get("timestamp"), reverse=True) cls.logger().info(f"Retrieved {len(total_messages)} chats from user #{user.id} ({user.username}).") return ChatsListResponse(total_messages)
def test_channel_regular_member_authenticating_to_channel_moderation_throws_exception( self): user_id = 0 team_id = 0 channel_id = 0 token = Authenticator.generate(user_id) authentication = MagicMock() authentication.token = token authentication.team_id = team_id authentication.channel_id = channel_id '''Mocked outputs''' user = User(user_id=user_id, token=token) team_user = PublicUser(user_id=user_id) team_user.team_role = TeamRoles.MEMBER.value team_user.team_id = team_id channel_user = PublicUser(user_id=user_id) channel_user.team_id = team_id channel_user.channel_id = channel_id channel_user.is_channel_creator = False sys.modules[ "daos.users"].UserDatabaseClient.get_user_by_id.return_value = user sys.modules[ "daos.users"].UserDatabaseClient.get_team_user_by_ids.return_value = team_user sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user self.assertRaises(NoPermissionsError, Authenticator.authenticate_channel, authentication, TeamRoles.is_channel_creator) channel_user.is_channel_creator = True sys.modules[ "daos.users"].UserDatabaseClient.get_channel_user_by_ids.return_value = channel_user authenticated_user = Authenticator.authenticate_channel( authentication, TeamRoles.is_channel_creator) self.assertEqual(user_id, authenticated_user.id) self.assertEqual(team_id, authenticated_user.team_id) self.assertEqual(channel_id, authenticated_user.channel_id) self.assertTrue(authenticated_user.is_channel_creator)
def leave_channel(cls, user_data): user = Authenticator.authenticate_channel(user_data) delete_user = ChannelDatabaseClient.get_user_in_channel_by_ids(user.id, user.channel_id) try: ChannelDatabaseClient.delete_channel_user(delete_user) DatabaseClient.commit() cls.logger().info(f"User #{user.id} leaved channel #{user.channel_id}.") return SuccessfulChannelMessageResponse("Channel leaved!", ChannelResponseStatus.REMOVED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error(f"User #{user.id} failing to leave channel #{userchannel_id}.") return UnsuccessfulTeamMessageResponse("Couldn't leave chanel.")
def delete_channel(cls, user_data): user = Authenticator.authenticate_channel(user_data) channel = ChannelDatabaseClient.get_channel_by_id(user.channel_id) try: ChannelDatabaseClient.delete_channel(channel) DatabaseClient.commit() cls.logger().info(f"Channel #{channel.channel_id} deleted by user {user.username}, with all messages.") return SuccessfulChannelMessageResponse("Channel removed!", ChannelResponseStatus.REMOVED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error(f"User #{user.id} couldn't remove channel #{user.channel_id}.") return UnsuccessfulChannelMessageResponse("Couldn't remove channel.")