Unit1 - Subjective Questions

Model-View-Controller (MVC) is an architectural pattern that separates an application into three main logical components: the Model, the View, and the Controller. This separation helps to manage complexity when building applications.

Components:

1. Model:
   • The Model represents the data and the business logic of the application.
   • It retrieves data from the database and persists data back to it.
   • In Laravel, this is handled via Eloquent ORM.
2. View:
   • The View is the User Interface (UI). It displays data to the user.
   • It contains HTML, CSS, and client-side JavaScript.
   • In Laravel, Views are typically created using the Blade templating engine.
3. Controller:
   • The Controller acts as an interface between the Model and the View.
   • It processes the incoming HTTP requests, interacts with the Model to fetch data, and passes that data to the View for rendering.

Laravel is a free, open-source PHP web framework created by Taylor Otwell and intended for the development of web applications following the model–view–controller (MVC) architectural pattern. It is designed to make common web development tasks easier and faster.

Key Features:

1. Eloquent ORM: An object-relational mapper that makes interacting with databases intuitive.
2. Blade Templating Engine: A powerful template engine that does not restrict developers from using plain PHP code.
3. Artisan Console: A built-in command-line interface for automating repetitive tasks.
4. Migration System: Version control for database schemas, allowing teams to modify and share the application's database schema.
5. Built-in Authentication: Laravel provides out-of-the-box support for authentication and authorization.

The Request Lifecycle describes how a request is handled from the moment it enters the application until the response is returned.

Steps in the Lifecycle:

1. Entry Point (index.php): All requests land on the public/index.php file, which loads the Composer autoloader and the Laravel application instance.
2. HTTP Kernel: The request is sent to the HTTP Kernel (app/Http/Kernel.php). This handles middleware (e.g., session handling, CSRF protection).
3. Routing: The Service Container sends the request to the router. The router determines which Controller or closure should handle the request.
4. Controller Action: The Controller executes logic. It may communicate with the Model to fetch or save data.
5. View Rendering: The Controller passes data to the View. The View generates the final HTML.
6. Response: The response is returned through the Kernel and sent back to the user's browser.

Composer is a dependency manager for PHP. It allows developers to declare the libraries their project depends on and manages the installation and updating of these libraries.

Significance:

• Dependency Management: It automatically downloads libraries and their specific dependencies (recursive dependencies).
• Autoloading: It generates an autoload.php file, allowing developers to use classes without manually include or require statements.
• Version Control: By using composer.json and composer.lock, it ensures that every developer on a team installs exactly the same version of the packages.
• Project Creation: It is the standard way to install frameworks like Laravel (e.g., composer create-project).

To install the latest version of Laravel via Composer, the following command is used:

bash
composer create-project laravel/laravel example-app

Explanation of Parameters:

• composer: Invokes the Composer executable.
• create-project: The command to clone a package and install its dependencies to create a new project.
• laravel/laravel: The package name (Vendor/Package) to install.
• example-app: The name of the directory where the application will be created (this is your project name).

Note: To force a specific version, one might add the version number, e.g., "laravel/laravel:^10.0".

To run the latest Laravel framework, the server must meet specific requirements, primarily regarding the PHP version and installed extensions.

Requirements:

1. PHP Version: Must be PHP 8.1 or higher (depending on the specific Laravel version).
2. BCMath PHP Extension
3. Ctype PHP Extension
4. Fileinfo PHP Extension
5. JSON PHP Extension
6. Mbstring PHP Extension
7. OpenSSL PHP Extension
8. PDO PHP Extension
9. Tokenizer PHP Extension
10. XML PHP Extension

Laravel follows a specific directory structure to organize code.

Key Directories:

1. app/: Contains the core code of the application (Models, Controllers, Middleware). Most of the development happens here.
2. config/: Contains all of the application's configuration files (database settings, mail settings, app execution settings).
3. database/: Contains database migrations, model factories, and seeds.
4. public/: The web server's document root. It contains the index.php file (entry point) and assets like images, JavaScript, and CSS.
5. resources/: Contains uncompiled assets such as raw CSS/SCSS, JavaScript, and the Blade templates (views).
6. routes/: Contains all of the route definitions for the application (e.g., web.php, api.php).
7. vendor/: Contains the Composer dependencies.

The routes directory defines how the application responds to client requests via URLs.

Default Route Files:

1. web.php: Contains routes that the RouteServiceProvider places in the web middleware group. These routes provide features like session state, CSRF protection, and cookie encryption. Used for standard web interface interactions.
2. api.php: Contains routes placed in the api middleware group. These are stateless and usually require token authentication. Used for API development.
3. console.php: Defines closure-based console commands (Artisan commands).
4. channels.php: Registers all of the event broadcasting channels for real-time applications.

