DEV Community: oritsegbubemi

Building a Simple Chat Application with Go, Gin, MongoDB, and WebSocket

oritsegbubemi — Sat, 27 Jul 2024 18:39:11 +0000

In this tutorial, we will walk through building a simple chat application using Go, Gin, MongoDB, and WebSocket. We'll set up a backend server to handle HTTP requests and WebSocket connections, and manage chat messages and user interactions.

Prerequisites
. Go installed on your machine.
. MongoDB running locally or on a remote server.
. Basic understanding of Go, Gin, and MongoDB.

Project Structure
We'll organize our project into several packages:

. main: Entry point of the application.
. server: Initializes the server and routes.
. controller: Handles HTTP requests.
. middleware: Contains middleware functions.
. database: Manages MongoDB connections.
. service: Contains business logic.
. model: Defines data models.
. websocket: Manages WebSocket connections.

Setting Up the Main Package Create a main.go file as the entry point of the application:

Creating the Server Package In the server package, we'll initialize the server, set up routes, and handle WebSocket connections.

Defining Models Define the Message and Conversation models in the model package.

Connecting Database

Implementing WebSocket Functionality Create the websocket package to manage WebSocket connections and messages.

WebSocketServer Structure
This structure holds information about the WebSocket server, including connected clients, channels for broadcasting messages, and services for conversations and messages.

Upgrader
The upgrader is used to upgrade HTTP connections to WebSocket connections. The CheckOrigin function allows connections from any origin.

NewWebSocketServer
This function creates a new instance of WebSocketServer, initializing its properties and returning it.

Run Method
This method starts the WebSocket server by listening on port 8081 and handling connections at the /ws/chat endpoint. It also starts a goroutine to handle messages.

HandleConnections Method
This method upgrades an HTTP connection to a WebSocket connection, registers the new connection, and listens for incoming messages.

handleMessages Method
This method listens for register, unregister, and broadcast events. It adds or removes clients from the list and sends broadcast messages to all connected clients.

Handling Actions
The server handles different types of actions received from clients, such as creating a conversation, fetching a conversation, and sending a message.

Create Conversation
This action creates a new conversation with the given sender and receiver IDs.

Get Conversation by ID
This action fetches a conversation by its ID and sends it back to the client.

Send Message
This action creates a new message in a conversation and sends the created message back to the client.

Conclusion
In this tutorial, we have built a simple chat application using Go, Gin, MongoDB, and WebSocket. We've covered setting up the server, defining models, and handling WebSocket connections. You can extend this application by adding more features like authentication, file uploads, and real-time notifications.

full code can be found
https://github.com/gbubemi22/goSetup.git

How to Upload Images to AWS S3 with Golang

oritsegbubemi — Thu, 04 Jul 2024 12:44:20 +0000

In this tutorial, we will walk through the steps to upload images to AWS S3 using Golang. We'll cover setting up the necessary packages, configuring AWS, and writing the code to handle the image upload. Let's get started!

Prerequisites
Before we begin, ensure you have the following:

. An AWS account with S3 access.
. Go installed on your machine.
. A basic understanding of Go and its ecosystem.

mkdir go_mongoDb
cd go_mongoDb
go mod init go_mongoDb

Next, install the required packages:

go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/service/s3
go get github.com/aws/aws-sdk-go-v2/feature/s3/manager
go get github.com/gin-gonic/gin
go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/mongo

tep 2: Configuring AWS
Create a .env file in the root of your project and add your AWS credentials:

AWS_REGION=your-aws-region
AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key

Step 3: Writing the Upload Code
Create a file named upload.go under a utils package and add the following code:

Step 4: Integrating with Your Application

Create a controller to handle image uploads. In your controller package, create a file named userController.go and Create service to handle the Bussiness logic, create a file named userService.go:

Service

Controller

Step 5: Setting Up Routes
In your server package, create a server.go file to set up the routes:

Conclusion
You now have a working Go application that uploads images to AWS S3. This tutorial covered the essential steps to set up AWS configuration, write the upload logic, and integrate it with a web server using the Gin framework.

Feel free to extend this example by adding user authentication, storing image URLs in a database, and more. Happy coding!

get full code here
https://github.com/gbubemi22/goSetup.git

How to send email with Go and MailTrap

oritsegbubemi — Mon, 01 Jul 2024 18:15:09 +0000

Sending emails is a common requirement in many applications. Whether it's for account verification, password reset, or notifications, integrating email functionality can enhance the user experience. In this post, we'll walk through the steps to send emails using Go, leveraging the gomail package.

Prerequisites
Ensure you have the following dependencies in your go.mod file:

require (
github.com/joho/godotenv v1.4.0
gopkg.in/gomail.v2 v2.0.0-20180604020328-0353e461b93c
)

Step 1: Create a .env file with the following content

MAILTRAP_HOST=smtp.mailtrap.io
MAILTRAP_PORT=2525
MAILTRAP_USER=your_mailtrap_user
MAILTRAP_PASS=your_mailtrap_password
SENDER=your_sender_email@example.com

Step 2: Create the SendMail Function
Now, we will create the SendMail function to handle email sending. This function will read the configuration from the environment variables and use the gomail package to send the email.

Step 3: Integrate Email Sending in Your Application
Let's say you have a user verification process where you need to send an OTP (One-Time Password) to the user's email. Here's an example of how you can integrate the SendMail function into your application:

Step 4: Create an Endpoint to Trigger Email Sending
Finally, you need an endpoint to trigger the email sending. Here is an example using the Gin framework:

In your server setup, register this endpoint:

With this setup, you can now send emails from your Go application using the SendMail function. This method ensures your credentials are secure and that your email sending logic is cleanly separated from the rest of your application.

Feel free to customize the code and the explanations according to your specific requirements and style preferences!

Link to the Full code
https://github.com/gbubemi22/goSetup

URL Shortener Service for your API

oritsegbubemi — Mon, 04 Oct 2021 15:02:45 +0000

https://twitter.com/Rapid_API/status/1445008466817568773?s=20

HTTP status code are pretty confusing sometimes ... check the link below

oritsegbubemi — Mon, 04 Oct 2021 15:00:36 +0000

https://twitter.com/Rapid_API/status/1444026755363348488?s=20

it is good to be hear

oritsegbubemi — Thu, 30 Sep 2021 17:01:17 +0000

what i love doing