Exemple #1
0
def load_users():
    """ Load users into our database """

    a = User(username="******",
             email="*****@*****.**",
             password=bcrypt.generate_password_hash('12').decode('utf-8'))
    b = User(username="******",
             email="*****@*****.**",
             password=bcrypt.generate_password_hash('23').decode('utf-8'),
             image_file='eevee.gif')
    c = User(username="******",
             email="*****@*****.**",
             password=bcrypt.generate_password_hash('kbr').decode('utf-8'),
             image_file='rex.jpg')
    d = User(username="******",
             email="*****@*****.**",
             password=bcrypt.generate_password_hash('jedi').decode('utf-8'),
             image_file='luke-skywalker.jpg')
    e = User(username="******",
             email="*****@*****.**",
             password=bcrypt.generate_password_hash('n64').decode('utf-8'),
             image_file='yoshi.png')

    db.session.add_all([a, b, c, d, e])
    db.session.commit()
    print('Users 😚')
Exemple #2
0
 def __init__(self, email, password, admin=False):
     self.email = email
     self.password = bcrypt.generate_password_hash(
         password, app.config.get('BCRYPT_LOG_ROUNDS')
     ).decode()
     self.registered_on = datetime.datetime.now()
     self.admin = admin
Exemple #3
0
def register():
    if request.method == 'POST':
        # Get username and password from the POST request.
        username = request.form.get('username')
        password = request.form.get('password')
        if not (len(username) > 4 and len(username) < 16) or not (
                len(password) > 6 and len(password) < 42):
            return abort(
                403,
                "Username must be between 4 and 16 characters, and password must be between 6 and 42."
            )
        hashed_password = bcrypt.generate_password_hash(password).decode(
            "UTF-8")
        isadmin = False
        if username.lower() == 'throupy' or username.lower() == 'chadders':
            isadmin = True
        # Instantiate and add a user object.
        user = models.User(username=username,
                           money=5.00,
                           password=hashed_password,
                           is_admin=isadmin)
        # Dice Game Statistics Child Model
        diceGameStats = models.DiceGameStats(parentUser=user)
        blackjackGameStats = models.BlackjackGameStats(parentUser=user)
        blackJackHand = models.BlackJackHand(player=user)
        db.session.add(user)
        db.session.add(diceGameStats)
        db.session.add(blackJackHand)
        db.session.add(blackjackGameStats)
        db.session.commit()
        return f"User Inserted - {username} : {password}"
    return abort(403, "Method not allowed for this endpoint")
Exemple #4
0
def reset_token(token):
    # Check if user is logged in
    if current_user.is_authenticated:
        return redirect(url_for('main.home'))

    # Validate token
    user = User.verify_reset_token(token)

    # Provide feedback for non-valid token
    if user is None:
        flash('You provided and invalid or expired token...', 'warning')
        return redirect(url_for('resent_request'))

    # Initialize form object
    form = ResetPasswordForm()

    # Validate form POST
    if form.validate_on_submit():
        # Hash user password
        hashed_pw = bcrypt.generate_password_hash(
            form.password.data).decode('utf-8')

        # Update user password
        user.password = hashed_pw
        db.session.commit()

        # User feedback message
        flash('Your password has been updated! You are able to log in',
              'success')
        return redirect(url_for('users.login'))

    return render_template('reset_token.html',
                           title='Reset Password',
                           form=form)
Exemple #5
0
def register():
    # Check if user is logged in
    if current_user.is_authenticated:
        return redirect(url_for('main.home'))

    # Initialize form object
    form = RegistrationForm()

    # Validate form POST
    if form.validate_on_submit():
        # Hash user password
        hashed_pw = bcrypt.generate_password_hash(
            form.password.data).decode('utf-8')

        # Create new user
        user = User(username=form.username.data,
                    email=form.email.data,
                    password=hashed_pw)
        db.session.add(user)
        db.session.commit()

        # User feedback message
        flash('Your account has been created! You are able to log in',
              'success')
        return redirect(url_for('users.login'))

    return render_template('register.html', title='Register', form=form)
