DEV Community: Himanshu👓💻

My 100DaysOfCode Journal Day — 05

Himanshu👓💻 — Tue, 05 Nov 2019 17:21:16 +0000

Hey Folks 👋🏻!!

I am back!! again haha!

So today, we’ll code together the CRUD of Post/Articles that we did together in this blog. So, as usual, we’ll open our backend/app.py file and post our make our code look like this:

    '''Flask App For PyGuy WebSite'''



from flask import (Flask, jsonify, render_template,

request, session, make_response, abort, Response)

from flask_jwt_extended import (

JWTManager, jwt_required, create_access_token,

get_jwt_identity

)

from flask_pymongo import PyMongo

from flask_bcrypt import Bcrypt

from bson.objectid import ObjectId

from http import HTTPStatus




# App Definitions & Configs

app = Flask(__name__, root_path='../frontend')

bcrypt = Bcrypt(app)

jwt = JWTManager(app)

app.config["MONGO_DBNAME"] =  'pysite'

app.config["MONGO_URI"] =  "mongodb://localhost:27017/pysite"

app.secret_key =  'dawudawudbawbfawbfawc3241241j1jnjkjkn141nj4'

app.config['JWT_SECRET_KEY'] =  "dawudawudbawbfawbfawc3241241j1jnjkjkn141nj4"

mongo = PyMongo(app)



# This will be the index route ....




@app.route("/api")

def  index():

return render_template("index.html")




@app.route('/api/v1/posts', methods=['GET'])

def  articles():

articles = mongo.db.articles



output = []



for q in articles.find():

output.append(

{'title': q['title'], 'description': q['description'], 'tags': q['tags']})

return make_response({'code': 200, 'result': output})




@app.route("/api/v1/add_articles", methods=["POST"])

def  add_articles():

"""

add_articles [Adds new article]



[Saves it to databases, with tags, description etc...]



:return: [description]

:rtype: [type]

"""

article = mongo.db.articles

title = request.json['title']

description = request.json['description']

tags = request.json['tags']

article_id = article.insert(

{'title': title, 'description': description, 'tags': tags})



new_article = article.find_one({'_id': article_id})

output = {'title': new_article['title'],

'description': new_article['description'], 'tags': new_article['tags']}

return make_response({'code': 201, 'result': output})




@app.route("/api/v1/edit_article/<article_id>", methods=["GET", "POST"])

def  edit_article(article_id):

article = mongo.db.articles

title = request.json['title']

description = request.json['description']

tags = request.json['tags']

for art in article.find({"_id": ObjectId(article_id)}):

if art['_id'] == ObjectId(article_id):



updated_data = {

'title': title,

'description': description,

'tags': tags

}



existing_data = {"title": art['title'],

"description": art['description'], "tags": art['tags']}



if updated_data != existing_data:

update_article = article.update(

{"_id": art['_id']},

{"$set": updated_data}, upsert=False)

return make_response({'code': 200, "Message": update_article})

else:

return make_response({'code': 404, 'Message': 'No Code Updated'})



return make_response({'code': 404, "Message": "Article Not Found"})




@app.route("/api/v1/delete/<article_id>", methods=["DELETE"])

def  delete(article_id):

article = mongo.db.articles

for art in article.find({"_id": ObjectId(article_id)}):

if art['_id'] == ObjectId(article_id):

article.remove(

{"_id": art['_id']})

return make_response({'code': 200, "Message": "Article Deleted Successfully"})




def  new_user_creation():

"""[User Creation]

Params: Username

Params: Password

Uses: Bcrypt to generate Password

Uses: Users Table

"""

user = mongo.db.users

gen_hashpass = bcrypt.generate_password_hash(request.json['password'])

user.insert(

{'username': request.json['username'], 'password': gen_hashpass})

session['username'] = request.json['username']




@app.route("/api/v1/login", methods=['POST', 'GET'])

def  login():

"""[Logins The User]



Returns:

[Access Token] -- [Returns access token, with code 200]

[!Access Token] -- [Returns code 404]

"""

user = mongo.db.users

username = request.json['username']

password = request.json['password']



for user_details in user.find():

if user_details['username'] == username and bcrypt.check_password_hash(user_details['password'], password):

access_token = create_access_token(identity=username)

