def user(mocker, setup, cleanup, email): engine, connection, session = setup() mocker.patch(SETUP, return_value=(engine, connection, session)) mocker.patch(CLEANUP) create_user(session, User(email=email)) yield find_user(session, email) cleanup(session, connection)
def create_account(): #регистрация пользователя from models import User, create_user form = LoginForm() if form.validate_on_submit(): create_user(form.username.data, form.email.data, form.password.data) #передача данных с формы в БД return redirect('/index') return render_template('registration.html', form=form, title='Регистрация')
def test_pessoa_juridica_login(client): """Testa o acesso de uma pessoa jurídica""" create_user(PESSOA_JURIDICA_EMAIL, SENHA, 'XXXXXXXXXXX', 'JUR', False) rv = login(client, PESSOA_JURIDICA_EMAIL, SENHA) rv = client.get('/') assert 'Consulte um CPF' in rv.data.decode('utf-8') rv = logout(client) assert 'Faça login' in rv.data.decode('utf-8')
def test_pessoa_juridica_consulta(client): """Testa o acesso de uma pessoa jurídica consultando um CPF""" create_user(PESSOA_JURIDICA_EMAIL, SENHA, 'XXXXXXXXXXX', 'JUR', False) login(client, PESSOA_JURIDICA_EMAIL, SENHA) rv = client.post('/', data=dict(cpf='XXXXXXXXXXX')) assert 'Nunca venda para ele!' in rv.data.decode('utf-8') rv = logout(client) assert 'Faça login' in rv.data.decode('utf-8')
def test_pessoa_fisica_assinatura(client): """Testa o acesso de uma pessoa física com assinatura""" create_user(PESSOA_FISICA_ASSINANTE_EMAIL, SENHA, 'XXXXXXXXXXX', 'FIS', True) rv = login(client, PESSOA_FISICA_ASSINANTE_EMAIL, SENHA) assert 'Bem vindo, Han Solo!' in rv.data.decode('utf-8') assert 'Corporação de Engenharia Corelliana' in rv.data.decode('utf-8') assert 'Canto Bight' in rv.data.decode('utf-8') rv = logout(client) assert 'Faça login' in rv.data.decode('utf-8')
def test_pessoa_fisica_simples(client): """Testa o acesso de uma pessoa física simples""" create_user(PESSOA_FISICA_SIMPLES_EMAIL, SENHA, 'XXXXXXXXXXX', 'FIS', False) rv = login(client, PESSOA_FISICA_SIMPLES_EMAIL, SENHA) assert 'Bem vindo, Han Solo!' in rv.data.decode('utf-8') assert 'Nunca venda para ele!' in rv.data.decode('utf-8') assert 'Jabba the Hutt' in rv.data.decode('utf-8') rv = logout(client) assert 'Faça login' in rv.data.decode('utf-8')
def register(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] if username in users: return 'This user is exist<a href="/register">Register</a>' create_user(username, password) session['username'] = username return redirect(url_for('index')) return render_template('register.html')
def add_new_user(): firstname = request.form[ "firstname"] #if request.form["firstname"] else None lastname = request.form['lastname'] #if request.form["lastname"] else None imageurl = request.form['imageurl'] #if request.form["imageurl"] else None create_user(firstname, lastname, imageurl) return redirect('/users')
def init_db(): with app.app_context(): db.create_all() db.session.commit() if app.debug: if User.query.count() == 0: create_user('*****@*****.**', 'MillFalcon1', 'XXXXXXXXXXX', profile='JUR')
def create(): if request.method == "POST": data = request.form try: create_user(data["email"]) except ValidationError, e: errors_dict = {} errors_dict['errors'] = e.message return jsonify(errors_dict) return jsonify(data)
def register(): try: data = request.get_json() create_user(data["username"], data["email"], data["password"]) res = auth_user(data["username"], data["password"]) return jsonify({ "msg": f'{data["username"]}', "id": res, "token": jwt_user(data["username"]) }) except Exception as e: return jsonify({'msg': f'{e}'}), 401
def process_new(body, number): ''' process a text if the user does NOT exist in the db ''' # looks like a signup request if parse.valid_signup_request(body): new_name = parse.get_signup_name(body) create_user(new_name, number) send_welcome(number) # looks like anything else else: send_signup_request(number)
def post(self): parser_copy = parser.copy() # required parser_copy.add_argument('fname', help='This field cannot be blank', required=True) parser_copy.add_argument('lname', help='This field cannot be blank', required=True) parser_copy.add_argument('mphone', help='This field cannot be blank', required=True) parser_copy.add_argument('email', help='This field cannot be blank', required=True) parser_copy.add_argument('mcode', help='This field cannot be blank', required=True) parser_copy.add_argument('pass', help='This field cannot be blank', required=True) # not required parser_copy.add_argument('phone', required=False) parser_copy.add_argument('state', required=False) parser_copy.add_argument('city', required=False) parser_copy.add_argument('address', required=False) data = parser_copy.parse_args() # check if user is new or not if models.find_user({"mphone": data['mphone']}): logging.warning('request for registering user that exists. user: {}'.format(data['mphone'])) return {'status': 400, 'message': 'User {} already exists'. format(data['mphone'])} new_user = { "fname": data['fname'], "lname": data['lname'], "mphone": data['mphone'], "phone": data['phone'], "email": data['email'], "mcode": data['mcode'], "state": data['state'], "city": data['city'], "address": data['address'], "pass": sha256.hash(data['pass']), } try: models.create_user(new_user) access_token = create_access_token(identity=data['mphone'], expires_delta=ACCESS_TOKEN_EXPIRE) refresh_token = create_refresh_token(identity=data['mphone']) logging.info('user created. user: {}'.format(data['mphone'])) return { 'status': 200, 'message': 'User {} {} was created'.format(data['fname'], data['lname']), 'access_token': access_token, 'refresh_token': refresh_token } except Exception as e: logging.error('exception occurred', exc_info=True) return {'status': 500, 'message': 'Something went wrong'}
def post(self): username = self.get_argument('username') password = self.get_argument('password') session = Session() result_dict = {} try: picture_binary = self.request.files['profile_picture'][0]['body'] create_user(username = username, password=password, profile_picture=picture_binary) result_dict['result'] = "SUCCESS" except Exception, e: session.rollback() result_dict['result'] = "ERROR" result_dict['reason'] = e.message
def register_user(): info = request.json email, password, name, role = info['email'], info['password'], info[ 'name'], info['role'] if auth.check_email_exists(email): # Make it a proper response? return jsonify({"id": -1, "status": "Nope, email taken"}), 401 if role not in ('teacher', 'student'): return jsonify({ "id": -1, "status": "Role has to be either teacher or student" }), 401 pwd_hash = generate_password_hash(password) student_id, teacher_id, user_id = models.create_user( email, pwd_hash, name, role) response = { "id": user_id, "student_id": student_id, "teacher_id": teacher_id, "status": "Worked" } if role == 'student': models.run_simple_query( "INSERT INTO classes_students (class_id, student_id) VALUES (1, ?)", (student_id, )) return jsonify(response)
def signup(): form = forms.SignupForm(request.form) form.country.choices = [(c.countryid, c.countryname) for c in models.get_all_countries()] if request.method == 'POST' and form.validate(): fname = form.first_name.data lname = form.last_name.data email = form.email_id.data passwd = sha256_crypt.encrypt(str(form.password.data)) user_type = form.usertype.data aptno = form.apartment_no.data street = form.street.data city = form.city.data state = form.state.data zipcode = form.zipcode.data country = form.country.data phoneno = form.phone_number.data r = models.create_user(fname, lname, email, passwd, aptno, street, city, state, zipcode, country, phoneno, user_type) if (r == 0): flash('You are now registered', 'success') return redirect(url_for('login')) elif (r == 1): flash("User with email %s already exists" % (email), 'danger') return render_template('signup.html', form=form) return render_template('signup.html', form=form)
def login(conn): message2conn('Enter your name : ', conn) try: name = conn.recv(2048) name = name.decode().strip() if 2 < len(name) < 20 and name not in dict_of_users: message2conn('Enter your password: '******'You are not logged', conn) return False if is_username_used(name): # registered user if check_user(name, password): message = 'Thank you, {}. You are logged!'.format(name) else: message2conn('Password is wrong', conn) return False else: # new user if create_user(name, password): message = 'Thank you, {}. You are registered and logged!'.format(name) else: message2conn('Login or password are wrong', conn) return False dict_of_users[conn] = name message2conn(message, conn) return True else: message2conn('This name is not available!\n\t( 2 < len(NAME) < 20 )', conn) return False except: message2conn('You are not logged', conn) return False
def signup(): form = SignupForm() print(form.validate_on_submit()) if form.validate_on_submit(): username = form.name.data password = form.password.data password1 = form.password_conf.data if password != password1: return '<h1>Password do not match!</h1>' if check_user_present(username): flash('User already present') return redirect(url_for('login')) hashed_pwd = bcrypt.hashpw(password.encode('utf8'), bcrypt.gensalt()) if bcrypt.checkpw(password.encode('utf8'), hashed_pwd): res = create_user(username, hashed_pwd) username,_,user_id = login_user(username) if res: session['id'] = user_id session['username'] = username flash('Signup Success!') return redirect(url_for('index')) else: flash('Signup Failed!') return redirect(url_for('signup')) return render_template('signup.html',form=form)
def register(): form = RegisterForm(request.form) if request.method == 'POST': rule_email = re.compile(r'(\w+[.|\w])*@(\w+[.])*\w+') if not rule_email.search(form.email.data): flash('ERROR! Please enter valid emailid') return redirect(url_for('register')) rule = re.compile(r'(^[+0-9]{1,3})*([0-9]{10,11}$)') if not rule.search(form.phonenumber.data): flash( 'ERROR! Please enter valid phone number in international number format '\ 'eg: +918888999900' ) return redirect(url_for('register')) user = models.create_user( form.firstname.data, form.lastname.data, form.group.data, form.email.data, form.address.data, form.phonenumber.data, ) if user == 1: flash('ERROR! Please enter something or check yours\ username or user already exists') return redirect(url_for('register')) else: flash( 'INFO! Person added sucessfully! want to add another user..Please add it!' ) return redirect(url_for('register')) return render_template('forms/register.html', form=form)
def post(self): logger = logging.getLogger('CreateUserHandler') username = self.get_argument('username') password = self.get_argument('password') email = self.get_argument('email') logger.info('Create user request received, args grabbed') session = Session() result_dict = {} try: picture_binary = self.request.files['profile_picture'][0]['body'] create_user(username=username, password=password, profile_picture_binary=picture_binary, email=email) result_dict = get_response_dict(True) result_dict['username'] = username except Exception, e: logger.exception(e) session.rollback() result_dict = get_response_dict(False, e.message)
def gconnect(): if request.args.get('state') != session['state']: response = make_response(json.dumps('Invalid state parameter.'), 401) response.headers['Content-Type'] = 'application/json' return response code = request.data sucesso_code, retorno_code = google_connect.\ exchange_code_for_credentials(code) if not sucesso_code: return retorno_code credentials = retorno_code access_token = credentials.access_token sucesso_token, retorno_token = google_connect.\ verify_access_token(access_token) if not sucesso_token: return retorno_token # Verifica se o token enviado é do usuario sucesso_gplus_id, response_gplus_id = google_connect.\ verify_user_token(credentials, retorno_token, CLIENT_ID) if not sucesso_gplus_id: return response_gplus_id stored_access_token = session.get('access_token') stored_gplus_id = session.get('gplus_id') # Guarda o access_token session['access_token'] = credentials.access_token session['gplus_id'] = response_gplus_id # Busca dados do usuario userinfo_url = "https://www.googleapis.com/oauth2/v1/userinfo" params = {'access_token': credentials.access_token, 'alt': 'json'} answer = requests.get(userinfo_url, params=params) data = answer.json() if not models.get_user_by_email(data['email']): user = models.User() user.id = data['id'] user.email = data['email'] user.name = data['name'] models.create_user(user) logged_user = models.User() logged_user.id = data['id'] logged_user.email = data['email'] logged_user.name = data['name'] login_user(logged_user) return redirect(url_for('home'))
def new_user(): username = request.json.get('username') password = request.json.get('password') if username is None or password in None: abort(400) if user_exist(username): return jsonify({'message': 'user already exists'}), 200 user = create_user(username, password) return jsonify({'username': user.username}), 201
def test_create_client(): user = create_user('Username', '1234') client = create_client('Name', '899920068885', '*****@*****.**', user) assert len(clients) == 1 assert len(users) == 1 assert client.fio == 'Name' assert client.phone == '899920068885' assert client.email == '*****@*****.**' assert client.user == user
def register(): if request.method == "POST": username = request.form.get("username") email = request.form.get("email") password = request.form.get("password") confirm = request.form.get("confirm") #Check if passwords match if confirm != password: return render_template("error.html", error="Passwords must match. This will be handled by javascript and not let you click the button until it matches.") #Try to create the user try: hashed = generate_password_hash(password) create_user(username=username, email=email, password=hashed) except Exception as e: return render_template("error.html", error=e) return redirect("/") else: return render_template("register.html")
def register(): form = UserRegForm(request.form) if request.method == 'POST' and form.validate(): user = create_user("local_%s" % form.data['name'], form.data["name"], form.data['email'], copper_coins=5000, password=form.data['password']) cache.set(str(user.id), user) if login_user(user, remember=True): return redirect(request.args.get("next") or "/") #print form.data["name"], type(form.data["name"]) return render_template("reg.html", form=form)
def add_user(): """ Add new user """ roles_selected = [] # init list if request.method == 'POST': # record from data to database username = request.form.get("username") pwd_raw1 = request.form.get("password") pwd_raw2 = request.form.get("retype_password") first_name = request.form.get("first_name") last_name = request.form.get("last_name") superior = request.form.get("superior") # format: '{id} {first_name} {last_name}' superior_id = int(superior.split()[0]) if superior else None roles_selected = request.form.getlist('roles') # check passwords if pwd_raw1 == pwd_raw2: # try to record entries into database result = models.create_user( username=username, password=pwd_raw1, first_name=first_name, last_name=last_name, superior_id=superior_id, roles=roles_selected ) # check exit code if result == 0: flash('User has been successfully registered') return redirect('/add_user') elif result == 1: flash('Username already exists!') elif result == 2: flash('Invalid password!') else: flash('Unknown error occured!') else: flash('Passwords do not match') # GET request or inappropriate POST request: render form managers = get_managers() roles = get_roles() if not roles_selected: roles_selected = ['Employee',] # default value: Employee return render_template("add_user.html", managers=managers, roles=roles, roles_selected=roles_selected)
def register(): form = UserRegForm(request.form) if request.method == "POST" and form.validate(): user = create_user( "local_%s" % form.data["name"], form.data["name"], form.data["email"], copper_coins=5000, password=form.data["password"], ) cache.set(str(user.id), user) if login_user(user, remember=True): return redirect(request.args.get("next") or "/") # print form.data["name"], type(form.data["name"]) return render_template("reg.html", form=form)
def register(): form = RegisterForm(request.form) if request.method == 'POST': user = models.create_user( form.userid.data, form.name.data, form.role.data, form.email.data, form.password.data ) if user == 1: hriks( 'ERROR! Please enter something or check yours\ username and password or user already exists' ) return redirect(url_for('register')) else: return redirect(url_for('home')) return render('forms/register.html', form=form)
def new_user(): """ Create a new user :return string: JSON """ # Get user data data = request.json.get('data') username = clean(data.get('username')) password = clean(data.get('password')) first_name = clean(data.get('first_name')) last_name = clean(data.get('last_name')) email = clean(data.get('email')) # Check user data if len(username) < 3: return jsonify({'error': 'username too short'}), 200 if len(password) < 8: return jsonify({'error': 'password must to be more 8 characters'}) if len(first_name) < 2: return jsonify({'error': 'first name is too short, min 2 characters'}) if len(last_name) < 2: return jsonify({'error': 'last name is too short, min 2 characters'}) if email_is_valid(email) is False: return jsonify({'error': 'email is not valid'}), 200 # Check user exist if user_exist(username): return jsonify({'error': 'user already exists'}), 200 # Create a new user user = create_user(username, password, first_name, last_name, email) or None if user is None: return jsonify({'error': 'error create user'}), 200 g.user = user # Data preparation data = { 'message': 'User created', 'id': g.user.id, 'full_name': g.user.get_full_name } return jsonify(data), 201
def register(): """Extracts user details from the post request using the UserDetails class imported from the user_details file. Runs a helper method called combine_details to check for validity of user details. uses helper function called create user from the models.py file fond in the root of the project to create a user and and inserts the user's details into the database. Otherwise it returns an error with an invalid message.""" details = UserDetails() if details.validate_details: return jsonify({"message": str(details.validate_details) + " must be longer then 5 and less than 60"}), 411 if details.get_password() == details.get_password2(): if create_user(details.get_first_name(), details.get_last_name(), details.get_user_name(), details.get_email(), details.get_password()) is True: return jsonify({"message": "Successfully registered."}), 201 return jsonify({"message": "username or email already taken."}), 403 return jsonify({"message": "passwords must match"}), 409
def login(request): token = None if request.method == 'POST': token = request.POST.get('token') else: token = request.GET.get('token') if token == None: return redirect("/demo.html?loginFailed=true") u = None try: u = urlopen('https://rpxnow.com/api/v2/auth_info?apiKey=%s&token=%s' % (JANRAIN_API_KEY, token)) auth_info = json.loads(u.read()) status = auth_info['stat'] if status != 'ok': return redirect("/demo.html?loginFailed=true") profile = auth_info['profile'] identifier = profile['identifier'] email = profile['email'] if profile.has_key('email') else None candidate = User.objects.filter(open_id = identifier) user = None portfolio = None target = 'transactions' if candidate.count() == 0: user = create_user(identifier, email) portfolio = create_portfolio(user, 'Default') else: user = candidate[0] portfolio = Portfolio.objects.filter(user__id__exact = user.id)[0] target = 'positions' request.session['user_id'] = user.id return redirect_to_portfolio_action(target, portfolio) finally: if u != None: u.close()
def post(self): errors = [] username = self.request.get('username'); logging.error(username) email = self.request.get('email'); logging.error(email) password = self.request.get('password'); logging.error(password) confirm_password = self.request.get('confirm_password'); logging.error(confirm_password) if (username and email and password and (password == confirm_password)): username = utils.clean_input(username) email = utils.clean_input(email) user = models.create_user(username, email, password) if user: self.set_user(user) self.redirect('/blog/posts') else: errors.append('An error occured, please try again.') if not username: errors.append('Username is required.') if not password: errors.append('Password is required.') elif not password == confirm_password: errors.append('Passwords do not match.') self.render_template('register.html', {'errors': errors})
def register(): if request.method == 'GET': return render_template('addUser.html') name = request.form.get('name') email = request.form.get('email') username = request.form.get('username') password = request.form.get('password') existentUser = User.query.filter((User.username == username) | (User.email == email)).first() if not existentUser: user = create_user(name, email, username, password) token = ts.dumps(user.email, salt='email-confirm-key') confirm_url = url_for('confirm_email', token=token, _external=True) return render_template('activate.html', confirm_url=confirm_url) else: flash('User credentials already exists') return redirect(url_for('register'))
def valid_api(): try: if 'apiKey' in request.json: api_key = request.json.get('apiKey') if 'secretkey' in request.json and 'email' in request.json and 'phone' in request.json: secret_key = request.json.get('secretkey') email = request.json.get('email') phone = request.json.get('phone') if api_key == "" or secret_key == "": return jsonify({"error-message": "Invalid Credentials"}) else: try: key_verf = models.api_vald(api_key=api_key, secret_key=secret_key) if key_verf == "Api key Verified": api_auth = models.mydb.Os_ver.find_one( {"api_key": api_key}) client = api_auth['client'] # sid = uuid.uuid4() # session['sid'] = sid session['client'] = client session['user'] = email entry = models.create_user(email=email, phone=phone, client=client) if entry == "Please fill all the feilds carefully": return jsonify({"error-message": entry}) else: if entry == "Email or Phone already exists.": return jsonify({"error-message": entry}) else: # addd client also mail = SendActivationApi.mailer( sid=sid, Resend="False") if mail == "Mail Sent Successfully": sent_at = datetime.now() + timedelta( minutes=2) models.mydb.User.update( { "Client Name": client, "email": email }, {"$set": { "sent_at": sent_at }}) session['sent_at'] = sent_at session[ 'Reg_Phase'] = "phase 1 complete" # if otp resend then having issue with sent_at timmings return jsonify({ 'Session_id': entry, 'error-message': mail }) else: session[ 'sent_at'] = "Mail sending Failed" session[ 'Reg_Phase'] = "Mail sending Failed" return jsonify({ 'Session_id': entry, 'error-message': "Mail sending Failed" }) # models.mydb.sessions.update({"sid" : session.sid}, {"$set": {"Last Used" : datetime.now()}}) else: return jsonify( {"error-message": "Invalid Api Key"}) except Exception as e: return "Error Occured: {}".format(str(e)) else: # raise ValueError ('Incomplete JSON data') return jsonify({"error-message": "Incomplete JSON data"}) else: # raise ValueError ('Invalid Argument List') return jsonify({"error-message": "Invalid Credentials"}) except Exception as e: return "Error Occured: {}".format(str(e))
def setUp(self): self.url_tester = TestURLs.URLTester(self) for _ in range(random.randint(1, 20)): create_user()
def setUp(self): self.client = Client() self.username, self.user = create_user()
def create_user(self): self.user_password = randstr(30, True) self.user = create_user(username=self.username, password=self.user_password) give.models.UserWebsite.objects.create( user=self.user.get_profile(), url='http://example.com')
def create_user(self): self.user_password = randstr(30, True) self.user = create_user(username=self.username, password=self.user_password) give.models.UserWebsite.objects.create(user=self.user.get_profile(), url="http://example.com")
def get_demo_user(): candidate = User.objects.filter(open_id = DEMO_USER_OPEN_ID) if candidate.count() == 1: return candidate[0] else: return create_user(DEMO_USER_OPEN_ID, DEMO_USER_OPEN_ID)