public Directory:

• This is the entry point for the web server.
• It contains the index.php file.
• It stores compiled or static assets accessible directly by the browser, such as images, compiled CSS, and compiled JavaScript bundles.

resources Directory:

• This directory contains the source code for assets.
• It holds raw, uncompiled files like SASS/SCSS, raw JavaScript, and language files.
• It also contains the Views (Blade templates) which are rendered by the server before being sent to the browser.

Artisan is the command-line interface (CLI) included with Laravel. It provides a number of helpful commands for use while building an application.

Accessing Artisan:

It is accessed via the terminal in the root of the Laravel project using the PHP executable:

bash
php artisan list

It is driven by the powerful Symfony Console component.

1. php artisan serve: Starts the local development server (typically at http://localhost:8000).
2. php artisan make:controller [Name]: Creates a new Controller class file in app/Http/Controllers.
3. php artisan make:model [Name]: Creates a new Eloquent Model class.
4. php artisan migrate: Runs the database migrations to update the database schema.
5. php artisan route:list: Displays a list of all registered routes in the application, including their methods, URIs, and middleware.

Blade is Laravel's powerful templating engine used for the View component of MVC.

• Inheritance: Blade allows defining a master layout (using @extends and @yield), reducing code duplication across different pages.
• Data Display: It easily displays data passed from the Controller using double curly braces (e.g., {{ $name }}), which automatically escapes data to prevent XSS attacks.
• Control Structures: It provides shortcuts for common PHP control structures like @if, @foreach, and @auth.
• Performance: Unlike some template engines, Blade views are compiled into plain PHP code and cached until they are modified, ensuring zero overhead.

The .env file serves as the configuration file for environment-specific variables.

• Environment Configuration: It allows developers to define different settings for local, staging, and production environments (e.g., APP_ENV=local).
• Security: Sensitive credentials like database passwords (DB_PASSWORD), API keys, and mail server credentials are stored here.
• Git Exclusion: The .env file is included in .gitignore by default, ensuring sensitive data is not committed to version control systems.
• Access: Values are accessed in the code using the env('KEY') helper function.

Eloquent ORM (Object-Relational Mapping) is Laravel's built-in database abstraction layer.

Mapping Concept:

• Active Record Implementation: Eloquent is an Active Record implementation, meaning each database table has a corresponding "Model" class.
• Table to Class: A table named users maps to a model class named User.
• Row to Object: Each instance of the User model represents a single row in the users table.
• Interactions: Developers can query the database using PHP syntax (e.g., User::all()) rather than writing raw SQL, making the code more readable and maintainable.

To install Composer globally on Windows:

1. Download: Visit getcomposer.org and download the Composer-Setup.exe installer.
2. Run Installer: Run the executable file.
3. PHP Path: During installation, Composer will ask for the location of php.exe. Browse and select the PHP executable (e.g., inside XAMPP/WAMP folder).
4. Path Variable: The installer automatically adds Composer to the system PATH environment variable.
5. Verification: Open a new Command Prompt terminal and type composer. If the Composer logo and version details appear, the installation is successful.

php artisan tinker launches an interactive shell (REPL - Read-Eval-Print Loop) for the Laravel application.

Purpose:

• Testing Logic: It allows developers to interact with the entire Laravel application (Models, Classes, Events) from the command line without creating routes or controllers.
• Database Interaction: Developers can run Eloquent queries (e.g., User::find(1)) to inspect data quickly.
• Debugging: It is useful for debugging code snippets and testing relationships between models in real-time.

In Laravel, Namespaces are used to organize classes and prevent naming collisions, adhering to the PSR-4 autoloading standard.

• Structure Reflection: The namespace usually reflects the directory structure. For example, a controller located in app/Http/Controllers usually has the namespace App\Http\Controllers.
• The App Namespace: By default, the application logic under the app/ directory lives under the App namespace.
• Autoloading: Composer uses these namespaces to automatically load files when a class is called, eliminating the need for include statements.
• Grouping: It groups related classes (e.g., all Models, all Controllers), making large applications manageable.

Laravel provides an easy way to disable the application while updates are performed using Artisan commands.

1. Enable Maintenance Mode:
   Run php artisan down. This will show a custom "Service Unavailable" view to all users.
2. Bypass:
   You can specify a secret token to bypass maintenance mode: php artisan down --secret="1630542a-246b-4b66-afa1-dd72a4c43515". You can then access the site via your-domain.com/1630542a... to set a cookie allowing access.
3. Disable Maintenance Mode:
   Run php artisan up to bring the application back online for all users.