return make_response({'code': 200, 'access_token': access_token, "Message": "Ok"})

return make_response({'code': 404, 'Message': "User Not Found, would you like to create one?"})




@app.route("/protected", methods=["GET"])

@jwt_required

def  protected():

"""

protected [JWT]



[extended_summary]



Returns:

[Success] -- [Return Current User If Login Is Successful]

"""

current_user = get_jwt_identity()

return make_response({'code': 200, "logged_in_as": current_user})




@app.route("/api/v1/register", methods=['POST', 'GET'])

def  create_user():

"""

create_user [Route call to create a user]



[Uses the new_user_creation method]



:return: [201, successfully created + Username]

:rtype: [In case of failure, returns, 403]

"""

user = mongo.db.users



# Users table definition for MongoDB

if request.method ==  'POST':

user_exists = user.find_one({'username': request.json['username']})



if user_exists is  None:

new_user_creation()

return make_response({'code': 201, "Message": "User {} has been created successfully".format(session['username'])})

return make_response({'code': 403, "Message": 'Already Exists'})


if __name__ ==  "__main__":

app.run(debug=True)

Now, let’s walk through code as we alwaaaaaays do 😁.

First, we’ll do some facelifting(dunno how i got to use word every now and then)

we will introduce, docstring because we’ll be introducing swagger later for documentation. so we did something like:

"""

add_articles [Adds new article]

[Saves it to databases, with tags, description etc...]

:return: [description]

:rtype: [type]

"""

EDIT POST

Now, We’ll now make our Edit/Update route in our CRUD. Let’s do that now…

@app.route(“/api/v1/edit_article/<article_id>”, _methods_=[“GET”, “POST”])

_def_ edit_article(_article_id_):

article = mongo.db.articles

title = request.json[‘title’]

description = request.json[‘description’]

tags = request.json[‘tags’]

The code above is pretty much same in every article route. So we don’t can simply skip that and go to next part ….

So, in the code below I will loop through articles using art keyword(not much good keyword usage by me 😒) and look for the ID we’ll pass as parameter in

@app.route(“/api/v1/edit_article/<article_id>”, _methods_=[“GET”, “POST”])

notice, article_id passed as param here, we will use it next.

Than we’ll compare if article_id that we’re passing does matches with the article id in collection. If yes, we’ll define the dictionary of update_data which will be the data that we’ll hold the data that we’ll be updating.

for art in article.find({“_id”: ObjectId(article_id)}):

if art[‘_id’] == ObjectId(article_id):

updated_data = {

‘title’: title,

‘description’: description,

‘tags’: tags

}

Now, next we will define our existing dictionary, which means the data we currently have saved in our db..

existing_data = {"title": art['title'],

"description": art['description'], "tags": art['tags']}

Okay, next step is we’ll check if our data that we’re passing as data to be updated is equal to or not equal to our existing data. If data is not same as our existing data it will get updated, with upsert set to False (will explain what upsert is).

if updated_data != existing_data:

update_article = article.update(

{"_id": art['_id']},

{"$set": updated_data}, _upsert_=False)

return make_response({'code': 200, "Message": update_article})

else:

return make_response({'code': 404, 'Message': 'No Code Updated'})

We can check the same in our database, let me show you to confirm that’s working.

This is the data I am seeing when I am browsing my collection

{  
 "title": "Hi this is the blacksheep post",  
 "description": "This ïś the aæaãaæaãaæaãaæaãaæaãaæaã",  
 "tags": "hi, testing, zero post"  
}

To check if data is getting updated.

we will send new request data set like this.

{  
 "title": "Hi this is the this is awesome post",  
 "description": "This ïś the awesome post",  
 "tags": "hi, testing, awesome post"  
}

Do a request for update article like this from our edit_article path, your article ID would be different case in my case it’s 5dbb07a99b5d9fc1d7127fa8

So this shall get updated right? let’s see in our DB if that’s updated

YAY!! our data got updated 🙌🏻.

Delete Post

So next stop.. DELETE. To this we will use “DELETE” method. Let’s check the code to delete. The code below uses delete method with article_id as parameter.

@app.route("/api/v1/delete/<article_id>", _methods_=["DELETE"])

def delete(_article_id_):

article = mongo.db.articles

