Enhance for global entity solution

Oh, I did not see your reply. I worked on my own also a bit meantime, and got some interesting results : I created a new project today that you can test out (https://www.drupal.org/project/entity_forms_in_blocks) but we need to merge rapidly the two projects I think.

I have the solution for the dynamic block system : we need to use the derivative system , where I use entity_get_bundles to get all bundles for each entity :

/**
 * @file
 * Contains \Drupal\entity_forms_in_blocks\Plugin\Derivative\DerivativeFormBlock.
 */

namespace Drupal\entity_forms_in_blocks\Plugin\Derivative;

use Drupal\Component\Plugin\Derivative\DeriverBase;
use Drupal\Core\Plugin\Discovery\ContainerDeriverInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;


/**
 * Creates all the form block variations per entity / bundle type.
 *
 * @see \Drupal\entity_forms_in_blocks\Plugin\Block\FormBlock
 */
class FormBlock extends DeriverBase implements ContainerDeriverInterface {


  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, $base_plugin_id) {
    return new static();
  }


  /**
   * Implements DeriverInterface::getDerivativeDefinitions().
   *
   * Returns the actual list of available blocks.
   */
  public function getDerivativeDefinitions($base_plugin_definition) {
    // Get all entity types and bundles.
    $all_entity_types  = entity_get_bundles();
    // Define which entity types to create form block(s) for.
    $entity_types = array('node', 'taxonomy_term', 'user');
    // Loop across all entity types.
    foreach ($all_entity_types as $entity_type => $bundles) {
      // If it match the specified entity type defined above.
      if (array_search($entity_type, $entity_types) !== FALSE) {
        // Loop across each bundle and create a form block for it.
        foreach($bundles AS $bundle => $informations) {
          $block_id = $entity_type . '__' . $bundle;
          $this->derivatives[$block_id] = $base_plugin_definition;
          $this->derivatives[$block_id]['admin_label'] = t('@form_type form', array('@form_type' => $informations['label']));
          $this->derivatives[$block_id]['cache'] = DRUPAL_NO_CACHE;
        }
      }
    }
    return $this->derivatives;
  }
}

With that, I create one bloc for each entity form (better than having a single block I think).

Then you can use the block ID to render the right block (even if I think some more methode should be used instead of my switch above) :

/**
 * @file
 * Contains \Drupal\entity_forms_in_blocks\Plugin\Block\FormBlock.
 */

namespace Drupal\entity_forms_in_blocks\Plugin\Block;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Session\AccountInterface;
use Drupal\user\EntityOwnerInterface;


/**
 *
 * @Block(
 *   id = "entity_form_block",
 *   admin_label = @Translation("Hello !"),
 *   category = @Translation("Forms"),
 *   deriver = "\Drupal\entity_forms_in_blocks\Plugin\Derivative\FormBlock"
 * )
 */
class FormBlock extends BlockBase {
  /**
   * {@inheritdoc}
   */
  public function build() {
    // Get derivative ID.
    $block_id = $this->getDerivativeId();

    // Create a blank entity.
    $entity = $this->create_entity_per_bundle($block_id);

    // Call the form entity and return.
    // @todo : settings to define the form view mode (not just default).
    $output['form'] = \Drupal::service('entity.form_builder')->getForm($entity, 'default');
    return $output;
  }

  /**
   * Check user access to the forms.
   * {@inheritdoc}
   */
  protected function blockAccess(AccountInterface $account) {
    // Get derivative ID.
    $block_id = $this->getDerivativeId();

    // Create a void entity to test and return the right access behind.
    $entity = $this->create_entity_per_bundle($block_id);
    if( $entity->access('create')) {
      return AccessResult::allowed();
    }
    else {
      return AccessResult::forbidden();
    }
  }

  /**
   * Takes care of creating blank entities with entity-type specificities.
   */
  protected function create_entity_per_bundle($block_id) {

    // Get entity type and bundle from block ID.
    $entity_type = $this->get_entity_type($block_id);
    $entity_bundle = $this->get_entity_bundle($block_id);

    // Initialize entity default values as it may be different depending
    // on entity type, especially for the bundle definition (compulsory).
    // @todo : add contact forms and others (entityforms, eck...).
    $args = array();
    switch($entity_type) {
      // Case of node types
      case 'node':
        $args['type'] = $entity_bundle;
        break;
      // Case of taxonomy term creation
      case 'taxonomy_term':
        $args['vid'] = $entity_bundle;
        break;
    }

    return entity_create($entity_type, $args);
  }

  /**
   * Returns entity type from the block ID.
   *
   */
  function get_entity_type($block_id) {
    // Get entity type and associated bundle.
    $explode = explode('__', $block_id);
    return $explode[0];
  }

  /**
   * Returns entity bundle from the block ID.
   */
  function get_entity_bundle($block_id) {
    // Get entity type and associated bundle.
    $explode = explode('__', $block_id);
    return $explode[1];
  }

}

Pretty straightforward and amazingly simple compared to D7 !

Well I studied a bit your code and I must say that the config solution is more elegant with the ability of D8 to add as many block as needed.

Important change : we now need to change the access part by using use Drupal\Core\Access\AccessResult;

  /**
   * Implements \Drupal\block\BlockBase::blockAccess().
   */
  public function blockAccess(AccountInterface $account) {
    $access_control_handler = $this->entityManager->getAccessControlHandler($this->configuration['entity_type']);
    if($access_control_handler->createAccess($this->configuration['bundle'], $account)) {
      return AccessResult::allowed();
    }
    else {
      return AccessResult::forbidden();
    }
  }

There is another issue : the cache of the block is not functionnal (once submitted, the form expires). We may cache per user only I think. For now we can specify no cache :

  /**
   * {@inheritdoc}
   *
   */
  public function getCacheMaxAge() {
    return 0;
  }

Could you release it as a dev version so that the whole community can elaborate on this ?

We've released a new version for the module with part of your code (see last dev version of https://www.drupal.org/project/entity_forms_in_blocks). We replaced the "operation" part that does not seem to have real interest and replace it with the form mode for any entity.

There are still some work remaining of course ! Some entity forms not working (especially comment forms).

Of course, if you wanna merge it into FormBlock you're welcome and we can put Entity Forms in Blocks as obsolete.

Regards.