def activate_deactivate_user( curr_user: dict, email: str, is_admin_action: bool, action) -> list: print( 'INFO: activation deactivation request received at {} for' ' \nuser: {},\nemail: {},\nadmin_action: {},\npermission: {}]'.format( str(datetime.datetime.now()), curr_user, email, is_admin_action, action )) email_length_invalid = UserUtils.verify_email_length(email, email) if email_length_invalid: return email_length_invalid elif curr_user.get('email') != email and not is_admin_action: return [{'error': 'Please provide your own valid email id address.'}, 404] UserDatabaseService.activate_deactivate_user(curr_user, email, is_admin_action, action) if action == AdminPermissionEnums.DEACTIVATE.name: deleted_user = dataStateAccess.UserDTO.user_dto(UserDatabaseService.get_active_inactive_single_user_by_email(email)) if deleted_user and not deleted_user.get('is_active'): # # Active tokens for current user should be revoked as soon as the user marks himself as inactive. user_session_history = SessionHistoryDatabaseService() session_bucket = user_session_history.get_active_sessions_for_user(deleted_user) if session_bucket: session_service = SessionService() session_service.revoke_session_token(session_bucket[0].get('access_token_jti')) return [{'response': 'User successfully deleted.'}, 200] return [{'error': 'No user with email {} found.'.format(email)}, 400] elif action == AdminPermissionEnums.ACTIVATE.name: activated_user = dataStateAccess.UserDTO.user_dto(UserDatabaseService.get_active_inactive_single_user_by_email(email)) if activated_user and activated_user.get('is_active'): return [{'response': 'User successfully restored.'}, 200] return [{'error': 'No user with email {} found .'.format(email)}, 400] print("Some error encountered, {}.".format(str(datetime.datetime.now()))) return [{'error': 'There was some error, please contact developer.'}, 500]
def block_unblock_a_user(self, requestor_users_email: str, user_to_be_blocked_unblocked_email: str, action) -> list: try: if requestor_users_email == user_to_be_blocked_unblocked_email: return [{ 'error': ErrorEnums.INVALID_INPUT_SUPPLIED_ERROR.value }, 400] self.target_user = UserDatabaseService.get_active_inactive_single_user_by_email( user_to_be_blocked_unblocked_email) if not self.target_user: return [{'error': ErrorEnums.NO_USER_FOUND_ERROR.value}, 404] if not self.target_user.is_active: return [{'error': ErrorEnums.INACTIVE_USER_ERROR.value}, 404] if action not in [ str(UserEnums.BLOCK.value), str(UserEnums.UNBLOCK.value) ]: return [{'error': ErrorEnums.UNKNOWN_REQUEST_ERROR.value}, 400] self._performer = UserDatabaseService.get_active_user_by_email( requestor_users_email) self.user_dao = UserDatabaseService() self.user_dao.block_unblock_users(user_dto(self._performer), user_dto(self.target_user), action) return [{'response': 'SUCCESS.'}, 200] except Exception as e: return [{ 'error': ErrorEnums.EXCEPTION_ERROR.value.format( e, "block/unblock user request") }, 400]
def follow_unfollow_a_user(self, requesting_user_email: str, user_to_be_followed_unfollowed_email: str, action) -> list: try: if requesting_user_email == user_to_be_followed_unfollowed_email: return [{ 'error': ErrorEnums.INVALID_INPUT_SUPPLIED_ERROR.value }, 400] self.target_user = UserDatabaseService.get_active_inactive_single_user_by_email( user_to_be_followed_unfollowed_email) if not self.target_user: return [{'error': ErrorEnums.NO_USER_FOUND_ERROR.value}, 404] if not self.target_user.is_active: return [{'error': ErrorEnums.INACTIVE_USER_ERROR.value}, 404] if action not in [ UserEnums.FOLLOW.value, UserEnums.UNFOLLOW.value ]: return [{'error': ErrorEnums.UNKNOWN_REQUEST_ERROR.value}, 400] self._performer = UserDatabaseService.get_active_user_by_email( requesting_user_email) self.user_dao = UserDatabaseService() response = self.user_dao.follow_unfollow_user( user_dto(self._performer), user_dto(self.target_user), action) if isinstance(response, dict): return [response, 500] return [{'response': 'SUCCESS.'}, 200] except Exception as e: return [{'error': 'Exception - {} - occurred.'.format(e)}, 400]
def confirm_if_username_or_email_exists_already_during_registration(user_email: str, user_name: str) -> dict: user_instance = UserDatabaseService.get_active_inactive_single_user_by_email(user_email) if user_instance: return {'result': True, 'value': ErrorEnums.EMAIL_ALREADY_EXISTS_ERROR.value} alt_username_user = UserDatabaseService.get_user_by_alt_username(user_name) username_instance = UserDatabaseService.get_user_by_username(user_name) if username_instance or alt_username_user: return {'result': True, 'value': ErrorEnums.USER_NAME_ALREADY_EXISTS.value}
def admin_access(performer, user_email: str, permission_type: str) -> list: user = UserDatabaseService.get_active_inactive_single_user_by_email(user_email) if not user.is_active: return [{'error': 'Cannot grant access as the user is inactive. Please activate the user profile first.'}, 400] access_type = AdminPermissionEnums.__dict__.get(permission_type.upper()) UserDatabaseService.admin_access(performer, user_email, access_type.value) verify_user_access = UserDatabaseService.get_active_user_by_email(user_email).is_admin if verify_user_access is True: return [{'response': 'User granted admin privileges.'}, 200] elif verify_user_access is False: return [{'response': 'User revoked from admin privileges.'}, 200] return [{'error': 'There was some error.'}, 500]
def create_update_user(user_identity, user_request_details: dict, user_identity_provided: bool): phone_length_is_valid = is_phone_vaild(user_request_details.setdefault('phone_number', None)) if not phone_length_is_valid: return ErrorEnums.INVALID_PHONE_LENGTH_ERROR.value user_request_details.__setitem__( 'date_of_birth', TimeUtils.convert_time( user_request_details.get('date_of_birth') ) ) if user_request_details.get('date_of_birth') else None if not user_identity_provided: if not validate_email_format(user_request_details.get('email')): return ErrorEnums.INVALID_EMAIL_FORMAT_ERROR.value if not validate_password_format(user_request_details.get('password')): return ErrorEnums.INVALID_PASSWORD_ERROR.value user_request_details.__setitem__('password', UserSecurity.encrypt_pass(user_request_details.get('password'))) created_user = UserDatabaseService.create_user(user_request_details) if isinstance(created_user, str): return created_user return dataStateAccess.UserDTO.user_dto(created_user) if user_request_details.get('email'): if not validate_email_format(user_request_details.get('email')): return ErrorEnums.INVALID_EMAIL_FORMAT_ERROR.value if user_request_details.get('email') and user_identity.get('email') != user_request_details.get('email'): verify_existence_for_user_email = UserDatabaseService.get_active_user_by_email(user_request_details.get('email')) if verify_existence_for_user_email: return ErrorEnums.EMAIL_ALREADY_EXISTS_ERROR.value if user_request_details.get('username'): if user_request_details.get('username') and user_identity.get('username') != user_request_details.get('username'): verify_username_existence = UserDatabaseService.get_active_user_by_username(user_request_details.get('username')) verify_alt_username_existence = UserDatabaseService().get_user_by_alt_username(user_request_details.get('username')) if verify_username_existence or verify_alt_username_existence: return ErrorEnums.USER_NAME_ALREADY_EXISTS.value updated_user = UserDatabaseService.update_user_generic_data(user_identity, user_request_details) if isinstance(updated_user, str): return updated_user return dataStateAccess.UserDTO.user_dto(updated_user)
def mark_unmark_book_as_favourite(user, book_id, action): print( 'INFO: Request to add/remove book as favourite by user: {} for bookId: {} with action {}. Session - {}.'.format( user, book_id, action, user.get('_session_signature') )) book_service = BookCreateUpdateService() user_dao = UserDatabaseService() books = user_dao.get_favourite_books_ids_by_email(user.get('email')) if book_id in books and action == UserEnums.MARK.name: return [{'error': 'Book is already marked as favourite.'}, 400] if book_id not in books and action == UserEnums.REMOVE.name: return [{'error': 'Book is not listed as a favourite.'}, 400] book = book_service.get_active_book_by_id(book_id) if isinstance(book, list): return book user_dao.set_unset_book_as_favourite(user, book, action) response = UserEnums.MARK.value if action == UserEnums.MARK.name else UserEnums.REMOVE.value return response
def verify_id_email_for_email_update(uid, email): user = UserDatabaseService.get_user_by_id(uid) if not user: return {'result': False, 'error': 'No user found with id {}.'.format(uid)} if isinstance(user, dict) and 'error' in user.keys(): return user if user and user.email != email: return {'result': False, 'error': 'Mismatch in id and oldEmail. Please correct the pair and retry again.'} return True
def update_user_email(user, old_em, new_em): is_length_invalid = UserUtils.verify_email_length(old_em, new_em) if is_length_invalid: return is_length_invalid u = get_existing_user_by_id(user['id']) if 'error' in u.keys(): return [u, 500] if u['email'] != old_em: return [{'error': '{} does not match your current email address. Please check and try again.'.format(old_em)}, 404] elif old_em == new_em: return [{'error': 'Email is already up to date for the user.'}, 200] email_exists_already = verify_if_email_already_exists(new_em) if email_exists_already: return [{'error': 'Cannot update email as the user with email id - {} already exists.'.format(new_em)}, 409] updated_user = UserDatabaseService.update_email(user, new_em) return updated_user
def update_user_name(user: dict, old_username: str, new_username: str): is_length_verified = UserUtils.verify_username_length(old_username, new_username) if is_length_verified: return is_length_verified user = get_existing_user_by_id(user['id']) if 'error' in user.keys(): return [user, 500] elif old_username != user['username']: return [ { 'Error': '{} does not match the current username. Please correct your username and retry again.' .format(old_username) }, 404 ] elif old_username == new_username: return [{'error': 'Username is already up to date for the user.'}, 200] if verify_if_username_already_exists(new_username): return [{'error': 'User with username - {} already exists.'.format(new_username)}, 409] response = UserDatabaseService.update_username(user, new_username) return response
def get_active_user_by_email(email): user = UserDatabaseService.get_active_user_by_email(email) return dataStateAccess.UserDTO.user_dto(user)
def get_existing_user_by_email(email): user = UserDatabaseService.get_active_inactive_single_user_by_email(email) if not user: return {'error': 'No user found for email {}.'.format(email)} return dataStateAccess.UserDTO.user_dto(user)
def get_existing_user_by_username(username): user = UserDatabaseService.get_user_by_username(username) return dataStateAccess.UserDTO.user_dto(user)
def confirm_if_user_name_already_exists(username): user_instance = UserDatabaseService.get_user_by_username(username) if user_instance.username == username: return True return False
def get_all_users() -> list: users_from_persistence = UserDatabaseService.get_all_active_users() aggregated_result = [] for user in users_from_persistence: aggregated_result.append(dataStateAccess.UserDTO.user_dto(user)) return aggregated_result
class UserSocialService: def __init__(self): self.user = None self.target_user = None self.user_followers = [] self.user_following = [] self.blocked_users = [] self.user_dao = None self._performer = None def follow_unfollow_a_user(self, requesting_user_email: str, user_to_be_followed_unfollowed_email: str, action) -> list: try: if requesting_user_email == user_to_be_followed_unfollowed_email: return [{ 'error': ErrorEnums.INVALID_INPUT_SUPPLIED_ERROR.value }, 400] self.target_user = UserDatabaseService.get_active_inactive_single_user_by_email( user_to_be_followed_unfollowed_email) if not self.target_user: return [{'error': ErrorEnums.NO_USER_FOUND_ERROR.value}, 404] if not self.target_user.is_active: return [{'error': ErrorEnums.INACTIVE_USER_ERROR.value}, 404] if action not in [ UserEnums.FOLLOW.value, UserEnums.UNFOLLOW.value ]: return [{'error': ErrorEnums.UNKNOWN_REQUEST_ERROR.value}, 400] self._performer = UserDatabaseService.get_active_user_by_email( requesting_user_email) self.user_dao = UserDatabaseService() response = self.user_dao.follow_unfollow_user( user_dto(self._performer), user_dto(self.target_user), action) if isinstance(response, dict): return [response, 500] return [{'response': 'SUCCESS.'}, 200] except Exception as e: return [{'error': 'Exception - {} - occurred.'.format(e)}, 400] def block_unblock_a_user(self, requestor_users_email: str, user_to_be_blocked_unblocked_email: str, action) -> list: try: if requestor_users_email == user_to_be_blocked_unblocked_email: return [{ 'error': ErrorEnums.INVALID_INPUT_SUPPLIED_ERROR.value }, 400] self.target_user = UserDatabaseService.get_active_inactive_single_user_by_email( user_to_be_blocked_unblocked_email) if not self.target_user: return [{'error': ErrorEnums.NO_USER_FOUND_ERROR.value}, 404] if not self.target_user.is_active: return [{'error': ErrorEnums.INACTIVE_USER_ERROR.value}, 404] if action not in [ str(UserEnums.BLOCK.value), str(UserEnums.UNBLOCK.value) ]: return [{'error': ErrorEnums.UNKNOWN_REQUEST_ERROR.value}, 400] self._performer = UserDatabaseService.get_active_user_by_email( requestor_users_email) self.user_dao = UserDatabaseService() self.user_dao.block_unblock_users(user_dto(self._performer), user_dto(self.target_user), action) return [{'response': 'SUCCESS.'}, 200] except Exception as e: return [{ 'error': ErrorEnums.EXCEPTION_ERROR.value.format( e, "block/unblock user request") }, 400]
def update_password(user, old_password, new_password): if not validate_password_format(old_password) or not validate_password_format(new_password): return [ErrorEnums.INVALID_PASSWORD_ERROR.value, 404] persisted_p, requested_p = SecurityUtils.encrypt_pass(old_password), SecurityUtils.encrypt_pass(new_password) updated_user = UserDatabaseService.update_password(user, persisted_p, requested_p) return updated_user
def get_existing_user_by_id(identity) -> dict: user = UserDatabaseService.get_user_by_id(identity) # gives an object if isinstance(user, dict): return user return dataStateAccess.UserDTO.user_dto(user)