for art in article.find({"_id": ObjectId(article_id)}):

if art['_id'] == ObjectId(article_id):

article.remove(

{"_id": art['_id']})

return make_response({'code': 200, "Message": "Article Deleted Successfully"})

so we’ll again use a loop with .find method looking for id key which have article_id as value. P.S ObjectID is method imported from bson.ObjectID to actually convert parameter id as mongo compatible and do a comparison.

We than did an if/else block to do the comparison and than called .remove method to remove the respective post with that article.

Let’s see how we did that delete call in postman, pass the relative article id

When you hit send it will delete the related post. You can check the collection to see if the post actually go deleted.

Awesome!!! we deleted our post….

That’s it folks.. We’ve successfull done the CRUD implementation on our Posts.

My 100DaysOfCode Journal — Day03/04

Himanshu👓💻 — Sun, 03 Nov 2019 18:11:39 +0000

Hey folks!

So it’s day 03 and day 04 of my 100daysofcode journal.

Here is a list of what we’ll be covering today:

Features listing
Login Implementation🤩
JWT integration.

Features listing

Here is the list of features we’ll be introducing for our application.

Authentication: JWT

SMS: #twilio by @twilio

Email:@Mailchimp

Project Management: #Trello by @trello

Comments: custom

Payments: stripe by @stripe

Login Implementation

So continuing with our code last time, we’ll be implementing login credentials as below. You might see that I have given some facelift, i will be explaining at some point.

@app.route("/api/v1/login", _methods_=['POST', 'GET'])

def login():
user = mongo.db.users
username = request.json['username']
password = request.json['password']
for user_details in user.find():
if user_details['username'] == username and bcrypt.check_password_hash(user_details['password'], password):
access_token = create_access_token(_identity_=username)
return make_response({'code': 200, 'access_token': access_token, "Message": "Ok"})
return make_response({'code': 404, 'Message': "User Not Found, would you like to create one?"})

The code is at followng URL :

https://github.com/aidataguy/pyguy/tree/Part3

So let me walk you through the code. Here, we will be defining our route for login. I have made URL’s a bit unique by making it something like:

/api/v1/login

Below I’ve defined the login url with GET and POST both. I

@app.route("/api/v1/login", _methods_=['POST', 'GET'])

So, next we’ll define the user table object and username which we’ll be getting from request(Postman)

def login():

user = mongo.db.users

username = request.json['username']

password = request.json['password']

Next, we’ll loop through existing users in table to find if the user exists. Also, before doing that, we’ll install following packages

flask_bcrypt & flask by running following command

pip install flask-jwt-extended flask-bcrypt

Then we would need to add definition at top of the our backend/app.py

from flask_pymongo import PyMongo

from flask_bcrypt import Bcrypt

Now that we have that sorted, we’ll loop through the user detail in users table. We are checking if the username and password do exists in the database. We’re using .check_password_hash method of bcrypt. You can check out the bcrypt the here

for user_details in user.find():  
if user_details[‘username’] == username and bcrypt.check_password_hash(user_details[‘password’], password):  
access_token = create_access_token(_identity_=username)  
return make_response({‘code’: 200, ‘access_token’: access_token, “Message”: “Ok”})  
return make_response({‘code’: 404, ‘Message’: “User Not Found, would you like to create one?”})

Awesome!! we have the login implemented. But before we could actually check this, we have to do changes to our register method. So here are changes I have implemented. I have implemented a new_user_creation method which we can be used anywhere in app.

def new_user_creation():
user = mongo.db.users
gen_hashpass = bcrypt.generate_password_hash(request.json['password'])
user.insert(
{'username': request.json['username'], 'password': gen_hashpass})
session['username'] = request.json['username']

The bcrypt’s generate_password_hash method actually helps in generating hash passwords and than with help of our check_hash_password method we can do comparison later on in Login method

JWT integration

We’ll introduce JWT extended in our application like so. Update the import and app configs to something like this in app. py . Also, we’ve introduced JWT_SECRET_KEY & app_secret key which will be used JWT. Additionally, we used JWTManager(app) so JWTManager can be used across the app.

'''Flask App For PyGuy WebSite'''
from flask import (Flask, jsonify, render_template,
request, session, make_response)
from flask_jwt_extended import (
JWTManager, jwt_required, create_access_token,
)
from flask_pymongo import PyMongo
from flask_bcrypt import Bcrypt

