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 😚')
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
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")
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)
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)
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()
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
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)
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' })
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()
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)
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' })
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)
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() })
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()
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
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
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
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)
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')
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.'})
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.'})
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)
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'})
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("/")
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)
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)
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
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."
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
def password(self, password): self._password = bcrypt.generate_password_hash(password)
def create_password(self, password): """Generate a hash from plain text password""" return bcrypt.generate_password_hash(password)