BaseController::create() - Code Metrics - Inspection of "fix some change" - Alive2212/LaravelSmartRestful - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 7b42a8...29affb )

by Babak
created 2018-07-23 10:17 UTC
BaseController::create() A

↳ Parent: BaseController
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	4
nc	1
nop	0
dl	0
loc	9
rs	10
c	0
b	0
f	0
<?php

namespace Alive2212\LaravelSmartRestful;

use Alive2212\ExcelHelper\ExcelHelper;
use Alive2212\LaravelQueryHelper\QueryHelper;
filter:
    dependency_paths: ["lib/*"]
use Alive2212\LaravelRequestHelper\RequestHelper;
filter:
    dependency_paths: ["lib/*"]
use Alive2212\LaravelSmartResponse\ResponseModel;
use Alive2212\LaravelSmartResponse\SmartResponse\SmartResponse;
filter:
    dependency_paths: ["lib/*"]
use Alive2212\LaravelStringHelper\StringHelper;
filter:
    dependency_paths: ["lib/*"]
use App\Car;
filter:
    dependency_paths: ["lib/*"]
use App\Http\Controllers\Controller;
filter:
    dependency_paths: ["lib/*"]
use App\Location;
filter:
    dependency_paths: ["lib/*"]
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Illuminate\Database\QueryException;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\MessageBag;
use Illuminate\Support\Facades\Validator;


abstract class BaseController extends Controller
{
    /**
     * to use this class
     * create message list as messages in message file
     * override __constructor and define your model
     * define your rules for index,store and update
     */

    /**
     * permission types 'admin'|'branch'|'own'|'guest'
     *
     * @var string
     */
    protected $DEFAULT_PERMISSION_TYPE = 'admin';

    /**
     * @var string
     */
    protected $LOCALE_PREFIX = 'controller';

    /**
     * @var int
     */
    protected $DEFAULT_RESULT_PER_PAGE = 15;

    /**
     * @var int
     */
    protected $DEFAULT_PAGE_NUMBER = 1;

    /**
     * @var array
     */
    protected $pivotFields = [];

    /**
     * @var array
     */
    protected $uniqueFields = [];

    /**
     * @var bool|string
     */
    protected $modelName;

    /**
     * @var string
     */
    protected $messagePrefix = 'messages.api.v1.';

    /**
     * this model
     */
    protected $model;

    /**
     * index request validator rules
     *
     * @var array
     */
    protected $indexValidateArray = [
        //
    ];

    /**
     * array of relationship for eager loading
     *
     * @var array
     */
    protected $indexLoad = [
        //
    ];

    /**
     * array of relationship for eager loading
     *
     * @var array
     */
    protected $editLoad = [
        //
    ];

    /**
     * array of relationship for eager loading
     *
     * @var array
     */
    protected $updateLoad = [
        //
    ];

    /**
     * array of relationship for eager loading
     *
     * @var array
     */
    protected $storeLoad = [
        //
    ];

    /**
     * store request validator rules
     *
     * @var array
     */
    protected $storeValidateArray = [
        //
    ];

    /**
     * update request validator rules
     *
     * @var array
     */
    protected $updateValidateArray = [
        //
    ];

    protected $middlewareParams = [];

    /**
     * defaultController constructor.
     */
    public function __construct()
    {
//        dd("I have closest relationship with all US & UK celebrities");
        // init controller
        $this->initController();

        // set local language
        $this->setLocale();
    }

    abstract public function initController();

