php - new - nwidart laravel modules laravel

¿Cómo estructurar una aplicación modular en Laravel 5?

Question

Me gustaría dividir mi aplicación en módulos. Por ejemplo, habría un módulo "central" que contiene la funcionalidad básica de inicio de sesión, el diseño / formato de la aplicación (CSS, etc.), la gestión de usuarios y un diario.

Más adelante, puedo crear otros módulos como un administrador de contactos que se pueden agregar o quitar fácilmente de la aplicación.

Habría cierta lógica en la navegación de las aplicaciones para determinar qué módulos están presentes y para mostrar / ocultar los enlaces a ellos.

¿Cómo puedo hacer esto en términos de estructura de directorios, espacios de nombres y cualquier otra cosa que sea necesaria?

Estoy viendo creolab / laravel-modules pero dice que es para Laravel 4. ¿Puedo usarlo con 5 exactamente de la misma manera?

La documentación dice colocar modelos, controladores y vistas dentro del directorio de cada módulo, pero ¿cómo funciona esto con las rutas? Idealmente, me gustaría que cada módulo tenga su propio archivo routes.php. ¿Cómo funcionará todo esto con las cosas en el http y el directorio de resources ?

Estaba pensando en algo como esto:

Pero no tengo idea de cómo lo haría funcionar.

Acabo de probar el tutorial aquí:

http://creolab.hr/2013/05/modules-in-laravel-4/

Sin bibliotecas adicionales, etc., solo Laravel 5 puro.

Parece que golpeé una pared de ladrillos con un mensaje de error:

FatalErrorException in ServiceProvider.php line 16:
Call to undefined method Illuminate/Config/Repository::package()

En cuanto a lo siguiente:

<?php namespace App/Modules;
abstract class ServiceProvider extends /Illuminate/Support/ServiceProvider
{
public function boot()
{
if ($module = $this->getModule(func_get_args())) {
$this->package(''app/'' . $module, $module, app_path() . ''/modules/'' . $module);
}
}
public function register()
{
if ($module = $this->getModule(func_get_args())) {
$this->app[''config'']->package(''app/'' . $module, app_path() . ''/modules/'' . $module . ''/config'');
// Add routes
$routes = app_path() . ''/modules/'' . $module . ''/routes.php'';
if (file_exists($routes)) require $routes;
}
}
public function getModule($args)
{
$module = (isset($args[0]) and is_string($args[0])) ? $args[0] : null;
return $module;
}
}

¿Qué está causando esto y cómo puedo solucionarlo?

Entendí esto un poco más ahora. Conseguí que mis rutas y vistas de paquete / módulo funcionaran, lo cual es genial:

abstract class ServiceProvider extends /Illuminate/Support/ServiceProvider
{
public function boot()
{
if ($module = $this->getModule(func_get_args())) {
include __DIR__.''/''.$module.''/routes.php'';
}
$this->loadViewsFrom(__DIR__.''/''.$module.''/Views'', ''core'');
}
public function register()
{
if ($module = $this->getModule(func_get_args())) {
}
}
public function getModule($args)
{
$module = (isset($args[0]) and is_string($args[0])) ? $args[0] : null;
return $module;
}
}

Tengo una última pregunta, ¿cómo cargaría todos mis controladores desde mi paquete, al igual que cómo funciona el método loadViewsFrom() ?

Answer 1

Kundan roy: me gustó su solución, pero copié su código de , tuve que cambiar las comillas y las semi comillas para que funcionara; creo que SOF las reemplazó. También cambió Dir para base_path () para que esté más en línea con el formato (nuevo) de Laravel.

namespace App/Modules;
/**
* ServiceProvider
*
* The service provider for the modules. After being registered
* it will make sure that each of the modules are properly loaded
* i.e. with their routes, views etc.
*
* @author kundan Roy <[email protected]>
* @package App/Modules
*/
use Illuminate/Support/Facades/Route;
use Illuminate/Foundation/Support/Providers/RouteServiceProvider as ServiceProvider;
class ModulesServiceProvider extends ServiceProvider
{
/**
* Will make sure that the required modules have been fully loaded
* @return void routeModule
*/
public function boot()
{
// For each of the registered modules, include their routes and Views
$modules = config("module.modules");
while (list(,$module) = each($modules)) {
// Load the routes for each of the modules
if(file_exists(base_path(''app/Modules/''.$module.''/routes.php''))) {
include base_path(''app/Modules/''.$module.''/routes.php'');
}
// Load the views
if(is_dir(base_path(''app/Modules/''.$module.''/Views''))) {
$this->loadViewsFrom(base_path(''app/Modules/''.$module.''/Views''), $module);
}
}
}
public function register() {}
}

