def register():
if request.method == 'POST' and 'User-Agent' not in request.headers:
email = request.form['email']
password = generate_password_hash(request.form['password'])
name = request.form['name']
if name and email and password:
if Users.query.filter_by(email = email).first() is None:
new_user = Users(name, email, password)
db.session.add(new_user)
db.session.commit()
user = Users.query.filter_by(email = email).first()
token = user.generate_auth_token(600) #---visit tutorial on generating this
return jsonify({'error':'null', 'data':{'token': token.decode('ascii'), 'expires': 600, 'user':{'id': user.id, 'email': user.email, 'name': user.name}, 'message':'success'}})
if Users.query.filter_by(email = email).first() is not None:
user = Users.query.filter_by(email = email).first()
return jsonify({'error': '1', 'data': {'email': user.email}, 'message':'user already exists'})
form = SignUpForm()
if request.method == 'POST' and 'User-Agent' in request.headers:
if form.validate_on_submit():
email = request.form['email']
password = generate_password_hash(request.form['password'])
name = request.form['name']
new_user = Users(name, email, password)
db.session.add(new_user)
db.session.commit()
# user = Users.query.filter_by(email = email).first()
# token = user.generate_auth_token(600) #---visit tutorial on generating this
return redirect(url_for('login'))
return render_template(
'signup.html',
title='User Signup',
year=datetime.datetime.now().year,
form=form,
user=g.user
)
def test_password_hash_random(self):
"""Testing password hash is random."""
user1 = Users(Username='******')
user2 = Users(Username='******')
user1.set_password('test')
user2.set_password('test')
self.assertTrue(user1.Password != user2.Password)
def test_class_save_db(new_user, init_db):
user, _ = new_user
init_db.session.add(user)
init_db.session.commit()
user_in_db = init_db.session.query(Users).get(1)
assert user_in_db.name == user.name
user_info = {
"name": "Rafiq",
"surname": "Alimaerdenov",
"email": "*****@*****.**",
"password": "******"
}
user = Users(**user_info)
user.save_db()
user_in_db = init_db.session.query(Users).get(2)
assert user_in_db.name == user.name
assert user_in_db.created is not None
new_user = Users(**user_info)
assert new_user.save_db() is False
user_info = {
"name": None,
"surname": "Alimaerdenov",
"email": "*****@*****.**",
"password": "******"
}
user = Users(**user_info)
assert user.save_db() is False
def setUp(self):
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.abspath(
os.getcwd()) + "/test.db"
db.drop_all(
) #Just to make sure there are no entries in the testing database before adding to the database.
db.create_all()
pass1 = "1234"
pass2 = "3421f"
userno1 = Users(username="******",
email="*****@*****.**",
password=bcrypt.hashpw(pass1.encode('utf-8'),
bcrypt.gensalt()))
userno2 = Users(username="******",
email="*****@*****.**",
password=bcrypt.hashpw(pass2.encode('utf-8'),
bcrypt.gensalt()))
prog1 = Progress(username="******", numFlips=23)
prog2 = Progress(username="******", numFlips=22)
prog3 = Progress(username="******", numFlips=21)
db.session.add(userno1)
db.session.add(userno2)
db.session.add(prog1)
db.session.add(prog2)
db.session.add(prog3)
db.session.commit()
def test_create_bucket_happy_path(self):
'''Testing that the create bucket does create a bucket list object. '''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
self.assertEqual(len(Users().users[0].user_bucket), 1)
def test_create_bucket_happy_path_1(self):
'''Testing that the create bucket does create a bucket list object with the
right bucket name.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
self.assertEqual(Users().users[0].user_bucket[0].bucket_name, "Family")
def test_delete_activity_happy_path(self):
'''Testing that delete activity deletes an activity object. '''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_activity(0, "Visit")
BucketList().delete_activity(0, 0)
self.assertEqual(len(Users().users[0].user_bucket[0].activity_list), 0)
def test_edit_bucket_happy_path(self):
'''Testing that the edit bucket edit a particular bucket list object with
right arguments entered.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().edit_bucket(0, "Travel")
self.assertEqual(Users().users[0].user_bucket[0].bucket_name, "Travel")
def test_edit_activity_happy_path(self):
'''Testing that edit activity does edit an activity with the right input. '''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_activity(0, "Visit")
BucketList().edit_activity(0, 0, "Buy Gifts")
self.assertEqual(Users().users[0].user_bucket[0].activity_list[0],
"Buy Gifts")
def test_create_bucket_sad_path_1(self):
'''Testing that the create bucket does not create a bucket list object
that is similar in name to a previous bucket object name created.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_bucket("Family")
self.assertEqual(len(Users().users[0].user_bucket), 1)
def test_create_activity_happy_path(self):
'''Testing that the create activity does create an activity object
with the right inputs.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_activity(0, "Visit")
self.assertEqual(Users().users[0].user_bucket[0].activity_list[0],
"Visit")
def test_create_activity_sad_path_1(self):
'''Testing that the create activity does not create an activity that was created
before.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_activity(0, "Visit my aunt")
BucketList().create_activity(0, "Visit my aunt")
self.assertEqual(len(Users().users[0].user_bucket[0].activity_list), 1)
def test_edit_activity_sad_path(self):
'''Testing that edit activity does not edit the activity if the activity input
is an empty string.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().create_activity(0, "Visit")
BucketList().edit_activity(0, 0, "")
self.assertEqual(Users().users[0].user_bucket[0].activity_list[0],
"Visit")
def test_edit_bucket_sad_path(self):
'''Testing that the edit bucket does not edit once an empty string is given
or when a bucket name entered already exists in the user's bucket list.
'''
Users().users.clear()
Users().create_user("user1", "*****@*****.**", "password", "password")
Users().login_user("*****@*****.**", "password")
BucketList().create_bucket("Family")
BucketList().edit_bucket(0, "")
self.assertEqual(Users().users[0].user_bucket[0].bucket_name, "Family")
BucketList().create_bucket("Travel")
BucketList().edit_bucket(0, "Travel")
self.assertEqual(Users().users[0].user_bucket[0].bucket_name, "Family")
def register():
if request.method == "POST" and 'username' in request.form and 'password' in request.form and 'email' in request.form:
nama = request.form.get("nama")
username = request.form.get("username")
email = request.form.get("email")
notlp = request.form.get("notlp")
alamat = request.form.get("alamat")
password = request.form.get("password")
# Check if account exists using MySQL
users = Users.query.filter_by(username=username).first()
# If account exists show error and validation checks
if users:
msg = 'Account already exists!'
elif not re.match(r'[^@]+@[^@]+\.[^@]+', email):
msg = 'Invalid email address!'
elif not re.match(r'[A-Za-z0-9]+', username):
msg = 'Username must contain only characters and numbers!'
elif not username or not password or not email:
msg = 'Please fill out the form!'
else:
# Account doesnt exists and the form data is valid, now insert new account into users table
users = Users(nama=nama,
username=username,
email=email,
notlp=notlp,
alamat=alamat,
password=password)
db.session.add(users)
db.session.commit()
msg = 'You have successfully registered!'
return redirect(url_for('login'))
return render_template("register.html")
def register():
data = request.get_json()
email = data['email']
name = data['name']
password = data['password']
if email.isspace() or name.isspace() or password.isspace():
response = jsonify({
'message': 'all fields are required',
'status': False
})
response.status_code = 401
return response
else:
hashed_password = generate_password_hash(password, method='sha256')
new_user = Users(email=email,
name=name,
role='customer',
password=hashed_password)
new_user.save()
response = jsonify({
'id': new_user.id,
'email': new_user.email,
'name': new_user.name,
'role': new_user.role
})
response.status_code = 201
return response
def register_post():
form = RegisterForm(request.form)
# Get the values from the form
if form.validate():
# TODO: use managers and don't put logic in views
name = form.name.data
email = form.email.data
username = form.username.data
password = form.password.data
try:
user = Users(name=name, email=email, username=username)
user.set_password(password)
db.session.add(user)
db.session.commit()
except Exception:
flash("Could not register", "danger")
return redirect(url_for('register_get'))
else:
flash("You are now registered and can login", "success")
return redirect(url_for('login_get'))
flash("Check the values", "danger")
return render_template("register.html", form=form)
def post(self):
claims = get_jwt_claims()
if claims['role'] != 'admin':
return None
parser = reqparse.RequestParser()
parser.add_argument('login', type=str)
parser.add_argument('password', type=str)
parser.add_argument('role', type=str)
login = parser.parse_args()['login']
password = parser.parse_args()['password']
role = parser.parse_args()['role']
newUser = Users(login=login, password=password, role=role)
db.session.add(newUser)
db.session.commit()
identity = get_jwt_identity()
user = [{
'id': x.id,
'login': x.login,
'role': x.role
} for x in Users.query.all() if x.login != identity]
return user
def register():
form = RegisterForm()
if request.method == 'POST':
if form.validate_on_submit():
username = form.username.data
photo = form.photo.data
passw = form.passw.data
fname = form.fname.data
lname = form.lname.data
email = form.email.data
location = form.location.data
bio = form.bio.data
joined = getDate()
filename = secure_filename(photo.filename)
photo.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
user = Users(username, passw, fname, lname, email, location, bio,
filename, joined)
db.session.add(user)
db.session.commit()
print("valid")
return jsonify({'works': "true"})
return jsonify(error=form_errors(form))
print("not at all")
def profile():
form = ProfileForm()
if request.method == "POST" and form.validate_on_submit():
photo = form.Pic.data
name = form.firstName.data + " " + form.lastName.data
gender = form.gender.data
email = form.email.data
location = form.location.data
bio = form.biography.data
filename = secure_filename(photo.filename)
photo.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
#print(os.path.join(
# app.config['UPLOAD_FOLDER'], filename
#))
created_on = getDate()
user = Users(created_on, name, location, filename, gender, email, bio)
db.session.add(user)
db.session.commit()
flash("user was successfully added", 'success')
return redirect(url_for("home"))
print(form.errors)
return render_template("profile.html", form=form)
def register():
user = UserForm()
message = [{"errors": "critical error"}]
if request.method == 'POST':
user.username.data = request.form['username']
user.password.data = request.form['password']
user.name.data = request.form['name']
user.email.data = request.form['email']
user.location.data = request.form['location']
user.biography.data = request.form['biography']
user.photo.data = request.files['photo']
message = [{"errors": form_errors(user)}]
if user.validate_on_submit():
username = user.username.data
password = user.password.data
name = user.name.data
email = user.email.data
location = user.location.data
biography = user.biography.data
photo = user.photo.data
filename = genUniqueFileName(photo.filename)
userDB = Users(username, password, name, email, location, biography, filename)
db.session.add(userDB)
db.session.commit()
photo.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
message = [{"message": "Successful Registered!"}]
message = jsonify(message=message)
return message
def comadduser():
user = str(request.form['username'])
passwd = str(request.form['password'])
mail = str(request.form['email'])
dep = str(request.form['area'])
groups = str(request.form['group'])
active = request.form.get('useractive')
accessweb = request.form.get('webaccess')
queryuser = db.session.query(Users).filter(
or_(Users.username == user, Users.email == mail)).first()
if queryuser:
flash('Ya existe ' + user + ' o el ' + mail + ' verificalo')
logging.warning('Ya tiene acceso a bastion ' + user)
return redirect(url_for('users'))
else:
if active:
active = True
else:
active = False
if accessweb:
accessweb = True
else:
accessweb = False
insertQuery = Users(user, passwd, mail, dep, groups, active, accessweb)
db.session.add(insertQuery)
logging.info('Add user' + ' ' + user)
db.session.commit()
return redirect(url_for('users'))
def post(self):
"""Handle POST request for this view. Url ---> /auth/register"""
# Query to see if the user already exists
user = Users.query.filter_by(email=request.data['email']).first()
if not user:
# There is no user so we'll try to register them
try:
post_data = request.data
# Register the user
email = post_data['email']
password = post_data['password']
user = Users(email=email, password=password)
user.save()
response = {
'message': 'You registered successfully. Please log in.'
}
# return a response notifying the user that they registered successfully
return make_response(jsonify(response)), 201
except Exception as e:
# An error occured, therefore return a string message containing the error
response = {'message': str(e)}
return make_response(jsonify(response)), 401
else:
# There is an existing user. We don't want to register users twice
# Return a message to the user telling them that they they already exist
response = {'message': 'User already exists. Please login.'}
return make_response(jsonify(response)), 202
def register():
post_data = request.get_json()
email = post_data.get('email')
password = post_data.get('password')
if email is None or password is None:
responseObject = {'status': 'error', 'message': 'Invalid input.'}
return jsonify(responseObject), 400
if Users.query.filter_by(email=email).first() is not None:
responseObject = {'status': 'error', 'message': 'User already exists.'}
return jsonify(responseObject), 400
user = Users(first_name=post_data.get('first_name'),
last_name=post_data.get('last_name'),
email=post_data.get('email'),
password=post_data.get('password'),
age=post_data.get('age'),
first_day=post_data.get('first_day'),
cycle_length=post_data.get('cycle_length'),
non_hormonal=post_data.get('non_hormonal'),
triphasic=post_data.get('triphasic'),
monophasic=post_data.get('monophasic'),
progestin=post_data.get('progestin'))
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered',
'auth_token': auth_token.decode()
}
return jsonify(responseObject), 201
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('username',
help='This field cannot be blank',
required=True)
parser.add_argument('email',
help='This field cannot be blank',
required=True)
parser.add_argument('password',
help='This field cannot be blank',
required=True)
data = parser.parse_args()
user_name = data["username"].strip()
email = data["email"].strip()
password = data["password"].strip()
if user_name == "" or email == "" or password == "":
return jsonify({"Error": "Fields have not been filled"}), 400
else:
t = tuple(user_name)
if t[0].isdigit():
return jsonify({"error": "username cant be string"}), 400
else:
# password_candidste = Users.generate_hash(password)
new_user = Users(user_name, password, email)
# user_data = {"username": user_name.lower(), "email": email, "password": password_candidste}
return new_user.check_user()
def init_db():
user = Users(login_name="super",
login_pass=generate_password_hash("super"),
desc="superUser",
update_at=TimesUnit.get_now())
db.session.add(user)
db.session.commit()
def post(self):
raw_dict = request.get_json(force=True)
try:
schema.validate(raw_dict)
request_dict = raw_dict['data']['attributes']
print(raw_dict)
user = Users(request_dict['firstName'], request_dict['lastName'],
request_dict['email'], request_dict['age'],
request_dict['birthDate'], request_dict['zipcode'])
user.add(user)
query = Users.query.get(user.id)
results = schema.dump(query).data
return results, 201
except ValidationError as err:
resp = jsonify({"error": err.messages})
resp.status_code = 403
return resp
except SQLAlchemyError as e:
db.session.rollback()
resp = jsonify({"error": str(e)})
resp.status_code = 403
return resp
def signup():
if request.method == 'POST':
username = request.form.get('username')
name = request.form.get('name')
password = request.form.get('password')
geolocation = requests.post(
'https://www.googleapis.com/geolocation/v1/geolocate?key=AIzaSyCDz4WY_rzOR_UnUghAjY1h_f9ut1GC8TM'
).json()
location = str(geolocation['location']['lat']) + "," + str(
geolocation['location']['lng'])
if username is None or password is None:
print("username or password is empty")
abort(400)
print(u)
usernamecheck = Users.query.filter_by(username=username).first()
if usernamecheck:
abort(400)
print("query error")
user = Users(username=username, name=name, location=location)
#hashedpassword=user.set_password(password).split(":")[2]
#user.password = hashedpassword
user.set_password(password)
db.session.add(user)
db.session.commit()
return render_template('signin.html')
elif request.method == 'GET':
return render_template('signup.html')
def register():
form = RegisterForm()
if request.method == "POST" and form.validate_on_submit() == True:
username = form.username.data
password = form.password.data
firstname = form.firstname.data
lastname = form.lastname.data
email = form.email.data
location = form.location.data
bio = form.biography.data
photo = form.photo.data
photo = assignPath(form.photo.data)
try:
#create user object and add to database
user = Users(username, password, firstname, lastname, email,
location, bio, photo)
if user is not None:
db.session.add(user)
db.session.commit()
#flash message to indicate the a successful entry
success = "User sucessfully registered"
return jsonify(message=success), 201
except Exception as e:
print(e)
db.session.rollback()
error = "An error occured with the server. Try again!"
return jsonify(error=error), 401
#flash message to indicate registration failure
failure = "Error: Invalid/Missing user information"
return jsonify(error=failure), 401
def register():
"""Accepts user information and saves it to the database"""
form = RegistrationForm()
if request.method == "POST" and form.validate_on_submit():
username = form.username.data
password = form.password.data
firstname = form.first_name.data
lastname = form.last_name.data
email = form.email.data
location = form.location.data
biography = form.biography.data
photo = form.photo.data
photoPath = assignFilename(photo)
try:
user = Users(username, password, firstname, lastname, email, location, biography, photoPath)
if user is not None:
db.session.add(user)
db.session.commit()
uploadFile(photo)
info = [{"message": "User successfully registered"}]
return jsonify(result=info), 201
except Exception as e:
print(e)
db.session.rollback()
error = "Server Error. Try again."
return jsonify(error=error), 401
all_errors = form_errors(form)
return jsonify(errors=all_errors)
