DEV Community: Mathias Jiya

Forget MVP: Start With the MVP of MVP

Mathias Jiya — Fri, 12 Sep 2025 09:37:00 +0000

I was reading The Lean Startup by Eric Ries the other day. In one of his stories, he talks about how his team at IMVU spent over six months building what they thought was their minimum viable product. They launched it to the market with high hopes… only to realize that customers didn’t care.
Of course, they walked away with lessons because that’s what startups do when things don’t work out. But Ries asked a question that stuck with me:
What if we didn’t need six months to learn this lesson? What if we could’ve learned it in weeks, maybe even days?
That question got me thinking about something I now call the MVP of MVP.

Why MVPs sometimes fail us

The MVP idea sounds great in theory: build the smallest possible version of your product, put it in front of customers, and learn quickly.
But in practice? Founders often spend three to six months building their MVPs. By then, they’ve poured in countless assumptions, lines of code, and a good portion of their emotions. If customers don’t care, the crash is brutal.
It makes you pause and wonder: Is there a way to test whether an MVP is even worth building in the first place?

Enter the MVP of MVP

Here’s how I see it: the MVP of MVP is the smallest, quickest, cheapest experiment you can run to figure out if your idea even deserves an MVP.
It’s not the product. It’s not even a prototype. It’s simply a test to answer one question: should I go ahead with building an MVP at all?

This isn’t a new idea, but it deserves a new name

When I thought about it more, I realized some of the most successful startups actually did this without calling it that.

Dropbox didn’t start with a file-syncing app. They made a short demo video. People signed up, proving demand.
Airbnb didn’t start with a polished platform. They put air mattresses in their apartment and rented them to conference attendees.
Zappos didn’t begin with warehouses of shoes. The founder took pictures in stores, posted them online, and manually fulfilled orders.

Each of these could’ve taken months of engineering. Instead, they ran quick experiments in days or weeks. That’s the MVP of MVP in action.

Why it matters even more today

Things move faster now than when The Lean Startup was published. By the time you spend six months on an MVP, the trend you’re chasing might already be gone.
On top of that, the tools we have today - no-code platforms, website builders, AI design tools, and even simple WhatsApp groups - make it ridiculously easy to test an idea almost instantly.
And let’s be real, attention spans are short. You don’t always get multiple shots to convince people. Early signals matter.

The honest limitations

I won’t sugarcoat it: an MVP of MVP isn’t a silver bullet. Sometimes, a scrappy test makes people walk away when they might have loved a more polished version. And sometimes people say “yes” to a landing page or demo video but don’t stick around when the real product launches.
That’s fine. Think of it as a filter. The MVP of MVP tells you whether to even bother building an MVP. The MVP itself then tells you whether it’s worth scaling into a full product.

How to think about it

Next time you’re hyped about an idea, pause and ask yourself three questions:

What’s the core assumption I am making?
What’s the quickest way to test it without spending months?
What signal will convince me to build a real MVP?

That “quickest way” could be as simple as:

A landing page with a signup button
A few ads to measure clicks
Manually offering the service over chat
A short explainer video

The point is that it takes days or weeks, not months.

Finally

If IMVU had tested their idea with an MVP of MVP, maybe they wouldn’t have spent six months building something nobody wanted.
For founders today, this isn’t just a “what if.” It’s becoming a necessity. Before you spend months building an MVP, ask yourself: what is my MVP of MVP?
Because sometimes, the fastest way forward isn’t building faster - it’s learning faster.

Golang in-memory key-value pair cache

Mathias Jiya — Fri, 26 Apr 2024 19:49:34 +0000

Hello devs, I am excited to share my most recent project.
I started working on this Golang project about a week ago. And as you must have guessed already, yes, it's yet another Golang library :)
Fs-cache is a Golang-based caching solution that's simple and lightweight. It supports data caching with optional parameters for expiration. This library has 14 methods added to it to allow for different use cases of the library.
Fs-cache provides a quick way to store and retrieve frequently accessed data, significantly enhancing your application performance and reducing database queries / API calls.
Below is a sample code on how to use the library.

Installation

go get github.com/iqquee/fs-cache@latest

Import

fscache "github.com/iqquee/fs-cache"

Usage

Debug()

Debug() enables debug to get certain logs

fs := fscache.New()
// set if you want to get logs of activities
fs.Debug()

Set()

Set() adds a new data into the in-memmory storage

fs := fscache.New()

// the third param is an optional param used to set the expiration time of the set data
if err := fs.Set("key1", "user1", 5*time.Minute); err != nil {
    fmt.Println("error setting key1:", err)
}

Get()

Get() retrieves a data from the in-memmory storage

fs := fscache.New()

result, err := fs.Get("key1")
if err != nil {
    fmt.Println("error getting key 1:", err)
}

fmt.Println("key1:", result)

SetMany()

SetMany() sets many data objects into memory for later access

fs := fscache.New()

testCase := []map[string]fscache.CacheData{
    {
        "key4": fscache.CacheData{
            Value:    "value4",
            Duration: time.Now().Add(time.Minute),
        },
        "key5": fscache.CacheData{
            Value: false,
        },
    },
}