Exemple #6
0
    def addUser(self, form_result_map):

        db_connection = dbapi2.connect(global_database_url)
        cursor = db_connection.cursor()

        name = form_result_map['firstname']
        surname = form_result_map['lastname']
        nickname = form_result_map['nickname']
        email = form_result_map['email']

        password = form_result_map['password']
        hashed_password = bcrypt.generate_password_hash(password).decode(
            'utf-8')

        status = form_result_map['status']
        city = form_result_map['city']

        universities_table = universitiesTable()
        university_name = form_result_map['university_selection']
        if university_name != 'None':
            university_id = universities_table.getUniversityIDbyName(
                university_name)
            university_id_as_str = str(university_id)
        else:
            university_id_as_str = "NULL"

        add_user_query = "INSERT INTO users (name, surname, nickname, email, password, status, city, university_id) VALUES('%s','%s','%s','%s','%s','%s','%s',%s)" % (
            name, surname, nickname, email, hashed_password, status, city,
            university_id_as_str)

        cursor.execute(add_user_query)
        db_connection.commit()
        cursor.close()
Exemple #7
0
def register():
	form = RegisterForm(request.form)
	if request.method == 'POST':
		try:
			form.validate()
			if User.model.objects().all().count() == 0:
				role_name = 'owner'
			else:
				role_name = 'follower'

			user = User(
				name=form.name.data,
				email=form.email.data,
				password=bcrypt.generate_password_hash(form.password.data),
				role=Role(name=role_name).get()
			).save()
			if login_user(user):
				return redirect(url_for('nest.home'))
			else:
				return redirect(url_for('auth.login'))
		except (DoesNotExist, ValidationError) as e:
			message = str(e)
		except NotUniqueError:
			message = 'Email address already registered. [login?](/login)'
	return render('register.html', mod='auth', markdown=True, **locals())
 def __init__(self, email, password, admin=False):
     self.email = email
     self.password = bcrypt.generate_password_hash(
         password, app.config.get('BCRYPT_LOG_ROUNDS')
     )
     self.registered_on = datetime.datetime.now()
     self.admin = admin
 def post(self):
     users = mongo_db.db.users
     login_user = users.find_one({'email': request.json['email']})
     if not login_user:
         try:
             user_name = request.json['name']
             email = request.json['email']
             password = bcrypt.generate_password_hash(
                 request.json['password'],
                 app.config.get('BCRYPT_LOG_ROUNDS')).decode()
             users.insert({
                 'name': user_name,
                 'email': email,
                 'password': password
             })
             response_object = {
                 'status': 'success',
                 'message': 'Successfully registered.',
             }
             return make_response(jsonify(response_object)), 201
         except Exception as e:
             print(e)
             response_object = {'status': 'fail', 'message': 'Try again'}
             return make_response(jsonify(response_object)), 500
     else:
         response_object = {
             'status': 'fail',
             'message': 'User already exists. Please Log in.',
         }
         return make_response(jsonify(response_object)), 202
Exemple #10
0
def home():
    form = RegistrationForm()
    if form.validate_on_submit():
        salt_pw = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(64)) + \
               form.password.data
        salt_api_key = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(64)) + \
               form.password.data
        form.password.data += salt_pw
        hashed_pw = bcrypt.generate_password_hash(form.password.data).decode("utf-8")
        user_id = models.User.query.limit(1).all()
        user_id[0] += 1
        api_key = user_id[0] + salt_pw + salt_api_key

        try:
            user = models.User(
                email=form.email.data, password=hashed_pw, address=form.address.data,
                api_key=api_key, salt_pw=salt_pw
            )

            db.session.add(user)
            db.session.commit()

            return flask.redirect(flask.url_for("test"))
        except:
            flask.flash("Some error occured", category="danger")
            return flask.redirect(flask.url_for("/"))

    return flask.render_template("index.html", footer_bg="white", form=form)
