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 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 setUp(self):
self.url_tester = TestURLs.URLTester(self)
for _ in range(random.randint(1, 20)):
create_user()
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)
