def register_user():
data = request.data
dataDict = json.loads(data)
_email = dataDict.get('email')
_password = dataDict.get('password')
u = Cognito(CONSTANTS['cognito_id'], CONSTANTS['cognito_app'])
u.add_base_attributes(email=_email)
u.register(_email, _password)
try:
user = {
'userId': _email,
'history': [],
'bookmarks': [],
"likes": [],
"dislikes": [],
'ml_one': " ",
'ml_two': {},
'ml_three': " "
}
users_table.put_item(Item=user)
except: # if there is any error
pass
return Response(json.dumps({"status": "Successful Register"}),
status=200,
mimetype='application/json')
def signup():
error = None
if request.method == 'POST':
if len(request.form['password']) < 8:
error = 'Password too short!'
else:
cognito = Cognito(user_pool_id=cognito_userpool_id,
client_id=cognito_app_client_id)
cognito.add_base_attributes(email=request.form['email'])
try:
cognito.register(username=request.form['username'],
password=request.form['password'])
_ = database.add_user(request.form['username'],
request.form['password'],
request.form['email'])
except Exception as e:
if e.response['Error']['Code'] == 'UsernameExistsException':
error = 'User Already Exists!'
else:
error = 'Unexpected Error: {}'.format(
e.response['Error']['Message'])
return render_template('signup.html', error=error)
session['username'] = request.form['username']
return redirect(url_for('verification'))
return render_template('signup.html', error=error)
def create_user(username, password, name, group):
"""
Create user and add him to the specifed group
"""
if not username:
raise ValidationError("error.create_user.invalid_user")
if not password:
raise ValidationError("error.create_user.invalid_password")
if not name:
raise ValidationError("error.create_user.invalid_name")
if not group:
raise ValidationError("error.create_user.invalid_group")
client = boto3.client("cognito-idp")
# check if group exists or through exception
try:
client.get_group(UserPoolId=cognito_userpool_id, GroupName=group)
except Exception as e:
log.exception(
"Failed to get_group, error.create_user.invalid_group, AWS Exception: {}"
.format(e))
raise ValidationError("error.create_user.invalid_group")
# here I am using warrant library because I found it easier than boto3
cognito = Cognito(cognito_userpool_id, cognito_app_client_id)
cognito.add_base_attributes(name=name)
# Register the user using warrant
try:
register_res = cognito.register(username, password)
except ClientError as e:
if "Username should be an email." in e.response["Error"]['Message']:
raise ValidationError("error.create_user.invalid_user")
elif "An account with the given email already exists." in e.response[
"Error"]['Message']:
raise ValidationError("error.create_user.already_exists")
elif "Password did not conform with policy" in e.response["Error"][
'Message']:
raise ValidationError("error.create_user.invalid_password")
else:
log.exception(
"Failed to register a user, error.create_user.failed, AWS Exception: {}"
.format(e))
raise ValidationError("error.create_user.failed")
# add user to the group using boto3 library
try:
client.admin_add_user_to_group(UserPoolId=cognito_userpool_id,
Username=username,
GroupName=group)
except Exception as e:
log.exception(
"Failed to add to a group, error.create_user.addtogroup.failed, AWS Exception: {}"
.format(e))
raise ValidationError("error.create_user.addtogroup.failed")
return register_res
def registerUser(self, username, password, email, given_name, family_name,
zip_code, timestamp):
u = Cognito(self.USER_POOL_ID, self.CLIENT_ID)
u.add_base_attributes(email=email,
given_name=given_name,
family_name=family_name)
u.add_custom_attributes(zip_code=zip_code, timestamp=timestamp)
u.register(username, password)
return u
def register(new_user):
new_user = model_to_dict(
new_user) if not type(new_user) == dict else new_user
pool_id = settings.COGNITO_USER_POOL_ID
app_id = settings.COGNITO_APP_ID
cog = Cognito(pool_id, app_id)
cog.add_base_attributes(email=new_user['email'])
cog.add_custom_attributes(is_staff=str(int(new_user['is_staff'])),
is_superuser=str(int(new_user['is_superuser'])))
cog.register(new_user['email'], new_user['password'])
def register(request, new_user):
pool_id = settings.COGNITO_USER_POOL_ID
app_id = settings.COGNITO_APP_ID
cog = Cognito(pool_id, app_id)
cog.add_base_attributes(email=new_user['username'])
cog.add_custom_attributes(
is_staff=str(int(new_user['is_staff'])),
is_superuser=str(int(new_user['is_superuser']))
)
cog.register(new_user['username'], new_user['password'])
def lambda_handler(event, context):
print("Got event \n" + json.dumps(event, indent=2))
p_body = parse_qs(event['body'])
#print str(p_body['user'][0])
#print str(p_body['tenant_id'][0])
#print str(p_body['user_id'][0])
#print p_body['email_addr'][0]
print event
cognito = boto3.client('cognito-idp', region_name='us-east-2')
if p_body['user'] != None:
user = p_body['user'][0]
email_add = p_body['email_addr'][0]
t_id = p_body['tenant_id'][0]
u_id = p_body['user_id'][0]
passwd = gen_random_string(8)
passwd = passwd + "!!" + str(random.randint(0, 100))
print passwd
u = Cognito(USER_POOL_ID, CLIENT_ID)
u.add_base_attributes(email=email_add)
u.add_custom_attributes(tenantId=t_id, userId=u_id, lib_view='*')
u.register(user, passwd)
response = cognito.admin_confirm_sign_up(UserPoolId=USER_POOL_ID,
Username=user)
u = Cognito(USER_POOL_ID, CLIENT_ID, username=user)
u.admin_authenticate(password=passwd)
print "getting refresh token"
return {
'statusCode': 200,
'headers': {
'Content-Type': 'application/json'
},
'body': json.dumps({'refresh_token': u.refresh_token})
}
else:
return {
'statusCode': 403,
'headers': {
'Content-Type': 'application/json'
},
'body': json.dumps({'message': 'invalid user input'})
}
def register_new_user(userPoolId, appClientId, userPoolRegion, username, password):
"""
Test userpool in AWS database for existing accounts.
Inputs:
- awsService = 'cognito-idp'
- regionName = "us-east-2"
outputs:
- Response from AWS
"""
u = Cognito(userPoolId, appClientId, userPoolRegion)
u.add_base_attributes()
data = u.register(username, password)
return data
def employeeSignIn():
loadMe = json.dumps(request.form)
payInfo = json.loads(loadMe)
try:
uuid = generate_uuid(payInfo)
response = table.get_item(
Key={
'userID' : uuid
}
)
item = response['Item'];
dumpedItem = json.loads(json.dumps(item, default=decimal_default));
except Exception as e:
return response_with(responses.UNAUTHORIZED_401, value={"value" : str(e)})
else:
return response_with(responses.SUCCESS_200, value={"value" : dumpedItem});
loadMe = json.dumps(request.get_json(silent=True)["info"])
payInfo = json.loads(loadMe)
admin = payInfo["admin"]
u = Cognito(pool_id, client_id, user_pool_region="us-east-2", access_key=os.environ["AWS_ACCESS_KEY"],
secret_key=os.environ["AWS_SECRET_KEY"]);
u.add_base_attributes(email=payInfo["email"], name="name");
#email has to be proper email format
#password needs to have uppercase, lowercase, and a number
res = u.register(payInfo["email"], payInfo["password"]);
try:
uuid = generate_uuid(payInfo)
response = table.put_item(
Item={
'userID' : uuid,
'name': payInfo["name"],
'email': payInfo["email"],
'password': sha256encrypt(payInfo["password"]),
'hireDate' : payInfo["hireDate"], #format: MM/DD/YYYY
'department' : payInfo["department"],
'salary' : int(payInfo["salary"]),
'admin' :int(admin)
}
)
except Exception as e:
return response_with(responses.INVALID_FIELD_NAME_SENT_422, value={"value" : str(e)});
else:
return response_with(responses.SUCCESS_200, value={
"userID" : uuid,
"admin" : int(admin)
})
def post(self):
"""Get user details"""
json_data = request.get_json(force=True)
email = json_data['email']
name = json_data['name']
family_name = json_data['family_name']
pwd = json_data['password']
try:
u = Cognito(cognitoUserPoolId, cognitoUserPoolClientId, awsRegion)
u.add_base_attributes(name=name, family_name=family_name)
u.register(email, password=pwd)
return ReturnDocument(email, "success").asdict()
except ClientError as err:
return ReturnDocument(err.__str__(), "error").asdict()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from getpass import getpass
from warrant import Cognito
from settings import *
#pool_id = 'us-east-1_KeZCl0wwt'
#client_id = '2lup6diqlr7usgsn26sqm9vd6c'
name = input('Your Name: ')
email = input('Your Email: ')
secret = input('Code Sprint Secret: ')
u = Cognito(pool_id, client_id)
u.add_base_attributes(email=email, name=name)
u.add_custom_attributes(secret=secret)
u.register(email, getpass(prompt='Password: '))
print("verification email will come from [email protected]")
def sign():
signinform = SigninForm(prefix="signin")
signupform = SignupForm(prefix="signup")
if request.method == 'POST':
form = request.form
pprint.pprint(form)
if request.form['btn'] == 'Signin':
# session["active_panel"] = "login-form-link"
if signinform.validate_on_submit():
try:
auth_cognito = Cognito(
cognito_userpool_id,
cognito_client_id,
user_pool_region=cognito_userpool_region,
username=form['signin-username'])
auth_cognito.authenticate(password=form['signin-password'])
decoded_token = cognitojwt.decode(auth_cognito.id_token,
cognito_userpool_region,
cognito_userpool_id,
cognito_client_id)
user = auth_cognito.get_user()
credit = user._data['custom:credit']
# except NotAuthorizedException as e:
# flash(e.response['Error']['Message'])
# return redirect(request.referrer)
except Exception as e:
if hasattr(e, 'message'):
msg = e.message
else:
msg = str(e)
flash(msg, 'error')
return redirect(request.referrer)
else:
flash("Signin Successfully!")
user = User()
user.id = decoded_token["cognito:username"]
user.credit = credit
session['credit'] = credit
session['expires'] = decoded_token["exp"]
session['refresh_token'] = auth_cognito.refresh_token
session['id_token'] = auth_cognito.id_token
session['access_token'] = auth_cognito.access_token
login_user(user, remember=True)
next_url = request.args.get('next', 'index').strip("/")
print("next_url:{}".format(next_url))
return redirect(url_for(next_url))
else:
flash(signinform.errors)
return redirect(request.referrer)
elif request.form['btn'] == 'Signup':
# session["active_panel"] = "register-form-link"
if signupform.validate_on_submit():
try:
u = Cognito(cognito_userpool_id, cognito_client_id,
cognito_userpool_region)
u.add_base_attributes(email=form['signup-email'])
u.add_custom_attributes(credit='0')
u.register(form['signup-username'],
form['signup-password'])
except Exception as e:
if hasattr(e, 'message'):
msg = e.message
else:
msg = str(e)
flash(msg, 'error')
else:
pprint.pprint(session)
flash("Finish the signup by confirm link in mailbox")
else:
flash(signupform.errors, "error")
return redirect(request.referrer)
return render_template('sign.html',
signinform=signinform,
signupform=signupform)
def save(self, user):
u = Cognito(self.pool_id, self.client_id)
u.add_base_attributes(email=user.user_id)
u.register(user.user_id, user.password)
def sign_up():
if request and request.method == "POST":
resp, err = GetUserPasswordFromAuthHeader(request)
if err:
res = GetResponseObject(err, 401)
log.error(res)
return res
username, password = resp[0], resp[1]
if request.data:
body = json.loads(request.data)
resp, err = ValidateRegistrationData(body)
if err:
res = GetResponseObject(err, 400)
log.error(res)
return res
try:
body["username"] = username
# Save user record in Cognito
user = Cognito(user_pool_id=COGNITO_USER_POOL_ID,
client_id=COGNITO_APP_CLIENT_ID,
user_pool_region=AWS_REGION)
user.add_base_attributes(email=username,
given_name=body["firstName"],
family_name=body["lastName"],
phone_number=body["phone"],
address=body["address"])
user.add_custom_attributes(usertype=body["userType"],
area=body["area"],
city=body["city"])
resp = user.register(username, password)
# log.info("Cognito response:" + str(resp))
user.admin_confirm_sign_up()
body["uuid"] = resp['UserSub']
body["email"] = username
# log.info(json.dumps(body, indent=2))
# saving user record in db
# filename, err = upload_image(request)
# if err:
# raise Exception(err)
# body["image"] = "https://" + settings.CLOUD_FRONT_URL + "/" + filename
SaveInDB(body)
data = "User registered successfully !!!"
res = GetResponseObject(data, 200, True)
return res
except ClientError as e:
if e.response['Error']['Code'] == 'UsernameExistsException':
data = f"{username} username already exists !!!"
log.error(data)
res = GetResponseObject(data)
return res
data = f"Error: {str(e)}"
log.error(data)
res = GetResponseObject(data)
return res
except Exception as e:
user = Cognito( \
user_pool_id=COGNITO_USER_POOL_ID, \
client_id=COGNITO_APP_CLIENT_ID, \
user_pool_region=AWS_REGION,
username=username)
user.authenticate(password=password)
resp = client.delete_user(AccessToken=user.access_token)
log.info(
f"Deleting user due to error while signing up: {resp}")
data = f"Error while registering user: {str(e)}"
log.error(data)
res = GetResponseObject(data)
return res
else:
data = f"Empty request body !!!!"
res = GetResponseObject(data, 400)
log.error(err)
return res
else:
data = f"Invalid request method, method {request.method} not supported !!!"
res = GetResponseObject(data, 405)
log.error(res)
return res
def register(username, password, email):
u = Cognito(pool_id, app_client_id)
u.add_base_attributes(email=email)
u.register(username, password)
def sign_up():
if request and request.method == "POST":
resp, err = GetUserPasswordFromAuthHeader(request)
if err:
res = GetResponseObject(err, 401)
log.error(res)
return res
username, password = resp[0], resp[1]
if request.data:
body = json.loads(request.data)
resp, err = ValidateRegistrationData(body)
if err:
res = GetResponseObject(err, 400)
return res
try:
body["username"] = username
# Save user record in Cognito
user = Cognito(user_pool_id=COGNITO_USER_POOL_ID,
client_id=COGNITO_APP_CLIENT_ID, user_pool_region=AWS_REGION)
user.add_base_attributes(
email=username,
given_name=body["firstName"],
family_name=body["lastName"]
)
print(username, password)
user.add_custom_attributes(
yoyoPoints=body["yoyoPoints"],
admin=body["admin"]
)
resp = user.register(username, password)
log.info("Cognito response:" + str(resp))
user.admin_confirm_sign_up()
body["uuid"] = resp['UserSub']
# log.info(json.dumps(body, indent=2))
data = "User registered successfully !!!"
res = GetResponseObject(data, 200, True)
return res
except ClientError as e:
print(f"Error: {str(e)}")
if e.response['Error']['Code'] == 'UsernameExistsException':
data = f"{username} username already exists !!!"
log.error(data)
res = GetResponseObject(data)
return res
except Exception as e:
user = Cognito(
user_pool_id=COGNITO_USER_POOL_ID,
client_id=COGNITO_APP_CLIENT_ID,
user_pool_region=AWS_REGION,
username=username)
user.authenticate(password=password)
resp = client.delete_user(AccessToken=user.access_token)
log.info(
f"Deleting user due to error while signing up: {resp}")
data = f"Error while registering user: {str(e)}"
log.error(data)
res = GetResponseObject(data)
return res
else:
data = f"Empty request body !!!!"
res = GetResponseObject(data, 400)
log.error(err)
return res
else:
data = f"Invalid request method, method {request.method} not supported !!!"
res = GetResponseObject(data, 405)
log.error(res)
return res
