Forem: Vishnu Dileesh

Deploying a Nodejs project to Railway

Vishnu Dileesh — Thu, 28 Sep 2023 07:50:40 +0000

We will deploy the discord bot we created in our previous article. Railway gives a seamless deployment experience.

Visit their website and click login, and in the pop-up, choose GitHub or Email sign-in option. If you choose GitHub, in the next step click on the button that says Authorize Railway App.

And done, you have now created an account with Railway through GitHub.

Now in the dashboard click on New Project.

And in the pop-up select Deploy from GitHub repo in our case. Our Discord bot project is a public GitHub project - GitHubDiscordBot.

In the next step click on Configure GitHub App, and a pop-up will open with GitHub asking you to select where to install the Railway App. Select your account.

Next, choose the permissions and access controls. Then for the last step click on the green button that says Install & Authorize.

Now you will be back in your dashboard. Give a refresh and if you click on the New Project again and choose Deploy from GitHub, it will load repositories from your GitHub account.

Select the project you want to deploy. And in the next step, you can deploy straight away or choose to add the needed environment variables.

When you click on either of those options, a new project will be created in Railway with your chosen GitHub project.

Here you can add your environment variables. In my case, I will add the variables listed in the .env_example file in the project GitHub folder.

In the Settings page, you can choose the branch you wish to deploy. And other details like what should the start command be.

In my case, I added the start command as

npm run start

Each time you make changes here in the project dashboard, like adding or removing an environment variable, or pushing a new update to the project GitHub repo, Railway will re-build the project and will deploy again.

In the Deployments, you can see your past deployment and the one running now. If you click on the View Logs button you can see different logs like Build Logs and Deploy Logs, and other details.

In the settings, you can also choose the deployment region, generate a domain, or add a custom domain, and other major changes can be made.

And that's it, you now have your project running live on Railway.

Node.js Discord Bot: Create GitHub Issues with Slash Commands

Vishnu Dileesh — Thu, 28 Sep 2023 07:49:11 +0000

A Discord bot that can help you create Github issues from the Discord chat via Slash Commands, let's begin.

We will be using Nodejs to build the bot while using the discord.js library. For the bot to talk to GitHub we will be using the GitHub-provided SDK Octokit. To deal with environment variables we will be using the npm package Dotenv. The Octokit SDK that will talk to GitHub needs a fetch package, for that we will be installing the package Node Fetch. We will be using two more libraries to be able to enable slash commands, @discordjs/rest and @discordjs/builders. Also, let's install another package named discord-api-types for type definitions.

That was all about installing packages. Now we will move on to some actual coding.

Create a project folder with your bot project name. And do npm init, to initialize npm.

NPM is our package manager and all the packages we talked about will be installed through npm commands.

npm install dotenv discord.js @discordjs/rest @discordjs/builders discord-api-types/v10 node-fetch octokit

The above command will install the needed packages. Now visit the package.json file which was auto-generated while we did npm init. There check to see if "main" is pointing to "index.js". Also while we are in here add the line "type": "module" to enable ES6 modules.

The finished package.json will look like below.

{
  "name": "yourbotname",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
}

Now we create another file named .env, this file will have the environment variables. The secrets that we don't want anyone to see.

Just because we are on the topic of secrets, and if you have plans to push the code to GitHub, never push this file .env to GitHub. For that create another file named .gitignore, so that when you do git add and git commit, the .env file is ignored.

.env

Moving on to the .env file, the file will have the following environment variables.

BOT_TOKEN=<your-bot-token-from-discord-application>
DISCORD_CLIENT_ID=<your-application-client-id>
DISCORD_GUILD_ID=<your-server-id>
GITHUB_AUTH_TOKEN=<your-github-auth-pat-token>
GITHUB_USERNAME=<your-github-username>

Before jumping in and creating the index.js file and getting going with coding. Let's figure out how to get BOT_TOKEN, DISCORD_CLIENT_ID, DISCORD_GUILD_ID, and GITHUB_AUTH_TOKEN.

First, let's dive in for the BOT_TOKEN. For that visit the Discord Developer Portal and on the Application page, click on the giant "Blurple" colored button that says New Application.

Before that if you have not turned on the Developer Mode. Please do so by clicking on the gear icon next to your username to get to the User Settings page.

There scroll a bit down while keeping an eye on the left panel items to find the one named Advanced. And then turn that Developer Mode on to become a Developer.

Now that you are a Developer and have the Developer permissions, let's continue with creating a new application.

