DEV Community: dhamola

Solving a Complex Backend Challenge: Integrating OpenAI and Termii for Multilingual SMS Delivery

dhamola — Fri, 28 Jun 2024 21:59:09 +0000

I encountered a challenging problem while working on a personal project, which involved consuming the OpenAI endpoint. The project's goal was to translate message content into various languages, providing a multilingual communication experience. To achieve this, I needed to integrate the functionalities of OpenAI for translation and Termii for reliable SMS delivery.

Let me give a practical example of how the service could be useful. imagine a church that has members from different language backgroundss. With this service, the church can send personalized messages to each member in their preferred languages.

Up until that point, my experience had primarily been in building endpoints rather than consuming APIs, making this task particularly difficult.

What I did?

I repeatedly read the documentation for the OpenAI and Termii APIs to understand their requirements and functionalities.
I had to search online, including Stack Overflow, to find any existing solutions or similar issues faced by other developers.
I reached out to my mentor, sharing all the research I had done and the specific issues I was facing. This made it easier for my mentor to understand the problem and guide me.
I applied the suggestions and solutions provided by my mentor, which helped me overcome the challenges and successfully integrate the APIs.

My journey into technology has been unconventional. I began with a Bachelor's degree in Business Education from Ekiti State University. After completing my NYSC in 2018/2019, I joined GTBank, one of Nigeria's largest banks, as an entry-level employee. There, we utilized Excel for reporting, analyzing data and engaging in peer-to-peer reviews with other banks to guide business decisions. It was during this time that I developed a keen interest in software development and its potential to transform traditional business practices.
Driven by this newfound curiosity, I decided to transition into tech while still working as a graduate trainee at GTBank. I enrolled in Altschool Africa's software development program and became proficient in HTML, CSS, JavaScript, Node.js, MongoDB, and SQL. I also dedicated time to learning tools like JMeter, Cypress, and Postman for automation on Udemy. After earning a diploma in Backend Engineering from Altschool Africa, I transitioned into IT and moved to Access Bank. There, I tested the bank's products before they were deployed to production. In my role at Access Bank, I have worked closely with developers and product owners to ensure that all requirements are met and that the final product is of the highest quality.
Breaking into tech wasn't easy; I had to balance both my work and learning,and even take on unpaid internships just to gain the necessary skills. However, through dedication and consistency, I acquired the expertise to become a QA Engineer and Backend Developer. Over the years, I have worked on various projects and in different organizations, adapting to their unique cultures and dynamics.

As a QA Engineer, I've had the opportunity to work closely with data teams,developers, gaining valuable insights into codebases, data-driven decision-making processes.

I'm incredibly excited about the HNG 11 cohort. I participated in the last cohort but was dropped at the 5th stage. Although I completed the task, I was informed that my implementation wasn't quite right. The project involved video translation. Despite this setback, I am a resilient individual and firmly believe that I can succeed this time.
I believe that getting to the final stage and finishing the program will give me a sense of fulfilment.In this internship, I want to get international jobs, network with great and like minds and be part of a community.

https://hng.tech/internship https://hng.tech/hire

Multilingual SMS Translation Service built with Hapi, Nodejs and Javascript

dhamola — Mon, 07 Aug 2023 09:01:48 +0000

Hey there! I've created this awesome service that makes sending bulk SMS messages super easy! But that's not all – it goes beyond the usual and lets you translate your messages into any language you want. How cool is that?

I've integrated the powerful features of OpenAI and Termii to make sure your messages get translated accurately and delivered on time. No more worrying about language barriers or missing out on reaching your audience!

Prerequisites

Before starting, please ensure that you have Node.js and npm installed as prerequisites. If you don't have them already, you can download and install them from the official Node.js website: https://nodejs.org.
This service leverages the power of OpenAI and Termii to ensure seamless translation and efficient delivery of SMS messages.

Setup

Install Node.js and npm on your system.
Clone this repository to your local machine.
Navigate to the project directory and install the required dependencies using npm install.
Create a .env file in the root directory and add the necessary environment variables:

 const Hapi = require("@hapi/hapi");
const axios = require("axios");
const dotenv = require("dotenv");
dotenv.config();

Package and tools

This documentation offers a comprehensive overview of the external API utilized in the project.

OPENAI:

OpenAI is a dedicated artificial intelligence research laboratory focused on the development of safe and beneficial artificial general intelligence (AGI). To use their services, you can visit their official website and access the documentation at this link: (https://platform.openai.com/docs/introduction). By creating an account on their platform, you will gain access to an API key, which is essential for using their AI capabilities in your applications.
OpenAI was seamlessly integrated into the app, empowering users to effortlessly translate messages from one source language to their desired destination language. This powerful integration added a valuable language conversion feature to our application, enhancing its versatility and usability.

async function translateText(text, source_language, destination_language) {
  const apiKey = process.env.OPENAI_KEY;
  const apiUrl = "https://api.openai.com/v1/chat/completions";
  const data = {
    model: "gpt-3.5-turbo",
    messages: [
      {
        role: "system",
        content: "You are a helpful assistant that translates text.",
      },
      {
        role: "user",
        content: `Translate the following '${source_language}' text to '${destination_language}': ${text}`,
      },
    ],
    max_tokens: 150,
    n: 1,
    stop: null,
    temperature: 0.5,
  };

  try {
    // Make the request with a delay of 2 seconds
    await new Promise((resolve) => setTimeout(resolve, 2000));
    const response = await axios.post(apiUrl, data, {
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });
    const translation = response.data.choices[0].message.content.trim();
    return translation;
  } catch (error) {
    console.error("Error:", error.message);
    throw error;
  }
}

Termii :

Termii is a platform that helps different companies send alerts. It helps other businesses authenticate user identities and transactions with one-time passwords (OTP).
you can visit their official website and access the documentation at this link: (https://developers.termii.com). By creating an account on their platform, you will gain access to an API key, which is plugged into the applications.
After the message has been converted by openAI, we incorporated the Termii api into our app to deliver the message to the recipient.

const request = require("request");
      convertedPhoneNumbers.forEach((convertedPhoneNumber) => {
        const data = {
          to: convertedPhoneNumber,
          from: "kokash",
          sms: translation,
          type: "plain",
          channel: "generic",
          api_key: process.env.TERMII_KEY,
        };
        const options = {
          method: "POST",
          url: "https://termii.com/api/sms/send",
          headers: {
            "Content-Type": ["application/json", "application/json"],
          },
          body: JSON.stringify(data),
        };

        request(options, function (error, response) {
          if (error) throw new Error(error);
          console.log(response.body);
        });
      });

Axios:

Axios played a crucial role in our application, enabling us to effortlessly interact with external APIs. Its user-friendly API, promise-based design, and robust error handling capabilities streamlined the process of fetching and processing data from different sources. By acting as a reliable bridge, Axios ensured smooth communication and significantly improved the overall performance of our application.

.env.example

environment variable offers all the configuration-related data needed.

Short URL generator built with Express, Nodejs and TypeScript.

dhamola — Mon, 26 Jun 2023 14:32:51 +0000

The shortUrl application was developed using Node.js, and it was designed to produce a short url from a given url as well as a barcode. Before using this feature, a user must first register and then log in.

Prerequisites
Before starting, please ensure that you have Node.js and npm installed as prerequisites. If you don't have them already, you can download and install them from the official Node.js website: https://nodejs.org.

In addition to Node.js and npm, this project also utilizes MongoDB as the database and Render for deployment. If you need detailed instructions on how to use these tools, please refer to their respective documentation.

Please note that this project was developed using TypeScript, so familiarity with TypeScript would be beneficial for understanding and working with the codebase.

Package and Tools

This documentation provides an overview of the packages and tools used in the project, along with their functionalities and installation instructions.

MongoDB:
Description: MongoDB is a popular NoSQL database used for storing and retrieving data.
Installation: Visit the official MongoDB website (https://www.mongodb.com) to download and install MongoDB according to your operating system. Follow the installation instructions provided.

EJS (Embedded JavaScript):

Description: EJS is a simple templating language that allows dynamic rendering of HTML templates.
Installation: EJS is a Node.js package and can be installed via npm. Open your terminal and run the following command:

Passport:

Description: Passport is a middleware for Node.js that provides authentication functionality.
Installation: Passport can be installed via npm. Open your terminal and run the following command:

QRCode:

Description: QRCode is a package that allows generating QR codes from text or URLs.
Installation: QRCode can be installed via npm. Open your terminal and run the following command:

Selenium WebDriver (for testing):

Description: Selenium WebDriver is a popular tool for automating web browsers and performing automated testing.
Installation: Selenium WebDriver requires additional setup. Visit the Selenium WebDriver documentation (https://www.selenium.dev/documentation/en/webdriver/) to download and install the WebDriver suitable for your preferred browser.

shortId generator:

Description: shortId is a package that generates short, unique, and URL-friendly IDs.
Installation: shortId can be installed via npm. Open your terminal and run the following command:

Express:

Description: Express is a fast and minimalist web application framework for Node.js.
Installation: Express can be installed via npm. Open your terminal and run the following command:

bcrypt:

Description: bcrypt is a password hashing library used to securely store user passwords.
Installation: bcrypt can be installed via npm. Open your terminal and run the following command:

Rate-limit:

Description: Rate-limit is a middleware that limits the number of requests a user can make within a certain time frame.
Installation: Rate-limit can be installed via npm. Open your terminal and run the following command:

Please note that the above installation commands assume you have npm and Node.js already installed. Make sure to run the commands from the root directory of your project.

It's important to consult the official documentation for each package and tool for detailed usage instructions, configuration options, and API references.

Refer to the readme file to set up the development environment
https://github.com/dhamolahedonist/short_url-generator/blob/main/README.md

Folder Structure

Folder: config

Files:
ensureAuthenticated.ts: This file defines the ensureAuthenticated middleware function that checks if a user is authenticated before allowing access to a protected resource. If the user is not authenticated, it flashes an error message and redirects to the login page.
Dependencies: The middleware uses the express library.

Files:
connectDB.ts: This file establishes a connection to the MongoDB database using the Mongoose library. It reads the MongoDB URI from the environment variables using the dotenv package.
Dependencies: The configuration file uses the mongoose and dotenv libraries.

Files:
configurePassport.ts: This file configures the passport authentication strategy using the passport-local strategy. It defines the local strategy for username-password authentication and sets up serialization and deserialization of user objects. It uses the bcrypt library for password hashing and the User model for user-related operations.
Dependencies: The service file uses the passport, mongoose, bcrypt, and User model.

Folder: controllers

File: shortUrlController.ts

This file contains controller functions related to URL shortening, QR code generation, and link management. It includes functions for rendering short URLs, generating short URLs, retrieving short URLs, generating QR codes, validating URLs, and deleting links. The file imports the express, ShortUrl, and QRCode libraries.

File: dashboardController.ts

Description: This file contains controller functions related to the dashboard functionality. It includes functions for rendering the welcome page, rendering the dashboard page, rendering the index page with the user's short URLs, generating short URLs, retrieving short URLs, generating QR codes, validating URLs, and deleting short URLs.

File: userController.ts

Description: This file contains controller functions related to user management and authentication using Passport. It includes functions for rendering the login and registration pages, handling user registration, user login, and user logout.

folder: model
The ShortUrl model file defines the Mongoose schema for storing shortened URLs. It includes fields for the full URL, generated short URL, number of clicks, and a reference to the associated user.

The User model file defines the Mongoose schema for storing user information. It includes fields for the user's name, email, and password.

Both models are used to create MongoDB documents and are exported for use in other parts of the application.

folder: routes

file:
shortUrlRoutes.ts: This is a route file that defines the routes for URL shortening and management. It imports controller functions from "shortUrlControllers" and "dashboardController". The routes include rendering the welcome page, rendering the dashboard page with authentication, rendering the URL page, generating a short URL, retrieving a short URL, generating a QR code, deleting a link, and logging out.

file:
userRoutes.ts:This is another route file that defines routes related to user authentication and URL management. It imports controller functions from "userController" and "shortUrlControllers". The routes include rendering the login and registration pages, registering a new user, logging in a user, and retrieving a short URL.

Both files use the express Router and export the defined routes as the default export.

folder: Views

dashboard.ejs: This file represents a dashboard page with a heading, a welcome message with the user's name, and a button to go back to the home page.

error.ejs: This file displays an error message with a back button if an invalid link is submited to generate barcode.

home.ejs: This file represents the home page with a form to enter a URL and generate a shortened URL. It also displays a table with existing short URLs, including their full URL, short URL, and click count. It has a section to generate a QR code for a given URL and a logout button.

layout.ejs: This file provides the basic structure for other pages, including a container div and necessary CSS and JS links.

register.ejs: This file displays a registration form with input fields for name, email, password, and password confirmation.

qrCode.ejs: This file displays a generated QR code for a given URL and provides options to download the barcode image or go back to the home page.

welcome.ejs: This file represents a welcome page with a Node.js logo and options to register or login.

db.js
All users and shortUrls data is kept in the mongdb database, which is connected to using db.js.

.env.example
environment variable offers all the configuration-related data needed.

server.ts
All of the application's files are combined into one file called server.ts.

Deployement on Render.
Refer to the documentation on how to deploy on ##Render
https://render.com/docs

CHATBOT Built with Nodejs and Telegram as the user interface

dhamola — Fri, 24 Mar 2023 09:08:48 +0000

This chatbot was created with Node.js and is intended to have conversations with users. Users must provide particular input in order for it to function.

Prerequisites

You will be required to have Node JS and npm before starting. Make sure you already have them installed. If not you can find them here: https://nodejs.org. Additional tools like Mongodb and Render(for deployment), were utilized. If you'd want more specific instructions on how to use these tools, please refer to their documentation.

Packages and Tools

To get started you will need to Register a Bot Account

You'll need a Telegram user account before you can create a Telegram bot. Head over to https://telegram.org/ and create an account if you don't already have one.

When you've signed in to Telegram, search for "BotFather" (a bot for managing all other Telegram bots) and start a new chat with it. Follow the steps below to register a new bot with the BotFather:

The BotFather will respond with a message containing an access token for your newly created bot. This access token will allow our application to access the Telegram API and tell our bot what to do when receiving different messages from users.

To confirm that your bot was created successfully, search for the bot's username. You should be able to see it and start a conversation with it, although it won't respond as we haven't written the bot's logic yet.

Refer to the readme file to set up the development environment https://github.com/dhamolahedonist/Jumia-Food-Telegram-Bot

The application makes use of a number of packages, including Mongoose and Telegraf. Please refer to the documentation provided with these packages for specific usage instructions.

Telegraf as a library was adopted to be able to develop our own app using javascript.refer to the documentation https://telegraf.js.org/#features

Mongoose is the preferred ORM to communicate with the database because we are using MongoDB

Folder Structure

Controller

The stepsControllers.js file handles all the responses based on the user input
The userControllers.js file look for the user; if none was found, a new user is created and the step the user is currently on is updated.
Both the stepsControllers and the userControllers file are complied in the webhookController.js file which is now compiled in the index.js file

db.js

All user and blog data is kept in the mongdb database, which is connected to using db.js.

.env.example

environment variable offers all the configuration-related data needed.

index.js

All of the application's files are combined into one file called index.js.

Deployement on Render.

Refer to the documentation on how to deploy on ##Render
https://render.com/docs

Design a blog API with Express, MongoDb and Heroku

dhamola — Mon, 02 Jan 2023 11:33:18 +0000

Several articles have been written about using NodeJs, Heroku, and the Express framework to build straightforward blogs. Here is yet another viewpoint and way of thinking that goes in the same direction.

The most widely used NodeJs framework, Express, offers a number of abstracted functionalities for creating straightforward yet effective APIs.

The blog initially uses APIs to handle articles for certain authors. Articles can be managed by authors as private or public.

Prerequisites
You will be required to have Node JS and npm before starting. Make sure you already have them installed. If not you can find them here: https://nodejs.org. Additional tools like Mongodb and Heroku were utilized. If you'd want more specific instructions on how to use these tools, please refer to their documentation.

Packages and Tools

A number of packages, including Joi, bcryptjs, Mongoose, Passport, and jwt, are used by the application. For detailed usage information, please consult the documentation for these packages.

In order to ensure that the payload is legitimate before being saved in the database, Joi is utilized in Post endpoints for payload validation. Bcryptjs was used to encrypt the data, including passwords, before it was put in the database.

Mongoose is the preferred ORM to communicate with the database because we are using MongoDB. For authentication and authorization, the program additionally uses the passport and jwt packages.

Folder Structure
Controllers
The controllers, which houses the business logic, is included in this.

The authenticationController.js file contains the middleware for "signup" and "login." The "singup" middleware transmits the user's information to the succeeding middleware after saving the user's information to the database. If not, an error is reported.

The "login" middleware verifies the user's identity using the specified email and password.
If the user is located, the following middleware receives the user's information.
If not, it reports an error.

The following actions can be performed by the blogController.js: create a blog, delete a blog by an id produced by a certain user, alter blog properties by an id by the person who created the blog, get a blog by an id, increase the read count of the blog when viewed, etc.
Additionally, it determines how long it takes to read a blog and retrieves every blog in the database.

The userController.js is capable of carrying out these operations: retrieve a user by an id, change user properties by the user's id.

Middleware
The validation is housed in the middleware.
Before signing up, the user must supply all required information, while the validateUser.js script checks to see if a token is included in the authorization headers before creating a blog. meaning that before publishing a blog post, the user must have registered and logged in.

Models
All of the input needed to create a blog post is specified in the BlogModel.js file.
The userModel.js file outlines all the information needed to create a user.

Routes
Before adding the user to the database, authRoute.js verifies that the user has provided the necessary information. It also verifies that the user's information matches that in the database when the user logs in before issuing a token to the user.

When a specific endpoint defined in the route is being called, the blogRoute.js merely applies the business logic defined in the blogContoller.js,
When a certain endpoint specified in the route is being called, the userRoute.js merely implements the business logic provided in the userContoller.js.

db.js
All user and blog data is kept in the mongdb database, which is connected to using db.js.

.env.example
environment variable offers all the configuration-related data needed.

app.js
All of the application's files are combined into one file called app.js.

The ReadMe file contains instructions on how to install the program and describes its features.

Deployment on heroku

Install the heroku CLI so that it is accessible in the terminal. Log in to the app that will be deployed using the heroku CLI, for example, cd blog-api. Type "heroku login" and then "heroku create" in the cmd window. -Next, depending on the branch, type "git push heroku main" or "git push heroku master". Type "git branch" to find out the branch you are now editing.

Conclusion
Altschool Africa assigned this application as part of their grade. Please visit https://github.com/dhamolahedonist/BloggingApi if you think the software needs further features.