def create_user(cls, email, password, admin=False):
try:
cls.create(email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
def __init__(self, name, age, email, password, best_friend=None, is_admin=False): self.name = name self.age = age self.email = email self.password = generate_password_hash(password) self.best_friend = best_friend self.is_admin = is_admin
def signup():
if request.method == "POST":
emailz = request.form['email']
pazz = request.form['password']
veri = request.form['verify']
# If password and verify fields match then create new BSON Document
if len(pazz) > 6:
if pazz == veri:
pazz = generate_password_hash(pazz)
new = Profile(email=emailz, password=pazz, vanity=emailz)
#checks if email address is not in use
try:
Profile.objects.get(email=emailz)
# If the email address isn't taken
except DoesNotExist:
#Checks if email address is the right format
try:
new.save()
# if email address not in right format
except (ValidationError, MultipleObjectsReturned):
return render_template('signup.html', eerror="Email is of incorrect format", verror="", perror="")
else:
session['email'] = emailz
flash('You were logged in')
return redirect('/MyAccount/')
else: return render_template('signup.html', verror="", eerror="Email Address is already Taken", perror="")
else: return render_template('signup.html', verror="Passwords do not match", eerror="", perror="", em=emailz)
else: return render_template('signup.html', verror="", eerror="", perror="Password has to be at least 6 characters long", em=emailz)
else: return render_template('signup.html', verror="",perror="",eerror="")
def create_new_user_from_email(first_name, last_name, email, password):
if len(password) < PASSWORD_MIN_LENGTH:
raise User.UserCreationError(
'Passwords must be at least 8 characters long.')
user = User(
email=email,
first_name=first_name,
join_date=datetime.datetime.now(),
join_source=User.JoinSource.EMAIL,
last_name=last_name,
password=bcrypt.generate_password_hash(
password, rounds=BCRYPT_ROUNDS),
)
try:
user.save()
except me.base.ValidationError as e:
if 'email' in e.errors:
raise User.UserCreationError('Oops, that email is invalid.')
raise
except me.queryset.NotUniqueError as e:
raise User.UserCreationError('That email is already signed up.'
' (Maybe you already signed up with Facebook?)')
return user
def index():
if login.current_user.is_authenticated():
return login.redirect('/dashboard')
# Create the forms
sign_up_form = forms.SignUpForm()
sign_in_form = forms.SignInForm()
if flask.request.method == 'POST' and sign_up_form.validate_on_submit():
new_user = models.User(
first_name=sign_up_form.first_name.data,
last_name=sign_up_form.last_name.data,
email=sign_up_form.email.data,
password=bcrypt.generate_password_hash(sign_up_form.password.data),
)
db.session.add(new_user)
db.session.commit()
return flask.redirect(flask.url_for('dashboard'))
if flask.request.method == 'POST' and sign_in_form.validate_on_submit():
user = models.User.query.filter(
models.User.email == sign_in_form.user_email.data).first()
login.login_user(user)
if (bcrypt.check_password_hash(user.password,
sign_in_form.user_password.data)):
return flask.redirect(flask.url_for('dashboard'))
return flask.render_template('home.epy', sign_up_form=sign_up_form,
sign_in_form=sign_in_form, user=login.current_user)
def register():
"""
An admin user already logged is allowed to register new usernames
the new usernames cannot be changed at the moment nor can they be
deleted unless done from command line
Registeration is not through ajax requests it's through proper form
POST request
"""
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
confirm = request.form["confirm"]
if confirm == password:
passhash = generate_password_hash(password)
new_user = {'username':username, 'password':passhash}
check_insert = users.insert(new_user)
if check_insert:
return redirect(url_for('show_profiles'))
else:
#not done and error occured
flash("For some reason it didn't work, try again")
else:
#dont proceed
flash("Please enter the password same twice")
return render_template('register.html')
def create_user(cls, username, password, admin=False):
try:
cls.create(username=username,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
ValueError("User already exists.")
def editUser(form):
if form.validate_on_submit():
session = DBSession()
user = session.query(User).filter(User.id == current_user.id).update({
'title':
form.title.data,
'fname':
form.fname.data,
'lname':
form.lname.data,
'username':
form.username.data,
'email':
form.email.data,
'password':
generate_password_hash(form.newpassword.data),
'address':
form.address.data,
'state':
form.state.data,
'is_Admin':
False
})
if user is not None:
session.commit()
return redirect(url_for('editaccount'))
return render_template('editaccount.html', form=form)
def create_new_user_from_email(first_name, last_name, email, password):
if len(password) < PASSWORD_MIN_LENGTH:
raise User.UserCreationError(
'Passwords must be at least 8 characters long.')
user = User(
email=email,
first_name=first_name,
join_date=datetime.datetime.now(),
join_source=User.JoinSource.EMAIL,
last_name=last_name,
password=bcrypt.generate_password_hash(password,
rounds=BCRYPT_ROUNDS),
)
try:
user.save()
except me.base.ValidationError as e:
if 'email' in e.errors:
raise User.UserCreationError('Oops, that email is invalid.')
raise
except me.queryset.NotUniqueError as e:
raise User.UserCreationError(
'That email is already signed up.'
' (Maybe you already signed up with Facebook?)')
return user
def save(self, **kwargs):
print kwargs.get('username')
self.username = kwargs.get('username', self.username)
password = kwargs.get('password', self.password)
self.password = generate_password_hash(
password) if password != self.password else password
self.email = kwargs.get('email', self.email)
self.first_name = kwargs.get('first_name', self.first_name)
self.last_name = kwargs.get('last_name', self.last_name)
birthday = kwargs.get('birthday', self.birthday)
self.birthday = datetime.strptime(
birthday, '%Y-%m-%dT%H:%M:%S.%fZ') if type(birthday) == type(
unicode('')) else birthday
self.gender = kwargs.get('gender', self.gender)
self.address = kwargs.get('address', self.address)
self.coordinates = kwargs.get('coordinates', self.coordinates)
self.is_staff = kwargs.get('is_staff', self.is_staff)
self.is_active = kwargs.get('is_active', self.is_active)
date_joined = kwargs.get('date_joined', self.date_joined)
self.date_joined = datetime.strptime(
date_joined, '%Y-%m-%dT%H:%M:%S.%fZ') if type(date_joined) == type(
unicode('')) else date_joined
friends = kwargs.get('friends', self.friends)
new_friends = []
for f in friends:
if isinstance(f, int):
new_friends.append(User.query.filter_by(id=f).first())
else:
new_friends.append(f)
self.friends = new_friends
self.image = kwargs.get('image', self.image)
def __init__(self, username, email, password, joined_at=None, is_admin=False): self.username = username self.email = email self.password = generate_password_hash(password) if joined_at == None: self.joined_at = datetime.datetime.now() self.is_admin = is_admin
def create_user(self,
fname,
lname,
username,
email,
password,
address,
state,
title,
is_Admin=False):
try:
session = DBSession()
myFirstUser = User(title=title,
fname=fname,
lname=lname,
username=username,
email=email,
password=generate_password_hash(password),
address=address,
state=state,
is_Admin=is_Admin)
session.add(myFirstUser)
session.commit()
except IntegrityError:
# recreate the session and re-add your object
session = DBSession()
session.add(User)
raise ValueError('user Already Exist !')
def create_user(cls, user, password, admin=False):
try:
cls.create(user=user,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("Username already in use")
def create_user(cls, email, password):
try:
with DATABASE.transaction():
cls.create(email=email,
password=generate_password_hash(password))
except IntegrityError:
raise ValueError("User already exists")
def create_user(cls, user, password, admin=False):
try:
cls.create(
user=user,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("Username already in use")
def change_user_password(pk_id, old_password, new_password):
"""Edit a user. Old password is required."""
user = User.get(User.id == pk_id)
if check_password_hash(user.password, old_password):
user.update(password=generate_password_hash(new_password)).execute()
else:
raise PermissionError("Invalid password.")
def create_user(cls, email, password):
try:
cls.create(
email=email,
password=generate_password_hash(password)
)
except IntegrityError:
raise ValueError('Email unavailable.')
def __init__(self, fullname, username, email, address, phone_number, password):
self.fullname = fullname
self.username = username
self.email = email
self.address = address
self.phone_number = phone_number
self.password = generate_password_hash(password)
self.created = datetime.datetime.now()
def add_user(username, password, email):
pw_hash = generate_password_hash(password)
try:
uid = mongo.db.users.insert({'username': username, 'hash': pw_hash,
'email': email})
return True
except pymongo.errors.DuplicateKeyError:
return False
def update_model(self, form, model):
existing_password = model.password
password = form.password.data
updated = super(UserModelView, self).update_model(form, model)
if password != existing_password:
model.password = generate_password_hash(password) if password else None
model.save()
return updated
def create_user(**kwargs):
"""Takes arguments and create a new user.
:param kwargs:
"""
db.connect()
User.create(first_name=kwargs['first_name'], second_name=kwargs['second_name'],
phone=kwargs['phone'], role=kwargs['role'], username=kwargs['username'],
password=generate_password_hash(kwargs['password']), email=kwargs['email'])
def change_user_password(pk_id, old_password, new_password):
"""Edit a user. Old password is required."""
user = User.get(User.id == pk_id)
if check_password_hash(user.password, old_password):
user.update(password=generate_password_hash(new_password)).execute()
else:
raise PermissionError("Invalid password.")
def create_user(cls, email, password):
try:
cls.create(
email=email,
password=generate_password_hash(password)
)
except IntegrityError:
raise ValueError
def create_user(cls, email, password, admin=False):
try:
cls.create(
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
def create_user(cls, username, password, admin=False):
try:
with database.transaction():
return cls.create(
username=username,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
def bcryptbenchmark():
"Test number of rounds"
# Chance the number of rounds (second argument) until it takes between
# 0.25 and 0.5 seconds to run.
from flask.ext.bcrypt import generate_password_hash
import time
duration = 0
i = 4
while duration < 0.25:
start = time.time()
generate_password_hash('password1', i)
end = time.time()
duration = end - start
i += 1
print("(" + str(duration) + " secounds)")
print("please copy the next line into config.py")
print("")
print("BCRYPT_LOG_ROUNDS=" + str(i))
def create_user(cls, username, email, password, is_admin=False):
try:
cls.create(
username=username,
email=email,
password=generate_password_hash(password)
)
except IntegrityError:
raise ValueError("User already exists.")
def create_user(cls, username, email, password, admin=False):
try:
user_record = cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
return user_record
def __init__(self, full_name, username, email, password):
self.full_name = full_name
self.username = username
self.email = email
self.password = generate_password_hash(password)
self.createdtime = datetime.datetime.now()
self.updatedtime = datetime.datetime.now()
self.deleted = 0
self.id_type_user = 5
def create_user(cls, username, email, password, admin=False):
"""Secure user creation in the database"""
try:
cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_admin=True)
except IntegrityError:
raise ValueError("User already exists")
def post(self):
data = request.get_json()
hashed_password = generate_password_hash(data['password'])
user = User(data['email'], hashed_password)
db.session.add(user)
db.session.commit()
return user
def create_user(cls, username, email, password, admin=False):
try:
with DATABASE.transaction():
cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
def post(self):
data = request.get_json()
hashed_password = generate_password_hash(data['password'])
user = User(data['email'], hashed_password)
db.session.add(user)
db.session.commit()
return user
def create_user(cls, username, email, password, admin=False):
try:
cls.create(
username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("Usuario ya Existe")
def create_user(cls, email, password):
try:
with DATABASE.transaction():
cls.create(
email=email,
password=generate_password_hash(password)
)
except IntegrityError:
raise ValueError("User already exists.")
def register_user(cls, email, password):
try:
user = AppUser.get(AppUser.email == email)
except DoesNotExist:
raise ValueError('User not created by admin')
if user.password is not None:
raise ValueError('User already registered')
user.password = generate_password_hash(password)
user.save()
def create_user(cls, username, email, password, admin, position):
try:
cls.create(
username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin,
position=position)
except IntegrityError:
raise ValueError("User already exists")
def update_user(cls, user_id, username=None, email=None, password=None):
user_record = cls.get(id=user_id)
if username:
user_record.username = username
if email:
user_record.email = email
if password:
user_record.password = generate_password_hash(password)
user_record.save()
return user_record
def create_user(cls, username, password, admin=False):
try:
cls.create(
#email = email,
username = username,
password = generate_password_hash(password),
is_admin = admin
)
except IntegrityError:
raise ValueError("User with the same email exists!")
def create_user(cls, username, email, password, admin = False): #cls instead of self
try:
cls.create(
username = username,
email = email,
password = generate_password_hash(password),
is_admin = admin
)
except IntegrityError:
raise ValueError("User already exists")
def create_user(cls, username, email, password, admin=False):
try:
with DATABASE.transaction(): # transaction says, try this thing out, if it works - awesome, if not, remove whatever you just did
cls.create(
username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError('User already exists')
def create_user(cls, email, password, admin=False, confirmed=True):
try:
cls.create(
email=email,
password=generate_password_hash(password),
is_admin=admin,
confirmed=confirmed,
)
except IntegrityError:
raise ValueError('User already exists')
def create_user(cls, username, email, password, admin=False):
try:
with DATABASE.transaction():
cls.create(
username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("Username or email already exists")
def create_user(cls, username, email, password, admin=False):
"""Secure user creation in the database"""
try:
cls.create(
username = username,
email = email,
password = generate_password_hash(password),
is_admin = True)
except IntegrityError:
raise ValueError("User already exists")
def nuevo(cls, usuario, email, password, admin=False, puntos=0):
try:
cls.create(
usuario=usuario,
email=email,
puntos=puntos,
password=generate_password_hash(password),
es_admin=admin
)
except IntegrityError:
raise ValueError("El usuario ya existe")
def create_user(cls, username, email, password, name, department, is_admin=False): # CREATE user
try:
with DATABASE.transaction():
cls.create(
username = username,
email = email,
password = generate_password_hash(password), # encripting the password for security
name = name,
department = department)
except IntegrityError: raise ValueError("User already exists")
def create_user(cls, username, email, password, admin=False):
try:
with DATABASE.transaction():
# transaction: if it works, awesome, keep going
# if not, remove whatever thing you just did.
cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError("User already exists")
def add_user(username, password, email):
pw_hash = generate_password_hash(password)
try:
res = r.table("users").insert({'id': genPrimaryKey64("%s%s" % (
username, email)), 'username': username, 'hash': pw_hash, 'email': email}).run(rdb.conn)
if res["inserted"] == 1:
return True
else:
return False
except Exception:
return False
def signup():
if not app.config.get("ENABLE_SIGNUP", False):
return abort(404)
elif (request.method == "POST" and
request.form["id"] and request.form["password"]):
u = model.User(request.form["id"], generate_password_hash(request.form["password"]), common.generate_random_string(32))
db.session.add(u)
db.session.commit()
return redirect(url_for("signin"))
else:
return render_template("signup.html")
def update_password(self, password):
"""Update user's password
Takes in a raw password and automatically hashes it using and updates the user
`password`: the user's new unhashed password
"""
try:
self.password = generate_password_hash(password)
self.save()
except Exception as e:
raise e
def dbfill():
# if the admin user is not created, create one
user = UserBasic.query.filter_by(email="*****@*****.**").first()
if user is None:
au = UserBasic(email="*****@*****.**", nickname="verdverm")
bu = UserBasic(email="*****@*****.**", nickname="tony")
db.session.add(au)
db.session.add(bu)
aa = UserAuth(user_id=1,
hpass=generate_password_hash("verdverm"),
role=USER.ADMIN,
status=USER.ACTIVE)
db.session.add(aa)
ba = UserAuth(user_id=2,
hpass=generate_password_hash("iassic"),
role=USER.USER,
status=USER.ACTIVE)
db.session.add(ba)
db.session.commit()
def profile():
form = forms.ChangePasswordForm()
if form.validate_on_submit():
user = models.User.get(models.User.email == form.email.data)
if user:
user.password = generate_password_hash(form.password.data)
user.save()
flash('Password successfully changed.', 'success')
return redirect(url_for('profile'))
else:
flash('Password change was unsuccessful.', 'error')
return redirect(url_for('profile'))
return render_template('profile.html', form=form)
def create_user(cls,
username,
email,
password,
admin=False): # cls instead of self
# if user gets, say, halfway created, to go back
with DATABASE.transaction():
try:
cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_admin=admin)
except IntegrityError:
raise ValueError
def change_pass(username, email, password):
pw_hash = generate_password_hash(password)
try:
q = r.table("users").get(genPrimaryKey64("%s%s" %
(username, email))).update({
"hash":
pw_hash
}).run(rdb.conn)
if q["replaced"]:
return True
else:
return False
except Exception as err:
print err
return False
def create_user(cls,
username,
email,
password,
teacher=False,
parent=False,
student=False):
try:
with DATABASE.transaction():
cls.create(username=username,
email=email,
password=generate_password_hash(password),
is_teacher=teacher,
is_parent=parent,
is_student=student)
except IntegrityError:
raise ValueError("User already exists")
def create_user(
cls,
username='******',
phone=775527640,
email='*****@*****.**',
account_type='supplier',
password='******',
address='77 Quorn Avenue, Mount Pleasant, Harare, Zimbabwe',
profile='default.png'):
cls.create(username=username,
phone=phone,
email=email,
profile=profile,
account_type=account_type,
password=generate_password_hash(password, 12),
address=address)
def add_user(username, password, email):
pw_hash = generate_password_hash(password)
try:
res = r.table("users").insert({
'id':
genPrimaryKey64("%s%s" % (username, email)),
'username':
username,
'hash':
pw_hash,
'email':
email
}).run(rdb.conn)
if res["inserted"] == 1:
return True
else:
return False
except Exception:
return False