App Definitions & Configs

app = Flask(__name__, _root_path_='../frontend')
bcrypt = Bcrypt(app)
jwt = JWTManager(app)
app.config["MONGO_DBNAME"] = 'pysite'
app.config["MONGO_URI"] = "mongodb://localhost:27017/pysite"
app.secret_key = 'dawudawudbawbfawbfawc3241241j1jnjkjkn141nj4'

app.config['JWT_SECRET_KEY'] = "dawudawudbawbfawbfawc3241241j1jnjkjkn141nj4"

mongo = PyMongo(app)

You can read more about JWT-Extended here.

Every aspect of JWT based authentication is based on access tokens. So what we would be needing here is implement an protected method that would do all the heavy lifting in terms of providing and validating access_token. So let’s walk through the current code below.

@app.route(“/protected”, _methods_=[“GET”])  
@jwt_required  
_def_ protected():  
current_user = get_jwt_identity()  
return make_response({‘code’: 200, “logged_in_as”: current_user})

We are defining a GET method for protected route, which would use jwt_required method, and next we defined the method. Current user is set to get_jwt_identity, which will get the identity of the user. If it’s true, we’ll send a response.

Now in order to get the access token we have to make changes to our login method. So after looping through the users, we will create access token by setting the identity as username, because username is the entity that we would like access token to be generated for. If all is successful, we will make a response sending access token and 200 code.

@app.route("/api/v1/login", _methods_=['POST', 'GET'])

def login():
user = mongo.db.users
username = request.json['username']
password = request.json['password']
for user_details in user.find():

**if user_details['username'] == username and bcrypt.check_password_hash(user_details['password'], password):**

**access_token = create_access_token(_identity_=username)**

**return make_response({'code': 200, 'access_token': access_token, "Message": "Ok"})**

return make_response({'code': 404, 'Message': "User Not Found, would you like to create one?"})

Voila!! we’ve created access token and authenticated our user too 😎

POSTMAN TIME!!

Now, we shall test our JWT implementation. You can open postman and first do a register call to register a new user with that will use our bcrypt implementation once user is created, for login request url add localhost:5000/api/v1/login then in Body -> raw (select JSON from dropdown) and paste your registered user context like so :

{  
 "username": "admin",  
 "password": "b lalala Password"  
}

Refer to the below image in case you aren’t sure.

That’s all folks!! we’ve successfully implemented JWT & Bcrypt.

My 100daysOfCode Journal — Day 02

Himanshu👓💻 — Fri, 01 Nov 2019 19:05:29 +0000

Hey folks!

So it’s day 02 of my 100daysofcode journal. Today, we’ll do first POST call for flask api.

Here is a list of what we’ll be covering today:

Setup ROBO 3T
Writing POST Call 🤩
Using our letterbox aka POSTMAN :)

Setup ROBO 3T

We’re going to setup ROBO 3T on mac, so in order to install that you need to go to https://robomongo.org/download

Once you’ve installed ROBO 3T, open the application and than follow the steps to add a new MongoDB connection. P.S for tutorial purposes, I haven’t actually used any DB authentication, will do so later down the line .

So as soon as you open your ROBO 3T app , you will be greeted with something like this:

Now we’re going to connect do the connection. Click on the small computer like icon on top left and fill up the connection details like shown(name it whatever you want) and than hit saveeeeee!!!

Okay , now that we have our connection in place. We will go back to our window and select the connection and click on connect button

On next window that opens we will create our very first database first here. Select the connection name and right click on connection name and click on create database option on the menu presented like shown below.

As soon as you click on “Create database” option you will see a window to post Database Name and than you need to enter name and hit create.

Now we have our database created. If you all goes right there shall be the db in left pane like shown in figure above.

Writing POST Call

We are going to write our very first POST call, excited?? Let’s do it!

So continuing with our app.py as we’ve done in my last post*.* If you don’t know what we’re talking about here, you can go through my post here.

Open the very same file and paste the code right after our very first GET call before the main declaration like this.

