DEV Community: Krishan

Retrying HTTP Requests in Go Without Making It Worse

Krishan — Tue, 26 May 2026 21:15:09 +0000

When you call an external API, things go fine until they don't. A network blip, a server restart, a rate limit. So you add a retry, and most of the time it helps. The problem is that the obvious retry, the one we all write first, can quietly make things worse: it can resend a payment twice, or keep a struggling server down longer than the original failure would have.

In this post we'll build a retry client in Go from the naive version up, fix each thing that bites, and end somewhere a little uncomfortable: telling you to use a library instead. By the end you'll understand exactly what that library is doing, which is the real reason to read this.

The retry everyone writes first

Three tries, wait a second, give up. It looks reasonable, and there are three problems hiding in it.

First, the body. An HTTP client reads the request body to the end when it sends it, and it doesn't rewind. So on the second attempt there's nothing left to send, the server gets an empty POST, and it returns 400. Now you're retrying a 400 that you caused.

Second, the wait is the same for everyone. When a server starts returning 503s, every client retries on the same one-second tick, together, over and over. You haven't given it room to recover. You've lined everyone up to hit it again at the same moment. This is the thundering herd.

Third, you're retrying everything. A 400 means your request is wrong. A 404 means the thing isn't there. No amount of retrying changes either, but this loop treats every failure the same.

Three problems, and they don't get fixed in the same place. Let's take them one at a time.

Backoff: don't retry in lockstep

The wait between attempts should grow, and it shouldn't be identical for every client. Growing is exponential backoff. Not-identical is jitter. You want both.

Two details here are worth slowing down on, because they're the ones people get wrong.

I used a left shift instead of math.Pow(2, attempt). Floats are imprecise for this, and Base * 2^attempt overflows an int64 of nanoseconds sooner than you'd expect, which can wrap a careful 800ms wait into a negative number. Shifting integers and capping early avoids all of it.

And jitter is a wrapper, not a second copy of the exponential math. The tempting move is to write a separate ExponentialBackoffWithJitter type and duplicate the doubling inside it. Then your linear and constant strategies don't get jitter, and you've got the same logic in two places. Wrapping any Backoff keeps it in one place. One more thing: this is full jitter, random(0, d), not the wait give or take 25 percent, and the difference is the whole point. If every client jitters in a narrow band around the same target, they stay bunched together, just a slightly wider bunch. Picking uniformly across the entire [0, d) window is what actually scatters them. If you want the simulations behind that, AWS's Exponential Backoff and Jitter post has the graphs.

Make sleep mockable, and make it respect context

Here's a practical problem you hit the moment you write a test. If the test actually sleeps through exponential backoff, it actually takes seconds, and a suite full of them crawls.

So don't call time.Sleep directly. Put it behind an interface, and while you're there, make it cancellable.

That select on ctx.Done() is the part most hand-rolled retry loops miss. They check the context once at the top of the loop, then block on a plain time.Sleep for ten seconds. If the request is cancelled during that wait, nothing happens until the sleep ends. With the timer-and-context version, a cancelled request stops right away. On a deploy, that's the difference between a clean shutdown and a thirty-second hang.

The client, where everything comes together

Let's walk through the decisions, because they're the whole point.

