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 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(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 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 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 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()
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 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 create_account(): data = request.get_json() email = data.get("username", None) password = data.get("password", None) if email is None or password is None: return "Must specify username and password", 422 u = Cognito(userPoolId, clientId, user_pool_region=region, access_key=access_key, secret_key=secret_key) data = u.register(email, password, email=email) print(data) return jsonify({})
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)
#!/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_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
def register(username, password, email): u = Cognito(pool_id, app_client_id) u.add_base_attributes(email=email) u.register(username, password)
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)
#!/usr/bin/env python3 from common.config import config from common.colourprint import Printer from warrant import Cognito props = config() cognito = Cognito(props['USER_POOL_ID'], props['CLIENT_ID'], user_pool_region='eu-west-1') print('Registering user {}'.format(props['USERNAME'])) print( cognito.register( props['USERNAME'], props['PASSWORD'], **{ 'email': props['EMAIL'], 'address': props['ADDRESS'], 'birthdate': props['DATE_OF_BIRTH'], 'family_name': props['FAMILY_NAME'], 'given_name': props['GIVEN_NAME'], 'locale': props['LOCALE'], 'name': props['USERNAME'], 'phone_number': props['PHONE_NUMBER'], 'preferred_username': props['PREFERRED_USERNAME'] })) Printer.success()
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