Download the PHP package larafast/fastapi without Composer

Larafast FastAPI

What does mean FastAPI:

A Fastapi Laravel package to help you generate CRUD API Controllers and Resources, Model.. etc

What actually do?

Suppose you are building an api, and you want to create controller and resources and model and factory.. etc, then you have to do a ton of other tedious and to be honest, boring things like creating migrations, model factories, the controller, form validation and adding all.

So what FastAPI does is when you tell it the model name, it will do all those boring things. When it's done you have the following:

• Blog.php
• BlogController.php ship with code already exists
• BlogStoreRequest.php and BlogUpdateRequest.php
• BlogResource.php
• Timestamped create_blogs_table.php migration file
• BlogFactory.php

Installation

composer require larafast/fastapi

Then publish the config

php artisan vendor:publish --tag=fastApi

For Lumen

Just Add this line into bootstrap/app.php

$app->register(Larafast\Fastapi\FastapiServiceProvider::class);

Example

php artisan fastApi Blog

Once done, it will show you the details of the files generated.

Factory created successfully

Created Migration: 2020_07_14_125128_create_blogs_table

Model created successfully

Controller created successfully

Request created successfully

Request created successfully

Resource created successfully

Snapshot of BlogController

namespace App\Http\Controllers;

use App\Blog;
use Illuminate\Http\Request;
use App\Http\Requests\BlogUpdateRequest;
use App\Http\Requests\BlogStoreRequest;
use App\Http\Resources\BlogResource;

class BlogController extends Controller
{
    function __construct()
    {
        // $this->middleware('permission:view_blogs', ['only' => ['index', 'show']]);
        // $this->middleware('permission:add_blogs',  ['only' => ['store']]);
        // $this->middleware('permission:edit_blogs', ['only' => ['update']]);
        // $this->middleware('permission:delete_blogs', ['only' => ['destroy']]);
    }

    public function index()
    {
        $rows = BlogResource::collection(Blog::filter());
        return response()->json([
            'rows'        => $rows,
            'paginate'    => $this->paginate($rows)
        ], 200);
    }

    public function store(BlogStoreRequest $request)
    {
        $row = Blog::createOrUpdate(NULL, request()->all());
        if($row === true) {
            return response()->json(['message' => ''], 201);
        } else {
            return response()->json(['message' => 'Unable to create entry ' . $row], 500);
        }
    }

    public function show($id)
    {
        $row = new BlogResource(Blog::findOrFail(decrypt($id)));
        return response()->json(['row' => $row], 200);
    }

    public function update(BlogUpdateRequest $request, $id)
    {
        $row = Blog::createOrUpdate(decrypt($id), request()->all());
        if($row === true) {
            return response()->json(['message' => ''], 200);
        } else {
            return response()->json(['message' => 'Unable to update entry ' . $row], 500);
        }
    }

    public function destroy($id)
    {
        try {
            $row = Blog::query();

            // can work with multi select
            if(strpos($id, ',') !== false) {
                foreach(explode(',',$id) as $sid) {
                    $ids[] = $sid;
                }
                $row->whereIN('id', $ids);
            } else {
                $row->where('id', $id);
            }   
            $row->delete();

            return response()->json(['message' => ''], 200);
        } catch (\Exception $e) {
            return response()->json(['message' => 'Unable to delete entry, '. $e->getMessage()], 500);
        }
    }
}

Snapshot of Blog Model

namespace App;

use DB;
use App\Image;
use Illuminate\Pipeline\Pipeline;
use Larafast\Fastapi\QueryFilters\Sort;
use Larafast\Fastapi\QueryFilters\Locale;
use Larafast\Fastapi\QueryFilters\Search;
use Illuminate\Support\Str;
use Illuminate\Database\Eloquent\Model;

class Blog extends Model
{
    protected $guarded = [];

    // imageable polymorphic
    public function image() {
        return $this->morphOne(Image::class, 'imageable');
    }

    // Filter
    public static function filter()
    {
        return app(Pipeline::class)
                ->send(self::query())
                ->through(
                [
                    Locale::class,
                    Search::class,
                    Sort::class
                ])
                ->thenReturn()
                ->paginate(request('paginate') ?? 10);
    }

    // Create or Update
    public static function createOrUpdate($id, $value)
    {
        try {

            // Begin Transaction
            DB::beginTransaction();

                // find Or New
                $row              = (isset($id)) ? self::find($id) : new self;
                $row->title       = $value['title'] ?? NULL;
                $row->body        = $value['body'] ?? NULL;
                $row->save();

                // Image
                if(isset($value['image'])) {
                    $row->image()->delete();
                    if($value['image']) {
                        if(!Str::contains($value['image'], [ Imageable::contains() ])) {
                            $image = Image::uploadImage($value['image']);
                        } else {
                            $image = explode('/', $value['image']);
                            $image = end($image);
                        }
                        $row->image()->create([ 'url' => $image ]);
                    }
                }

            DB::commit();
            // End Commit of Transaction

            return true;
        } catch (\Exception $e) {
            DB::rollback();
            return $e->getMessage();
        }
    }
}

Snapshot of Blog Resource

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class BlogResource extends JsonResource
{

    public function toArray($request)
    {
        return [
            'id'            => $this->id,
            'encrypt_id'    => encrypt($this->id),
            'image'         => ($this->image) ? $this->image->url : NULL,

            'title'         => $this->title,
            'body'          => $this->body,

            'dateForHumans' => $this->created_at->diffForHumans(),
            'timestamp'     => $this->created_at
        ];
    }
}

Now add the necessary fields and run

php artisan migrate

And that saved you an hour worth of repetitive and boring work which you can spend on more important development challenges.

Credits

• Mahmoud Italy
• All Contributors

License

The MIT License (MIT). Please see License File for more information.