In the pop-up appearing after clicking the New Application button while you were on the Developer Portal. Enter your dream bot project name (Discord doesn't allow the naming of bots with names containing words like discord, bot, etc.). Select the check box and then proceed by clicking the button that says Create.

On the page that opens after the bot is created. There on the General Information page, you can beautify your bot by adding a profile picture and such.

Then move your eyes through the menu items listed under General Information on the left side panel. Then click on Bot.

While on the page, turn that Public Bot option off, if you don't want people other than you using the bot. Initially, you won't see the Token listed like in the screenshot. But then you will see the Reset Token button, click on that and proceed. And there you will have your Token displayed. Remember it's a secret, a deep secret to be kept secret. Don't ever take a screenshot of that Token post it on a blog article for the world to see.

Copy the TOKEN and paste it into your .env file corresponding to BOT_TOKEN. And keep it a secret.

BOT_TOKEN=MTE1NjQzOTgxNDQ2NDM0MDAxOQ.Gixlqs.HZlLAsfqaQdECiAgQ5v7UE3uec5eoYazliDW1M

Then scroll a bit and under the Privileged Gateway Intents, turn on the option for Message Content Intent. This will allow your bot to see the chat message contents happening on your server.

Now again gaze your eyes through the left panel and click on OAuth2, which is above Bot on the side panel. Here copy CLIENT ID displayed under Client Information.

Then click on URL Generator, which will be in the dropdown that just opened while you clicked OAuth2.

On the screen, where a giant box of checkboxes with scops appears, click the checkmark for bot. Now that would have opened another giant box of checkboxes with Bot Permissions. Here select Administrator. (It is best practice to only provide the permissions that you really intend to use for security purposes.)

Now scrolling to a bit bottom, you will see a URL. That's the generated URL for you to invite your bot to your server. Copy and paste the URL into a new tab of your browser.

On the page that opens select a Server of your choice in which you intend to add the bot. Click Continue. A confirmation page opens asking if you are sure about the permissions that you are giving to this newly born bot. If you are good with it, then click Authorize.

Done, there in you get a success message of your bot being added to the server. Now if you go to your Server and check the members list you will see your bot listed.

Now let's dive back into coding, the bot, and deploying it.

In the index.js file, we will start by doing the imports of the packages we installed.

import 'dotenv/config'
import { Octokit } from 'octokit'
import fetch from 'node-fetch'
import { Client, GatewayIntentBits } from 'discord.js'
import { REST } from '@discordjs/rest'
import { Routes } from 'discord-api-types/v10'
import { SlashCommandBuilder } from '@discordjs/builders'

Then we will initialize both Discord client.

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent
  ]
})

Now to do the same for Ocktokit, that is to initialize Octkokit. We need GitHub PAT (Personal Access Token)

Log in to GitHub and then click on your profile, in the menu, scroll down and select Settings. Now in on your profile page, scroll to the bottom to find the Developer Settings link. That is on the left panel, the last item.

Now you will see a page with GitHub Apps, OAuth Apps, and Personal Access Tokens.

We know what to click here, select Personal Access tokens. In the newly opened sub-menu of items under PAT, click on Tokens (Classic).

On the page, click, Generate New Token and again go for the option of Classic. Now we have to enter a note to understand why created this token when we come back in the future. Then select an expiration for the bot from the dropdown selection. Then we are to carefully select the permissions we need for the bot to work with GitHub with this newly generated access token.

Then we click on the green button at the bottom that says Generate Toke

On the next opened screen, copy your personal access token. It's a one-time thing, you won't be able to see the token again on this page. So save it in your .env, and keep it away from spying eyes. Never share it with anyone.

BOT_TOKEN=MTE1NjQzOTgxNDQ2NDM0MDAxOQ.Gixlqs.HZlLAsfqaQdECiAgQ5v7UE3uec5eoYazliDW1M
DISCORD_CLIENT_ID=7951522907057725878
GITHUB_ACCESS_TOKEN=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

Now that we have got Personal Access Token from GitHub, let's now initialize Octokit.

const octokit = new Octokit({
  auth: process.env.GITHUB_AUTH_TOKEN,
  request: {
    fetch
  }
})

Here we are passing the token from our environment to the auth parameter on the initialization. And also we are setting fetch as our choice request handler for Octokit.

Now we will add a listener to know when our discord client is connected and ready to go ahead and listen for messages.

client.on("ready", () => {
  console.log(`Logged in as MyNewBot!`);
});

Okay, so we have our client-ready code done, which will do a console log, we have our bot token, client ID, and GitHub personal access token.

Now we need the server ID, which you can find by right-clicking on your server name. Then select the last item in the opened menu which says Copy Server ID. Now paste the server ID in the .env file in correspondence to the variable DISCORD_GUILD_ID, and then we are good to go.

We will go back to index.js file. Under the client initialization, we will create a new variable rest and initialize it with the discord rest package we installed by providing the bot token from our .env file.

const rest = new REST({ version: '10' }).setToken(process.env.BOT_TOKEN)

Then we will create our commands in a variable of an array named commands. Find more about command building in the docs provided by discord. We will have two main commands for creating an issue and another command to get all issues.

