def test_decode_auth_token(self):
user = UserModel(email='*****@*****.**', password='******')
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(UserModel.decode_auth_token(auth_token) == 1)
def sign_up_user_post(environ, start_response):
"""
Used to manage sign up user request.
Manage sign_up.html request.
Parameters
----------
start_response : start_response
WSGI start_response
environ : environ
WSGI python environ
Returns
-------
list
sign up view
"""
request = POST(environ)
fields = set(field for field in User.__dict__)
dct = {key: value for key, value in request.items() if key in fields}
user = User(**dct)
user.password = hashlib.sha256(user.password.encode()).hexdigest()
try:
Session = sessionmaker()
Session.configure(bind=engine)
session = Session()
session.add(user)
session.commit()
return redirect(start_response, '/')
except Exception as e:
return redirect(start_response, '/')
async def get_user(request, user, logged_user):
if logged_user.username == user and User.get(
logged_user.username) is not None:
return json(User.get(user).export())
return json(
{
'error': 'You cannot access these information',
'code': 403
},
status=403)
def main():
conn = init_db()
try:
conn.use(config.db_name)
User(username='******', password='******', group=0)
except r.errors.ReqlOpFailedError:
build_db(conn)
User(username='******', password='******', group=0)
except ThinkTwiceException:
pass
init_routes()
app.run(host=config.webapi_host, port=config.webapi_port)
return 0
def get_user(test_input):
return User(
_id=test_input["_id"],
username=test_input["username"],
firstname=test_input["firstname"],
lastname=test_input["lastname"],
email=test_input["email"],
password=test_input["password"],
created_at=test_input["created_at"],
updated_at=test_input["updated_at"],
permissions=test_input["permissions"],
)
def register():
if current_user.is_authenticated :
return redirect(url_for('home'))
form=RegisterForm()
if form.validate_on_submit() :
hash_password=bcrypt.generate_password_hash(form.password.data).decode("utf-8")
user=User(username=form.username.data,email=form.email.data,password=hash_password)
db.session.add(user)
db.session.commit()
flash(f"'{form.username} is created you can login now ","success")
return redirect(url_for('user.login'))
return render_template("user/register.html",title="Register",form=form)
def test_user_legit_args(self, test_input, expected):
user = User(
username=test_input["username"],
firstname=test_input["firstname"],
lastname=test_input["lastname"],
email=test_input["email"],
password=test_input["password"],
)
assert user.username == expected["username"]
assert user.firstname == expected["firstname"]
assert user.lastname == expected["lastname"]
assert user.email == expected["email"]
assert user.password == expected["password"]
def setUp(self):
"""
Prepares test case.
Create an user call 'david'.
"""
password = hashlib.sha256('1t3st1t'.encode()).hexdigest()
user = User(name='david',
email='*****@*****.**',
country='CO',
password=password)
Session = sessionmaker()
Session.configure(bind=engine)
session = Session()
session.add(user)
session.commit()
def test_unique_email(self):
"""
Verifies unique email.
Tries to create user with email '*****@*****.**'.
"""
password = hashlib.sha256('1t3st1t'.encode()).hexdigest()
user = User(name='jose',
email='*****@*****.**',
country='CO',
password=password)
with self.assertRaises(IntegrityError):
Session = sessionmaker()
Session.configure(bind=engine)
session = Session()
session.add(user)
session.commit()
def wrappee(*args, **kwargs):
headers = args[0].headers
if 'authorization' not in headers.keys():
return json({
'error': 'Missing Authorization header',
'code': 401
},
status=401)
try:
json_user = jwt.decode(headers['authorization'],
config.secret,
algorithms=['HS256'])
except jwt.exceptions.DecodeError as e:
return json({
'error': 'Invalid Authorization token',
'code': 401
},
status=401)
kwargs['logged_user'] = User.get(json_user['username'])
return f(*args, **kwargs)
def get_all(self):
return [User.from_dict(x) for x in super().get_all()]
def signup(inputs):
inputs["permissions"] = []
user = User(**inputs)
if UserManager().insert_one(user):
login_user(user)
return user
def test_password_setter(self):
u = User(password='******')
self.assertTrue(u.password_hash is not None)
def test_no_password_getter(self):
u = User(password='******')
with self.assertRaises(AttributeError):
u.password
def get(self, user_id):
return User.from_dict(self.collection.find_one({"_id": user_id}))
def from_dict_to_object(data, state):
username = data['username']
email = data['email']
client_id = data['client_id']
return User(username, email, client_id, state)
def get_one_by_query(self, query):
result = self.collection.find_one(query)
return User.from_dict(result) if result else None
async def login_user(request):
return json(
User.login(request.json['username'], request.json['password']))
def put_user(request):
try:
User(request.json['username'], request.json['password']).export()
return json({})
except ThinkTwiceException as e:
return json({"error": e.message, "code": e.code}, status=e.code)