@app.route(“/add_articles”, _methods_=[“POST”])
def_ add_articles():
    article = mongo.db.articles
    title = request.json[‘title’]
    description = request.json[‘description’]
    tags = request.json[‘tags’]
    article_id = article.insert(
     {‘title’: title, ‘description’: description, ‘tags’: tags})
    new_article = article.find_one({‘_id’: article_id})
    output = {‘title’: new_article[‘title’],
    ‘description’: new_article[‘description’], ‘tags’: new_article[‘tags’]}

    return jsonify({‘result’: output})

Don’t worry, I will explain the code as I always do 😁.

Okay so as you know our articles had following fields, title, description, tags. So accordingly we want to post our data in same manner right?

So first thing first,

@app.route(“/add_articles”, _methods_=[“POST”])

The code above is definition of POST route which is using route add_articles, so something like this will be our url “http://localhost:5000/add_articles”

Next step is to add definition that will define how our add article will work. We will define each our our variables like request.json[‘title’], what this means? whatever we’ll be sending in title will be a json value. We’ll do same for our rest of the values that we want to insert.

def_ add_articles():
    article = mongo.db.articles
    title = request.json[‘title’]
    description = request.json[‘description’]
    tags = request.json[‘tags’]

Now next step is to insert the values into database. Alright! let’s do it.

So for this we will be using article.insert ( as it will be one single article at a time). The article_id variable is very important keep an eye on it !!

article_id = article.insert(
{‘title’: title, ‘description’: description, ‘tags’: tags})

So what we did here is inserting key:value pair while inserting them.

One more thing is that we’ve have to set a new_article variable and new_article = article.find_one({‘_id’: article_id}) will set the same along with article_id as _id. So every new article that we post, will have a new unique ID thanks to the new_article we’ve set here.

new_article = article.find_one({‘_id’: article_id})

Okay now we will set an output variable which will output our new post values. and we’ve set a result key which will return json for us with the ID 😁

output = {‘title’: new_article[‘title’],
‘description’: new_article[‘description’], ‘tags’: new_article[‘tags’]}
return jsonify({‘result’: output})

Using our letterbox aka POSTMAN

Okay, you must be saying… dude how on earth are we going to test this 😆

Let’s post it using letterbox.. aka Postman :)

Okay first thing first what is postman?? As per Postman official website:

Postman is a collaboration platform for API development. Postman’s features simplify each step of building an API and streamline collaboration so you can create better APIs — faster.

Now, you need download and install the postman at your end and open the postman app. You will see a window like this

On this window, we will put our URL in request tab, put “localhost:5000/add_articles” and choose POST from drop down. Than click on “Body” option below and than what you need to do is , select raw option under Body and paste your json like this:

   {  
     “title”: “Hi this is the zero post”,  
     “description”: “This is the zero description”,  
     “tags”: “hi, testing, zero post”  
    }

Once you have everything set like that, hit send. You shall see a response below something like this:

Wooohooo!!! we have made the post call tooo 😎

That’s all folks!! If you have any questions let me know!!

My 100daysOfCode Journal — Day 01

Himanshu👓💻 — Thu, 31 Oct 2019 18:18:43 +0000

Hey folks!

So it’s day 01 of my 100daysofcode journal. Today, we’ll do setup and first GET call for flask api.

Here is a list of what we’ll be covering today:

Environment Setup
Project Setup
Making first API call 🤩

Environment Setup:

So I am using a Mac machine, so for my environment setup I have to install following software:

Python3
MongoDB
Pipenv
Flask

let’s go one by one over the dependencies and software

Python 3:

In order to install python3 on a Mac you need to install Homebrew first. You can go to following link to install homebrew and simply follow the instructions.

Once you have hombrew install simply run following command

brew install python3

If everything goes well, you shall be able to run following command on Iterm or Terminal and get output in return as shown below, run

python – –version

Python Version

MongoDB

Now that we have Python3 installed on machine, we need to install MongoDB on mac machine. We will be using brew for this purpose also. So open the terminal again and run following set of commands.

brew tap mongodb/brew

This will add mongodb formula. Done? let’s install the MongoDB community edition. To do so, we will run next command

brew install mongodb-community@4.2

This shall install mongo on your system. To double check run

mongod --version

You will get following output

pyguy@Himanshus-MacBook-Pro ~ % mongod — version

db version v4.2.1

Now, we need to make sure that mongodb is running as a service in the background. so we will execute

brew services start mongodb-community@4.2

So we’re all set with MongoDB , it’s running in the backend, silently 🤫.

We’ll move come back to mongoDB later at some point. Let’s move on to next step.

Project Setup

Pipenv, Flask & flask_pymong

Now, In order to install pipenv & flask, we have to first create a code directory, so create one with any name using UI or command line. I mostly prefer command line so yeah…

mkdir pyguy

Once that’s created cd into the directory and let’s install pipenv using pip3 which is already installed when we install python3 using brew. Ok, so now run

pip3 install pipenv

Okay now that pipenv environment is setup in the code directory a Pipfile will be created.

Let’s activate this 😁. you need to run

pipenv shell

You will see something like this once it’s activated.

Pipenv is activated

See that (pyguy), in front of our terminal window? That means environment is ACTIVE!!

All good, now we will install our dependencies. Now that our pipenv is active, we will install flask and pymongo. To do so we will run

pip3 install flask_pymongo flask

Alright, we have our dependencies installed so all we need to do right now is do directory setup.

Directory Setup

We will segregate our backend and frontend for our project. As we will be having a separate front end that will be React. So this is how our directory structure will be like.

Directory structure

You can ignore the Pipfile.lock , PyGuy.code-workspace files. Pipfile.lock will auto-generate and the other one is generated by my vscode, because I have saved it as workspace.

Making first API call 🤩

Now that we’ve everything setup, let’s buckle up and make our API call.

Go into backend directory and then create app.py file. The app.py file will be our very base file. Open the file in your favourite editor and paste following code. I will explain the code one by one.

'''Flask App For PyGuy WebSite'''  

from flask import Flask, jsonify  
from flask_pymongo import PyMongo  

#App Definitions & Configs  
app = Flask(__name__)  
app.config["MONGO_DBNAME"] = 'pysite'  
app.config["MONGO_URI"] = "mongodb://localhost:27017/pysite"  
mongo = PyMongo(app)  

#This will be the index route ....  


"""  
Defining all API routes.   
"""  


@app.route("/", methods=['GET'])  
def index():  
    return "<h1> Hi I am Himanshu :)</h1>"  



    @app.route('/posts', methods=['GET'])  
    def articles():  
        articles = mongo.db.articles  

        output = []  

        for q in articles.find():  
            output.append(  
                {'title': q['title'], 'description': q['description'], 'tags': q['tag']})  
        return jsonify({'result': output})  


    if __name__ == "__main__":  
        app.run(debug=True)

Let’s go through the code….

'''Flask App For PyGuy WebSite'''

This is our app definition.

Than let’s import flask and jsonify to convert things to json. Also, import PyMongo in order to connect to our MongoDB.

from flask import Flask, jsonify  
from flask_pymongo import PyMongo

Next, we are defining App definitions & configs. The very first line is where we set our current class. Here, we’ve set Flask as our name.

app = Flask(__name__)

Now, we’ll set our app configs to set, dbname, mongo db uri and then define the MongoDb connected using PyMongo passing app as parameter.

app.config["MONGO_DBNAME"] = 'pysite'  
app.config["MONGO_URI"] = "mongodb://localhost:27017/pysite"  
mongo = PyMongo(app)

Okay, next we will make our index call. Here is how we define index route with GET method and returning a H1 text when you browse to index of api.

@app.route("/", methods=['GET'])  
def index():  
    return "<h1> Hi I am Himanshu :)</h1>"

Okay, so in order to list our posts, we will create our routes as follows. First, we define the url we will be using to go to particular api route. In our case its /posts. Next, we will write definition which will tell us what to do. We want to list all the posts so in that case we will query through our collection. By setting article variable with mongo.db.articles value. Here, mongo is coming from our definition above, we use .db.articles to access the articles collection that’s in our mongoDB.

@app.route('/posts', methods=['GET'])  
def articles():  
    articles = mongo.db.articles

In the code below, we have initialized a blank array, output. Once we’ve collection accessed, we will do a for loop to query through the articles defined above. We will append each q key value in our output and will return jsonified output in result key.

output = []  

    for q in articles.find():  
        output.append(  
            {'title': q['title'], 'description': q['description'], 'tags': q['tag']})  
    return jsonify({'result': output})

This very last line will run the named program which is app as our main application. app.run statement with debug=True will run our application in debug mode.

if __name__ == "__main__":  
    app.run(debug=True)

Now to run our flask application open terminal(activate pipenv if not already) and navigate to our “backend” folder and issue flask run command. This will give a similar output in terminal like below.

(pyguy) pyguy@Himanshus-MacBook-Pro backend % flask run  
Environment: production  
WARNING: This is a development server. Do not use it in a production deployment.  
Use a production WSGI server instead.  
Debug mode: off  
Running on [http://127.0.0.1:5000/](http://127.0.0.1:5000/) (Press CTRL+C to quit)

If you want to see if your api calls are working, go to http://localhost:5000/, you shall see something like this on index page

Hi I am Himanshu :)

This tutorial doesn’t covers creating collections on MongoDB, which I will cover in 2nd part of same. That’s all for today, if you have comments, feel free to comment.

My 100daysOfCode Journal - Introduction….

Himanshu👓💻 — Thu, 31 Oct 2019 09:40:22 +0000

Before I start my 100DaysOfCode Journal, it's time for a little bit of introduction.

About me…

I am Himanshu Patel, I am self taught developer from India. To add.. I have a degree in Bachelor Of Commerce, but my love for computers motivated me to try learning web development and sorts. In my earlier years of college, I didn't had internet at home. So I preferred learning from books.. since than these books became my best friends.

First language or shall i say thing that i learned was C & C++, to my taste it was booooooring(I was not finding it interesting, duh)and not my cup of tea. So I started learning some PHP, my first project was total s**t, but that gave me an idea. So i starting making some mooore PHP projects. While I was learning PHP, I came to know about Python and well.. dropped PHP as i came to know how awesome Python is. In early days of python I was learning how to make programs work. Well my first program was simple application that I used to read PDF and text file. That got me more interested in Python.

My First Job.. I mean an internship and so on....
My very first job was that of an intern, I was asked to work on PHP. I wanted to get into the tech so I accepted it. Learned a few things here and there while learning more and more python. I was in it for almost an year while trying to finish my college. I took RHCE certification at around same time of my last year in college (2019) and made it to top 5 of my class.

In Year 2009, I passed out from my college and looked for my a job in IT. It was difficult for me to get something, but got one as a systems administrator. I learned so much about networking, systems, technology and what not. It was a good exposure for me.
Eventually, after working my butt off for almost 4 years, I left that job too. I got my very first job as a developer at CodeKrieg. It was a Ruby on Rails developer job. That was the point when i was actually happy and was enjoying the work I am doing. I built so many robust systems and applications that helped our clients. Down the line, I climbed up to position as a Lead Developer at the same company. My work was appreciated by people I was working with.

Over the course of time, the company did grew. But due to some financial crunches, everything went down and they ran out of business in 2015. It was a sad day for me, but hey! that's not the end of it. While i was not having a job, I started working as freelancer and got some gigs, that got the ball rolling.
In August of 2016 I landed another job as a Associate Infrastructure Analyst, where I was suppose to work with servers, and help developers with different issue they might face on infrastructure side. This was a good job but short lived. Well, again… i left that too.

For an year, I was doing more than 2 jobs as a freelancer and learning and coding using python. Finally, i landed the job as Technical Team Lead and working on Python now. I have developed a number of products in 1 year span and successfully delivered them too.

I love the idea of continuity of learning in Tech, this keeps me running. In the past years, I have worked on number of languages. I worked with C C++, Python, Laravel, Haskell Language.

Why 100daysofcode…..???
Because, I love challenges!!. Well that and the fact that I have a few projects that I wanted to finish, but was not able to as I was too lazy to take time for my own learning. For past year, I was trying to finish my website/portfolio/blog you can call it anything but due to my engagements at work, I was not able to do that at all. I was more or less feeling awkward about not getting started and finishing them off… 100DaysOfCode was one of the best reason for me to challenge my self up(or end up in putting myself to shame over the internet for not finishing it lol :D)

What I will be covering in 100DaysOfCode

Flask
React
Mongo
Self Driven cars
A.I

I will try to record all my 100daysofcode each day here.
If you would like to know more about me you can connect me over

Twitter