def post(self):
# get the post data
post_data = request.get_json()
# check if the user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
try:
user = User(email=post_data.get('email'),
password=post_data.get('password'))
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please log in.',
}
return make_response(jsonify(responseObject)), 202
def register_user():
"""Register a user."""
post_data = request.get_json()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
if not post_data:
return jsonify(response_object), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
try:
# Check for existing user
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
new_user = User(username=username, email=email, password=password)
db.session.add(new_user)
db.session.commit()
# Generate auth token
auth_token = new_user.encode_auth_token(new_user.id)
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return jsonify(response_object), 200
else:
response_object['message'] = 'Sorry. That user already exists.'
return jsonify(response_object), 400
# Handle errors
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
return jsonify(response_object), 400
def register_user():
post_data = request.get_json()
response_obj = {
'status': 'fail',
'message': 'Invalid payload.'
}
if not post_data:
return jsonify(response_obj), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
try:
user = User.query.filter(
or_(User.username == username, User.email == email)
).first()
if not user:
# add new user to db
new_user = User(
username=username,
email=email,
password=password)
db.session.add(new_user)
db.session.commit()
# generate auth token
auth_token = new_user.encode_auth_token(new_user.id)
response_obj['status'] = 'success'
response_obj['message'] = 'Successfully registered.'
response_obj['auth_token'] = auth_token.decode()
return jsonify(response_obj), 201
else:
response_obj['message'] = 'Sorry. That user already exists.'
return jsonify(response_obj), 400
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
return jsonify(response_obj), 400
def register_user():
post_data = request.get_json()
print(post_data)
response_object = {'status': 'fail', 'message': 'Invalid payload'}
if not post_data:
return jsonify(response_object), 400
email = post_data.get('email')
try:
user = User.query.filter(or_(User.email == email)).first()
if not user:
new_user = User(email=email,
created_at=datetime.datetime.utcnow(),
active=True)
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token(new_user.id)
response_object['status'] = 'success'
response_object['message'] = 'Successfully registered.'
response_object['auth_token'] = auth_token.decode()
return jsonify(response_object), 201
else:
return redirect(url_for('auth.login_user'), code=307)
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
return jsonify(response_object), 400
def post(self):
post_data = request.get_json()
response_object = {
'status': 'fail',
'message': 'Invalid payload.'
}
if not post_data:
return response_object, 400
email = post_data.get('email')
first_name = post_data.get('first_name')
last_name = post_data.get('last_name')
password = post_data.get('password')
try:
user = User.query.filter_by(email=email).first()
if not user:
user = User(email=email, first_name=first_name, last_name=last_name, password=password)
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id, user.admin)
response_object['status'] = 'success'
response_object['message'] = f'{email} was added!'
response_object['token'] = auth_token.decode()
return response_object, 201
else:
response_object['status'] = 'fail'
response_object['message'] = 'Sorry. That email already exists.'
return response_object, 202
except exc.IntegrityError:
db.session.rollback()
return response_object, 400
def register_user():
post_data = request.get_json()
response_object = {"status": "fail", "message": "Invalid payload."}
if not post_data:
return jsonify(response_object), 400
username = post_data.get("username")
email = post_data.get("email")
password = post_data.get("password")
try:
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
new_user = User(username=username, email=email, password=password)
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token(new_user.id)
response_object["status"] = "success"
response_object["message"] = "Successfully registered."
response_object["auth_token"] = auth_token.decode()
return jsonify(response_object), 201
else:
response_object["message"] = "Sorry. That user already exists."
return jsonify(response_object), 400
except (exc.IntegrityError, ValueError):
db.session.rollback()
return jsonify(response_object), 400
def test_decode_auth_token(self):
user = add_user('thiesen', '*****@*****.**', 'xunda')
auth_token = User.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertEqual(user.id, User.decode_auth_token(auth_token))
def post(self):
post_data = request.get_json()
if not post_data:
return {"message": "Invalid payload."}, 400
try:
print('enter getJSONResult', flush=True)
username = post_data["username"]
email = post_data["email"]
if not validate_email(email):
return {"message": f"{email} is not a valid email."}, 400
if User.query.filter_by(email=email).first():
return {"message": f"User {email} already exists."}, 400
elif User.query.filter_by(username=username).first():
return {"message": f"User {username} already exists."}, 400
simple_user = SimpleUser.query.filter_by(email=email).first()
if simple_user:
simple_user.signed_up = True
else:
simple_user = SimpleUser(email=email, signed_up=True)
db.session.add(simple_user)
db.session.commit()
post_data["simple_user_id"] = simple_user.id
print('enter getJSONResult', flush=True)
new_address = Address(**post_data["address"])
print('enter getJSONResult', flush=True)
db.session.add(new_address)
db.session.commit()
post_data["main_address_id"] = new_address.id
del post_data["address"]
post_data["password_hash"] = post_data["password"]
del post_data["password"]
user = User(**post_data)
user.set_password_hash(post_data["password_hash"])
db.session.add(user)
simple_user.user = user
user.addresses = [new_address]
user.address_history = [new_address.id]
db.session.commit()
auth_token = user.encode_auth_token(user.id)
return {
"message": f"{username} has signed up!",
"auth_token": auth_token.decode()
}, 201
except TypeError as te:
return {"message": f"Type Error: {te}"}, 400
except KeyError as ke:
return {"message": f"Key Error: {ke}"}, 400
except exc.IntegrityError as ie:
db.session.rollback()
return {"message": f"Integrity Error: {ie}"}, 400
def test_encode_auth_token(self):
user = User(username='******',
email='*****@*****.**',
password="******")
db.session.add(user)
db.session.commit()
token = user.encode_auth_token()
self.assertTrue(isinstance(token, str))
def test_decode_auth_token(self):
user = User(username='******',
email='*****@*****.**',
password="******")
db.session.add(user)
db.session.commit()
token = user.encode_auth_token()
user_obj = User.decode_auth_token(token)
self.assertTrue(user_obj.id == user.id)
def test_decode_auth_expired_token(self):
user = User(username='******',
email='*****@*****.**',
password="******")
db.session.add(user)
db.session.commit()
token = user.encode_auth_token()
time.sleep(6)
message = User.decode_auth_token(token)
self.assertEqual(message, 'Signature expired. Please log in again.')
def register_user():
if current_app.config.get('REGISTER_DEACTIVATED'):
response_object = {
'status': 'Failed',
'message': 'Registration not allowed!'
}
return jsonify(response_object), 403
post_data = request.get_json()
if not post_data:
response_object = {
'status': 'error',
'message': 'Invalid payload.'
}
return jsonify(response_object), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
try:
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
new_user = User(
username=username,
email=email,
password=password
)
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token(new_user.id)
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return jsonify(response_object), 201
else:
response_object = {
'status': 'error',
'message': 'Sorry. That user already exists.'
}
return jsonify(response_object), 400
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
response_object = {
'status': 'error',
'message': 'Invalid payload.'
}
return jsonify(response_object), 400
def register_user():
#get the post data
post_data = request.get_json()
if not post_data:
response_object = {'status': 'error', 'message': 'Invalid payload.'}
return make_response(jsonify(response_object)), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
try:
#check for exiting user
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
#add user to db
new_user = User(username=username, email=email, password=password)
db.session.add(new_user)
db.session.commit()
#generate auth token and qiniu upload token that all included in JWT
auth_token = new_user.encode_auth_token(new_user.id)
response_object = {
'status': 'success',
'message': 'Successfully registered',
'auth_token': auth_token.decode()
}
return make_response(jsonify(response_object)), 201
else:
response_object = {
'status': 'error',
'message': 'Sorry, That user already exits.'
}
return make_response(jsonify(response_object)), 400
except exc.IntegrityError as e:
db.session.rollback()
response_object = {'status': 'error', 'message': 'Invalid payload.'}
return make_response(jsonify(response_object)), 400
except ValueError as e:
db.session.rollback()
response_object = {'status': 'error', 'message': 'Invalid payload.'}
return make_response(jsonify(response_object)), 400
def register():
post_data = request.get_json()
response_object = {
'message': 'Invalid payload.',
'status': 'fail',
}
if not post_data:
return jsonify(response_object), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
response = post_data.get('response')
try:
if current_app.config.get('RECAPTCHA_VERIFICATION_ENABLED'):
captcha_response = (
validate_recaptcha(response))['captcha_response']
if not captcha_response['success']:
return response_failure(captcha_response, 401)
# check for existing user
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
# add new user to the db
new_user = User(
username=username,
email=email,
password=password,
)
db.session.add(new_user)
db.session.commit()
# generate auth token
auth_token = new_user.encode_auth_token(new_user.id)
response_object['status'] = 'success'
response_object['message'] = 'Successfully registered'
response_object['auth_token'] = auth_token.decode()
return jsonify(response_object), 201
else:
response_object['message'] = 'Sorry, that user already exists.'
return jsonify(response_object), 400
# handle errors
except (exc.IntegrityError, ValueError):
db.session.rollback()
return jsonify(response_object), 400
def register_user():
post_data = request.get_json()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
if not post_data:
return jsonify(response_object), 400
company_name = post_data.get('company_name')
cnpj = post_data.get('cnpj')
company_email = post_data.get('company_email')
fantasy_name = post_data.get('fantasy_name')
cep = post_data.get('cep')
city = post_data.get('city')
state = post_data.get('state')
company_phone = post_data.get('company_phone')
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
try:
company = Company(company_name, cnpj, company_email, fantasy_name, cep,
city, state, company_phone)
db.session.add(company)
db.session.flush()
user = User.query.filter(
or_(User.username == username, User.email == email)).first()
if not user:
new_user = User(username=username,
email=email,
password=password,
company_id=company.id)
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token(new_user.id)
response_object['status'] = 'success'
response_object['message'] = 'Successfully registered.'
response_object['auth_token'] = auth_token.decode()
return jsonify(response_object), 201
else:
response_object['message'] = 'Sorry. That user already exists.'
return jsonify(response_object), 400
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
return jsonify(response_object), 400
def post(self):
# get the post data
post_data = request.get_json()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
if not post_data.get('username'):
return response_object, 400
if not post_data.get('email'):
return response_object, 400
if not post_data.get('password'):
return response_object, 400
# check if user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
un = User.query.filter_by(username=post_data.get('username')).first()
if not user and not un:
try:
user = User(username=post_data.get('username'),
email=post_data.get('email'),
password=post_data.get('password'))
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return responseObject, 201
except ValueError:
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return responseObject, 401
else:
responseObject = {
'status': 'fail',
'message': 'Sorry. That user already exists.',
}
return responseObject, 400
def register_user():
# get post data
post_data = request.get_json()
response = {
'status': 'fail',
'message': 'Invalid payload.',
}
if not post_data:
return jsonify(response), 400
username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
# check for existing user
try:
if User.query.filter(User.username == username).first():
raise AssertionError('Sorry. Username is already in use')
if User.query.filter(User.email == email).first():
raise AssertionError('Sorry. Email is already in use')
# add new user to DB
new_user = User(
username=username,
email=email,
password=password,
)
db.session.add(new_user)
db.session.commit()
auth_token = new_user.encode_auth_token(new_user.id)
response['status'] = 'success'
response['message'] = 'Successfully registered.'
response['auth_token'] = auth_token.decode()
return jsonify(response), 201
# handler errors
except (exc.IntegrityError, AssertionError, ValueError) as e:
db.session.rollback()
response['message'] = 'Error: {}. '.format(e)
return jsonify(response), 400
def register_user():
# get post data
post_data = request.get_json()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
if not post_data:
return jsonify(response_object), 400
try:
user_info = validate_new_user_details(post_data)
except ValueError as e:
response_object['message'] = str(e)
return jsonify(response_object), 400
# only people signing up a new school will register via this route
user_info['admin'] = True
try:
# add new user to db
new_user = User(user_info=user_info)
db.session.add(new_user)
db.session.commit()
# generate auth token
auth_token = new_user.encode_auth_token(new_user.id)
response_object['status'] = 'success'
response_object['message'] = 'Successfully registered.'
response_object['user'] = new_user.asdict(exclude=['password'])
response_object['user']['token'] = str(auth_token)
return jsonify(response_object), 201
# handler errors
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
response_object['message'] = str(e)
return jsonify(response_object), 400
def login():
response_object = {
'status': 'fail',
'message': 'Invalid payload.',
}
post_data = request.get_json()
if not post_data:
return jsonify(response_object), 400
email = post_data.get('email')
password = post_data.get('password')
try:
user = User.query.filter_by(email=email).first()
if user and bcrypt.check_password_hash(user.password, password):
auth_token = User.encode_auth_token(user.id)
if auth_token:
response_object = {
'status': 'success',
'message': 'Successfully logged in.',
'auth_token': auth_token.decode(),
}
return jsonify(response_object), 200
else:
response_object = {
'status': 'fail',
'message': 'User does not exist.',
}
return jsonify(response_object), 404
except Exception as e:
response_object['message'] = 'Try again.'
return jsonify(response_object), 500
def test_encode_auth_token(self):
user = add_user('justatest', '*****@*****.**', 'test')
auth_token = User.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
def test_decode_auth_token(self):
user = add_user('justatest', '*****@*****.**', 'test')
auth_token = User.encode_auth_token(user.id)
self.assertEqual(User.decode_auth_token(auth_token), user.id)
def post(self):
""" Register New User """
# Get Post Data
print(request)
post_data = request.get_json()
# If there is not any post data, response with error json object
if not post_data:
print(post_data.get('email'), post_data.get('password'))
response = jsonify({
'status': 'error',
'message': 'Invalid payload.'
})
response.status_code = 400
return response
# getting username, email and password from post request
#username = post_data.get('username')
email = post_data.get('email')
password = post_data.get('password')
status = 'registered'
admin = False
#first_name = post_data.get('first_name')
#last_name = post_data.get('last_name')
#birthday = post_data.get('birthday')
# company = post_data.get()
first_name = post_data.get('first_name')
last_name = post_data.get('last_name')
birthday = post_data.get('birthday')
# company = post_data.get()
try:
# checking for existing user
user = User.query.filter(or_(User.email == email)).first()
if not user:
# add new user to db
new_user = User(
#username=username,
admin=admin,
status=status,
email=email,
#password=password
#first_name=first_name,
#last_name=last_name,
#birthday=birthday
password=password,
first_name=first_name,
last_name=last_name,
birthday=birthday,
last_step=0,
)
db.session.add(new_user)
db.session.commit()
# create auth_token
auth_token = new_user.encode_auth_token(new_user.uid)
print(auth_token)
response = jsonify({
'status': 'success',
'message': 'Successfully registered',
'auth_token': auth_token.decode()
})
response.status_code = 201
return response
else:
response = jsonify({
'status':
'error',
'message':
'Sorry. That user already exists.'
})
response.status_code = 400
return response
# handler errors
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
response = jsonify({
'status': 'error',
'message': 'Invalid payload.'
})
response.status_code = 400
return response
def post(self):
"""Connecting to Google"""
data = request.get_json()
# refresh_token = data['refreshToken']
access_token = data['access_token']
basic_route = 'https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=%s' % (
access_token)
r = requests.get(basic_route)
# getting UserInfo from Google
basic_profile = json.loads(r.text)
print(basic_profile)
email = basic_profile['email']
first_name = basic_profile['given_name']
last_name = basic_profile['family_name']
profile = basic_profile['picture']
password = access_token
# looking up to see if user exist
try:
user = User.query.filter_by(email=email).first()
# if user does not exist, create a new users based on user info
# return user uid
if not user:
user = User(email=email,
password=password,
status='registered',
admin=False)
db.session.add(user)
db.session.commit()
current_user = User.query.filter_by(email=email).first()
current_user.google_access_token = access_token
current_user.first_name = first_name
current_user.last_name = last_name
current_user.profile = profile
db.session.add(current_user)
db.session.commit()
response_object = jsonify({
'status':
'success',
'message':
'Successfully create new user %s %s' %
(current_user.first_name, current_user.last_name),
'data': {
'userId':
current_user.uid,
'auth_token':
current_user.encode_auth_token(current_user.uid)
}
})
response_object.status_code = 200
return response_object
# if user does exist, log user in
# return user user uid and user auth token
else:
user.google_access_token = access_token
user.first_name = first_name
user.last_name = last_name
user.profile = profile
user_uid = user.uid
db.session.add(user)
db.session.commit()
response_object = jsonify({
'status':
'success',
'message':
'Successfully login %s %s' %
(user.first_name, user.last_name),
'data': {
'userId': user_uid,
'auth_token': user.encode_auth_token(user_uid)
}
})
response_object.status_code = 200
return response_object
except (exc.IntegrityError, ValueError) as e:
db.session.rollback()
response = jsonify({
'status': 'fail',
'message': 'Invalid payload.'
})
response.status_code = 400
return response
def register():
"""
Add user to the database
receives payload
NOTE We only accept lower case eth address
{
"eth_address":
"signed_message":
}
If user already exists sends user exists
"""
post_data = request.get_json()
response_object = {'status': 'fail', 'message': 'Invalid payload.'}
if not post_data:
return jsonify(response_object), 400
# Get eth address and sanitize
eth_address = post_data.get('eth_address')
if eth_address == '' or eth_address is None:
response_object['message'] = "Eth address error"
return jsonify(response_object), 400
eth_address = eth_address.strip()
eth_address = eth_address.lower()
# Get signed message and sanitize
signed_message = post_data.get('signed_message')
if signed_message == '' or signed_message is None:
response_object['message'] = "Signed message error"
return jsonify(response_object), 400
signed_message = signed_message.strip()
# recover contents of message hash
# sha3('EventProtocol') =
# '0x10dc127b5f076691f4dcf6b485d12179195cbe70e226dce5c333254592dca71e'
acc = web3.eth.Account()
message_hash = \
'0x10dc127b5f076691f4dcf6b485d12179195cbe70e226dce5c333254592dca71e'
sign_eth_addr = acc.recoverHash(message_hash, signature=signed_message)
# check if addresses match, otherwise send error
if sign_eth_addr.lower() != eth_address:
response_object['message'] = "Invalid signature"
return jsonify(response_object), 400
try:
user = User.query.filter_by(eth_address=eth_address).first()
# if eth address does not exist we add the entry
if not user:
user = User(eth_address=eth_address)
# insert user
db.session.add(user)
db.session.commit()
# generate auth token
auth_token = user.encode_auth_token(user.id)
# print()
# print('DEBUG: Registration')
# print("user id = ", user.id)
response_object['status'] = 'success'
response_object['message'] = 'Registration Success'
response_object['auth_token'] = auth_token.decode()
# send a jwt token for authentication error message
return jsonify(response_object), 201
# If the eth address exists sends and
else:
response_object['message'] = 'User already exists'
return jsonify(response_object), 400
# Throw integrityError if this does not work
except exc.IntegrityError:
db.session.rollback()
return jsonify(response_object), 400