const commands = [
  new SlashCommandBuilder()
    .setName('issue')
    .setDescription('To deal with github issues')
    .addSubcommand(subcommand =>
      subcommand.setName('create')
        .setDescription('Create a new issue')
        .addStringOption(option =>
          option
            .setName('project')
            .setDescription('Project name')
            .setRequired(true)
        )
        .addStringOption(option =>
          option
            .setName('title')
            .setDescription('Issue title')
            .setRequired(true)
        )
        .addStringOption(option =>
          option
            .setName('description')
            .setDescription('Issue description')
            .setRequired(true)
        )
    )
    .addSubcommand(subcommand =>
      subcommand.setName('get')
        .setDescription('Get all issues from project')
        .addStringOption(option =>
          option
            .setName('project')
            .setDescription('Project name')
            .setRequired(true)
        )
    )
    .toJSON()
];

Now that we have our commands ready, we will write an anonymous function that will invoke at the start of the server and will send the discord server our commands.

(async () => {
  try {
    console.log('Started refreshing application (/) commands.')

    await rest.put(
      Routes.applicationGuildCommands(process.env.DISCORD_CLIENT_ID, process.env.DISCORD_GUILD_ID),
      { body: commands }
    )

    console.log('Successfully reloaded application (/) commands.')
  } catch (error) {
    console.error(error)
  }
})()

/*
The client id and guild id we have in the .env file are passed here
in the arguments along with commands we created in the value of body.
*/

Like we listened for client-ready we will listen for interactions. For that we will use interactionCreate listener and inside we will return without doing anything if the interaction.isCommand check returns false.

client.on('interactionCreate', async (interaction) => {
  if (!interaction.isCommand()) return

  const { commandName, options } = interaction

  if (commandName === 'issue') {
    const subcommand = options.getSubcommand()

    if (subcommand === 'create') {
      const projectName = options.getString('project')
      const issueTitle = options.getString('title')
      const issueDescription = options.getString('description')

      await octokit.rest.issues
        .create({
          owner: process.env.GITHUB_USERNAME,
          repo: projectName,
          title: issueTitle,
          body: issueDescription
        })
        .then(async ({ data }) => {
          await interaction.reply(
          `Issue created in ${projectName} repository with title ${issueTitle}
          Issue URL: ${data.html_url}
          `
          )
        })
        .catch((err) => {
          console.log('err::: ', err)
        })
    } else if (subcommand === 'get') {
      const projectName = options.getString('project')

      await octokit.rest.issues.listForRepo({
        owner: process.env.GITHUB_USERNAME,
        repo: projectName
      })
        .then(async ({ data }) => {
          console.log('data::: ', data)

          const issues = data.map((issue) => issue.html_url)

          await interaction.reply(
          `Fetching issues from ${projectName} repository:
          Done:
          ${issues.join('\n')}
          `
          )
        })
        .catch((err) => {
          console.log('err::: ', err)
        })
    }
  }
})

When we know it's a command and we extract the command name, options from the variable "interact" that we receive in the callback. Then we proceed with our if checks and the steps to create issues and fetch issues with the package Octokit.

That's it, we are all set. The only thing that we need to do now is let the bot client login by passing the bot token.

client.login(process.env.BOT_TOKEN)

Now deploy the bot, visit your discord server, and type / in the chat and see your commands coming alive. Select and enter the parameters. You will receive a reply from the bot telling of its new creation of an issue on your provided repository. Or the list of issues it fetches based on your provided project name.

The easiest forms of deployments are through Heroku or Railway.

Full source code: GithubDiscordBot.

Creating a Discord bot in Nodejs: Create GitHub issues from Discord Chat

Vishnu Dileesh — Thu, 28 Sep 2023 07:44:43 +0000

A Discord bot that can help you create Github issues from the Discord chat, let's begin. Discord bots can also be created to use slash commands, which gives a better user experience.

That was all about installing packages. Now we will move on to some real coding.

Create a project folder with your bot project name. And do npm init, to initialize npm.

NPM is our package manager and all the packages we talked about will be installed through npm commands.

npm install dotenv discord.js node-fetch octokit

The finished package.json will look like below.

{
  "name": "yourbotname",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
}

Now we create another file named .env, this file will have the environment variables. The secrets that we don't want anyone to see.

Just because we talked about secrets, and if you have plans to push the code to GitHub, never push this file .env to GitHub. For that create another file named .gitignore, so that when you do git add and git commit, the .env file is ignored.

.env

Moving on to the .env file, the file will have the following environment variables.

BOT_TOKEN=<your-bot-token-from-discord-application>
GITHUB_AUTH_TOKEN=<your-github-auth-pat-token>

Before jumping in and creating the index.js file and getting going with coding. Let's figure out how to get BOT_TOKEN and GITHUB_AUTH_TOKEN.

First, let's dive in for the BOT_TOKEN. For that visit the Discord Developer Portal and on the Application page, click on the giant "Blurple" colored button that says New Application.

Before that if you have not turned on the Developer Mode. Please do so by clicking on the gear icon next to your username to get to the User Settings page.