Exemple #11
0
def register():
    username = request.json.get('username')
    password = request.json.get('password')
    mail = request.json.get('email')
    user = User.query.filter_by(username=username).first()
    email = User.query.filter_by(email=mail).first()
    if user:
        return jsonify(
            result={
                'message': 'Konto o podanej nazwie użytkownika już istnieje.',
                'category': 'danger'
            })
    if email:
        return jsonify(
            result={
                'message': 'Konto o podanym adresie email już istnieje!',
                'category': 'danger'
            })
    hashed_password = bcrypt.generate_password_hash(password).decode('utf-8')
    newUser = User(username=username,
                   password=hashed_password,
                   email=mail,
                   registered_on=datetime.now())
    token = generate_confirmation_token(newUser.email)
    confirm_url = url_for('auth.confirm_email', token=token, _external=True)
    subject = "Potwierdź swoje konto"
    send_email(newUser.email, subject, confirm_url)
    db.session.add(newUser)
    db.session.commit()
    return jsonify(
        result={
            'message':
            'Rejestracja przebiegła pomyślnie, na podany adres email została wysłana wiadomość z linkiem wymaganym do dokończenia rejestracji.',
            'category': 'succes'
        })
Exemple #12
0
 def __init__(self, user_id, password, currency):
     self.user_id = user_id
     self.password = bcrypt.generate_password_hash(password, app.config['BCRYPT_LOG_ROUNDS']).decode()
     self.balance = 0.0
     self.currency = currency
     self.state = True
     self.created_at = self.updated_at = datetime.datetime.utcnow().isoformat()
Exemple #13
0
def login():
    '''
        login 
        1. check validity of email such as [email protected] etc...
        2. via digest to compare user input password and password in the DB
    '''
    if current_user.is_authenticated:
        return redirect(url_for('home'))
    form = LoginForm()
    if form.validate_on_submit():
        user = User.query.filter_by(email=form.email.data).first()
        if not user:
            flash('Login Failed,Please Check Your Email', 'danger')
            return render_template('login.html', title='Login', form=form)
        '''
            To compare hashpassword (backend and user-input)
        '''
        hashed_password = bcrypt.generate_password_hash(user.password)
        if bcrypt.check_password_hash(hashed_password, form.password.data):
            login_user(user, remember=form.remember.data)
            next_page = request.args.get('next')
            return redirect(next_page) if next_page else redirect(
                url_for('home'))
            #return '<p>White Test two Digests are The Same</p>'
        else:
            #return 'White Test two Digests are not The Same'
            flash('Login Failed,Please check your Password', 'danger')
    return render_template('login.html', title='Login', form=form)
Exemple #14
0
def reset_password(token):
    global tokens
    try:
        if not confirm_token(token):
            raise BadToken()
        if [token for t in tokens]:
            raise BadToken()
        email = confirm_token(token)
        user = User.query.filter_by(email=email).first_or_404()
        password = request.json.get('password')
        hashed_password = bcrypt.generate_password_hash(password).decode(
            'utf-8')
        user.password = hashed_password
        tokens.append(token)
        db.session.commit()
    except BadToken:
        return jsonify(
            result={
                'message':
                'Link resetowania hasła wygasł lub jest nieprawidłowy, skontaktuj się z administratorem serwisu',
                'category': 'warning'
            })
    return jsonify(
        result={
            'message': 'Hasło do konta zostało pomyślnie zresetowane.',
            'category': 'success'
        })
Exemple #15
0
    def post(self):
        args = parser.parse_args()
        user_id = get_jwt_identity()['id']

        # Check if passwords are the same
        if args['password'] is not None and args['passwordConfirm'] != args[
                'password']:
            return response(
                {'errors': ['Password and Confirm Password must be same']},
                400)

        # Check if the email is already taken or not
        email = args['email']
        user = User().where('email', email).first()
        if user.exists() and user.ATTRIBUTES['id'] != user_id:
            return response({'errors': ['This email is already taken']}, 400)

        # Update user
        user = User().where('id', '=', user_id).first()
        if user.exists() is True:
            user.update({
                'name':
                args['name'],
                'email':
                args['email'],
                'slug':
                user.generateSlug(name=args['name']),
                'password':
                bcrypt.generate_password_hash(args['password']).decode('utf-8')
            })
            return response({'user': user.data()})

        return response({'errors': ['User could not found']}, 404)
