Need to create a collection with calculated values? Laravel's times method lets you generate collections dynamically!

#Basic Usage

Here's the simplest way to use times:

$collection = Collection::times(10, function (int $number) {
    return $number * 9;
});
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

#Real-World Example

Here's how you might use it in a date slot generator:

class AppointmentSlotGenerator
{
    public function generateDailySlots(
        string $startTime = '09:00',
        int $slotCount = 8,
        int $intervalMinutes = 60
    ) {
        return Collection::times($slotCount, function (int $index) use ($startTime, $intervalMinutes) {
            $time = Carbon::parse($startTime)
                ->addMinutes(($index) * $intervalMinutes);
            
            return [
                'slot_id' => $index + 1,
                'start_time' => $time->format('H:i'),
                'end_time' => $time->addMinutes($intervalMinutes)->format('H:i'),
                'is_available' => true
            ];
        });
    }
}

// Usage
$generator = new AppointmentSlotGenerator();
$slots = $generator->generateDailySlots('10:00', 6, 30);

$slots->each(function ($slot) {
    $this->info("Slot {$slot['slot_id']}: {$slot['start_time']} - {$slot['end_time']}");
});

The  times method is perfect for generating sequences, creating test data, or any scenario where you need calculated values in a collection.

In web applications, file uploads are a common feature, but they can also be a significant security risk if not handled properly. Laravel provides robust tools for validating file uploads, including the ability to verify file types. Let's explore how to implement secure file type validation in your Laravel applications.

#Understanding File Type Validation

Laravel offers two primary methods for validating file types:

1. The mimes rule

2. The mimetypes rule

    

Both of these rules help ensure that uploaded files match expected types, but they work slightly differently.

#Using the 'mimes' Rule

The mimes rule validates files against a list of extension names:

$request->validate([
    'document' => 'required|file|mimes:pdf,docx,txt|max:10240',
]);

In this example:

• The file must be present (required)
• It must be a file upload (file)
• It must have an extension of pdf, docx, or txt
• It must not exceed 10MB in size (10240 KB)

#Using the 'mimetypes' Rule

The mimetypes rule checks the file's MIME type:

$request->validate([
    'image' => 'required|file|mimetypes:image/jpeg,image/png|max:5120',
]);

This rule ensures:

• The file is present
• It's a file upload
• It has a MIME type of either image/jpeg or image/png
• It doesn't exceed 5MB in size

#Combining with Other Validation Rules

You can combine these rules with other Laravel validation rules for comprehensive file validation:

$request->validate([
    'avatar' => [
        'required',
        'file',
        'mimes:jpg,png',
        'dimensions:min_width=100,min_height=100',
        'max:2048',
    ],
]);

This example ensures the avatar is a jpg or png image, has minimum dimensions, and doesn't exceed 2MB.

#Real-World Example: Document Management System

Let's consider a more complex scenario for a document management system:

public function store(Request $request)
{
    $request->validate([
        'document' => [
            'required',
            'file',
            'mimes:pdf,doc,docx,txt,xls,xlsx',
            'max:20480',  // 20MB max
        ],
        'document_type' => 'required|in:contract,report,presentation',
        'description' => 'required|string|max:500',
    ]);

    if ($request->document_type === 'presentation' && !in_array($request->file('document')->extension(), ['ppt', 'pptx'])) {
        return back()->withErrors(['document' => 'Presentations must be PowerPoint files.']);
    }

    // Process and store the document
    $path = $request->file('document')->store('documents');

    Document::create([
        'path' => $path,
        'type' => $request->document_type,
        'description' => $request->description,
        'user_id' => auth()->id(),
    ]);

    return redirect()->route('documents.index')->with('success', 'Document uploaded successfully.');
}

This example demonstrates:

• Basic file type and size validation
• Additional contextual validation based on document type
• Proper file storage and database recording

Validating file types is a crucial aspect of building secure Laravel applications that handle file uploads. By leveraging Laravel's built-in validation rules and combining them with custom logic, you can create robust and secure file handling systems. Always remember to validate on the server-side and never trust client-side validation alone. With these practices in place, you can confidently manage file uploads in your Laravel applications.

Laravel's collections are already a powerful tool for working with arrays of data, but high order collections take this to the next level. These methods allow you to perform common operations on collections in a more concise and expressive way, leading to cleaner and more readable code. Let's dive into how you can leverage high order collections in your Laravel projects.