There scroll a bit down while keeping an eye on the left panel items to find the one named Advanced. And then turn that Developer Mode on to become a Developer.

Now that you are a Developer and have the Developer permissions, let's continue with creating a new application.

In the pop-up appearing after clicking the New Application button while you were on the Developer Portal. Enter your dream bot project name. Select the check box and then proceed by clicking the button that says Create.

On the page that opens after the bot is created. There on the General Information page, you can beautify your bot by adding a profile picture and such.

Then move your eyes through the menu items listed under General Information on the left side panel. Then click on Bot.

Copy the TOKEN and paste it into your .env file corresponding to BOT_TOKEN. And keep it a secret.

BOT_TOKEN=MTE1NjQzOTgxNDQ2NDM0MDAxOQ.Gixlqs.HZlLAsfqaQdECiAgQ5v7UE3uec5eoYazliDW1M

Then scroll a bit and under the Privileged Gateway Intents, turn on the option for Message Content Intent. This will allow your bot to see the chat message contents happening on your server.

Now again gaze your eyes through the left panel and click on OAuth2, which is above Bot on the side panel. Therein click on URL Generator, which will be in the dropdown that just opened while you clicked OAuth2.

Now scrolling to a bit bottom, you will see a URL. That's the generated URL for you to invite your bot to your server. Copy and paste the URL into a new tab of your browser.

And on the page that opens select a Server of your choice in which you intend to add the bot. Click Continue. A confirmation page opens asking if you are sure about the permissions that you are giving to this newly born bot. If you are good with it, then click Authorize.

Done, there in you get a success message of your bot being added to the server. Now if you go to your Server and check the members list you will see your bot listed.

Now let's dive back into coding, the bot, and deploying it.

In the index.js file, we will start by doing the imports of the packages we installed.

import 'dotenv/config'
import { Octokit } from 'octokit'
import fetch from 'node-fetch'
import { Client, GatewayIntentBits } from 'discord.js'

Then we will initialize both Discord client.

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent
  ]
})

Now to do the same for Ocktokit, that is to initialize Octkokit. We need GitHub PAT (Personal Access Token)

Now you will see a page with GitHub Apps, OAuth Apps, and Personal Access Tokens.

We know what to click here, select Personal Access tokens. In the newly opened sub-menu of items under PAT, click on Tokens (Classic).

Then we click on the green button at the bottom that says Generate Token.

BOT_TOKEN=MTE1NjQzOTgxNDQ2NDM0MDAxOQ.Gixlqs.HZlLAsfqaQdECiAgQ5v7UE3uec5eoYazliDW1M
GITHUB_ACCESS_TOKEN=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

Now that we have got Personal Access Token from GitHub, let's now initialize Octokit.

const octokit = new Octokit({
  auth: process.env.GITHUB_AUTH_TOKEN,
  request: {
    fetch
  }
})

Here we are passing the token from our environment to the auth parameter on the initialization. And also we are setting fetch as our choice request handler for Octokit.

Now we will add a listener to know when our discord client is connected and ready to go ahead and listen for messages.

client.on("ready", () => {
  console.log(`Logged in as MyNewBot!`);
});

// we will also ! mark as our prefix to identify the message commands
const prefix = "!";

Okay, so we have our client ready code done, which will do a console log, we have our bot token, our GitHub personal access token, and the exclamation mark as a prefix set.

We will do the on message listening to check if a message is our command to create some GitHub issues.

So how do we want the bot to work?

The message should have a prefix of !. And then the word "mybot" or something like that to identify. Let's go with "gdbot" (GitHub Discord Bot?).

And then we need arguments like repository name and issue name.

So the message will look like:

!gdbot my_repository_name issue_name_that_i_choose

client.on("messageCreate", async (msg) => {
  if (msg.author.bot) return; // if message is by a bot, ignore

  // checking if the message has a prefix to ensure it's our command
  if (!msg.content.startsWith(prefix)) return;

  // remove the prefix from the message
  const commandBody = msg.content.slice(prefix.length);

  // then we split and turn the first item to lower case
  const commands = commandBody.split(" ");

  const command = commands[0].toLocaleLowerCase();

  // other items in the message we will treat as argument
  const args = commands.slice(1);

  // !gdbot <repository name> <issue name>

  if (command === "gdbot") {
    await octokit.rest.issues
      .create({
        owner: "YourGitHubUsername",
        repo: args[0],
        title: args[1],
        body: "Issue created using my new discord bot!",
      })
      .then(async ({ data }) => {
        await msg.channel.send(
          `Issue created in ${args[0]} repository with title ${args[1]} \n
          Issue URL: ${data["html_url"]} \n
          `
        );
      })
      .catch((err) => {
        console.log(err);
      });
  }
});

The above code, checks if the command is "gdbot". Then if it is, we proceed with creating an issue using the Octokit SDK where we will pass the owner parameter value as our GitHub username. And then the repository name as the first item in our extracted args variable. And title parameter value is the second item in the args, which is the issue name.

