Forem: Oleks

Still Typing URLs? Level Up Your Workflow with a Modern QR Code Generator! (And a Hot Tip 😉)

Oleks — Fri, 09 May 2025 10:31:08 +0000

Hey Devs!

In a world of instant everything, QR codes are still one of the slickest ways to bridge the physical and digital. Whether you're sharing your latest project link, a Wi-Fi password, contact details, or even pointing users to app downloads, a good QR code generator is an essential tool in your arsenal.

But with so many options out there, how do you pick one that doesn't just spit out a pixelated square, but actually works for you?

What Makes a QR Code Generator Truly Useful in 2025?

Beyond just encoding a URL, a top-notch QR code generator should offer:

Ease of Use: Nobody wants to fight with a clunky interface. A clean, intuitive experience is key.
Customization: The ability to add logos, change colors, and even play with shapes can make your QR codes more engaging and on-brand.
Variety of Data Types: From simple text and URLs to vCards, Wi-Fi access, calendar events, and more.
Dynamic QR Codes: This is a big one! The ability to change the destination URL after the QR code has been generated and printed is a lifesaver. No more reprinting everything for a tiny link change!
Analytics: Knowing how many times your QR code is scanned, and where, can be incredibly valuable.
Reliability & Speed: It should just work, every time, and generate codes quickly.
Developer Friendliness (Bonus!): For us devs, an API for programmatic QR code generation can be a massive plus for integrating into our own apps and workflows.

Cut Through the Noise: Give QRCodia.com a Spin!

Now, I know what you're thinking: "Another tool?" But hear me out. I've been on the lookout for a QR code solution that ticks all the right boxes without unnecessary complexity, and https://qrcodia.com has really caught my attention as a fantastic contender that you should definitely check out.

While many generators offer a piece of the puzzle, QRCodia.com appears designed with a focus on providing a smooth and efficient experience for creating the QR codes you need, quickly. If you're looking for a platform that potentially offers a great balance of powerful features (likecustomization options we talked about) with a user-friendly approach, QRCodia.com is shaping up to be a real winner.

Think about it:

Need to quickly generate a QR for your GitHub repo at a hackathon?
Want to create a custom-branded QR for your freelance business card?
Looking to share a link to your latest deployed app for easy mobile testing?

QRCodia.com is built for exactly these kinds of scenarios. While I'm still exploring all its nooks and crannies, the initial impression is that it aims to strip away the friction often found in other tools, letting you get to that useful QR code faster.

Why might QRCodia.com be your winner?

Focus on Simplicity & Power: It looks to provide the robust features you need without a steep learning curve.
Modern Interface: A clean and intuitive UI is always a breath of fresh air.
Versatility: Likely supports a good range of QR code types for various applications.

The best way to know if a tool is right for you is to try it. So, if you're in the market for a QR code generator that could simplify your life and boost your projects, I strongly suggest heading over to https://qrcodia.com.

Give it a try, and I'd love to hear your thoughts! What are your go-to QR code tools? What features do you find indispensable? Drop a comment below!

Happy coding (and QR-ing)!

Go middleware example. How to alter a HTTP handler result?

Oleks — Thu, 24 Oct 2019 13:39:29 +0000

Let's imagine a situation when you want to alter a result, returned by some http handler to the client. Fortunately, Golang provides an easy mechanism for that, called a middleware.

I will dive directly into the source code, to save your time.