setMany, err := fs.SetMany(testCase)
if err != nil {
    fmt.Println("error setMany:", err)
}
fmt.Println("setMany:", setMany)

GetMany()

GetMany() retrieves datas with matching keys from the in-memmory storage

fs := fscache.New()

keys := []string{"key1", "key2"}

getMany := fs.GetMany(keys)
fmt.Println("getMany:", getMany)

OverWrite()

OverWrite() updates an already set value using it key

fs := fscache.New()

if err := fs.OverWrite("key1", "overwrite1", 1*time.Minute); err != nil {
    fmt.Println("error overwriting:", err)
}

OverWriteWithKey()

OverWriteWithKey() updates an already set value and key using the previously set key

fs := fscache.New()

if err := fs.OverWriteWithKey("previousKey", "newKey", "newValue", 1*time.Minute); err != nil {
    fmt.Println("error overWriteWithKey:", err)
}

Del()

Del() deletes a data from the in-memmory storage

fs := fscache.New()

if err := fs.Del("key1"); err != nil {
    fmt.Println("error deleting key 1:", err)
}

TypeOf()

TypeOf() returns the data type of a value

fs := fscache.New()

typeOf, err := fs.TypeOf("key1")
if err != nil {
    fmt.Println("error typeOf:", err)
}
fmt.Println("typeOf:", typeOf)

Clear()

Clear() deletes all datas from the in-memmory storage

fs := fscache.New()

if err := fs.Clear(); err != nil {
    fmt.Println("error clearing all datas:", err)
}

Size()

Size() retrieves the total data objects in the in-memmory storage

fs := fscache.New()

size := fs.Size()
fmt.Println("total size: ", size)

Keys()

Keys() returns all the keys in the storage

fs := fscache.New()

keys := fs.Keys()
fmt.Println("keys: ", keys)

Values()

Values() returns all the values in the storage

fs := fscache.New()

values := fs.Values()
fmt.Println("values: ", values)

KeyValuePairs()

KeyValuePairs() returns an array of key-value pairs of all the data in the storage

fs := fscache.New()

keyValuePairs := fs.KeyValuePairs()
fmt.Println("keyValuePairs: ", keyValuePairs)

This sample code above shows how easy it is to use this library in your Golang projects. You can check out fs-cache on GitHub.

How to integrate zeptomail in Golang

Mathias Jiya — Tue, 19 Mar 2024 13:20:44 +0000

Transaction emailing have become a very vital part of any application. Wondering what transactional email means?
Transactional emails are messages that are sent in response to an action a user takes on a website or application. Examples include: Password reset emails etc.
There are several transactional email service providers out there just to name a few:

Postmark
ZeptoMail
SendGrid

In this article, I will be talking about ZeptoMail. As we already know, ZeptoMail is a transactional emailing service. It is tailor-made for sending transactional emails, ensuring fast delivery and inbox placement for your application emails.

So, while working on a project for a company I worked at. We decided to use ZeptoMail to send transactional emails. After my search, I realized that ZeptoMail does not have a Golang library. And as you already know by now, I opted in to build one. My reasons for always building Golang libraries is so as to make the work of other Golang developers easier and for re-usability as well.
Now lets get to the fun part :). Here's how to setup ZeptoMail in your Golang project.

Get started

In order to use this package, you need to first head over to https://zoho.com to create an account to get your Authorization Token Key.

Installation

This package can in installed using the go command below.

go get github.com/iqquee/zeptomail@latest

Quick start

# assume the following codes in example.go file
$ touch example.go
# open the just created example.go file in the text editor of your choice

SendHTMLEmail

SendHTMLEmail() sends a HTML template email.

This method takes in the zeptomail.SendHTMLEmailReq{} struct as a parameter.

package main

import (
    "fmt"
    "net/http"

    "github.com/iqquee/zeptomail"
)

func main() {
    zeptomailToken := "your zeptomail authorization token"

    client := zeptomail.New(*http.DefaultClient, zeptomailToken)
    sendTo := []zeptomail.SendEmailTo{}
    sendTo = append(sendTo, zeptomail.SendEmailTo{
        EmailAddress: zeptomail.EmailAddress{
            Address: "rudra.d@zylker.com",
            Name:    "Rudra",
        },
    })

    data := "<div><b> Kindly click on Verify Account to confirm your account </b></div>"

    req := zeptomail.SendHTMLEmailReq{
        To: sendTo,
        From: zeptomail.EmailAddress{
            Address: "accounts@info.zylker.com",
            Name:    "Paula",
        },
        Subject:  "Account Confirmation",
        Htmlbody: data,
    }
    res, err := client.SendHTMLEmail(req)
    if err != nil {
        fmt.Printf("This is the error: %v", err.Error())
    }

    for _, e := range res.Data {
        fmt.Printf("response message: %v\n", e.Message)
    }
}

SendTemplatedEmail

SendTemplatedEmail() sends a templated email set from your ZeptoMail dashboard.

This method takes in the zeptomail.SendTemplatedEmailReq{} struct as a parameter.

package main

import (
    "fmt"
    "net/http"

    "github.com/iqquee/zeptomail"
)