When the issue is created successfully our bot will send in a message in the server channel, saying the issue has been created with a link to the newly created issue.

Then below the code that does all the magic of listening to the command and creating an issue. We need to make the bot login with the bot token.

client.login(process.env.BOT_TOKEN)

That's it we have our bot ready. Now the next part is to deploy the project to a server.

The easiest forms of deployments are through Heroku or Railway.

Full source code: GithubDiscordBot.

Linux Rice (Coder edition)

Vishnu Dileesh — Sat, 21 Nov 2020 06:27:54 +0000

Operating System: MX Linux
Desktop Environment: XFCE
Window Manager: i3wm
Status bar: i3status
Launcher: dmenu / rofi
Notification: dunst
File Manager: Thunar / NNN / Ranger
Browser: QuteBrowser / Chrome / Firefox
Text Editor: NeoVim / VS Code / Geany
Terminal: xfce4-terminal / Hyper
Shell: ZSH / BASH
Word Processor: FeatherPad
Document Viewer: mupdf
Video Player: MPV / VLC
Music Player: CMUS
Podcast: Clementine
Music Visualizer: CAVA
Audio Controller: Pavucontrol
Image Viewer: FEH / NOMACS
Password Manager: ButterCup
Screen Recorder: Kazam
Screenshot: Flameshot
System Info: Neofetch
Process Viewer: htop
Version Control: git
Color Schemes: pywal
Wallpapers: IG acc: codingwitharman Wallpaper Drive

DOTFILES: Linux rice Coder Edition

Host nodejs Discord bot for free

Vishnu Dileesh — Sun, 15 Nov 2020 06:54:12 +0000

After going through the basic steps of setting up a bot in Discord's Application Dashboard Building a Discord Bot (Basic Setups) and inviting it to our server.

We went ahead with coding the functionality of the bot
Build a Discord Bot using Nodejs - Project 01 and our bot is all set to be hosted to the cloud.

Well if you want to be a little fancy, you could also host your bot on a raspberry pi or you could host it on your laptop and set it to run 24/7.

But for the sake of simplicity, we will be hosting our bot on Heroku in a free tier account. The hosting procedure will stay the same even if you use a paid tier or free tier. But in the case of the free tier, your bot has a quota limit of 550hours/month. So your bot will only stay online for roughly 22days in a month. Verifying your account with a credit card will add an extra 450hours to your quota.
Or you could choose to go ahead with a hobby tier which costs around 7$ per month.

So set up an account in Heroku, and will host our bot in a free tier.

Before heading over to Heroku, let's first jump into our project folder and get it ready for hosting.

Create a new file named Procfile

Procfile is a file that specifies the commands that are executed by the app on startup. The file is needed by Heroku.
The Procfile is always a simple text file that is named Procfile without a file extension. For example, Procfile.txt is not valid.
Check out the docs to know more

worker: node index.js

Heroku offers two dynos web and worker, the web is suited for hosting web apps and the worker is for hosting scapers and bots. The difference is anything hosted on the web will take a small nap in-betweens, and in our scenario, we can't afford our bot to be sleeping while the user tries to invoke it, so we need to use the worker.

Procfile will let Heroku know which dynos to activate.

Now it is time to push your code to GitHub, make sure you have gitignored .env files or any file that contains secret tokens.

After pushing your project code to GitHub, jump into the Heroku dashboard.

Inside the dashboard, click New and from the dropdown select create new app.

Now type in the app name of your choice, and check if it is available to use. If not available try out different combinations of names. If you want you could also pick and change the hosting region from the United States to Europe. Then click create app.

Now on the app's dashboard page, click the connect to GitHub option.

After selecting Connect to GitHub option, you will be able to pick a GitHub account and a project repository to connect.

Search for your project and click Connect to connect your project to Heroku.

Click on Deploy Branch under manual deploy, you could also use the automatic deploy option.

If it is all green ticks, well then things look pretty successful.

Then navigate to the Overview page. You can see it says Build Successful and Deployed under Latest activity. But if you look to the left, under dyno formation. You can see Heroku has chosen the web as the default dyno. We need to change it to the worker to ensure the bot stays awake all the time under our free quota.

Navigate to the Resources page to change the running dyno.

Click on the edit button on the web dyno, then turn it off and click confirm.

Now time to activate our worker dyno, click on the edit button on the worker dyno, then turn it on and click confirm.

On navigating back to the Overview page, now we can see the worker dyno is running successfully.

And this is the moment, we expect to see our bot coming online in our server. But sadly on checking our discord server, we will see that the bot is still offline. Well, the issue is that the bot running on Heroku is not aware of the secret token needed for logging into our server.

Remember the secret token is never pushed to GitHub so it is not available for the instance running on Heroku. So we need to pass the token to our instance from the dashboard.

Navigate to the Settings page, here you will see some of the information about our running app.