We buffer the body once, up front, and only when it's a raw stream. Requests built with http.NewRequest from a bytes.Reader or a string already carry GetBody, so we reuse it instead of reading anything. We also don't mutate the request you passed in. (This does read the whole body into memory, so if you're streaming a very large upload, know that retries and streaming pull in opposite directions, and pick one on purpose.)

The default policy won't retry your POST, and this is the one I'd most want you to take away. A POST that timed out may have already succeeded on the server before the response got lost on the way back. Retry it blindly and you've charged the customer twice. So GET, HEAD, PUT and the other safe-to-repeat methods retry by default, and POST doesn't unless you opt in with an idempotency key. The policy gets the request so it can actually make that distinction.

Retry-After is respected and capped. If a server says wait two seconds, we wait two seconds. If a misconfigured server says wait 86400, we don't park the goroutine for a day. We also handle the HTTP-date form of the header, not just delta-seconds, since the spec allows both and the date form is the one that usually gets forgotten.

And when we finally give up, we hand back the last response with its body still open, plus an error. An earlier version of mine closed that body before returning it, which left the caller holding a response it couldn't read. Close it yourself and check the status if you want to know why we stopped.

Why a wrapper and not an http.RoundTripper? You can do it as a RoundTripper too, and it composes more cleanly into any http.Client. The trick is the one the code already uses: clone the request per attempt and replay the body rather than mutating the original. I used a plain wrapper here mainly to keep the retry loop explicit for the walkthrough, but the RoundTripper version is just as valid, and arguably more idiomatic for a cross-cutting concern.

Now the tests run in microseconds

Because the sleeper is mocked, we can assert the exact backoff schedule, prove Retry-After overrides the backoff, prove a cancelled context stops immediately, and prove a POST is left alone. None of it waits on a real clock. That last test, the one that pins the POST behaviour, is the one I'd be most nervous shipping without.

You probably shouldn't use any of this

Here's the uncomfortable turn. For real work, reach for a library. go-retryablehttp buffers bodies, respects Retry-After, does exponential backoff with jitter, and is wired into Terraform and Vault, so it has survived far more abuse than anything you or I will write this week. If you want a full HTTP client with a chainable API and JSON handling on top, resty has retries built in.

So why build it at all? Because now you can open that library's source and read it as a set of decisions instead of magic: why it buffers, why it clones the request, why its default policy is careful about methods. The day it does something surprising, you're debugging a thing you understand. That was the deliverable all along. Not the code, the understanding.

What actually bites people

A few things that aren't obvious until they catch you.

Idempotency is the big one. Retrying is safe right up until the operation has a side effect, and then it isn't. Make the operation idempotent, send an idempotency key, or don't retry it. There's no fourth choice that ends well.

Logging is the quiet one. The instinct is to log the full request and response on every retry, and then your logs fill with duplicated payloads, some of them carrying tokens. Log the attempt number, the status, and the endpoint. Not the body.

Timeouts catch people who think retries replace them. They don't. The HTTP client timeout is per attempt, and your overall deadline belongs in the context. Those are two different clocks, and you want both, or one slow call holds your whole retry loop hostage.

And the one worth saying out loud: retries are most dangerous in a chain. If service A retries B three times, and B retries C three times, a small hiccup in C arrives at C as nine times the load. Stack a few layers and you get a retry storm that keeps a system down well after the original cause is gone. The fix is a retry budget: cap retries to a small fraction of your request rate so a bad minute can't multiply into an outage. Single-server jitter handles the herd. A budget handles the chain. Real systems need both.

The full implementation is in the gist above. Clone it, run the tests, then break something and watch what the tests tell you. That's how it stuck for me, and how it'll stick for you. Happy coding.

Build a CLI TODO App with Goravel Console

Krishan — Fri, 30 May 2025 20:53:16 +0000

Hello Everyone! It's been a while since I last wrote a blog post, but I'm back with something fresh(at least for me) post. In this post, we'll be building a command-line TODO app using Goravel console.

But before we dive in, let me introduce you to a framework called Goravel.

What is Goravel?

You may have used Laravel (personally, I’ve used it a lot!). I love its developer-friendly experience and straightforward architecture. However, for the Go community, something similar was missing. Enter Goravel—a framework that makes life easier for PHP developers like me who want to work with Go.

Goravel borrows best practices and features from Laravel, bringing them into the Go ecosystem.

That’s enough introductions. Let’s dive into what we’re building today!

Prerequisites

Before we dive in, make sure you have:

Go 1.21 or higher installed
Basic understanding of Go syntax
Familiarity with command-line interfaces
SQLite (we'll use it for simplicity, but you can swap it for any database)

Don't worry if you're new to Goravel—I'll explain everything as we go!

What are we building?

This article focuses on learning Goravel's console, so we will implement only the following two features in about command line todo application:

Add a new task.
View all tasks

You can checkout source code of the todo application at kkumar-gcc/todo.

Project Structure

Project will be structured in following way where each folders servers their respective purpose as name sounds:

constants/           # Store constants or config for the application
  └── version.go

console/
  ├── commands/      # Implement commands
  │   └── add_task.go
  └── kernel.go      # Register all commands

models/
  └── task.go        # Model definition for a task

services/            # Handle business logic
  └── task_service.go # Service for CRUD operations on tasks

repositories/        # Layer between the database and business logic
  └── task_repository.go

database/
  └── database.go    # Logic for interacting with and resolving the database

main.go              # Application entry point

Project Initialization

In the last section, we have outlined the project structure. Now, let's create these folders (files) and initialize a Go project named github.com/kkumar-gcc/todo.

mkdir todo
cd todo

go mod init github.com/kkumar-gcc/todo

Install the Goravel framework:

go get github.com/goravel/framework

Let's create, the entry point of the application main.go where all magical thing will happen.

package main

import (
    "os"

    goravelconsole "github.com/goravel/framework/console"
    "github.com/goravel/framework/support/color"

    "github.com/kkumar-gcc/todo/constants"
)

func main() {
    name := "todo"
    usage := "TODO"
    usageText := "todo [global options] command [command options] [arguments...]"

  // The last argument is false, which indicates that it is not an artisan command.
    cli := goravelconsole.NewApplication(name, usage, usageText, constants.Version, false)

  // run the any command called in os.Args
    if err := cli.Run(os.Args, false); err != nil {
        color.Red().Println(err)
    }
}

Here, we’re creating and running a Goravel console instance with custom metadata for the TODO application. Running go run . will show the default help message.

Create your first Goravel command.

Now that the initial setup is complete, let's create our first Goravel command by adding a file named add_task_command.go inside the console/commands directory. Every Goravel command must implement the github.com/goravel/framework/contracts/console/command.Command interface.
Here's how you can define the AddTaskCommand:

package commands

import (
    "github.com/goravel/framework/contracts/console"
    "github.com/goravel/framework/contracts/console/command"
)

type AddTaskCommand struct {}

// Signature The name and signature of the console command.
func (r *AddTaskCommand) Signature() string {
    return "task:add"
}

// Description The console command description.
func (r *AddTaskCommand) Description() string {
    return "Create a new task"
}

// Extend The console command extend.
func (r *AddTaskCommand) Extend() command.Extend {
    return command.Extend{}
}

// Handle Execute the console command.
func (r *AddTaskCommand) Handle(ctx console.Context) (err error) {
    ctx.Success("Hello world!")
    return nil
}

Let's understand the command structure:

Signature : Serves as a identifier for the command (must be unique)
Description: Displays the description when the help flag is used.
Extend: Defines the Category and Flags for the command.
Handle: The entry point for the command. It accepts an instance of github.com/goravel/framework/console.Context, which offers many convenient methods for command I/O (Read More).

Register the command

To register a command, open main.go and use the Register method provided by the Goravel console:

// main.go
package main

import (
    "os"

    goravelconsole "github.com/goravel/framework/console"
    "github.com/goravel/framework/contracts/console"
    "github.com/goravel/framework/support/color"

    "github.com/kkumar-gcc/todo/console/commands"
    "github.com/kkumar-gcc/todo/constants"
)

func main() {
    ...

    cli := goravelconsole.NewApplication(name, usage, usageText, constants.Version, false)

  cli.Register([]console.Command{
        &commands.AddTaskCommand{},
  })

  ...
}

We have successfully registered the command. Let’s test it out by running the following in the terminal:

go run . task:add

Output:

Hurray!! We've created our first command successfully. However, as your application grows, you will likely have many commands - or commands that accepts dependencies. To keep things clean and maintainable, it's a good idea to centralize command registration in a dedicated console/kernel.go file and then use the kernel in main.go.

Define the Kernel

Create the console/kernel.go file and register commands there:

package console

import (
    "github.com/goravel/framework/contracts/console"

    "github.com/kkumar-gcc/todo/console/commands"
)

type Kernel struct {
}

func (kernel *Kernel) Commands() []console.Command {
    return []console.Command{
        &commands.AddTaskCommand{},
    }
}

Now let's update main.go to use the kernel:

package main

...

func main() {
     ...

     kernel := &console.Kernel{}

     cli.Register(kernel.Commands())

     ...

}

Now that we have setup everything, we are ready to implement the actual logic of the task:add command. But before we do that, let's define the Task model, which will represent and store task data in the database.

package models

import "time"

type Task struct {
    ID          int        `json:"id"`
    Title       string     `json:"title"`
    Status      int        `json:"status"` // Use constants: constants.StatusPending(1), constants.StatusInProgress(2), constants.StatusCompleted(3)
    CreatedAt   time.Time  `json:"created_at"`
    CompletedAt *time.Time `json:"completed_at,omitempty"`
    Priority    int        `json:"priority"` // Use constants: constants.PriorityLow(1), constants.PriorityMedium(2), constants.PriorityHigh(3)
    Tags        string     `json:"tags"`     // Tags for categorization
}

Handling User Input

Goravel console offers two ways to take named input from the terminal: the first is by defining Flags (Options and the second is by prompting For Input in terminal. We will use both - flags as the primary input method and interactive prompts as a fallback.

We require the user to provide title, status, priority and tags(Optional) to create a task. Let's define flags for each input inside the Extend method of AddTaskCommand.

// add_task_command.go
package commands

...

func (r *AddTaskCommand) Extend() command.Extend {
    return command.Extend{
        Category: "tasks",
        Flags: []command.Flag{
            &command.StringFlag{
                Name:    "title",
                Aliases: []string{"t"},
                Usage:   "The title of the task",
            },
            &command.StringFlag{
                Name:    "priority",
                Aliases: []string{"p"},
                Usage:   "The priority of the task (low, medium, high)",
            },
            &command.StringFlag{
                Name:    "status",
                Aliases: []string{"s"},
                Usage:   "The status of the task (pending, in-progress, completed)",
            },
            &command.StringFlag{
                Name:    "tags",
                Aliases: []string{"g"},
                Usage:   "Tags for the task, separated by commas",
            },
        },
    }
} 

...

Accessing Flag Values

You can pass these flags using (--{name} {value} or -{alias} {value}) when executing the command . To access them, use ctx.Option("{name}") in Handle method.

package commands

...

func (r *AddTaskCommand) Handle(ctx console.Context) (err error) {
    title := ctx.Option("title")
    priority := ctx.Option("priority")
    status := ctx.Option("status")
    tags := ctx.Option("tags")

    println(title, priority, status, tags)
    return nil
}

Try running:

go run . task:add --title "write article" -p 1 -s 2

If you want the flag value in a specific type, Goravel provides methods like OptionInt, OptionSlice etc.

Interactive Prompts for Missing Input

We have handled input via flags, but what if some required fields are missing? Let's use interactive prompts to ensures title, priority and status are always provided.

Goravel console provides various convenient methods to prompt the user.

package commands

...

func (r *AddTaskCommand) Handle(ctx console.Context) (err error) {
    title := ctx.Option("title")
    priority := ctx.Option("priority")
    status := ctx.Option("status")
    tags := ctx.Option("tags")

    if title == "" {
        title, err = ctx.Ask("What is the title of the task?", console.AskOption{
            Placeholder: "E.g., Write article",
            Prompt:      "> ",
            Validate: func(value string) error {
                if strings.TrimSpace(value) == "" {
                    return errors.New("the task title is required")
                }
                return nil
            },
        })
        if err != nil {
            ctx.Error(err.Error())
            return nil
        }
    }

    if priority == "" {
        choices := []console.Choice{
            {Key: constants.PriorityColors[constants.PriorityLow], Value: strconv.Itoa(constants.PriorityLow)},
            {Key: constants.PriorityColors[constants.PriorityMedium], Value: strconv.Itoa(constants.PriorityMedium)},
            {Key: constants.PriorityColors[constants.PriorityHigh], Value: strconv.Itoa(constants.PriorityHigh)},
        }
        priority, err = ctx.Choice("Select the priority of the task:", choices, console.ChoiceOption{
            Default:     strconv.Itoa(constants.PriorityLow),
            Description: "Choose a priority for the task",
        })
        if err != nil {
            ctx.Error(err.Error())
            return nil
        }
    }

    if status == "" {
        choices := []console.Choice{
            {Key: constants.StatusColors[constants.StatusPending], Value: strconv.Itoa(constants.StatusPending)},
            {Key: constants.StatusColors[constants.StatusInProgress], Value: strconv.Itoa(constants.StatusInProgress)},
            {Key: constants.StatusColors[constants.StatusCompleted], Value: strconv.Itoa(constants.StatusCompleted)},
        }
        status, err = ctx.Choice("Select the status of the task:", choices, console.ChoiceOption{
            Default:     strconv.Itoa(constants.StatusPending),
            Description: "Choose a priority for the task",
        })
        if err != nil {
            ctx.Error(err.Error())
            return nil
        }
    }

    if tags == "" {
        tags, err = ctx.Ask("Enter tags for the task (comma-separated):", console.AskOption{
            Placeholder: "E.g., work,urgent",
            Prompt:      "> ",
        })
        if err != nil {
            ctx.Error(err.Error())
            return nil
        }
    }

priorityInt, err := strconv.Atoi(priority)
    if err != nil {
        ctx.Error(err.Error())
        return nil
    }

    statusInt, err := strconv.Atoi(status)
    if err != nil {
        ctx.Error(err.Error())
        return nil
    }
       println(priorityInt, statusInt)

return nil
}

You can refer to the docs for each method. For example, Ask accepts a question and an optional second argument console.AskOption struct. In our case, we added a Validate function that runs whenever the user presses Enter key. If the input is invalid, it will shows an error and waits for valid input.

Integrating the Service Layer

Now that we have collected all required fields, let's define a services.TaskService interface to handle task creation and listing. Let's accept TaskService as a struct level argument in AddTaskCommand. Implementation of TaskService is not part of this article if you want to check you can read source code.

// task_service.go
package services

type TaskService interface {
    CreateTask(ctx context.Context, title string, status, priority int, tags string) error
    GetAllTasks(ctx context.Context, status, priority int, sort string) ([]models.Task, error)
}

// update add_task_command.go
...

type AddTaskCommand struct {
    TaskService services.TaskService
}

// update kernel.go

...

func (kernel *Kernel) Commands() []console.Command {
        // init the service
        taskService := services.NewTaskService()
    return []console.Command{
        &commands.AddTaskCommand{
                       TaskService: taskService,                                      
                },
    }
}

Completing the Add Task Command

Now we can call TaskService.CreateTask() to create the task using the collected input

package commands

...
func (r *AddTaskCommand) Handle(ctx console.Context) (err error) {
        ...

if err := r.TaskService.CreateTask(context.Background(), title, statusInt, priorityInt, tags); err != nil {
        ctx.Error(err.Error())
        return nil
    }

    ctx.Success("Task created successfully!")
    return nil
}

Creating the List Tasks Command

Hurray!! we have completed our first full implementation of command. Now let's create another command, task:list, to view tasks. We'll explore how to beautifully display output using Goravel's console methods.

// list_tasks_command.go
package commands

import (
    "context"
    "time"

    "github.com/goravel/framework/contracts/console"
    "github.com/goravel/framework/contracts/console/command"
    "github.com/goravel/framework/support/color"

    "github.com/kkumar-gcc/todo/constants"
    "github.com/kkumar-gcc/todo/models"
    "github.com/kkumar-gcc/todo/services"
)

type ListTasksCommand struct {
    TaskService services.TaskService
}

// Signature The name and signature of the console command.
func (r *ListTasksCommand) Signature() string {
    return "task:list"
}

// Description The console command description.
func (r *ListTasksCommand) Description() string {
    return "List all tasks"
}

// Extend The console command extend.
func (r *ListTasksCommand) Extend() command.Extend {
    return command.Extend{
        Category: "tasks",
    Flags: []command.Flag{
            &command.StringFlag{
                Name:    "sort",
                Aliases: []string{"s"},
                Usage:   "Sort tasks by field (status or priority)",
            },
            &command.StringFlag{
                Name:    "status",
                Aliases: []string{"st"},
                Usage:   "Filter tasks by status (pending, in_progress, completed)",
            },
            &command.StringFlag{
                Name:    "priority",
                Aliases: []string{"p"},
                Usage:   "Filter tasks by priority (low, medium, high)",
            },
        },
    }
}

// Handle Execute the console command.
func (r *ListTasksCommand) Handle(ctx console.Context) (err error) {
    sort, status, priority := ctx.Option("sort"), ctx.Option("status"), ctx.Option("priority")
   tasks, err := r.TaskService.GetAllTasks(context.Background(), constants.StatusMap[status], constants.PriorityMap[priority], sort)
    if err != nil {
        ctx.Error(err.Error())
        return nil
    }
    if len(tasks) == 0 {
        ctx.Info("No tasks found matching the given criteria.")
        return nil
    }


    ctx.NewLine()
    color.Println("<fg=blue;op=bold>Task List:</>")
    ctx.NewLine()

    ctx.TwoColumnDetail(color.Sprintf("<fg=cyan;op=bold>%s</>", "tasks"), "Details")
    for _, task := range tasks {
        idLabel := color.Sprintf("<fg=white;op=bold>%d</>", task.ID)
        statusLabel := constants.StatusColors[task.Status]
        priorityLabel := constants.PriorityColors[task.Priority]
        tagsAndCreatedAt := color.Sprintf("<fg=gray>Tags: %s, Created At: %s</>", task.Tags, task.CreatedAt.Format(time.RFC822))
        ctx.TwoColumnDetail(task.Title+" ("+idLabel+") "+tagsAndCreatedAt, statusLabel+" | "+priorityLabel)
    }
    ctx.NewLine()

    return nil
}

console.Context provides convenient methods like TwoColumnDetail and Info, Spinner, WithProgressBar etc. to display rich output in the terminal.

That's a wrap!

We've built a working TODO CLI app with Goravel Console. Pretty neat how easy it was, right? From commands to interactive prompts to colorful output - Goravel handled it all beautifully.

Want to take it further? Try adding update/delete commands or maybe due dates.

Check out the complete code at kkumar-gcc/todo.

How to Import and Export Excel and CSV Files in Laravel 9

Krishan — Wed, 08 Feb 2023 10:54:56 +0000

Laravel 9 is a popular PHP framework that makes it easy to build robust and scalable web applications. One of the important features of any web application is the ability to import and export data in different formats. This can be particularly useful when you need to transfer data from one system to another, or when you need to store data for later use. In this tutorial, we’ll look at how to import and export Excel and CSV files in Laravel 9 using the Maatwebsite\Excel package.

The Maatwebsite\Excel package is a popular package that makes it easy to work with Excel and CSV files in Laravel. It provides a simple API that you can use to import and export data with just a few lines of code. This package also supports multiple file formats, so you can choose the format that works best for your needs.

Step 1: Install the Package

To get started, you need to install the Maatwebsite\Excel package. You can install it using composer:

composer require maatwebsite/excel

Step 2: Create a Model

In this step, you need to create a model that represents the data you want to import and export. For example, if you want to import and export products, you can create a Product model.

php artisan make:model Product

Step 3: Create a Migration

Next, you need to create a migration that creates the products table in your database. You can use the following command to create a migration:

php artisan make:migration create_products_table

If you would like to generate a database migration when you generate the model, you may use the --migration or -m option in step 2

Then, open the created migration file and add the following code:

public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description');
        $table->double('price');
        $table->timestamps();
    });
}

