EntitiesTrait::saveBulk() - Code Metrics - SoliDry/api-generator - Measure and Improve Code Quality continuously with Scrutinizer

EntitiesTrait::saveBulk() D
last analyzed 2022-08-08 18:19 UTC

↳ Parent: EntitiesTrait
Complexity

Conditions	10
Paths	626
Size

Total Lines	59
Code Lines	28
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
eloc	28
c	3
b	0
f	0
dl	0
loc	59
rs	4.0194
cc	10
nc	626
nop	1
How to fix Long Method Complexity

<?php

namespace SoliDry\Blocks;

use Illuminate\Container\Container;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Facades\DB;
use SoliDry\Exceptions\ErrorHandler;
use SoliDry\Extension\ApiController;
use SoliDry\Extension\BaseFormRequest;
use SoliDry\Extension\BaseModel;
use SoliDry\Extension\JSONApiInterface;
use SoliDry\Helpers\Classes;
use SoliDry\Helpers\ConfigHelper as conf;
use SoliDry\Helpers\ConfigOptions;
use SoliDry\Helpers\Json;
use SoliDry\Types\DefaultInterface;
use SoliDry\Types\DirsInterface;
use SoliDry\Types\ModelsInterface;
use SoliDry\Types\PhpInterface;
use SoliDry\Types\ApiInterface;

/**
 * Class EntitiesTrait
 *
 * @package SoliDry\Blocks
 * @property ApiController entity
 * @property BaseFormRequest $formRequest
 * @property ApiController props
 * @property BaseModel model
 * @property ApiController modelEntity
 * @property ConfigOptions configOptions
 * @property Json json
 * @property \SoliDry\Containers\Response response
 */
trait EntitiesTrait
{
    use ErrorHandler;

    /**
     * Gets form request entity fully qualified path
     *
     * @param string $version
     * @param string $object
     * @return string
     */
    public function getFormRequestEntity(string $version, string $object): string
    {
        return DirsInterface::MODULES_DIR . PhpInterface::BACKSLASH . strtoupper($version) .
            PhpInterface::BACKSLASH . DirsInterface::HTTP_DIR .
            PhpInterface::BACKSLASH .
            DirsInterface::FORM_REQUEST_DIR . PhpInterface::BACKSLASH .
            $object .
            DefaultInterface::FORM_REQUEST_POSTFIX;
    }

    /**
     *  Sets all props/entities needed to process request
     *
     * @throws \Illuminate\Contracts\Container\BindingResolutionException
     * @throws \ReflectionException
     */
    protected function setEntities(): void
    {
        $this->entity = Classes::cutEntity(Classes::getObjectName($this), DefaultInterface::CONTROLLER_POSTFIX);

        $formRequestEntity = $this->getFormRequestEntity(conf::getModuleName(), $this->entity);

        $this->formRequest = new $formRequestEntity();
        $this->props = get_object_vars($this->formRequest);


        $this->modelEntity = Classes::getModelEntity($this->entity);

        $this->model = new $this->modelEntity();

        $container = Container::getInstance();
        $this->response = $container->make(\SoliDry\Containers\Response::class);
        $this->response->setFormRequest($this->formRequest);
        $this->response->setEntity($this->entity);
    }

    /**
     * Save bulk transactionally, if there are some errors - rollback
     *
     * @param Request $request
     * @return Response
     * @throws \InvalidArgumentException
     * @throws \LogicException
     */
    protected function saveBulk(Request $request): Response
    {
        $meta = [];
        $collection = new Collection();

        $json = Json::decode($request->getContent());
        $jsonApiAttributes = Json::getBulkAttributes($json);

        try {
            DB::beginTransaction();
            foreach ($jsonApiAttributes as $jsonObject) {

                $this->model = new $this->modelEntity();
                $this->model = /** @scrutinizer ignore-call */ new $this->modelEntity();

                // FSM initial state check
                if ($this->configOptions->isStateMachine() === true) {
                    $this->checkFsmCreate($jsonObject);
                           checkFsmCreate($jsonObject);
                }

                // spell check
                if ($this->configOptions->isSpellCheck() === true) {
                    $meta[] = $this->spellCheck($jsonObject);
                    $meta[] = $this->spellCheck($jsonObject);
                }

                // fill in model
                foreach ($this->props as $k => $v) {
                    // request fields should match FormRequest fields
                    if (isset($jsonObject[$k])) {
                        $this->model->$k = $jsonObject[$k];
                    }
                }

                // set bit mask
                if ($this->configOptions->isBitMask() === true) {
                    $this->setMaskCreate($jsonObject);
                           setMaskCreate($jsonObject);
                }

                $collection->push($this->model);
                $this->model->save();

                // jwt
                if ($this->configOptions->getIsJwtAction() === true) {
                    $this->createJwtUser(); // !!! model is overridden
                           createJwtUser(); // !!! model is overridden
                }

                // set bit mask from model -> response
                if ($this->configOptions->isBitMask() === true) {
                    $this->model = $this->setFlagsCreate();
                    $this->model = $this->setFlagsCreate();
                }
            }

            DB::commit();
        } catch (\PDOException $e) {
            DB::rollBack();

            return $this->getErrorResponse($request, $e);
        }

        return $this->response->get($collection, $meta);
    }

