def create_user_manager():
if request.method == "GET":
return render_template("register.html")
if request.method == "POST":
result_form = request.form.to_dict()
check_requirements = user_service.check_user_properties(result_form)
if check_requirements is True:
try:
user_service.create_user(**result_form)
return redirect(url_for("routes.login_manager"))
except Exception as e:
return render_template("register.html",
info={
"error_description":
"Error adding user to the DB",
"error": e
})
else:
return render_template(
"register.html",
info={"error_description": "The Data is incomplete!"})
else:
return render_template(
"register.html",
info={"error_description": "Error adding user to the DB"})
def test_create_user_should_create_user(self, mock_user):
user = {"id": 1}
new_user = MagicMock()
new_user.save.return_value = user
mock_user.return_value = new_user
assert user_service.create_user(user) == user
def register_post():
r = flask.request
name = r.form.get('name')
email = r.form.get('email', '').lower().strip()
password = r.form.get('password', '').strip()
if not name or not email or not password:
return {
'name': name,
'email': email,
'password': password,
'error': 'Some required fields are missing',
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
user = user_service.create_user(name, email, password)
if not user:
return {
'name': name,
'email': email,
'password': password,
'error': 'A user with that email already exists',
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
# TODO: log in browser as a session
resp = flask.redirect('/account')
cookie_auth.set_auth(resp, user.id)
return resp
def register_post():
data = request_dict.create(default_val='')
name = data.name
email = data.email.lower().strip()
password = data.password.strip()
if not name or not email or not password:
return {
'name': name,
'email': email,
'password': password,
'error': "Some required fields are missing.",
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
user = user_service.create_user(name, email, password)
if not user:
return {
'name': name,
'email': email,
'password': password,
'error': "A user with that email already exists.",
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
resp = flask.redirect('/account')
cookie_auth.set_auth(resp, user.id)
return resp
def register_post():
r = flask.request
name = r.form.get('name')
email = r.form.get('email', '').lower().strip()
password = r.form.get('password').strip()
if not name or not email or not password:
return {
'name': name,
'email': email,
'password': password,
'error': 'some required fields are missing.',
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
# TODO: create a user
user = user_service.create_user(name, email, password)
if not user:
return {
'name': name,
'email': email,
'password': password,
'error': 'email already associated with registered user',
'user_id': cookie_auth.get_user_id_via_auth_cookie(flask.request),
}
resp = flask.redirect('/account')
cookie_auth.set_auth(resp, user.id)
return resp
def register():
print('Enter /register route')
body = request.json
message = create_user( # create_user() defined in user_service.py
body['email'],
bcrypt.generate_password_hash(body['password']).decode('utf-8'),
body['f_name'],
body['l_name'],
)
return {
'message': message
}
def register():
# Create a user
# Body: { email, password, first_name, last_name }
# Return: { message }
body = request.json
message = create_user(
body['email'],
bcrypt.generate_password_hash(body['password']).decode('utf-8'),
body['f_name'], body['l_name'])
return {"message": message}
def index_post():
vm = RegisterViewModel()
vm.validate()
if vm.error:
return vm.to_dict()
user = user_service.create_user(vm.name, vm.email)
if not user:
vm.error = 'The account could not be created.'
return vm.to_dict()
return flask.redirect('/users')
def register_post():
vm = RegisterViewModel()
vm.validate()
if vm.error:
return vm.to_dict()
user = user_service.create_user(vm.name, vm.email, vm.password)
if not user:
vm.error = 'The account could not be created'
return vm.to_dict()
resp = flask.redirect('/account')
cookie_auth.set_auth(resp, user.id)
return resp
def an_admin_user(cfaker):
password = '******'
user = user_service.create_user({
'name': cfaker.name(),
'last_name': cfaker.last_name(),
'email': cfaker.email(),
'password': password,
'profile_image': cfaker.image_url(),
'phone': cfaker.phone_number(),
'type': "BACK_OFFICE"
})
user.password = password
return user
def register_post():
vm = RegisterViewModel()
vm.validate()
if vm.error:
return render_template("account/register.html",
name=vm.name,
username=vm.username,
email=vm.email,
error=vm.error)
user = user_service.create_user(vm.name, vm.username, vm.email,
vm.password)
if not user:
vm.error = "The account could not be created."
return render_template("account/register.html", error=vm.error)
return redirect("/account/login")
def create(gratitude_points=5):
password = '******'
user = user_service.create_user({
'name': cfaker.name(),
'last_name': cfaker.last_name(),
'email': cfaker.email(),
'password': password,
'profile_image': cfaker.image_url(),
'phone': cfaker.phone_number(),
'type': "DELIVERY",
'gratitude_points': gratitude_points,
'reputation': 1.0,
'balance': 0.0
})
user.password = password
return user
def register():
if flask.request.method == "POST":
# Getting xml data from request
xml = etree.fromstring(request.data)
xml_validator = etree.DTD(file='db/register.dtd')
isvalid = xml_validator.validate(xml)
# if xml input matches DTD it will proceed
if isvalid:
data = []
for i in xml:
data.append(i.text)
name = data[0]
email = data[1]
password = data[2]
if not name or not email or not password:
error = "MF"
return Response(error, mimetype='text/xml')
user = user_service.create_user(name, email, password)
if not user:
error = 'EE'
return Response(error, mimetype='text/xml')
resp = flask.redirect('/accounts')
cookie_auth.set_auth(resp, user.id)
return resp
# If xml does not match DTD it will return an error message
else:
return Response("TA", mimetype='text/xml')
# If xml input contains external Entities it will return error message
return Response("TA", mimetype='text/xml')
elif flask.request.method == "GET":
return {
'user_id': cookie_auth.get_user_id_via_cookie(flask.request),
}
def signup():
if request.method == 'POST':
signup_detail = request.form
if user_service.check_username(signup_detail['username']) == False:
username_msg = 'username already exist!!'
else:
username_msg = ''
if user_service.check_email(signup_detail['email']) == False:
email_msg = 'email already exist!!'
else:
email_msg = ''
if username_msg == '' and email_msg == '':
email = signup_detail['email']
token = s.dumps(email, salt='email_confirmed')
msg = Message('Email Confirmation CBM CTF',
sender='*****@*****.**',
recipients=[email])
#link= url_for('confirm_email', token=token,_external=True)
link = "localhost:5001/confirm_email/" + token
msg.body = 'email Confirmation link is {}'.format(link)
mail.send(msg)
user_service.signup_user(user_service.create_user(signup_detail))
return "<h1>confirmation mail is send please confirm email for access acount.</h1>"
else:
return render_template('signup.html',
username_msg=username_msg,
email_msg=email_msg,
firstname=signup_detail['firstname'],
email=signup_detail['email'],
username=signup_detail['username'])
return render_template('signup.html')
def create_user():
user_data = UserInputSchema().load(request.get_json(force=True))
return jsonify(UserOutputSchema().dump(service.create_user(user_data)))
def create_user(self):
response = make_response(json.dumps(
us.create_user(request.get_json()).__dict__), 201)
return response
def post():
content = request.get_json()
schema = CreateUserSchema()
user_data = schema.load(content)
return jsonify(user_service.create_user(user_data)), HTTP_201_CREATED
