OfflineAgency\MongoAutoSync\Traits\MainMongoTrait

Complexity

Total Complexity

31

Size/Duplication

Total Lines	283
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	setPartialGeneratedRequest()	0	6	1
A	updateWithSync()	0	10	1
A	setRequest()	0	4	1
A	setTargetAdditionalData()	0	3	1
A	getOptions()	0	3	1
A	storeWithSync()	0	10	1
A	getModelTobeSync()	0	9	1
A	getOptionValue()	0	3	2
A	setOptions()	0	3	1
A	checkRequestExistence()	0	5	2
A	getRequest()	0	3	1
A	destroyWithSync()	0	38	5
A	getIsSkippable()	0	3	3
A	initDataForSync()	0	6	1
A	getTargetAdditionalData()	0	3	1
A	getHasPartialRequest()	0	3	1
A	getRelationshipRequest()	0	8	1
A	setHasPartialRequest()	0	6	1
A	getPartialGeneratedRequest()	0	3	1
A	checkArrayExistence()	0	5	2
A	checkPropertyExistence()	0	5	2

<?php

namespace OfflineAgency\MongoAutoSync\Traits;

use Exception;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;

trait MainMongoTrait
{
    protected $has_partial_request;
    protected $request;
    protected $target_additional_data;
    protected $partial_generated_request;
    protected $options;
    protected $tempEM;