func main() {
    zeptomailToken := "your zeptomail authorization token"
    tempKey := "your zeptomail template key"

    client := zeptomail.New(*http.DefaultClient, zeptomailToken)
    sendTo := []zeptomail.SendEmailTo{}
    sendTo = append(sendTo, zeptomail.SendEmailTo{
        EmailAddress: zeptomail.EmailAddress{
            Address: "rudra.d@zylker.com",
            Name:    "Rudra",
        },
    })

    req := zeptomail.SendTemplatedEmailReq{
        To: sendTo,
        From: zeptomail.EmailAddress{
            Address: "accounts@info.zylker.com",
            Name:    "Paula",
        },
        TemplateKey: tempKey,
    }

    res, err := client.SendTemplatedEmail(req)
    if err != nil {
        fmt.Printf("This is the error: %v", err.Error())
    }

    for _, e := range res.Data {
        fmt.Printf("response message: %v\n", e.Message)
    }
}

For a detailed documentation, you can check out https://github.com/iqquee/zeptomail. For more sample codes, you can see https://github.com/iqquee/zeptomail/blob/main/examples/main.go. Please do not hesitate to create an issue on GitHub if you encounter any issue while using this library as it will be attended to and resolved as soon as possible.

invalid go version '1.21.4': must match format 1.23

Mathias Jiya — Wed, 31 Jan 2024 13:46:20 +0000

Todays article is about how to get passed this error. So, I was trying to setup a GitHub workflow (golangci-lint and tests) for a project I am working on and then this error came up.
The above error is as a result of the go version in your go.mod file. Which apparently should look like this 1.x.x but the GitHub actions you are trying to setup wants it to be in this format 1.x
The way to solve this problem is to update the go version in your go.mod file to be 1.21 instead of 1.21.4. Also, note that if any of your GitHub actions is running the command go tidy in anyway, then you will need to reduce the go version in your go.mod file because the maximum version supported by the go tidy is 1.20 else you'll get another kind of error similar to maximum version supported by the go tidy is 1.20 for that particular Github action.

Generally, when you get this error, just update your go version from this format 1.x.x to 1.x and you should be good.
Do have a wonderful day ;).

How to run shell scripts in windows

Mathias Jiya — Wed, 13 Dec 2023 12:11:58 +0000

Hello there, today's article is about shell scripts. Shell scripts are commands put together in a file to be ran on the terminal in other to perform certain operation(s) by just running a single command in most cases.
Running a shell script on windows can be a little bit tricky though. Here's how to run a shell script on windows:

Assuming our script is in a file named helloworld.sh which contains the following commands

#!/bin/sh

echo "script running..."
echo "hello world"

Copy the scripts from the .sh file
Navigate to https://daniel-sc.github.io/bash-shell-to-bat-converter and paste the copied bash script.
Copy the bash script that have just been converted to a batch(.bat) script.

At this point I know you might be wondering what a Batch(.bat) script is. Well wonder no more ;)
BAT file extension is a Windows batch file. It's a plain text file that contains various commands used for repetitive tasks or to run groups of scripts one after another. Software of all types use BAT files for various purposes—for example, to copy or delete files, run applications, and shut down processes.

Create a new file named helloworld.bat (the name of the new file does not matter but I think it makes sense to name it after the original bash file) and paste the copied batch commands into it and save.
On the windows power shell, navigate the project folder and run ./helloworld.bat

If everything is done correctly, you should see something similar to this in your windows power shell

"script running..."
"hello world"

How to setup ZeptoMail in Golang

Mathias Jiya — Tue, 14 Nov 2023 10:36:52 +0000

Hello ninjas,
In today's article, I bring you ZeptoMail.
ZeptoMail is an email service built exclusively to send transactional emails from applications or websites such as welcome emails, password reset emails, invoice emails, etc.
Building your backend service is enough work already. Including an emailing functionality should not add to your problems. That is why I decided to build a Golang library for ZeptoMail after I realized that ZeptoMail does not have a Golang library that implements its APIs. You should know just how much I love to build Golang libraries already. The reason for this is simple - it makes the work of other Golang developers out there easier and faster.

Using this library, you can send HTML email, templated email, etc to your users\customers. Here is how to set up ZeptoMail in your Golang project:

Get Started

In order to use this package, you need to first head over to https://zoho.com to create an account to get your Authorization Token Key.

Documentation

See the ZeptoMail API Docs

Installation

This package can in installed using the go command below.

go get github.com/iqquee/zeptomail

Quick start

# assume the following codes in example.go file
$ touch example.go
# open the just created example.go file in the text editor of your choice

SendHTMLEmail

SendHTMLEmail() sends a HTML template email.

This method takes in the zeptomail.SendHTMLEmailReq{} struct as a parameter.

List of all the fields available in the zeptomail.SendHTMLEmailReq{} struct.