#Understanding High Order Collections

High order collection methods in Laravel allow you to call collection methods directly on the collection items, without the need for nested closures. This results in more compact and often more readable code.

#Basic Usage

Here's a simple example comparing traditional collection methods with high order methods:

// Traditional approach
$activeUserNames = $users->filter(function ($user) {
    return $user->isActive();
})->map(function ($user) {
    return $user->name;
});

// Using high order collections
$activeUserNames = $users->filter->isActive()->map->name;

As you can see, the high order approach is much more concise.

#Common High Order Methods

filter()

The filter() method becomes particularly elegant with high order collections:

$adults = $users->filter->isAdult();

This assumes your User model has an isAdult() method.

map()

map() is another method that benefits greatly from the high order approach:

$userEmails = $users->map->email;

This is equivalent to $users->map(function ($user) { return $user->email; }).

sort()

Sorting can also be simplified:

$sortedUsers = $users->sortBy->lastLoginAt;

#Chaining Multiple High Order Methods

One of the strengths of high order collections is the ability to chain multiple operations:

$result = $users
    ->filter->isActive()
    ->map->name
    ->sort()
    ->take(5);

This code filters for active users, maps to their names, sorts the names, and takes the first 5.

#Real-World Example: Processing Orders

Let's look at a more complex example involving order processing:

$highValueOrders = $orders
    ->filter->isPaid()
    ->filter->shipped()
    ->map->items
    ->collapse()
    ->groupBy->product_id
    ->map->sum('price')
    ->filter(function ($total) {
        return $total > 1000;
    })
    ->sortDesc()
    ->take(10);

This code does the following:

• Filters for paid and shipped orders
• Maps to the items in each order
• Collapses the items into a single collection
• Groups items by product ID
• Sums the price for each product
• Filters for products with total sales over $1000
• Sorts in descending order
• Takes the top 10

#Combining with Regular Collection Methods

High order methods can be seamlessly combined with regular collection methods:

$result = $users
    ->filter->isActive()
    ->mapToGroups(function ($user) {
        return [$user->role => $user->name];
    })
    ->map->sort()
    ->map->take(3);

This groups active users by role, sorts names within each role, and takes the top 3 from each group.

#Performance Considerations

While high order collections can make your code more readable, be aware that they might have a slight performance overhead compared to using closures directly. For most applications, this difference is negligible, but it's worth considering for performance-critical sections of your code.

Ensuring regular database backups is crucial for any application. Laravel's Task Scheduler combined with cloud storage provides an efficient way to automate this process. Let's explore how to implement automated database backups using Laravel and store them in the cloud.

#Setting Up the Backup Command

First, create a custom Artisan command for the backup process:

php artisan make:command DatabaseBackup

In the newly created command file:

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Storage;

class DatabaseBackup extends Command
{
    protected $signature = 'db:backup';
    protected $description = 'Backup the database to cloud storage';

    public function handle()
    {
        $filename = "backup-" . now()->format('Y-m-d') . ".sql";
        $path = storage_path("app/backup/{$filename}");

        // Create the backup
        $command = "mysqldump --user=" . env('DB_USERNAME') ." --password=" . env('DB_PASSWORD') 
            . " --host=" . env('DB_HOST') . " " . env('DB_DATABASE') 
            . "  > " . $path;

        exec($command);

        // Upload to cloud storage (e.g., AWS S3)
        Storage::disk('s3')->put("backups/{$filename}", file_get_contents($path));
        unlink($path); // Remove local copy

        $this->info('Database backup uploaded to S3.');
    }
}

#Scheduling the Backup

Schedule the backup command in app/Console/Kernel.php:

protected function schedule(Schedule $schedule)
{
    $schedule->command('db:backup')->daily()->at('01:00');
}

This schedules the backup to run daily at 1:00 AM.

#Cloud Storage Configuration

Ensure your cloud storage is configured in config/filesystems.php:

's3' => [
    'driver' => 's3',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION'),
    'bucket' => env('AWS_BUCKET'),
    'url' => env('AWS_URL'),
    'endpoint' => env('AWS_ENDPOINT'),
],

Don't forget to set the corresponding environment variables in your .env file.

