EventEspresso\core\services\orm\tree_traversal\RelationNode

Complexity

Total Complexity

27

Size/Duplication

Total Lines	222
Duplicated Lines	3.6 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	work()	3	36	6
A	allChildrenComplete()	0	9	3
A	visitAlreadyDiscoveredNodes()	0	14	4
A	isDiscovered()	0	4	1
A	isComplete()	5	11	3
A	discover()	0	4	1
A	whereQueryParams()	0	19	3
A	toArray()	0	12	2
A	getIds()	0	16	3

<?php

namespace EventEspresso\core\services\orm\tree_traversal;

use EE_Base_Class;
use EE_Error;
use EE_Has_Many_Any_Relation;
use EE_Model_Relation_Base;
use EEM_Base;
use EventEspresso\core\exceptions\InvalidDataTypeException;
use EventEspresso\core\exceptions\InvalidInterfaceException;
use EventEspresso\core\services\payment_methods\forms\PayPalSettingsForm;
use InvalidArgumentException;
use ReflectionException;

/**
 * Class RelationNode
 *
 * Wraps a model object and one of its model's relations; stores how many related model objects exist across that
 * relation, and eventually createsa a ModelObjNode for each of its related model objects.
 *
 * @package     Event Espresso
 * @author         Mike Nelson
 * @since         $VID:$
 *
 */
class RelationNode extends BaseNode
{
    /**
     * @var EE_Base_Class
     */
    protected $main_model_obj;

    /**
     * @var int
     */
    protected $count;

    /**
     * @var EEM_Base
     */
    protected $related_model;

    /**
     * @var ModelObjNode[]
     */
    protected $model_obj_nodes;

    public function __construct($main_model_obj, $related_model)
    {
        $this->main_model_obj = $main_model_obj;
        $this->related_model = $related_model;
        $this->model_obj_nodes = [];
    }


    /**
     * Here is where most of the work happens. We've counted how many related model objects exist, here we identify
     * them (ie, learn their IDs). But its recursive, so we'll also find their related dependent model objects etc.
     * @since $VID:$
     * @param int $model_objects_to_identify
     * @return int
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     */
    protected function work($model_objects_to_identify)
    {
        $num_identified = $this->visitAlreadyDiscoveredNodes($this->model_obj_nodes, $model_objects_to_identify);
        if ($num_identified < $model_objects_to_identify) {
            $related_model_objs = $this->related_model->get_all(
                [
                    $this->whereQueryParams(),
                    'limit' => [
                        count($this->model_obj_nodes),
                        $model_objects_to_identify
                    ]
                ]
            );
            $new_item_nodes = [];

            // Add entity nodes for each of the model objects we fetched.
            foreach ($related_model_objs as $related_model_obj) {
                $entity_node = new ModelObjNode($related_model_obj);
                $this->model_obj_nodes[ $related_model_obj->ID() ] = $entity_node;
                $new_item_nodes[ $related_model_obj->ID() ] = $entity_node;
            }
            $num_identified += count($new_item_nodes);
            if ($num_identified < $model_objects_to_identify) {
                // And lastly do the work.
                $num_identified += $this->visitAlreadyDiscoveredNodes(
                    $new_item_nodes,
                    $model_objects_to_identify - $num_identified
                );
            }
        }

        if (count($this->model_obj_nodes) >= $this->count && $this->allChildrenComplete()) {
            $this->complete = true;
        }
        return $num_identified;
    }

    /**
     * Checks if all the identified child nodes are complete or not.
     * @since $VID:$
     * @return bool
     */
    protected function allChildrenComplete()
    {
        foreach ($this->model_obj_nodes as $model_obj_node) {
            if (! $model_obj_node->isComplete()) {
                return false;
            }
        }
        return true;
    }

    /**
     * Visits the provided nodes and keeps track of how much work was done, making sure to not go over budget.
     * @since $VID:$
     * @param ModelObjNode[] $model_obj_nodes
     * @param $work_budget
     * @return int
     */
    protected function visitAlreadyDiscoveredNodes($model_obj_nodes, $work_budget)
    {
        $work_done = 0;
        if (! $model_obj_nodes) {

The expression $model_obj_nodes of type EventEspresso\core\services\orm\tree_traversal\ModelObjNode[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return 0;
        }
        foreach ($model_obj_nodes as $model_obj_node) {
            if ($work_done >= $work_budget) {
                break;
            }
            $work_done += $model_obj_node->visit($work_budget - $work_done);
        }
        return $work_done;
    }

    /**
     * Whether this item has already been initialized
     */
    protected function isDiscovered()
    {
        return $this->count !== null;
    }

    /**
     * @since $VID:$
     * @return boolean
     */
    public function isComplete()
    {
        if ($this->complete === null) {
            if (count($this->model_obj_nodes) === $this->count) {
                $this->complete = true;
            } else {
                $this->complete = false;
            }
        }
        return $this->complete;
    }

    /**
     * Discovers how many related model objects exist.
     * @since $VID:$
     * @return mixed|void
     * @throws EE_Error
     * @throws InvalidArgumentException
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws ReflectionException
     */
    protected function discover()
    {
        $this->count = $this->related_model->count([$this->whereQueryParams()]);
    }

    /**
     * @since $VID:$
     * @return array
     * @throws EE_Error
     * @throws InvalidDataTypeException
     * @throws InvalidInterfaceException
     * @throws InvalidArgumentException
     * @throws ReflectionException
     */
    protected function whereQueryParams()
    {
        $where_params =  [
            $this->related_model->get_foreign_key_to(
                $this->main_model_obj->get_model()->get_this_model_name()
            )->get_name() => $this->main_model_obj->ID()
        ];
        try {
            $relation_settings = $this->main_model_obj->get_model()->related_settings_for($this->related_model->get_this_model_name());
        } catch (EE_Error $e) {
            // This will happen for has-and-belongs-to-many relations, when this node's related model is that join table
            // which hasn't been explicitly declared in the main model object's model's relations.
            $relation_settings = null;
        }
        if ($relation_settings instanceof EE_Has_Many_Any_Relation) {
            $where_params[ $this->related_model->get_field_containing_related_model_name()->get_name() ] = $this->main_model_obj->get_model()->get_this_model_name();
        }
        return $where_params;
    }
    /**
     * @since $VID:$
     * @return array
     */
    public function toArray()
    {
        $tree = [
            'count' => $this->count,
            'complete' => $this->isComplete(),
            'objs' => []
        ];
        foreach ($this->model_obj_nodes as $id => $model_obj_node) {
            $tree['objs'][ $id ] = $model_obj_node->toArray();
        }
        return $tree;
    }

    /**
     * Gets the IDs of all the model objects to delete; indexed first by model object name.
     * @since $VID:$
     * @return array
     */
    public function getIds()
    {
        if (empty($this->model_obj_nodes)) {
            return [];
        }
        $ids = [
            $this->related_model->get_this_model_name() => array_combine(
                array_keys($this->model_obj_nodes),
                array_keys($this->model_obj_nodes)
            )
        ];
        foreach ($this->model_obj_nodes as $model_obj_node) {
            $ids = array_replace_recursive($ids, $model_obj_node->getIds());
        }
        return $ids;
    }
}
// End of file RelationNode.php
// Location: EventEspresso\core\services\orm\tree_traversal/RelationNode.php