When we are developing real-world projects, file management is one of the crucial parts of a project. For projects like online shopping where image files grow rapidly over time, it becomes too complex and overhead if it is stored in the same server with the project. Because files are usually large in size and can occupy most of the server space.
Also, it is good practise to manage files and project codes on different servers. There are plenty of services that provide cloud storage for files and assets. AWS S3 and Cloudinary are one of the leading services out there.&nbsp;
In this tutorial, we are going to use Cloudinary service, since it's free and does not require a credit card for basic use.
So before we begin, make sure you have created an account in cloudinary and get your API keys. Follow the link below to create an account.
<a href="https://cloudinary.com/" target="_blank" rel="noopener">https://cloudinary.com/</a>
After creating an account get the following details from cloudinary dashboard.
<ol>
<li>API key</li>
<li>API secret</li>
<li>Cloud name</li>
</ol>
I am assuming, you are implementing cloudinary API in node js project. So, I am not setting up complete node js app here to make this tutorial short and simple. If you need to set up basic node app you can find a basic boilerplate at the link given below.
<a href="https://github.com/thebinod7/devcolumn/tree/basic-setup" target="_blank" rel="noopener">https://github.com/thebinod7/devcolumn/tree/basic-setup</a>
So, we are going to create a function that will take an image file path as input and upload that image to cloudinary server. Before we write our function, install <code>npm packages</code>&nbsp;
<pre class="language-javascript"><code>npm install cloudinary --save

npm install body-parser --save

// body-parser is used to parse form data in express js</code></pre>
Now, let's create our upload function.
<pre class="language-javascript"><code>const cloudinary = require("cloudinary").v2;
const fs = require("fs");

cloudinary.config({
 cloud_name: YOUR_CLOUD_NAME,
 api_key: YOUR_API_KEY,
 api_secret: YOUR_API_SECRET
});

const uploadToCloud = filePath =&gt; {
 return new Promise((resolve, reject) =&gt; {
 cloudinary.uploader
 .upload(filePath)
 .then(result =&gt; {
 fs.unlinkSync(filePath); 
 // Remove uploaded file from our server once it gets uploaded to cloudinary server.
 resolve(result);
 })
 .catch(error =&gt; {
 reject(error);
 });
 });
};</code></pre>
Explanation:&nbsp;
<ul>
<li>First of all, we imported cloudinary and set config variables.</li>
<li>Then created a javascript promise function that takes an input argument i.e. the absolute path of the image to be uploaded.</li>
<li>If the image is uploaded, <code>resolve</code>&nbsp;block will be executed, otherwise <code>reject</code> block will be executed.</li>
<li>We can call this function where-ever we want, we just need to pass the absolute path of an image to be uploaded.</li>
</ul>
To get an absolute path of an image uploaded from the frontend, we can use <code>multer npm package</code> as follows:
<pre class="language-javascript"><code>const multer = require("multer");
const path = require("path");

const upload = multer({
 storage: multer.diskStorage({
 destination: "./public/uploads/", // path to directory inside a project
 filename: function(req, file, cb) {
 cb(
 null,
 "myfile-" + Date.now() + path.parse(file.originalname).ext
 );
 }
 })
});

router.post("/upload-image", upload.single("imageFile"), (req, res, next) =&gt; {
 uploadToCloud(req.file.path)
 .then(d =&gt; res.json(d))
 .catch(e =&gt; next(e));
});
</code></pre>
So that's all. you can now call <code>/upload-image</code> API with the field name <code>imageFile</code> using postman or your frontend service.&nbsp;
Note: Make sure your node app is well set up to handle routes requests and form data with your node framework. eg: Express JS
I have already provided a basic node express app boilerplate link before in this article. And that brings us to an end. Besides image uploading, there are many other features like image cropping and resizing in cloudinary service. You can play around and make the best out of it.&nbsp;
Also, its a good practise to upload images of small size so that upload/download becomes faster. You can use tools like: <a href="https://www.imagemin.com/" target="_blank" rel="noopener">ImageMin</a> &nbsp;to reduce file size.

Learn how to  setup cloudinary service and upload image using node js

Image upload to free cloud using cloudinary service and node js

Binod Chaudhary

facebook

instagram

linkedin

JSON web token(JWT)&nbsp; is basically a digitally signed string, in which some data is encoded and can be transmitted over the network.
Let's make it simpler.
You can think of it as a piece of paper with an authorized signature. Let us assume the paper is signed by education ministry (government) so that you can get admission to any government school or college.
If you haven't worked on it before, JWT token looks like this:
<pre class="language-javascript"><code>eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.dyt0CoTl4WoVjAHI9Q_CwSKhl6d_9rhM3NrXuJttkao</code></pre>
If you look at it closely, you can find two dots(.) dividing it into three sections. These three individual sections have different values.
1. Header:
The first part of the token is a header which is base64Url. It holds the meta-information of a token which can be used by a receiver in order to validate the token.&nbsp;
If we decode only the first portion of a header, it will provide the JSON object as follows.
<pre class="language-javascript"><code>{
 "alg": "HS256",
 "typ": "JWT"
}</code></pre>
We can see, this is just a plain object, and the signature algorithm is "HS256" for this particular token.
2. Payload:
The payload, also knows as the claim is information about an entity like user info. Furthermore, it also includes metadata of that particular payload as follows:
<ul>
<li><code>iat</code> - Timestamp of the issued date.</li>
<li><code>sub</code> - Technical identifier of the user.</li>
<li><code>exp</code> - JWT expiration time.</li>
<li><code>iss</code> - The issuer of the token.</li>
</ul>
Upon decoding a payload only i.e. middle part of a token, we get the entity information (eg: user entity) as follows:
<pre class="language-javascript"><code>{
 "sub": "1234567890",
 "firstname": "John",
 "lastname": "Doe",
 "admin": true,
 "iat": 1516239022
}</code></pre>
And these are the claims we are going to send to servers that maybe our own server or any third-party server that supports JWT.
3. Signature:
The final token is generated by applying JWS (JSON Web Specification). The final part of JWT is generated by combining encoded JWT header, encoded JWT payload, and signing algorithms like HMAC SHA-256.
Since we know the basics of JWT now, let's create a token. I am using node js for this tutorial.
<pre class="language-markup"><code>const jwt = require("jsonwebtoken");

const secrete_key = 'your_secret_key'

const user = { _id : 1234, firstname: "John", lastname: "Doe" }

const _token = jwt.sign(user.toJSON(), secret_key, {
 expiresIn: 60 * 60 * 24, // 24 hours
});</code></pre>
What we did above:
<ul>
<li>Imported <code>jsonwebtoken</code> as jwt from the npm package.</li>
<li>Defined a secret key to sign token. Remember that, the same key is used to decode token so don't make it public.</li>
<li>Set user details, it can be logged in user information in case of real applications.</li>
<li>Signed a token with <code>jwt.sign()</code> method with payload, secret key, and expiration time.</li>
</ul>
So far we have created a token, but we need to verify it before we provide any access to server resources using this token. Look at the code below to verify JWT.
<pre class="language-javascript"><code>const jwt = require("jsonwebtoken");
const SECRET_KEY = "same_secret_key_used_to_sign_token";

 jwt.verify(token, SECRET_KEY, function (err, token_data) {
 if (err) throw err;
 console.log("Verified token data:", token_data);
});</code></pre>
Simple as that. Just call a <code>jwt.verify()</code> function with a secret key and you should have your payload data i.e. user data in this case.
Summary:
<ul>
<li>JWT is an authorization token to make sure someone has access to some resource or entity.</li>
<li>It has three basic components; Header, Payload, and Signature.</li>
<li>It can be decrypted if anybody intercepts the token. So don't put private information like credit card details, bank account details, and all in it.</li>
<li>JWT becomes very useful in micro-service architecture where we can do request/response between multiple servers. In traditional systems, logged in user details were stored in session which is valid only in, that one particular server it was created.</li>
<li>It is encoded as base64Url so that it becomes reliable to transfer over different servers. Other string formats may invite issues like, automatically concatenating special characters or symbols.</li>
<li>If expiring time is not specified while signing the token, JWTs never expire.</li>
</ul>
That brings us to an end. I hope it was helpful enough to understand about JWT. Keep learning, keep sharing!

