├── database
    ├── migrations
    │   ├── .gitkeep
    │   └── 2014_10_12_000000_create_users_table.php
    ├── seeds
    │   └── DatabaseSeeder.php
    └── factories
    │   └── ModelFactory.php
├── resources
    └── views
    │   └── .gitkeep
├── app
    ├── Console
    │   ├── Commands
    │   │   └── .gitkeep
    │   └── Kernel.php
    ├── Events
    │   ├── Event.php
    │   └── ExampleEvent.php
    ├── Http
    │   ├── Controllers
    │   │   ├── Controller.php
    │   │   ├── ExampleController.php
    │   │   ├── AuthorController.php
    │   │   ├── BookController.php
    │   │   └── UserController.php
    │   └── Middleware
    │   │   ├── ExampleMiddleware.php
    │   │   └── Authenticate.php
    ├── Providers
    │   ├── AppServiceProvider.php
    │   ├── EventServiceProvider.php
    │   └── AuthServiceProvider.php
    ├── Jobs
    │   ├── ExampleJob.php
    │   └── Job.php
    ├── Listeners
    │   └── ExampleListener.php
    ├── Traits
    │   ├── ConsumesExternalService.php
    │   └── ApiResponser.php
    ├── User.php
    ├── Services
    │   ├── BookService.php
    │   └── AuthorService.php
    └── Exceptions
    │   └── Handler.php
├── storage
    ├── app
    │   └── .gitignore
    ├── logs
    │   └── .gitignore
    └── framework
    │   ├── cache
    │       └── .gitignore
    │   └── views
    │       └── .gitignore
├── .gitignore
├── config
    ├── services.php
    └── auth.php
├── tests
    ├── TestCase.php
    └── ExampleTest.php
├── .env.example
├── public
    ├── .htaccess
    └── index.php
├── phpunit.xml
├── artisan
├── composer.json
├── readme.md
├── routes
    └── web.php
└── bootstrap
    └── app.php


/database/migrations/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/resources/views/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/app/Console/Commands/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/storage/app/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore
3 | 


--------------------------------------------------------------------------------
/storage/logs/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore
3 | 


--------------------------------------------------------------------------------
/storage/framework/cache/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore
3 | 


