https://www.pavelzanek.com/en/blog My articles, insights, and updates from practice en Wed, 20 May 2026 07:01:58 +0200 https://www.pavelzanek.com/en/blog/artisan-console-command-make https://www.pavelzanek.com/en/blog/artisan-console-command-make Fri, 01 Sep 2023 00:00:00 +0200 'Post', '--migration' => true, '--controller' => true]); Artisan::call('make:seeder', ['name' => 'PostsTableSeeder']); Optimizing Templates for Teamwork If you are working in a team, it is important to ensure that all generated files will have a consistent and expected structure. Customized templates can be saved in a version control system (e.g., Git) so that the entire team can use them. Tips for Teamwork Share Customized Templates: Save them in a repository so that the entire team has access. Document Changes: When you modify a template, document what and why you changed it to make it clear for other team members. Common Errors and How to Solve Them Error: Class Already Exists This error occurs when you try to create a class that already exists in the application. Solution Check the Directory: Make sure that the class actually already exists by browsing the relevant directory. Rename the Class: If you need to create a new class with a different purpose, consider renaming the class to avoid a name conflict. Error: Invalid Class Name This error occurs if you enter an invalid class name when using the make command. Solution Check the Syntax: Make sure that the class name is in the correct format. It should start with an uppercase letter and must not contain invalid characters. Use the Correct Command: Ensure that you are using the correct Artisan command to generate the desired type of file. Error: Template Not Found This error occurs if Laravel cannot find the required template (stub) for generating a file. Solution Check the Template Directory: Make sure that all templates are in the correct place in the stubs/ directory in your application's root directory. Republish the Templates: If some templates are missing, try republishing them using the command:php artisan stub:publish Error: Syntax Error in Generated File This error occurs if there is a PHP syntax error in the generated file. Solution Check the Templates: The error may be in the template that Laravel used to create the file. Check the template and correct the error. Check the Generated File: Open the generated file and locate and correct the PHP syntax error. Conclusion The make command in Laravel's Artisan Console is a powerful tool that significantly increases a developer's productivity by automating the process of creating new classes and files. It allows for the generation of various types of files, from controllers and models to tests and migrations. Templates (stubs) are a key part of this process and can be customized according to the developer's needs. Common errors when using the make command are easily solvable and usually relate to class names, template locations, or PHP syntax. The Importance of Effectively Using the 'Make' Command Effectively using the make command can significantly improve a developer's workflow, enabling faster development and reducing the risk of errors by providing consistent and reliable ways of generating code. It is a tool that should be part of every Laravel developer's arsenal. Recommendations for Next Steps Explore More Artisan Commands: Laravel Artisan offers many other commands that can facilitate development. Try, for example, php artisan list to display all available commands. Study Laravel's Documentation: Laravel's documentation is a rich source of information. Dedicate time to browsing through it and learn about the additional features that the framework offers. ]]> https://www.pavelzanek.com/en/blog/generative-ai-rapid-rise-impact-tech-world https://www.pavelzanek.com/en/blog/generative-ai-rapid-rise-impact-tech-world Tue, 15 Aug 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/amazon-ai-generating-product-descriptions https://www.pavelzanek.com/en/blog/amazon-ai-generating-product-descriptions Sun, 13 Aug 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/rss-feed-laravel https://www.pavelzanek.com/en/blog/rss-feed-laravel Thu, 10 Aug 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/google-howto-faq-rich-results https://www.pavelzanek.com/en/blog/google-howto-faq-rich-results Wed, 09 Aug 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/laravel-livewire-crud https://www.pavelzanek.com/en/blog/laravel-livewire-crud Thu, 29 Jun 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/laravel-crud https://www.pavelzanek.com/en/blog/laravel-crud Sat, 24 Jun 2023 00:00:00 +0200 id(); $table->string('title'); $table->mediumText('body')->nullable(); $table->boolean('is_active')->default(false); $table->string('type', 8)->default(ExampleItemType::TYPE1->value); $table->timestamps(); $table->softDeletes(); }); } /** * Reverse the migrations. */ public function down(): void { Schema::dropIfExists('example_items'); } }; Creating a model Models are one of the key aspects of the framework. They are representations of database tables and allow you to work with database records as objects. This means that you can perform CRUD operations on your models without having to write SQL. Creating a model in Laravel is simple. You use the Artisan command "php artisan make:model", which creates a new model in the "app/Models" directory. The model name should be in singular and start with a capital letter. Each model in Laravel extends the "Illuminate\\Database\\Eloquent\\Model" class and contains methods that allow interaction with the database. You can also define your own methods and properties on your models. Models also contain so-called Eloquent relationships, which allow you to define relationships between different models. For example, if you have a "User" model and a "Post" model, you can define a relationship that says that one user can have many posts. "ExampleItem" Model (app\\Models\\Examples): <?php namespace App\Models\Examples; use App\Enums\Examples\ExampleItemType; use Illuminate\Database\Eloquent\Factories\HasFactory; use Illuminate\Database\Eloquent\Model; use Illuminate\Database\Eloquent\SoftDeletes; class ExampleItem extends Model { use HasFactory; use SoftDeletes; protected $fillable = [ 'title', 'body', 'is_active', 'type', ]; protected $casts = [ 'is_active' => 'boolean', 'type' => ExampleItemType::class, ]; } Creating actions In Laravel, you can define actions as separate classes that represent individual operations that your application can perform. This is an alternative approach to the traditional model where actions are defined as methods in controllers. Creating an action as a separate file in Laravel is simple. First, you need to create a new class in the "app/Actions" directory. The class, for example, can have an "execute()" method that performs the desired operation. This approach has several advantages. One of them is that your actions are well isolated, easily extendable, and testable. Each action has a clearly defined responsibility and it's easy to test it independently of other parts of your application. "CreateExampleItemAction" Action (app\\Actions\\Examples\\ExampleItems): <?php namespace App\Actions\Examples\ExampleItems; use App\Models\Examples\ExampleItem; class CreateExampleItemAction { public function execute(array $validatedData): ExampleItem { return ExampleItem::create($validatedData); } } "UpdateExampleItemAction" Action (app\\Actions\\Examples\\ExampleItems): <?php namespace App\Actions\Examples\ExampleItems; use App\Models\Examples\ExampleItem; class UpdateExampleItemAction { public function execute(ExampleItem $exampleItem, array $validatedData): ExampleItem { $exampleItem->update($validatedData); return $exampleItem; } } "RemoveExampleItemAction" Action (app\\Actions\\Examples\\ExampleItems): <?php namespace App\Actions\Examples\ExampleItems; use App\Models\Examples\ExampleItem; class RemoveExampleItemAction { public function execute(ExampleItem $exampleItem): void { $exampleItem->delete(); } } Creating enum Creating Enums in Laravel is a powerful way to define a type of variable that allows for many different, but specific values. This feature is particularly useful when you want to limit the possibilities of a variable's value, ensuring that it only holds a value from a specific set. In Laravel, Enums are not built-in, but they can be easily implemented using PHP classes. Creating Enums in Laravel can be a great way to make your code more readable and maintainable, especially when dealing with variables that should only have a specific set of values. They can be used in various parts of your Laravel application, such as in models, controllers, and even in your database migrations. In addition to making your code cleaner and easier to understand, Enums also help to reduce errors in your code. By limiting the possible values of a variable, you can ensure that it only ever holds a value that it's supposed to, reducing the likelihood of unexpected values causing bugs in your code. Remember, Enums are just one of the many advanced features that Laravel offers to make your PHP development easier and more efficient. Whether you're building a small personal project or a large enterprise application, Laravel has the tools and features you need to build robust, scalable, and maintainable PHP applications. "ExampleItemType" Enum (app\\Enums\\Examples): <?php namespace App\Enums\Examples; use Illuminate\Support\Collection; enum ExampleItemType: string { case TYPE1 = 'Type 1'; case TYPE2 = 'Type 2'; public static function all(): Collection { return collect(ExampleItemType::cases())->map( fn(ExampleItemType $code) => $code->details() ); } public function details(): array { return match($this) { self::TYPE1 => [ 'name' => 'Type Name 1', 'value' => 'Type 1', ], self::TYPE2 => [ 'name' => 'Type Name 2', 'value' => 'Type 2', ], }; } } Creating validation / validation requests Validation requests are special classes that serve to validate input data before they are processed by your application. Using validation requests, you can ensure that the data your application receives is always in the expected format and meets all the rules you have set. Creating a validation request in Laravel is simple. First, you need to create a validation class using the Artisan command "php artisan make:request", which creates a new validation request in the "app/Http/Requests" directory. The validation class contains two methods: "authorize()" and "rules()". The "authorize()" method determines whether the user is authorized to make the request. The "rules()" method then returns an array of validation rules that should be applied to the input data. "StoreXYZRequest" and "UpdateXYZRequest" are two common types of validation requests in Laravel. "StoreXYZRequest" is used when creating a new record and "UpdateXYZRequest" is used when updating an existing record. However, you can, for example, create only one validation request that will be used when creating and editing a record - which is handy if the validation conditions for creating and editing are the same. "StoreExampleItemRequest" Validation Request (app\\Http\\Requests\\Examples\\ExampleItems): <?php namespace App\Http\Requests\Examples\ExampleItems; use App\Enums\Examples\ExampleItemType; use Illuminate\Foundation\Http\FormRequest; use Illuminate\Validation\Rules\Enum; class StoreExampleItemRequest extends FormRequest { public function authorize(): bool { return true; } public function rules(): array { return [ 'title' => 'required|string|max:255', 'body' => 'nullable|string', 'is_active' => 'required|boolean', 'type' => [ 'required', 'string', 'max:8', new Enum(ExampleItemType::class), ], ]; } protected function prepareForValidation() { $this->merge([ 'is_active' => $this->has('is_active') ? true : false, ]); } } "UpdateExampleItemRequest" Validation Request (app\\Http\\Requests\\Examples\\ExampleItems): <?php namespace App\Http\Requests\Examples\ExampleItems; use App\Enums\Examples\ExampleItemType; use Illuminate\Foundation\Http\FormRequest; use Illuminate\Validation\Rules\Enum; class UpdateExampleItemRequest extends FormRequest { public function authorize(): bool { return true; } public function rules(): array { return [ 'title' => 'required|string|max:255', 'body' => 'nullable|string', 'is_active' => 'required|boolean', 'type' => [ 'required', 'string', 'max:8', new Enum(ExampleItemType::class), ], ]; } protected function prepareForValidation() { $this->merge([ 'is_active' => $this->has('is_active') ? true : false, ]); } } Creating a controller Controllers are a key part of any application built on this framework. They are classes that handle all HTTP requests that your application receives and control how your application should respond. Creating a controller in Laravel is simple again thanks to the Artisan tool, which is part of Laravel. The "php artisan make:controller" command creates a new controller in the "app/Http/Controllers" directory. The controller name should be in singular and start with a capital letter. Controllers in Laravel can either be simple, which are controllers with one action (uses the "__invoke" method), or resource, which are controllers that handle a whole set of CRUD operations. Resource controllers are ideal for working with database records, such as users, blog posts, or any other entities in your application. Of course, a controller can also be created according to your ideas, so it does not have to be either with one method, nor a resource one. "ExampleItemController" Controller (app\\Http\\Controllers\\Examples): <?php namespace App\Http\Controllers\Examples; use App\Actions\Examples\ExampleItems\CreateExampleItemAction; use App\Actions\Examples\ExampleItems\RemoveExampleItemAction; use App\Actions\Examples\ExampleItems\UpdateExampleItemAction; use App\Enums\Examples\ExampleItemType; use App\Http\Controllers\Controller; use App\Http\Requests\Examples\ExampleItems\StoreExampleItemRequest; use App\Http\Requests\Examples\ExampleItems\UpdateExampleItemRequest; use App\Models\Examples\ExampleItem; class ExampleItemController extends Controller { public function index() { $exampleItems = ExampleItem::orderBy('created_at', 'desc')->paginate(20); return view('examples.example-items.index', ['exampleItems' => $exampleItems]); } public function create() { return view('examples.example-items.create', ['exampleItemTypes' => ExampleItemType::all()]); } public function store(StoreExampleItemRequest $request) { (new CreateExampleItemAction())->execute($request->validated()); return redirect()->route('example-items.index')->with(['flashType' => 'success', 'flashMessage' => __('Example Item was successfully created.')]); } public function show(ExampleItem $exampleItem) { abort_if(!$exampleItem->is_active, 404, "Example Item is not active."); return view('examples.example-items.show', ['exampleItem' => $exampleItem]); } public function edit(ExampleItem $exampleItem) { return view('examples.example-items.edit', ['exampleItem' => $exampleItem, 'exampleItemTypes' => ExampleItemType::all()]); } public function update(UpdateExampleItemRequest $request, ExampleItem $exampleItem) { (new UpdateExampleItemAction())->execute($exampleItem, $request->validated()); return redirect()->route('example-items.index')->with(['flashType' => 'success', 'flashMessage' => __('Example Item was successfully updated.')]); } public function destroy(ExampleItem $exampleItem) { (new RemoveExampleItemAction())->execute($exampleItem); return redirect()->route('example-items.index')->with(['flashType' => 'success', 'flashMessage' => __('Example Item was successfully removed.')]); } } Creating a template Templates are a key tool for creating dynamic web pages. Laravel uses the "Blade" template engine, which allows you to insert PHP code directly into HTML templates. Creating a template in Laravel is simple. First, you need to create a template file in the "resources/views" directory. Template files have a ".blade.php" extension. Templates can contain any valid HTML code as well as special Blade directives for inserting PHP code. For example, you can use the directive "{{ $variable }}" to output the value of a variable, or directives @if, @foreach, and others to control the flow of the application. In addition, you can use the template inheritance system, which allows you to define "base" templates with a general page structure and then create "inherited" templates that extend this structure and add specific content. [Index, Create, Edit, Show Blade templates as fully fetched above] Routing Routing is one of the most important aspects of any web application, and Laravel provides a powerful and flexible routing system that makes it easy to define routes for your application. Routes in Laravel are defined in route files, which are located in the "routes" directory of your application. Laravel provides several different route files for different types of routes, including web routes, API routes, and console routes. Each route is defined using an HTTP method (such as GET, POST, PUT, or DELETE), a path, and an action to be performed when the route is invoked. The action can be either a function (closure function), or a reference to a controller method. Laravel also supports advanced routing features such as wildcard routing, named routing, middleware routing, parameter constraint routing, and so on. Routing for "web" (routes): ... Route::group([ 'prefix' => "{language}", 'where' => ['language' => '[a-zA-Z]{2}'] ], function () { // Admin Route::group(['middleware' => ['role:superadmin']], function () { ... Route::resource('/examples/example-items', ExampleItemController::class); }); }); ... Creating a factory Factories are tools that make it easy to generate test data for your database. Factories allow you to define "templates" (not to be confused with blade templates) for creating new instances of your models with random or predefined data. Creating a factory in Laravel is simple again thanks to Artisan. The "php artisan make:factory" command creates a new factory in the "database/factories" directory. The name of the factory should correspond to the name of the model for which the factory is intended. Each factory contains a "definition()" method, which returns an array of attributes to be used when creating a new instance of the model. You can use Laravel functions like "faker" to generate random data. Factories are ideal for creating large amounts of data for testing or for populating your database before development or during development. "ExampleItemFactory" Factory (database/factories/Examples): <?php namespace Database\Factories\Examples; use App\Enums\Examples\ExampleItemType; use App\Models\Examples\ExampleItem; use Illuminate\Database\Eloquent\Factories\Factory; class ExampleItemFactory extends Factory { protected $model = ExampleItem::class; public function definition() { return [ 'title' => $this->faker->sentence(4), 'body' => $this->faker->realText(500), 'is_active' => $this->faker->boolean(), 'type' => $this->faker->boolean() ? ExampleItemType::TYPE1 : ExampleItemType::TYPE2, ]; } } Creating tests Testing is a fundamental part of developing any application, and Laravel provides excellent tools for automated testing of your code. Laravel allows you to easily create and run tests for your application. Creating a test in Laravel is simple, as you might expect, thanks to the Artisan tool. The "php artisan make:test" command creates a new test in the "tests/Feature" or "tests/Unit" directory, depending on what type of test you want to create. Each test is a class that contains one or more test methods. These methods contain assertions that verify that your code is working as it should. Laravel provides a wide range of assertions to verify various aspects of your application, including HTTP responses, database interactions, and much more. You can run tests using the "php artisan test" command, which runs all tests in your application and prints the results to the console. Tests for the controller "ExampleItemControllerTest" Test (tests/Feature/App/Controllers/Examples): [full Pest controller test code as fetched above] Tests for actions "CreateExampleItemActionTest", "UpdateExampleItemActionTest", "RemoveExampleItemActionTest" Tests (tests/Feature/App/Actions/Examples/ExampleItems): [full Pest action test code as fetched above] Conclusion In this tutorial, we have thoroughly familiarized ourselves with the process of creating CRUD operations in Laravel. We have gone through all the key steps, from creating migrations and models, through defining actions and validation requests, to creating templates, factories, and tests. I hope this tutorial has helped you understand how to work with Laravel and has provided you with a solid foundation for further development of your own applications.]]> https://www.pavelzanek.com/en/blog/seo-ai-optimization-chatgpt-browse-with-bing https://www.pavelzanek.com/en/blog/seo-ai-optimization-chatgpt-browse-with-bing Thu, 22 Jun 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/laravel-newsletter https://www.pavelzanek.com/en/blog/laravel-newsletter Wed, 21 Jun 2023 00:00:00 +0200 $this->faker->email(), 'language' => NewsletterLanguage::ENGLISH, 'is_verified' => false, ]; } } This factory now allows us to create test instances of our NewsletterUser model with random data. This will come in handy during the further development and testing of our newsletter subscription system. Database Migration Migration is a key part of Laravel that allows us to create the structure of our database directly from our code. Let's create a migration using the artisan command: php artisan make:migration create_newsletter_users_table In our case, we created a migration for the NewsletterUser model, which contains all the necessary information for managing newsletter subscribers, such as email, language, and verification status. <?php use App\Enums\Newsletter\NewsletterLanguage; use Illuminate\Database\Migrations\Migration; use Illuminate\Database\Schema\Blueprint; use Illuminate\Support\Facades\Schema; return new class extends Migration { /** * Run the migrations. */ public function up(): void { Schema::create('newsletter_users', function (Blueprint $table) { $table->id(); $table->string('email', 128)->unique(); $table->string('language', 6)->default(NewsletterLanguage::ENGLISH->value); $table->boolean('is_verified')->default(false); $table->string('verification_token', 60)->nullable(); $table->timestamps(); $table->softDeletes(); }); } /** * Reverse the migrations. */ public function down(): void { Schema::dropIfExists('newsletter_users'); } }; Thanks to migration, we can easily create, modify, and delete database tables, which is very useful during application development and distribution among different environments. Moreover, Laravel automatically keeps track of which migrations have already been applied, so we don't have to deal with their repeated execution. Creating an Email Template When a user enters their email and selects the preferred language of the newsletter, we need to send them a verification email. It contains a verification link that the user has to click on to verify their email. For this purpose, we will need to create an email template. Laravel again offers very convenient work with email templates. We start by creating a new class for our email notification using the Artisan command: php artisan make:mail NewsletterVerificationMail --markdown=emails.newsletter-verification With this command, we created a new NewsletterVerificationMail class and at the same time told Laravel that we want to use markdown format to create our email template. Laravel automatically created a file for this template in the resources/views/emails directory. We can now modify this template to suit our needs. In our case, for demonstration purposes, we need to display several pieces of information in the email: Welcome message Verification link Button to redirect to our website The resulting template could look like this: <x-mail::message> # {{ __('template.newsletter-email-verification-headline') }} {{ __('template.newsletter-email-verification-description') }} <x-mail::button :url="$signedUrl"> {{ __('template.newsletter-email-verification-verify-button') }} </x-mail::button> <x-mail::button :url="$homepageUrl"> {{ __('template.newsletter-email-verification-homepage-button') }} </x-mail::button> {{ __('template.newsletter-email-verification-thanks') }},<br> {{ config('app.name') }} </x-mail::message> In this template, we used Laravel's mail::message and mail::button components, which allow us to easily create the structure of our email. The texts are loaded from translation files, so we can easily switch between different languages according to the user's choice. Finally, we need to use this template in our NewsletterVerificationMail class: <?php namespace App\Mail\App\Guest\Newsletter; use App\Models\Newsletter\NewsletterUser; use Illuminate\Bus\Queueable; use Illuminate\Contracts\Queue\ShouldQueue; use Illuminate\Mail\Mailable; use Illuminate\Mail\Mailables\Content; use Illuminate\Mail\Mailables\Envelope; use Illuminate\Queue\SerializesModels; use Illuminate\Support\Facades\URL; class NewsletterVerificationMail extends Mailable { use Queueable, SerializesModels; public NewsletterUser $newsletterUser; public function __construct(NewsletterUser $newsletterUser) { $this->newsletterUser = $newsletterUser; } /** * Get the message envelope. */ public function envelope(): Envelope { return new Envelope( subject: __('template.newsletter-email-verification-subject') . ' | PavelZanek.com', ); } /** * Get the message content definition. * * @return \Illuminate\Mail\Mailables\Content */ public function content() { $signedUrl = URL::signedRoute('newsletter.verify-user', [ 'language' => $this->newsletterUser->language, 'token' => $this->newsletterUser->verification_token ]); return new Content( markdown: 'emails.app.guest.newsletter.verification-mail', with: [ 'newsletterUser' => $this->newsletterUser, 'signedUrl' => $signedUrl, 'homepageUrl' => route('homepage', ['language' => 'en']), ], ); } } There is no need to discuss the code sample in more detail here, we will use the provided data and set the subject of the email. Creating a Livewire Component Livewire is an excellent tool for creating dynamic components in Laravel, allowing for an easy connection between JavaScript and PHP. Its main advantage is that it does not require knowledge of JavaScript and everything can be solved directly in PHP. In our case, we will use a Livewire component to create a form for newsletter subscription. First, we create a new Livewire component using the Artisan command: php artisan make:livewire NewSubscriberForm This will create two new files - NewSubscriberForm.php and new-subscriber-form.blade.php. The first one is a class where we define the logic of the component. The second one is a template that describes what the component looks like. In the NewSubscriberForm.php class, we define two public attributes - $email and $language, which represent the values entered by the user in our form. Furthermore, we need to create a subscribe() method, which will be called after the form submission. <?php namespace App\Http\Livewire\Guest\Newsletter; use App\Actions\Guest\Newsletter\CreateNewsletterUserAction; use App\Enums\Newsletter\NewsletterLanguage; use App\Mail\App\Guest\Newsletter\NewsletterVerificationMail; use Illuminate\Support\Facades\Mail; use Illuminate\Validation\Rules\Enum; use Livewire\Component; class NewSubscriberForm extends Component { public string $email = ''; public string $language = ''; public function render() { return view('livewire.guest.newsletter.subscription-form'); } public function subscribe() { $validatedData = $this->validate([ 'email' => 'required|email|max:128|unique:newsletter_users,email', 'language' => [ 'required', 'string', 'max:6', new Enum(NewsletterLanguage::class), ], ]); $newsletterUser = (new CreateNewsletterUserAction())->execute($validatedData); // Send verification email Mail::to($this->email) ->locale($this->language) ->send(new NewsletterVerificationMail($newsletterUser)); $this->reset('email'); $this->dispatchBrowserEvent('alert',[ 'type'=> 'success', 'message'=> __('template.newsletter-waiting-for-validation') ]); } } In the subscribe() method, we check if the input data is valid. If not, Livewire will automatically display error messages in our template. Finally, in the new-subscriber-form.blade.php file, we create our form template: <div> <div class="items-top mb-3 space-y-4 sm:flex sm:space-y-0 max-w-4xl"> <div class="relative w-full mr-1"> <label for="newsletter_email" class="hidden mb-2 text-sm font-medium text-gray-900 dark:text-gray-300"> {{ __('template.newsletter-email-label') }} </label> <div class="flex absolute inset-y-0 left-0 items-center pl-3 pointer-events-none"> <svg class="w-5 h-5 text-gray-500 dark:text-gray-400" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path d="M2.003 5.884L10 9.882l7.997-3.998A2 2 0 0016 4H4a2 2 0 00-1.997 1.884z"></path><path d="M18 8.118l-8 4-8-4V14a2 2 0 002 2h12a2 2 0 002-2V8.118z"></path></svg> </div> <input wire:model.defer="email" class="block p-3 pl-10 w-full text-sm text-gray-900 bg-gray-50 rounded-lg border border-gray-300 sm:rounded-none sm:rounded-l-lg focus:ring-primary-500 focus:border-primary-500 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-white dark:text-white dark:focus:ring-primary-500 dark:focus:border-primary-500" placeholder="{{ __('template.newsletter-email-placeholder') }}" type="email" id="newsletter_email"> @error('email') <p class='mt-2 text-sm text-red-600'>{{ $message }}</p> @enderror </div> <div class="relative w-full md:w-80 mr-1"> <label for="newsletter_language" class="hidden mb-2 text-sm font-medium text-gray-900 dark:text-gray-300"> {{ __('template.newsletter-language-label') }} </label> <select wire:model.defer="language" id="newsletter_language" class="bg-gray-50 border border-gray-300 text-gray-900 rounded-lg text-sm focus:ring-blue-500 focus:border-blue-500 block w-full p-3 dark:bg-gray-700 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white dark:focus:ring-blue-500 dark:focus:border-blue-500"> @foreach (config('app.locales') as $lang => $language) <option value="{{ $lang }}">{{ __('template.' . $lang) }}</option> @endforeach </select> @error('language') <p class='mt-2 text-sm text-red-600'>{{ $message }}</p> @enderror </div> <div> <button wire:click="subscribe()" wire:loading.attr="disabled" type="submit" class="py-3 px-5 w-full text-sm font-medium text-center text-white rounded-lg border cursor-pointer bg-primary-700 border-primary-600 sm:rounded-none sm:rounded-r-lg hover:bg-primary-800 focus:ring-4 focus:ring-primary-300 dark:bg-primary-600 dark:hover:bg-primary-700 dark:focus:ring-primary-800"> {{ __('template.newsletter-subscribe-button') }} </button> </div> </div> </div> This code defines a form for entering email and selecting language. We use the wire:model command here, which allows us for two-way database binding between PHP and HTML. We also use wire:submit.prevent="subscribe" to submit the form and call our subscribe() method. And that's all we need to create our Livewire component. How to integrate it into the page and further steps can be found below. Implementing Livewire Component into the Template Using a Livewire component in your Laravel application is straightforward and easy. In your Blade templating file, you simply use the @livewire directive. This directive accepts as the first parameter the name of the Livewire component you want to insert, and as the second parameter, you can pass an array with the data you want to pass to the component. <section class="mb-4 md:mb-8"> <div class="mx-auto"> <h2 class="mb-2 text-xl tracking-tight font-extrabold text-gray-900 sm:text-2xl dark:text-white"> {{ __('template.newsletter-headline') }} </h2> <p class="mx-auto mb-2 font-light text-gray-500 sm:text-xl dark:text-gray-400"> {{ __('template.newsletter-description') }} </p> @livewire('guest.newsletter.new-subscriber-form', ['language' => app()->getLocale()]) </div> </section> In the example guest.newsletter.new-subscriber-form is the name of our component and ['language' => app()->getLocale()] is the data we are passing to the component - specifically, the language the user is currently on. Thanks to this simple notation, we can easily use the component anywhere in your project. Setting Up Routing Routing is a key element of any web application. Laravel provides great support for defining routes for your applications. In our case, we only need to define one route: A route for user email address verification. We define the route in the routes/web.php file. ... Route::group([ 'prefix' => "{language}", 'where' => ['language' => '[a-zA-Z]{2}'] ], function () { Route::get('/newsletter/verify/{token}', [NewsletterUserController::class, 'verify']) ->name('newsletter.verify-user') ->middleware('signed'); }); ... Note: It would be possible to use 2 routes - for user email address verification and a second route directly for the Livewire component. In our case, we use the so-called signed route, which allows us to create links that are secure against "forgery". This route leads to the verify method in our NewsletterVerificationController. Translations and Internationalization Laravel provides a powerful tool for internationalizing your applications. Thanks to this, you can easily create applications that support multiple languages. For our newsletter system, we will need several translations. Translations in Laravel are organized into files located in the resources/lang directory. Each language has its own directory and contains files with translations. In our case, we will need translations for two languages, Czech and English. So, we create two files: resources/lang/cs/template.php resources/lang/en/template.php In these files, we define the translations we will use in our newsletter subscription system. Each file contains an array, where the key represents the translation identifier and the value is the translation itself. Sample for Czech translation: <?php return [ ... 'newsletter-headline' => "Přihlašte se k odběru novinek", 'newsletter-description' => "Přihlaste se k odběru novinek o AI, Laravelu, SEO a mnoho dalšího.", 'newsletter-email-label' => "Email", 'newsletter-email-placeholder' => "Zadejte svůj email", 'newsletter-language-label' => "Jazyk", 'newsletter-subscribe-button' => "Odebírat", 'newsletter-waiting-for-validation' => "Na váš e-mailový účet byl odeslán ověřovací odkaz.", 'newsletter-invalid-token' => "Neplatný token.", 'newsletter-successfuly-verified' => "Úspěšně ověřeno.", 'newsletter-email-verification-subject' => "Ověřte prosím svou emailovou adresu", 'newsletter-email-verification-headline' => "Vítejte v mém Newsletteru!", 'newsletter-email-verification-description' => "Děkujeme, že jste se přihlásili k odběru mého newsletteru. Kliknutím na tlačítko níže ověřte svou e-mailovou adresu a dokončete odebírání novinek.", 'newsletter-email-verification-verify-button' => "Ověřit email", 'newsletter-email-verification-homepage-button' => "Přejít na web", 'newsletter-email-verification-thanks' => "Děkuji", ... ]; Sample for English translation: <?php return [ ... 'newsletter-headline' => "Sign up for newsletter", 'newsletter-description' => "Sign up for news on AI, Laravel, SEO and much more.", 'newsletter-email-label' => "Email address", 'newsletter-email-placeholder' => "Enter your email", 'newsletter-language-label' => "Language", 'newsletter-subscribe-button' => "Subscribe", 'newsletter-waiting-for-validation' => "A verification link has been sent to your email account.", 'newsletter-invalid-token' => "Invalid token.", 'newsletter-successfuly-verified' => "Successfully verified.", 'newsletter-email-verification-subject' => "Please verify your email address", 'newsletter-email-verification-headline' => "Welcome to my Newsletter!", 'newsletter-email-verification-description' => "Thank you for subscribing to my newsletter. Click the button below to verify your email address and complete your newsletter subscription.", 'newsletter-email-verification-verify-button' => "Verify email", 'newsletter-email-verification-homepage-button' => "Go to website", 'newsletter-email-verification-thanks' => "Thanks", ... ]; We can then use these translations in our templates or code using the __helper - as already shown in the previous code parts. In this way, we can add more languages to our application by simply adding more translation files. Laravel will automatically choose the right language according to the application settings (which is not the topic of this article). System Testing Using Pest Once we have a system for signing up users to the newsletter, it is important to make sure that all its parts are working properly. This is where automated tests come in. Pest is a popular tool for testing in Laravel. Pest is an elegant wrapper over PHPUnit, which allows writing tests in a declarative style, which is often more readable and easier to understand. Pest allows testing all parts of our application. We can test if our routes behave correctly, if the data is stored correctly in the database, or if the correct emails are sent. To test our newsletter system, we will create two tests: A test for verifying the newsletter user. A test for subscribing new users using the Livewire component. In these tests, we verify whether users can subscribe to the newsletter and verify whether verification emails are being sent and whether flash messages are displayed correctly. Testing the Livewire component - NewSubscriberFormTest.php: <?php use App\Enums\Newsletter\NewsletterLanguage; use App\Http\Livewire\Guest\Newsletter\NewSubscriberForm; use App\Mail\App\Guest\Newsletter\NewsletterVerificationMail; use App\Models\Newsletter\NewsletterUser; use Illuminate\Support\Facades\Mail; use Livewire\Livewire; it('subscribes a new user to the newsletter and sends a verification email', function () { Mail::fake(); Livewire::test(NewSubscriberForm::class) ->set('email', 'test@example.com') ->set('language', NewsletterLanguage::ENGLISH->value) ->call('subscribe') ->assertDispatchedBrowserEvent('alert'); expect(NewsletterUser::where('email', 'test@example.com')->first()) ->email->toEqual('test@example.com') ->language->toEqual(NewsletterLanguage::ENGLISH) ->is_verified->toBeFalse(); Mail::assertSent(NewsletterVerificationMail::class, function ($mail) { return $mail->newsletterUser->email === 'test@example.com' && $mail->newsletterUser->language === NewsletterLanguage::ENGLISH; }); }); it('validates the new user subscription input data', function () { Livewire::test(NewSubscriberForm::class) ->set('email', 'invalid-email') ->set('language', 'invalid-language') ->call('subscribe') ->assertHasErrors(['email', 'language']); }); Testing the controller - NewsletterUserControllerTest.php: <?php use App\Models\Newsletter\NewsletterUser; use Illuminate\Support\Facades\Config; use Illuminate\Support\Facades\URL; it('verifies a newsletter user successfully and redirects to the homepage with a success flash message', function () { $newsletterUser = NewsletterUser::factory()->create(); $response = $this->get(URL::signedRoute('newsletter.verify-user', [ 'language' => $newsletterUser->language, 'token' => $newsletterUser->verification_token ])); $response->assertStatus(302); $response->assertRedirect(route('homepage', ['language' => $newsletterUser->language])); $response->assertSessionHas('flashType', 'success'); $response->assertSessionHas('flashMessage', __('template.newsletter-successfuly-verified')); $newsletterUser->refresh(); expect($newsletterUser->is_verified)->toBeTrue(); }); it('fails to verify a newsletter user for an invalid token and redirects to the homepage with an error flash message', function () { $response = $this->get(URL::signedRoute('newsletter.verify-user', [ 'language' => Config::get('translatable.fallback_locale'), 'token' => 'invalidtoken' ])); $response->assertStatus(302); $response->assertRedirect(route('homepage', ['language' => Config::get('translatable.fallback_locale')])); $response->assertSessionHas('flashType', 'error'); $response->assertSessionHas('flashMessage', __('template.newsletter-invalid-token')); expect(NewsletterUser::where('is_verified', true)->count())->toBe(0); }); Pest provides us with a range of methods for asserting such as assertStatus, assertRedirect or for example assertSessionHas. To verify the status in the database, we can use the assertDatabaseHas method. When writing tests, it is important to make sure that the tests cover all possible scenarios and that they are independent of each other. This means that each test should have its own isolated state and should not affect the results of other tests. Working with Actions Actions in Laravel help us keep our code organized and ensure that each operation is clearly defined. In our newsletter subscription system, we created two key actions - CreateNewsletterUserAction and VerifyNewsletterUserAction, which we did not discuss in the article. CreateNewsletterUserAction is responsible for creating a new user in our newsletter database. This is where the email and language chosen by the user for receiving the news are recorded. <?php namespace App\Actions\Guest\Newsletter; use App\Models\Newsletter\NewsletterUser; class CreateNewsletterUserAction { public function execute(array $validatedData): NewsletterUser { return NewsletterUser::create($validatedData); } } Then, VerifyNewsletterUserAction verifies the user based on the token received in the verification email. This action also sets the is_verified flag to true upon successful verification. <?php namespace App\Actions\Guest\Newsletter; use App\Models\Newsletter\NewsletterUser; class VerifyNewsletterUserAction { public function execute(NewsletterUser $newsletterUser): NewsletterUser { $newsletterUser->update([ 'is_verified' => true, 'verification_token' => null ]); return $newsletterUser; } } These two actions demonstrate how we can effectively organize our operations in Laravel. They make it easier for us to scale our newsletter system in the future. Using Enum for Language Settings The NewsletterLanguage enumerator provides us with an elegant and safe way to manipulate language codes in our application. By using Enum, we are sure that we will only work with permitted values - in our case, en for English and cs for Czech. Using Enum also increases the readability of the code and simplifies maintenance, as all possible values are centralized in one place. <?php namespace App\Enums\Newsletter; use Illuminate\Support\Collection; enum NewsletterLanguage: string { case ENGLISH = 'en'; case CZECH = 'cs'; public static function all(): Collection { return collect(NewsletterLanguage::cases())->map( fn(NewsletterLanguage $code) => $code->details() ); } public function details(): array { return match($this) { self::ENGLISH => [ 'name' => 'English', 'value' => 'en', ], self::CZECH => [ 'name' => 'Czech', 'value' => 'cs', ], }; } } The all and details methods then allow us to easily obtain all available languages and their details, which is useful for example when filling in a language selection field in the form. Homework Use of enumerator in Livewire component In the template at the Livewire component, I used iteration over an array stated in the configuration file, specifically in app.php - config('app.locales'). However, in production, it would be ideal to use enum. Hint: Why do we have the all() method in the enumerator? Could it be used? Handling of validation messages The Livewire component is not completely translated. Laravel can output messages in English for error messages, but not in Czech. Hint: Livewire has a nicely described documentation and with the use of Laravel documentation, this task should be easily solvable. Creating a seeder If you want to have a database filled with randomly generated data and you do not want to rely only on tests, you will definitely use a seeder. This also makes it easier for other developers to understand your application without the need to create data manually. Hint: Since we have a factory for creating model instances, including an example of use in the test, nothing should cause you problems. Send mail in the queue So that the user does not wait until the function is executed (an email is sent), you can use processing via so-called queues for the email. Hint: Laravel again has everything nicely summarized in the documentation. Personally, I recommend "implementing" the use of a queue in the file for email logic (i.e., the only class that is not used in our demonstration, yet the file contains it - it is even added if you generate the file via the artisan command). Conclusion Creating a newsletter subscription system in Laravel may seem like a complex task. This article should show you that it is not as complicated as it might seem at first glance. Thanks to this guide, you had the opportunity to familiarize yourself with the whole process from basic preparation to the implementation of individual parts and testing. Laravel is a powerful and flexible framework that allows you to create different types of web applications. Using Livewire, we can easily create dynamic components and thanks to Pest, we can effectively test our application and make sure everything works correctly. It is also important to remember internationalization and prepare our application for multilingual users. Laravel provides great tools for working with translations and localization. I hope this guide has helped you understand how to create a newsletter subscription system in Laravel and that it has inspired you for further projects. Remember, practical experience is the most important thing, so don't hesitate and start your own project!]]> https://www.pavelzanek.com/en/blog/factory-astrotomic-laravel-translatable https://www.pavelzanek.com/en/blog/factory-astrotomic-laravel-translatable Sun, 18 Jun 2023 00:00:00 +0200 $this->faker->word, // other attributes... ]; } ... In the definition() method, we use the so-called Faker library, which allows us to generate various types of random data, such as words, sentences, numbers, and other data. Now that you have created a factory, you can use it to create data for your tests. You can do this, for example, as follows: $user = UserFactory::new()->create(); In this way, you create a new record in the database with data generated by your factory. Factories in Laravel are a powerful tool that allows you to easily and efficiently generate test data for your applications. How to use the Astrotomic/laravel-translatable package for translations The Astrotomic/laravel-translatable package is a tool that allows for easy translations of your models in Laravel. This package is ideal for projects that require multilingual support and allows you to store translations of your models directly in the database. To be able to use the package, we must first install it. This can be done using the following command: composer require astrotomic/laravel-translatable After installing the package, we need to use the Translatable trait in our model that we want to translate. The trait adds methods that allow us to easily work with translations. ... use Astrotomic\Translatable\Translatable; class Post extends Model { use Translatable; public $translatedAttributes = ['title', 'body']; ... } In this example, we used the Translatable trait in the Post model and we define that the title and body attributes will be translated. In addition to the trait, we can also add a contract: ... use Astrotomic\Translatable\Contracts\Translatable as TranslatableContract; use Astrotomic\Translatable\Translatable; class Post extends Model implements TranslatableContract { use Translatable; public $translatedAttributes = ['title', 'body']; ... } The Astrotomic/laravel-translatable package then allows us to easily access translations and work with them. For example: $post = Post::first(); echo $post->translate('en')->title; // this will print the English title of the post The Astrotomic/laravel-translatable package is a powerful tool for working with translations in Laravel. In the next section, we will look at how we can use it when creating factories. Creating a factory for models with the Astrotomic/laravel-translatable package Now that we have a basic understanding of how the Astrotomic/laravel-translatable package works, we can look at how to create a factory for models that use this package. Let's imagine that we have a Post model that uses the Astrotomic/laravel-translatable package for translating the title and body attributes. How would we create a factory for this model? The first step is the same as we showed in the previous section - we create a factory using the Artisan command: php artisan make:factory PostFactory --model=Post Then we open the factory file and modify the definition() method to generate translations for our attributes. We can do this, for example, as follows: ... public function definition() { $locales = ['en', 'cs']; $translations = collect($locales)->mapWithKeys(function($locale) { return [ $locale => [ 'title' => $this->faker->words(3, true), 'body' => $this->faker->realText(500), ... ] ]; })->toArray(); return array_merge($translations, [ 'type' => PostType::POST, // non-translatable attribute ]); } ... In this example, we generate translations for English (en) and Czech (cs) using the Faker library. We can add as many languages as we need. Now that we have created a factory, we can use it to create data for our tests in the same way as we showed in the previous section. In this way, we can easily create factories for models that use the Astrotomic/laravel-translatable package for translations. Conclusion In this article, we have thoroughly familiarized ourselves with the process of creating a factory for models in Laravel using the Astrotomic/laravel-translatable package for translations. We went through the basics of creating a factory, got acquainted with the Astrotomic/laravel-translatable package, and finally showed how to create a factory for models that use this package. We hope that this guide has helped you understand how to effectively use factories in Laravel and how to combine them with the translation package. Laravel is a powerful framework that offers many tools and features that make web application development easier. Factories and the translation package are just a small part of what Laravel offers. If you want to deepen your knowledge of Laravel and its features, I recommend looking at other resources and tutorials/guides that are available online. Also, don't be afraid to experiment and try new things - that's the best way to learn and improve your skills. I wish you a lot of success and joy in developing with the Laravel framework!]]> https://www.pavelzanek.com/en/blog/title https://www.pavelzanek.com/en/blog/title Wed, 14 Jun 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/structured-data https://www.pavelzanek.com/en/blog/structured-data Wed, 07 Jun 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/chatgpt https://www.pavelzanek.com/en/blog/chatgpt Tue, 06 Jun 2023 00:00:00 +0200 https://www.pavelzanek.com/en/blog/new-laravel-application-homestead https://www.pavelzanek.com/en/blog/new-laravel-application-homestead Sun, 05 Dec 2021 00:00:00 +0100 Open… (CTRL+O) and go to the folder "C:\Windows\System32\drivers\etc". Remember to display all files if you only see .txt files (or see nothing, like me): We see all the files in the folder and open the "hosts" file. Now we add: ... 192.168.10.10 your-laravel-application.test ... Thus, we have mapped the IP address of our future Homestead to a URL. If we enter the URL into the browser later, the requests will be directed to Homestead – let's set it up. Setting Up the Homestead.yaml File Go to the folder where you have Homestead installed (in my case "C:\Users\***\Homestead") and open (again you can in Notepad without the need to run the file as an administrator, or in your favorite IDE) the Homestead.yaml file. Take a look at an example of what your Homestead.yaml could look like. --- ip: "192.168.10.10" memory: 512 cpus: 1 provider: virtualbox ssl: true authorize: c:/Users/***/.ssh/your-public-key.pub keys: - c:/Users/***/.ssh/your-private-key.ppk folders: - map: d:/laravel-websites to: /home/vagrant/code sites: - map: your-laravel-app.test to: /home/vagrant/code/your-laravel-app.test/public php: '8.0' databases: - your_db_to_application features: - mysql: false - mariadb: true - postgresql: false - ohmyzsh: false - webdriver: false # ports: # - send: 50000 # to: 5000 # - send: 7777 # to: 777 # protocol: udp Several things are worth noting, let's take a look at them. IP address – the same one we used in the hosts file folders – we need to map where the application is located. In my case, I use the "D:\" drive, in which I have a "laravel-websites" folder. This entire folder gets to Homestead under "/home/vagrant/code". databases – we can directly create a db for our application additionally, I showed how you can access Homestead under SSH. Installing Laravel Using the Installer Now we know on which URL we will build the application. We also know that if we enter the URL into the browser, we will get to Homestead thanks to the mapping. Homestead is then configured to download content from the local "D:\laravel-websites" folder and place it in "/home/vagrant/code". However, we also know that we are specifically looking for /home/vagrant/code/your-laravel-app.test/public. So we need to install a Laravel application. So, we go to "D:\laravel-websites" using the command line and run: laravel new your-laravel-app.test After completion, the result should end up something like this: Launching Homestead with New Configuration Now we need to start Homestead including our new configuration. So, go to the location where you have Homestead installed (in my case "C:\Users\***\Homestead") in the command line and run: vagrant up --provision Alternatively, if you already have Homestead running, you can use (so you don't have to turn off Homestead via "vagrant halt") vagrant reload --provision It's important that the --provision switch is used, which launches Homestead with the new configuration. TIP If you want to log into Homestead using SSH, just run from the installed folder with Homestead: vagrant ssh Then you can get to your application: cd code/your-laravel-app.test In Homestead, in the project folder, you can perform various commands (migrations, generation of assets, installation of packages, etc.). In Conclusion Now you just need to add the project to your IDE and edit the .env file. Once you configure it, you can enter the URL of the project in the browser and see the new Laravel application. Then just create something great.]]> https://www.pavelzanek.com/en/blog/laravel-application-localization https://www.pavelzanek.com/en/blog/laravel-application-localization Sat, 20 Nov 2021 00:00:00 +0100 [ 'en' => 'English', 'cs' => 'Czech', ], ... Middleware Language app/Http/Middleware/Language.php: <?php namespace App\Http\Middleware; use Closure; use Illuminate\Http\Request; use Illuminate\Support\Facades\App; use Illuminate\Support\Facades\URL; class Language { /** * Handle an incoming request. * * @param \Illuminate\Http\Request $request * @param \Closure $next * @return mixed */ public function handle(Request $request, Closure $next) { App::setLocale($request->language); URL::defaults(['language' => $request->language]); $request->route()->forgetParameter('language'); return $next($request); } } Adding Middleware to the Kernel app/Http/Kernel.php: ... protected $middlewareGroups = [ 'web' => [ \App\Http\Middleware\Language::class, // Localization ], ... ]; ... Routes in web.php routes/web.php: ... Route::group([ 'prefix' => "{language}", 'where' => ['language' => '[a-zA-Z]{2}'] ], function () { ... }); ... LanguageController.php Controller app/Http/Controllers/LanguageController.php: <?php namespace App\Http\Controllers; use Illuminate\Http\Request; use Illuminate\Support\Facades\App; use Illuminate\Support\Facades\URL; class LanguageController extends Controller { public function switchLang(Request $request, $lang) { // $urlParts[1] == current lang $urlParts = explode('/', str_ireplace(array('http://', 'https://'), '', url()->previous())); $newUrl = str_replace( '/' . $urlParts[1] . '/', '/' . $lang . '/', url()->previous() ); App::setLocale($lang); URL::defaults(['language' => $lang]); return redirect()->to($newUrl); } } Adding the Controller Route to web.php routes/web.php: ... Route::get('lang/{lang}', [App\Http\Controllers\LanguageController::class, 'switchLang'])->name('langSwitcher'); ... RouteServiceProvider.php app/Providers/RouteServiceProvider.php: ... public const DASHBOARD = '/en/dashboard'; ... Creating a Language Switcher Example for use in the stack: Laravel, Jetstream – Livewire + Blade, Tailwindcss resources/views/navigation-menu.blade.php: Desktop ... <!-- Language Dropdown --> <div class="ml-3 relative"> <x-jet-dropdown align="right" width="48"> <x-slot name="trigger"> <span class="inline-flex rounded-md"> <button type="button" class="inline-flex items-center px-3 py-2 border border-transparent text-sm leading-4 font-medium rounded-md text-gray-500 bg-white hover:text-gray-700 focus:outline-none transition"> @lang(config('app.locales')[App::getLocale()]) <svg class="ml-2 -mr-0.5 h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20" fill="currentColor"> <path fill-rule="evenodd" d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clip-rule="evenodd" /> </svg> </button> </span> </x-slot> <x-slot name="content"> <!-- Language Switcher --> <div class="block px-4 py-2 text-xs text-gray-400"> {{ __('Select language') }} </div> @foreach (config('app.locales') as $lang => $language) @if ($lang !== App::getLocale()) <x-jet-dropdown-link href="{{ route('langSwitcher', $lang) }}"> @lang($language) </x-jet-dropdown-link> @endif @endforeach </x-slot> </x-jet-dropdown> </div> ... Responsive Version ... <div class="mt-3 space-y-1"> <div class="border-t border-gray-200"></div> <div class="block px-4 py-2 text-xs text-gray-400"> {{ __('Select language') }} </div> @foreach (config('app.locales') as $lang => $language) @if ($lang !== App::getLocale()) <x-jet-responsive-nav-link href="{{ route('langSwitcher', $lang) }}"> @lang($language) </x-jet-responsive-nav-link> @endif @endforeach <div class="border-t border-gray-200"></div> </div> ... Adding Translations For example, resources/lang/cs.json: { "Dashboard": "Nástěnka", "Select language": "Vyberte jazyk", "Czech": "Čeština", ... } Result Czech Version: English Version: Tip If you use Jetstream with Livewire as in the example and want to localize the default routes, then a few more minor adjustments are necessary. From the /vendor/jetstream/routes/ folder, copy the routes to your routes. The file can then look like this (routes/web.php): <?php use Illuminate\Support\Facades\Route; use Laravel\Jetstream\Http\Controllers\CurrentTeamController; use Laravel\Jetstream\Http\Controllers\Livewire\ApiTokenController; use Laravel\Jetstream\Http\Controllers\Livewire\PrivacyPolicyController; use Laravel\Jetstream\Http\Controllers\Livewire\TeamController; use Laravel\Jetstream\Http\Controllers\Livewire\TermsOfServiceController; use Laravel\Jetstream\Http\Controllers\Livewire\UserProfileController; use Laravel\Jetstream\Http\Controllers\TeamInvitationController; use Laravel\Jetstream\Jetstream; Route::get('lang/{lang}', [App\Http\Controllers\LanguageController::class, 'switchLang'])->name('langSwitcher'); Route::get('/', function () { return redirect()->route('login'); }); Route::group([ 'prefix' => "{language}", 'where' => ['language' => '[a-zA-Z]{2}'] ], function () { Route::group(['middleware' => config('jetstream.middleware', ['web'])], function () { if (Jetstream::hasTermsAndPrivacyPolicyFeature()) { Route::get('/terms-of-service', [TermsOfServiceController::class, 'show'])->name('terms.show'); Route::get('/privacy-policy', [PrivacyPolicyController::class, 'show'])->name('policy.show'); } Route::group(['middleware' => ['auth:sanctum', 'verified']], function () { Route::get('/user/profile', [UserProfileController::class, 'show']) ->name('profile.show'); if (Jetstream::hasApiFeatures()) { Route::get('/user/api-tokens', [ApiTokenController::class, 'index'])->name('api-tokens.index'); } if (Jetstream::hasTeamFeatures()) { Route::get('/teams/create', [TeamController::class, 'create'])->name('teams.create'); Route::get('/teams/{team}', [TeamController::class, 'show'])->name('teams.show'); Route::put('/current-team', [CurrentTeamController::class, 'update'])->name('current-team.update'); Route::get('/team-invitations/{invitation}', [TeamInvitationController::class, 'accept']) ->middleware(['signed']) ->name('team-invitations.accept'); } }); }); Route::group(['middleware' => ['auth:sanctum', 'verified']], function () { Route::get('/dashboard', function () { return view('dashboard'); })->name('dashboard'); }); }); For instance, if we modify the route for displaying the profile, like this (routes/web.php): ... // Old value: /user/profile Route::get('/profile', [UserProfileController::class, 'show'])->name('profile.show'); ... If we make the above change, the profile display will be available on our route /profile, and we can also use the default route /user/profile (loaded from the package – laravel/jetstream/routes/livewire.php). If we want to disable the default routes, then we must modify JetsreamServiceProvider.php (app/Providers/JetsreamServiceProvider.php). ... public function register() { Jetstream::ignoreRoutes(); } ...]]> https://www.pavelzanek.com/en/blog/page-indexing https://www.pavelzanek.com/en/blog/page-indexing Thu, 30 Nov 2017 00:00:00 +0100 https://www.pavelzanek.com/en/blog/automatically-generated-content https://www.pavelzanek.com/en/blog/automatically-generated-content Sat, 19 Aug 2017 00:00:00 +0200 https://www.pavelzanek.com/en/blog/correct-landing-page https://www.pavelzanek.com/en/blog/correct-landing-page Wed, 31 May 2017 00:00:00 +0200 https://www.pavelzanek.com/en/blog/data-collection-keyword-research-part-1 https://www.pavelzanek.com/en/blog/data-collection-keyword-research-part-1 Sat, 22 Apr 2017 00:00:00 +0200 https://www.pavelzanek.com/en/blog/keyword-research https://www.pavelzanek.com/en/blog/keyword-research Sat, 22 Apr 2017 00:00:00 +0200