By implementing this setup, you ensure that your database is regularly backed up and securely stored in the cloud. This approach provides an extra layer of data protection and makes disaster recovery more manageable.

Remember to test your backup process thoroughly and periodically verify the integrity of your backups to ensure they're valid and can be restored if needed.

The Laravel team released v11.20 this week, including a new collection method, a deduplicate string method, the ability to use Enums with AssertableJson, and more.

If you need to remove string duplication in Laravel and PHP applications, Laravel v11.20 adds a new method named deduplicate to the String helpers, which allows you to quickly and easily remove duplicate characters.

use Illuminate\Support\{Str,Stringable};
 
$string = '/usr/local////path/to///desktop';
 
Str::deduplicate($string, '/');
// "/usr/local/path/to/desktop"
 
(new Stringable($string))->deduplicate('/')->toString();
// "/usr/local/path/to/desktop"

The default replacement character in the deduplicate() method is a space character, which could also be a use for the squish() helper introduced in Laravel v9.7.0. Let me illustrate when squish() might be a better choice to remove extra spaces:

Str::deduplicate(' John     Smith Jr.  '); // " John Smith Jr. "
Str::squish(' John     Smith Jr.  '); // "John Smith Jr."

Note the extra space ' ' characters at the beginning and end using deduplicate(), which is by design. Deduplicate is used to replace consecutive instances of a given character with a single character in the given string. Squish also removes other space characters, such as newlines and tabs:

