# Views
# Introduction
Views in Laravel are responsible for separating the application's logic from the presentation layer. They provide a clean way to manage and organize the HTML content of your application. Views are typically stored in the resources/views
directory and are rendered using the Blade templating engine, which offers a simple and powerful way to create dynamic content.
By using views, you can create reusable templates and components, making your code more maintainable and easier to understand. Blade templates allow you to use control structures like loops and conditionals, as well as to include other templates, which helps to keep your views organized and modular.
To learn in detail about Views, you can visit the Laravel documentation here (opens new window).
Here's a basic example of a Blade template:
# Directory Structure
To organize the views for our blog package, we need to set up a specific directory structure. Follow the steps below to create the necessary folders.
# Create the Resources
Folder
- Navigate to the
packages/Webkul/Blog/src
directory. - Create a folder named
Resources
.
# Create the views
Folder
- Inside the
Resources
folder, create another folder namedviews
.
# Create the admin
and shop
Folders
- Inside the
views
folder, create two folders namedadmin
andshop
.
The updated directory structure will look like this:
└── packages
└── Webkul
└── Blog
└── src
├── ...
└── Resources
└── views
├── admin
└── shop
# Create the index.blade.php
File in the shop
Folder
Inside the
shop/default
folder, create a file namedindex.blade.php
,create.blade.php
,edit.blade.php
.└── packages └── Webkul └── Blog └── src ├── ... └── Resources └── views ├── admin │ └── index.blade.php └── shop └── index.blade.php └── create.blade.php └── edit.blade.php
# Adding HTML Content
Below is an example of basic HTML content that you can add to each index.blade.php
file.
# index.blade.php
in the admin
Folder
<!DOCTYPE html>
<html>
<head>
<title>Admin - Blog Posts</title>
</head>
<body>
<h1>Admin - Blog Posts</h1>
<p>Welcome to the admin section for managing blog posts.</p>
</body>
</html>
# index.blade.php
in the default
Folder
<!DOCTYPE html>
<html>
<head>
<title>Shop - Blog Posts</title>
</head>
<body>
<h1>Shop - Blog Posts</h1>
<p>Welcome to the shop section for viewing blog posts.</p>
</body>
</html>
# Load Views from Package
To make the views in our package accessible, we need to register them in the service provider's boot
method. This involves updating the BlogServiceProvider.php
file to include the view loading logic. Follow the steps below:
# Open the Service Provider File
- Navigate to the
packages/Webkul/Blog/src/Providers
directory. - Open the
BlogServiceProvider.php
file.
# Update the boot
Method
- Inside the
boot
method of theBlogServiceProvider
class, add the logic to load views from the package.
# Updated BlogServiceProvider.php
Here is the updated code for BlogServiceProvider.php
:
<?php
namespace Webkul\Blog\Providers;
use Illuminate\Support\ServiceProvider;
class BlogServiceProvider extends ServiceProvider
{
/**
* Bootstrap services.
*
* @return void
*/
public function boot()
{
//...
$this->loadViewsFrom(__DIR__ . '/../Resources/views', 'blog');
}
}
# Explanation
- The
namespace
keyword defines the namespace for theBlogServiceProvider
class, which isWebkul\Blog\Providers
. - The
BlogServiceProvider
class extends Laravel's baseServiceProvider
class. - The
boot
method is used to bootstrap any application services. - Inside the
boot
method, we use the$this->loadViewsFrom
method to register the views from the package. - The
loadViewsFrom
method takes two arguments:- The path to the views directory within the package:
__DIR__ . '/../Resources/views'
. - A namespace for the views:
'blog'
.
- The path to the views directory within the package:
# Rendering Views
In Laravel applications, views are typically rendered from controller methods using the view
helper function. This section describes how views are invoked and passed data from a controller.
<?php
namespace Webkul\Blog\Http\Controllers\Shop;
use Webkul\Blog\Http\Controllers\Controller;
use Webkul\Blog\Repository\PostRepository;
class PostController extends Controller
{
/**
* Create a controller instance.
*
* @param \Webkul\Blog\Repository\PostRepository $postRepository
* @return void
*/
public function __construct(protected PostRepository $postRepository){}
/**
* Index.
*
* @return \Illuminate\View\View
*/
public function index()
{
$blogs = $this->postRepository->with(['author'])->all();
return view('blog::shop.index', compact('blogs'));
}
}
# Explanation
The
view
helper function in Laravel is used within theindex
method of thePostController
to render theshop.index
view.It accepts two parameters the name of the view (
blog::shop.index
) and an array of data (compact('blogs')
) to pass to theview
.
# Blade File Naming Convention
Bagisto utilizes Blade templates to handle listing
, creation
, and updating
operations for resources like products, posts, and categories. This section provides a detailed guide on how to implement these operations using Blade templates within your Bagisto package.
# Listing (Index Blade):
The
index.blade.php
template is used to display a list of all records (posts).The controller's
index
method fetches all posts and passes them to the view.
# Creation (Create Blade):
The
create.blade.php
template contains a form for creating new records.The controller's
create
method renders this view.
# Updating (Edit Blade):
The
edit.blade.php
template contains a form for editing existing records.The controller's
edit
method fetches the specific post and passes it to the view.
By following these steps, you can effectively utilize Blade templates in Bagisto for listing, creating, and updating resources, ensuring a structured and maintainable approach to managing CRUD operations within your application.