bundle_inheritance.module

<?php

define( 'BUNDLE_INHERIT_KEY', 'inherit bundle');

function bundle_inheritance_entity_info ()
{
    $entities = array();
    $entities[BundleInheritanceRelation::EntityType] = array(
        'label' => t('inheritance relation'),
        'controller class' => 'BundleInheritanceController',
        'entity class' => 'BundleInheritanceRelation',
        'base table' => 'bundle_inheritances',
        'fieldable' => FALSE,
        'entity keys' => array(
            'id' => 'id',
            'label' => 'label',
            'bundle' => 'bundle'
        ),
        'bundle keys' => array(
            'bundle' => 'bundle'
        )
    );
    return $entities;
}

/**
 * 
 * @param unknown $entities
 */
function bundle_inheritance_entity_info_alter (&$entities)
{
    foreach( $entities as $entityName=>$entity)
    {
        if( array_key_exists( 'bundles', $entity) )
        {
            foreach( $entity['bundles'] as $bundleName=>$bundle )
            {
                if( array_key_exists(BUNDLE_INHERIT_KEY, $bundle) )
                {
                    $module = NULL;
                    if( $entityName == 'node')
                    {
                        $type = node_type_load($bundleName);
                        $module = $type->module;
                    }
                    bundle_inheritance_do_inheritance($entityName, $bundle[BUNDLE_INHERIT_KEY], $bundleName, $module );
                }
            }
        }
    }
}

/**
 * makes inheritance
 *
 * @param string $entity_type
 * @param string $parent
 * @param string $child
 */
function bundle_inheritance_do_inheritance ($entity_type, $parent, $child, $module = 'bundle_inheritance')
{
    watchdog('debug', 'bundle_inheritance_do_inheritance between '.$parent.' and '.$child );
    $relation = new BundleInheritanceRelation();
    // store inheritance relation in a table
    $relation->parent = $parent;
    $relation->child = $child;
    $relation->entity_type = $entity_type;
    if ($relation->save()) {
        foreach (bundle_inheritance_copy_field_instances($entity_type, $parent, $child) as $instance) {
            if (! field_read_instance($entity_type, $instance['field_name'], $child)) {
                field_create_instance($instance);
            }
        }
    }
}


function bundle_inheritance_break_inheritance($entity_type, $parent, $child)
{
    watchdog( "bundle_inheritance", "breaks inheritance link : " .$entity_type." :: ".$parent." :: ". $child );
    $ctrl = new BundleInheritanceController();
    $relations = $ctrl->load( FALSE, array( 'parent' => $parent, 'child' => $child) );
    $parentInstances = field_info_instances($entity_type, $parentBundle);
    foreach( $relations as $relation )
    {
        $childInstances = field_info_instances( $entity_type, $relation->child);
        foreach( $parentInstances as $key=>$instance )
        {
            if( array_key_exists( $key, $childInstances) && !$childInstances[$key]['settings']['bundle_inheritance']['modified'] )
            {
                field_delete_instance( $childInstances[$key] );
            }
        }
        $relation->delete();
    }
}

function bundle_inheritance_copy_field_instances ($entity_type, $parentBundle, $newBundle)
{
    try {
        // liste des instances à récupérer
        $parentInstances = field_info_instances($entity_type, $parentBundle);
        if ($parentInstances) {
            foreach ($parentInstances as $key => $instance) {
                $parentInstances[$key] = bundle_inheritance_prepare_instance($parentInstances[$key], $newBundle);
            }
        }
    } catch (Exception $e) {
        $parentInstances = array();
    }
    
    return $parentInstances;
}

/**
 *
 * @param array $instance
 * @param string $newBundle
 */
function bundle_inheritance_prepare_instance ($instance, $newBundle)
{
    unset($instance['id']);
    $instance['bundle'] = $newBundle;
    $instance['label'] .= " [Inherited]";
    $instance['settings']['bundle_inheritance']['inherited'] = true;
    $instance['settings']['bundle_inheritance']['modified'] = FALSE;
    return $instance;
}

/**
 * implementation of hook_field_create_instance
 *
 * when an instance is created on an identified superclass
 * the instance have to be copied
 *
 * @param unknown $instance
 */
function bundle_inheritance_field_create_instance ($instance)
{
    $ctrl = new BundleInheritanceController(BundleInheritanceRelation::EntityType);
    // retrieving all childs from
    $chain = $ctrl->getChilds($instance['bundle']);
    
    if (! empty($chain)) {
        foreach ($chain as $bundle) {
            $newInstance = bundle_inheritance_prepare_instance($instance, $bundle);
            field_create_instance($newInstance);
        }
    }
}

/**
 * implementation of hook_field_update_instance
 *
 * when an instance is updated on an identified superclass
 * (only if the child hasn't been modified)
 * the instance have to be copied
 *
 * @param unknown $instance
 *
 */
function bundle_inheritance_field_update_instance ($instance, $prior_instance)
{
    $updateFlag =& drupal_static( __FUNCTION__.'flag' );
    $ctrl = new BundleInheritanceController(BundleInheritanceRelation::EntityType);
    $isOverrided = isset($instance['settings']['bundle_inheritance']) && $instance['settings']['bundle_inheritance']['modified'];
    
    // lookin' for subclass childs bundle
    $chain = $ctrl->getChilds($instance['bundle']);
    if (! empty($chain)) {
        foreach ($chain as $bundle) {
            $existing = field_read_instance($instance['entity_type'], $instance['field_name'], $bundle);
            if (! $existing['settings']['bundle_inheritance']['modified']) {
                $newInstance = bundle_inheritance_prepare_instance($instance, $bundle);
                // we forbid the override check for the updated child 
                $updateFlag = FALSE;
                field_update_instance($newInstance);
                $updateFlag = TRUE;
            }
        }
    } else {
        if (! $isOverrided && $updateFlag) {
            // case of an inherited which is modified
            // so we flag it to modified
            $diff = NULL;
            $justWeight = FALSE;
            if( is_array( $instance) && is_array( $prior_instance ) )
            {
                $diff = array_diff_assoc_recursive( $instance, $prior_instance);
                dsm( $diff, "diff");
                if( is_array($diff) && array_keys( $diff ) == array( 'widget') && array_keys( $diff['widget']) == array( 'weight') )
                {
                    $justWeight = TRUE;
                }
            }

            if( !$justWeight ) {
                $instance['settings']['bundle_inheritance']['modified'] = TRUE;
                $instance['label'] = str_replace(" [Inherited]", "", $instance['label'] );
                field_update_instance($instance);
            }
        }
    }
}

/**
 * implementation of hook_field_delete_instance
 *
 * when an instance is deleted on an identified superclass
 * the instance have to be copied
 *
 * @param unknown $instance
 */
function bundle_inheritance_field_delete_instance ($instance)
{
    $ctrl = new BundleInheritanceController(BundleInheritanceRelation::EntityType);
    $chain = $ctrl->getChilds($instance['bundle']);
    if (! empty($chain)) {
        foreach ($chain as $bundle) {
            $existing = field_read_instance($instance['entity_type'], $instance['field_name'], $bundle);
            if (! $existing['settings']['bundle_inheritance']['modified']) {
                $newInstance = bundle_inheritance_prepare_instance($instance, $bundle);
                field_delete_instance($newInstance);
            }
        }
    }
}

/**
 * implementation of hook_module_implements_alter
 * we need to be sure that this module is the last to execute entity_info_alter
 * in order to guarantee that other modules may have filled inheritance metadata
 * from entity_info_alter
 *
 * @param array $implementations
 * @param string $hook
 */
function bundle_inheritance_module_implements_alter (&$implementations, $hook)
{
    if (in_array($hook, array(
        'entity_info_alter'
    ))) {
        // Move our hook implementation to the bottom.
        $group = $implementations['bundle_inheritance'];
        unset($implementations['bundle_inheritance']);
        $implementations['bundle_inheritance'] = $group;
    }
}


function bundle_inheritance_node_type_delete( $info )
{
    watchdog( 'bundle_inheritance', "deleted content type : ".$info->type );
    $ctrl = new BundleInheritanceController(BundleInheritanceRelation::EntityType);
    $chain = $ctrl->getInheritanceChain( $info->type );
    if( !is_null( $chain ) )
    {
        foreach( $chain as $bundle)
        {
            bundle_inheritance_break_inheritance( 'node',  $bundle, $info->type);
        }
    }
    $chain = $ctrl->getChilds( $info->type );
    if( !is_null( $chain ) )
    {
        foreach( $chain as $bundle)
        {
            bundle_inheritance_break_inheritance( 'node', $info->type, $bundle);
        }
    }
}

function array_diff_assoc_recursive($array1, $array2)
{
    $difference = NULL;
    foreach($array1 as $key => $value)
    {
        if(is_array($value))
        {
            if(!array_key_exists($key, $array2))
            {
                $difference[$key] = $value;
            }
            elseif(!is_array($array2[$key]))
            {
                $difference[$key] = $value;
            }
            else
            {
                $new_diff = array_diff_assoc_recursive($value, $array2[$key]);
                if($new_diff != FALSE)
                {
                    $difference[$key] = $new_diff;
                }
            }
        }
        elseif(!array_key_exists($key, $array2) || $array2[$key] != $value)
        {
            $difference[$key] = $value;
        }
    }
    return !isset($difference) ? 0 : $difference;
}
?>