Imagine, we have this simple webserver (here I'm using a chi router):

package main

import (
   "bytes""github.com/go-chi/chi""io""log""net/http"
)

func main() {
   r := chi.NewRouter()
   r.Get("/", myFirstHandler)

   http.ListenAndServe(":3000", r)
}

func myFirstHandler(w http.ResponseWriter, r *http.Request) {
   w.Write([]byte("This is a main page"))
}

When we run this application and visit a frontpage htttp://localhost:3000/, you can see this:

And now we got a new requirement to create another handler which should get all response data from myFirstHandler and add some modification on top.

We can do it easily in this way:

// Adds a new router handler with a middleware myMiddleware.  
r.With(myMiddleware).Get("/other", myFirstHandler)

To be able to read a response from another handler, we have to implement our own ResponseWriter:

type MyResponseWriter struct {
   http.ResponseWriter
   buf *bytes.Buffer
}

// Here we are implementing a Write() function from ResponseWriter with our custom instructions. 
func (myrw *MyResponseWriter) Write(p []byte) (int, error) {
   return myrw.buf.Write(p)
}

And finally, let's write our middleware:

func myMiddleware(next http.Handler) http.Handler {
   return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      // Create a response writer:
      myResponseWriter := &MyResponseWriter{
         ResponseWriter: w,
         buf:            &bytes.Buffer{},
      }
      // Here we are pssing our custom response writer to the next http handler.
      next.ServeHTTP(myResponseWriter, r)

      // Here we are adding our custom stuff to the response, which we received after http handler execution. 
      myResponseWriter.buf.WriteString(" and some additional modifications")

      // And, finally, we are copiing everything back to the original response writer.  if _, err := io.Copy(w, myResponseWriter.buf); err != nil {
         log.Printf("Failed to send out response: %v", err)
      }
   })
}

Now, if we run our server again and go to /other path, we will see this:

This was a silly example, which will never happen in real life, but, I hope you got an overview of how you can play with HTTP handlers and middlewares.

The source code you can find in this repository: https://github.com/alexsergivan/blog-examples/tree/master/middleware

How to make Nginx cache cookie aware?

Oleks — Tue, 18 Jun 2019 14:16:20 +0000

In this post, I'm going to describe how we can configure nginx to be able to cache responses based on the specific cookie value.

Let's imagine a situation when you want to do an A/B test on your website, where 50% of users should see new headline text on the page. Other 50% of visitors will continue see the old page. In this case, all your server-side manipulation about splitting users to different versions will be ignored by nginx cache (of course, if you have it).

It happens because nginx, by default, has this configuration:

proxy_cache_key $scheme$proxy_host$request_uri;

So, it will use the same cache key for all users, who requests page with the same url.

Luckily, nginx allows us easily to customize proxy_cache_key! What we need to do, it's just to add a specific cookie to this key:

proxy_cache_key $scheme$proxy_host$request_uri$cookie_MY_COOKIE_NAME;

And that's it! After this, if userA has MY_COOKIE_NAME=A and userB has MY_COOKIE_NAME=B they will receive different versions of page by the same url.

If you need more complex behaviour, where you won't use hardcoded cookie name in your nginx config, you can do something like this:

if ($http_cookie ~* "ab_(.*?)=([\w-]+)" ) {
  set $abcookie $1$2;
}

proxy_cache_key $scheme$proxy_host$request_uri$abcookie;

As you can see, you can use $http_cookie and generate proxy_cache_key based on specific cookie patterns. In this concrete example we check if http cookies contains cookie with regex pattern "ab_(.*?)=([\w-]+)" and if this cookie exists, we generate new variable for proxy_cache_key.

How to control router access permissions in Golang web application

Oleks — Fri, 17 May 2019 07:38:51 +0000

In this post I'm going to describe how can we limit user access to the specific url in golang web application. I will use chi router - a lightweight, idiomatic and composable router for building Go HTTP services.

Let's create our main package.

package main

import (
    "net/http"
    "github.com/go-chi/chi"
)

func main() {
  r := chi.NewRouter()

  r.Get("/", homePageHandler)
  r.Get("/admin", adminPageHandler)
  http.ListenAndServe(":3000", r)
}

func homePageHandler(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("This is home page")) 
}

func adminPageHandler(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("This is admin page")) 
}

After this, if we go to the /admin page, we will see "This is admin page".

Now, let's make this path accessible only for admin.

We have to replace

r.Get("/admin", adminPageHandler)
With
r.Mount("/admin", adminRouter())

Mount attaches another http.Handler or chi Router as a subrouter along a routing path.

Then, we have to attach middleware inside adminRouter() function.

func adminRouter() http.Handler {
    r := chi.NewRouter()
    // Middleware with access rules for router.
    r.Use(AdminOnly)
    r.Get("/", adminPageHandler)

    return r
}

In this middleware we have a simple check is user authorized to access this page or not.