type ( 
    // SendHTMLEmailReq is the SendHTMLEmail() request object
    SendHTMLEmailReq struct {
        From     EmailAddress  `json:"from" validate:"required"`
        To       []SendEmailTo `json:"to" validate:"required"`
        Subject  string        `json:"subject" validate:"required"`
        Htmlbody string        `json:"htmlbody" validate:"required"`
    }

    // EmailAddress is an email address object
    EmailAddress struct {
        /*
            The email address to which the recipient's email responses will be addressed.

            Allowed value - A valid email address containing a domain that is verified in your Mail Agent.
        */
        Address string `json:"address" validate:"required"`
        // Recipient's name.
        Name string `json:"name" validate:"required"`
    }
)

package main

import (
    "fmt"
    "net/http"

    "github.com/iqquee/zeptomail"
)

func main() {
    zeptomailToken := "your zeptomail authorization token"

    client := zeptomail.New(*http.DefaultClient, zeptomailToken)
    sendTo := []zeptomail.SendEmailTo{}
    sendTo = append(sendTo, zeptomail.SendEmailTo{
        EmailAddress: zeptomail.EmailAddress{
            Address: "rudra.d@zylker.com",
            Name:    "Rudra",
        },
    })

    data := "<div><b> Kindly click on Verify Account to confirm your account </b></div>"

    req := zeptomail.SendHTMLEmailReq{
        To: sendTo,
        From: zeptomail.EmailAddress{
            Address: "accounts@info.zylker.com",
            Name:    "Paula",
        },
        Subject:  "Account Confirmation",
        Htmlbody: data,
    }
    res, err := client.SendHTMLEmail(req)
    if err != nil {
        fmt.Printf("This is the error: %v", err.Error())
    }

    for _, e := range res.Data {
        fmt.Printf("response message: %v\n", e.Message)
    }
}

You can check out the library for documentation of other available methods. I will be adding some more methods to the library soon because my goal is to ensure that this library implements all the functionalities supported by ZeptoMail.

Have a wonderful day ahead devs - Happy coding ;)

How to screenshot webpages in Golang

Mathias Jiya — Sat, 01 Jul 2023 13:48:35 +0000

Hello there,
So, I've been lazy to publish an article for about a month or probably more but today is that day :).
This article is about my recent project. Wondering what that is?
Well, it is about Urlbox.
I wanted to implement a website screenshotting functionality. So, I got into googling, and at the end of it all, I came across Urlbox. Here is a little explanation as to what Urlbox is about.
Urlbox is a lightweight REST API built to automate the process of capturing website screenshots on your product.
The reason why I am so excited about this project is that Urlbox seems to be the answer to the problem I had at hand. But then, I realized that Urlbox doesn't have a Golang library. And so, just as I always do, I decided to build one. Now, you can add this functionality to your application. Well, I mean for Golang developers anyways. You should know me by now. I'm all about Golang ;).
Below are sample screenshots taken with the library:

So here's how to setup Urlbox in your Golang application:
NOTE: This Golang library supports the two ways of taking the screenshot of websites supported by Urlbox.

Installation

This package can in installed using the go command below.

go get github.com/iqquee/urlbox

List of file formats you could use for the Format field in the Request{} struct.

const (
    //FileFormatPng for png file format
    FileFormatPng string = "png"
    //FileFormatJpeg for jpeg file format
    FileFormatJpeg string = "jpeg"
    // FileFormatAvif for avif file format
    FileFormatAvif string = "avif"
    //FileFormatWebp for webp file format
    FileFormatWebp string = "webp"
    //FileFormatWebm for webm file format
    FileFormatWebm string = "webm"
    // FileFormatPdf for pdf file format
    FileFormatPdf string = "pdf"
    //FileFormatSvg for svg file format
    FileFormatSvg string = "svg"
    // FileFormatHtml for html file format
    FileFormatHtml string = "html"
    // FileFormatMd for md file format
    FileFormatMd string = "md"
    // FileFormatMp4 for mp4 file format
    FileFormatMp4 string = "mp4"
)

Screenshot

Screenshot takes the screenshot of a website synchronously.
Inother words, whenever you make a request using this method, you wait to get the screenshotted data([]byte) from the server.

This method takes in the Request{} struct as a parameter.

List of all the fields available in the Request{} struct.

type (
    // Request parameter for the ScreenshotAsync method
    Request struct {
        Url     string  `json:"url"`    // url of website to screenshot
        Format  string  `json:"format"` // screenshot file format
        Options Options // optional params for the request
    }
    // optional parameter
    Options struct {
        FullPage        bool // for full page screenshot
        Width           int  // the viewport width of the browser, in pixels
        Height          int // the viewport height of the browser, in pixels
        BlockingOptions Blocking // options for blocking or dismissing certain page elements, such as cookie banners
        SelectorOption  Selector // take a screenshot of the element that matches this selector. By default, if the selector is not found, Urlbox will take a normal viewport screenshot. If you prefer Urlbox to fail the request when the selector is not found, pass fail_if_selector_missing=true.
        ImageOption     Image    // options relating to the outputted PNG, WebP or JPEG file
        WaitOption      Wait // options relating to waiting before taking the screenshot 
    }
    // blocking option parameter
    Blocking struct {
        BlockAds          bool `json:"block_ads"`           // remove ads from page
        HideCookieBanners bool `json:"hide_cookie_banners"` // remove cookie banners if any
        ClickAccept       bool `json:"click_accept"`        // click accept buttons to dismiss pop-upsSelector
    }
    // selector option parameter
    Selector struct {
        Selector              string `json:"selector"`                 // for css selectors e.g #playground for id of playground
        FailIfSelectorMissing bool   `json:"fail_if_selector_missing"` // fail the request when the selector is not found
    }
    // image option parameter
    Image struct {
        Retina      bool `json:"retina"`      // take a 'retina' or high-definition screenshot, equivalent to setting a device pixel ratio of 2.0 or @2x. Please note that retina screenshots will be double the normal dimensions and will normally take slightly longer to process due to the much bigger image size.
        Quality     int  `json:"quality"`     // the image quality of the resulting screenshot (JPEG/WebP only)
        Transparent bool `json:"transparent"` // if a website has no background color set, the image will have a transparent background (PNG/WebP only)
    }

    // wait option parameter
    Wait struct {
        Delay   int // the amount of time to wait before Urlbox takes the screenshot or PDF, in milliseconds.
        TimeOut int // the amount of time to wait for the requested URL to respond, in milliseconds.
    }
)

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "strings"
    "time"

    "github.com/iqquee/urlbox"
)