Finally, run the following command to apply the migration:

php artisan migrate

Step 4: Create a Controller

Now, you need to create a controller that will handle the import and export operations. You can create a controller using the following command:

php artisan make:controller ProductController

Step 5: Import Data

In this step, you’ll add the code that imports the data from the Excel or CSV file into the products table in your database. Open the ProductController file and add the following code:

//...
use Illuminate\Http\Request;
use Maatwebsite\Excel\Facades\Excel;
use App\Models\Product;

class ProductController extends Controller
{
    public function index()
    {
        return view('import');
    }
    //...
    public function import(Request $request)
    {
        $file = $request->file('file');
        Excel::import(new ProductsImport, $file);
        return back()->with('success', 'Products imported successfully.');
    }
}

In this code, you first retrieve the uploaded file from the request object. Then, you import data to ProductsImport using the import method of the Excel façade. This class extends the Maatwebsite\Excel\Concerns\ToModel interface, which provides the necessary methods for importing data from an Excel or CSV file into a database table.

php artisan make:import ProductsImport --model=Product

This will create a new file named ProductsImport.php in the app/Imports directory. The --model=Product option specifies the name of the model class that will be used to store the imported data.

use Maatwebsite\Excel\Concerns\ToModel;
use Illuminate\Support\Facades\Hash;
use App\Models\Product;

