def post(self):
data = UserParser.parser.parse_args()
data['semester'] = StudentRegister.student_parser.parse_args(
)['semester']
# ensure username is proper
if not data['username'][0].isalpha():
return {"message": f"Invalid username."}, 400
if UserModel.find_by_username(data['username']):
return {
"message":
f"User with username: {data['username']} already exists."
}, 400
if UserModel.find_by_code(data['code']):
return {
"message": f"User with code: {data['code']} already exists."
}, 400
if UserModel.find_by_email(data['email']):
return {
"message": f"User with email: {data['email']} already exists."
}, 400
temp_pass = bcrypt.generate_password_hash(data['password'],
10).decode('UTF-8')
data['password'] = temp_pass
user = StudentModel(**data) # unpacking the dictionary
user.save_to_db()
return {"message": f"Student was created successfully."}, 201
def post(self):
request_data = Login.parser.parse_args()
username = request_data.get('username')
password = request_data.get('password')
user = UserModel.find_by_username(username)
if user:
if safe_str_cmp(password, user.password):
# create expiration time for access and refresh tokens
access_token_expiry_time = timedelta(minutes=15)
refresh_token_expiry_time = timedelta(hours=1)
# username or user.id anything can be used here as identity
# eg. access_token = create_access_token(identity=User.id)
access_token = create_access_token(
identity=username,
fresh=True,
expires_delta=access_token_expiry_time)
# similary create a refresh token
refresh_token = create_refresh_token(
identity=username, expires_delta=refresh_token_expiry_time)
return {
'access_token': access_token,
'refresh_token': refresh_token
}, 200
return {'message': 'Invalid credentials!'}, 401
def post(cls):
data = _user_parser.parse_args()
user = UserModel.find_by_username(data["username"])
if user:
return {"message": USER_ALREADY_EXISTS.format(data["username"])}, 400
UserModel(**data).save_to_db()
return {"message": USER_CREATED}, 201
def post(self):
"""
Create a new user after verifying that all details are provided
"""
data = register_parser.parse_args()
username = data["username"]
if UserModel.find_by_username(username):
return {"message": f"User {username} already exists"}
new_user = UserModel(
username=username,
email=data["email"],
full_name=data["full_name"],
password=UserModel.generate_hash(data["password"])
)
try:
new_user.save_to_db()
access_token = create_access_token(
identity=username, expires_delta=False)
return {
"message": f"User {username} was created",
"access_token": access_token
}
except:
return {"message": "Something went wrong"}, 500
def post(self):
data = UserParser.parser.parse_args()
if not data['username'][0].isalpha():
return {'message': 'Invalid username.'}, 400
if UserModel.find_by_username(data['username']):
return {
"message":
f"User with username: {data['username']} already exists."
}, 400
if UserModel.find_by_code(data['code']):
return {
"message": f"User with code: {data['code']} already exists."
}, 400
if UserModel.find_by_email(data['email']):
return {
"message": f"User with email: {data['email']} already exists."
}, 400
temp_pass = bcrypt.generate_password_hash(data['password'],
10).decode('UTF-8')
data['password'] = temp_pass
user = AdminModel(**data) # unpacking the dictionary
user.save_to_db()
return {"message": f"Admin was created successfully."}, 201
def post(self):
data = UserRegister.parse.parse_args()
if UserModel.find_by_username(data['user_name']):
return {'msg': 'User already exists.'}, 400
UserModel(**data).save_to_db()
return {'msg': 'User created'}, 201
def post(self):
data = UserRegister.parser.parse_args()
user = UserModel(**data)
if UserModel.find_by_username(data['username']):
return {'message': 'A user with that username already exist'}, 400
user.save_user_to_database()
return {'message': 'User created succesfully'}
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {"message": "a user with that username already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "user created successfully"}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'Username already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "That username already exists"}, 400
user = UserModel(data['username'], hash_password(data['password']), data['role'])
user.save_to_db()
return {"message": "User created successfully"}, 201
def post(self):
'''Register a user'''
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(**data)
user.save()
return {"message": "User created successfully."}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return { 'message': 'User with username: "******" already exists in database'.format(data['username'])}, 400
user = UserModel(**data)
user.save_to_db()
return { 'message': 'User created successfully.' }, 201
def post(self):
data = user_parser.parse_args()
if safe_str_cmp(data['username'], "") or safe_str_cmp(
data['password'], ""):
return {'message': "Invalid input. Please try again"}, 400
if UserModel.find_by_username(data['username']):
return {'message': "Username already exists"}, 200
user = UserModel(data['username'], data['password'])
user.save_to_db()
return {'message': "User has been created successfully"}, 201
def test_register_user(self):
with self.api_client() as c:
with self.app_context():
response = c.post('/api/user/register',
data={
"username": "******",
"password": "******",
"role": "admin"
})
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(UserModel.find_by_username('test_admin'))
def post(self):
data = UsersRegister.parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user:
return {"message": "This user already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': "User created"}, 201
def authenticate(user_name, password):
if not user_name:
return {"msg": "Missing username parameter"}, 400
if not password:
return {"msg": "Missing password parameter"}, 400
user = UserModel.find_by_username(user_name)
if not user:
return {"msg": "No User Found"}, 401
if not safe_str_cmp(user.password, password):
return {"msg": "Incorrect Password"}, 401
else:
return {"token": create_access_token(identity=user.username)}, 200
def post(cls):
data = _user_parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and safe_str_cmp(user.password, data['password']):
access_token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(user.id)
return {
'access_token': access_token,
'refresh_token': refresh_token
}
return {"message": INVALID_CREDENTIALS}, 401
def post(self):
data = user_parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and safe_str_cmp(user.password, data['password']):
access_token = create_access_token(identity=user.id, fresh=True)
session['access_token'] = access_token
return {
'access_token': access_token,
'message': "Successfully logged in"
}, 200
else:
return {'message': "Invalid Credentials. Please try again"}, 401
def post(self):
data = UserRegister.parser.parse_args()
# is the username does not exist create new user, else give error message
if UserModel.find_by_username(data['username']) is None:
user = UserModel(
**data) # creates user with data that was entered by the user
user.save_to_db()
else:
return {'Message': "Username already exists"}, 400
# message to let user know they can now login using the username and password they provided
return {'message': "user was created successfully"}, 201
def post(self, name):
# if UserModel.find_by_username(data['username']):
if UserModel.find_by_username(name):
return {
'message': "A user with that username already exists."
}, 400
data = UserRegister.parser.parse_args()
user = UserModel(**data)
user.save_to_db()
return user.json(), 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {
"message": "User {} already exists.".format(data['username'])
}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
data = UserRegister.parser.parse_args()
#print ("**********am here", data['username'], data['password'])
if UserModel.find_by_username(data['username']) is not None:
return {'message': 'User already exists'}, 400
user = UserModel(1, data['username'], data['password'])
#print (data['username'], data['password'])
#also can -- user = UserModel(**data)
user.save_to_db()
return {'message': 'User created'}, 201
def post(cls):
data = cls.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "Already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User '{}' created".format(data['username'])}, 201
#gebruik classmethod en cls, om te voorkomen dat je de class moet hardcoden (User) in dit voorbeeld
def post(self):
try:
user = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages, 400
if UserModel.find_by_username(user.username):
return {"message": "User already exists"}, 400
user.save_to_db()
return {"message": "User created successfully"}, 201
def post(self):
data = UserRegister.parser.parse_args()
#Check if the user exists in the database
if UserModel.find_by_username(data['username']): #implies if arg not None
return {"message": "User already exists"}
#If doesnt exist create e a new user
user = UserModel(**data)#data['username'], data['password']
user.save_to_db()
return {"message":"User created successfully"},201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {
'message':
"User by the name '{}' already exists".format(data['username'])
}, 400
# user = UserModel(data['username'], data['password'])
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully"}, 201
def post(self):
data = UserRegister.parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user:
return {'message': 'username already exists. please try another..'}, 400
user = UserModel(data['username'], data['password'])
# here it wont update coz in the above return we are handling situation where user already exists
# so here it will create new user only
user.upsert()
return {'message': 'user created successfully'}, 201
def post(self):
payload = UserRegister.parser.parse_args()
if UserModel.find_by_username(payload['username']):
return {"message": "user already exists"}, 400
# connection = sqlite3.connect("users.db")
# cursor = connection.cursor()
#
# query = "INSERT INTO users VALUES (NULL, ?, ?)"
# cursor.execute(query, (payload['username'], payload['password']))
# connection.commit()
# connection.close()
user = UserModel(**payload)
user.save_to_db()
return {'message': "User was created successfully."}, 201
def post(self):
data = UserRegister.parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user:
message = 'User already exists'
status = 400
else:
user = UserModel(data['username'], data['password'])
user.save_to_database()
message = 'User created successfully'
status = 201
return {'message': message}, status
def test_crud(self):
with self.app_context():
# Create
user = UserModel('test_user', 'password', 'admin')
user.save_to_db()
# Read
user = UserModel.find_by_username('test_user')
self.assertIsNotNone(user)
user = UserModel.find_by_id(1)
self.assertIsNotNone(user)
user = next(iter(UserModel.find_by_role('admin')))
self.assertIsNotNone(user)
# Update
user.username = '******'
user.save_to_db()
user = UserModel.find_by_username('administrator')
self.assertIsNotNone(user)
# Delete
user.delete_from_db()
self.assertIsNone(UserModel.find_by_username('administrator'))