Learn about how json web tokens generated and used.

Easy guide to json web token and its use cases

In this tutorial, I will show you how to dockerize a Django web application with PostgreSQL and PgAdmin for the development environment. Prerequisites To follow this post, you will need the following installed on your machine:
<ol>
<li>
Docker
</li>
<li>
Docker Compose
</li>
</ol>
After installing the above requirements, follow the below steps:
1. Create a new project directory
<pre class="language-markup"><code>mkdir dev_project &amp;&amp; cd dev_project</code></pre>
<pre>2. Create a file called <code>Dockerfile</code> in your project directory. And add the following content to it. </pre>
<pre class="language-markup"><code># pull official base image
FROM python:3

# set default environment variable
ENV PYTHONUNBUFFERED 1
ENV WEB_ROOT=/web_root

# create a root project folder
RUN mkdir ${WEB_ROOT}

# Set default workdir
WORKDIR ${WEB_ROOT}

# Install pip requirements files
COPY requirements.txt ${WEB_ROOT}/

# Install project dependencies
RUN pip install --no-cache-dir -r requirements.txt

# copy everything from currnt directory to workdir
COPY . /${WEB_ROOT}/</code></pre>
<pre>3. Create a new file called <code>requirements.txt</code> and add the following lines: </pre>
<pre class="language-markup"><code>Django==2.2.13
psycopg2-binary&gt;=2.8
</code></pre>
<pre>4. Create a file called <code>docker-compose.yml</code> in your project directory with the following contents. </pre>
<pre class="language-markup"><code>version: "3.7"

services:
 web:
 container_name: dev_project
 build:
 context: .
 dockerfile: ./Dockerfile
 command: python manage.py runserver 0.0.0.0:8000
 volumes:
 - .:/web_root/
 ports:
 - 8000:8000
 environment: 
 - PGUSERNAME=postgres
 - POSTGRES_PASSWORD=postgres
 - PGDBNAME=devcolumn
 - PGHOST=db
 - PGPORT=5432
 - DJANGO_DEBUG=True
 - TZ=PST
 depends_on: 
 - db 

 db:
 container_name: db
 image: postgres:12.0-alpine
 volumes:
 - postgres-data:/var/lib/postgresql/data
 - postgres-log:/var/log/postgresql
 ports:
 - "5432:5432"
 environment:
 - POSTGRES_USER=postgres
 - POSTGRES_PASSWORD=postgres
 - POSTGRES_DB=devcolumn
 - TZ=PST
 
 pgadmin:
 image: dpage/pgadmin4
 container_name: pgadmin
 depends_on: 
 - db
 ports: 
 - "5051:80"
 environment: 
 PGADMIN_DEFAULT_EMAIL: pgadmin@gamil.com
 PGADMIN_DEFAULT_PASSWORD: pgadmin@1234
 restart: always


volumes: 
 postgres-data:
 postgres-log:


</code></pre>
Create a Django Project
Finally, you can create a Django project by running the <code>docker-compose run</code> command from the root of your project directory.
<pre class="language-markup"><code>docker-compose run --rm web django-admin startproject mysite .</code></pre>
<blockquote>
The <code>docker-compose</code> run command is a one-time command which is run against a service. You'll use this command for performing administrative tasks. You can explore more about this command from <a href="https://docs.docker.com/compose/reference/run/" target="_blank" rel="noopener">here.</a>
</blockquote>
<ul>
<li>Running the above command will first create a&nbsp; service called <code>web</code> using the defined configurations, as it is not created yet.</li>
<li>Then the container <code>dev_project</code> will be created using the <code>build</code> keyword defined in the <code>docker-compose.yml</code> file which takes the destination of your <code>Dockerfile</code> as defined in the <code>context</code> parameter.</li>
<li>once the <code>web</code> service is built, compose runs it, and executes the <code>django-admin startproject</code> command. in the container which results in creating a directory called <code>mysite</code> with the following default Django structures.</li>
</ul>
<pre class="language-markup"><code>dev_project
├── docker-compose.yml
├── Dockerfile
├── manage.py
├── mysite
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── requirements.txt
</code></pre>
If you're running Docker on Linux,&nbsp; the files <code>django-admin</code> created are owned by root. This happens because the container run as the root user. Change the ownership of the new files.
<pre class="language-markup"><code>sudo chown -R $USER:$USER .
</code></pre>
Connect the database
Now, you have created a Django project, you need to configure it to use the PostgresSQL database.
1. Open the Django project settings file, <code>settings.py</code> located inside your <code>mysite</code> directory.
2. Towards the end of the file, you'll see <code>DATABASES</code> section. Replace this section with the following content.
<pre class="language-markup"><code>DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.postgresql_psycopg2',
 'NAME': 'devcolumn',
 'USER': 'postgres',
 'PASSWORD': 'postgres',
 'HOST': 'db',
 'PORT': 5432,
 }
}
</code></pre>
<ul>
<li>Here, we are telling the Django database engine to uses the <code>postgresql_psycopg2 adaptor</code> (that you have installed it using pip from the above <code>requirements.txt</code> file ) instead of the default sqlite3 adaptor.&nbsp;</li>
<li>Then we have given the database name, the database username, the database password, and the database port based on the environment variables that you have defined in <code>db</code> service of <code>docker-comose.yml</code> file.</li>
<li>The database hostname is the name of the Postgres service name, <code>db</code>.&nbsp;</li>
</ul>
Build and run your app with compose
1. From your project directory, start up your application by running.
<pre class="language-markup"><code>docker-compose up</code></pre>
The above command will builds, (re)creates, starts, and attaches to container for service.
<blockquote>
Note:
Don't forget to build the image, if you change your Dockerfile or after adding dependencies in requriements.txt file. To build the image use:
</blockquote>
<pre class="language-markup"><code>$ docker-compose up -d --build </code></pre>
This will rebuild the images each time the command is run, and -d flag runs the container in the detached mode so that it keeps running in the background even when you closed your terminal. In the above command
To stop&nbsp; the running container, run below command from where your docker-compose.yml file is located:
<pre class="language-markup"><code>$ docker-compose stop # stop running containers without removing them</code></pre>
&nbsp;or
<pre class="language-markup"><code>$ docker-compose down # stops containers and removes containers</code></pre>
2. Enter <code>http://localhost:8000/</code> in a browser to see the application running.&nbsp;
Connect pgAdmin to PostgreSQL
1. Visit <img src="https://drive.google.com/file/d/1tePuRFVG3SCzkTAtJzmUFSjmGlC9UrGA/view?usp=sharing" alt="" width="500" height="500" /><a href="http://localhost:5051/browser/">http://localhost:5051/browser/</a> in your browser. Then login into pgAdmin with the login credentials you have provided in <code>docker-compose.yml</code> file.
<pre class="language-markup"><code>PGADMIN_DEFAULT_EMAIL: pgadmin@gamil.com #you can change this
PGADMIN_DEFAULT_PASSWORD: pgadmin@1234 #you can change this </code></pre>
<img src="https://codemon.s3.ap-south-1.amazonaws.com/assets/devcolumn1.png?fbclid=IwAR2muc3GrkiZrFf6X_1iVk7bA4wKYfM5As7pii3_qDq-d2fk5JgtLAj9Vg4" alt="" width="1000" height="586" />
<img src="https://codemon.s3.ap-south-1.amazonaws.com/assets/devcolumn2.png?fbclid=IwAR2muc3GrkiZrFf6X_1iVk7bA4wKYfM5As7pii3_qDq-d2fk5JgtLAj9Vg4" alt="" width="1000" height="524" />
2. Click on <code>Add New server</code> and the following dialog box will appear. In the <code>Name</code> field give a descriptive name for the server, the name specified will be displayed in the Browser tree control.
<img src="https://codemon.s3.ap-south-1.amazonaws.com/assets/devcolumn3.png?fbclid=IwAR2muc3GrkiZrFf6X_1iVk7bA4wKYfM5As7pii3_qDq-d2fk5JgtLAj9Vg4" alt="" width="502" height="547" />
3. Click the <code>connection</code> tab to continue.&nbsp;
<img src="https://codemon.s3.ap-south-1.amazonaws.com/assets/devcolumn4.png?fbclid=IwAR2muc3GrkiZrFf6X_1iVk7bA4wKYfM5As7pii3_qDq-d2fk5JgtLAj9Vg4" alt="" width="505" height="552" />
<img src="https://codemon.s3.ap-south-1.amazonaws.com/assets/devcolumn5.png?fbclid=IwAR3VF6yGe-n2k3HfrqW2SbI41tZZFFMQLBhsHMisCb2mkbUN6hdr6g_XxmI" alt="" width="1000" height="520" />
<ul>
<li>The hostname/address <code>db</code> is the name of PostgreSQL service in your <code>docker-compose.yml</code> file.</li>
<li>Port 5432 is the port PostgreSQL service is using from <code>docker-compose.yml</code> file. The default is 5432.</li>
<li>The maintenance database field is the name of the initial database to which the client will connect, <code>postgres</code>.</li>
<li>Username and Password are <code>postgres</code> and <code>postgres</code> respectively from the environment variable that you have defined in <code>db</code> service of <code>docker-compose.yml</code> file.</li>
<li>Click on the Save button.</li>
</ul>
<h4>Some useful Django commands using docker-compose</h4>
<pre class="language-markup"><code>docker-compose run --rm web python manage.py startapp &lt;app_name&gt;
docker-compose run --rm web python managepy makemigrations
docker-composer run --rm web python manage.py migrate
docker-compose run --rm web python manage.py collectstatic
</code></pre>
&nbsp;