Scroll down to the Config Vars section and click the Reveal Config Var button.

And here it says, There are no config vars for this app yet. Well, it is true, as we have not yet set any. But let's do that part now.

In the place of Key use the one, we used in our .env file. In my case I used BOT_TOKEN and for the token value, you can find it in Discord's Application Dashboard.

And then click Add, and depending on your project, if you are using any other secrets token, also add them in here.

Now navigate back to the Deploy page and click Deploy Branch again to make sure that the newly provided tokens are used by the bot.

And that's it, your bot is live on the cloud, ready to serve your Discord server.

If you are getting errors, no worries, errors are part of the journey. Google is your friend, try some googling and scavaging around StackOverflow.

Still not able to resolve the error and get the bot working?
Well free to connect and let's figure it out.

Connect on LinkedIn
Connect on Instagram

Comment below your thoughts and bugs

Happy Coding
Keep Coding

Building Discord Bot using Nodejs - Project 01

Vishnu Dileesh — Sat, 14 Nov 2020 16:16:15 +0000

Project Idea:
Inspiration quotes are as important as your daily dose of coffee to keep yourself motivated enough to deal with your day to day challenges.
So let's build a bot, which gives a dose of random inspiration quote every time a user types in the command !inspire in our discord server.

The basic steps required to be done in the Discord's Application Dashboard before jumping into coding is written in the below-linked Article

Building a Discord Bot (Basic Setups)

Okay, so we have gone through all the steps mentioned in the above article. Now it's time to jump into doing some actual coding.

Step 1:

Open your terminal and create a new project folder.
Inside the project folder initialize npm

npm init -y

When the initialization is done you will have a package.json file in your folder.

Great now let's install discordjs and dotenv npm packages.

discord.js is a powerful node.js module that allows you to interact with the Discord API very easily.

Dotenv is a zero-dependency module that loads environment variables from a .env file into process.env.

Run the below command to install the packages
npm install discord.js dotenv

Awesome, so now we have the packages installed.
Now let's make two files in our project folder.
This is the time to open the project in your choice of text editor.

The first file is the .env file, We will store our bot token in this file. This file is never pushed to Github or not the content of the files is shared with anyone. Anyone who gets access to that secret token can log in to your server as the bot and can do malicious activities.

BOT_TOKEN=<copy-pasted-token-value-here>

The token is found on Discord's Application dashboard under the bot information page.

Great, so now our .env file is all set. Let's move on to the real action.

Create a new file named index.js

const Discord = require('discord.js')
const client = new Discord.Client()

const config = require('dotenv').config()

In the above code, we are first importing the discord.js package, initializing it, and storing it in a constant named client.
Then we are importing and activating dotenv to deal with our secrets.

const quotes = [
  'Chase the vision, not the money; the money will end up following you. — Tony Hsieh',
  'Don’t worry about failure; you only have to be right once. — Drew Houston',
  'Ideas are commodity. Execution of them is not. — Michael Dell',
  'If you are not embarrassed by the first version of your product, you’ve launched too late. — Reid Hoffman',
  'I knew that if I failed I wouldn’t regret that, but I knew the one thing I might regret is not trying. — Jeff Bezos',
]

const randomQuote = () => quotes[Math.floor(Math.random() * quotes.length)]

Okay, now it's time to set up our inspirational quotes. If you want you could get innovative and use some available inspiration quotes API services. Here, am going humble, and gonna store the quotes in an Array named quotes. Also created a simple anonymous function named randomQuote to do some magic and pickup random quote from the array of quotes.

client.on('ready', () => {
  console.log('Inspire Bot running')
  console.log(randomQuote())
})

Client.on ready function lets us do stuff when the bot successfully logs in and is ready to go wild in our server. Here, am just console logging a message and a random quote because am superstitious. You could also get innovative and maybe make the bot add a message to your channel saying, the bot is all ready to spread some motivational vibes.

const prefix = "!"

Okay, so what is the prefix? Well, prefix could literally be anything. It is all about how we want our bot to be invoked by the users. Here we are going for the exclamation point, I might have just gone ahead with maybe a dollar symbol?. It doesn't matter, just choose one.

client.on('message', (msg) => {

  if(msg.author.bot) return
  if(!msg.content.startsWith(prefix)) return

  const commandBody = msg.content.slice(prefix.length)

  const command = commandBody.toLowerCase()

  if(command === 'inspire'){
    msg.reply(randomQuote())
  }

})

Just like client.on ready, client.on message, let us do some stuff when someone writes a message on our server. So, what do we wanna do, when a new message comes up?

First, let's check if the author of the message is a bot. If so do nothing, stay quiet.

Second, If the message doesn't start with a prefix (the exclamation point in our case) just ignore and do nothing.

Third, let's extract the command from the message by removing the prefix from the start of the message. So if the message was !inspire, we will extract the word inspire and will store it in a variable named commandBody.