func main() {
    apiKey := ""
    secreteKey := ""
    client := urlbox.New(*http.DefaultClient, apiKey, secreteKey)

    request := urlbox.Request{
        Url:    "https://urlbox.io",
        Format: urlbox.FileFormatPng,
        Options: urlbox.Options{
            ImageOption: urlbox.Image{
                Retina:  true,
                Quality: 100,
            },
        },
    }

    data, err := client.Screenshot(request)
    if err != nil {
        fmt.Println("an error occured: ", err)
        return
    }

    fmt.Println("This is the response byte: ", data)

    filename := fmt.Sprintf("%s-%d.%s", strings.Replace(request.Url, "/", "-", -1), time.Now().UTC().Unix(), request.Format)

    if err := os.WriteFile(filename, data, 0666); err != nil {
        fmt.Println("error writing to disk: ", err)
        return
    }
}

ScreenshotAsync

ScreenshotAsync allows your application to receive information when a screenshot has been rendered.
This allows you to render screenshots asynchronously.

This method takes in the RequestAsync{} struct as a parameter.

Use this object payload to implement the ScreenshotAsync() method

type RequestAsync struct {
    Url        string `json:"url"`         // url of website to screenshot
    WebhookUrl string `json:"webhook_url"` // Pass a webhook URL in as the webhook_url option and Urlbox will send a POST request back to that URL with data about the screenshot in JSON format once it has completed rendering
}

package main

import (
    "fmt"
    "net/http"

    "github.com/iqquee/urlbox"
)

func main() {
    apiKey := ""
    secreteKey := ""
    client := urlbox.New(*http.DefaultClient, apiKey, secreteKey)

    request := urlbox.RequestAsync{
        Url:        "https://urlbox.io",
        WebhookUrl: "https://example.com/webhooks/urlbox",
    }

    message, err := client.ScreenshotAsync(request)
    if err != nil {
        fmt.Println("an error occured: ", err)
        return
    }

    fmt.Println("This is the response message: ", message)

}

I have put in some work to make sure that this library was properly documented so that Golang developers out there can find it quite easy to use and without much stress. And as such, sample code were added for each methods.
Do have a great day ahead.

How to setup Redis on linux machine

Mathias Jiya — Mon, 01 May 2023 11:19:08 +0000

Redis, the open-source in-memory data structure store, has become popular among developers for its exceptional performance and versatility.

What makes Redis useful

Redis offers a wide range of features like caching, real-time analytics, queuing, etc. That makes it an ideal choice for different types of applications. Its in-memory architecture allows it to deliver data at lightning-fast speeds. Its support for various data structures like strings, lists, sets, and hashes, makes it a powerful tool for building complex applications. Redis is also easy to use, deploy, and scale, making it a developer's favorite. In this article, we'll explore Redis and how to set it up on a Linux machine.

How to setup Redis on Linux

NOTE: It's not always applicable but you may need to run an update on your machine to proceed.

Step 1 - Installing Redis using the Terminal

For Arch

sudo pacman -S redis

For Ubuntu

sudo apt install redis

For CentOS

sudo yum install redis

For Fedora

sudo dnf -y install redis

Step 2 - Check the Redis Version

Once the installation is complete, you can check if the installation was successful using this command below:

redis-cli --version

Step 3 - Start the Redis Service

sudo systemctl start redis

Step 4 - Enable the Redis Service

To automatically start Redis on boot run the command below

sudo systemctl enable redis

Step 4 - Verify your installation

sudo systemctl status redis

You should now see something similar to the image below. In the output, locate the Active: active (running) line.

NOTE: If what you saw is Active: inactive, then it means that you must have missed Step 3.

You can also verify your installation using this Ping command.

redis-cli ping

The expected return should be PONG.

Your Redis Config

Wondering how you can connect to your Redis server? Well, you can just copy the address below and set it as your Redis address and you are good to go.

NOTE: Redis runs on port 6379

127.0.0.1:6379

I hope you found this helpful. Happy coding ;)

