DEV Community: Muhammad ABir

How to Automatically Remove All LinkedIn Connections with Python

Muhammad ABir — Wed, 13 Nov 2024 15:08:37 +0000

Are you tired of manually removing LinkedIn connections one by one? It can be time-consuming and frustrating, especially if you have hundreds or even thousands of connections that you no longer need. Well, I’ve created a solution for you!

With this Python script, you can automatically remove unwanted LinkedIn connections with just a few lines of code. This script uses Selenium to interact with LinkedIn’s web interface, mimicking human behavior, and automating the process of removing connections. No need to worry about account bans, as the script simulates human-like interaction with pauses between actions.

Key Features:

Automates the Removal of LinkedIn Connections: Save time by removing unwanted connections in bulk.
Human-Like Interaction: The script waits between actions, ensuring that LinkedIn doesn’t flag your account for suspicious activity.
Easy to Use: Simply input your login credentials, run the script, and let it do the rest!

How It Works:

Login to LinkedIn: The script logs into your LinkedIn account using your email and password stored in an .env file for added security.
Navigate to Connections Page: It goes directly to your LinkedIn connections page, where all your connections are listed.
Click and Remove: For each connection, the script clicks the "More" button, selects "Remove Connection," and confirms the removal.
Continuous Removal: The script continues to remove connections one by one with pauses between actions to simulate human behavior.

How to Use:

Clone the repository or download the script from the GitHub link.
Set up your environment by installing the required dependencies and creating a .env file with your LinkedIn credentials.
Run the script, sit back, and let it do the work!

Requirements:

Python 3.10.x
Selenium
Firefox

Final Words:

This script is a simple yet powerful tool for anyone who needs to clean up their LinkedIn connections. Whether you’ve added people by mistake or just want to declutter your network, this script will save you time and effort.

If you found this post helpful, make sure to like and comment below. Don’t forget to check out the full script on Blog and watch the video tutorial here.

Happy coding! 🚀

Sending Emails with Queues in Node.js - Improve Your App’s Email Deliverys

Muhammad ABir — Wed, 06 Nov 2024 14:14:39 +0000

Why You Need an Email Queue System in Node.js for Scalable, Fast Email Delivery

When building modern web applications, handling email communication is a critical feature. Whether you're sending verification emails, password resets, or notifications, ensuring fast and reliable delivery is essential. However, sending emails directly from the application can slow down your user experience and increase server load. This is where email queues come in—offering a solution to these challenges while improving overall performance.

In this article, we’ll explore how you can implement an email queue system in Node.js, why it’s important, and how it can drastically improve your app’s email delivery process.

Setting Up an Email Queue in Node.js

Let’s dive into how you can implement an email queue system using Node.js and Bull, a popular queue library for handling jobs in Node.js.

1. Install Required Packages

npm init -y
npm i express nodemailer ioredis bull dotenv

nodemailer is used for sending emails.
bull is a powerful job queue library for Node.js.
dotenv is used for managing environment variables.

File Structure

-root
 |-lib
   |-emailService.js       # Handles email sending logic
   |-emailQueue.js         # Manages the email queue
-server.js                 # Main server file to run the app
-package.json              # Contains app dependencies and scripts
-package-lock.json         # Ensures consistent dependency versions
-.env                      # Stores sensitive data like email credentials and Redis config

In this structure:

emailService.js will handle the actual logic for sending emails.
emailQueue.js will manage the queue where email jobs are placed and processed.
.env will store sensitive information like email credentials and Redis configuration.

Inside .env file

REDIS_HOST=127.0.0.1
REDIS_PORT=6379

MAIL_HOST=
MAIL_PORT=
MAIL_USER=
MAIL_PASS=

2. Create the Email Service (lib/emailService.js)

The emailService.js file will contain the logic to send emails using Nodemailer:

const nodemailer = require("nodemailer");
require("dotenv").config();

const transporter = nodemailer.createTransport({
  host: process.env.MAIL_HOST,
  port: process.env.MAIL_PORT,
  secure: true,
  auth: {
    user: process.env.MAIL_USER,
    pass: process.env.MAIL_PASS
  }
});

exports.sendEmail = async (emailOptions) => {
  return await transporter.sendMail(emailOptions);
};

3. Create the Email Queue (lib/emailQueue.js)

The emailQueue.js file will set up the queue and process email jobs using Bull:

const Queue = require("bull");
const emailService = require("./emailService");
require("dotenv").config();

const emailQueue = new Queue("emailQueue", {
  redis: {
    host: process.env.REDIS_HOST,
    port: process.env.REDIS_PORT
  },
  limiter: {
    max: 10,
    duration: 1000
  }
});

// Process emails in the queue
emailQueue.process(async (job) => {
  console.log(`Processing job ${job.id} for ${job.data.to}`);
  try {
    const { to, subject, text, html } = job.data;
    const emailOptions = { from: process.env.MAIL_USER, to, subject, text, html };
    await emailService.sendEmail(emailOptions);
    console.log(`Email sent to ${to}`);
  } catch (error) {
    console.error(`Error sending email: ${error.message}`);
    // Automatically retry failed jobs (up to 3 attempts)
    if (job.attemptsMade < 3) throw error;
  }
});

// Error handling
emailQueue.on("failed", (job, err) => {
  console.error(`Job ${job.id} failed: ${err.message}`);
});

module.exports = emailQueue;

4. Create the Email Queue (lib/emailQueue.js)

The server.js file is the entry point of your application. It will set up the routes and initiate the email queue:

const express = require("express");
const emailQueue = require("./lib/emailQueue");

const app = express();
app.use(express.json());

// Sample route to trigger email sending
app.post("/signup", async (req, res) => {
  const { username, email, password } = req.body;

  // signup logics here 

  // Generate a 6-digit OTP
  const otp = Math.floor(100000 + Math.random() * 900000).toString();
  const otpExpiresAt = new Date(Date.now() + 5 * 60 * 1000); // OTP expires in 5 minutes

  // Add email to the queue
  await emailQueue.add({
    to: email,
    subject: "Verify Your Email",
    text: `Your verification code is: ${otp}`,
    html: `<p>Your verification code is: <strong>${otp}</strong></p>`
  });

  res.json({ message: "Signup successful. Please check your email for the OTP verification code." });
});

app.listen(8000, () => {
  console.log("Server is running on port 8000");
});

Why Email Queues are Essential

Using an email queue system in your Node.js application provides several benefits:

Non-blocking Operations: Email sending is offloaded to a background process, preventing it from blocking the main application thread. This leads to a faster, more responsive user experience.
Scalability: As your application grows and the volume of emails increases, email queues allow you to scale efficiently by processing emails in the background without overloading your system.
Reliability: Email queues often come with retry mechanisms, ensuring that emails are reattempted in case of failure, and preventing the loss of critical messages.
Optimized Server Performance: By handling emails asynchronously, you can better manage server load, reduce latency, and avoid timeouts, especially when your application experiences traffic spikes.

Conclusion

Implementing an email queue system in Node.js is a simple yet powerful way to optimize email delivery, improve server performance, and provide a seamless user experience. By offloading email sending to a background process, you can avoid blocking your main application flow, ensuring that your users don’t face slow loading times or interrupted services. Whether you're sending OTPs, password reset emails, or notifications, an email queue can enhance scalability, reliability, and overall performance, keeping your app running smoothly even as your user base grows.

For the complete code, visit the GitHub repository, and don’t forget to watch the full tutorial for an in-depth, hands-on guide.

Regex Simplified: The Art of Pattern Matching with Regular Expressions

Muhammad ABir — Sat, 11 Feb 2023 07:08:52 +0000

Regular expressions (regex) are a powerful tool for matching and manipulating strings. They are used in many programming languages, including Python, JavaScript, Perl, and Ruby, to name a few. Regex patterns are used to search, match, and replace text, and they are an essential part of many text processing applications.

A regex pattern is a combination of characters that define a searchable pattern. It consists of literal characters and special characters known as metacharacters. Literal characters, such as letters, numbers, and symbols, match themselves exactly. Metacharacters, on the other hand, have special meaning and are used to match specific types of characters or groups of characters. Some common metacharacters include:

: Escapes a special character, making it a literal character
. Matches any single character except for a newline
* Matches zero or more occurrences of the preceding character or group
+ Matches one or more occurrences of the preceding character or group
? Matches zero or one occurrence of the preceding character or group
^ Matches the beginning of a line
$ Matches the end of a line
[] Matches any character within the brackets
[^] Matches any character not within the brackets
{m,n} Matches between m and n occurrences of the preceding character or group
( ) Grouping characters and capturing groups
| Alternation, matches either the expression before or the expression after the |
\d Matches a digit (equal to [0-9])
\D Matches a non-digit (equal to [^0-9])
\w Matches a word character (equal to [a-zA-Z0-9_])
\W Matches a non-word character (equal to [^a-zA-Z0-9_])
\s Matches a whitespace character (equal to [\t\n\r\f\v ])
\S Matches a non-whitespace character (equal to [^\t\n\r\f\v ])
\b Matches a word boundary
\B Matches a non-word boundary
\A Matches the beginning of the string
\Z Matches the end of the string, or before the newline at the end of the string
\z Matches the end of the string

Regex patterns are used with the match(), search(), and sub() functions in most programming languages. The match() function matches the pattern at the beginning of the string, while the search() function scans the entire string for the first occurrence of the pattern. The sub() function is used to replace matched patterns with new text.

One of the key benefits of using regex is its ability to match complex patterns with a single expression. For example, you can use a regex pattern to match email addresses, URLs, phone numbers, and more. Regex patterns can also be used to validate user input, such as checking if a string is a valid password.

It's important to note that regex can become complex and difficult to read, especially when matching multiple patterns or using complex expressions. In these cases, it's a good idea to break down the pattern into smaller parts and test each part individually.

In conclusion, regex patterns are an essential tool for text processing and manipulation. They allow developers to match and manipulate strings with great precision, saving time and reducing the number of lines of code required. Whether you're a seasoned developer or just starting out, it's important to familiarize yourself with regex and add it to your toolkit.

here is an simple example of regex in different language:

in python

import re

# Match email addresses
email = "example@gmail.com"
pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
match = pattern.search(email)
if match:
    print("Email found:", match.group())
else:
    print("Email not found.")

in javascript

const email = "example@gmail.com";
const pattern = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/;
const match = email.match(pattern);
if (match) {
    console.log("Email found:", match[0]);
} else {
    console.log("Email not found.");
}

In these examples, the regular expression [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} matches a string that starts with one or more characters that are letters, digits, ., _, %, +, or -, followed by an @ symbol, followed by one or more characters that are letters, digits, ., or -, followed by a . symbol and then two or more characters that are letters.

The Ultimate MongoDB Command Cheatsheet for Developers

Muhammad ABir — Fri, 10 Feb 2023 18:00:00 +0000

This MongoDB command cheatsheet is the perfect tool for developers who want to work more efficiently and effectively with MongoDB. With 50 of the most commonly used MongoDB commands, this reference guide provides quick and easy access to the information you need to get the job done. Whether you're new to MongoDB or an experienced user, this cheatsheet will help you streamline your development process and maximize your productivity. So, if you want to take your MongoDB skills to the next level, be sure to get this must-have cheatsheet today!