class ProductsImport implements ToModel
{
    public function model(array $row)
    {
        return new Product([
            'name' => $row[0],
            'description' => $row[1],
            'price' => $row[2],
        ]);
    }
}

This code implements the ProductsImport class and implements the model method, which takes an array of data for each row as an argument and returns a new Product model instance populated with the data from that row.

Step 6: Export Data

In this step, you’ll add the code that exports the data from the products table in your database to an Excel or CSV file. Open the ProductController file and add the following code:

//....
class ProductController extends Controller
{
    //...
    public function export()
    {
        return Excel::download(new ProductsExport, 'products.xlsx');
    }
}

In this code, you use the download method of the Excel facade to download the data from the ProductsExport class. The ProductsExport class is responsible for preparing the data that needs to be exported. To create this class, you can use the following command:

php artisan make:export ProductsExport --model=Product

This command will create a new export class in the app/Exports directory. Open this file and add the following code:

use Maatwebsite\Excel\Concerns\FromCollection;
use App\Product;
class ProductsExport implements FromCollection
{
    public function collection()
    {
        return Product::all();
    }
}

In this code, you implement the FromCollection interface, which requires you to implement the collection method. In this method, you return the collection of all products using the all method of the Product model.

Step 7: Add Routes

Finally, you need to add routes for the import and export operations. Open the routes/web.php file and add the following code:

Route::get('/import', [ProductController::class,"index"]);
Route::post('/import', [ProductController::class,"import"]);
Route::get('/export', [ProductController::class,"export"]);

In this code, you add two routes for the import operation, one for the GET request and one for the POST request. The GET request is used to display the form for uploading the file, and the POST request is used to handle the file upload and import the data. You also add a route for the export operation, which returns the Excel or CSV file with the data.

Step 8: Create the View

Finally, you need to create a view that will have the form to import the file and a button to export the data.

<form action="{{ url('/import') }}" method="post" enctype="multipart/form-data">
    @csrf
    <input type="file" name="file">
    <button type="submit">Import</button>
</form>

<a href="{{ url('/export') }}">Export</a>

That’s it! You now have a complete Laravel 9 application that can import and export Excel and CSV files. You can customize this code as per your requirements. You can add validation to the imported data, and you can also add a confirmation message before exporting the data.

Conclusion

In this tutorial, you learned how to import and export Excel and CSV files in Laravel 9 using the Maatwebsite\Excel package. This package provides a simple and easy-to-use API that makes it possible to import and export data with just a few lines of code. You can use this package to handle data transfer between different systems or to store data for later use. With the help of this package, you can simplify your data import and export process and improve the efficiency of your web application.I hope this tutorial helps you in your Laravel projects.Happy coding!