    /**
     * Display a listing of the resource.
     *
     * @param Request $request
     * @return string
     */
    public function index(Request $request)
    {
        // handle permission
        $request = $this->handlePermission($request, __FUNCTION__);

        // create response model
        $response = new ResponseModel();

        $pageSize = $this->DEFAULT_RESULT_PER_PAGE;


        $pageNumber = 1;

        //set default pagination

        //set page size
        if (!isset($request->toArray()['page']['size'])) {
            $pageSize = $this->DEFAULT_RESULT_PER_PAGE;
        } elseif (($request->get('page')['size']) == 0) {
            $pageSize = $this->DEFAULT_RESULT_PER_PAGE;
        } else {
            $pageSize = $request->get('page')['size'];
        }

        //set page number
        if (!isset($request->get('page')['number'])) {
            $pageNumber = $this->DEFAULT_PAGE_NUMBER;
        } elseif (($request->get('page')['number']) == 0) {
            $pageNumber = $this->DEFAULT_PAGE_NUMBER;
        } else {
            $pageNumber = $request->get('page')['number'];
        }
        $request['page'] = $pageNumber;


        //set default ordering
        if (isset($request->toArray()['order_by'])) {
            if (is_null($request['order_by'])) {
                $request['order_by'] = "{\"field\":\"id\",\"operator\":\"Desc\"}";
            }
        }

        $validationErrors = $this->checkRequestValidation($request, $this->indexValidateArray);
        $validationErrors = $this->checkRequestValidation(/** @scrutinizer ignore-type */ $request, $this->indexValidateArray);
        if ($validationErrors != null) {
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($validationErrors->toArray()));
            }
            $response->setMessage($this->getTrans(__FUNCTION__, 'validation_failed'));
            $response->setStatus(false);
            $response->setError(99);
            return SmartResponse::response($response);
        }

        try {
            $data = $request->get('query') != null ?
                $this->model
                    ->whereKey(collect($this->model
                        ->search(($request->get('query')))
                        ->raw())->get('ids')) :
                $this->model;

            if (array_key_exists('file', $request->toArray())) {
                //TODO add relation on top if here and create a tree flatter array in array helper
                return (new ExcelHelper())->setOptions([
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                    'store_format' => $request->get('file') == null ? 'xls' : $request->get('file'),
                    'download_format' => $request->get('file') == null ? 'xls' : $request->get('file'),
                ])->table($data->get()->toArray())->createExcelFile()->download();
            }

            // load relations
            if (count($this->indexLoad) > 0) {
                $data = $data->with($this->indexLoad);
            }

            // filters by
            if (isset($request->toArray()['filters'])) {
                $data = (new QueryHelper())->deepFilter($data, (new RequestHelper())->getCollectFromJson($request['filters']));
            }

            // order by
            if (isset($request->toArray()['order_by'])) {
                $data = (new QueryHelper())->orderBy($data, (new RequestHelper())->getCollectFromJson($request['order_by']));
            }

            // return response
            $response->setData(collect($data->paginate($pageSize)));
            $response->setMessage($this->getTrans('index', 'successful'));
            return SmartResponse::response($response);

        } catch (QueryException $exception) {

            // return response
            $response->setData(collect($exception->getMessage()));
            $response->setError($exception->getCode());
            $response->setMessage($this->getTrans('index', 'failed'));
            $response->setStatus(false);
            return SmartResponse::response($response);
        }
    }

    public function checkRequestValidation(Request $request, $validationArray)
    {
        $requestParams = $request->toArray();

        $validator = Validator::make($request->all(), $validationArray);
        if ($validator->fails()) {
            return $validator->errors();
        }
        return null;
    }

    /**
     * @param $status
     * @return mixed
     */
    public function message($status)
    {
        $key = $this->messagePrefix . $this->modelName . '.' . debug_backtrace()[1]['function'] . '.' . $status;
        return $this->getMessageFromFile($key);
    }

    /**
     * @param $key
     * @return mixed
     */
    public function getMessageFromFile($key)
    {
        return config($key);
    }

    /**
     * Show the form for creating a new resource.
     *
     * @return \Illuminate\Http\JsonResponse
     */
    public function create()
    {
        // Create Response Model
        $response = new ResponseModel();

        // return response
        $response->setData(collect($this->model->getFillable()));
        $response->setMessage($this->getTrans('create', 'successful'));
        return SmartResponse::response($response);
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function store(Request $request)
    {
        // handle permission
        $request = $this->handlePermission($request, __FUNCTION__);

        // Create Response Model
        $response = new ResponseModel();

        if (!isset($userId)) {

            $userId = 1;
        }

        //add author id into the request if doesn't exist
        if (is_null($request->get('author_id'))) {
            $request['author_id'] = $userId;
        }

        //add user id into the request if doesn't exist
        if (is_null($request->get('user_id'))) {
            $request['user_id'] = $userId;
        }

        $validationErrors = $this->checkRequestValidation($request, $this->storeValidateArray);
        $validationErrors = $this->checkRequestValidation(/** @scrutinizer ignore-type */ $request, $this->storeValidateArray);

        if ($validationErrors != null) {
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($validationErrors->toArray()));
            }
            $response->setMessage($this->getTrans(__FUNCTION__, 'validation_failed'));
            $response->setStatus(false);
            $response->setError(99);
            return SmartResponse::response($response);

        }

        try {
            // get result of model creation
            $result = $this->model->create($request->all());
            // sync many to many relation
            foreach ($this->pivotFields as $pivotField) {
                if (collect($request[$pivotField])->count()) {
                    $pivotField = (new StringHelper())->toCamel($pivotField);
                    $this->model->find($result['id'])->$pivotField()->sync(json_decode($request[$pivotField]));
                }
            }
            $response->setMessage($this->getTrans('store', 'successful'));


            $response->setData($this->model
                ->where($this->model->getKeyName(), $result['id'])
                ->with(collect($this->updateLoad)->count() == 0 ? $this->indexLoad : $this->updateLoad)
                ->get());

            $response->setStatus(true);
        } catch (QueryException $exception) {
            $response->setError($exception->getCode());
            $response->setMessage($this->getTrans('store', 'failed'));
            $response->setStatus(false);
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }
        }
        return SmartResponse::response($response);
    }

    /**
     * Display the specdefaultied resource.
     *
     * @param  int $id
     * @return \Illuminate\Http\JsonResponse
     */
    public function show($id)
    {
        // Create Response Model
        $response = new ResponseModel();

        // try to get data
        try {
            $response->setMessage($this->getTrans('show', 'successful'));
            $response->setData(collect($this->model->findOrFail($id)));

            // catch exception
        } catch (ModelNotFoundException $exception) {
            $response->setError($exception->getCode());
            $response->setError(/** @scrutinizer ignore-type */ $exception->getCode());
            $response->setMessage($this->getTrans('show', 'failed'));
            $response->setStatus(false);
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }
        }
        return SmartResponse::response($response);
    }

    /**
     * Show the form for editing the specified resource.
     *
     * @param  int $id
     * @return \Illuminate\Http\JsonResponse
     */
    public function edit($id)
    {
        // Create Response Model
        $response = new ResponseModel();

        try {
            $response->setMessage($this->getTrans('edit', 'successful'));
            $response->setData($this->model
                ->where($this->model->getKeyName(), $id)
                ->with(collect($this->editLoad)->count() == 0 ? $this->indexLoad : $this->editLoad)
                ->get());

        } catch (ModelNotFoundException $exception) {
            $response->setError($exception->getCode());
            $response->setError(/** @scrutinizer ignore-type */ $exception->getCode());
            $response->setMessage($this->getTrans('edit', 'failed'));
            $response->setStatus(false);
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }

        }

        return SmartResponse::response($response);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request $request
     * @param  int $id
     * @return \Illuminate\Http\JsonResponse
     */
    public function update(Request $request, $id)
    {


        // Create Response Model
        $response = new ResponseModel();

        $modelFilter = [
            [$this->model->getKeyName(), '=', $id],
        ];

        $validationErrors = $this->checkRequestValidation($request, $this->updateValidateArray);
        if ($validationErrors != null) {
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($validationErrors->toArray()));
            }
            $response->setMessage($this->getTrans(__FUNCTION__, 'validation_failed'));
            $response->setStatus(false);
            $response->setError(99);
            return SmartResponse::response($response);

        }

        try {
            // sync many to many relation
            foreach ($this->pivotFields as $pivotField) {
                if (collect($request[$pivotField])->count()) {
                    $pivotMethod = (new StringHelper())->toCamel($pivotField);
                    $this->model->findOrFail($id)->$pivotMethod()->sync(json_decode($request[$pivotField], true));
                }
            }
            //get result of update
            $result = $this->model->findOrFail($id)->update($request->all());

            // return response
            $response->setData($this->model
                ->where($modelFilter)
                ->with(collect($this->updateLoad)->count() == 0 ? $this->indexLoad : $this->updateLoad)
                ->get());
            $response->setMessage(
                $this->getTrans('update', 'successful1') .
                /** @scrutinizer ignore-type */ $this->getTrans('update', 'successful1') .
                $result .
                $this->getTrans('update', 'successful2')
                /** @scrutinizer ignore-type */ $this->getTrans('update', 'successful2')
            );

        } catch (ModelNotFoundException $exception) {
            $response->setStatus(false);
            $response->setMessage($this->getTrans('update', 'model_not_found'));
            $response->setError($exception->getCode());
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }

        } catch (QueryException $exception) {
            $response->setStatus(false);
            $response->setMessage($this->getTrans('update', 'failed'));
            $response->setError($exception->getCode());
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }

        }

        return SmartResponse::response($response);
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  int $id
     * @return \Illuminate\Http\JsonResponse
     */
    public function destroy($id)
    {
        // Create Response Model
        $response = new ResponseModel();

        try {
            $response->setData(collect($this->model->findOrFail($id)->delete()));
            $response->setMessage($this->getTrans('destroy', 'successful'));

        } catch (ModelNotFoundException $exception) {
            $response->setMessage($this->getTrans('destroy', 'successful'));
            $response->setStatus(false);
            $response->setError($exception->getCode());
            $response->setError(/** @scrutinizer ignore-type */ $exception->getCode());
            if (env('APP_DEBUG', false)) {
                $response->setData(collect($exception->getMessage()));
            }

        }

        return SmartResponse::response($response);
    }

    /**
     * @param $method
     * @param $status
     * @return array|\Illuminate\Contracts\Translation\Translator|null|string
     */
    public function getTrans($method, $status)
    {
        return trans('laravel_smart_restful::' . $this->LOCALE_PREFIX . '.' . get_class($this->model) . '.' . $method . '.' . $status);
    }

    /**
     * set local
     */
    public function setLocale()
    {
        if (isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {
            \App::setLocale($_SERVER['HTTP_ACCEPT_LANGUAGE']);
        }
    }

    public function handlePermission(Request $request, $functionName, $params = [])
    {
        if (!isset($request['permission_type'])) {
            $request['permission_type'] = $this->DEFAULT_PERMISSION_TYPE;
        }
        switch ($request['permission_type']) {
            case 'admin':
                return $this->handleAdminPermission($request, $functionName, $params);
            case 'branch':
                return $this->handleBranchPermission($request, $functionName, $params);
            case 'own':
                return $this->handleOwnPermission($request, $functionName, $params);
            case 'guest':
                return $this->handleGuestPermission($request, $functionName, $params);
            default:
                return $params;
        }
    }

    public function handleAdminPermission(Request $request, $functionName, $params = [])
    {
        switch ($functionName) {
            case 'index':
            case 'store':
            case 'show':
            case 'edit':
            case 'create':
            case 'update':
            case 'destroy':
            default:
                return $params;
        }
    }

    public function handleBranchPermission(Request $request, $functionName, $params)
    {
        switch ($functionName) {
            case 'index':
            case 'store':
            case 'show':
            case 'edit':
            case 'create':
            case 'update':
            case 'destroy':
            default:
                return $params;
        }
    }

    public function handleOwnPermission(Request $request, $functionName, $params)
    {
        switch ($functionName) {
            case 'index':
                if (isset($request['filters'])) {
                    $filters = json_decode($request['filters'], true);
                } else {
                    $filters = [];
                }
                array_push($filters, [
                    "key" => "owner_id",
                    "operator" => "=",
                    "value" => auth()->id(),
                ]);
                $request['filters'] = json_encode($filters);
                return $request;
            case 'store':
                $request['owner_id'] = auth()->id();
                return $request;
            case 'show':
                $filters = [];
                array_push($filters, [
                    "key" => "owner_id",
                    "operator" => "=",
                    "value" => auth()->id(),
                ]);
                $request['permission_filters'] = json_encode($filters);
                return $request;
            case 'edit':
                $filters = [];
                array_push($filters, [
                    "key" => "owner_id",
                    "operator" => "=",
                    "value" => auth()->id(),
                ]);
                $request['permission_filters'] = json_encode($filters);
                return $request;
            case 'create':
            case 'update':
                $filters = [];
                array_push($filters, [
                    "key" => "owner_id",
                    "operator" => "=",
                    "value" => auth()->id(),
                ]);
                $request['permission_filters'] = json_encode($filters);
                return $request;
            case 'destroy':
                $filters = [];
                array_push($filters, [
                    "key" => "owner_id",
                    "operator" => "=",
                    "value" => auth()->id(),
                ]);
                $request['permission_filters'] = json_encode($filters);
                return $request;
            default:
                return $params;
        }
    }

    public function handleGuestPermission(Request $request, $functionName, $params)
    {
        switch ($functionName) {
            case 'index':
            case 'store':
            case 'show':
            case 'edit':
            case 'create':
            case 'update':
            case 'destroy':
            default:
                return $params;
        }
    }

}
Alive2212 / LaravelSmartRestful

Push — master ( 7b42a8...29affb )

BaseController::create() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