use <database> switch to a specific database
show dbs list all available databases
db.createCollection(<collection_name>) create a new collection
db.<collection_name>.insertOne(<document>) insert a single document into a collection
db.<collection_name>.insertMany([<document1>, <document2>, ...]) insert multiple documents into a collection
db.<collection_name>.find() query all documents in a collection
db.<collection_name>.findOne() query a single document in a collection
db.<collection_name>.find(<filter>) query documents in a collection using a filter
db.<collection_name>.findOne(<filter>) query a single document in a collection using a filter
db.<collection_name>.updateOne(<filter>, <update>) update a single document in a collection
db.<collection_name>.updateMany(<filter>, <update>) update multiple documents in a collection
db.<collection_name>.deleteOne(<filter>) delete a single document from a collection
db.<collection_name>.deleteMany(<filter>) delete multiple documents from a collection
db.<collection_name>.aggregate(<pipeline>) perform aggregation operations on a collection
db.<collection_name>.count() count the number of documents in a collection
db.<collection_name>.drop() delete a collection and its data
db.<collection_name>.createIndex(<field>, <options>) create an index on a field in a collection
db.<collection_name>.ensureIndex(<field>, <options>) ensure an index on a field in a collection
db.<collection_name>.getIndexes() list all indexes for a collection
db.<collection_name>.dropIndex(<index>) delete an index from a collection
db.<collection_name>.dropIndexes() delete all indexes from a collection
db.<collection_name>.reIndex() rebuild all indexes for a collection
db.<collection_name>.explain() provide execution statistics for a query
db.runCommand({<command>}) run a database command
db.getCollectionNames() list all collections in a database
db.getProfilingLevel() get the current profiling level
db.setProfilingLevel(<level>) set the profiling level
db.system.profile.find() query the system.profile collection
db.currentOp() display current in-progress operations
db.killOp(<opid>) kill a specific operation
db.serverStatus() display server status information
db.printCollectionStats() display statistics for a collection
db.repairDatabase() repair a database and its collections
db.cloneDatabase(<source>, <target>) clone a database to a new target database
db.copyDatabase(<source>, <target>) copy a database from a source to a target host
db.shutdownServer() shut down the MongoDB server
db.listDatabases() list all databases on the MongoDB server
db.stats() display database statistics
db.version() display the version of the MongoDB server
db.eval(<function>) evaluate a JavaScript expression on the server
db.loadServerScripts() load scripts stored in the `db.system.js collection
db.auth(<username>, <password>) authenticate as a specific user
db.logout() log out of the current user session
db.getUser(<username>) get information about a specific user
db.createUser(<user>) create a new user
db.updateUser(<username>, <user>) update an existing user
db.dropUser(<username>) delete a user
db.grantRolesToUser(<username>, <roles>) grant roles to a user
db.revokeRolesFromUser(<username>, <roles>) revoke roles from a user
db.getRole(<role>) get information about a specific role.

Unlocking the Power of the Windows Command Prompt: 50 Must-Know Commands

Muhammad ABir — Fri, 10 Feb 2023 09:53:45 +0000

Unleash the full capabilities of your Windows system with this guide to 50 underutilized Command Prompt commands. From network management to system information, these powerful yet lesser-known commands will help you streamline your workflow and get the most out of your Windows experience. Whether you're a seasoned user or just starting to explore the command line, this list has something for everyone.

ping Tests connectivity to a networked device.
tracert Displays the path taken by packets to reach a networked device.
ipconfig Displays the configuration of the network adapter.
nslookup Queries DNS servers for information about a domain name.
netstat Displays active network connections and their status.
tasklist Displays a list of running processes and their information.
taskkill Terminates a running process.
ftp Transfers files between computers using FTP.
xcopy Copies files and directories from one location to another.
net Manages various aspects of the network.
dir Displays a list of files and directories in a folder.
cd Changes the current working directory.
type Displays the contents of a text file.
copy Copies one or more files to another location.
xcopy Copies files and directories, including subdirectories, to another location.
rename Renames a file or directory.
del Deletes one or more files.
rd Deletes a directory.
md Creates a new directory.
cls Clears the command-line screen.
sort Sorts the contents of a text file.
find Searches for a text string in a file or set of files.
grep Searches for a text pattern in a file or set of files.
net user Manages user accounts, including adding and removing users.
net localgroup Manages local user groups, including adding and removing users from groups.
net share Manages shared resources, including creating and deleting shares.
net view Displays a list of network resources, including computers, shares, and printers.
chkdsk Checks the integrity of the file system and repairs any errors it finds.
sfc /scannow Scans the system files and replaces any that are corrupted or missing.
start Opens a program or file.
net time Displays or sets the date and time on the network.
netstat -a Shows all active connections and listening ports.
netstat -b Shows the executables involved in creating each network connection or listening port.
netstat -r Shows the routing table for the local system.
nslookup -a Shows the authoritative DNS server for a domain.
netstat -e Shows network statistics, including the number of bytes and packets sent and received.
netstat -n Shows active connections and listening ports, but does not attempt to resolve hostnames or service names.
netstat -o Shows the process ID associated with each network connection or listening port.
netstat -p Shows the protocol associated with each network connection or listening port.
systeminfo Shows information about the system, including the operating system version, system uptime, and system configuration.
whoami Shows the user account that is currently logged in.
set Displays or sets environment variables.
time Shows or sets the system time.
date Shows or sets the system date.
ping -t Pings a networked device continuously until stopped.
ping -a Attempts to resolve the hostname of a networked device.
ping -n Specifies the number of echo requests to send.
ping -l Specifies the size, in bytes, of the echo request packet.
ping -f Specifies that the echo request packet should not be fragmented.
ping -i Specifies the time-to-live value for the echo request packet.`

