midcom_helper_reflector_copy::copy_attachments() - Code Metrics - Inspection of "Fix wrong api usage" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( d0f685...56fb23 )

by Andreas
created 2020-11-05 14:08 UTC
midcom_helper_reflector_copy::copy_attachments() A

↳ Parent: midcom_helper_reflector_copy
Complexity

Conditions	2
Paths	2
Size

Total Lines	11
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	2.032
Importance

Changes
Metric	Value
cc	2
eloc	5
nc	2
nop	2
dl	0
loc	11
ccs	4
cts	5
cp	0.8
crap	2.032
rs	10
c	0
b	0
f	0
<?php
/**
 * @package midcom.helper.reflector
 * @author The Midgard Project, http://www.midgard-project.org
 * @copyright The Midgard Project, http://www.midgard-project.org
 * @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
 */

/**
 * The Grand Unified Reflector, copying helper class
 *
 * @package midcom.helper.reflector
 */
class midcom_helper_reflector_copy extends midcom_baseclasses_components_purecode
{
    /**
     * Target
     *
     * @var midcom_core_dbaobject
     */
    public $target;

    /**
     * Exclusion list
     *
     * @var array        List of GUIDs of objects that shall not be copied
     */
    public $exclude = [];

    /**
     * Override properties of the new root object. This feature is
     * directed for overriding e.g. parent information.
     *
     * @var array        Property-value pairs
     */
    public $root_object_values = [];

    /**
     * Switch for attachments
     *
     * @var boolean
     */
    public $attachments = true;

    /**
     * Switch for parameters
     *
     * @var boolean
     */
    public $parameters = true;

    /**
     * Switch for privileges
     *
     * @var boolean
     */
    public $privileges = true;

    /**
     * Switch for metadata
     *
     * @var boolean
     */
    public $metadata = true;

    /**
     * Copy the whole tree
     *
     * @var boolean
     */
    public $recursive = true;

    /**
     * Metadata fields that shall be copied
     */
    public $copy_metadata_fields = [
        'owner',
        'authors',
        'schedulestart',
        'scheduleend',
        'navnoentry',
        'hidden',
        'score',
    ];

    /**
     * Switch for halt on error. If this is set to false, errors will be
     * reported, but will not stop executing
     *
     * @var boolean        Set to false to continue on errors
     */
    public $halt_on_errors = true;

    /**
     * Encountered errors
     *
     * @var array
     */
    public $errors = [];

    /**
     * Get the parent property for overriding it
     */
    public static function get_parent_property(midcom_core_dbaobject $object) : string
    {
        $parent = midgard_object_class::get_property_parent($object->__mgdschema_class_name__);
        if (!$parent) {
            $parent = midgard_object_class::get_property_up($object->__mgdschema_class_name__);

            if (!$parent) {
                throw new midcom_error('Failed to get the parent property for copying');
            }
        }

        return $parent;
    }

    /**
     * Copy an object tree. Both source and parent may be liberally filled. Source can be either
     * MgdSchema or MidCOM db object of the object and parent can be
     *
     * - MgdSchema object
     * - MidCOM db object
     * - left empty to copy as a parentless object
     *
     * This method is self-aware and will refuse to perform any infinite loops (e.g. to copy
     * itself to its descendant, copying itself again and again and again).
     *
     * Eventually this method will return the first root object that was created, i.e. the root
     * of the new tree.
     */
    public function copy_tree(midcom_core_dbaobject $source, midcom_core_dbaobject $parent) : ?midcom_core_dbaobject
    {
        // Copy the root object
        $root = $this->copy_object($source, $parent);

        if (!$root) {
            $this->errors[] = sprintf($this->_l10n->get('failed to copy object %s'), $source->guid);
            return null;
        }

        // Add the newly copied object to the exclusion list to prevent infinite loops
        $this->exclude[] = $source->guid;

        // Get the children
        $children = midcom_helper_reflector_tree::get_child_objects($source);
        $children = midcom_helper_reflector_tree::get_child_objects(/** @scrutinizer ignore-type */ $source);

        if (empty($children)) {
            return $root;
        }

        // Loop through the children and copy them to their corresponding parents
        foreach ($children as $subchildren) {
            // Get the children of each type
            foreach ($subchildren as $child) {
                // Skip the excluded child
                if (in_array($child->guid, $this->exclude)) {
                    continue;
                }

                $this->copy_tree($child, $root);
            }
        }

        // Return the newly created root object
        return $root;
    }

