Welcome folks today in this blog post we will be building the python crud rest api in browser using flask and mongodb database. For this we will be using the flask-pymongo library.
Get Started
In order to get started you need to install the dependencies using the pip command as shown below
pip install flask_pymongo
pip install bcrypt
As you can see we are installing the above dependencies inside the flask project. Now we need to create the app.py file and copy paste the following code
app.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from flask import Flask from flask_pymongo import PyMongo from bson.json_util import dumps from bson.objectid import ObjectId from flask import jsonify,request from werkzeug.security import generate_password_hash,check_password_hash app = Flask(__name__) app.secret_key = "secretkey" app.config['MONGO_URI'] = "mongodb://localhost:27017/crud" mongo = PyMongo(app) if __name__ == "__main__": app.run(debug=True) |
As you can see we are importing the required libraries such as the flask and also the flask_pymongo library. And then we are making the new flask app. And also we are setting the secret key and also we are setting the config url of the mongo database. And here as you can see the mongodb uri contains the port number which is 27017 and also we have the mongodb database which is crud here. And then we are wrapping the flask app inside the PyMongo constructor. And then we are starting the flask app using the run() method.
Creating the Database in MongoDB
You can start the MongoDB Compass desktop software and then we can create a new database as shown below
And now if you run the app.py file inside the console you will see the below screenshot in browser
As you can see if you open 404 error will be there. This indicates that there is route specified for this as shown above.
Configuring the Routes
Now guys we will be configuring the routes inside the flask app as shown below
Adding the Users in MongoDB Database
Now guys we will be adding the users inside the mongodb database. For this we will be using the post route. So you need to copy paste the below code
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
@app.route('/add',methods=['POST']) def add_user(): _json = request.json _name = _json['name'] _email = _json['email'] _password = _json['password'] if _name and _email and _password and request.method == "POST": _hashed_password = generate_password_hash(_password) id = mongo.db.user.insert({'name':_name,'email':_email,'password':_hashed_password}) resp = jsonify("User Added successfully") resp.status_code = 200 return resp else: return not_found() |
As you can see in the above code we are writing the post route which is /adduser inside this we have defined the method add_user(). Here we are getting all the required json request data submitted by the user. Here we are using the json property of the request object. And then we are getting the name,email and password fields that the user submits while making the post request in postman. And then we are comparing if the name,email and password data exist and then we are checking the request method if it is post or not. If it is post we are converting the normal password to the hashed password using the generate_password_hash() function. And then we are inserting the details to the mongodb database using the insert() method And here we are inserting the name,email and password. And then we are returning the json response back to the client using the jsonify() method. And then we are also returning the status code and also the response as well. And in the else block if the data is not send alongside with the post request we will show the 404 error message using the not_found() method.
Now we need to define this not_found() method as shown below
|
1 2 3 4 5 6 7 8 9 10 11 |
@app.errorhandler(404) def not_found(error=None): message = { 'status':404, 'message':'Not Found' + request.url } resp = jsonify(message) resp.status_code = 404 return resp |
As you can see in the above code we are defining the 404 error function we are defining the json object which contains the two properties which is the status and the message of the error. And then we are returning the 404 status code. And also returning the response as well.
Now if you open the postman http client and make the post request to the specified url which is http://localhost:5000/add and pass the json data as shown below. You will get the message that the users has been successfully added and also a user record will be inserted inside the mongodb database
Getting all the Users From MongoDB Database
Now we will be writing the simple GET route where if you go we will be returning all the added users inside the mongodb database as shown below
|
1 2 3 4 5 |
@app.route('/users') def users(): users = mongo.db.user.find() resp = dumps(users) return resp |
As you can see we have written the route which is /users and for this we have defined the method which is called users() and inside this method we are fetching all the users present inside the user collection in mongodb database using the find() method and then we are returning the users as the json response back to the client using the dumps() method.
Now if you make the get request to the route /users inside the postman you will get the below json response
Getting Specific User Information Using ID From MongoDB Database
Now we will be writing the simple GET route where if you go we will be returning a specific user information which is present inside the mongodb database as shown below
|
1 2 3 4 5 |
@app.route('/users/<id>') def user(id): user = mongo.db.user.find_one({'_id':ObjectId(id)}) resp = dumps(user) return resp |
As you can see we have written the route which is /users/<id>and for this we have defined the method which is called user(id) and inside this method we are only fetching the specific user information using it’s id which is passed in the url as the parameter present and using the id we are using the find_one() method and passing the id as an argument and then we are returning the user as the json response back to the client using the dumps() method.
Now if you make the get request to the route /users/<id> inside the postman and passing the id of the user that you want the information you will get the below json response
Deleting Specific User Information Using ID From MongoDB Database
Now we will be writing the simple DELETE route where if you go we will be deleting a specific user using it’s id which is present inside the mongodb database as shown below
|
1 2 3 4 5 6 |
@app.route('/delete/<id>',methods=['DELETE']) def delete_user(id): mongo.db.user.delete_one({'id':ObjectId(id)}) resp = jsonify("User deleted successfully") resp.status_code = 200 return resp |
As you can see we have written the route which is /delete/<id>and for this we have defined the method which is called delete_user(id) and inside this method we are deleting the user using it’s id passed in the method as an argument. We are getting the id in the request as an argument and then we are using the delete_one() method and passing the id as an argument inside this method to delete the user. And after deletion we are returning the simple json response back to the client that the user is deleted. And also returning the status code of success which is 200.
Now if you make the delete request to the route /delete/<id> inside the postman and passing the id of the user that you want the information you will get the below json response
Updating Specific User Information Using ID From MongoDB Database
Now we will be writing the simple PUT route where if you go we will be updating a specific user using it’s id which is present inside the mongodb database as shown below
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
@app.route('/update/<id>',methods=['PUT']) def update_user(id): _id = id _json = request.json _name = _json['name'] _email = _json['email'] _password = _json['password'] if _name and _email and _password and _id and request.method == "PUT": _hashed_password = generate_password_hash(_password) mongo.db.user.update_one({'_id':ObjectId(_id['$oid']) if '$oid' in _id else ObjectId(_id)},{'$set':{'name':_name,'email':_email,'password:':_hashed_password}}) resp = jsonify("User updated successfully") resp.status_code = 200 return resp else: return not_found() |
As you can see we have written the route which is /update/<id>and for this we have defined the method which is called update_user(id) and inside this method we are updating the user using it’s id passed in the method as an argument. We are getting the id in the request as an argument and then we are using the update_one() method and passing the id as an argument inside this method to update the user. And after updation we are returning the simple json response back to the client that the user is updated. And also returning the status code of success which is 200.
Now if you make the update request to the route /update/<id> inside the postman and passing the id of the user that you want the information you will get the below json response
Wrapping the blog post this is the full source code of the app.py file as shown below
app.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
from flask import Flask from flask_pymongo import PyMongo from bson.json_util import dumps from bson.objectid import ObjectId from flask import jsonify,request from werkzeug.security import generate_password_hash,check_password_hash app = Flask(__name__) app.secret_key = "secretkey" app.config['MONGO_URI'] = "mongodb://localhost:27017/crud" mongo = PyMongo(app) @app.route('/add',methods=['POST']) def add_user(): _json = request.json _name = _json['name'] _email = _json['email'] _password = _json['password'] if _name and _email and _password and request.method == "POST": _hashed_password = generate_password_hash(_password) id = mongo.db.user.insert({'name':_name,'email':_email,'password':_hashed_password}) resp = jsonify("User Added successfully") resp.status_code = 200 return resp else: return not_found() @app.route('/update/<id>',methods=['PUT']) def update_user(id): _id = id _json = request.json _name = _json['name'] _email = _json['email'] _password = _json['password'] if _name and _email and _password and _id and request.method == "PUT": _hashed_password = generate_password_hash(_password) mongo.db.user.update_one({'_id':ObjectId(_id['$oid']) if '$oid' in _id else ObjectId(_id)},{'$set':{'name':_name,'email':_email,'password:':_hashed_password}}) resp = jsonify("User updated successfully") resp.status_code = 200 return resp else: return not_found() @app.errorhandler(404) def not_found(error=None): message = { 'status':404, 'message':'Not Found' + request.url } resp = jsonify(message) resp.status_code = 404 return resp @app.route('/users') def users(): users = mongo.db.user.find() resp = dumps(users) return resp @app.route('/users/<id>') def user(id): user = mongo.db.user.find_one({'_id':ObjectId(id)}) resp = dumps(user) return resp @app.route('/delete/<id>',methods=['DELETE']) def delete_user(id): mongo.db.user.delete_one({'id':ObjectId(id)}) resp = jsonify("User deleted successfully") resp.status_code = 200 return resp if __name__ == "__main__": app.run(debug=True) |