These additional commands will help you further explore and utilize the power of the Windows command-line. Again, I encourage you to familiarize yourself with these commands, as well as the various options and arguments that can be used with each command, to make the most of your Windows system.

A Simple and Customizable Password Generator in Python

Muhammad ABir — Tue, 07 Feb 2023 08:27:42 +0000

In today's digital age, it's important to have strong and secure passwords to protect your personal and sensitive information. However, coming up with new and unique passwords can be difficult and time-consuming. That's where a password generator comes in handy. In this article, we will be building a simple yet customizable password generator using Python.

The Code

We'll start by defining the password_generator function, which takes five parameters: password_length, use_lowercase, use_uppercase, use_digits, and use_symbols. The password_length parameter determines the length of the generated password. The other parameters determine which character sets to include in the password. If a parameter is set to True, the corresponding character set will be included in the password. If a parameter is set to False, it will be excluded.

import random
import string

def password_generator(password_length, use_lowercase, use_uppercase, use_digits, use_symbols):
    # Define the character sets for the password based on the input
    characters = ""
    if use_lowercase:
        characters += string.ascii_lowercase
    if use_uppercase:
        characters += string.ascii_uppercase
    if use_digits:
        characters += string.digits
    if use_symbols:
        characters += "!@#$%^&*()_+=-"

    # Use random.choices() to generate a password of the desired length
    password = "".join(random.choices(characters, k=password_length))
    return password

The function uses the string module's ascii_lowercase and ascii_uppercase constants to define the lowercase and uppercase characters, respectively. The string module's digits constant defines the digit characters. The symbols are defined as a string of commonly used symbols.

The random.choices() function is used to generate a password of the desired length. The function generates a list of random characters from the characters string and then joins the list into a single string using the join() method.

User Input

Next, we'll prompt the user for the desired password length and the character sets to include in the password.

# Prompt the user for the desired password length
password_length = int(input("Enter desired password length: "))

# Prompt the user for the character sets to include in the password
use_lowercase = input("Include lowercase characters? (y/n): ").lower() == "y"
use_uppercase = input("Include uppercase characters? (y/n): ").lower() == "y"
use_digits = input("Include digits? (y/n): ").lower() == "y"
use_symbols = input("Include symbols? (y/n): ").lower() == "y"

The user inputs are converted to boolean values using the comparison operator == "y". If the user enters "y", the corresponding parameter will be set to True, otherwise it will be set to False.

Output

~ python password_generator.py

