Beispiel #1
0
    def register_user(email, password, nick_name):
        """
        This method registers a user using e-mail and password
        The password already comes hashed as sha-512
        :param email: user's email (might be invalid)
        :param password: sha512-hashed password
        :return: True if registered successfully, of False otherwise (exceptions can also be raised)
        """
        user_data = Database.find_one(UserConstants.COLLECTION,
                                      {"email": email})

        if user_data is not None:
            # Tell user they are already registered
            raise UserErrors.UserAlreadyRegisteredError(
                "The e-mail you used to register already exists.")

        if not Utils.email_is_valid(email):
            # Tell user that their e-mail is not constructed properly.
            raise UserErrors.InvalidEmailError(
                "The e-mail does not have the right format.")

        if nick_name == '' or nick_name == None:

            User(email, Utils.hash_password(password),
                 nick_name=None).save_to_mongo()

        else:
            User(email, Utils.hash_password(password),
                 nick_name=nick_name).save_to_mongo()

        return True
Beispiel #2
0
    def register_user(username,
                      email,
                      password,
                      confirm_pass,
                      user_type,
                      institution=None):
        user_data = Database.find_one("users", {"username": username})

        if user_data is not None:
            raise UserErrors.UserAlreadyExistsError(
                "This username already exists. Try using a different username")

        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailFormat("Wrong email format")

        if not password == confirm_pass:
            raise UserErrors.PasswordMatchError("Passwords don't match")

        if institution is None:
            Users(username, email, Utils.hash_password(password),
                  user_type).save_to_db_user()

        elif institution is not None:
            Users(username, email, Utils.hash_password(password), user_type,
                  institution).save_to_db_owner()

        return True
Beispiel #3
0
    def register_user(cls, name: str, lastname: str, email: str,
                      password: str) -> bool:
        """
        This method registers a user using e-mail and password.
        :param email: user's e-mail (might be invalid)
        :param password: password
        :return: True if registered successfully, or False otherwise (exceptions can also be raised)
        """

        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                "The e-mail does not have the right format.")

        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError(
                "The e-mail you used to register already exists.")
        except UserErrors.UserNotFoundError:
            User(name,
                 lastname,
                 email,
                 Utils.hash_password(password),
                 create_date=now_string(),
                 update_date=now_string()).save_to_mongo()

        return True
Beispiel #4
0
 def register_user(cls, email: str, password: str) -> bool:
     if not Utils.email_is_valid(email):
         raise UserErrors.InvalidEmailError('The e-mail does not have the right format.')
     try:
         user = cls.find_by_email(email)
         raise UserErrors.UserAlreadyRegisteredError('The email you used to register already exists.')
     except UserErrors.UserNotFoundError:
         User(email, Utils.hash_password(password)).save_to_mongo()
     return True