// Each example returns `laravel php framework`:
Str::squish(' laravel php framework '));
Str::squish("laravel\t\tphp\n\nframework");
Str::squish('
    laravel
    php
    framework
');

Filepond is a JavaScript package that allows you to upload anything, with popular integrations for React, Vue, Svelte, and more

If you're using Livewire, now you can easily use Filepond to upload files within Livewire components using Spatie's livewire-filepond package. This package contains a Livewire component that allows you to start using it in your Laravel projects easily:

use LivewireComponent;
use SpatieLivewireFilepondWithFilePond;
 
class MyLivewireComponent extends Component
{
    use WithFilePond;
 
    public $file;
}
 
// <x-filepond::upload wire:model="file" />

You can pass any property that Filepond accepts, and you can further customize the Livewire Filepond component with the following options available at the time of writing:

• Allow multiple file uploads
• Make the file upload required
• Ability to disable the upload input
• Custom placeholder text

You can learn more about this package, get full installation instructions, and view the source code on GitHub. To learn more about this project, check out Freek Van der Herten's writeup about this package.

The binafy/laravel-cart package adds the ability to add shopping cart functionality to Laravel applications. It simplifies storing and managing cart items, supports storing multiple item types, and more

Features

• Secure card information storage and management
• Support for multiple payment gateways
• Recurring payment and subscription management
• Robust validation and error handling
• Highly customizable and flexible architecture

From the package's documentation, here's an example of retrieving a cart for a given user and adding an item to the cart:

$cart = Cart::query()->firstOrCreate(['user_id' => $user->id]);
$cartItem = new CartItem([
    'itemable_id' => $itemable->id,
    'itemable_type' => $itemable::class,
    'quantity' => 1,
]);
 
$cart->items()->save($cartItem);
 
// Or create and store
Cart::query()->firstOrCreateWithStoreItems(
    item: $product,
    quantity: 1,
    userId: $user->id
);

This package also allows you to store multiple items in the cart, and the cart items are polymorphic model associations. You can access the underlying model associated with the CartItem using the itemable() method:

$cartItem->itemable()->first();

Here you can see an example of how it works.

You can learn more about this package, get full installation instructions, and view the source code on GitHub.

Creating a DateTime from a Unix timestamp will be more convenient in PHP 8.4 with the new createFromTimestamp() method

It will support both a typical Unix timestamp as well as timestamps containing microseconds:

$dt = DateTimeImmutable::createFromTimestamp(1718337072);
$dt->format('Y-m-d'); // 2024-06-14
 
$dt = DateTimeImmutable::createFromTimestamp(1718337072.432);
$dt->format('Y-m-d h:i:s.u'); // 2024-06-14 03:51:12.432000

With PHP 8.3 and below, you need to use the createFromFormat() method to convert a timestamp into a DateTime or DateTimeImmutable instance. As you can see below, it's not too complicated, but it'll be nice to have a new method to take care of both cases below:

$dt = DateTimeImmutable::createFromFormat('U', (string) 1718337072);
// DateTimeImmutable @1718337072 {#7948
//   date: 2024-06-14 03:51:12.0 +00:00,
// }
 
$dt = DateTimeImmutable::createFromFormat('U.u', (string) 1718337072.432);
// DateTimeImmutable @1718337072 {#7950
//   date: 2024-06-14 03:51:12.432 +00:00,
// }

For those using the Carbon PHP library, it already has a createFromTimestamp() method available! It is encouraging that PHP is getting this new method at the language level as well!

Carbon\Carbon::createFromTimestamp(1718337072.432);
// Carbon\Carbon @1718337072 {#7981
//   date: 2024-06-14 03:51:12.432 UTC (+00:00),
// }
 
Carbon\CarbonImmutable::createFromTimestamp(1718337072);
// Carbon\CarbonImmutable @1718337072 {#7999
//  date: 2024-06-14 03:51:12.0 UTC (+00:00),
// }

The chaotic-schedule package for Laravel allows you to randomize scheduled command execution time and date intervals via Pseudorandom number generators (PRNGs)

"Ever wanted to run your scheduled commands on random times of the day, or on certain days of the week? Or you may need to send some notifications not on fixed date times, but rather on random intervals hence it feels more human. Then this is the package you're looking for.

This Laravel packages enables you to run commands on random intervals and periods while respecting the boundaries set exclusively by you".

One use-case mentioned in the readme is sending user notifications or emails but sending them randomly to add a more personal human touch. Avoiding the sending of these messages at regular intervals at the same time would be more recognizably automated:

// Run a command daily on a random time between 08:15 and 11:42
$schedule->command('inspire')->daily()->atRandom('08:15','11:42');
 
// Run a command every Tuesday, Saturday and Sunday on a random time between 04:20 and 06:09
$schedule->command('your-command-signature:here')
    ->days([Schedule::TUESDAY, Schedule::SATURDAY, Schedule::SUNDAY])
    ->atRandom('04:20','06:09');

This package includes quite a few methods to define your random specifications based on several factors, such as:

• - dailyAtRandom()
• - hourlyAtRandom()
• - hourlyMultipleAtRandom()
• - randomDays()

You can learn more about this package, get full installation instructions, and view the source code on GitHub.

Laravel Herd is a blazingly fast, native Laravel and PHP development environment. It’s now available for everyone running Windows machines. It includes everything you need to start Laravel development, including PHP and Nginx. Once you install Herd, you're ready to start developing with Laravel.

Herd Features Include

The fastest environment around

Herd uses native binaries for PHP, nginx, and other services, making it faster than other PHP development environments. No containers, VMs, or wonky virtualization methods – just plain binaries as it should be.

Herd will install tools you need for development, like Composer, the Laravel installer, and more.

Everything you need to get started

Herd includes binaries for Composer, the Laravel installer, and Expose, which are automatically available to your CLI.

This makes it possible to manage your sites via Powershell or use the Herd site wizard.

Unlock your real productivity

Herd Pro comes with services for databases, caches, queues, storage, and realtime applications, changing how you work.

You can manage everything you ever need from one beautiful application.

Download Herd For Windows

Download the Windows version and give it a try today.

Have you ever wanted to know what version of Laravel you have installed? Here I show you how to find out in two seconds.

Ever wanted to know what version of Laravel you have installed?

Here's the quickest way to find out...

Open your terminal and cd into your project then run:

php artisan about

This will give you a complete list of all the details about your sites, including the version.

Environment ........................................
  Application Name ........................... Laravel
  Laravel Version ............................ 10.46.0
  PHP Version ................................. 8.2.13
  Composer Version ............................. 2.4.1
  Environment .................................. local
  Debug Mode ................................. ENABLED
  URL ..............................antoniojenaro.test
  Maintenance Mode ............................... OFF

  Cache ..............................................
  Config .................................. NOT CACHED
  Events .................................. NOT CACHED
  Routes .................................. NOT CACHED
  Views ....................................... CACHED

  Drivers ............................................
  Broadcasting ................................... log
  Cache ......................................... file
  Database ..................................... mysql
  Logs ................................ stack / single
  Mail .......................................... smtp
  Queue ......................................... sync
  Session ................................... database

  Livewire ...........................................
  Livewire .................................... v3.4.6