In this tutorial, you'll learn how to dockerize a Django project that uses PostgreSQL as a database and pgAdmin for managing PostgreSQL.

Dockerizing Django with PostgreSQL, and pgAdmin

Bishwo Bijaya Shah

In this article we are going to post a tweet to a twitter account every 5 minute (Just for testing purpose) using cron job. You can run any task like sending email or notifications if you want inside a cron job, but if you want to post a tweet, follow the link below to create a function that posts tweet using twitter API.
<a href="https://www.devcolumn.com/articles/view/tweet-and-publish-article-to-twitter-and-facebook-page-using-node-js-server" target="_blank" rel="noopener">Post a tweet to twitter account</a>
What we are going to do:
<ol>
<li>Create a node app</li>
<li>Create a twitter feed function or anything you want.</li>
<li>Create a schedular function&nbsp;</li>
<li>Invoke schedular.</li>
</ol>
Step 1: Create a node app (Skip this part if you already have a node app):
Go to terminal and run following commands sequentially.
<pre class="language-javascript"><code>mkdir myapp

cd myapp

npm init -y

npm i express cron twitter

npm i nodemon -g

touch app.js</code></pre>
Inside app.js file paste following code.
<pre class="language-javascript"><code>const express = require("express");

const app = express();

const port = Number(8888);

//Start server at given port number.
app.listen(port, function () {
 console.log("Server running at port:" + port);
});
</code></pre>
Now, if you run 'nodemon app.js' inside project root directory without quotes, the server must be running at port number 8888&nbsp;
Step 2: Create twitter feed function:
Create a folder, lets say 'helpers' inside project root and add index.js file.
Inside index.js file paste following code.
<pre class="language-javascript"><code>const Twitter = require("twitter");

const twitterFeed = async() =&gt; {
 let twitter_config = {
 consumer_key: "YOUR_CONSUMER_KEY",
 consumer_secret: "YOUR_CONSUMER_SECRET_KEY",
 access_token_key: "YOUR_ACCESS_TOKEN_KEY",
 access_token_secret: "YOUR_ACCESS_TOKEN_SECRET"
 };
 try {
 let client = new Twitter(twitter_config);
 let status = "Hello worldy! https://www.example.com";
 let d = await client.post("statuses/update", {
 status
 });
 return d;
 } catch (e) {
 console.log("ERR===", e);
 return e;
 }
}

module.exports = {twitterFeed}</code></pre>
If getting an twitter API key and setting it up is too much hassle, you can create a simple function that logs a text message instead of twitterFeed.
Step 3: Create a schedular function inside /helpers/index.js&nbsp;
Now the complete code of index.js will be;
<pre class="language-javascript"><code>const Twitter = require("twitter");
const CronJob = require("cron").CronJob;

const twitterFeed = async() =&gt; {
 let twitter_config = {
 consumer_key: "YOUR_CONSUMER_KEY",
 consumer_secret: "YOUR_CONSUMER_SECRET_KEY",
 access_token_key: "YOUR_ACCESS_TOKEN_KEY",
 access_token_secret: "YOUR_ACCESS_TOKEN_SECRET"
 };
 try {
 let client = new Twitter(twitter_config);
 let status = "Hello worldy! https://www.example.com";
 let d = await client.post("statuses/update", {
 status
 });
 return d;
 } catch (e) {
 console.log("ERR===", e);
 return e;
 }
}

const schedular = () =&gt; {
 let job = new CronJob(
 "0 */5 * * * *",
 //Run this job after every 5 minutes.
 async () =&gt; {
 await twitterFeed()
 },
 null,
 true,
 "Asia/Kathmandu"
 // Your timezone
 );
 job.start();
};

module.exports = {schedular}</code></pre>
Those asterisks (*) represent following information from right to left.
<ul>
<li>* (right-most) - Day of week (0-6)</li>
<li>* - Month (1-12)</li>
<li>* - Day of month (1-31)</li>
<li>* - Hour (0-23)</li>
<li>* - Minute (0-59)</li>
<li>* - Second (0-59) - optional</li>
</ul>
Step 4: Invoke schedular inside app.js
Since, schedular function is inside helpers/index.js file, our node server won't execute it automatically. We need to invoke this function inside app.js so that when the time comes, it gets executed successfully.
Lets open app.js file and import a function;
<pre class="language-javascript"><code>const { schedular } = require("./helpers/");
</code></pre>
Now, app.js looks something like this.
<pre class="language-javascript"><code>const express = require("express");

const { schedular } = require("./helpers/");

const app = express();

schedular();

const port = Number(8888);

//Start server at given port number.
app.listen(port, function () {
 console.log("Server running at port:" + port);
});
</code></pre>
Now as long as your node app is up and running, you will be executing twitterFeed() function every 5 minutes.&nbsp;
To make sure it's working, you can just put console.log("message") inside twitterFeed() function.
And BOOM! we just created a function which posts tweet to the twitter account and autmatically re-posts in every 5 minutes time interval.
You can achieve so many things by applying cron job. One of the most useful use cases is database backup. So keep learing and sharing. I hope the article was worth the time.

Learn how to automate background tasks in node js using cron job. Automate twitter post with node js

Automate background tasks in node js using cron job

Google doc has become one of those tools we use in our daily life. It has a great features to manage documents. It is easily accessible and can be shared with anyone to collaborate.
In case you didn't know, google has an API to read and write google doc contents. We can use this API for many use cases like importing data from google doc to our application, export application data to google doc depending on our requirements.
In this article we are going to setup a node.js server which will interact with googleapi to read/write google docs data.
Before we begin, we must have a google doc ID which is string before <code>/edit</code> when you open a google doc in browser.
Eg:&nbsp;<a href="https://docs.google.com/document/d/1NgD6Ve96RObMeNOPDyVpl5cuA-tv934IKOzYHxT2dc4/edit" target="_blank" rel="noopener">https://docs.google.com/document/d/{google_doc_id}/edit</a>
Now lets follow the steps given below:
Step 1: Setup project and store google doc ID.
Run following commands in order to setup an app.
<pre class="language-javascript"><code>mkdir google-docs 
cd google-docs
npm init -y
git init
touch .gitignore
npm i googleapis config
mkdir src &amp;&amp; touch src/auth.js
mkdir config &amp;&amp; touch config/local.json</code></pre>
Inside .gitignore file, paste following code so that they won't get uploaded to git repository.
<pre class="language-javascript"><code>node_modules/
config/
credentials.json
token.json</code></pre>
Inside <code>config/local.json</code> file paste following code:
<pre class="language-javascript"><code>{
 "google": {
 "doc_id": "YOUR_GOOGLE_DOC_ID"
 }
}
</code></pre>
Step 2: Enable google doc and gmail API.
Go to link given below and click on Enable button.
<a href="https://console.developers.google.com/apis/library/docs.googleapis.com" target="_blank" rel="noopener">https://console.developers.google.com/apis/library/docs.googleapis.com</a>
Go to link given below and click on Enable Gmail API.
<a href="https://developers.google.com/gmail/api/quickstart/nodejs" target="_blank" rel="noopener">https://developers.google.com/gmail/api/quickstart/nodejs</a>
Get credentials.json file and store it in your project root directory i.e. <code>google-docs</code> in our case.
Step 3: Inside <code>src/auth.js</code> insert following code:&nbsp;
Here, we are authorizing our app to get token.json file from google.
<pre class="language-javascript"><code>const fs = require("fs");
const readline = require("readline");
const { google } = require("googleapis");

const SCOPES = ["https://www.googleapis.com/auth/documents"];
// The file token.json stores the user's access and refresh tokens, and is
// created automatically when the authorization flow completes for the first
// time.
const TOKEN_PATH = "token.json";

// Load client secrets from a local file.
fs.readFile("credentials.json", (err, content) =&gt; {
 if (err) return console.log("Error loading client secret file:", err);
 // Authorize a client with credentials, then call the Gmail API.
 authorize(JSON.parse(content), () =&gt; console.log("authorized!"));
});

function authorize(credentials, callback) {
 const { client_secret, client_id, redirect_uris } = credentials.installed;
 const oAuth2Client = new google.auth.OAuth2(
 client_id,
 client_secret,
 redirect_uris[0]
 );

 // Check if we have previously stored a token.
 fs.readFile(TOKEN_PATH, (err, token) =&gt; {
 if (err) return getNewToken(oAuth2Client, callback);
 oAuth2Client.setCredentials(JSON.parse(token));
 callback(oAuth2Client);
 });
}

function getNewToken(oAuth2Client, callback) {
 const authUrl = oAuth2Client.generateAuthUrl({
 access_type: "offline",
 scope: SCOPES,
 });
 console.log("Authorize this app by visiting this url:", authUrl);
 const rl = readline.createInterface({
 input: process.stdin,
 output: process.stdout,
 });
 rl.question("Enter the code from that page here: ", (code) =&gt; {
 rl.close();
 oAuth2Client.getToken(code, (err, token) =&gt; {
 if (err) return console.error("Error retrieving access token", err);
 oAuth2Client.setCredentials(token);
 // Store the token to disk for later program executions
 fs.writeFile(TOKEN_PATH, JSON.stringify(token), (error) =&gt; {
 if (error) return console.error(error);
 console.log("Token stored to", TOKEN_PATH);
 });
 callback(oAuth2Client);
 });
 });
}
</code></pre>
Now run <code>node src/auth.js</code> inside project directory and follow the prompt in terminal.&nbsp;
After authorizing, you will have a <code>token.json</code> file in project root directory.
And if you run <code>node src/auth.js</code> you will see <code>authorized!</code> message in terminal
Great! our app is authorized, now we can write message in google doc.
Step 4: Write data inside google doc:
Create&nbsp;<code>write.js</code>&nbsp;inside src folder and paste following code.
<pre class="language-javascript"><code>const { google } = require("googleapis");
const token = require("../token.json");
const credentials = require("../credentials.json");
const config = require("config");

function authorize() {
 const { client_secret, client_id, redirect_uris } = credentials.installed;
 const oAuth2Client = new google.auth.OAuth2(
 client_id,
 client_secret,
 redirect_uris[0]
 );
 oAuth2Client.setCredentials(token);
 return oAuth2Client;
}

async function main(DOC_ID) {
 const auth = await authorize();
 const docs = google.docs({
 version: "v1",
 auth,
 });
 await docs.documents.batchUpdate({
 auth,
 documentId: DOC_ID,
 requestBody: {
 requests: [
 {
 insertText: {
 location: {
 index: 1,
 },
 text: "hello world.!\n",
 },
 },
 ],
 },
 });
 console.log("========data written successfully.===========");
}

main(config.get("google.doc_id"));
</code></pre>
Now run <code>node src/write.js</code> and you will have <code>hello world</code> data written in your google doc.
Step 5: Read data from google docs.
Create&nbsp;<code>read.js</code>&nbsp;inside src folder and paste following code.
<pre class="language-javascript"><code>const { google } = require("googleapis");
const token = require("../token.json");
const credentials = require("../credentials.json");
const config = require("config");

function authorize() {
 const { client_secret, client_id, redirect_uris } = credentials.installed;
 const oAuth2Client = new google.auth.OAuth2(
 client_id,
 client_secret,
 redirect_uris[0]
 );
 oAuth2Client.setCredentials(token);
 return oAuth2Client;
}

async function print(DOC_ID) {
 const auth = await authorize();
 const docs = google.docs({ version: "v1", auth });
 let d = await docs.documents.get({
 documentId: DOC_ID,
 });
 console.log("========", d.data);
}

print(config.get("google.doc_id"));
</code></pre>
Run <code>node src/read.js </code>and you can get contents of your google doc in the terminal.
Conclusion:
This is just a basic tutorial to authorize, read and write google docs. You can play around with google doc contents, like convert the contents of google docs into html format and render it.
Reference: <a href="https://developers.google.com/gmail/api/quickstart/nodejs" target="_blank" rel="noopener">https://developers.google.com/gmail/api/quickstart/nodejs</a>

Learn how to read and write google docs content using node js and googleapi

Read and write data in google docs using node js and googleapi

In this article, we are going to deploy node js app to ubuntu production server. There are plenty of good service providers if you want to buy your own hosting server. Digitalocean is one of the widely used and favorite among the developers, since you can get your own VPS server at just $5.&nbsp;
If you don't have your own vps server yer, go to <a href="https://www.digitalocean.com/" target="_blank" rel="noopener">digitalocean</a> and&nbsp; create a droplet that suits your requirement.
So, before we begin, here is the list of prerequisites you need to have.
<ul>
<li>Node js app</li>
<li>Ubuntu based hosting server</li>
<li>Basic knowledge of linux commands</li>
</ul>
Now lets just follow the steps given below, sequentially.
Step 1. Create a node app:
Since you are here for a node app deployment tutorial, I am assuming that you already have a node app. If you don't have one, you can find sample node app at the github link given below.
<a href="https://github.com/thebinod7/devcolumn/tree/basic-setup" target="_blank" rel="noopener">https://github.com/thebinod7/devcolumn/tree/basic-setup</a>
Download and setup the app on your PC and make sure it is working as expected in local environment.
Also don't forget to keep your project in github or any other git server. Because, we will be downloading/cloning the project from git server to production server.
2. Login to production server:
So by now, our app should be doing well on local machine and the next step is to get it on production server.
We are going to use ssh service to login to server. Just open the terminal and enter server credentials in following format.
<pre class="language-javascript"><code>sudo ssh username@server_ip_address</code></pre>
Where username is usually root and server ip address is provided to you by your hosting service provider.
Now enter password given by service provider in the terminal and you should be logged in to the server.
3. Install git, node, nginx and pm2:
Lets setup our server before we run our node app.
Run commands given below sequentially to install services we need in order to deploy our app.
<pre class="language-javascript"><code>sudo apt update

// Install git
sudo apt install git

// Install node.js
sudo apt install nodejs

// Install nginx
sudo apt install nginx

// Install pm2
npm install pm2 -g</code></pre>
4. Clone project inside production server and run:
Now lets clone our project from git server to our deployment server where we just logged in.
If you want to create a folder or directory inside your server root, you can create&nbsp; with the following command and clone your project inside it.
<pre class="language-javascript"><code>mkdir dir_name</code></pre>
But, in this tutorial we are using root directory of a server.
<pre class="language-javascript"><code>git clone git_clone_url</code></pre>
You maybe asked github username and password if ssh key is not added to your git. For now, enter username and password and clone the project.
After cloning, go to project directory and run 'npm install'
Now, you can run you app using pm2 command as follows.
<pre class="language-javascript"><code>pm2 start app.js</code></pre>
*Note: Don't forget to have your config files or environemnt variables on your production server. Since, these files may ignored by git and you may need to add it manually.
5.Configure nginx as reverse proxy server:
Nginx is an open source http server and reverse-proxy. In our case it is going to be like a middle-man between our node server and client. The requests sent by client is sent to nginx server and those requests are transferred to node js server and vice-versa.
After installing we can configure nginx by simply typing following command.
<pre class="language-javascript"><code>sudo nano /etc/nginx/sites-available/demo
</code></pre>
Inside config file, find server block and replace /location section with following code.
<pre class="language-javascript"><code> location / {
 # Note that port number must be same as your app running on.
 proxy_pass http://localhost:3000;
 proxy_http_version 1.1;
 proxy_set_header Upgrade $http_upgrade;
 proxy_set_header Connection 'upgrade';
 proxy_set_header Host $host;
 proxy_cache_bypass $http_upgrade;
 }</code></pre>
This will serve your node app running at http://localhost:3000
To make sure, nginx configuration don't have any syntax error, just type:
<pre class="language-javascript"><code>sudo nginx -t</code></pre>
Now, restart nginx by typing,
<pre class="language-javascript"><code>sudo systemctl restart nginx
</code></pre>
If you forgot to run your app with pm2. Run&nbsp; with pm2 command as&nbsp; follows:
<pre class="language-javascript"><code>pm2 start app.js</code></pre>
If everything went well, your app should be now accessible from your server ip. Enter your server in your browser and app should be running.
Furthermore, it's now easier to update your code from local machine to server. If you push any changes to git server from your local machine, you just need to go to your project root directory on production server and run git command:
<pre class="language-javascript"><code>git pull origin master

// If you want to pull from any other branch.

git pull origin branch_name</code></pre>
If you want to learn how to deploy next js app, follow the tutorial given below. It's similar to deploying node app with few tweaks.&nbsp;
<a href="https://www.devcolumn.com/articles/view/deploy-next-js-app-with-pm2-and-nginx-on-ubuntu-1804">Deploy next js app to your own server</a>
Keep learning, keep sharing...

Learn how to setup node js app for production on ubuntu server. You will also learn how to configure nginx and run pm2

Deploy your first node js app to production server with pm2 and nginx

Twitter and facebook page have always been a great source of audience. When we have to share something among the people, twitter and facebook&nbsp; are one of the easily accessible mediums out there.
In genernal, what we do is; we create a content in the system and copy the content manually that we want share and paste it on twitter or facebook. But as a developer, we can automate these tasks in the background with APIs provided by twitter and facebook.
So, we are going to send content directly from our node app to the facebook page and twitter. In order to accomplish this, we will need some packages to be installed in our app.
First of all, I am assuming that; you have already setup your node app. If you don't know how to setup node server, please follow the link below:
<a href="https://www.devcolumn.com/articles/view/node-js-complete-tutorial-to-setup-your-first-app-with-express-js-and-mongoose" target="_blank" rel="noopener">Setup node app for beginners</a>
Now lets install packages that we are going to use in this article.
<pre class="language-javascript"><code>npm install --save axios

npm install --save twitter

npm install --save config

</code></pre>
Step 1: Create config folder inside project root and add local.json file
Inside local.json file paste following code:
<pre class="language-javascript"><code> "services": {
 "twitter": {
 "consumer_key": "YOUR_CONSUMER_KEY",
 "consumer_secret": "YOUR_CONSUMER_SECRET_KEY",
 "access_token_key": "YOUR_ACCESS_TOKEN_KEY",
 "access_token_secret": "YOUR_ACCESS_TOKEN_SECRET"
 },
 "facebook": {
 "graph_api": "https://graph.facebook.com/v7.0",
 "page_id": "YOUR_PAGE_ID",
 "page_access_token": "YOUR_PAGE_ACCESS_TOKEN"
 },
}</code></pre>
Store your facebook/twitter credentials in local.json file. The process of getting these credentials is given below, keep going...
Step 2:&nbsp; Get API keys for twitter
Go to this link <a href="https://developer.twitter.com/en/apps" target="_blank" rel="noopener">https://developer.twitter.com/en/apps</a> and click on 'Create App' button.
Getting access key from twitter is quite a process. You will need to fill a form with reasons to use twitter API with valid points and other information that twitter asks. Once you have created an app, you can generate a token and use twitter APIs.&nbsp;
Make sure you have following keys from twitter:
<ul>
<li>consumer_key (also called API Key)</li>
<li>consumer_secret_key (also called API Secret Key)</li>
<li>access_token_key</li>
<li>access_token_secret</li>
</ul>
Step 3: Create a function as follows:
<pre class="language-javascript"><code>async twitterFeed() {
 let twitter_config = config.get("services.twitter"); // Set your twitter credentials here.
 try {
 let client = new Twitter(twitter_config);
 let status = "Hello worldy! https://www.example.com";
 let d = await client.post("statuses/update", {
 status,
 });
 return d;
 } catch (e) {
 console.log("ERR===", e);
 return e;
 }
 }</code></pre>
Now, call the function twitterFeed() to tweet status.
Step 4: Get page access token for facebook
We are going to use facebook graph API to post our content in facebook. Before we call an API, we need following data to proceed. Go to <a href="https://developers.facebook.com/docs/pages/access-tokens/" target="_blank" rel="noopener">https://developers.facebook.com/docs/pages/access-tokens/</a> to get these tokens
<ul>
<li>Page ID</li>
<li>User Access Token</li>
<li>Page Access Token</li>
</ul>
You can find Page ID of your page inside About section of your page.
* Note: Page Access Token can be generated once and used forever. Make sure you extend life of token while generating. Also don't forget to add following permissions while creating User Access Token
<ul>
<li>pages_manage_posts</li>
<li>pages_read_engagement</li>
</ul>
You need to call following API.&nbsp;
<pre class="language-javascript"><code>Method: "GET"

// Here, access_token is user_access_token you generate from Graph API Explorer Tool of facebook.
https://graph.facebook.com/{page_id}? fields=access_token&amp;access_token={access_token}

// After running above API, you will get page_access_token which can be used to post in facebook page.</code></pre>
5. Create a function&nbsp; facebookFeed() as follows:
<pre class="language-javascript"><code> facebookFeed() {
 let base_url = config.get("services.facebook.graph_api");
 let page_id = config.get("services.facebook.page_id");
 let page_access_token = config.get("services.facebook.page_access_token");
 axios
 .post(
 `${base_url}/${page_id}/feed?access_token=${page_access_token}&amp;message=Hello there!&amp;link=https://www.example.com`
 )
 .then((res) =&gt; {
 return res.data;
 })
 .catch((err) =&gt; {
 console.log("ERR:", err);
 return err;
 });
 }</code></pre>
That's it, now you can call the function facebookFeed() to publish your content to facebook page.
Rememeber that facebook user_access_token and page_access_token are different things and you need to call APIs with postman or run curl commands as described in the link below to get those tokens:&nbsp;
<a href="https://developers.facebook.com/docs/pages/access-tokens/" target="_blank" rel="noopener">https://developers.facebook.com/docs/pages/access-tokens/</a>&nbsp;
You can test if your data is posted in facebook page by calling following API.
<pre class="language-javascript"><code>// Method = "GET"

https://graph.facebook.com/v7.0/{page_id}/feed?access_token={access_token}</code></pre>
If you get array of data in response, your APIs are working.&nbsp;
Rememeber that, these APIs will only work in development environment if your app is not verified. You need to submit for review and verify the app in order to work in live projects.

Learn how to get API keys from twitter and facebook and publish contents directly from node server. 

Tweet and publish article to twitter and facebook page using node js server

Background processing in programming referes to tasks that run behind the scene without direct involvement of users. We can perform tasks that are heavy and take much processing time in execution, and also usually occur frequently in the system.&nbsp;&nbsp;
Services like email/message sending, system notifications, scheduled task exection are some of the use cases of background processing service. Furthermore, single threaded programming like node js can use background processing services&nbsp; to offer responsiveness to the system without blocking the CPU.
There are many services that offer background task processing smoothly. One of the most popular services and my favorite is RabbitMQ.
RabbitMQ is an open source message broker system. Basically, it's a server that holds messages until it gets delivered to receiver. We can think of it as a post office where letter is stored which are then delivered to receiver. The working mechanism is quite different though, I'm trying to give a whole picture of the system.
In RabbitMQ there are three basic elements we need to understand.
<ol>
<li>Producer</li>
<li>Server/Broker</li>
<li>Consumer</li>
</ol>
1. Producer:
Producer is responsible for generating a message that is going to be stored on server and latter being consumed by consumer.&nbsp;
2. Server:
Server stores the data sent by producer and make sures it's there untill consumer gets it.
3. Consumer:
Consumer reads data from server by providing appropriate information required to access the server.
Now, before we start writing code, we need to have a RabbitMQ server either on local computer or cloud. If you want your server on cloud create an account at <a href="https://www.cloudamqp.com/plans.html" target="_blank" rel="noopener">https://www.cloudamqp.com/plans.html</a> and get connection URL.&nbsp;
In this tutorial we are going to use local server. So, lets install it on our PC as follows:
Insatall on ubuntu:
<pre class="language-javascript"><code>sudo apt-get install rabbitmq-server</code></pre>
Install on mac
<pre class="language-javascript"><code>brew install rabbitmq
</code></pre>
If you are Windows user please follow the link below to install:
<a href="https://www.rabbitmq.com/download.html" target="_blank" rel="noopener">https://www.rabbitmq.com/download.html</a>
Now we are ready to code. Lets setup our node app with following commands:
<pre class="language-javascript"><code>mkdir rabbit-node 

cd rabbit-node

npm init -y

npm install &ndash;-save amqplib
</code></pre>
Now follow these steps:
Step1: Add producer.js file inside project root directory and paste following code
<pre class="language-javascript"><code>const amqp = require("amqplib/callback_api");

amqp.connect("amqp://localhost", function (error, connection) {
 if (error) {
 throw error;
 }
 connection.createChannel(function (error1, channel) {
 if (error1) {
 throw error1;
 }

 let queue = "my_queue";
 let msg = "Hello world!";

 channel.assertQueue(queue, {
 durable: true,
 });
 channel.sendToQueue(queue, Buffer.from(msg), {
 persistent: true,
 });
 console.log("Sent '%s'", msg);
 });
 setTimeout(function () {
 connection.close();
 process.exit(0);
 }, 7000);
});
</code></pre>
Explanation of above code:
<ul>
<li>amqp.connect(): Conncets to rabbitmq server. You can replace localhost with your server URL if you have one.</li>
<li>After connecting, it will return connection object with which we can create channel on server as connection.createChannel()</li>
<li>channel.assertQueue() assures there is a queue on server and creates one if it does not exist.</li>
<li>channel.sendToQueue() sends message to queue on server.</li>
<li>setTimeOut() function closes connection with server after time specified to it.</li>
</ul>
Now run 'node producer.js' in terminal without quotes, you will see a message as follows:
<pre class="language-markup"><code>Sent 'Hello world!'</code></pre>
It just means that, we sent a message to the server.
Step 2: Add consumer.js file inside project directory and paste following code
<pre class="language-javascript"><code>const amqp = require("amqplib/callback_api");

amqp.connect("amqp://localhost", function (err, connection) {
 if (err) {
 throw err;
 }
 connection.createChannel(function (e, channel) {
 if (e) {
 throw e;
 }
 let queue = "my_queue";

 channel.assertQueue(queue, {
 durable: true,
 });
 channel.prefetch(1);

 console.log("Waiting for messages in %s", queue);
 channel.consume(queue, function (msg) {
 console.log("Received '%s'", msg.content.toString());

 setTimeout(function () {
 channel.ack(msg);
 }, 1000);
 });
 });
});
</code></pre>
Here, you can see similar code as above. Except, we have a method called channel.consume() which receives message from the server, we created just before.
Run 'node consumer.js' without quotes in terminal and you will see a message sent by producer as follows:
<pre class="language-markup"><code>Waiting for messages in my_queue
Received 'Hello world!'

</code></pre>
To make this code more fruitful, you can write email sending code inside channel.consume() method. If you don't know how to send email in node js, there is a tutorial with full code. Just follow the link below:
<a href="https://www.devcolumn.com/articles/view/send-email-with-handlebar-template-and-dynamic-data-using-node-js" target="_blank" rel="noopener">Send email using node js</a>
Conclusion:
This is just a basic tutorial on how to setup RabbitMQ with node js. You can use RabbitMQ as an intermediate service in your application and get most out of it. It's easy to integrate and use cases are a lot of it out there.
&nbsp;If you want to learn more about rabbitmq, here is a good tutorial to start with:
<a href="https://www.cloudamqp.com/blog/2015-05-18-part1-rabbitmq-for-beginners-what-is-rabbitmq.html" target="_blank" rel="noopener">https://www.cloudamqp.com/blog/2015-05-18-part1-rabbitmq-for-beginners-what-is-rabbitmq.html</a>
Thanks for reading and keep learning, keep sharing ;)

Learn how to setup rabbitmq with node js and exchange messages between sender and receiver.

Messaging and background processing in node js with RabbitMQ

First and foremost, you must have installed Node.js and mongodb on your computer. I am skipping this part. You can follow this tutorial of digitalocean to install it on Ubuntu.&nbsp;
<a href="https://www.digitalocean.com/community/tutorials/how-to-install-node-js-on-ubuntu-18-04" target="_blank" rel="noopener">Install node js on ubuntu</a>
For other PCs, you can find so many tutorials available on web.
Similarly, to install and setup mongodb go to this link:
<a href="https://www.digitalocean.com/community/tutorials/how-to-install-mongodb-on-ubuntu-18-04" target="_blank" rel="noopener">Install mongodb on ubuntu</a>
Also, if you don't have any text editor, get any text editor you like. I prefer VS Code.
Before starting, create a project folder on your computer and change current directory to it.
Alright, we are all set to go now.
Step 1 : Inside project directory run following command
<pre class="language-javascript"><code>npm init -y</code></pre>
It will create a file named 'package.json', which contains information like project name, version, author and all. But, most importantly it will have scripts and packages we would use in our app.
Step 2 : Install express js which is a framework based on node js.
<pre class="language-javascript"><code>npm install express --save</code></pre>
After installing, you can see dependencies section inside package.json where it will be located and also node_modules folder is created inside project directory.
Step 3 : Create a config folder inside project root and add local.json&nbsp;
Config files let us access variables across the project without hard coding them. It's also useful to manage dev/production environment variables. You can use .env files if you like.
Once you create a local.json file you can paste following code or write your own.
<pre class="language-javascript"><code>{
 "app_url": "http://localhost:8888",
 "app": {
 "name": "My App",
 "db": "mongodb://localhost:27017/my_db"
 }
}
</code></pre>
Also install following packages in your project.
<pre class="language-javascript"><code>npm install -g nodemon

npm install body-parser

npm install config

npm install cookie-parser

npm install ejs

npm install express

npm install mongoose

npm install morgan
</code></pre>
Step 4 : Create views folder inside project root and add index.ejs
Note that;&nbsp; ejs is templating engine just like handlebars and jade out there. It's just a html file with .ejs extension and server side rendering capabilites.
Add following code inside index.ejs file.
<pre class="language-markup"><code>&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
 &lt;head&gt;
 &lt;meta charset="UTF-8" /&gt;
 &lt;meta name="viewport" content="width=device-width, initial-scale=1.0" /&gt;
 &lt;title&gt;Home - &lt;%= title %&gt;&lt;/title&gt;
 &lt;/head&gt;
 &lt;body&gt;
 &lt;h3&gt;&lt;%= message %&gt;&lt;/h3&gt;
 &lt;/body&gt;
&lt;/html&gt;</code></pre>
As you can see, data from server can be passed inside &lt;%=&nbsp; variable_name %&gt;.
Step 5 : Add routes folder inside project root and add index.js file
We will setup routing for our project here so that we can send response on the basis of client request.
<pre class="language-javascript"><code>const router = require("express").Router();

router.get("/", (req, res, next) =&gt; {
// This data is renderd on ejs page. We can get data from database here as well.
 const data = {
 title: "Devcolumn Exercise",
 message: "Welcome to your app ;)",
 };
 res.render("index", data);
});

router.get("/some_other_route", (req,res,next) =&gt; {
 // Your code.
}

module.exports = router;</code></pre>
Step 6 : Add app.js file inside project root and add following code.
<pre class="language-javascript"><code>const express = require("express");
const path = require("path");
const cookieParser = require("cookie-parser");
const bodyParser = require("body-parser");
const morgan = require("morgan");
const mongoose = require("mongoose");

const RouteManager = require("./routes");
const config = require("config");

// Connect to database using mongoose.
mongoose.connect(config.get("app.db_url"));
mongoose.connection.on("connected", function () {
 console.log("Connected to database successfully.");
});

mongoose.connection.on("error", function (err) {
 console.log("Database error:" + " " + err);
});

const app = express();

// To log requests inside app.
app.use(morgan("combined"));

const port = Number(config.get("app.port") || 8888);

// view engine setup to ejs.
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "ejs");

// To parse data from form body.
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(cookieParser());

// ROUTES FOR OUR APP
app.use("/", RouteManager);

// To serve static files inside public folder. eg: js, css, images.
app.use(express.static(path.join(__dirname, "public")));

//Start server at given port number.
app.listen(port, function () {
 console.log("Server running at port:" + port);
});
</code></pre>
Now run npm start inside your project root. You can now see your app at http://localhost:8888
* Note: Don't forget to read comments inside code. I have tried to explain why they are there.
If you missed something, don't worry there is a complete code in github you can just download it and read it.
Github: <a href="https://github.com/thebinod7/devcolumn" target="_blank" rel="noopener">Node js basic setup with express and mongoose database</a>
This is just a basic setup for the beginners. You can now play around the app by adding different routes and ejs files inside view and serving them.
Try to figure out how data being passed from route to rendering page, how packages are added and imported/exported.
There is miles ahead to go, keep learning. ;)
You might also like to learn:
<a href="https://www.devcolumn.com/articles/view/send-email-with-handlebar-template-and-dynamic-data-using-node-js">Sending email in node js</a>

Learn how to setup node js server with express framework and mongoose ORM.

Node js complete tutorial to setup your first app with express js and mongoose

<a href="https://www.djangoproject.com/" target="_blank" rel="noopener">Django</a>&nbsp;is a high-level Python Web Framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of the Web development, so you can focus on writing your app without needing to reinvent the wheel. it's free and open-source.
Prerequisites
Python: Install the version of Python 3, as Django is a Python Web Framework. Unix environment comes preinstalled with Python. For Windows users, you can download the Python from <a href="https://www.python.org/downloads/" target="_blank" rel="noopener">here</a>.
To check your Python version, run the following commands:&nbsp;
<pre class="language-markup"><code>python3 -V</code></pre>
Pip: Pip is the standard package manager for Python. It allows us to install and manage packages from the <a href="https://pypi.org/" target="_blank" rel="noopener">Python Package Index</a> and other indexes.
<blockquote>
Pip is already installed if you are using Python 2&gt;=2.7.9 or Python 3&gt;=3.4. If not installed, then you can install it from <a href="https://pip.pypa.io/en/stable/installing/" target="_blank" rel="noopener">here.</a>
</blockquote>
Virtualenv:&nbsp;Actually this one is an optional prerequisite. But it is strongly recommended to create a separate virtual environment for different Django projects. Because it avoids installing Django into a global Python environment and gives you an isolated Python environment. So that you can have control over the libraries used in Python applications.&nbsp;
Install virtualenv via pip
<pre class="language-markup"><code>pip install virtualenv</code></pre>
Check your installation
<pre class="language-markup"><code>virtualenv --version</code></pre>
Now, you have your prerequisites installed. You can start creating and running a Django project.
1. First, create a directory
<pre class="language-python"><code>mkdir django_project
cd django_project</code></pre>
2. Then create a new virtual environment for the Django project by typing:
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;<code>python3 -m venv ENV</code>
This will create a folder called "ENV" in the current directory which will contain Python executable files and a copy of the pip library which you can use to install other packages. The name of the virtual environment in our case "ENV" is user-defined and can be anything.
If you have only Python3 installed on your machine do the following. The above command also works.
&nbsp; &nbsp; &nbsp;<code>virtualenv ENV</code>
<ul>
<li>To begin using the virtual environment, you need to activate it.
<ul>
<li>on Windows, run&nbsp;<code>ENV\scripts\activate.bat</code></li>
<li>On Unix/Mac, run&nbsp;<code>source ENV/bin/activate</code></li>
</ul>
</li>
<li>The name of the virtual environment appears on the left of the prompt to let you know that it is active.</li>
<li>To deactivate the virtual environment, simply type <code>deactivate</code><code></code> on your command prompt.</li>
</ul>
3. Install Django
Now, install Django on your virtual environment (ENV):
<pre class="language-markup"><code>$ pip install Django</code></pre>
or
<pre class="language-markup"><code>$ pip install Django==3.0</code></pre>
You can check Django installation with the help of the following commands:
<pre class="language-markup"><code>$ python -m django --version</code></pre>
or
<pre class="language-markup"><code>$ pip freeze</code></pre>
4. Start the Django project
<pre class="language-markup"><code>$ django-admin startproject project .
</code></pre>
<ul>
<li>The period (.) after the &lt;proejct_name&gt; in our case "project" tells the script to create the project in your current directory.</li>
<li>Here, we are invoking the Django command-line utility for administrative tasks called django-admin ( installed inside /bin/ directory of a virtualenv ) to create the Django project directory structure for the given project name in the current directory.</li>
<li>Upon executing the above command, the following default Django project structures will be created:</li>
</ul>
<pre class="language-markup"><code>├── manage.py
└── project
 ├── asgi.py
 ├── __init__.py
 ├── settings.py
 ├── urls.py
 └── wsgi.py
