def update_user(cls, update_data): user = Authenticator.authenticate(update_data) user.username = \ update_data.updated_user["username"] if "username" in update_data.updated_user else user.username user.email = \ update_data.updated_user["email"] if "email" in update_data.updated_user else user.email user.password = \ hashing.hash( update_data.updated_user["password"]) if "password" in update_data.updated_user else user.password user.first_name = \ update_data.updated_user["first_name"] if "first_name" in update_data.updated_user else user.first_name user.last_name = \ update_data.updated_user["last_name"] if "last_name" in update_data.updated_user else user.last_name user.profile_pic = \ update_data.updated_user["profile_pic"] if "profile_pic" in update_data.updated_user else user.profile_pic try: UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"User {user.id} information updated.") return SuccessfulUserResponse(user) except IntegrityError: DatabaseClient.rollback() new_username = update_data.updated_user.get("username") new_email = update_data.updated_user.get("email") if UserDatabaseClient.get_user_by_username( new_username) is not None: cls.logger().info( f"Name {new_email} is taken for another user.") return BadRequestUserMessageResponse( f"Name {new_username} is already in use!", UserResponseStatus.ALREADY_REGISTERED.value) elif UserDatabaseClient.get_user_by_email(new_email) is not None: cls.logger().info( f"Email {new_email} is taken for another user.") return BadRequestUserMessageResponse( f"Email {new_email} is already in use!", UserResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().error( f"Couldn't update user {user.id} information.") return UnsuccessfulClientResponse( "Couldn't update user information!")
def change_role(cls, change_role_data): team_admin = Authenticator.authenticate_team( change_role_data.authentication, TeamRoles.is_team_creator) if change_role_data.new_role == TeamRoles.CREATOR.value: cls.logger().warning( f"Trying to set user as team #{team_admin.team_id} {TeamRoles.CREATOR.value}" ) return BadRequestTeamMessageResponse( "You cannot set someone as team CREATOR.", TeamResponseStatus.ROLE_UNAVAILABLE.value) user_team = TeamDatabaseClient.get_user_in_team_by_ids( change_role_data.user_id, team_admin.team_id) if user_team is None: cls.logger().info( f"Trying to modify role from user #{change_role_data.user_id}, who's not part of team #{team_admin.team_id}" ) return BadRequestTeamMessageResponse( "The given user is not part this team.", TeamResponseStatus.USER_NOT_MEMBER.value) old_role = user_team.role user_team.role = change_role_data.new_role try: TeamDatabaseClient.update_team_user(user_team) DatabaseClient.commit() NotificationService.notify_change_role(user_team, old_role, team_admin.id) cls.logger().info( f"User #{user_team.user_id} set as team #{team_admin.team_id} {user_team.role} by user " f"#{team_admin.id}.") except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"Failing to modifying role of #{user_team.user_id} in team #{user_team.team_id}." ) return UnsuccessfulTeamMessageResponse( "Couldn't modify user role.") else: return SuccessfulTeamMessageResponse( "Role modified", TeamResponseStatus.ROLE_MODIFIED.value)
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 update_information(cls, update_data): user = Authenticator.authenticate_team(update_data.authentication, TeamRoles.is_team_moderator) team = TeamDatabaseClient.get_team_by_id( update_data.authentication.team_id) team.name = \ update_data.updated_team["team_name"] if "team_name" in update_data.updated_team else team.name team.picture = \ update_data.updated_team["picture"] if "picture" in update_data.updated_team else team.picture team.location = \ update_data.updated_team["location"] if "location" in update_data.updated_team else team.location team.description = \ update_data.updated_team["description"] if "description" in update_data.updated_team else team.description team.welcome_message = \ update_data.updated_team[ "welcome_message"] if "welcome_message" in update_data.updated_team else team.welcome_message try: team = TeamDatabaseClient.update_team(team) DatabaseClient.commit() cls.logger().info( f"Team {team.id} information updated by user #{user.id}, who's team {user.team_role}." ) return SuccessfulTeamResponse(team, TeamResponseStatus.UPDATED.value) except IntegrityError: DatabaseClient.rollback() team_name = update_data.updated_team.get("team_name") if TeamDatabaseClient.get_team_by_name(team_name) is not None: cls.logger().info( f"Trying to update team {user.team_id}'s name with {team_name}, that currently exists." ) return BadRequestTeamMessageResponse( f"Name {team_name} is already in use!", TeamResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().error( f"Couldn't update team {user.team_id} information.") return UnsuccessfulTeamMessageResponse( "Couldn't update team information!")
def delete_user(cls, delete_data): user = Authenticator.authenticate_team(delete_data.authentication, TeamRoles.is_team_moderator) delete_user = TeamDatabaseClient.get_user_in_team_by_ids( delete_data.delete_id, user.team_id) if delete_user is not None: if TeamRoles.is_higher_role(user.team_role, delete_user.role): try: TeamDatabaseClient.delete_team_user(delete_user) DatabaseClient.commit() cls.logger().info( f"User #{delete_user.user_id} deleted from team #{user.team_id} by user #{user.id}." ) return SuccessfulTeamMessageResponse( "User removed!", TeamResponseStatus.REMOVED.value) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"User #{user.id} failed to delete user {delete_user.user_id} from team #{user.team_id}." ) return UnsuccessfulTeamMessageResponse( "Couldn't delete user.") else: cls.logger().info( f"Cannot delete user #{delete_user.user_id} because he's role ({delete_user.role}) " f"is higher than yours.") return ForbiddenTeamMessageResponse( "You don't have enough permissions to delete this user.", TeamResponseStatus.NOT_ENOUGH_PERMISSIONS.value) else: cls.logger().info( f"Trying to delete user #{delete_data.delete_id}, who's not part of the team {user.team_id}." ) return NotFoundTeamMessageResponse( "Couldn't find user to delete", UserResponseStatus.USER_NOT_FOUND.value)
def get_messages_from_chat(cls, chat_data): user = Authenticator.authenticate_team(chat_data.authentication) chat = MessageDatabaseClient.get_chat_by_ids(user.id, chat_data.chat_id, user.team_id) if chat is None: cls.logger().error(f"User #{user.id} trying to retrieve messages from chat {chat_data.chat_id}, " f"that doesn't exist.") raise ChatNotFoundError("Chat not found.", MessageResponseStatus.CHAT_NOT_FOUND.value) else: is_channel, messages = cls._determinate_messages(user.id, chat_data.chat_id, user.team_id, chat_data.offset) unseen_messages = chat.offset try: chat.offset = 0 MessageDatabaseClient.add_or_update_chat(chat) DatabaseClient.commit() cls.logger().error(f"{unseen_messages} messages set as seen for user {user.id} in chat {chat.chat_id}.") except IntegrityError: DatabaseClient.rollback() cls.logger().error(f"Couldn't set seen messages for user {user.id} in chat {chat.chat_id}.") cls.logger().info(f"Retrieved {len(messages)} messages from chat {chat_data.chat_id} from user #{user.id}.") return MessageListResponse(cls._generate_messages_list(messages, unseen_messages, user.id, user.team_id), is_channel)
def regenerate_token(cls, regenerate_data): user = UserDatabaseClient.get_user_by_email(regenerate_data.email) if user: password_recovery = UserDatabaseClient.get_password_recovery_by_id( user.id) if password_recovery: try: UserDatabaseClient.delete_password_recovery( password_recovery) cls.logger().debug( f"Deleting token recover entry for user {user.id}") user.token = Authenticator.generate(user.id) cls.logger().debug( f"Regenerating token for user {user.id}") user.online = True UserDatabaseClient.update_user(user) DatabaseClient.commit() cls.logger().info(f"Logging in user {user.id}") headers = {"auth_token": user.token} return SuccessfulUserResponse(user, headers) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"Couldn't regenerate token for user #{user.id}.") return UnsuccessfulClientResponse( "Couldn't regenerate token.") else: cls.logger().info( f"Attempting to recover password for user #{user.id} with no password recovery token." ) return BadRequestUserMessageResponse( "You haven't ask for password recovery!", UserResponseStatus.WRONG_CREDENTIALS.value) else: cls.logger().info(f"User {regenerate_data.email} not found.") raise UserNotFoundError("User not found.", UserResponseStatus.USER_NOT_FOUND.value)
def create_team(cls, new_team_data): user = Authenticator.authenticate(new_team_data) new_team = Team(name=new_team_data.team_name, picture=new_team_data.picture, location=new_team_data.location, description=new_team_data.description, welcome_message=new_team_data.welcome_message) try: team = TeamDatabaseClient.add_team(new_team) new_team.id = team.id new_user_by_team = TeamUser(user_id=user.id, team_id=team.id, role=TeamRoles.CREATOR.value) TeamDatabaseClient.add_team_user(new_user_by_team) BotService.register_tito_in_team(team.id) DatabaseClient.commit() cls.logger().info(f"Team #{team.id} created.") cls.logger().info( f"User #{user.id} assigned as team #{team.id} {new_user_by_team.role}." ) except IntegrityError: DatabaseClient.rollback() if TeamDatabaseClient.get_team_by_name( new_team_data.team_name) is not None: cls.logger().info( f"Failing to create team {new_team_data.team_name}. Name already in use." ) return BadRequestTeamMessageResponse( f"Name {new_team_data.team_name} already in use for other team.", TeamResponseStatus.ALREADY_REGISTERED.value) else: cls.logger().error( f"Failing to create team {new_team_data.team_name}.") return UnsuccessfulTeamMessageResponse("Couldn't create team.") else: return SuccessfulTeamResponse(new_team, TeamResponseStatus.CREATED.value)
def recover_password(cls, recover_data): user = UserDatabaseClient.get_user_by_email(recover_data.email) if user is not None: old_password_recovery = UserDatabaseClient.get_password_recovery_by_id( user.id) if old_password_recovery is not None: cls.logger().debug( f"It already exists a recovery token for user {user.username}. Resending token." ) recovery_token = old_password_recovery.token else: recovery_token = Authenticator.generate_recovery_token() cls.logger().debug("Generating recovery token") password_recovery = PasswordRecovery(user_id=user.id, token=recovery_token) UserDatabaseClient.add_password_recovery(password_recovery) DatabaseClient.commit() email_data = RecoveryPasswordEmailDTO( email=user.email, username=user.username, token=recovery_token, message_template=EmailService.recovery_token_message) EmailService.send_email(email_data) cls.logger().info( f"Sending recovery token email for user {user.username}.") return SuccessfulUserMessageResponse("Recovery token sent!", UserResponseStatus.OK.value) else: cls.logger().info(f"User {recover_data.email} not found.") raise UserNotFoundError("User not found.", UserResponseStatus.USER_NOT_FOUND.value)
def invite_user(cls, invite_data): team_mod = Authenticator.authenticate_team(invite_data.authentication, TeamRoles.is_team_moderator) invited_user = UserDatabaseClient.get_user_by_email(invite_data.email) if invited_user is not None and invited_user.role == UserRoles.ADMIN.value: cls.logger().info( f"Mod #{team_mod.id} tried to invite admin #{invited_user.id} to team #{team_mod.team_id}." ) return BadRequestTeamMessageResponse( "You cannot invite an admin to a team!", TeamResponseStatus.ROLE_UNAVAILABLE.value) already_member = TeamDatabaseClient.get_user_in_team_by_email( invite_data.email, team_mod.team_id) if already_member is not None: cls.logger().info( f"Mod #{team_mod.id} tried to invite user #{already_member.user_id} to team " f"#{team_mod.team_id}, but it already belongs to that team.") return BadRequestTeamMessageResponse( "This user already belongs to the team.", TeamResponseStatus.ALREADY_REGISTERED.value) if TeamDatabaseClient.get_team_invite(team_mod.team_id, invite_data.email) is not None: cls.logger().info( f"Mod #{team_mod.id} tried to invite an user already invited to team #{team_mod.team_id}" ) return BadRequestTeamMessageResponse( "This user was already invited to join the team.", TeamResponseStatus.ALREADY_INVITED.value) invite_token = Authenticator.generate_team_invitation() new_invite = TeamInvite(team_id=team_mod.team_id, email=invite_data.email, token=invite_token) try: TeamDatabaseClient.add_invite(new_invite) team = TeamDatabaseClient.get_team_by_id(team_mod.team_id) DatabaseClient.commit() cls.logger().info( f"New invitation for {new_invite.email} to join team #{team_mod.team_id}, by user #" f"{team_mod.id}.") email_data = TeamInvitationEmailDTO( email=invite_data.email, team_name=team.name, inviter_name=team_mod.username, token=invite_token, message_template=EmailService.team_invitation_message) EmailService.send_email(email_data) NotificationService.notify_team_invitation(new_invite, team_mod.id) cls.logger().info( f"Team #{team_mod.team_id} invitation email sent to {new_invite.email}." ) except IntegrityError: DatabaseClient.rollback() cls.logger().error( f"Couldn't invite user {new_invite.email} to team #{team_mod.team_id}." ) return UnsuccessfulTeamMessageResponse( "Couldn't invite user to team.") else: return SuccessfulTeamMessageResponse( "User invited.", TeamResponseStatus.INVITED.value)