Fourth, This is an optional step, oftentimes, your bot will have multiple commands to deal with so this step just allows you to do that check. So we are converting the commandBody to lowercase and storing it in a variable named command. Then we are doing an if check to see if the command is equal to the word inspire. Again you could come up with any command names, here am just choosing to call my command inspire.

When the command is - inspire, we are replying to the message with our randomly generated inspirational quote.
msg.reply will make sure that the bot replies directly to the user who invoked and asked for the inspirational vibe.

Now our bot is all set to spread some inspirational vibes in our discord server. All that now required to do is to let the bot login to our server.

client.login(process.env.BOT_TOKEN)

Bot needs the secret token to do the login. Remember we have the token all hidden on our .env file. To use it in our index.js file and pass it to client.login function we have earlier imported and activated dotenv package. That lets us call the token here without revealing it to anyone by calling process.env.BOT_TOKEN.

To run the bot locally on your system, open your terminal in the project folder and run the below command

node index.js

Also in the package.json file, we will add a start script.

"scripts": {
 "start": "node index.js"
}

Now you can run the bot by using either of the below commands

node index.js

npm run

Once the bot successfully logs in and all ready to go, we will see our console message, also in the discord server, the bot will appear online.

Try invoking the bot by sending the below message to your discord server.

And if all went well, you will get an inspirational quoted reply from your bot. If you are getting errors, no worries, errors are part of the journey. Google is your friend, try some googling and scavaging around StackOverflow.

Full source code on GitHub

Still not able to resolve the error and get the bot working?
Well free to connect and let's figure it out.

Connect on LinkedIn
Connect on Instagram

Comment below your thoughts and bugs

Happy Coding
Keep Coding

Building a Discord Bot (Basic Setups)

Vishnu Dileesh — Thu, 12 Nov 2020 06:53:29 +0000

Discord bots are a great way to add engagement to the servers. They are also fun to build and share with friends.

I always love to keep the official docs open for quick reference
https://discordjs.guide/
This tutorial from Digital Ocean was very handy while I got started
Digital Ocean Nodejs Discord Bot - tutorial

Before jumping into coding, we first need to set up a discord bot using the discord's application dashboard

Create an App by clicking the button - New Application

Now click on the button - Bot

On bot page - click on the button - Add Bot

Now we are on the newly added Bot page, here we can see information on our bot, including secrets like Token, which has to be kept a secret. They are never meant to be shared with anyone.

Now let's invite the bot to our server, click on the button - OAuth2. On the 0Auth2 page choose scope as bot and bot permissions as Administrator

Copy the link and paste it on a new tab in your browser, and select the server in which you want to add your newly born baby bot

Then approve the needed permissions for the bot to function on your server of choice and click Authorize

Ones Authorized, your bot is all set to bring joy to your Discord Server.

For the bot to be functional we need to do some actual coding
In future posts, We will do a walkthrough of building Discord bots

If you got any Discord Bot ideas, comment below

Serve scraped data through API— FastAPI

Vishnu Dileesh — Sun, 27 Sep 2020 05:44:24 +0000

In our previous project, we used python's requests-html library to scrape through the website (thehackernews.com) to go and fetch all the latest articles from every category. The project was just simply printing out the title & link of every article to the terminal.

In this project, we will serve the scraped data through an API using python 's FastAPI framework. We will also do some tweaks to the way the scraping is done to make it easy to serve the data & in activating the scraping.

So let's get started by cloning the THN_scraper project to our system.

git clone https://github.com/VishnuDileesh/THN_scraper

After moving into the folder, let's create a virtual environment to install our packages.

python3 -m venv env

source env/bin/activate

After activating the environment, let's install the needed packages from our requirements.txt

pip3 install -r requirements.txt

Now let's try running the project by calling the following command in our terminal.

python3 main.py

On running the project we will get the above output in our terminal. Now that means we are all good with setting up our base project. Now let's get started in serving the data through API.

We will start by renaming our main.py file to scraper.py

Once the renaming is done we need to make few tweaks in our scraper.py file

def scrapeData():

    datas = []

    for category in categories:

        category = CategoryScrape(f'{baseURL}{category}', category)

        category.scrapeArticle()


def getScrapedData():

    return datas

Here, we are putting the scrape loop in a function named scrapeData, so that we could call the function from our API endpoint, to do the real scraping of the data. Also, we are creating another function named getScrapedData to receive the scraped data in our API endpoint to serve.

Now, all our work is done here in the scraper.py file. Let's move forward by creating a new file named main.py, which will house all our API code.

Let's not forget to install FastAPI and uvicorn in our project.

pip3 install fastapi uvicorn

Now when we have everything installed, let's also update our requirements.txt file to reflect our newly installed packages

pip3 freeze > requirements.txt

from fastapi import FastAPI, BackgroundTasks
from scraper import scrapeData, getScrapedData

app = FastAPI()