    /**
     * Copy an object
     */
    public function copy_object(midcom_core_dbaobject $source, ?midcom_core_dbaobject $parent, array $defaults = []) : ?midcom_core_dbaobject
    {
        // Duplicate the object
        $class_name = get_class($source);
        $target = new $class_name();

        $properties = midcom_helper_reflector::get_object_fieldnames($source);

        // Copy the object properties
        foreach ($properties as $property) {
            // Skip certain fields
            if (preg_match('/^(_|metadata|guid|id)/', $property)) {
                continue;
            }

            $target->$property = $source->$property;
        }

        // Override requested root object properties
        if (   !empty($this->target->guid)
            && $target->guid === $this->target->guid) {
            foreach ($this->root_object_values as $name => $value) {
                $target->$name = $value;
            }
        }

        // Override with defaults
        foreach ($defaults as $name => $value) {
            $target->$name = $value;
        }

        if ($this->recursive) {
            $parent_property = self::get_parent_property($source);

            // Copy the link to parent
            if (!empty($parent->guid)) {
                // @TODO: Is there a sure way to determine if the parent is
                // GUID or is it ID? If so, please change it here.
                $parent_key = (is_string($source->$parent_property)) ? 'guid' : 'id';
                $target->$parent_property = $parent->$parent_key;
            } else {
                $target->$parent_property = (is_string($source->$parent_property)) ? '' : 0;
            }
        }
        if ($name_property = midcom_helper_reflector::get_name_property($target)) {
            $resolver = new midcom_helper_reflector_nameresolver($target);
            $target->$name_property = $resolver->generate_unique_name();
        }

        // This needs to be here, otherwise it will be overridden
        $target->allow_name_catenate = true;
        if (!$target->create()) {
            $this->errors[] = $this->_l10n->get('failed to create object: ' . midcom_connection::get_error_string());
            return null;
        }

        foreach (['parameters', 'metadata', 'attachments', 'privileges'] as $type) {
            if (!$this->_copy_data($type, $source, $target)) {
                return null;
            }
        }

        return $target;
    }

    /**
     * Copy object data
     */
    private function _copy_data(string $type, midcom_core_dbaobject $source, midcom_core_dbaobject $target) : bool
    {
        if ($this->$type) {
            $method = 'copy_' . $type;
            if (   !$this->$method($source, $target)
                && $this->halt_on_errors) {
                $this->errors[] = $this->_l10n->get('failed to copy ' . $type);
                return false;
            }
        }

        return true;
    }

    /**
     * Copy parameters for the object
     */
    public function copy_parameters(midcom_core_dbaobject $source, midcom_core_dbaobject $target) : bool
    {
        // Loop through the parameters
        foreach ($source->list_parameters() as $domain => $parameters) {
            foreach ($parameters as $name => $value) {
                if (!$target->set_parameter($domain, $name, $value)) {
                    $this->errors[] = sprintf($this->_l10n->get('failed to copy parameters from %s to %s'), $source->guid, $target->guid);

                    if ($this->halt_on_errors) {
                        return false;
                    }
                }
            }
        }

        return true;
    }

    /**
     * Copy metadata for the object
     */
    public function copy_metadata(midcom_core_dbaobject $source, midcom_core_dbaobject $target) : bool
    {
        foreach ($this->copy_metadata_fields as $property) {
            $target->metadata->$property = $source->metadata->$property;
        }

        if ($target->update()) {
            return true;
        }

        $this->errors[] = sprintf($this->_l10n->get('failed to copy metadata from %s to %s'), $source->guid, $target->guid);
        return false;
    }

    /**
     * Copy attachments
     */
    public function copy_attachments(midcom_core_dbaobject $source, midcom_core_dbaobject $target) : bool
    {
        $defaults = [
            'parentguid' => $target->guid,
        ];

        foreach ($source->list_attachments() as $attachment) {
            $this->copy_object($attachment, $target, $defaults);
        }

        return true;
    }

    /**
     * Copy privileges
     */
    public function copy_privileges(midcom_core_dbaobject $source, midcom_core_dbaobject $target) : bool
    {
        $qb = midcom_core_privilege_db::new_query_builder();
        $qb->add_constraint('objectguid', '=', $source->guid);

        foreach ($qb->execute() as $privilege) {
            $new = new midcom_core_privilege_db();
            $new->objectguid = $target->guid;

            $new->classname = $privilege->classname;
            $new->privilegename = $privilege->privilegename;
            $new->value = $privilege->value;
            $new->assignee = $privilege->assignee;

            if (!$new->create()) {
                $this->errors[] = 'privilege creation failed';
                return false;
            }
        }

        return true;
    }

    /**
     * Dispatches the copy command according to the attributes set
     */
    public function execute(midcom_core_dbaobject $source) : ?midcom_core_dbaobject
    {
        if ($this->recursive) {
            // Disable execution timeout and memory limit, this can be very intensive
            midcom::get()->disable_limits();

            $new_root_object = $this->copy_tree($source, $this->target);
        } else {
            $new_root_object = $this->copy_object($source, $this->target);
        }

        if (empty($new_root_object->guid)) {
            $this->errors[] = $this->_l10n->get('failed to get the new root object');
            return null;
        }

        return $new_root_object;
    }
}

flack / openpsa

Push — master ( d0f685...56fb23 )

midcom_helper_reflector_copy::copy_attachments() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