--------------------------------------------------------------------------------
/storage/framework/views/.gitignore:
--------------------------------------------------------------------------------
1 | *
2 | !.gitignore
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | /.idea
3 | Homestead.json
4 | Homestead.yaml
5 | .env
6 | database/database.sqlite
7 | *sublime*
8 | storage/*.key
9 | 


--------------------------------------------------------------------------------
/app/Events/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Events;
 4 | 
 5 | use Illuminate\Queue\SerializesModels;
 6 | 
 7 | abstract class Event
 8 | {
 9 |     use SerializesModels;
10 | }
11 | 


--------------------------------------------------------------------------------
/app/Http/Controllers/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Controllers;
 4 | 
 5 | use Laravel\Lumen\Routing\Controller as BaseController;
 6 | 
 7 | class Controller extends BaseController
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/app/Events/ExampleEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Events;
 4 | 
 5 | class ExampleEvent extends Event
 6 | {
 7 |     /**
 8 |      * Create a new event instance.
 9 |      *
10 |      * @return void
11 |      */
12 |     public function __construct()
13 |     {
14 |         //
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/database/seeds/DatabaseSeeder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Seeder;
 4 | 
 5 | class DatabaseSeeder extends Seeder
 6 | {
 7 |     /**
 8 |      * Run the database seeds.
 9 |      *
10 |      * @return void
11 |      */
12 |     public function run()
13 |     {
14 |         // $this->call('UsersTableSeeder');
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/config/services.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'authors' => [
 5 |         'base_uri' => env('AUTHORS_SERVICE_BASE_URL'),
 6 |         'secret' => env('AUTHORS_SERVICE_SECRET'),
 7 |     ],
 8 | 
 9 |     'books' => [
10 |         'base_uri' => env('BOOKS_SERVICE_BASE_URL'),
11 |         'secret' => env('BOOKS_SERVICE_SECRET'),
12 |     ],
13 | ];
14 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | abstract class TestCase extends Laravel\Lumen\Testing\TestCase
 4 | {
 5 |     /**
 6 |      * Creates the application.
 7 |      *
 8 |      * @return \Laravel\Lumen\Application
 9 |      */
10 |     public function createApplication()
11 |     {
12 |         return require __DIR__.'/../bootstrap/app.php';
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/app/Http/Controllers/ExampleController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Controllers;
 4 | 
 5 | class ExampleController extends Controller
 6 | {
 7 |     /**
 8 |      * Create a new controller instance.
 9 |      *
10 |      * @return void
11 |      */
12 |     public function __construct()
13 |     {
14 |         //
15 |     }
16 | 
17 |     //
18 | }
19 | 


--------------------------------------------------------------------------------
/app/Providers/AppServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Providers;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | 
 7 | class AppServiceProvider extends ServiceProvider
 8 | {
 9 |     /**
10 |      * Register any application services.
11 |      *
12 |      * @return void
13 |      */
14 |     public function register()
15 |     {
16 |         //
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/app/Jobs/ExampleJob.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Jobs;
 4 | 
 5 | class ExampleJob extends Job
 6 | {
 7 |     /**
 8 |      * Create a new job instance.
 9 |      *
10 |      * @return void
11 |      */
12 |     public function __construct()
13 |     {
14 |         //
15 |     }
16 | 
17 |     /**
18 |      * Execute the job.
19 |      *
20 |      * @return void
21 |      */
22 |     public function handle()
23 |     {
24 |         //
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/app/Http/Middleware/ExampleMiddleware.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Middleware;
 4 | 
 5 | use Closure;
 6 | 
 7 | class ExampleMiddleware
 8 | {
 9 |     /**
10 |      * Handle an incoming request.
11 |      *
12 |      * @param  \Illuminate\Http\Request  $request
13 |      * @param  \Closure  $next
14 |      * @return mixed
15 |      */
16 |     public function handle($request, Closure $next)
17 |     {
18 |         return $next($request);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
 1 | APP_ENV=local
 2 | APP_DEBUG=true
 3 | APP_KEY=
 4 | APP_TIMEZONE=UTC
 5 | 
 6 | LOG_CHANNEL=stack
 7 | LOG_SLACK_WEBHOOK_URL=
 8 | 
 9 | DB_CONNECTION=sqlite
10 | #DB_HOST=127.0.0.1
11 | #DB_PORT=3306
12 | #DB_DATABASE=homestead
13 | #DB_USERNAME=homestead
14 | #DB_PASSWORD=secret
15 | 
16 | CACHE_DRIVER=file
17 | QUEUE_DRIVER=sync
18 | 
19 | AUTHORS_SERVICE_BASE_URL=localhost:8000
20 | AUTHORS_SERVICE_SECRET=
21 | BOOKS_SERVICE_BASE_URL=localhost:8001
22 | BOOKS_SERVICE_SECRET=
23 | 


--------------------------------------------------------------------------------
/app/Providers/EventServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Providers;
 4 | 
 5 | use Laravel\Lumen\Providers\EventServiceProvider as ServiceProvider;
 6 | 
 7 | class EventServiceProvider extends ServiceProvider
 8 | {
 9 |     /**
10 |      * The event listener mappings for the application.
11 |      *
12 |      * @var array
13 |      */
14 |     protected $listen = [
15 |         'App\Events\ExampleEvent' => [
16 |             'App\Listeners\ExampleListener',
17 |         ],
18 |     ];
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/ExampleTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Laravel\Lumen\Testing\DatabaseMigrations;
 4 | use Laravel\Lumen\Testing\DatabaseTransactions;
 5 | 
 6 | class ExampleTest extends TestCase
 7 | {
 8 |     /**
 9 |      * A basic test example.
10 |      *
11 |      * @return void
12 |      */
13 |     public function testExample()
14 |     {
15 |         $this->get('/');
16 | 
17 |         $this->assertEquals(
18 |             $this->app->version(), $this->response->getContent()
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/app/Listeners/ExampleListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Listeners;
 4 | 
 5 | use App\Events\ExampleEvent;
 6 | use Illuminate\Queue\InteractsWithQueue;
 7 | use Illuminate\Contracts\Queue\ShouldQueue;
 8 | 
 9 | class ExampleListener
10 | {
11 |     /**
12 |      * Create the event listener.
13 |      *
14 |      * @return void
15 |      */
16 |     public function __construct()
17 |     {
18 |         //
19 |     }
20 | 
21 |     /**
22 |      * Handle the event.
23 |      *
24 |      * @param  ExampleEvent  $event
25 |      * @return void
26 |      */
27 |     public function handle(ExampleEvent $event)
28 |     {
29 |         //
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/database/factories/ModelFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Model Factories
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | Here you may define all of your model factories. Model factories give
 9 | | you a convenient way to create models for testing and seeding your
10 | | database. Just tell the factory how a default model should look.
11 | |
12 | */
13 | 
14 | $factory->define(App\User::class, function (Faker\Generator $faker) {
15 |     return [
16 |         'name' => $faker->name,
17 |         'email' => $faker->email,
18 |     ];
19 | });
20 | 


--------------------------------------------------------------------------------
/app/Console/Kernel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Console;
 4 | 
 5 | use Illuminate\Console\Scheduling\Schedule;
 6 | use Laravel\Lumen\Console\Kernel as ConsoleKernel;
 7 | 
 8 | class Kernel extends ConsoleKernel
 9 | {
10 |     /**
11 |      * The Artisan commands provided by your application.
12 |      *
13 |      * @var array
14 |      */
15 |     protected $commands = [
16 |         //
17 |     ];
18 | 
19 |     /**
20 |      * Define the application's command schedule.
21 |      *
22 |      * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
23 |      * @return void
24 |      */
25 |     protected function schedule(Schedule $schedule)
26 |     {
27 |         //
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/public/.htaccess:
--------------------------------------------------------------------------------
 1 | <IfModule mod_rewrite.c>
 2 |     <IfModule mod_negotiation.c>
 3 |         Options -MultiViews -Indexes
 4 |     </IfModule>
 5 | 
 6 |     RewriteEngine On
 7 | 
 8 |     # Handle Authorization Header
 9 |     RewriteCond %{HTTP:Authorization} .
10 |     RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
11 | 
12 |     # Redirect Trailing Slashes If Not A Folder...
13 |     RewriteCond %{REQUEST_FILENAME} !-d
14 |     RewriteCond %{REQUEST_URI} (.+)/$
15 |     RewriteRule ^ %1 [L,R=301]
16 | 
17 |     # Handle Front Controller...
18 |     RewriteCond %{REQUEST_FILENAME} !-d
19 |     RewriteCond %{REQUEST_FILENAME} !-f
20 |     RewriteRule ^ index.php [L]
21 | </IfModule>
22 | 


--------------------------------------------------------------------------------
/app/Traits/ConsumesExternalService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Traits;
 4 | 
 5 | use GuzzleHttp\Client;
 6 | 
 7 | trait ConsumesExternalService
 8 | {
 9 |     /**
10 |      * Send a request to any service
11 |      * @return string
12 |      */
13 |     public function performRequest($method, $requestUrl, $formParams = [], $headers = [])
14 |     {
15 |         $client = new Client([
16 |             'base_uri' => $this->baseUri,
17 |         ]);
18 | 
19 |         if (isset($this->secret)) {
20 |             $headers['Authorization'] = $this->secret;
21 |         }
22 | 
23 |         $response = $client->request($method, $requestUrl, ['form_params' => $formParams, 'headers' => $headers]);
24 | 
25 |         return $response->getBody()->getContents();
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/app/Jobs/Job.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Jobs;
 4 | 
 5 | use Illuminate\Bus\Queueable;
 6 | use Illuminate\Queue\SerializesModels;
 7 | use Illuminate\Queue\InteractsWithQueue;
 8 | use Illuminate\Contracts\Queue\ShouldQueue;
 9 | 
10 | abstract class Job implements ShouldQueue
11 | {
12 |     /*
13 |     |--------------------------------------------------------------------------
14 |     | Queueable Jobs
15 |     |--------------------------------------------------------------------------
16 |     |
17 |     | This job base class provides a central location to place any logic that
18 |     | is shared across all of your jobs. The trait included with the class
19 |     | provides access to the "queueOn" and "delay" queue helper methods.
20 |     |
21 |     */
22 | 
23 |     use InteractsWithQueue, Queueable, SerializesModels;
24 | }
25 | 


--------------------------------------------------------------------------------
/database/migrations/2014_10_12_000000_create_users_table.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateUsersTable extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('users', function (Blueprint $table) {
17 |             $table->bigIncrements('id');
18 |             $table->string('name');
19 |             $table->string('email')->unique();
20 |             $table->string('password');
21 |             $table->timestamps();
22 |         });
23 |     }
24 | 
25 |     /**
26 |      * Reverse the migrations.
27 |      *
28 |      * @return void
29 |      */
30 |     public function down()
31 |     {
32 |         Schema::dropIfExists('users');
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/app/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App;
 4 | 
 5 | use Illuminate\Auth\Authenticatable;
 6 | use Illuminate\Contracts\Auth\Access\Authorizable as AuthorizableContract;
 7 | use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
 8 | use Illuminate\Database\Eloquent\Model;
 9 | use Laravel\Lumen\Auth\Authorizable;
10 | use Laravel\Passport\HasApiTokens;
11 | 
12 | class User extends Model implements AuthenticatableContract, AuthorizableContract
13 | {
14 |     use Authenticatable, Authorizable, HasApiTokens;
15 | 
16 |     /**
17 |      * The attributes that are mass assignable.
18 |      *
19 |      * @var array
20 |      */
21 |     protected $fillable = [
22 |         'name', 'email', 'password',
23 |     ];
24 | 
25 |     /**
26 |      * The attributes excluded from the model's JSON form.
27 |      *
28 |      * @var array
29 |      */
30 |     protected $hidden = [
31 |         'password',
32 |     ];
33 | }
34 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="bootstrap/app.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false">
11 |     <testsuites>
12 |         <testsuite name="Application Test Suite">
13 |             <directory suffix="Test.php">./tests</directory>
14 |         </testsuite>
15 |     </testsuites>
16 |     <filter>
17 |         <whitelist processUncoveredFilesFromWhitelist="true">
18 |             <directory suffix=".php">./app</directory>
19 |         </whitelist>
20 |     </filter>
21 |     <php>
22 |         <env name="APP_ENV" value="testing"/>
23 |         <env name="CACHE_DRIVER" value="array"/>
24 |         <env name="QUEUE_DRIVER" value="sync"/>
25 |     </php>
26 | </phpunit>
27 | 


--------------------------------------------------------------------------------
/public/index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Create The Application
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | First we need to get an application instance. This creates an instance
 9 | | of the application / container and bootstraps the application so it
10 | | is ready to receive HTTP / Console requests from the environment.
11 | |
12 | */
13 | 
14 | $app = require __DIR__.'/../bootstrap/app.php';
15 | 
16 | /*
17 | |--------------------------------------------------------------------------
18 | | Run The Application
19 | |--------------------------------------------------------------------------
20 | |
21 | | Once we have the application, we can handle the incoming request
22 | | through the kernel, and send the associated response back to
23 | | the client's browser allowing them to enjoy the creative
24 | | and wonderful application we have prepared for them.
25 | |
26 | */
27 | 
28 | $app->run();
29 | 


--------------------------------------------------------------------------------
/app/Http/Middleware/Authenticate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Middleware;
 4 | 
 5 | use Closure;
 6 | use Illuminate\Contracts\Auth\Factory as Auth;
 7 | 
 8 | class Authenticate
 9 | {
10 |     /**
11 |      * The authentication guard factory instance.
12 |      *
13 |      * @var \Illuminate\Contracts\Auth\Factory
14 |      */
15 |     protected $auth;
16 | 
17 |     /**
18 |      * Create a new middleware instance.
19 |      *
20 |      * @param  \Illuminate\Contracts\Auth\Factory  $auth
21 |      * @return void
22 |      */
23 |     public function __construct(Auth $auth)
24 |     {
25 |         $this->auth = $auth;
26 |     }
27 | 
28 |     /**
29 |      * Handle an incoming request.
30 |      *
31 |      * @param  \Illuminate\Http\Request  $request
32 |      * @param  \Closure  $next
33 |      * @param  string|null  $guard
34 |      * @return mixed
35 |      */
36 |     public function handle($request, Closure $next, $guard = null)
37 |     {
38 |         if ($this->auth->guard($guard)->guest()) {
39 |             return response('Unauthorized.', 401);
40 |         }
41 | 
42 |         return $next($request);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/artisan:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | 
 4 | use Symfony\Component\Console\Input\ArgvInput;
 5 | use Symfony\Component\Console\Output\ConsoleOutput;
 6 | 
 7 | /*
 8 | |--------------------------------------------------------------------------
 9 | | Create The Application
10 | |--------------------------------------------------------------------------
11 | |
12 | | First we need to get an application instance. This creates an instance
13 | | of the application / container and bootstraps the application so it
14 | | is ready to receive HTTP / Console requests from the environment.
15 | |
16 | */
17 | 
18 | $app = require __DIR__.'/bootstrap/app.php';
19 | 
20 | /*
21 | |--------------------------------------------------------------------------
22 | | Run The Artisan Application
23 | |--------------------------------------------------------------------------
24 | |
25 | | When we run the console application, the current CLI command will be
26 | | executed in this console and the response sent back to a terminal
27 | | or another output device for the developers. Here goes nothing!
28 | |
29 | */
30 | 
31 | $kernel = $app->make(
32 |     'Illuminate\Contracts\Console\Kernel'
33 | );
34 | 
35 | exit($kernel->handle(new ArgvInput, new ConsoleOutput));
36 | 


--------------------------------------------------------------------------------
/app/Providers/AuthServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Providers;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | use Dusterio\LumenPassport\LumenPassport;
 7 | 
 8 | class AuthServiceProvider extends ServiceProvider
 9 | {
10 |     /**
11 |      * Register any application services.
12 |      *
13 |      * @return void
14 |      */
15 |     public function register()
16 |     {
17 |         //
18 |     }
19 | 
20 |     /**
21 |      * Boot the authentication services for the application.
22 |      *
23 |      * @return void
24 |      */
25 |     public function boot()
26 |     {
27 |         // Here you may define how you wish users to be authenticated for your Lumen
28 |         // application. The callback which receives the incoming request instance
29 |         // should return either a User instance or null. You're free to obtain
30 |         // the User instance via an API token or any other method necessary.
31 | 
32 |         /*$this->app['auth']->viaRequest('api', function ($request) {
33 |             if ($request->input('api_token')) {
34 |                 return User::where('api_token', $request->input('api_token'))->first();
35 |             }
36 |         });*/
37 | 
38 |         LumenPassport::routes($this->app->router);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "laravel/lumen",
 3 |     "description": "The Laravel Lumen Framework.",
 4 |     "keywords": ["framework", "laravel", "lumen"],
 5 |     "license": "MIT",
 6 |     "type": "project",
 7 |     "require": {
 8 |         "php": ">=7.1.3",
 9 |         "dusterio/lumen-passport": "^0.2.8",
10 |         "guzzlehttp/guzzle": "^6.3",
11 |         "laravel/lumen-framework": "5.7.*",
12 |         "vlucas/phpdotenv": "~2.2"
13 |     },
14 |     "require-dev": {
15 |         "fzaninotto/faker": "~1.4",
16 |         "phpunit/phpunit": "~7.0",
17 |         "mockery/mockery": "~1.0"
18 |     },
19 |     "autoload": {
20 |         "classmap": [
21 |             "database/seeds",
22 |             "database/factories"
23 |         ],
24 |         "psr-4": {
25 |             "App\\": "app/"
26 |         }
27 |     },
28 |     "autoload-dev": {
29 |         "classmap": [
30 |             "tests/"
31 |         ]
32 |     },
33 |     "scripts": {
34 |         "post-root-package-install": [
35 |             "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
36 |         ]
37 |     },
38 |     "config": {
39 |         "preferred-install": "dist",
40 |         "sort-packages": true,
41 |         "optimize-autoloader": true
42 |     },
43 |     "minimum-stability": "dev",
44 |     "prefer-stable": true
45 | }
46 | 


--------------------------------------------------------------------------------
/app/Traits/ApiResponser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Traits;
 4 | 
 5 | use Illuminate\Http\Response;
 6 | 
 7 | trait ApiResponser
 8 | {
 9 |     /**
10 |      * Build a success response
11 |      * @param  string|array $data
12 |      * @param  int $code
13 |      * @return Illuminate\Http\Response
14 |      */
15 |     public function successResponse($data, $code = Response::HTTP_OK)
16 |     {
17 |         return response($data, $code)->header('Content-Type', 'application/json');
18 |     }
19 | 
20 |     /**
21 |      * Build a valid response
22 |      * @param  string|array $data
23 |      * @param  int $code
24 |      * @return Illuminate\Http\JsonResponse
25 |      */
26 |     public function validResponse($data, $code = Response::HTTP_OK)
27 |     {
28 |         return response()->json(['data' => $data], $code);
29 |     }
30 | 
31 |     /**
32 |      * Build error responses
33 |      * @param  string $message
34 |      * @param  int $code
35 |      * @return Illuminate\Http\JsonResponse
36 |      */
37 |     public function errorResponse($message, $code)
38 |     {
39 |         return response()->json(['error' => $message, 'code' => $code], $code);
40 |     }
41 | 
42 |     /**
43 |      * Return an error in JSON format
44 |      * @param  string $message
45 |      * @param  int $code
46 |      * @return Illuminate\Http\Response
47 |      */
48 |     public function errorMessage($message, $code)
49 |     {
50 |         return response($message, $code)->header('Content-Type', 'application/json');
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Lumen PHP Framework
 2 | 
 3 | [![Build Status](https://travis-ci.org/laravel/lumen-framework.svg)](https://travis-ci.org/laravel/lumen-framework)
 4 | [![Total Downloads](https://poser.pugx.org/laravel/lumen-framework/d/total.svg)](https://packagist.org/packages/laravel/lumen-framework)
 5 | [![Latest Stable Version](https://poser.pugx.org/laravel/lumen-framework/v/stable.svg)](https://packagist.org/packages/laravel/lumen-framework)
 6 | [![Latest Unstable Version](https://poser.pugx.org/laravel/lumen-framework/v/unstable.svg)](https://packagist.org/packages/laravel/lumen-framework)
 7 | [![License](https://poser.pugx.org/laravel/lumen-framework/license.svg)](https://packagist.org/packages/laravel/lumen-framework)
 8 | 
 9 | Laravel Lumen is a stunningly fast PHP micro-framework for building web applications with expressive, elegant syntax. We believe development must be an enjoyable, creative experience to be truly fulfilling. Lumen attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as routing, database abstraction, queueing, and caching.
10 | 
11 | ## Official Documentation
12 | 
13 | Documentation for the framework can be found on the [Lumen website](http://lumen.laravel.com/docs).
14 | 
15 | ## Security Vulnerabilities
16 | 
17 | If you discover a security vulnerability within Lumen, please send an e-mail to Taylor Otwell at taylor@laravel.com. All security vulnerabilities will be promptly addressed.
18 | 
19 | ## License
20 | 
21 | The Lumen framework is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)
22 | 


--------------------------------------------------------------------------------
/app/Services/BookService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Services;
 4 | 
 5 | use App\Traits\ConsumesExternalService;
 6 | 
 7 | class BookService
 8 | {
 9 |     use ConsumesExternalService;
10 | 
11 |     /**
12 |      * The base uri to be used to consume the books service
13 |      * @var string
14 |      */
15 |     public $baseUri;
16 | 
17 |     /**
18 |      * The secret to be used to consume the books service
19 |      * @var string
20 |      */
21 |     public $secret;
22 | 
23 |     public function __construct()
24 |     {
25 |         $this->baseUri = config('services.books.base_uri');
26 |         $this->secret = config('services.books.secret');
27 |     }
28 | 
29 |     /**
30 |      * Get the full list of books from the books service
31 |      * @return string
32 |      */
33 |     public function obtainBooks()
34 |     {
35 |         return $this->performRequest('GET', '/books');
36 |     }
37 | 
38 |     /**
39 |      * Create an instance of book using the books service
40 |      * @return string
41 |      */
42 |     public function createBook($data)
43 |     {
44 |         return $this->performRequest('POST', '/books', $data);
45 |     }
46 | 
47 |     /**
48 |      * Get a single book from the books service
49 |      * @return string
50 |      */
51 |     public function obtainBook($book)
52 |     {
53 |         return $this->performRequest('GET', "/books/{$book}");
54 |     }
55 | 
56 |     /**
57 |      * Edit a single book from the books service
58 |      * @return string
59 |      */
60 |     public function editBook($data, $book)
61 |     {
62 |         return $this->performRequest('PUT', "/books/{$book}", $data);
63 |     }
64 | 
65 |     /**
66 |      * Remove a single book from the books service
67 |      * @return string
68 |      */
69 |     public function deleteBook($book)
70 |     {
71 |         return $this->performRequest('DELETE', "/books/{$book}");
72 |     }
73 | 
74 | }
75 | 


--------------------------------------------------------------------------------
/app/Services/AuthorService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Services;
 4 | 
 5 | use App\Traits\ConsumesExternalService;
 6 | 
 7 | class AuthorService
 8 | {
 9 |     use ConsumesExternalService;
10 | 
11 |     /**
12 |      * The base uri to be used to consume the authors service
13 |      * @var string
14 |      */
15 |     public $baseUri;
16 | 
17 |     /**
18 |      * The secret to be used to consume the authors service
19 |      * @var string
20 |      */
21 |     public $secret;
22 | 
23 |     public function __construct()
24 |     {
25 |         $this->baseUri = config('services.authors.base_uri');
26 |         $this->secret = config('services.authors.secret');
27 |     }
28 | 
29 |     /**
30 |      * Get the full list of authors from the authors service
31 |      * @return string
32 |      */
33 |     public function obtainAuthors()
34 |     {
35 |         return $this->performRequest('GET', '/authors');
36 |     }
37 | 
38 |     /**
39 |      * Create an instance of author using the authors service
40 |      * @return string
41 |      */
42 |     public function createAuthor($data)
43 |     {
44 |         return $this->performRequest('POST', '/authors', $data);
45 |     }
46 | 
47 |     /**
48 |      * Get a single author from the authors service
49 |      * @return string
50 |      */
51 |     public function obtainAuthor($author)
52 |     {
53 |         return $this->performRequest('GET', "/authors/{$author}");
54 |     }
55 | 
56 |     /**
57 |      * Edit a single author from the authors service
58 |      * @return string
59 |      */
60 |     public function editAuthor($data, $author)
61 |     {
62 |         return $this->performRequest('PUT', "/authors/{$author}", $data);
63 |     }
64 | 
65 |     /**
66 |      * Remove a single author from the authors service
67 |      * @return string
68 |      */
69 |     public function deleteAuthor($author)
70 |     {
71 |         return $this->performRequest('DELETE', "/authors/{$author}");
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/routes/web.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | |--------------------------------------------------------------------------
 5 | | Application Routes
 6 | |--------------------------------------------------------------------------
 7 | |
 8 | | Here is where you can register all of the routes for an application.
 9 | | It is a breeze. Simply tell Lumen the URIs it should respond to
10 | | and give it the Closure to call when that URI is requested.
11 | |
12 | */
13 | 
14 | $router->group(['middleware' => 'client.credentials'], function () use ($router) {
15 |     /**
16 |      * Authors routes
17 |      */
18 |     $router->get('/authors', 'AuthorController@index');
19 |     $router->post('/authors', 'AuthorController@store');
20 |     $router->get('/authors/{author}', 'AuthorController@show');
21 |     $router->put('/authors/{author}', 'AuthorController@update');
22 |     $router->patch('/authors/{author}', 'AuthorController@update');
23 |     $router->delete('/authors/{author}', 'AuthorController@destroy');
24 | 
25 |     /**
26 |      * Books routes
27 |      */
28 |     $router->get('/books', 'BookController@index');
29 |     $router->post('/books', 'BookController@store');
30 |     $router->get('/books/{book}', 'BookController@show');
31 |     $router->put('/books/{book}', 'BookController@update');
32 |     $router->patch('/books/{book}', 'BookController@update');
33 |     $router->delete('/books/{book}', 'BookController@destroy');
34 | 
35 |     /**
36 |      * Users routes
37 |      */
38 |     $router->get('/users', 'UserController@index');
39 |     $router->post('/users', 'UserController@store');
40 |     $router->get('/users/{user}', 'UserController@show');
41 |     $router->put('/users/{user}', 'UserController@update');
42 |     $router->patch('/users/{user}', 'UserController@update');
43 |     $router->delete('/users/{user}', 'UserController@destroy');
44 | });
45 | 
46 | /**
47 |  * Routes protected by user credentials
48 |  */
49 | $router->group(['middleware' => 'auth:api'], function () use ($router) {
50 |     $router->get('/users/me', 'UserController@me');
51 | });
52 | 


--------------------------------------------------------------------------------
/app/Http/Controllers/AuthorController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Controllers;
 4 | 
 5 | use App\Traits\ApiResponser;
 6 | use Illuminate\Http\Request;
 7 | use Illuminate\Http\Response;
 8 | use App\Services\AuthorService;
 9 | 
10 | class AuthorController extends Controller
11 | {
12 |     use ApiResponser;
13 | 
14 |     /**
15 |      * The service to consume the author service
16 |      * @var AuthorService
17 |      */
18 |     public $authorService;
19 | 
20 |     /**
21 |      * Create a new controller instance.
22 |      *
23 |      * @return void
24 |      */
25 |     public function __construct(AuthorService $authorService)
26 |     {
27 |         $this->authorService = $authorService;
28 |     }
29 | 
30 |     /**
31 |      * Retrieve and show all the authors
32 |      * @return Illuminate\Http\Response
33 |      */
34 |     public function index()
35 |     {
36 |         return $this->successResponse($this->authorService->obtainAuthors());
37 |     }
38 | 
39 |     /**
40 |      * Creates an instance of author
41 |      * @return Illuminate\Http\Response
42 |      */
43 |     public function store(Request $request)
44 |     {
45 |         return $this->successResponse($this->authorService->createAuthor($request->all()), Response::HTTP_CREATED);
46 |     }
47 | 
48 |     /**
49 |      * Obtain and show an instance of author
50 |      * @return Illuminate\Http\Response
51 |      */
52 |     public function show($author)
53 |     {
54 |         return $this->successResponse($this->authorService->obtainAuthor($author));
55 |     }
56 | 
57 |     /**
58 |      * Updated an instance of author
59 |      * @return Illuminate\Http\Response
60 |      */
61 |     public function update(Request $request, $author)
62 |     {
63 |         return $this->successResponse($this->authorService->editAuthor($request->all(), $author));
64 |     }
65 | 
66 |     /**
67 |      * Removes an instance of author
68 |      * @return Illuminate\Http\Response
69 |      */
70 |     public function destroy($author)
71 |     {
72 |         return $this->successResponse($this->authorService->deleteAuthor($author));
73 |     }
74 | 
75 | }
76 | 


--------------------------------------------------------------------------------
/app/Http/Controllers/BookController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Http\Controllers;
 4 | 
 5 | use App\Traits\ApiResponser;
 6 | use Illuminate\Http\Request;
 7 | use App\Services\BookService;
 8 | use Illuminate\Http\Response;
 9 | use App\Services\AuthorService;
10 | 
11 | class BookController extends Controller
12 | {
13 |     use ApiResponser;
14 | 
15 |     /**
16 |      * The service to consume the book service
17 |      * @var BookService
18 |      */
19 |     public $bookService;
20 | 
21 |     /**
22 |      * The service to consume the author service
23 |      * @var AuthorService
24 |      */
25 |     public $authorService;
26 | 
27 |     /**
28 |      * Create a new controller instance.
29 |      *
30 |      * @return void
31 |      */
32 |     public function __construct(BookService $bookService, AuthorService $authorService)
33 |     {
34 |         $this->bookService = $bookService;
35 |         $this->authorService = $authorService;
36 |     }
37 | 
38 |     /**
39 |      * Retrieve and show all the Books
40 |      * @return Illuminate\Http\Response
41 |      */
42 |     public function index()
43 |     {
44 |         return $this->successResponse($this->bookService->obtainBooks());
45 |     }
46 | 
47 |     /**
48 |      * Creates an instance of Book
49 |      * @return Illuminate\Http\Response
50 |      */
51 |     public function store(Request $request)
52 |     {
53 |         $this->authorService->obtainAuthor($request->author_id);
54 | 
55 |         return $this->successResponse($this->bookService->createBook($request->all()), Response::HTTP_CREATED);
56 |     }
57 | 
58 |     /**
59 |      * Obtain and show an instance of Book
60 |      * @return Illuminate\Http\Response
61 |      */
62 |     public function show($book)
63 |     {
64 |         return $this->successResponse($this->bookService->obtainBook($book));
65 |     }
66 | 
67 |     /**
68 |      * Updated an instance of Book
69 |      * @return Illuminate\Http\Response
70 |      */
71 |     public function update(Request $request, $book)
72 |     {
73 |         return $this->successResponse($this->bookService->editBook($request->all(), $book));
74 |     }
75 | 
76 |     /**
77 |      * Removes an instance of Book
78 |      * @return Illuminate\Http\Response
79 |      */
80 |     public function destroy($book)
81 |     {
82 |         return $this->successResponse($this->bookService->deleteBook($book));
83 |     }
84 | 
85 | }
86 | 


--------------------------------------------------------------------------------
/app/Exceptions/Handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace App\Exceptions;
 4 | 
 5 | use Exception;
 6 | use App\Traits\ApiResponser;
 7 | use Illuminate\Http\Response;
 8 | use GuzzleHttp\Exception\ClientException;
 9 | use Illuminate\Auth\AuthenticationException;
10 | use Illuminate\Validation\ValidationException;
11 | use Illuminate\Auth\Access\AuthorizationException;
12 | use Illuminate\Database\Eloquent\ModelNotFoundException;
13 | use Laravel\Lumen\Exceptions\Handler as ExceptionHandler;
14 | use Symfony\Component\HttpKernel\Exception\HttpException;
15 | 
16 | class Handler extends ExceptionHandler
17 | {
18 |     use ApiResponser;
19 | 
20 |     /**
21 |      * A list of the exception types that should not be reported.
22 |      *
23 |      * @var array
24 |      */
25 |     protected $dontReport = [
26 |         AuthorizationException::class,
27 |         HttpException::class,
28 |         ModelNotFoundException::class,
29 |         ValidationException::class,
30 |     ];
31 | 
32 |     /**
33 |      * Report or log an exception.
34 |      *
35 |      * This is a great spot to send exceptions to Sentry, Bugsnag, etc.
36 |      *
37 |      * @param  \Exception  $exception
38 |      * @return void
39 |      */
40 |     public function report(Exception $exception)
41 |     {
42 |         parent::report($exception);
43 |     }
44 | 
45 |     /**
46 |      * Render an exception into an HTTP response.
47 |      *
48 |      * @param  \Illuminate\Http\Request  $request
49 |      * @param  \Exception  $exception
50 |      * @return \Illuminate\Http\Response
51 |      */
52 |     public function render($request, Exception $exception)
53 |     {
54 |         if ($exception instanceof HttpException) {
55 |             $code = $exception->getStatusCode();
56 |             $message = Response::$statusTexts[$code];
57 | 
58 |             return $this->errorResponse($message, $code);
59 |         }
60 | 
61 |         if ($exception instanceof ModelNotFoundException) {
62 |             $model = strtolower(class_basename($exception->getModel()));
63 | 
64 |             return $this->errorResponse("Does not exist any instance of {$model} with the given id", Response::HTTP_NOT_FOUND);
65 |         }
66 | 
67 |         if ($exception instanceof AuthorizationException) {
68 |             return $this->errorResponse($exception->getMessage(), Response::HTTP_FORBIDDEN);
69 |         }
70 | 
71 |         if ($exception instanceof AuthenticationException) {
72 |             return $this->errorResponse($exception->getMessage(), Response::HTTP_UNAUTHORIZED);
73 |         }
74 | 
75 |         if ($exception instanceof ValidationException) {
76 |             $errors = $exception->validator->errors()->getMessages();
77 | 
78 |             return $this->errorResponse($errors, Response::HTTP_UNPROCESSABLE_ENTITY);
79 |         }
80 | 
81 |         if ($exception instanceof ClientException) {
82 |             $message = $exception->getResponse()->getBody();
83 |             $code = $exception->getCode();
84 | 
85 |             return $this->errorMessage($message, $code);
86 |         }
87 | 
88 |         if (env('APP_DEBUG', false)) {
89 |             return parent::render($request, $exception);
90 |         }
91 | 
92 |         return $this->errorResponse('Unexpected error. Try later', Response::HTTP_INTERNAL_SERVER_ERROR);
93 | 
94 |     }
95 | }
96 | 


--------------------------------------------------------------------------------
/app/Http/Controllers/UserController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace App\Http\Controllers;
  4 | 
  5 | use App\Traits\ApiResponser;
  6 | use App\User;
  7 | use Illuminate\Http\Request;
  8 | use Illuminate\Http\Response;
  9 | use Illuminate\Support\Facades\Hash;
 10 | 
 11 | class UserController extends Controller
 12 | {
 13 |     use ApiResponser;
 14 | 
 15 |     /**
 16 |      * Create a new controller instance.
 17 |      *
 18 |      * @return void
 19 |      */
 20 |     public function __construct()
 21 |     {
 22 |         //
 23 |     }
 24 | 
 25 |     /**
 26 |      * Return users list
 27 |      * @return Illuminate\Http\Response
 28 |      */
 29 |     public function index()
 30 |     {
 31 |         $users = User::all();
 32 | 
 33 |         return $this->validResponse($users);
 34 |     }
 35 | 
 36 |     /**
 37 |      * Create an instance of User
 38 |      * @return Illuminate\Http\Response
 39 |      */
 40 |     public function store(Request $request)
 41 |     {
 42 |         $rules = [
 43 |             'name' => 'required|max:255',
 44 |             'email' => 'required|email|unique:users,email',
 45 |             'password' => 'required|min:8|confirmed',
 46 |         ];
 47 | 
 48 |         $this->validate($request, $rules);
 49 | 
 50 |         $fields = $request->all();
 51 |         $fields['password'] = Hash::make($request->password);
 52 | 
 53 |         $user = User::create($fields);
 54 | 
 55 |         return $this->validResponse($user, Response::HTTP_CREATED);
 56 |     }
 57 | 
 58 |     /**
 59 |      * Return an specific user
 60 |      * @return Illuminate\Http\Response
 61 |      */
 62 |     public function show($user)
 63 |     {
 64 |         $user = User::findOrFail($user);
 65 | 
 66 |         return $this->validResponse($user);
 67 |     }
 68 | 
 69 |     /**
 70 |      * Update the information of an existing user
 71 |      * @return Illuminate\Http\Response
 72 |      */
 73 |     public function update(Request $request, $user)
 74 |     {
 75 |         $rules = [
 76 |             'name' => 'max:255',
 77 |             'email' => 'email|unique:users,email,' . $user,
 78 |             'password' => 'min:8|confirmed',
 79 |         ];
 80 | 
 81 |         $this->validate($request, $rules);
 82 | 
 83 |         $user = User::findOrFail($user);
 84 | 
 85 |         $user->fill($request->all());
 86 | 
 87 |         if ($request->has('password')) {
 88 |             $user->password = Hash::make($request->password);
 89 |         }
 90 | 
 91 |         if ($user->isClean()) {
 92 |             return $this->errorResponse('At least one value must change', Response::HTTP_UNPROCESSABLE_ENTITY);
 93 |         }
 94 | 
 95 |         $user->save();
 96 | 
 97 |         return $this->validResponse($user);
 98 |     }
 99 | 
100 |     /**
101 |      * Removes an existing user
102 |      * @return Illuminate\Http\Response
103 |      */
104 |     public function destroy($user)
105 |     {
106 |         $user = User::findOrFail($user);
107 | 
108 |         $user->delete();
109 | 
110 |         return $this->validResponse($user);
111 |     }
112 | 
113 |     /**
114 |      * Identifies the curren user
115 |      * @return Illuminate\Http\Response
116 |      */
117 |     public function me(Request $request)
118 |     {
119 |         return $this->validResponse($request->user());
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/config/auth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Authentication Defaults
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | This option controls the default authentication "guard" and password
11 |     | reset options for your application. You may change these defaults
12 |     | as required, but they're a perfect start for most applications.
13 |     |
14 |     */
15 | 
16 |     'defaults' => [
17 |         'guard' => env('AUTH_GUARD', 'api'),
18 |     ],
19 | 
20 |     /*
21 |     |--------------------------------------------------------------------------
22 |     | Authentication Guards
23 |     |--------------------------------------------------------------------------
24 |     |
25 |     | Next, you may define every authentication guard for your application.
26 |     | Of course, a great default configuration has been defined for you
27 |     | here which uses session storage and the Eloquent user provider.
28 |     |
29 |     | All authentication drivers have a user provider. This defines how the
30 |     | users are actually retrieved out of your database or other storage
31 |     | mechanisms used by this application to persist your user's data.
32 |     |
33 |     | Supported: "token"
34 |     |
35 |     */
36 | 
37 |     'guards' => [
38 |         'api' => [
39 |             'driver' => 'passport',
40 |             'provider' => 'users',
41 |         ],
42 |     ],
43 | 
44 |     /*
45 |     |--------------------------------------------------------------------------
46 |     | User Providers
47 |     |--------------------------------------------------------------------------
48 |     |
49 |     | All authentication drivers have a user provider. This defines how the
50 |     | users are actually retrieved out of your database or other storage
51 |     | mechanisms used by this application to persist your user's data.
52 |     |
53 |     | If you have multiple user tables or models you may configure multiple
54 |     | sources which represent each model / table. These sources may then
55 |     | be assigned to any extra authentication guards you have defined.
56 |     |
57 |     | Supported: "database", "eloquent"
58 |     |
59 |     */
60 | 
61 |     'providers' => [
62 |         'users' => [
63 |             'driver' => 'eloquent',
64 |             'model' => App\User::class,
65 |         ],
66 |     ],
67 | 
68 |     /*
69 |     |--------------------------------------------------------------------------
70 |     | Resetting Passwords
71 |     |--------------------------------------------------------------------------
72 |     |
73 |     | Here you may set the options for resetting passwords including the view
74 |     | that is your password reset e-mail. You may also set the name of the
75 |     | table that maintains all of the reset tokens for your application.
76 |     |
77 |     | You may specify multiple password reset configurations if you have more
78 |     | than one user table or model in the application and you want to have
79 |     | separate password reset settings based on the specific user types.
80 |     |
81 |     | The expire time is the number of minutes that the reset token should be
82 |     | considered valid. This security feature keeps tokens short-lived so
83 |     | they have less time to be guessed. You may change this as needed.
84 |     |
85 |     */
86 | 
87 |     'passwords' => [
88 |         //
89 |     ],
90 | 
91 | ];
92 | 


--------------------------------------------------------------------------------
/bootstrap/app.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | require_once __DIR__ . '/../vendor/autoload.php';
  4 | 
  5 | try {
  6 |     (new Dotenv\Dotenv(__DIR__ . '/../'))->load();
  7 | } catch (Dotenv\Exception\InvalidPathException $e) {
  8 |     //
  9 | }
 10 | 
 11 | /*
 12 | |--------------------------------------------------------------------------
 13 | | Create The Application
 14 | |--------------------------------------------------------------------------
 15 | |
 16 | | Here we will load the environment and create the application instance
 17 | | that serves as the central piece of this framework. We'll use this
 18 | | application as an "IoC" container and router for this framework.
 19 | |
 20 | */
 21 | 
 22 | $app = new Laravel\Lumen\Application(
 23 |     realpath(__DIR__ . '/../')
 24 | );
 25 | 
 26 | $app->withFacades();
 27 | 
 28 | $app->withEloquent();
 29 | 
 30 | /**
 31 |  * Registering config files
 32 |  */
 33 | $app->configure('services');
 34 | $app->configure('auth');
 35 | 
 36 | /*
 37 | |--------------------------------------------------------------------------
 38 | | Register Container Bindings
 39 | |--------------------------------------------------------------------------
 40 | |
 41 | | Now we will register a few bindings in the service container. We will
 42 | | register the exception handler and the console kernel. You may add
 43 | | your own bindings here if you like or you can make another file.
 44 | |
 45 | */
 46 | 
 47 | $app->singleton(
 48 |     Illuminate\Contracts\Debug\ExceptionHandler::class,
 49 |     App\Exceptions\Handler::class
 50 | );
 51 | 
 52 | $app->singleton(
 53 |     Illuminate\Contracts\Console\Kernel::class,
 54 |     App\Console\Kernel::class
 55 | );
 56 | 
 57 | /*
 58 | |--------------------------------------------------------------------------
 59 | | Register Middleware
 60 | |--------------------------------------------------------------------------
 61 | |
 62 | | Next, we will register the middleware with the application. These can
 63 | | be global middleware that run before and after each request into a
 64 | | route or middleware that'll be assigned to some specific routes.
 65 | |
 66 | */
 67 | 
 68 | // $app->middleware([
 69 | //    App\Http\Middleware\ExampleMiddleware::class
 70 | // ]);
 71 | 
 72 | $app->routeMiddleware([
 73 |     'auth' => App\Http\Middleware\Authenticate::class,
 74 |     'client.credentials' => Laravel\Passport\Http\Middleware\CheckClientCredentials::class,
 75 | ]);
 76 | 
 77 | /*
 78 | |--------------------------------------------------------------------------
 79 | | Register Service Providers
 80 | |--------------------------------------------------------------------------
 81 | |
 82 | | Here we will register all of the application's service providers which
 83 | | are used to bind services into the container. Service providers are
 84 | | totally optional, so you are not required to uncomment this line.
 85 | |
 86 | */
 87 | 
 88 | // $app->register(App\Providers\EventServiceProvider::class);
 89 | // $app->register(App\Providers\AppServiceProvider::class);
 90 | $app->register(App\Providers\AuthServiceProvider::class);
 91 | $app->register(Laravel\Passport\PassportServiceProvider::class);
 92 | $app->register(Dusterio\LumenPassport\PassportServiceProvider::class);
 93 | 
 94 | /*
 95 | |--------------------------------------------------------------------------
 96 | | Load The Application Routes
 97 | |--------------------------------------------------------------------------
 98 | |
 99 | | Next we will include the routes file so that they can all be added to
100 | | the application. This will provide all of the URLs the application
101 | | can respond to, as well as the controllers that may handle them.
102 | |
103 | */
104 | 
105 | $app->router->group([
106 |     'namespace' => 'App\Http\Controllers',
107 | ], function ($router) {
108 |     require __DIR__ . '/../routes/web.php';
109 | });
110 | 
111 | return $app;
112 | 


--------------------------------------------------------------------------------