Sorting in Go(Golang) made easy

Mathias Jiya — Tue, 13 Dec 2022 19:55:01 +0000

Hello there,
In today's article, I will be talking about https://github.com/iqquee/sort, a Go library I built for sorting data.

What is sort ?

sort is a Go library that sorts data(both string and int) with their number of occurrences and returns the desired data length in descending order with no duplicates of values.

Use cases range from:

To implement a trending feature in an e-commerce platform
To get the most ordered(purchased) products e.t.c

This library contains two methods in the x package:

SortInt()

The SortInt() sorts an array of int

package main

import (
    "fmt"

    "github.com/iqquee/sort"
)

func main() {

    arr := []int{2, 3, 10, 4, 1, 10, 1, 4, 4, 5, 6, 6, 6, 6, 1, 6, 7, 8, 12, 9, 1, 1, 1}

    //pass in the array to be sorted and the desired length of data to be returned in descending order
    //the lenght should be zero(0) if you want to get all the sorted data
    sortedInt := sort.SortInt(arr, 3)
    fmt.Printf("This is the sorted int data: %v\n", sortedInt)

}

SortString()

The SortString() sorts an array of string

package main

import (
    "fmt"

    "github.com/iqquee/sort"
)

func main() {

    arr := []string{"by", "me", "come", "by", "me", "hello", "hey", "hey", "me", "buy", "by", "come", "hello", "go"}

     //pass in the array to be sorted and the desired length of data to be returned in descending order
     //the lenght should be zero(0) if you want to get all the sorted data
    sortedString := sort.SortString(arr, 3)
    fmt.Printf("This is the sorted string data: %v\n", sortedString)

}

Telegram bot with Golang and Mongodb

Mathias Jiya — Mon, 05 Sep 2022 19:16:03 +0000

So over the weekend I was working on a telegram bot whose task is to manage a particular telegram group. Wondering what the bot does?

The bot welcomes newly added users to the telegram group
Deletes links sent to the group by the users aside from the Admin
Deletes every messages sent to the group by new users until they have added a certain number of users to the group and after words they can send messages to the group

In this article, I would be showing you how to create a telegram bot with Golang and Mongodb. First search for "botfather" on telegram and create a newbot. After you have set a name for you bot and a username, a token would be sent to you. This token would be used to authenticate your bot.

This is the .env config:

TOKEN=<generated token from botfather in telegram>

USER_NAME=<the group admin username>

MONGO_URI=mongodb://localhost:27017<for local host mongodb>
DATABASE_NAME=<database name>

This is the code for the bot:

package tele

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "strings"

    tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
    "github.com/iqquee/telebot/database"
    "go.mongodb.org/mongo-driver/bson"
)