    /**
     * @param Request $request
     * @param array $additionalData
     * @param array $options
     * @param array $target_additional_data
     * @return $this
     * @throws Exception
     */
    public function storeWithSync(Request $request, array $additionalData = [], array $options = [], array $target_additional_data = [])
    {
        $this->initDataForSync($request, $additionalData, $options, $target_additional_data);
        $this->storeEditAllItems($request, 'add', $options);

It seems like storeEditAllItems() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->processAllRelationships($request, 'add', '', '', $options);

It seems like processAllRelationships() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        //Dispatch the creation event
        $this->fireModelEvent('storeWithSync');

It seems like fireModelEvent() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this->fresh();

It seems like fresh() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @param Request $request
     * @param array $additionalData
     * @param array $options
     * @param array $target_additional_data
     * @return $this
     * @throws Exception
     */
    public function updateWithSync(Request $request, array $additionalData = [], array $options = [], array $target_additional_data = [])
    {
        $this->initDataForSync($request, $additionalData, $options, $target_additional_data);
        $this->storeEditAllItems($request, 'update', $options);
        $this->processAllRelationships($request, 'update', '', '', $options);

        //Dispatch the update event
        $this->fireModelEvent('updateWithSync');

        return $this->fresh();
    }

    /**
     * @return $this
     */
    public function destroyWithSync()
    {
        //Get the relation info
        $relations = $this->getMongoRelation();

It seems like getMongoRelation() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        //Process all relationships
        foreach ($relations as $method => $relation) {
            //Get Relation Save Mode
            $type = $relation['type'];
            $hasTarget = hasTarget($relation);
            if ($hasTarget) {
                $modelTarget = $relation['modelTarget'];
                $methodOnTarget = $relation['methodOnTarget'];
                $modelOnTarget = $relation['modelOnTarget'];

The assignment to $modelOnTarget is dead and can be removed.

                $is_EO = is_EO($type);
                $is_EM = is_EM($type);
                $is_HO = is_HO($type);

The assignment to $is_HO is dead and can be removed.

                $is_HM = is_HM($type);

The assignment to $is_HM is dead and can be removed.

                if ($is_EO || $is_EM) {//EmbedsOne Create - EmbedsMany Create
                    //Delete EmbedsMany or EmbedsOne on Target
                    $this->deleteTargetObj($method, $modelTarget, $methodOnTarget, $is_EO);

It seems like deleteTargetObj() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                }

                //TODO: Need to be implemented
                /* elseif ($is_HM) {//HasMany
                 } elseif ($is_HO) {//HasOne Create
                 }*/
            }
        }
        //Delete current object
        $this->delete();

It seems like delete() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        //Dispatch the destroy event
        $this->fireModelEvent('destroyWithSync');

        return $this;
    }

    /**
     * @param array $options
     * @param string $key
     * @return bool|mixed
     */
    private function getOptionValue(array $options, string $key)
    {
        return Arr::has($options, $key) ? $options[$key] : '';
    }

    /**
     * @param $obj
     * @param string $EOkey
     * @param string $method
     * @param string $model
     * @throws Exception
     */
    public function checkPropertyExistence($obj, string $EOkey, $method = '', $model = '')
    {
        if (! property_exists($obj, $EOkey)) {
            $msg = 'Error - '.$EOkey.' attribute not found on obj '.json_encode($obj).' during save of model: '.$model.' and attribute: '.$method;
            throw new Exception($msg);
        }
    }

    /**
     * @param $arr
     * @param string $key
     * @throws Exception
     */
    public function checkArrayExistence($arr, string $key)
    {
        if (! Arr::has($arr, $key)) {
            $msg = ('Error - '.$key.' attribute not found on obj '.json_encode($arr));
            throw new Exception($msg);
        }
    }

    /**
     * @param Request $request
     * @param string $key
     * @throws Exception
     */
    private function checkRequestExistence(Request $request, string $key)
    {
        if (! $request->has($key)) {
            $msg = ('Error - '.$key.' attribute not found in Request '.json_encode($request->all()));
            throw new Exception($msg);
        }
    }

    /**
     * @param bool $request_has_key
     * @param bool $hasTarget
     * @return bool
     */
    public function getIsSkippable($request_has_key, $hasTarget = false)
    {
        return ! $request_has_key && $this->getHasPartialRequest() && ! $hasTarget;
    }

    /**
     * @return bool
     */
    public function getHasPartialRequest()
    {
        return $this->has_partial_request;
    }

    public function setHasPartialRequest(): void
    {
        $this->has_partial_request = $this->getOptionValue(
                $this->getOptions(),
                'request_type'
            ) == 'partial';
    }

    /**
     * @param string $modelTarget
     * @param stdClass $obj
     * @return MDModel

The type OfflineAgency\MongoAutoSync\Traits\MDModel was not found. Maybe you did not declare it correctly or list all dependencies?

     * @throws Exception
     */
    private function getModelTobeSync(string $modelTarget, stdClass $obj)

The type OfflineAgency\MongoAutoSync\Traits\stdClass was not found. Did you mean stdClass? If so, make sure to prefix the type with \.

    {
        $this->checkPropertyExistence($obj, 'ref_id');
        $target_id = $obj->ref_id;

        //Init the Target Model
        $modelToBeSync = new $modelTarget;

        return $modelToBeSync->find($target_id);
    }

    /**
     * @param string $key
     * @param Request $request
     * @return mixed
     * @throws Exception
     */
    private function getRelationshipRequest(string $key, Request $request)
    {
        $this->checkRequestExistence(
            $request,
            $key
        );

        return $request->input($key);
    }

    /**
     * @return Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * @param Request $request
     * @param array $additionalData
     */
    public function setRequest(Request $request, array $additionalData): void
    {
        $request = $request->merge($additionalData);
        $this->request = $request;
    }

    /**
     * @return Request
     */
    public function getPartialGeneratedRequest()
    {
        return $this->partial_generated_request;
    }

    /**
     * @param array $arr
     */
    public function setPartialGeneratedRequest(array $arr): void
    {
        $partial_generated_request = new Request;
        $partial_generated_request->merge($arr);

        $this->partial_generated_request = $partial_generated_request;
    }

    /**
     * @return array
     */
    public function getOptions()
    {
        return $this->options;
    }

    /**
     * @param array $options
     */
    public function setOptions(array $options): void
    {
        $this->options = $options;
    }

    /**
     * @return array
     */
    public function getTargetAdditionalData()
    {
        return $this->target_additional_data;
    }

    /**
     * @param array $target_additional_data
     */
    public function setTargetAdditionalData($target_additional_data): void
    {
        $this->target_additional_data = $target_additional_data;
    }

    /**
     * @param Request $request
     * @param array $additionalData
     * @param array $options
     * @param array $target_additional_data
     */
    public function initDataForSync(Request $request, array $additionalData, array $options, array $target_additional_data)
    {
        $this->setRequest($request, $additionalData);
        $this->setTargetAdditionalData($target_additional_data);
        $this->setOptions($options);
        $this->setHasPartialRequest();
    }
}