Beispiel #5
0
    def register(cls, email, password):
        user = cls.get_by_email(email)
        if user is not None:
            return f"{email} already exists"
        if not Utils.email_is_valid(email):
            return "Email is not in correct format"

        new_user = cls(email, password)
        new_user.save_to_mongo()
        return True
    def login_valid(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise errors.InvalidEmail("The format of email is wrong")

        user = cls.get_by_email(email)

        if not Utils.check_hashed_passwords(password, user.passsord):
            raise errors.WrongPassword("The password is incorrect!")

        return True
Beispiel #7
0
 def register_user(cls, email: str, password: str) -> bool:
     if not Utils.email_is_valid(email):
         raise UserErrors.InvalidEmailError('Invalid email format')
     try:
         cls.find_by_email(email)
         raise UserErrors.UserAlreadyRegisteredError(
             'The email already exists')
     except UserErrors.UserNotFoundError:
         User(email, Utils.hash_password(password)).save_to_mongo()
     return True
    def register_user(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise errors.InvalidEmail("The format of email is wrong")

        try:
            cls.get_by_email(email)
            raise errors.UserExists("This user is already registered!")
        except errors.UserNotFound:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #9
0
    def register_user(cls, name: str, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError("The  e-mail does not have a right format!")

        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError("The  e-mail you used already exists!")
        except UserErrors.UserNotFoundError:
            User(name, email, password).save_to_mongo()

        return True
Beispiel #10
0
    def register_user(cls, email:str, password:str):
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError("The email does not have the right format.")

        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError('A user with this email already exists.')

        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #11
0
    def register_user(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                "The email is not correctly formatted")

        try:
            cls.find_by_email(email)
            session['email'] = email
            raise UserErrors.UserAlreadyRegisteredError("User already exists")
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()
        return True
Beispiel #12
0
    def register_user(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError('Email incorrecto')

        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError(
                'El email introducido ya existe')
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #13
0
 def register_user(email, password, name, address, ph_no, card_no):
     user_data = Database.find_one(UserConstants.COLLECTION,
                                   {"email": email})
     if user_data is not None:
         raise UserErrors.UserAlreadyRegisteredError(
             "The email you used to register already exists.")
     if not Utils.email_is_valid(email):
         raise UserErrors.InvalidEmailError(
             "The email does not have the right format.")
     User(name, email, Utils.hash_password(password), address, ph_no,
          card_no).save_to_db()
     return True
Beispiel #14
0
    def register_user(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            # This shouldn't really be called because the form validation should catch if it is an email type
            raise UserErrors.InvalidEmailError(
                'The email does not have the right format.')
        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError(
                'The registering email already exists.')
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #15
0
    def register_user(cls, email: str, password: str):
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError('Email id is not valid')

        #try:
        user = cls.find_by_email(email)
            #for users in user:
        if len(user) > 0:
            raise UserErrors.UserAlreadyRegisteredError('User with this email {} is already registered'.format(email))
        else:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #16
0
    def register_user(cls, email: str, password: str) -> bool:
        # Checking if e-mail format is correct
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError("This e-mail does not have the right format ! ")

        # Trying to check if user already exists
        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegistered("There is already a user registered in this e-mail id ! ")
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #17
0
    def register_user(cls, email: str, password: str) -> bool:
        # check that email is in correct format -- return invalid email error if not
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError('The e-mail does not have the correct format.')

        # if it is in the correct format, check if user already exists -- if so return error saying that user already exists
        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError('The e-mail you used to register already exists.')
        # if the user does not exist, make a new one
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #18
0
 def register_user(cls, email: str, password: str) -> bool:
     if not Utils.email_is_valid(email):
         # email is invalid
         raise errors.InvalidEmailError(
             'The email does not have the right format.')
     try:
         cls.find_by_email(email)  # this just checks it
         # email already exists
         raise errors.UserAlreadyExistsError(
             'The email you used to register already exists.')
     except errors.UserNotFoundError:
         # success!
         User(email, Utils.hash_password(password)).register_model(
             User(email, Utils.hash_password(password)))
     return True
Beispiel #19
0
 def register_user(email, password):
     """
     This method register a user with email and sha-512 password
     :param email: user email
     :param password: already comes in sha_512 encryption
     :return: returns true if the credentials are valid Else return False
     """
     user_data = Database.find_one(UserConstant.COLLECTION, {"email": email})
     if user_data is not None:
         #Tell user that they are already registered
         raise UserErrors.UserAlreadyExist("The email you are trying to register already exist")
     if not Utils.email_is_valid(email):
         # Tell that there email is not valid
         raise UserErrors.InvalidEmail("The email your are trying to register is not valid")
     User(email, Utils.hashed_password(password)).save_to_db()
     return True
    def register_user(cls, email: str, password: str) -> bool:
        # First verify that the email is a valid email address
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailERror(
                'The email does not have the right format.')

        # Next check to see if the email address is already a registered user
        if (cls.find_by_email(email) != None):
            raise UserErrors.UserAlreadyRegisteredError(
                'The email you used to register already exists.')
        else:
            user = User(email, Utils.hash_password(password))
            print(user)
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #21
0
 def register_user(email, password):
     """
     This method registers a user using  e-mail and password.
     The password already come with sha-512 hash algorithm.
     :param email: user's email (might be invalid)
     :param password: sha512-hashed password
     :return: True if registered successfully, of False otherwise
     """
     userData = Database.find_one("users", {'email': email})
     if userData is not None:
         raise UserExistsError("user already existed!")
     #if email is invalid, then what?
     if not Utils.email_is_valid(email):
         raise UserEmailInvalid("invalid email!")
     #hash password, create new object, then insert to db
     User(email, Utils.hash_password(password)).save_to_db()
     return True
    def register_user(cls, email: str, password: str) -> bool:
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError('The e-mail does not have the right format.')

        try:
            user = cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError('The e-mail you used to register already exists.')

        return True

        def json(self) -> Dict:
            return {
                '_id': self.id,
                'email': self.email,
                'password': self.password
            
            }
Beispiel #23
0
 def register_user(email, password):
     """
     This method registers a user using e-mail and password.
     The password already comes hashed as sha-512.
     """
     user_data = Database.find_one("users", {"email": email})
     if user_data is not None:
         flash(
             f'The e-mail {email} you used to register already exists. Try again or'
         )
         redirect(url_for('login'))
         return False
     if not Utils.email_is_valid(email):
         flash('The e-mail does not have the right format. Try again!')
         redirect(url_for('signup'))
         return False
     User(email, Utils.hash_password(password)).save_to_db()
     return True
Beispiel #24
0
    def register_user(email, password):
        """
        Registers user using Email and Password
        :param email: users email id (can be invalid)
        :param password: sha512-hashed password
        :return: True if registered succesfully
        """
        user_data = Database.find_one('users', {"email": email})

        if user_data is not None:
            raise UserErrors.UserAlreadyRegisteredError(
                "The e-mail already Exists")
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                "This e-mail is not in the right format.")

        User(email, Utils.hash_password(password)).save_to_db()

        return True
Beispiel #25
0
    def register_user(email, password):
        """
        This method registers a user using e-mail and password.
        The password already comes hashed as sha-512.
        :param email: user's e-mail (may be invalid)
        :param password: sha512-hashed password
        :return: True if registered successfully, False otherwise (exceptions can also be raised)
        """
        user_data = Database.find_one('users', {"email": email})

        if user_data is not None:
            # if user exists
            raise UserErrors.UserAlreadyRegisteredError("This email already exists!")
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError("The email does not have correct format.")

        User(email, Utils.hash_password(password)).save_to_db()

        return True
Beispiel #26
0
    def register_user(email, password):
        """
        This method registers a user using e-mail and password.
        The password already comes hashed as sha-512.
        :param email: user's e-mail (might be invalid)
        :param password: sha512-hashed password
        :return: True if registered successfully, or False otherwise (exceptions can also be raised)
        """
        user_data = Database.find_one(UserConstants.COLLECTION, {"email": email})

        if user_data is not None:
            raise UserErrors.UserAlreadyRegisteredError("The e-mail you used to register already exists.")
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError("The e-mail does not have the right format.")

        user = User(email, Utils.hash_password(password))
        user.save_to_db()

        return user
Beispiel #27
0
    def register_user(cls, email: str, password: str) -> bool:
        """
        This method registers a user using e-mail and password.
        :param email: user's e-mail (might be invalid)
        :param password: password
        :return: True if registered successfully, or False otherwise (exceptions can also be raised)
        """
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                'The e-mail does not have the right format.')

        try:
            cls.find_by_email(email)
            raise UserErrors.UserAlreadyRegisteredError(
                'The e-mail is already registered.')

        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

            return True
Beispiel #28
0
    def register_user(email: str, password: str) -> bool:
        """
        This method registers a user using e-mail and password.
        The password already comes hashed as sha-512.
        :param email: user's e-mail (might be invalid)
        :param password: sha512-hashed password
        :return: True if registered successfully, or False otherwise (exceptions can also be raised)
        """
        user_data = Database.find_one("users", {"email": email})

        if user_data is not None:
            raise UserErrors.UserAlreadyRegisteredError(
                "The e-mail you used to register already exists.")
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                "The e-mail does not have the right format.")

        User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #29
0
    def register_user(email, password, name, phone_no, gender, dob):
        """
        This method registers a user to the database using the entered details.
        The password already comes in a sha512 hashed format
        :param email: Email entered by the user
        :param password: sha512 hashed password
        :return: True if registration is successful, an exception is raised otherwise

        """
        # user_data = Database.find_one(COLLECTION, {'email': email})
        user_data = Database.find_user_email(email)
        if user_data is not None:
            raise UserErrors.UserAlreadyRegisteredError(
                'This email is already registered with us.')
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                'The email is not of a valid format')

        User(email, Utils.hash_password(password), name, phone_no, gender,
             dob).save_to_database()
        return True
Beispiel #30
0
    def register_user(cls, email: str, password: str) -> bool:
        """
        Registers a :class:`.User`.

        Parameters
        ----------
        email : str
            The email to register with.
        password : str
            The password to register with.

        Returns
        -------
        bool
            True if :class:`.User` was successfully registered, False otherwise.

        Raises
        ------
        UserErrors.InvalidEmailError
            If an invalid email was provided.
        UserErrors.UserAlreadyRegisteredError
            If the :class:`.User` has already been registered.
        UserErrors.UserNotFoundError
            If the :class:`.User` was not found.

        """
        if not Utils.email_is_valid(email):
            raise UserErrors.InvalidEmailError(
                "The e-mail does nothvae the right format.")
        try:
            user = cls.find_by_email(email)
            logger.debug(f"user already found: {user}")
            raise UserErrors.UserAlreadyRegisteredError(
                "The e-mail you used to register already exists.")
        except UserErrors.UserNotFoundError:
            User(email, Utils.hash_password(password)).save_to_mongo()

        return True
Beispiel #31
0
 def register_user(cls, email: str, password: str):
     if not Utils.email_is_valid(email):
         # email is invalid
         raise errors.InvalidEmailError('The email does not have the right format.')
     # try:
     #     cls.find_by_email(email)  # this just checks it
     #     # email already exists
     #     raise errors.UserAlreadyExistsError('The email you used to register already exists.')
     # except errors.UserNotFoundError:
     #     # success!
     # try:
     Database.insert(email, {
             'password': Utils.hash_password(password),
             'timesSlouched': [
                 {'date': "2019-09-09", 'numSlouch': 7},
                 {'date': "2019-09-10", 'numSlouch': 13},
                 {'date': "2019-09-11", 'numSlouch': 15},
                 {'date': "2019-09-12", 'numSlouch': 10},
                 {'date': "2019-09-13", 'numSlouch': 7},
                 {'date': "2019-09-14", 'numSlouch': 11},
                 {'date': "2019-09-15", 'numSlouch': 0}
             ]
     })