Enter desired password length: 25
Include lowercase characters? (y/n): n
Include uppercase characters? (y/n): y
Include digits? (y/n): y
Include symbols? (y/n): y
Generated password: 6P&Y1FU(^5_6RL5!$LWKJ4#+W

Here is an web version of this view

Linux for Power Users: A Cheatsheet of 50 Most Used Commands

Muhammad ABir — Fri, 27 Jan 2023 18:00:00 +0000

A Linux commands cheatsheet is a quick reference guide for users to easily access and utilize various Linux commands. It includes a list of commonly used commands along with examples and explanations of their usage. This resource can be helpful for both beginners learning the Linux command line and experienced users looking to improve their efficiency and productivity. It can be used as a quick reference for daily tasks, troubleshooting, and system administration.

ls - List files and directories in a directory. ls /home
cd - Change the current working directory. cd /home/documents
mkdir - Create a new directory. mkdir new_directory
rmdir - Remove an empty directory. rmdir old_directory
rm - Remove files or directories. rm file.txt
touch - Create a new file or update the timestamp of an existing file. touch new_file.txt
cp - Copy files or directories. cp file.txt /home/documents/
mv - Move or rename files or directories. mv file.txt /home/documents/
pwd - Print the current working directory. pwd
cat - Display the contents of a file. cat file.txt
less - Display the contents of a file one page at a time. less file.txt
head - Display the first few lines of a file. head file.txt
tail - Display the last few lines of a file. tail file.txt
grep - Search for a string in a file or output. grep "search_string" file.txt
find - Search for files in a directory. find / -name "file.txt"
man - Display the manual for a command. man ls
chmod - Change file permissions. chmod 755 file.txt
chown - Change file ownership. chown user:group file.txt
su - Switch to another user. su root
sudo - Run a command as the superuser. sudo apt-get update
passwd - Change the password for a user. passwd
df - Display filesystem usage. df -h
du - Display disk usage for a directory. du -sh /
free - Display memory usage. free -m
ps - Display process information. ps aux
kill - Send a signal to a process. kill -9 1234
top - Display real-time process information. top
htop - A more user-friendly version of top. htop
systemctl - Control system services. systemctl start apache2
apt-get - Package manager for Debian-based systems. apt-get update
yum - Package manager for Red Hat-based systems. yum update
wget - Download files from the internet. wget https://example.com/file.zip
curl - Transfer data from or to a server using various protocols. curl https://example.com
ping - Test the connectivity to a host. ping example.com
traceroute - Trace the route to a host. traceroute example.com
ssh - Securely connect to a remote host. ssh user@example.com
scp - Securely copy files to or from a remote host. scp file.txt user@example.com:/path/to/file
tar - Create or extract files from a tar archive. tar -xvf file.tar
gzip - Compress or decompress files. gzip file.txt
gunzip - Decompress files compressed with gzip. gunzip file.txt.gz
bzip2 - Compress or decompress files. bzip2 file.txt
bunzip2 - Decompress files compressed with bzip2. bunzip2 file.txt.bz2
uname - Display system information. uname -a
date - Display the current date and time. date
cal - Display a calendar. cal
time - Measure the running time of a command. time ls /
history - Display the command history. history
alias - Create a shortcut for a command. alias ll='ls -l'
bash - Start the Bash shell. bash
exit - Exit the current shell. exit

Git at a Glance: A Cheatsheet of 30 Must-know Commands

Muhammad ABir — Thu, 26 Jan 2023 18:00:00 +0000

Managing code and collaborating with others can be a daunting task, but Git makes it easy. This cheatsheet is here to help you take your Git skills to the next level by providing a comprehensive list of 30 essential commands. From initializing a new repository to merging changes, this cheatsheet covers all the basics you need to know to streamline your workflow and make your life as a developer much easier. Whether you're new to Git or an experienced user, this cheatsheet is a valuable resource to have on hand.

Initialize a new repository: git init
Clone an existing repository: git clone [repository url]
Check the status of your repository: git status
Add changes to the staging area: git add [file name]
Commit changes: git commit -m "[commit message]"
View the commit history: git log
View the difference between the working directory and the staging area: git diff
View the difference between the staging area and the last commit: git diff --staged
Discard changes in the working directory: git checkout [file name]
Discard changes in the staging area: git reset [file name]
Discard a commit: git revert [commit hash]
Remove a file from the repository: git rm [file name]
Rename a file in the repository: git mv [old file name] [new file name]
Show the branches in the repository: git branch
Create a new branch: git branch [branch name]
Switch to a different branch: git checkout [branch name]
Merge changes from one branch to another: git merge [branch name]
Show remote repositories: git remote
Show remote repositories: git remote -v
Add a new remote repository: git remote add [remote name] [repository url]
Push changes to a remote repository: git push [remote name] [branch name]
Pull changes from a remote repository: git pull [remote name] [branch name]
Show the tags in the repository: git tag
Create a new tag: git tag -a [tag name] -m "[tag message]"
Checkout a specific tag: git checkout [tag name]
Show the history of a file: git log -p [file name]
Show the commits that contain a certain string: git log -S [string]
Show the commits that were made by a certain author: git log --author=[author name]
Show the commits that were made in a certain date range: git log --since=[date] --until=[date]
Show the commits that were made on a certain branch: git log [branch name]

Please note that this is a list of commonly used Git commands, and there are many other commands that you can use as well. Additionally, each command has many options and flags that can be used to customize its behavior. I would suggest you to use the official Git documentation to learn more about the various commands and their usage.

MySQL in a Nutshell: A Handy Cheatsheet of Frequently Used Queries

Muhammad ABir — Thu, 26 Jan 2023 11:53:16 +0000

This MySQL cheatsheet provides a comprehensive list of essential commands for managing and manipulating databases. From creating and modifying tables to querying and updating data, this reference guide covers all the key commands you need to know to effectively work with MySQL. Whether you're a beginner or an experienced user, this cheatsheet is a valuable resource for quickly finding the command you need.

Connect to MySQL: mysql -u [username] -p
Show all databases: SHOW DATABASES;
Create a new database: CREATE DATABASE [database name];
Select a database: USE [database name];
Show all tables in a database: SHOW TABLES;
Create a new table: CREATE TABLE [table name] ([column name] [data type], [column name] [data type], ...);
Display the structure of a table: DESCRIBE [table name];
Insert data into a table: INSERT INTO [table name] ([column name], [column name], ...) VALUES ([value], [value], ...);
Select data from a table: SELECT [column name], [column name], ... FROM [table name];
Update data in a table: UPDATE [table name] SET [column name] = [new value] WHERE [condition];
Delete data from a table: DELETE FROM [table name] WHERE [condition];
Select data with a condition: SELECT [column name], [column name], ... FROM [table name] WHERE [condition];
Select data with a join: SELECT [column name], [column name], ... FROM [table name1] JOIN [table name2] ON [table name1.[column name] = [table name2].[column name];
Order data by a column: SELECT [column name], [column name], ... FROM [table name] ORDER BY [column name];
Limit the number of rows returned: SELECT [column name], [column name], ... FROM [table name] LIMIT [number];
Count number of rows: SELECT COUNT([column name]) FROM [table name];
Sum of a column: SELECT SUM([column name]) FROM [table name];
Average of a column: SELECT AVG([column name]) FROM [table name];
Group by a column: SELECT [column name], [aggregate function]([column name]) FROM [table name] GROUP BY [column name];
Create a new user: CREATE USER 'username'@'host' IDENTIFIED BY 'password';
Grant permissions to user: GRANT [permission] ON [database name].[table name] TO 'username'@'host';
Revoke permissions: REVOKE [permission] ON [database name].[table name] FROM 'username'@'host';
Show all users: SELECT User, Host FROM mysql.user;
Change a user's password: SET PASSWORD FOR 'username'@'host' = PASSWORD('new_password');
Rename a table: ALTER TABLE [table name] RENAME TO [new table name];
Add a column to a table: ALTER TABLE [table name] ADD [column name] [data type];
Modify a column in a table: ALTER TABLE [table name] MODIFY [column name] [data type];
Drop a column from a table: ALTER TABLE [table name] DROP COLUMN [column name];
Create an index: CREATE INDEX [index name] ON [table name] ([column name]);
Drop an index: DROP INDEX [index name] ON [table name];
Create a primary key: ALTER TABLE [table name] ADD PRIMARY KEY ([column name]);
Create a foreign key: ALTER TABLE [table name] ADD FOREIGN KEY ([column name]) REFERENCES [referenced table name] ([referenced column name]);
Create a unique constraint: ALTER TABLE [table name] ADD UNIQUE ([column name]);
Create a check constraint: ALTER TABLE [table name] ADD CHECK (condition);
Create a trigger: CREATE TRIGGER [trigger name] [trigger action] [event] ON [table name] FOR EACH ROW [trigger code];
Drop a trigger: DROP TRIGGER [trigger name];
Create a stored procedure: CREATE PROCEDURE [procedure name] ([parameter name] [data type], ...) BEGIN [procedure code]; END;
Call a stored procedure: CALL [procedure name]([parameter value], ...);
Drop a stored procedure: DROP PROCEDURE [procedure name];
Create a view: CREATE VIEW [view name] AS SELECT [column name], ... FROM [table name];
Drop a view: DROP VIEW [view name];
Create a backup: mysqldump -u [username] -p [database name] > [file name].sql
Restore a backup: mysql -u [username] -p [database name] < [file name].sql
Show current user: SELECT CURRENT_USER();
Show server version: SELECT VERSION();
Show system variables: SHOW VARIABLES;
Show status: SHOW STATUS;
Show processlist: SHOW FULL PROCESSLIST;
Kill a process: KILL [process id];
Exit MySQL: EXIT;

Note: replace the square bracketed placeholders with actual values.

Python & Firebase realtime messaging

Muhammad ABir — Mon, 23 Jan 2023 18:00:00 +0000

Firebase Realtime Database is a cloud-hosted NoSQL database that allows you to store and sync data between your users in real-time. You can use the Firebase Realtime Database with Python using the firebase-admin library. Here is an example of how to send a message to the Firebase Realtime Database using Python:

Install the firebase-admin library:

pip install firebase-admin

Import the necessary modules:

from firebase_admin import credentials, db

Initialize the Firebase Admin SDK with a service account:

cred = credentials.Certificate('path/to/serviceAccountKey.json')
firebase_admin.initialize_app(cred, {'databaseURL': 'https://your-project-name.firebaseio.com'})

Get a reference to the database:

ref = db.reference()

Send a message to the database:

ref.child("messages").push({"text": "Hello, World!"})

You can also listen for real-time updates to the database:

def on_message(event):
    print(event.event_type)  # can be 'put' or 'patch'
    print(event.path)
    print(event.data)  # new data at /path

my_stream = ref.child("messages").stream(on_message)

Make sure to replace "path/to/serviceAccountKey.json" with the path to your service account key and "your-project-name" with the name of your Firebase project. The file will have the following structure:

{
  "type": "service_account",
  "project_id": "your-project-id",
  "private_key_id": "your-private-key-id",
  "private_key": "-----BEGIN PRIVATE KEY-----\nyour-private-key\n-----END PRIVATE KEY-----\n",
  "client_email": "your-service-account-email",
  "client_id": "your-client-id",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/your-service-account-email"
}

Also, you can use the python library pyrebase to interact with the Firebase Realtime Database using the REST API, it has some more functionality than firebase-admin library.

Simple way to build an Whatsapp bot using NodeJS

Muhammad ABir — Mon, 23 Jan 2023 11:56:59 +0000

Creating a WhatsApp bot using Node.js requires a different approach than using the Telegram Bot API. WhatsApp does not provide a public API for building bots, but there are a few different ways to build a WhatsApp bot using Node.js.

One way to build a WhatsApp bot is to use the Twilio API for WhatsApp. Twilio is a cloud communications platform that provides an API for sending and receiving WhatsApp messages. To use Twilio for WhatsApp, you will need to sign up for a Twilio account and obtain a Twilio phone number that is WhatsApp-enabled.

Here is an example of a basic WhatsApp bot using the Twilio Node.js library:

const accountSid = 'YOUR_ACCOUNT_SID';
const authToken = 'YOUR_AUTH_TOKEN';
const client = require('twilio')(accountSid, authToken);

// replace with your Twilio phone number
const from = 'whatsapp:+14155238886';

client.messages
      .create({
         body: 'Hello World!',
         from: from,
         to: 'whatsapp:+1234567890'
       })
      .then(message => console.log(message.sid))
      .done();

This example sends a message with the text "Hello World!" from the Twilio phone number to the specified WhatsApp number.

You will need to replace YOUR_ACCOUNT_SID and YOUR_AUTH_TOKEN with the appropriate values from your Twilio account, and replace +1234567890 with the phone number of the recipient.

You can also use Twilio's WhatsApp Sandbox to test your bot. The Sandbox allows you to test your bot by sending and receiving messages to a pre-approved number, rather than a real phone number.

Another way is to use WhatsApp Business API which can be accessed via WhatsApp Business Account, this will give you access to more functionality and features compared to Twilio.

Please keep in mind that WhatsApp's policies strictly prohibit the use of automated messaging systems and bots on the platform. Make sure to read and abide by WhatsApp's guidelines when building your bot.

Suggested library: wwebjs

Lets build a Telegram bot using NodeJS

Muhammad ABir — Sun, 22 Jan 2023 18:00:00 +0000

To create a Telegram bot using Node.js, you will need to install the node-telegram-bot-api package. This package provides an easy-to-use interface for interacting with the Telegram Bot API.

Here is an example of a basic Telegram bot that can respond to messages:

const TelegramBot = require('node-telegram-bot-api');

// replace with your own token
const token = 'YOUR_TOKEN';

const bot = new TelegramBot(token, {polling: true});

bot.on('message', (msg) => {
  const chatId = msg.chat.id;
  bot.sendMessage(chatId, 'Hello World!');
});

In this example, the bot will listen for incoming messages and respond with "Hello World!" when a message is received. The polling: true option tells the bot to use long polling to receive updates from Telegram.

You will need to replace YOUR_TOKEN with the token you received from the Bot Father after creating your bot.

You can also use commands to make the bot do specific things. For example, you can make the bot respond to the command '/start' like this:

bot.onText(/\/start/, (msg) => {
  const chatId = msg.chat.id;
  bot.sendMessage(chatId, 'Welcome! How can I help you today?');
});

This is just a simple example, you can make your bot more complex by using more advanced features of the Telegram Bot API, such as sending photos, audio, etc.

Checkout the github repo