Answer 2

Parece que lo he resuelto todo.

Lo publicaré aquí en caso de que ayude a otros principiantes, solo se trataba de obtener los espacios de nombres correctos.

En mi composer.json tengo:

...
"autoload": {
"classmap": [
"database",
"app/Modules"
],
"psr-4": {
"App//": "app/",
"Modules//": "Modules/"
}
}

Mi directorio y archivos terminaron así:

Obtuve mi módulo Core router.php para trabajar envolviendo mis controladores para ese módulo en un grupo que especifica el espacio de nombres:

Route::group(array(''namespace'' => ''Modules/Core''), function() {
Route::get(''/test'', [''uses'' => ''TestController@index'']);
});

Me imagino que cuando haga mis modelos para el paquete, será un caso similar de obtener los espacios de nombres correctos.

¡Gracias por toda su ayuda y paciencia!

Answer 3

Solución:

Paso 1: Crear carpeta "Módulos" dentro de "aplicación /"

Paso 2: en la carpeta Módulos, cree su Módulo (Módulo1 (supongamos que el Módulo de administración))

 Inside admin module : create the following folder
1. Controllers (here will your controller files)
2. Views (here will your View files)
3. Models (here will your Model files)
4. routes.php (here will your route code in this file)

Del mismo modo, puede crear múltiples módulos

Module2( suppose API )
-Controllers
-Views
-Models
-routes.php

Paso 3: Crear ModulesServiceProvider.php dentro de la carpeta "Módulos /"

Paso 4: pegue el siguiente código dentro de ModulesServiceProvider.php

<?php
namespace App/Modules;
/**
* ServiceProvider
*
* The service provider for the modules. After being registered
* it will make sure that each of the modules are properly loaded
* i.e. with their routes, views etc.
*
* @author kundan Roy <[email protected]>
* @package App/Modules
*/
use Illuminate/Support/Facades/Route;
use Illuminate/Foundation/Support/Providers/RouteServiceProvider as ServiceProvider;
class ModulesServiceProvider extends ServiceProvider {
/**
* Will make sure that the required modules have been fully loaded
*
* @return void routeModule
*/
public function boot() {
// For each of the registered modules, include their routes and Views
$modules=config("module.modules");
while (list(,$module)=each($modules)) {
// Load the routes for each of the modules
if (file_exists(DIR.''/''.$module.''/routes.php'')) {
include DIR.''/''.$module.''/routes.php'';
}
if (is_dir(DIR.''/''.$module.''/Views'')) {
$this->loadViewsFrom(DIR.''/''.$module.''/Views'',$module);
}
}
}
public function register() { }
}

Paso 5: Agregue la siguiente línea dentro del archivo ''config / app.php''

App/Modules/ModulesServiceProvider::class,

Paso 6: Cree el archivo module.php dentro de la carpeta ''config''

Paso 7: Agregue el siguiente código dentro de module.php (ruta => “config / module.php”)

<?php
return [
''modules''=>[
''admin'',
''web'',
''api''
]
];

Nota: Puede agregar el nombre de su módulo cualquiera que haya creado. Aquí hay módulos.

Paso 8: ejecuta este comando

composer dump-autoload

Answer 4

También puedes usar pingpong-labs

documentaciones Here .

Aquí hay un ejemplo.

Simplemente puede instalar y verificar el proceso.

Nota: no estoy haciendo publicidad. Acabo de comprobar que cms construido en Laravel con soporte de módulo. Así que pensé que podría ser útil para usted y para otros.

Answer 5

Un poco tarde, pero si quieres usar módulos en tus proyectos futuros, he escrito un generador de módulos. Genera módulos a través de php artisan make:module name También puede colocar algunos módulos en la carpeta de la app/Modules y están listos para usar / trabajar. Echar un vistazo. Ahorre algo de tiempo;)

l5-modular

Answer 6

pingpong/modules es un paquete laravel que se creó para administrar su gran aplicación laravel usando módulos. El módulo es como un paquete laravel para una estructura fácil, tiene algunas vistas, controladores o modelos.

Funciona tanto en Laravel 4 como en Laravel 5.

Para instalar a través de Composer, simplemente ponga lo siguiente en su archivo composer.json :

{
"require": {
"pingpong/modules": "~2.1"
}
}

Y luego ejecute composer install para obtener el paquete.

Para crear un nuevo módulo, simplemente puede ejecutar:

php artisan module:make <module-name>

- Requerido Se creará el nombre del módulo. Crea un nuevo módulo

php artisan module:make Blog

Crea múltiples módulos

php artisan module:make Blog User Auth

para más visita: pingpong-labs