</code></pre>
<ul>
<li>manage.py&nbsp;is a command-line utility that lets you execute Django administrative commands such as creating superuser, running the development server, creating apps, and making migrations of your database models. To get the full list of sub-commands that can be executed by manage.py, type <code>python manage.py --help</code> on your command prompt.</li>
<li>asgi.py&nbsp;is a standard Python asynchronous web apps and servers to communicate with each other and it is a successor to WSGI. Read more about ASGI <a href="https://channels.readthedocs.io/en/latest/asgi.html" target="_blank" rel="noopener">here.</a></li>
<li>__init__.py is an empty file that tells the Python interpreter to treat this directory as a Python package. This file allows Python packages to be imported from directories where it's located.&nbsp;</li>
<li>settings.py contains all the configuration settings for the Django project.</li>
<li>urls.py contains URL patterns for the Django project.</li>
<li>wsgi.py&nbsp;file basically provides an interface between web application written in Python and Webservers (NGINX, Apache, etc.). It's used both by Django's development server and in production WSGI deployment.</li>
</ul>
To check the creation of Django project was successful, you can run the following command on your command prompt:
<pre class="language-markup"><code>$ python manage.py runserver</code></pre>
You'll see the following output on the command prompt:
<pre class="language-markup"><code>Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

June 21, 2020 - 17:46:01
Django version 3.0.7, using settings 'project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.</code></pre>
This means that your server is running and everything goes as planned, visit <a href="http://localhost:8000/" target="_blank" rel="noopener">http://localhost:8000/</a> on your web browser and you should see a "Congratulations" page, with a rocket taking off.
5. Create an application(s)
In order to create an application, you need to run the following command:
<pre class="language-markup"><code>$ python manage.py startapp app1</code></pre>
<blockquote>
If you want to know the difference between project and application(s), you can learn from <a href="https://docs.djangoproject.com/en/3.0/ref/applications/" target="_blank" rel="noopener">here.</a>&nbsp;
</blockquote>
After running the command, it should create another directory called "app1" with the following file structure:
<pre class="language-markup"><code>app1
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── tests.py
└── views.py
</code></pre>
<ul>
<li>admin.py&nbsp;is used for registering your Django models to the Django admin panel.</li>
<li>apps.py&nbsp;contains settings for the application configurations.</li>
<li>__init__.py&nbsp;tells Python to treat this directory as a Python package.</li>
<li>migrations&nbsp;folders store the changes you make to your Django models.</li>
<li>models.py&nbsp;contains a series of classes that Django's ORM converts to database tables.</li>
<li>tests.py&nbsp;hold test cases that you write for your applications.&nbsp;</li>
<li>views.py is a function or class that takes a web request and returns a web response which can be the HTML contents of a Web page, or a redirect, or a 404 error, or an XML document, etc. In other words, Views are used to do things like fetching objects from the database, modify those objects if needed, render forms, return HTML, and much more.&nbsp;</li>
</ul>
6. Register an application
After creating an application, you need to register it in your project. To register it, just simply add your &lt;app_name&gt; in the <code>INSTALLED_APPS</code> list in the <code>project/settings.py</code> file.
<pre class="language-markup"><code>INSTALLED_APPS = [
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'app1',
]</code></pre>
<blockquote>
Don't forget to add comma after adding the &lt;app_name&gt;.&nbsp;
</blockquote>
7. Create a view
Navigate to the views.py file in the app1 directory. And add the following line of code:
<pre class="language-python"><code>from django.shortcuts import render


def index(request):
 return render(request, 'index.htm')
</code></pre>
<ul>
<li>In the first line, we are importing render function from django.shortcut library.</li>
<li>Then you've defined a view function called "index", which takes one argument, request. Each view function takes an HttpRequest object as its first parameter, which is typically named as "request".</li>
<li>After taking a request argument, it will return the value it gets from calling another function render that will render your template index.htm.</li>
</ul>
After creating a view function, you have to create a directory called templates inside your app_1 directory. And inside a templates directory create a file called index.htm.
Now your app_1 directory looks like this:
<pre class="language-markup"><code>app1
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── templates
│ └── index.htm
├── tests.py
└── views.py
</code></pre>
Open the index.htm file in your code editor and add the following lines:&nbsp;
<pre class="language-markup"><code>&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
 &lt;meta charset="UTF-8"&gt;
 &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;
 &lt;title&gt;Devcolumn&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;h1&gt;This is an index page.&lt;/h1&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
8. Map URLs to Views
To call the above create view called index, we need to map it to the URL - and for this, we need a URLconf. To create a URLconf in the app1 directory, create a file called urls.py.&nbsp; And your app1 directory should like this:
<pre class="language-markup"><code>app1
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│ └── __init__.py
├── models.py
├── templates
│ └── index.htm
├── tests.py
├── urls.py
└── views.py
</code></pre>
In the app1/urls.py file, add the following code:
<pre class="language-python"><code>from django.urls import path

from . import views

urlpatterns = [
 path('', views.index, name='index'),
]</code></pre>
The next step is to point the root URLconf at the project.urls module. In project/urls.py file includes the below changes:
<pre class="language-python"><code>from django.contrib import admin
from django.urls import path, include

urlpatterns = [
 path('admin/', admin.site.urls),
 path('', include('app1.urls')),
]
</code></pre>
Here, the include() function allows referencing other URLconfs. Whenever you visit the root path of your URL (<a href="http://127.0.0.1:8000/" target="_blank" rel="noopener">http://localhost:8000</a>), the app1 application's URLs will be registered.&nbsp;
Finally, when you restart the server and visit <a href="http://127.0.0.1:8000/" target="_blank" rel="noopener">http://127.0.0.1:8000/</a>, you should see the text "This is an index page." that you wrote in the index.htm file.
&nbsp;

devcolumn-1594042631690.jpg

This is a step-by-step tutorial that details how to create a Django project and application(s) and also covers a brief description of the Django skeleton.