How to Implement an Autocomplete Typeahead Search Feature in Laravel

Krishan — Thu, 02 Feb 2023 18:09:55 +0000

Laravel is a popular open-source PHP framework that is widely used for building web applications. It provides a lot of features and functionalities that make web development easier and faster. One of these features is the Typeahead search, also known as Autocomplete search.

Autocomplete search is a feature that helps users to find the desired content by suggesting possible options as they type. It is a useful tool that can make the search process more intuitive and convenient for the users. In this article, we will explore how to implement the Typeahead search in Laravel.

Prerequisites

Before we start, make sure that you have a Laravel project setup. If you don't, you can follow the Laravel installation guide. You also need to have basic knowledge of HTML, CSS, JavaScript, and PHP.

Implementing Typeahead search in Laravel

To implement the Typeahead search in Laravel, we need to create a search form and a controller to handle the search requests. We will also use the Typeahead library to display the search suggestions.

Step 1: Installing Typeahead library

To install the Typeahead library, we can use a package manager like npm. Open the terminal and navigate to your Laravel project directory. Run the following command to install the jQuery Typeahead plugin:

npm install jquery-typeahead

Step 2: Creating a search form

To create a search form, we will use the HTML form element. Open resources/views/welcome.blade.php file and add the following code:

<head>
    //......

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jquery-typeahead/2.11.2/jquery.typeahead.css"
        integrity="sha512-zPDjm5fHC6JUi5jEnhJetvp1zLvc1Dd5TuMFQQtqRH0KpOzrng4vHiFu2Eva+Xgu7umz0lqGHkmGjUYdeSW54w=="
        crossorigin="anonymous" referrerpolicy="no-referrer" />
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-typeahead/2.11.2/jquery.typeahead.js"
        integrity="sha512-8+3AF+qMeZ3HSeKKru1YD5pFbXnIxUvMH1UsK8sKbHwbj5ZixBtDP+8oMMkBeaZc8TIIOjHnxN++zCPhHWCrMQ=="
        crossorigin="anonymous" referrerpolicy="no-referrer"></script>
