def post(self):
parser = reqparse.RequestParser()
parser.add_argument('username',
help='This field cannot be blank',
location='json',
required=True)
parser.add_argument('password',
help='This field cannot be blank',
location='json',
required=True)
data = parser.parse_args()
if not re.match(UserModel.USERNAME_FORMAT, data['username']):
return {'message': 'User not found'}
current_user = UserModel.find_by_username(username=data['username'],
exclude_deleted=True)
if not current_user or current_user.deleted_at != None:
return {'message': 'User {} not found'.format(data['username'])}
if UserModel.verify_hash(data['password'], current_user.password):
access_token = create_access_token(current_user.jwt_serialize())
refresh_token = create_refresh_token(current_user.jwt_serialize())
return {
'message': 'Logged in as {}'.format(current_user.username),
'access_token': access_token,
'refresh_token': refresh_token
}
else:
return {'message': 'Wrong credentials'}
def create_test_note1_and_note2_by_user1(self):
user_data = {
"username": '******',
'password': '******'
}
user = UserModel(**user_data)
user.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data["username"])
notes_data = [
{
"note": 'test note 1'
},
{
"note": 'test note 2'
},
]
ids = []
for note_data in notes_data:
note = NoteModel(author_id=user.id, **note_data)
note.save()
ids.append(note.id)
return user, user_data
def post(self):
"""Handles registration of user
Handles native user signup and sends authToken back in the
response
Request Body:
user (LoginRequestParams) -- LoginRequestParams data.
200 Response:
status (SuccessResponse) -- success
authToken ([jwt]) -- jwtToken
Error Responses:
400 () -- Bad Request
500 () -- Internal Server Error
"""
model = UserModel(db=self.db)
(status, _) = yield model.login(self.args)
if status:
authToken = yield self.authorize(_)
self.write(
json.dumps({
'status': 'success',
'auth_token': authToken
}))
else:
self.set_status(400)
self.write(json.dumps(_))
self.finish()
def test_get_note_by_id(self):
user_data = {"username": '******', "password": '******'}
user = UserModel(**user_data)
user.save()
notes_data = [
{
"text": 'Text note 1',
},
{
"text": 'Text note 2',
},
]
ids = []
for note_data in notes_data:
note = NoteModel(author_id=user.id, **note_data)
note.save()
ids.append(note.id)
headers = {
'Authorization':
'Basic ' +
b64encode(f"{user_data['username']}:{user_data['password']}".
encode('ascii')).decode('utf-8')
}
res = self.client.get('/notes', headers=headers)
self.assertEqual(res.status_code, 200)
data = json.loads(res.data)
self.assertEqual(len(data), 2)
def create_test_user1_note1_tag1_tag1(self):
user_data = {
"username": '******',
'password': '******'
}
user = UserModel(**user_data)
user.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data["username"])
note_data1 = {
"note": 'test note 1'
}
note = NoteModel(author_id=user.id, **note_data1)
note.save()
tags_data = [
{
"name": 'test1 tag'
},
{
"name": 'test2 tag'
}
]
for tag_data in tags_data:
tag = TagModel(author_id=user.id, **tag_data)
tag.save()
return user, note, user_data, tags_data
def post(self, **kwargs):
user = UserModel(**kwargs)
try:
user.save()
return user, 201
except:
abort(404, error=f"An error occurred while adding new user" \
"or a user with such name is already exist. " \
"You can only add a unique name")
def test_user_get_by_id(self):
user_data = {"username": '******', 'password': '******'}
user = UserModel(**user_data)
user.save()
user_id = user.id
response = self.client.get(f'/users/{user_id}')
data = json.loads(response.data)
self.assertEqual(response.status_code, 200)
self.assertEqual(data["username"], user_data["username"])
def mock_user_model(mocker):
# so that we don't actually save to the db
mocker.patch("api.models.user.UserModel.save_to_db")
mocker.patch(
"api.models.user.UserModel.find_all",
return_value=[
UserModel(name="john smith"),
UserModel(name="mary jane")
],
)
def create_test_user1(self):
user_data = {"username": '******', 'password': '******'}
user = UserModel(**user_data)
user.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data["username"])
return user_data
def post(self):
# make sure all required fields are present
user_data = self.parser.parse_args()
try:
user = UserModel(**user_data)
user.save_to_db()
except Exception:
return {"message": "Unable to create user"}, 500
return {"message": "successfully created user", "payload": user.json()}, 201
def test_register_duplicate_user(self):
user = UserModel('test', 'password')
user.save_to_db()
response = self.client.post(
'/register',
data=json.dumps({
'username': '******',
'password': '******'
}),
headers={'Content-Type': 'application/json'})
self.assertEqual(response.status_code, 400)
expected = {"message": "A user with that username already exists"}
self.assertDictEqual(expected, json.loads(response.data))
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('username',
help='This field cannot be blank',
location='json',
required=True)
parser.add_argument('password',
help='This field cannot be blank',
location='json',
required=True)
parser.add_argument('email',
help='This field cannot be blank',
location='json',
required=True)
data = parser.parse_args()
if not re.match(UserModel.USERNAME_FORMAT, data['username']):
return {
'message':
'Username must consist of letters, numbers, hyphens and underscores'
}
if UserModel.find_by_username(username=data['username'],
exclude_deleted=False):
return {
'message':
'Username {} already exists'.format(data['username'])
}
if UserModel.find_by_email(email=data['email'], exclude_deleted=False):
return {
'message':
'User with email {} already exists'.format(data['email'])
}
new_user = UserModel(
username=data['username'],
password=UserModel.generate_hash(data['password']),
email=data['email'],
deleted_at=None,
)
try:
new_user.save_to_db()
access_token = create_access_token(new_user.jwt_serialize())
refresh_token = create_refresh_token(new_user.jwt_serialize())
return {
'message': 'User {} was created'.format(data['username']),
'access_token': access_token,
'refresh_token': refresh_token
}
except:
return {'message': 'Something went wrong'}, 400
def create_test_tag1_by_user1(self):
user_data1 = {"username": '******', 'password': '******'}
user1 = UserModel(**user_data1)
user1.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data1["username"])
tag_data1 = {"name": 'test tag'}
tag1 = TagModel(author_id=user1.id, **tag_data1)
tag1.save()
return tag1, user1, user_data1
def get(self):
"""
Returns user Profile
HTTP Header:
Authorization (str) -- Required
200 Response:
status (ProfileSchema) -- success
:return:
"""
model = UserModel(user=self._user, db=self.db)
profile = model.get_profile()
self.write(dumps(profile))
def get(self):
# Search user
users = UserModel.search(
keyword=request.args.get('keyword'),
fields=('username', '_id')
)
return {'users': users}
def isUserExist(self, userid):
user = UserModel.get_by_id(userid)
# print user
if user is not None:
return True
else:
return False
def test_create_user(self):
user = UserModel('Test', 'password')
self.assertIsNotNone(user)
self.assertEqual(user.username, 'Test')
self.assertEqual(user.password, 'password')
def addUser(self, user):
# currentuser = UserModel(parent=self.getUserKey()) #User is a parent and has username as the key
if self.isUserExist(user['username']) is not True:
currentuser = UserModel()
currentuser.key = ndb.Key(UserModel, user['username'])
currentuser.username = user['username']
currentuser.realname = user['realname']
currentuser.password = user['password']
currentuser.group = user['group']
currentuser.put()
return True
else:
return False
def create_test_user1_and_user2(db_create):
users_data = [
{
"username": '******',
'password': '******'
},
{
"username": '******',
'password': '******'
},
]
users_lst = []
for user_data in users_data:
user = UserModel(**user_data)
user.save()
users_lst.append(user)
return users_lst
def post(cls):
data = _user_parser.parse_args()
user = UserModel.find_by_username(data['username'])
data_password_hashed = sha512(
data['password'].encode('utf-8')).hexdigest()
if user and safe_str_cmp(data_password_hashed, user.password):
access_token = create_access_token(identity=user.id)
return {'access_token': access_token}
return {'message': 'Invalid credentials'}, 401
def load_tables():
if len(DryBreadModel.find_all()) == 0:
print('Database does not exist/is empty. Creating from file...')
data = dict()
with open('tmp_database.json', 'r', encoding='utf-8') as f:
data = json.loads(f.read())
for e in data['suchary']:
if e['type'] <= cfg['JOKE_TYPE']:
db = DryBreadModel(e['q'], e['a'])
db.save_to_db()
print('drybreads loaded:', [x.json() for x in db.find_all()])
####users database
from api.models.user import UserModel
admin = UserModel('admin', 'admin', UserModel.ROLE_ADMIN)
admin.save_to_db()
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("username", required=True)
parser.add_argument("password", required=True)
user_data = parser.parse_args()
user = UserModel(**user_data)
db.session.add(user)
db.session.commit()
return user_schema.dump(user), 201
def test_register_and_login(self):
UserModel('test', 'password').save_to_db()
auth_response = self.client.post(
'/auth',
data=json.dumps({
'username': '******',
'password': '******'
}),
headers={'Content-Type': 'application/json'})
self.assertIn('access_token', json.loads(auth_response.data).keys())
def on_post(self, req, resp):
data = req.context.get("json")
if UserModel.find_by_username(data.get("username")):
payload = {
"message":
f"User with username:{data.get('username')} already exists"
}
resp.body = json.dumps(payload, ensure_ascii=False)
resp.status = falcon.HTTP_400
else:
user = UserModel(**data)
user.save_to_db()
payload = {"message": "User created sucessfully"}
resp.body = json.dumps(payload, ensure_ascii=False)
resp.status = falcon.HTTP_201
def post(self):
args = self.reqparse.parse_args()
user = UserModel(args.name, args.state)
db.session.add(user)
db.session.commit()
response = UserSchema().dump(user)
return response, 201
def verify_password(username_or_token, password):
from api.models.user import UserModel
#print("username_or_token = ", username_or_token)
user = UserModel.verify_auth_token(username_or_token)
if not user:
user = UserModel.query.filter_by(username=username_or_token).first()
if not user or not user.verify_password(password):
return False
g.user = user
return True
def create_test_tag1_and_tag2_by_user1(self):
user_data1 = {"username": '******', 'password': '******'}
user1 = UserModel(**user_data1)
user1.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data1["username"])
tags_data = [{"name": 'test1 tag'}, {"name": 'test2 tag'}]
ids = []
for tag_data in tags_data:
tag = TagModel(author_id=user1.id, **tag_data)
tag.save()
ids.append(tag.id)
return user1, user_data1, tags_data
def setUp(self):
super(ItemTest, self).setUp()
UserModel('test', 'password').save_to_db()
auth_response = self.client.post(
'/auth',
data=json.dumps({
'username': '******',
'password': '******'
}),
headers={'Content-Type': 'application/json'})
self.token = 'JWT {}'.format(
json.loads(auth_response.data).get('access_token'))
def test_users_get(self):
users_data = [
{
"username": '******',
'password': '******'
},
{
"username": '******',
'password': '******'
},
]
for user_data in users_data:
user = UserModel(**user_data)
user.save()
res = self.client.get('/users')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
print(data)
self.assertEqual(data[0]["username"], users_data[0]["username"])
self.assertEqual(data[1]["username"], users_data[1]["username"])
def test_register_user(self):
response = self.client.post(
'/register',
data=json.dumps({
'username': '******',
'password': '******'
}),
headers={'Content-Type': 'application/json'})
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(UserModel.find_by_username('test'))
expected = {"message": "User created successfully."}
self.assertDictEqual(expected, json.loads(response.data))
def create_test_user1_note1_by_user1(self):
user_data1 = {
"username": '******',
'password': '******'
}
user1 = UserModel(**user_data1)
user1.save()
res = self.client.get("/users")
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data[0]["username"], user_data1["username"])
note_data1 = {
"note": 'test note 1'
}
note1 = NoteModel(author_id=user1.id, **note_data1)
note1.save()
return note1, user1, user_data1
def post(self, _id=None):
UserModel.register(request.form)
return 'ok'