Exemple #16
0
    def post(self):
        args = parser.parse_args()
        password = args['password']
        password_confirm = args['passwordConfirm']

        if password != password_confirm:
            return response({'errors': ['Passwords do not match']}, 401)

        # Rule 2
        user = User()
        user.create({
            'name':
            args['name'],
            'email':
            args['email'],
            'password':
            bcrypt.generate_password_hash(args['password']).decode('utf-8'),
            'slug':
            user.generateSlug(args['name'])
        })
        if user.validate() is False:
            return response({'errors': user.getErrors()}, 401)

        user.save()
        return response({
            'user':
            user.plus('token',
                      user.generateToken()['jwt']).plus(
                          'admin', user.hasRole('admin')).data()
        })
Exemple #17
0
def load_users():
    """Load users from user_data into database."""

    # Delete all rows in table, so if we need to run this a second time,
    # we won't be trying to add duplicate users
    # User.query.delete()

    # Read user_data file and insert datat
    for line in open("seed_data/user_data"):
        line = line.rstrip()
        user_id, fname, lname, username, email, phone_number, password, notification = line.split(
            ",")

        hashed_pw = bcrypt.generate_password_hash(password)

        user = User(user_id=user_id,
                    fname=fname,
                    lname=lname,
                    username=username,
                    email=email,
                    phone_number=phone_number,
                    password=hashed_pw,
                    notification=notification)

        # We need to add to the session or it won't be stored
        db.session.add(user)

    #Once we're done, we should commit our work
    db.session.commit()
Exemple #18
0
def create_user(_):
    """
    Creates a new User.
    ---
    tags:
      - user
    summary: Create User
    requestBody:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/User'
      description: Created user object
      required: true
    responses:
      default:
        description: successful operation
      400:
        description: email already exists
    """
    data = request.get_json()
    if not data:
        raise BadRequest()
    data["password"] = bcrypt.generate_password_hash(
        data["password"],
        current_app.config.get("BCRYPT_LOG_ROUNDS")).decode()
    user = User(**data)
    user.save()
    res = {"status": "success", "message": "user was added!"}
    return res, 201
def make_new_user(u):
    # hash password
    hashed = bcrypt.generate_password_hash(u['password'])
    # make new user entry
    # add new user entry to the table
    #__init__(self, created_at, username, pw_hash, email, name_title, name_first, name_last, gender, location, birthday)
    session.add(User(str(datetime.datetime.now()), u['username'], hashed, u.get('email', ''), u.get('name_title', ''), u.get('name_first', ''), u.get('name_last', ''), u.get('profile_pic', ''), u.get('gender', ''), u.get('location', ''), u.get('birthday', ''),u.get('skin_tone', '')))
    session.commit()
    return None
