def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_user_by_username(data["username"]):
return {"Message": "Username already exists."}, 400
user = UserModel(**data)
user.save_to_db()
return {"Message": "User was succesfully created."}, 201
def post(self):
json_data = request.get_json()
user_schema = UserSchema()
try:
data = user_schema.load(json_data).data
except ValidationError as err:
return jsonify({"message": err.messages})
hashed = hashpw(data.password.encode("utf-8"), gensalt())
user = UserModel.fetch_using_username(data.username)
if user is None:
user = UserModel.fetch_using_email(data.email)
if user is None:
try:
data.password = hashed
data.save_to_db()
except:
return {
"message": "An error occurred while registering."
}, 500
session.clear()
return jsonify({"message": "User successfully registered."})
else:
return {
"message": "A user with the same email already exists."
}, 500
else:
return {
"message": "A user with the same username already exists."
}, 500
def post(self):
request_data = _user_parser.parse_args()
if UserModel.findusername(request_data['username']):
return {'Message': 'A user with that username already exist'}, 400
user = UserModel(**request_data)
user.savestorage()
return {"Message": "Userid was successfully created"}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "username already exist!"}, 400
UserModel(data['username'], data['password']).save_to_db(
) #we can also do UserModel(**data).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": "A user with that username already exists"}, 400
user = UserModel(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": "the account is used by someone already"}, 400
user_account = UserModel(**data)
user_account.save_to_db()
return {"message": "the account register successfully"}, 201
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_name(data['name']):
return {"message": "A user with that name already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
data = UserRegistration.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User with this username already exists"}, 409
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully"}, 201
def post(self):
data = User_register.parser.parse_args()
if UserModel.find_by_user(data['user']):
return {"message": "This user already exists."}, 400
user = UserModel(data['user'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
data=user_register.parser.parse_args()
row=UserModel.get_username(data['username'])
if row:
return {"message":"User already registered"}
else:
user=UserModel(data['username'],data['password'])
db.session.add(user)
db.session.commit()
return {'message':"User registered successfully"}
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 successfully registered'}, 201
def post(self):
data = Register_User.parser.parse_args()
if UserModel.find_by_user(data['username']):
return {
'message':
"username :{} already exists".format(data['username'])
}
user = UserModel(**data)
user.save_to_db()
return {'message': "username registered successfully"}, 201
def post(self):
data = UserRegister.parser.parse_args()
if(UserModel.find_by_username(data['username'])):
return {"message": "User {} alreay exists".format(data['username'])},401
user = UserModel(data['username'],data['password'])
# alternate way of using unpacking
# user = UserModel(**data)
user.save_to_db()
return {"message":"Created user {} successfully".format(data['username'])},201
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 # Bad request
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201 # Created
def post(self):
data = _parser.parse_args()
username = data['username']
user = UserModel.find_by_username(data['username'])
if user:
return {"message": f"Username '{data['username']}' already exists"}
else:
user = UserModel(**data)
user.save_to_db()
count_of_users = len(UserModel.query.all())
sms_contact(os.getenv(
'ADMIN_PHONE'), f"A new user just created an account (username: {username}) that makes {count_of_users} users")
return {"message": "Acccount was created successfully"}, 201
def test_register_user(self):
with self.app() as client:
with self.app_context():
response = client.post("/register",
data={
"username": "******",
"password": "******"
})
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(UserModel.find_by_username("ipo"))
self.assertIsNotNone(UserModel.find_by_id(1))
self.assertDictEqual(
{"message": "the account register successfully"},
json.loads(response.data))
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'User with this username already exists'}, 400
User = UserModel(**data)
User.save_to_db()
# connection = sqlite3.connect('data.db')
# cursor = connection.cursor()
# query = "INSERT INTO users VALUES (NULL, ?, ?)"
# cursor.execute(query, (data['username'],data['password']))
#
# connection.commit()
# connection.close()
return {'message': 'User created successfully'}, 201
def put(self, username):
if username == session.get("username", None):
user = UserModel.fetch_using_username(username)
json_data = request.get_json()
user_schema = UserSchema()
try:
data = user_schema.load(json_data, partial=True).data
except ValidationError as err:
return jsonify("message", err.messages)
user.email = data.email
user.password = data.password
user.first_name = data.first_name
user.last_name = data.last_name
try:
user.save_to_db()
except:
return {
"message": "An error occurred while updating details.."
}, 500
return jsonify({"message": "User details updated."})
else:
return jsonify({"message": "User not logged in."})
def authenticate(username, password):
"""
authenticates the user by using username and password
"""
user = UserModel.find_by_username(username)
if user and user.password == password:
return user
def get(self, username):
if username == session.get("username", None):
user = UserModel.fetch_using_username(username)
user_schema = UserSchema()
return user_schema.dump(user).data
else:
return jsonify({"message": "User not logged in."})
def login_user(**kwargs):
user = UserModel.get_by_username(kwargs['username'])
if user and user.authenticate(kwargs['password']):
access_token = create_access_token(user.id, fresh=True)
refresh_token = create_refresh_token(user.id)
return jsonify(access_token=access_token, refresh_token=refresh_token)
return {"message": "Invalid username or password."}, 401
def authenticate(username, password):
"""prepare password, username in string format to call the /auth endpoint"""
user = UserModel.find_by_username(username)
if user and safe_str_cmp(user.password, password):
return user
return None
def post(self):
data = _parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and safe_str_cmp(user.password, data['password']):
token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(identity=user.id)
return {"token": token, "refresh_token": refresh_token}, 200
return {"message": "Invalid credentials"}
def test_crud(self):
with self.app_context():
user = UserModel("ipo", "kk")
self.assertIsNone(UserModel.find_by_username("ipo"))
self.assertIsNone(UserModel.find_by_id(1))
user.save_to_db()
self.assertIsNotNone(UserModel.find_by_username("ipo"))
self.assertIsNotNone(UserModel.find_by_id(1))
def post(self):
request_data = Register.parser.parse_args()
if UserModel.usernamefinding(request_data['username']):
return {'Message': 'A user with that username already exist'}, 400
user = UserModel(**request_data)
user.save_db()
## connection = sqlite3.connect('data.db')
## cursor = connection.cursor()
## insert = "INSERT INTO users VALUES(NULL, ?, ?)"
## cursor.execute(insert, (request_data['username'],request_data['password']))
##
## connection.commit()
## connection.close()
return {'Message': 'User Id was created successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User with that username already exists."}, 400
# connection = sqlite3.connect('data.db')
# cursor = connection.cursor()
# query = "INSERT INTO {table} VALUES (NULL, ?, ?)".format(table=self.TABLE_NAME)
# cursor.execute(query, (data['username'], data['password']))
# connection.commit()
# connection.close()
# return {"message": "User created successfully."}, 201
# user = UserModel(data['username'], data['password'])
user = UserModel(**data) #same as above
def get():
"""
GET /user?username=<string:name>
Method for getting user details
"""
data = request.args
_username = str(data['username'])
if _username == '$_give_me_all_users_$':
all_users = UserModel.find_all()
return {"user_details": [user.json() for user in all_users]}, 200
else:
user = UserModel.find_by_username(_username)
if user is not None:
return user.json(), 200
else:
return {"message": "No user Found"}, 404
def test_delete_user(self):
result = self.session.query(UserModel).all()
if (not len(result)):
self.session.add(UserModel('testing', '123456'))
self.session.commit()
result = self.session.query(UserModel).all()
self.session.delete(result[0])
after_result = self.session.query(UserModel).all()
self.assertEqual(len(after_result), len(result) - 1)
def test_add_user(self):
actual_users_before = self.session.query(UserModel).count()
user_to_add = UserModel('testing', '123456')
self.session.add(user_to_add)
self.session.commit()
total_now = self.session.query(UserModel).count()
self.assertEqual(total_now, actual_users_before + 1)
def delete(self, user_id):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'Admin Privileges required for this operation'}
user = UserModel.find_by_id(user_id)
if (not user):
return {'message': 'User not found'}, 404
elif user.id == 1:
return {'message': 'Can not delete admin'}, 500
user.delete_from_db()
return {'message': 'User {} deleted'.format(user.username)}, 200