    /**
     * Mutates/Updates a bulk by applying it to transaction/rollback procedure
     *
     * @param Request $request
     * @return Response
     * @throws \InvalidArgumentException
     * @throws \SoliDry\Exceptions\AttributesException
     * @throws \LogicException
     */
    protected function mutateBulk(Request $request): Response
    {
        $meta = [];
        $collection = new Collection();

        $json = Json::decode($request->getContent());
        $jsonApiAttributes = Json::getBulkAttributes($json);

        try {
            DB::beginTransaction();
            foreach ($jsonApiAttributes as $jsonObject) {

                $model = $this->getEntity($jsonObject[JSONApiInterface::CONTENT_ID]);
                $model = $this->getEntity($jsonObject[JSONApiInterface::CONTENT_ID]);

                // FSM transition check
                if ($this->configOptions->isStateMachine() === true) {
                    $this->checkFsmUpdate($jsonObject, $model);
                           checkFsmUpdate($jsonObject, $model);
                }

                // spell check
                if ($this->configOptions->isSpellCheck() === true) {
                    $meta[] = $this->spellCheck($jsonObject);
                }

                $this->processUpdate($model, $jsonObject);
                       processUpdate($model, $jsonObject);
                $collection->push($model);
                $model->save();

                // set bit mask
                if ($this->configOptions->isBitMask() === true) {
                    $this->setFlagsUpdate($model);
                           setFlagsUpdate($model);
                }

            }
            DB::commit();
        } catch (\PDOException $e) {
            DB::rollBack();

            return $this->getErrorResponse($request, $e);
        }

        return $this->response->get($collection, $meta);
    }

    /**
     * Deletes bulk by applying it to transaction/rollback procedure
     *
     * @param Request $request
     * @return Response
     * @throws \LogicException
     */
    public function removeBulk(Request $request): Response
    {
        $json = Json::decode($request->getContent());
        $jsonApiAttributes = Json::getBulkAttributes($json);

        try {
            DB::beginTransaction();

            foreach ($jsonApiAttributes as $jsonObject) {
                $model = $this->getEntity($jsonObject[JSONApiInterface::CONTENT_ID]);

                if ($model === null) {
                    DB::rollBack();

                    return $this->response->getModelNotFoundError($this->modelEntity, $jsonObject[JSONApiInterface::CONTENT_ID]);
                    return $this->response->getModelNotFoundError(/** @scrutinizer ignore-type */ $this->modelEntity, $jsonObject[JSONApiInterface::CONTENT_ID]);
                }

                $model->delete();
            }

            DB::commit();
        } catch (\PDOException $e) {
            DB::rollBack();

            return $this->getErrorResponse($request, $e);
        }

        return $this->response->removeBulk();
    }

    /**
     * Gets the relations of entity or null
     * @param string $objectName
     *
     * @return mixed
     */
    private function getRelationType(string $objectName)
    {
        if (empty($this->generator->types[$objectName][ApiInterface::RAML_PROPS]
            [ApiInterface::RAML_RELATIONSHIPS][ApiInterface::RAML_TYPE]) === false
        ) {
            return trim(
                $this->generator->types[$objectName][ApiInterface::RAML_PROPS]
                [ApiInterface::RAML_RELATIONSHIPS][ApiInterface::RAML_TYPE]
            );
        }

        return null;
    }

    /**
     * Sets use stmt for Soft Delete op on model Entity
     *
     * @throws \ReflectionException
     */
    private function setUseSoftDelete(): void
    {
        if ($this->isSoftDelete()) {
        if ($this->/** @scrutinizer ignore-call */ isSoftDelete()) {
            $this->setUse(Classes::getObjectName(SoftDeletes::class), true, true);
                   setUse(Classes::getObjectName(SoftDeletes::class), true, true);
        }
    }

    /**
     * Sets property for Soft Delete op on model Entity
     */
    private function setPropSoftDelete(): void
    {
        if ($this->isSoftDelete()) {
            $this->createPropertyArray(ModelsInterface::PROPERTY_DATES, PhpInterface::PHP_MODIFIER_PROTECTED, [ModelsInterface::COLUMN_DEL_AT]);
                   createPropertyArray(ModelsInterface::PROPERTY_DATES, PhpInterface::PHP_MODIFIER_PROTECTED, [ModelsInterface::COLUMN_DEL_AT]);
        }
    }
}
SoliDry / api-generator

EntitiesTrait::saveBulk() D last analyzed 2022-08-08 18:19 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

EntitiesTrait::saveBulk() D
last analyzed 2022-08-08 18:19 UTC