@app.get("/")
async def index():
    """ index route """

    return {
        "get-data": "visit /get-data to get scraped data",
        "scrape-data": "visit /scrape-data to activate scraping"
    }

In our main.py, we start by importing FastAPI and BackgroundTasks from our installed fastapi framework. Then we need to import the functions scrapeData and getScrapedData from our scraper.py file.

Then we create an app object by initializing the import FastAPI(), we start by creating our first route, which will simply return a very simple JSON response.

@app.get("/get-data")
async def get_data():
    """ Get all scraped data as in json by visiting /get-data """
    return getScrapedData()


@app.get("/scrape-data")
async def scrape_data(background_tasks: BackgroundTasks):
    """ On doing a get request to '/scrape-data' you Activates scraping """

    background_tasks.add_task(scrapeData)

    return {"Status": "Activated Scraping"}

In our get-data route, we call getScrapedData function, which was imported from scraper.py file. The route will return all the data we scraped from the website (thehackernews.com)

In scrape-data route, we pass the scrapeData function, which we imported from scraper.py into the background_tasks. Which in return activates our scrapeData function, making the script run and do all the scraping magic to get the latest hacking news articles.

Now, we have our API ready to be served on a web server. We will use uvicorn as our web server. Let's create a new file named run.py, which will have the webserver configuration.


import uvicorn

if __name__ == "__main__":

    uvicorn.run("main:app",
                host='0.0.0.0',
                port=8000,
                reload=False,
                debug=False,
                workers=25)

Here in our run.py file, we are importing our installed unicorn. And then we are initializing the file, calling the function uvicorn.run, in which we are passing in our app (which we initialized in main.py file), and also we are specifying host and port for uvicorn to serve. And we are setting reload and debug to false, as they are development settings. With the workers parameter we can set the number of workers to be run for the server to handle.

So, that's all the code we needed for the project. Now we can go ahead and run the project by running the command in terminal

python3 run.py

Link to project GitHub repo:

VishnuDileesh / THN_scraper_api

A web API that scrapes and list out latest articles in all categories from the website (thehackernews.com)

Happy Coding, Keep Coding
Connect with me on LinkedIn
Connect with me on Instagram

Python web scraping — requests-html

Vishnu Dileesh — Sat, 08 Aug 2020 11:33:52 +0000

Web scraping is the process of extracting data from websites. To refine my skills I choose to do multiple projects using some of the awesome python libraries. For this project, we are using requests-html, which the creators describe as HTML parsing for humans.

The project idea is very minimal and the goal is to get basics of using requests-html library. We are going to scrape through all categories in thehackernews.com website and get all the titles and links of the latest articles. To keep things simple, we are going to print out the story titles and links to the terminal.

So let's get started by creating a new project folder (am naming the folder thn_scraper)

mkdir thn_scraper

Change into the folder and create a python virtual environment

cd thn_scraper

python3 -m venv env

Activate the environment & install the packages

source env/bin/activate

pip3 install requests-html

Let's start by creating file named main.py

nvim main.py (am using neovim, u can use any editor of your choice)

from requests_html import HTMLSession

session = HTMLSession()

baseURL = 'https://thehackernews.com/search/label/' 

categories = ['data%20breach', 'Cyber%20Attack', 'Vulnerability', 'Malware']

First, we are importing HTMLSession function from the requests_html library we just installed. Also, we are initializing HTMLSession(). We also store the website URL to a variable baseURL. We are also storing the categories in a list.

class CategoryScrape():
    catURL = ''     
    r = ''
    def __init__(self, catURL, category):         
        print(f'Scraping starting on Category : {category} \n')  
        print(' ')         
        self.catURL = catURL         
        self.r = session.get(self.catURL)

Here, we are creating class named CategoryScrape, which has initialization function which takes in two parameters catURL and category. We are also calling session.get in here, and passing the catURL. The response is then stored on a variable named r.

def scrapeArticle(self):         
        blog_posts = self.r.html.find('.body-post')         
        for blog in blog_posts:             
            storyLink = blog.find('.story-link', first=True).attrs['href']
            storyTitle = blog.find('.home-title', first=True).text
            print(storyTitle)
            print(storyLink)             
            print("\n")

The class also has a function named scrapeArticle, which has all bells and whistles to parse through the HTML and look for a list of articles and then scrape titles and links of individual articles. Once the data is scraped for each article, the story title and link are printed out into the terminal.

for category in categories:     
    category = CategoryScrape(f'{baseURL}{category}', category)
    category.scrapeArticle()

Now, once we have the class and its functions ready, we are going to do a loop on for every category in the list named categories. And for in every loop, we will create a new object with the category name and will initialize it with the class, CategoryScrape. We also pass in the URL and category name. Then we call the scrape function on the object we created.
So, all the code we needed for the project. Now we can go ahead and run the project by running the command in terminal

python3 main.py

VishnuDileesh / THN_scraper

Happy Coding, Keep Coding
Connect with me on Instagram