Exemple #20
0
 def __init__(self,
              username,
              email,
              password,
              created_at=datetime.datetime.utcnow()):
     self.username = username
     self.email = email
     self.password = bcrypt.generate_password_hash(
         password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
     self.created_at = created_at
Exemple #21
0
def register():  # method that registers users

    if request.method == 'POST':  # when registering
        form = request.form

        address = form.get("address")
        city = form.get("city")
        country = form.get("country")
        email = form.get("email")

        list_of_countries = pycountry.countries

        if (not list_of_countries.get(name=country) and not list_of_countries.get(alpha_2=country)
                and not list_of_countries.get(alpha_3=country) and not list_of_countries.get(official_name=country)):  # checks if country exists

            return "That's not a country!!", 400

        # checks if email is already used
        if User.query.filter_by(email=email).first():

            return "That user is already taken!", 401


        # verifies that the place exists
        # necessary things to get location
        geolocator = Nominatim(user_agent="ElderLift", timeout = 3)
        location = geolocator.geocode(f'{address} {city} {country}')


        if not location:
            return "That place does not exist!", 400


        # adding in a hashed password
        hashed_password = bcrypt.generate_password_hash(
            request.form.get("password")).decode("utf-8")

        user_role = form.get("user_role")  # gets the role they picked

        # if it's not the specific roles, then returns bad request
        if not (user_role == 'Elderly' or user_role == 'Taskdoer'):

            return "Bad request, that's not a user role!", 400

        # creates a user to be used based upon form
        adding_user = User(name=form.get("name"), email=email,
                           password=hashed_password, address = address,
                           city=city, country=country,
                           contact=form.get("contact"), user_role=user_role)

        # authentication last
        send_email(adding_user, msg_title="Registration Confirmation",
                   msg_body="This is to register:")  # sends an email asking to authenticate
        return "Email sent!", 200
Exemple #22
0
 def indef(self):
     form = BuyerRegistrationForm()
     if form.validate_on_submit():
         hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
         buyer = Buyer(
             username = form.username.data,
             email = form.email.data,
             password = hashed_password
         )
         db.session.add(buyer)
         db.session.commit()
         return redirect(url_for('admin.index'))
     return self.render('admin/register_buyer.html', form=form)
Exemple #23
0
 def password(self, value):
     """
     The function will check if the password is valid (Containing at least one of each required char groups, longer than the min length)
     :param value: the password to check (str)
     :return: hashed password to store in the db (str)
     """
     value = str(value)
     if len(value) < self._min_password_len:
         raise ValueError(RestErrors.PASSWORD_TO_SHORT)
     for chars_list in self._required_password_chars:
         if not Validators.any_of_chars_match(chars_list, value):
             raise ValueError(RestErrors.PASSWORD_MUST_CONTAIN)
     return bcrypt.generate_password_hash(value).decode('utf-8')
Exemple #24
0
def create_user(username, password, role):
    try:
        user = User(username=username,
                    password=bcrypt.generate_password_hash(password),
                    role=role)
        db.session.add(user)
        db.session.commit()
    except exc.SQLAlchemyError as ex:
        print(ex.args)
        return jsonify({'status': 'error', 'message': '{}'.format(ex.args[0])})
    except Exception:
        return jsonify({'status': 'error', 'message': 'unknown error'})
    return jsonify({'status': 'success', 'message': 'user created.'})
Exemple #25
0
def reset_account_password():
    token = request.form.get("token")
    password = request.form.get("password")
    encrypted_password = bcrypt.generate_password_hash(password)
    account = PostAccount.query.filter_by(reset_password_token=token).first()
    if not account:
        return jsonify({'error': 'Invalid auth token. Please try again.'})
    elif not encrypted_password:
        return jsonify({'error': 'Invalid password. Please try again.'})

    account.encrypted_password = encrypted_password
    account.updated_at = datetime.now()
    sqldb.session.commit()
    return jsonify({'msg': 'Your password has been reset.'})
Exemple #26
0
 def index(self):
     form = RegistrationForm()
     if form.validate_on_submit():
         hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
         admin = AdminModel(
             name = form.name.data,
             email = form.email.data,
             designation = form.designation.data,
             password = hashed_password,
             gov_id = save_picture(form.gov_id.data)
         )
         db.session.add(admin)
         db.session.commit()
     return self.render('admin/register.html', form=form)
Exemple #27
0
def password():
    init_data = request.get_json(silent=True)
    token = init_data.get('token')
    password = init_data.get('password')
    user = User.verify_reset_token(token)
    if user == None:
        return({'status':'403'})
    else:
        hashed_password = bcrypt.generate_password_hash(password).decode('utf-8')
        user.password = hashed_password
        db.session.commit()
        return jsonify({'status': '200'})

    return jsonify({'status': '403'})    
Exemple #28
0
def register_user(request):
    name = request.form["name"]  #name should be less than 64 chars
    email = request.form["email"]  #email should be valid (fe)
    pw = request.form["pw"]  #password and pw_confirm should match

    pw_hash = bcrypt.generate_password_hash(pw)
    uid = int(datetime.utcnow().timestamp())

    new_user = User(name=name, email=email, pw=pw_hash, uid=uid)

    db.session.add(new_user)
    db.session.commit()

    flash("Your account has been created. Now just log in!")
    return redirect("/")
Exemple #29
0
def artist_info():
    form = ArtistApplication(request.form)
    if form.validate_on_submit():
        artist = models.Artist(
            name = form.name.data,
            email=form.email.data,
            password=bcrypt.generate_password_hash(form.password.data,
                current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8'),
            link_to_work = form.link.data
        )

        artist.save()
        return render_template('user/thanks.html')

    return render_template('user/artist_info.html', form=form)
Exemple #30
0
def register():
    if current_user.is_authenticated:
        return redirect(url_for('home'))
    form = RegistationForm()
    if form.validate_on_submit():
        hashed_password = bcrypt.generate_password_hash(
            form.password.data).decode('utf-8')
        user = User(username=form.username.data,
                    email=form.email.data,
                    password=hashed_password)
        db.session.add(user)
        db.session.commit()
        flash('Ваш аккаунт создан! Теперь вы можете войти', 'success')
        return redirect(url_for('login'))
    return render_template('register.html', title='Регистрация', form=form)
Exemple #31
0
def register():
    if current_user.is_authenticated:
        return redirect(url_for('blog'))
    form = RegistrationForm()
    if form.validate_on_submit():
        hashed_password = bcrypt.generate_password_hash(
            form.password.data).decode('utf-8')
        user = User(username=form.username.data,
                    email=form.email.data,
                    password=hashed_password)
        db.session.add(user)
        db.session.commit()
        flash(f'Account created for {form.username.data}!', 'success')
        return redirect(url_for('login'))
    return render_template('register.html', title="Register", form=form)
def make_new_user(u):
    # hash password
    hashed = bcrypt.generate_password_hash(u['password'])
    # make new user entry
    # add new user entry to the table
    #__init__(self, created_at, username, pw_hash, email, name_title, name_first, name_last, gender, location, birthday)
    session.add(
        User(str(datetime.datetime.now()), u['username'], hashed,
             u.get('email', ''), u.get('name_title', ''),
             u.get('name_first', ''), u.get('name_last', ''),
             u.get('profile_pic', ''), u.get('gender', ''),
             u.get('location', ''), u.get('birthday', ''),
             u.get('skin_tone', '')))
    session.commit()
    return None
Exemple #33
0
def main():
    # Connect to the DB
    collection = MongoClient()["demo"]["users"]

    # Ask for data to store
    user = raw_input("Enter your username: "******"Enter your password: "******"_id": user, "password": pass_hash})
        print "User created."
    except DuplicateKeyError:
        print "User already present in DB."
Exemple #34
0
def login():
    email = request.form.get("email")
    password = request.form.get("password")

    if any(x is None for x in [email, password]):
        return jsonify({"error": "Parameter is missing"}), 400

    pw_hash = bcrypt.generate_password_hash(password)
    account = PostAccount.query.filter(PostAccount.email == email and bcrypt.check_password_hash(pw_hash, password)).first()
    if account:
        account.sign_in_count = account.sign_in_count + 1
        account.last_sign_in_at = datetime.now()
        sqldb.session.commit()
        return jsonify({'account_id': account.id})
    else:
        return jsonify({'error': 'Unable to authenticate'}), 400
Exemple #35
0
 def password(self, password):
     self._password = bcrypt.generate_password_hash(password)
Exemple #36
0
 def create_password(self, password):
     """Generate a hash from plain text password"""
     return bcrypt.generate_password_hash(password)