func urlChecker(character string) bool {
    var val bool
    //check if the string contains a .
    if strings.Contains(character, ".") {
        for i, value := range character {
            //get the index of .
            if string(value) == "." {
                fmt.Printf("%d - %v\n", i, string(value))
                prev := i - 1
                next := i + 1
                for e, v := range character {
                    //check the previous character if its an "" string
                    if e == prev {
                        if string(v) != " " && string(v) != "." {
                            //check the next character if its an "" string
                            for ee, vv := range character {
                                if ee == next {
                                    if string(vv) != " " && string(vv) != "." {
                                        val = true
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return val
}

func Bot() {
    token := os.Getenv("TOKEN")
    bot, err := tgbotapi.NewBotAPI(token)
    if err != nil {
        log.Panic(err)
    }

    bot.Debug = true

    log.Printf("Authorized on account %s", bot.Self.UserName)

    u := tgbotapi.NewUpdate(0)
    u.Timeout = 60

    updates := bot.GetUpdatesChan(u)

    for update := range updates {
        if update.Message != nil {
            log.Printf("[%s] %s\n", update.Message.From.UserName, update.Message.Text)


            // THESE APPLIES TO EVERYONE IN THE GROUP EXCEPT THE ADMIN OF THE GROUP
            foundUser := update.Message.From.UserName
            if foundUser != os.Getenv("USER_NAME") {

                //welcome new users
                wc := update.Message.NewChatMembers
                if wc != nil {
                    var byt []map[string]string

                    jsonM, _ := json.Marshal(wc)

                    json.Unmarshal(jsonM, &byt)
                    for val := range byt {
                        if byt[val]["first_name"] != "" {
                            firstname := byt[val]["first_name"]

                            sendMsg := fmt.Sprintf("your message")
                            msg := tgbotapi.NewMessage(update.Message.Chat.ID, sendMsg)

                            bot.Send(msg)
                        }
                    }
                }

                if update.Message.NewChatMembers != nil {

                    up := update.Message
                    var addedUsers database.AddedUsers
                    jsonr, _ := json.Marshal(up)

                    json.Unmarshal(jsonr, &addedUsers)
                    insertID, _ := database.CreateMongoDoc(database.UserCollection, addedUsers)
                    fmt.Printf("Mongodb data created with ID: %v\n", insertID)

                }

                usersFirstname := update.Message.From.FirstName
                //delete messages that contains link sent by other users aside from the admin
                domain := urlChecker(update.Message.Text)
                if domain {

                    deleteMsg := tgbotapi.NewDeleteMessage(update.Message.Chat.ID, update.Message.MessageID)
                    bot.Send(deleteMsg)

                    //notify they user that links can't be sent to the group
                    sendMsg := fmt.Sprintf("%s The message you sent contains a link or you failed to add a space after the full stop(.). Links cannot be sent to this group", usersFirstname)
                    msg := tgbotapi.NewMessage(update.Message.Chat.ID, sendMsg)

                    bot.Send(msg)
                } else { //if the messages sent to the group is not a link

                    //check if the text message sent is not empty
                    if update.Message.Text != "" {
                        //check if the user have already added _ number of users to the group
                        countFilter := bson.M{"from.firstname": update.Message.From.FirstName}
                        addedUserCount := database.CountCollection(database.UserCollection, countFilter)
                        fmt.Printf("This is the number of users you have added to the group %v\n....", addedUserCount)
                        userNum := 5
                        if addedUserCount < userNum {
                            // delete the messages sent to the group by the user who have not added the set numbers of users
                            deleteMsg := tgbotapi.NewDeleteMessage(update.Message.Chat.ID, update.Message.MessageID)
                            bot.Send(deleteMsg)

                            fmt.Println(deleteMsg)
                            // and if not delete their message and notify them to first add _ numbers of users before they can send in messages
                            usersToAdd := userNum - addedUserCount
                            sendMsg := fmt.Sprintf("%s you have only added %v user(s). You need to add %v more user(s) to be able to send messages to this group. If you can't follow the process send a DM to @EXODUSTV to pay #500 and get verified to the VCF file", usersFirstname, addedUserCount, usersToAdd)
                            msg := tgbotapi.NewMessage(update.Message.Chat.ID, sendMsg)
                            // msg.ReplyToMessageID = update.Message.MessageID
                            bot.Send(msg)
                        }
                    }
                }

            }

        }
    }
}

This is the mongodb code:

package database

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/joho/godotenv"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)


var (
    UserCollection  *mongo.Collection = OpenCollection(Client, "users")
)

type AddedUsers struct {
    From           From             `json:"from"`
    NewChatMembers []NewChatMembers `json:"new_chat_members"`
}

type From struct {
    ID        int64  `json:"id"`
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
    Username  string `json:"username"`
}

type NewChatMembers struct {
    ID        int64  `json:"id"`
    FirstName string `json:"first_name"`
    LastName  string `json:"last_name"`
    Username  string `json:"username"`
}


func DbInstance() *mongo.Client {
    if err := godotenv.Load(); err != nil {
        log.Println("no env gotten")
    }
    MongoDb := os.Getenv("MONGO_URI")
    client, err := mongo.NewClient(options.Client().ApplyURI(MongoDb))
    if err != nil {
        log.Fatal(err)
    }

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    err = client.Connect(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("successfully connected to mongodb")
    return client
}

var Client *mongo.Client = DbInstance()

func OpenCollection(client *mongo.Client, collectionName string) *mongo.Collection {
    if err := godotenv.Load(); err != nil {
        log.Println("no env gotten")
    }
    databaseName := os.Getenv("DATABASE_NAME")
    var collection *mongo.Collection = client.Database(databaseName).Collection(collectionName)
    return collection
}

func GetMongoDoc(colName *mongo.Collection, filter interface{}) (*AddedUsers, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    var data AddedUsers

    if err := colName.FindOne(ctx, filter).Decode(&data); err != nil {
        return nil, err
    }

    return &data, nil
}

func GetMongoDocs(colName *mongo.Collection, filter interface{}, opts ...*options.FindOptions) (*[]AddedUsers, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    var data []AddedUsers

    filterCusor, err := colName.Find(ctx, filter, opts...)
    if err != nil {
        return nil, err
    }

    if err := filterCusor.All(ctx, &data); err != nil {
        return nil, err
    }

    return &data, nil
}

func CreateMongoDoc(colName *mongo.Collection, data interface{}) (*mongo.InsertOneResult, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    insertNum, insertErr := colName.InsertOne(ctx, data)
    if insertErr != nil {
        return nil, insertErr
    }

    return insertNum, nil
}

func CountCollection(colName *mongo.Collection, filter interface{}) int {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    count, err := colName.CountDocuments(ctx, filter)

    if err != nil {
        return 0
    }
    return int(count)
}

This is the code in my main.go file:

package main

import (
    "log"

    "github.com/iqquee/telebot/tele"
    "github.com/joho/godotenv"
)

func main() {
    if err := godotenv.Load(); err != nil {
        log.Println(".env not found")
    }

    tele.Bot()
}

After which you are done building your bot, you would need to deploy it to a server. Heroku doesn't work well with it so I would highly recommend you deploy your bot on https://railway.app. After your bot have been successfully deployed to the server, add your bot to the group you want it to manage for you and then make the bot an admin in the group. Your bot is now set :)

I hope this helps you build your own telegram bot. You can checkout this GitHub repository github.com/iqquee/telebot for the complete code.

Monnify Payment Gateway with Golang v1.4.0

Mathias Jiya — Mon, 22 Aug 2022 00:37:00 +0000

There have been a lot of updates to the monnify-go library since the last time I published an article on this subject.
Today' article is on the updates in the library as the previous methods in the library were updated alongside their request payload and some other new methods were added to the library as well.
The monnify-go library is now in its v1.4.0 and it contains all the API endpoints made available by monnify. This library (monnify-go) is properly documented as there is an example code for each of the methods available in the package to make it easy for anyone to use. You can visit the monnify-go github repo for the complete documentation of all the methods in the library.
Here are some code sample below:

Get Disburstment Wallet Balance

Use this to get disburstment wallet balance

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)

func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com"
    monnify.Options(apiKey, secretKey, baseUrl)

    walletId := "123"
    res, status, err := transaction.GetDisburstmentWalletBal(walletId)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Accept Payment

Use this to accept payments from customers

Use this object payload to implement the AcceptPayment() method

Note: CurrencyCode should be "NGN" for naira

type AcceptPaymentReq struct {
    PaymentReference    string `json:"paymentReference"`
    Amount              int    `json:"amount"`
    CurrencyCode        string `json:"currencyCode"`
    ContractCode        string `json:"contractCode"`
    CustomerEmail       string `json:"customerEmail"`
    CustomerName        string `json:"customerName"`
    CustomerPhoneNumber string `json:"customerPhoneNumber"`
    RedirectUrl         string `json:"redirectUrl"`
    PaymentDescription  string `json:"paymentDescription"`
}

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)

func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com" // for test
    monnify.Options(apiKey, secretKey, baseUrl)

    payload := transaction.AcceptPaymentReq{}

    res, status, err := transaction.AcceptPayment(payload)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Get Accepted Payment Status

Use this to get accepted payment status

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)

func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com" // for test
    monnify.Options(apiKey, secretKey, baseUrl)

    paymentReference := "ref123"
    res, status, err := transaction.GetTransactionStatus(paymentReference)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Initiate Single Transfer

Use this to initiate single transfers

Use this object payload to implement the InitiateSingleTransfer() method

type InitiateSingleTransferReq struct {
    Amount        int    `json:"amount"`
    Reference     string `json:"reference"`
    Narration     string `json:"narration"`
    BankCode      int    `json:"bankCode"`
    Currency      string `json:"currency"`
    AccountNumber int    `json:"accountNumber"`
    WalletId      string `json:"walletId"`
}

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)

func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com" // for test
    monnify.Options(apiKey, secretKey, baseUrl)

    payload := transaction.InitiateSingleTransferReq{}
    res, status, err := transaction.InitiateSingleTransfer(payload)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Single Transfer Details

Use this to get the initiated single transfer details

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)

func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com" // for test
    monnify.Options(apiKey, secretKey, baseUrl)

    paymentReference := "ref123"
    res, status, err := transaction.GetSingleTransferDetails(paymentReference)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Initiate Bulk Transfer

Use this to initiate bulk transfer

Use this object payload to implement the InitiateBulkTransfer() method

Note: Use BREAK to tell Monnify to reject the entire batch and use CONTINUE to tell Monnify to process the valid transactions for the OnValidationFailure field

type InitiateBulkTransferReq struct {
    Title                string                                   `json:"title"`
    BatchReference       string                                   `json:"batchReference"`
    Narration            string                                   `json:"narration"`
    WalletId             string                                   `json:"walletId"`
    OnValidationFailure  string                                   `json:"onValidationFailure"`
    NotificationInterval int                                   `json:"notificationInterval"`
    TransactionList      []InitiateBulkTransferReqTransactionList `json:"transactionList"`
}

type InitiateBulkTransferReqTransactionList struct {
    Amount        string `json:"amount"`
    Reference     string `json:"reference"`
    Narration     string `json:"narration"`
    BankCode      string `json:"bankCode"`
    AccountNumber string `json:"accountNumber"`
    Currency      string `json:"currency"`
}

package main

import (
    "fmt"
    monnify "github.com/iqquee/monnify-go"
    "github.com/iqquee/monnify-go/transaction"
)



func main() {
    apiKey := ""
    secretKey := ""
    baseUrl := "https://sandbox.monnify.com" // for test
    monnify.Options(apiKey, secretKey, baseUrl)

    payload := transaction.InitiateBulkTransferReq{}
    res, status, err := transaction.InitiateBulkTransfer(payload)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(status)
    fmt.Println(res)
}

Golang backend development guide for Beginners

Mathias Jiya — Wed, 10 Aug 2022 22:08:43 +0000

Starting out as a backend Go developer wasn't easy for me, I had a lot of ups and downs in search for resources to learn from. I didn't have a mentor to guide my steps and as such I had a stiff learning curve and I had to figure out about everything by my self with lots of google search. I knew what I had to go through just to arrive at where I am at the moment. I really don't wish for anyone to go through the same path I did when I started out because I was literally confused and as such I have put together some resources to help absolute beginners get started as a Go backend developer. Here is a link to the resource https://github.com/iqquee/Golang_roadmap_for_beginners. I am so much interested in helping beginners in any way I can so that they can have a smooth ride. I hope someone finds this helpful