func AdminOnly(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // If user is admin, allows access.
        if IsLoggedInAdmin(r) {
            next.ServeHTTP(w, r)
        } else {
            // Otherwise, 403.
            http.Error(w, http.StatusText(403), 403)
            return
        }

        return
    })
}

In sake of demonstration, I'm going just to use a random bool function to decide is used admin or not. You can modify this function according to your user authentication model.

func IsLoggedInAdmin(r *http.Request) bool {
    return rand.Float32() < 0.5
}

And that's it. Looks really simple, Isn't it?

Let's go to to the /admin page again.

As you see, now, sometimes (depends on our random decider), user has no access to this page anymore.

You can find source code here

How to test database interactions in golang applications

Oleks — Thu, 09 May 2019 08:12:33 +0000

Testing of functions with database interactions always was challenging. Recently, I found a wonderful library go-sqlmock which will simplify writing tests and mocking database queries in golang applications a lot. And I want to share a short example of how to work with it.

First, we have to install it

go get github.com/DATA-DOG/go-sqlmock

We have this function with SQL query:

func MenuByNameAndLanguage(ctx context.Context, db *sql.DB, name string, langcode string) (*models.Menu, error) {
    result, err := db.Query("SELECT id, langcode, title, link__uri, view_sidemenu FROM menu_link_content_data WHERE menu_name=? AND langcode=?",
         name,
         langcode,
    )
    defer result.Close()

    var menuLinks []models.MenuLink
    for result.Next() {
         menuLink := models.MenuLink{}
         err = result.Scan(&menuLink.ID, &menuLink.Langcode, &menuLink.Title, &menuLink.URL, &menuLink.SideMenu)
         menuLinks = append(menuLinks, menuLink)    
    }
    menu := &models.Menu{
         Name: name,
         Links: menuLinks,
    }
    return menu, err
}

This function just getting menu links by menu name and language.

And now let's test it.

We are going to test that MenuByNameAndLanguage function will return correct Menu structure.

package menu


import (
    "context"
    "testing"


    "github.com/DATA-DOG/go-sqlmock"
    "github.com/stretchr/testify/assert"
    "gitlab.mfb.io/user/graphql_server/models"
)


func TestShouldReturnCorrectMenu(t *testing.T) {

    // Creates sqlmock database connection and a mock to manage expectations.
    db, mock, err := sqlmock.New()

    if err != nil {
        t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    }
    // Closes the database and prevents new queries from starting.
    defer db.Close()

    // Here we are creating rows in our mocked database.
    rows := sqlmock.NewRows([]string{"id", "langcode", "title", "link__uri", "view_sidemenu"}).
        AddRow(1, "en", "enTitle", "/en-link", "0").
        AddRow(2, "en", "enTitle2", "/en-link2", "0")

    // This is most important part in our test. Here, literally, we are altering SQL query from MenuByNameAndLanguage
    // function and replacing result with our expected result. 
    mock.ExpectQuery("^SELECT (.+) FROM menu_link_content_data*").
        WithArgs("main", "en").
        WillReturnRows(rows)


    ctx := context.TODO()

    // Calls MenuByNameAndLanguage with mocked database connection in arguments list. 
    menu, err := MenuByNameAndLanguage(ctx, db, "main", "en")

    // Here we just construction our expecting result.
    var menuLinks []models.MenuLink
    menuLink1 := models.MenuLink{
        ID:       1,
        Title:    "enTitle",
        Langcode: "en",
        URL:      "/en-link",
        SideMenu: "0",
    }
    menuLinks = append(menuLinks, menuLink1)

    menuLink2 := models.MenuLink{
        ID:       2,
        Title:    "enTitle2",
        Langcode: "en",
        URL:      "/en-link2",
        SideMenu: "0",
    }

    menuLinks = append(menuLinks, menuLink2)

    expectedMenu := &models.Menu{
        Name:  "main",
        Links: menuLinks,
    }

    // And, finally, let's check if result from MenuByNameAndLanguage equal with expected result.// Here I used Testify library (https://github.com/stretchr/testify).
    assert.Equal(t, expectedMenu, menu)
}

As you see everything in this example was pretty straightforward.

For mo details, you can refer to GoDocs.