</head>
<body>
  // .....

  <form action="{{ url('search') }}" method="GET">
     <div class="typeahead__container">
          <div class="typeahead__field">
               <div class="typeahead__query">
                    <input class="typeahead"
                                 name="query"
                                 autocomplete="off">
                </div>
                <div class="typeahead__button">
                     <button type="submit">
                             <span class="typeahead__search-icon"></span>
                     </button>
                </div>
           </div>
     </div>
  </form>

  //....

  @vite(['resources/js/app.js'])

</body>

In the code above, we have created a form with a text input field and a submit button. The input field has a typeahead class that we will use in the next step to initialize the Typeahead library.

Step 3: Initializing Typeahead library

To initialize the Typeahead library, we will use the JavaScript code. Open the public/js/app.js file and add the following code:

import $ from "jquery";
import "jquery-typeahead";

$(function () {
    $.typeahead({
        input: ".typeahead",
        hint:true,
        minLength:2,// default
        source: {
            groupName: {
                // Ajax Request
                ajax:  function (query) {
                    return {
                        type: "GET",
                        url: "/search/suggestions",
                        data: {
                            query: "{{query}}"
                        },
                        callback: {
                            done: function (data) {
                                return data;
                            }
                        }
                    }
                }
            }
        }
    });
});

In the code above, we have used the jQuery $(function () {} function to make sure that the Typeahead library is initialized after the page has loaded. We have also used the $.typeahead() function to initialize the Typeahead library on the text input field with the typeahead class.
We have also passed an object with some configuration options to the typeahead function. The options are:

hint: This option is set to true so a suggestion text will appear if there is an item inside the result list that starts by the user query, also pressing the right arrow at the end of the search input text will autocomplete the query with the suggested hint.
highlight: This option is set to true to highlight the matching part of the suggestion.
minLength: This option sets the minimum number of characters that need to be typed before the suggestions start appearing.
source : The source option corresponds to the data set(s) that Typeahead will look through to find matches for the user query string.Inside the source, you can have multiple lists of data (groups) . You can config source.group:
- ajax : This function makes an AJAX request to the /search/suggestions endpoint with the query to get the suggestions.

Step 4: Creating a controller

To handle the search requests, we need to create a controller. Run the following command to create a controller:

php artisan make:controller SearchController

This command will create a SearchController class in the app/Http/Controllers directory. Open the app/Http/Controllers/SearchController.php file and add the following code:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Product;

class SearchController extends Controller
{
    public function index(Request $request)
    {
        $query = $request->input('query');
        $products = Product::where('name', 'like', "%$query%")->get();

        return view('search', compact('products'));
    }

    public function suggestions(Request $request)
    {
        $query = $request->input('query');
        $suggestions = Product::where('name', 'like', "%$query%")->pluck('name');

        return response()->json($suggestions);
    }
}

We are looking in the Product model (used in the previous blog). You are free to use any other model you choose.

In the code above, we have created two methods in the SearchController class. The index method handles the search requests and retrieves the products with names that match the query. The suggestions method returns the suggestions for the Typeahead search.

Step 5: Creating routes

To map the search form to the SearchController class, we need to create routes. Open the routes/web.php file and add the following code:

Route::get('/', function () {
    return view('welcome');
});
Route::get('search', [SearchController::class,'index']);
Route::get('search/suggestions', [SearchController::class,'suggestions']);

In the code above, we have created two routes. The first route maps the / endpoint to the home view. The second route maps the search endpoint to the index method of the SearchController class. The third route maps the search/suggestions endpoint to the suggestions method of the SearchController class.

Step 6: Creating a view

To display the search results, we need to create a view. Create a new file resources/views/search.blade.php and add the following code:

<table class="table">
    <thead>
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Price</th>
        </tr>
    </thead>
    <tbody>
        @foreach ($products as $product)
            <tr>
                <td>{{ $product->id }}</td>
                <td>{{ $product->name }}</td>
                <td>{{ $product->price }}</td>
            </tr>
        @endforeach
    </tbody>
</table>

In the code above, we have created a table to display the search results. The $products variable contains the search results that are passed from the SearchController class. The @foreach loop iterates through the $products array and displays the product information in the table.

Step 7: Testing the application

Finally, we are ready to test the application. Start the development server by running the following command:

php artisan serve

Open a web browser and go to http://localhost:8000. You should see the Typeahead search form. Start typing in the search form, and you should see the suggestions appear below the input field. Select a suggestion, and you should be redirected to the search results page that displays the matching products.

Conclusion

In this tutorial, we have learned how to implement a Typeahead search feature in Laravel. We have used the jQuery Typeahead plugin and created a search form, a controller, routes, and a view to handle the search requests and display the results. By following the steps in this tutorial, you should be able to implement a Typeahead search feature in your own Laravel applications.

Creating PDF Files in Laravel 9: A Step-by-Step Guide using DomPDF

Krishan — Fri, 27 Jan 2023 08:33:34 +0000

Creating PDF files in Laravel is a common task for many web applications. Whether it’s for invoices, reports, or other types of documents, the ability to generate PDFs can be a valuable feature for your users. In this tutorial, we will show you how to create PDF files in Laravel 9 using the laravel-dompdf package.

Step 1: Install DomPDF

The first thing you need to do is add the DomPDF package to your laravel-app. You can do this by running the following command in Composer:

composer require barryvdh/laravel-dompdf

Step 2: Register the Service Provider

Once the package is installed, you need to register the service provider in the config/app.php file. You can do this by adding the following line to the providers array:

'providers' => [
    // ...
    Barryvdh\DomPDF\ServiceProvider::class,
],

Next, we’ll add an alias for the package to the aliases array in the same file:

'aliases' => [
    // ...
    'PDF' => Barryvdh\DomPDF\Facade::class,
],

Step 3: Create a Route

Next, you need to create a route that will handle the PDF generation. In this example, we will create a route that generates a PDF from an HTML view.

Route::get('/pdf', function () {
    $pdf = PDF::loadView('invoice', $data);
    return $pdf->download('invoice.pdf');
});

The above code will take the invoice view and data, and generate a PDF that the user can download. The download method is used to prompt the user to download the file.

Step 4: Create a View

Now you need to create an HTML view that will be used as the template for the PDF. You can do this by creating a new file in the resources/views folder called invoice.blade.php. This file can contain any HTML and CSS that you want to be included in the PDF.

Step 5: Customize and Style the PDF

You can customize the PDF by editing the view file or you can use css file separately. You can use the following code in order to include css file in pdf.

$pdf = PDF::loadView('invoice')->setPaper('a4', 'portrait')->setWarnings(false);
return $pdf->download('invoice.pdf');

Step 6: Download or Save the PDF

Finally, you can use the download method to prompt the user to download the PDF or use the save method to save it to a specific location on your server.

Route::get('/pdf', function () {
    $pdf = PDF::loadView('invoice', $data);
    return $pdf->save('/path-to/my_stored_file.pdf')->stream('invoice.pdf');
    //return $pdf->download('invoice.pdf');
});

In conclusion, creating PDF files in Laravel 9 is a simple task that can be accomplished using the laravel-dompdf package. By following the steps outlined in this tutorial, you can easily generate PDFs for your web application. This can be a great feature for creating invoices, reports, and other types of documents, with the added benefit of being SEO optimized.

I hope this tutorial has been helpful in understanding how to use DomPDF to generate PDFs in Laravel 9. Happy coding!

Program for Fibonacci Numbers

Krishan — Wed, 10 Aug 2022 14:02:00 +0000

What is the Fibonacci series?

The Fibonacci sequence is a sequence where the next term is the sum of the previous two terms. The first two terms of the Fibonacci sequence are 0 followed by 1.

The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21 ....

In mathematical terms,the sequence Fn of Fibonacci numbers is defined by recursion relation

Fn = Fn-1 + Fn-2

where

F0 = 0 , F1 = 1

We will discuss three ways to write the Fibonacci series program :

Fibonacci series using recursion
Fibonacci series using Iterative method
Fibonacci series using Matrix Exponentiation

(1) Recursive Method :

A simple method that is a direct recursive implementation mathematical recurrence relation is given above.

//pseudo code 
RFib(n)
{
  if n=0 return 0;
    else if n=1 return 1;
         else return (RFib(n-1)+RFib(n-2));
}

Time Complexity: T(n) = T(n-1) + T(n-2) which is exponential.
Extra Space: O(n) if we consider the function call stack size, otherwise O(1).

Run Replit

(2) Iterative Method :

We can optimize the space used in Recursive Method by storing the previous two numbers only because that is all we need to get the next Fibonacci number in series.

//pseudo code 
IFib(n)
if n=0 return 0;
   else if n=1 return 1;
        else {   a <= 0; b<=1;
            for(i=2 to n) do
            { temp <= b;
              b<= a+b;
              a <= temp;
            }
return b;

Time complexity: O(n)
Extra space: O(1)

Run Replit

(3) Matrix Exponentiation :

Let n > 1

Time complexity : O(log(n))
Extra space : O(log(n)) if we consider the function call stack size, otherwise O(1).

Run Replit

Thanks for reading

There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form

Krishan — Thu, 04 Aug 2022 12:56:00 +0000

making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.

The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from "de Finibus Bonorum et Malorum" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham.
Where can I get some?

There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable. The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic