Call Us Today! (443) 500-7624
Drupal is a great content management system, that everyone should use to build their systems. In today’s article we are going to talk about another Drupal concept which we need to delve a bit deeper, this concept is known as modules. If you would like your site to be more dynamic, by adding new features and extending Drupal core, then you’d need to know what a module is and know how to use and develop them.
Developers can also alter existing functionality developed a website, which meet the requirements of stakeholders, by only using the features of Drupal that they need. Community-contributed modules are available to any developer, who wish to fulfil a certain specific purpose.
Developers must know what they need, and determine the functionality they are looking to fulfill, to know how to locate, install and evaluate existing modules, which is a huge part of learning Drupal. When necessary new modules can be created, by writing PHP, HTML, CSS and JavaScript code. Solving specific project requirements, requires a developer to use a module, which contain custom features or alter existing features.
Custom modules are types of modules, that usually reside in the /modules/custom directory, they are project-specific, and written for a specific application. Contributed modules are another type of modules, found and downloaded from Drupal.org, these modules are placed in the /modules/contrib directory and are not part of Drupal core.
Another type of modules are core modules, these modules are found in the /core/modules/ directory and are part of Drupal core. During the development of a module, it is a very good idea to understand how to secure, and keep the code updated, so that the website does not suffer, from security vulneraries and is always up to date.
Another thing to remember when writing code to develop a custom module, is to adhere to Drupal’s coding standards.
It is important to understand what coding standards are and why they are important to follow, to write code. The set of rules designed for programmers, which define best practices, code formatting and various other rules, is known as coding standards. Following coding standards, can help programmers on a team, to be able to follow and understand each other’s code, because everyone would have to follow the same conventions.
Developers learn how to style and format their code, by following code standards, which define how the code will be read and how it will look. Indentation, whitespace and line length are all part of the style coding standards of Drupal. The whole Drupal project has a sense of coherence, when developers across the globe, using Drupal adhere to the same coding standards.
Setting up expectations on how code should look, is a good thing, and makes coding standards very important. It is essential in a community like Drupal, for developers to follow coding standards, because developers around the world, can read, maintain and modify each other’s code. Drupal’s codebase can also stay consistent, when there are concrete coding standards, to follow.
Another important part of code standards is substance, which has information about the content and standard of your code. The use of various functions and components in your code, is very important according to substance coding standards
Thank you for reading this article!!!
\Drupal\Component\Plugin\PluginManagerInterface,Implements all plugin managers, and this piece of code extends these three pieces of code, which are the basis for any new plugin manager.
\Drupal\Component\Plugin\Discovery\DiscoveryInterface, \Drupal\Component\Plugin\Factory\FactoryInterface and, \Drupal\Component\Plugin\Mapper\MapperInterface.The plugin.manager.* a piece of code is used to generate plugin manager services and from the service container, a copy of the plugin manager can be requested. Example:
$example_manager = \Drupal::service('plugin.manager.example');Once a developer has identified the plugin manager needed, to complete a task, then that developer has to start, by locating the name of the plugin manager service he/she needs. The controller will be the place where, a developer can inject their plugin manager services, and this is the Drupal way of doing things. The code below is a controller file, located under custom_module/src/Controller, it is very important that you get those names and file directory correct, for Drupal to recognize your controller and plugin.
<?php namespace Drupal\plugin_type_example\Controller; use Drupal\Core\Controller\ControllerBase; use Drupal\plugin_type_example\SandwichPluginManager; use Symfony\Component\DependencyInjection\ContainerInterface; /** * Controller for our example pages. */ class PluginTypeExampleController extends ControllerBase { /** * The sandwich plugin manager. * * We use this to get all of the sandwich plugins. * * @var \Drupal\plugin_type_example\SandwichPluginManager */ protected $sandwichManager; /** * Constructor. * * @param \Drupal\plugin_type_example\SandwichPluginManager $sandwich_manager * The sandwich plugin manager service. We're injecting this service so that * we can use it to access the sandwich plugins. */ public function __construct(SandwichPluginManager $sandwich_manager) { $this->sandwichManager = $sandwich_manager; } /** * {@inheritdoc} * * Override the parent method so that we can inject our sandwich plugin * manager service into the controller. * * For more about how dependency injection works read https://www.drupal.org/node/2133171 */ public static function create(ContainerInterface $container) { // Inject the plugin.manager.sandwich service that represents our plugin // manager as defined in the plugin_type_example.services.yml file. return new static($container->get('plugin.manager.sandwich')); } }All defined plugins have information that can aid our application development to move forward faster. All that information from defined plugins is available to developers when they can make calls to the getDefinitions method. Enabled modules, can be used to locate all plugin definitions of the type in question, through the discovery handler . When the discovery handler is not used to retrieve data, then the DefaultPluginManager is used to retrieve the data from the cache if the data is available there. A good example of is in the code below, watch how the definitions of a plugin can be obtained in the code.
// Get the list of all the sandwich plugins defined on the system from the // plugin manager. Note that at this point, what we have is *definitions* of // plugins, not the plugins themselves. $sandwich_plugin_definitions = $this->sandwichManager->getDefinitions(); // Let's output a list of the plugin definitions we now have. $items = array(); foreach ($sandwich_plugin_definitions as $sandwich_plugin_definition) { // Here we use various properties from the plugin definition. These values // are defined in the annotation at the top of the plugin class: see // \Drupal\plugin_type_example\Plugin\Sandwich\ExampleHamSandwich. $items[] = t("@id (calories: @calories, description: @description )", array( '@id' => $sandwich_plugin_definition['id'], '@calories' => $sandwich_plugin_definition['calories'], '@description' => $sandwich_plugin_definition['description'], )); } // Add our list to the render array. $build['plugin_definitions'] = array( '#theme' => 'item_list', '#title' => 'Sandwich plugin definitions', '#items' => $items, );When a list of plugin types is desired by a developer he/she may want to use the method above to accomplish this task. The unique ID of a plugin can be utilized in order to retrieve the definition of the plugin in question, calling the getDefinition($plugin_id) method. // If we want just a single plugin definition, we can use getDefinition(). // This requires us to know the ID of the plugin we want. This is set in the // annotation on the plugin class: see \Drupal\plugin_type_example\Plugin\Sandwich\ExampleHamSandwich. $ham_sandwich_plugin_definition = $this->sandwichManager->getDefinition('meatball_sandwich'); In order to instantiate and use an individual plugin object, the createInstance($plugin_id) method can be used. It is not good practice to instantiate a plugin object directly, instead, the plugin manager should be used to do so. Understanding how instances of a plugin are created requires that you see it in action, in the code below.
// To get an instance of a plugin, we call createInstance() on the plugin // manager, passing the ID of the plugin we want to load. Let's output a // list of the plugins by loading an instance of each plugin definition and // collecting the description from each. $items = array(); // The array of plugin definitions is keyed by plugin id, so we can just use // that to load our plugin instances. $sandwich_plugin_definitions = $this->sandwichManager->getDefinitions(); foreach ($sandwich_plugin_definitions as $plugin_id => $sandwich_plugin_definition) { // We now have a plugin instance. From here on it can be treated just as // any other object; have its properties examined, methods called, etc. $plugin = $this->sandwichManager->createInstance($plugin_id); $items[] = $plugin->description(); }All the code on this tutorial was taken from Drupalize.me. Thank you for reading this article!!!
Phone: (443) 500-7624
Email: admin@kinginfolife.com
Address: Baltimore, MD 21206
All Rights Reserved | KING INFO LIFE