Media Expire

New Drupal Modules - 10 October 2016 - 11:40pm

This module enables you to unpublish your media entites automatically by setting an expire field.


  • "Activate media expire" on admin/structure/media/manage/{media}
  • Specify an expire field
  • Optionally: You are able to provide a fallback entity for unpublished entities

Drupal checks on every cron-run if there are expired media elements. Additionally you can use "drush media-expire-check" for a manually check

Categories: Drupal

Hook Event Dispatcher

New Drupal Modules - 10 October 2016 - 10:20pm

This module registers event dispatchers for several drupal core hooks. This allows you to use the D8 Event Subscriber system instead of the outdated hook system to react on certain events. The module includes event dispatchers for the most common hooks for the entity api

Currently this module contains dispatchers for

Categories: Drupal

Palantir: Top 5 Takeaways From Dublin DrupalCon

Planet Drupal - 10 October 2016 - 6:55pm
Top 5 Takeaways From Dublin DrupalCon brandt Mon, 10/10/2016 - 20:55 Alex Brandt Oct 11, 2016

Dublin DrupalCon: Community, Sessions, Guinness, and Toast.

In this post we will cover...
  • What we learned in Dublin

  • Some of our favorite events

  • Why we’ll be back next time

Stay connected with the latest news on web strategy, design, and development.

Sign up for our newsletter.

We’ve settled back into our routines, but we are still left with the warm afterglow of another DrupalCon. Palantir’s Tiffany Farriss, George DeMet, Ken Rickard, and Avi Schwab reflect on their time in Dublin and share their thoughts on what makes DrupalCon so special in our top 5 takeaways.

5.) The Drupal community is bright and ambitious.

  • Avi: I’ve been working as a FED on projects lately. This DrupalCon gave me a great opportunity to reinforce and grow my existing Twig knowledge, now that I have some real places to apply the skills. The trio of “Branch out of your comfort zone…”, “Drupal 8 Theming In Depth”, and “21 Things I Learned…” is enough to get anyone from zero to Twig hero in no time.
  • George: I was only at DrupalCon for a couple of days, but during that time I had a lot of great conversations with people in the community. I heard a lot of great ideas for how we can help make Drupal contribution more sustainable, and how we can make it easier for more people to engage with the project and the community in different ways.
  • Tif: Of late, I’ve been thinking about how Drupal can better communicate its community values and expectations at the organizational level (to and among the business ecosystem). Central to that is the question: what does it mean to be a good Drupal citizen whether you’re an individual, an organization or an end user of Drupal? I had some excellent conversations around that topic and am excited about the possibilities for recognizing all of the wonderful work that already happens within the community as a way to communicate and reinforce our community values.

4.) There’s always something to look forward to.

  • Avi: The Drupal Association team always works hard to put on a great event, but I feel like Dublin went more smoothly from a logistical standpoint than any DrupalCon I’ve been to. The venue staff assisted the volunteers at a phenomenal level, the venue itself was amazing, and the food was great.
  • Tif: I love reconnecting with old friends and making some new ones, and having thought-provoking conversations (especially with Kristof Van-Tomme, my friend and CEO of Pronovix).
  • Ken: DrupalCon is a great combination for me, in that I can always expect to run into old friends, and I am also guaranteed to meet new contributors. That makes it a special event.

3.) Yet, we’re always pleasantly surprised with what’s different.

  • George: Now that Drupal 8 has been out for some time and people are building sites with it, this DrupalCon felt more focused on the community. The new Being Human session track in particular had a lot of great content aimed at helping people learn how to contribute in a healthy way while also supporting others.
  • Avi: I’ve gone through some personal changes since NOLA, but for me Dublin felt much more like DrupalCons from our pre-D8 days, where developers dug into the hard problems and worked to share their solutions. It’s refreshing to be back in that seat both personally and as a community. D8 is moving along well and now has the confidence of most folks in the community, and we’re really putting it to work.
  • Tif: It’s remarkable how much the Drupal community has matured and expanded since my first DrupalCon Europe in Szeged in 2008.

2.) The sessions and events only reinforce how special the Drupal community is.

  • George: I very much appreciated Dries’ focus in his keynote on the core values and purpose (http://buytaert.net/drupal-collective-purpose) of the Drupal project and community, which set a really great tone for the event. Being able to see and hear how Drupal has made a positive difference in the lives of people all over the world was particularly inspiring.
  • Avi: After a few years of doing more PM work and less development, it was great to come back to Con and be able to absorb so much incredible knowledge from such great people. I also really enjoyed the Tuesday night party on the Cill Airne — too often our socializing is overpowered by loud music and tight spaces, but having a night outside, with a good bar and good folks, but not so much screaming, was greatly appreciated.
  • Tif: I always enjoy the Driesnote. Dries’ expanded purpose for the project (that Drupal is as much about people and impact as it is about code) resonates with me and affirms that Drupal continues to be aligned with Palantir’s purpose and values.
  • Ken: I went to Tim Millwood's session on the Workflow Initiative. That's the Drupal 8 core project that includes moving Workbench Moderation into core as Content Moderation. In many ways, it's the culmination of work that we started at the end of the Drupal 6 development cycle, so it's very rewarding to see the progress being made today.

1.) It wouldn’t be DrupalCon without a few shenanigans.

  • Avi: At the boat party, upon learning that I was a Palantiri, an Irish admirer of his began expounding on Mr. Ken Rickard’s amazing, deep, Hollywood-like voice and how, despite Ken’s contextual configuration talk being incredibly interesting, just listening to the words come from Ken’s mouth made it that much better.
  • Tif: I got Angie (webchick) to try Guinness: https://twitter.com/gdemet/status/780865264598523905.
  • Ken: We shared an apartment with Avi’s family. Avi's daughter Calliope tried to put buttered toast into everyone's pockets at the breakfast table every single morning. (I guess to save for later.) Which led to the viral quote. "No, you can't put toast in my pockets. I don't have any pockets."

We want to make your project a success.

Let's Chat.
Categories: Drupal

Views Contextual Filter Custom Function

New Drupal Modules - 10 October 2016 - 5:54pm
Declare custom functions to pick within contextual filters, easily.

Creating a custom contextual plugin filter can be a bit painful as you need to ensure all namespacing is done perfectly. This creates an undue barrier to entry in a place that can really increase the value of Views in general. Gaining ad hoc control of filter values is a common scenario, and creating focused value obtaining function helps keep concerns separate and improve testability.

Register your custom function via info hook.

Categories: Drupal

CSSGram - Recreating Instagram Filters

New Drupal Modules - 10 October 2016 - 5:47pm

CSSGram is a simple module to apply CSS filters on image field type using field formatters for recreating Instagram filters with CSS filters and blend modes.

CSSGram Module uses CSSGram library for adding filter effects via CSS to the image fields. Basically, module extends Field Formatter Settings to add image filter for that particular field.

To configure image filters for a field, visit Manage Display settings and use format column to specify the filter to be used for that image.

Categories: Drupal

Nacho Digital: Assisting to Drupalcon Dublin 2016

Planet Drupal - 10 October 2016 - 4:25pm
I had the opportunity to assist to Drupalcon Dublin 2016. Some insights and highlights on sessions I assisted on this Drupalcon.

Dublin is a lovely city, very international and The Convention Centre Dublin was an excellent location. Dries keynote was less enterprise oriented than others and helps to understand where he wants to take Drupal8. The most interesting thing for me is to see how the new life cycle of D8 roll-out is. There was more about D8 new development cycle on the session "Drupal 8's rapid innovation promises".

Categories: Drupal

SimpleSAML Runtime Config

New Drupal Modules - 10 October 2016 - 2:49pm
Categories: Drupal

OSTraining: How to Set Up Dropdown Menus in Drupal 8

Planet Drupal - 10 October 2016 - 2:46pm

A few years ago, we published a very popular post called "How to Create Dropdown Menus in Drupal".

That post covers many of the basic points that have not changed in Drupal 8, including these:

  • Many themes don't have dropdown menus built-in. That includes Drupal's core themes, such as Bartik.
  • It is best to choose a theme that does already have dropdowns available.
  • You need to go to Structure > Block layout and make sure your menu is placed in the correct block region.
  • You need to go to Structure > Menus and make sure your menus links are indented.  
Categories: Drupal

myDropWizard.com: Top 5 (In My Opinion) Drupal Blogs for Agencies

Planet Drupal - 10 October 2016 - 1:51pm

Drupal is open source sofware. Thousands of contributors help build it, but of similar importance is the marketing and education wing of the Drupal Community. Drupal Twitter accounts, Drupal podcasts, and today's topic: Drupal Blogs.

There are many, many blogs that are of importance to various aspects of Drupaling. My criteria are really just my own non-authoritative views. Please feel free to Tweet me, Facebook me, or throw in your own ideas in the comments below!

Categories: Drupal

OSTraining: How to Use the Breeze Theme in Drupal 8

Planet Drupal - 10 October 2016 - 1:33pm

Breeze is a design that we make available as a Joomla template and a WordPress theme. Now, finally, it's available as a Drupal 8 theme!

We use Breeze as an example in many of our video classes and books.

By using the same design, it makes it easy for OSTraining members to see differences and similarities between the various platforms.

Breeze is fully responsive and uses the Bootstrap framework.

Categories: Drupal

Drupalize.Me: Catching the Spirit of Open Hardware

Planet Drupal - 10 October 2016 - 12:52pm

Drupalize.Me trainer Amber Matz attended this year's Open Hardware Summit in Portland and reports back on what she took away from the event.

Categories: Drupal

Migrate Spreadsheet

New Drupal Modules - 10 October 2016 - 12:32pm

The module provides a migrate source plugin for importing data from spreadsheet files. This source plugin uses the PhpOffice/PhpSpreadsheet library to read from the spreadsheet files.

The supported source files includes .ods, .xls, .xlsx, .csv.

How to use it?

In the migration file add the plugin provided by this module:

Categories: Drupal

The Sego Blog: Testing Software - A Quick Overview

Planet Drupal - 10 October 2016 - 12:28pm
10/10/2016Testing Software - A Quick Overview

Software is an ever changing interweaving of collections of ideas expressed in code to solve various problems. In today's day an age the problems that software is solving is expanding at an ever increasing rate.

Categories: Drupal

Commerce ECPay

New Drupal Modules - 10 October 2016 - 11:28am

Provides integration between Drupal Commerce and ECPay’s payment solutions.
ECPay offers two API modes, on-site and off-site. This module aims to provide the on-site integration, i.e. executing payments without having to redirect the user to external URLs. The entire checkout and payment process is completed within your Drupal site.
Currently supported payment methods:

Categories: Drupal

Palantir: Palantir.net's Guide to Digital Governance: Ownership

Planet Drupal - 10 October 2016 - 10:37am
Palantir.net's Guide to Digital Governance: Ownership Palantir.net's Guide to Digital Governance brandt Mon, 10/10/2016 - 12:37 Scott DiPerna Oct 10, 2016

This is the third installment of Palantir.net’s Guide to Digital Governance, a comprehensive guide intended to help get you started when developing a governance plan for your institution’s digital communications.

In this post we will cover...
  • Why ownership is the cornerstone of good governance
  • What ownership entails
  • How to manage instances of shared or collaborative ownership 

Stay connected with the latest news on web strategy, design, and development.

Sign up for our newsletter.

Now that we have defined all of the digital properties and platforms that we will consider for our Governance Plan, we next need to establish who “owns,” or who will ultimately be responsible for the care, maintenance, and accuracy, of these properties.

Ownership is the cornerstone of good governance. In fact, some may think of ownership as being synonymous with governance. From my experience, I believe that good governance of any digital communications platform involves more than simply defining who is responsible for each piece.

In most organizations, many people are using, sharing, and collaborating on the same systems together. The processes and interactions between those users needs to be defined as well, however we have to identify the people before the process. Defining ownership first is the foundation on which we can begin to define the more complex relationships that exist in a shared system.

Ownership is the cornerstone of good governance…. Defining ownership first is the foundation on which we can begin to define the more complex relationships that exist in a shared system.

I should make one other important distinction between maintenance of the system and the maintenance of the presentation of content, as it relates to ownership.

Since this Governance Plan is considering the guidelines for digital communications, it is explicitly NOT considering the roles, policies, and procedures for the maintenance of the infrastructure that supports the properties and platforms we are considering for the plan.

In other words, when we define who has ownership of the public website or the intranet, we are considering only the content and its presentation – not the underlying software and hardware that makes the website or intranet functional.

Perhaps this is obvious, but it is an important distinction to make for those who are less familiar with modern web technology, who may not fully understand where the functions of an IT department end and an Online Marketing or Communications department begin.

With those caveats out of the way, we can now begin to define who is responsible for each of the properties and platforms we listed earlier.

Obviously, I can’t tell you who is or who should be responsible for each piece within your organization – that must be defined by how your work responsibilities are distributed across the institution – but I can describe some general principles for defining ownership that should help.

  • Ownership of your organization’s web presences ultimately should reside at the very top, with levels of responsibility being delegated down the hierarchy of the institution.
  • The top leadership of an organization should be responsible ultimately for the accuracy and maintenance of the content contained within the parts of the properties they own.
  • Every website, subsite, microsite, department site; every section and sub-section; every page, aggregated listing, and piece of content all the way down to each video, photo, paragraph, headline, and caption should fall within the ownership of someone at the top.
  • Responsibility for daily oversight and hands-on maintenance of those properties then may be delegated to staff within the owner’s groups, offices, or areas of responsibility.
  • Owners should have sufficiently trained staff who have the authority and capacity to make changes, corrections, and updates to the content as needed in a timely manner, such that inaccurate and/or outdated content does not remain on the property for an unreasonable period of time.

In short, ownership has two essential aspects:

  1. top-level responsibility for the accuracy and efficacy of the content, and
  2. hands-on responsibility for the creation and maintenance of the content.

Both are essential and required for good governance, and very likely may be responsibilities held by one person, split between two, or shared among a group.

Shared Ownership / Responsibility

There may be instances in which shared ownership may be necessary. I generally recommend against doing that as it puts at risk a clear chain of accountability. If two people are responsible, it’s easy for both to think the other person is handling it.

If some form of shared ownership is required, consider having one person be the primary owner, who is supported by a secondary owner when needed; or that a primary owner is a decision-maker, but secondary owner(s) are consulted or informed of issues and pending decisions.

If “equally” shared ownership or responsibility is required, try defining the exact responsibilities that are to be owned and dividing them logically between the two. Perhaps there is a logical separation of pages or sections. Or maybe one person is responsible for copy, while another is responsible for images.

Shared ownership is less-than-ideal, but there can be reasonable ways to make it work, provided you do not create any structural gaps in authority, unwittingly.


There are many instances in digital communications where groups of people collaborate to produce content. This is most common with organizational news and events, publications, blogs, social media, etc.

For example, if there is a single person who can be ultimately responsible for all blog content created by various content creators, great! If blog content is created by subject-matter experts from different fields or different parts of the organization, perhaps it is possible to invest ownership in one person for all of the blog posts within a specific subject for each field.

If you are in a situation similar to what I described above, where you have multiple, subject-specific owners, it will probably make sense for all of the owners to meet regularly to agree on standards and best-practices for all contributors to follow.

In the end, the fundamental concept here is to place responsibility for all content and every part of a digital property with the people who are in the best position to manage it and ensure its quality, accuracy, pertinence, and value.


This post is part of a larger series of posts, which make up a Guide to Digital Governance Planning. The sections follow a specific order intended to help you start at a high-level of thinking and then focus on greater and greater levels of detail. The sections of the guide are as follows:

  1. Starting at the 10,000ft View – Define the digital ecosystem your governance planning will encompass.
  2. Properties and Platforms – Define all the sites, applications and tools that live in your digital ecosystem.
  3. Ownership – Consider who ultimately owns and is responsible for each site, application and tool.
  4. Intended Use – Establish the fundamental purpose for the use of each site, application and tool.
  5. Roles and Permissions – Define who should be able to do what in each system.
  6. Content – Understand how ownership and permissions should apply to content.
  7. Organization – Establish how the content in your digital properties should be organized and structured.
  8. URLs – Define how URL patterns should be structured in your websites.
  9. Design – Determine who owns and is responsible for the many aspects design plays in digital communications and properties.
  10. Personal Websites – Consider the relationship your organization should have with personal websites of members of your organization.
  11. Private Websites, Intranets and Portals – Determine the policies that should govern site which are not available to the public.
  12. Web-Based Applications – Consider use and ownership of web-based tools and applications.
  13. E-Commerce – Determine the role of e-commerce in your website.
  14. Broadcast Email – Establish guidelines for the use of broadcast email to constituents and customers.
  15. Social Media – Set standards for the establishment and use of social media tools within the organization.
  16. Digital Communications Governance – Keep the guidelines you create updated and relevant.

We want to make your project a success.

Let's Chat.
Categories: Drupal

Commerce Pay2go

New Drupal Modules - 10 October 2016 - 8:56am

Provides integration between Drupal Commerce module and Pay2go’s payment solutions.
Currently supported payment methods:

Categories: Drupal


New Drupal Modules - 10 October 2016 - 8:02am

Provides integration between the Payment module and Pay2go’s payment solutions.
Currently supported payment methods:

  • Credit card (under development)
  • WebATM (under development)
  • ATM virtual account
  • Convenience store kiosk
  • Convenience store barcode

The development of this module is not sponsored by Pay2go, and the developers are in no way affiliated with Pay2go.

Categories: Drupal

Matt Glaman: Managing Your Drupal Project with Composer

Planet Drupal - 10 October 2016 - 6:15am

Drupal Commerce was started without writing any Drupal code. Our libraries set Drupal Commerce off the island before Drupal was able to support using third party library not provided by core.

Drupal now ships without third party libraries committed, fully using Composer for managing outside dependencies. However, that does not mean the community and core developers have everything figured out, quite yet.

YNACP: Yet Another Composer Post. Yes. Because as a co-maintainer of Drupal Commerce we're experiencing quite a lot of issue queue frustration. I also want to make the case of "let's make life eaiser" for working with Drupal. As you read compare the manual sans-Composer process for local development and remote deployment versus the Composer flows.

Before we begin

We're going to be discussing Composer. There's specific terminologies I'll cover first.

  • composer.json: defines metadata about the project and dependencies for the project.
  • composer.lock: metadata file containing computed information about dependencies and expected install state.
  • composer install: downloads and installs dependencies, also builds the class autoloader. If a .lock file is available it will install based off of the metadata. Otherwise it will calculated and resolve the download information for dependencies.
  • composer update: updates defined dependencies and rebuilds the lock file.
  • composer require: adds a new dependency, updates the JSON and .lock file.
  • composer remove: removes a dependency, updates the JSON and .lock file.

All Composer commands need to run in the same directory as your composer.json file.

Installing Drupal

There are multiple ways to install Drupal. This article focuses on working with Composer, for general installation help review the official documentation at https://www.drupal.org/docs/8/install

Install from packaged archive

Drupal.org has a packaging system which provides zip and tar archives. These archives come with all third party dependencies downloaded.

You download the archive, extract the contents and have an installable Drupal instance. The extracted contents will contain the vendor directory and a composer.lock file.

Install via Composer template

A community initiative was started to provide a Composer optimized project installation for Drupal. The  project provided a version of Drupal core which could be installed via Composer and a mirror of Drupal.org projects via a Composer endpoint (This has been deprecated in favor of the Drupal.org endpoint).

To get started you run the create-project command. 

composer create-project drupal-composer/drupal-project:8.x-dev some-dir --stability dev --no-interaction

This will create some-dir folder which holds the vendor directory and a web root directory (Drupal.) This will allow you to install Drupal within a subdirectory of the project, which is a common application structure.

This also keeps your third party libraries out of access from your web server.

Review the repository for documentation on how to use the project, including adding and updating core/projects: https://github.com/drupal-composer/drupal-project.

Adding dependencies to Drupal Without Composer

Modules, themes, and profiles are added to Drupal my placing them in a specific directory. This can be done by visiting Drupal.org, downloading the packaged archive and extracting it to the proper location.

There's a problem with this process: it's manual and does not ensure any of the project's dependencies were downloaded. Luckily Composer is a package and dependency manager!

With Composer

To add a dependency we use the composer require command. This will mark the dependency, download any of its own. 

Note if you did not use project base: Currently there is no out of the box way to add Drupal.org projects to a standard Drupal installation. You will need to run a command to the endpoint.

composer config repositories.drupal composer https://packages.drupal.org/8

Let's use the Panels module as an example. Running the following command would add it to your Drupal project.

composer require drupal/panels

This will install the latest stable version of the Paragraphs version. If you inspect your composer.json file you should see something like the following

"require": { "drupal/panels": "3.0-beta4", }

One of the key components is the version specification. This tells Composer what version it can install, and how it can update.

  • 3.0 will be considered a specific version and never update.
  • ~3.0 will consider any patch version as a possible installation option, such as new betas, RCs.
  • ~3 will allow any minor releases to be considered for install or update.
  • ^3.0 will match anything under the major release — allowing any minor or patch release.

You can specify version constraints when adding a dependency as well. This way you can define of you will allow minor or patch updates when updating.

composer require drupal/panels:~3.0

This will allow versions 3.0-beta5,3.0-rc1, 3.0 to be valid update versions.

Know what! The same versioning patterns exist in NPM and other package managers.

Updating dependencies Without Composer

As stated with installing dependencies, it could be done manually. But this requires knowing if any additional dependencies need to be updated. In fact, this is becoming a common issue in the Drupal.org issue queues.

With Composer

Again, this is where Composer is utilized and simplifies package management.

Going from our previous example, let's say that Paragraphs has a new patch release. We want to update it. We would run

composer update drupal/panels --with-dependencies

This will update our Drupal project and any of its dependencies. Why is this important? What if Paragraphs required the newest version of Entity Reference Revisions for a critical fix? Without a package manager, we would have not known or possibly updated.

Why we need --with-dependencies

When Composer updates a dependency, it does not automatically update its dependencies. Why? No idea, apparently the maintainers do not believe it should.

Updating Drupal core Without the Composer template

If you installed Drupal through the normal process, via an extracted archive, you have to manually update in the same fashion. You will need to remove all files provided by Drupal core — *including your possibly modified composer.json file*.

Rightly so, you can move your modified .htaccess, composer.json, or robots.txt and move them back. However, you’ll need to make sure your composer.json matches the current Drupal core’s requirements and run composer update.

That’s difficult.

The official documentation: https://www.drupal.org/docs/7/updating-your-drupal-site/update-procedure...

Updating Drupal core via the Composer template

If you have setup Drupal with the Composer template or any Composer based workflow, all you need to do is run the following command (assuming you’ve tagged the drupal/core dependency as ^8.x.x or ~8, ~8.1, ~8.2)

composer update drupal/core --with-dependencies

This will update Drupal core and its files alongside the drupal-composer/drupal-scaffold project.

Using patches with Composer

I have been a fan of using build tools with Drupal, specifically  using . However, when I first used Composer I was concerned on how to use patches or pull requests not yet merged with the project — without maintaining some kind of fork.

 create the   project. This will apply patches to your dependencies. The project’s README fully documents its use, so I’ll cover it quickly here.

Patches are stored in a patches portion of the extra schema of the JSON file.

"extra": { "patches": { "drupal/commerce”: { "#2805625: Add a new service to manage the product variation rendering": "https://www.drupal.org/files/issues/add_a_new_service_to-2805625-4.patch" } } }

This patches Drupal Commerce with a specific patch. 

Using GitHub PRs as a patch

Patches are great, as they let you use uncommitted functionality immediately. A problem can arise when you need code from a GitHub pull request (or so it seems.) For instance, Drupal Commerce is developed on GitHub since DrupalCI doesn’t support Composer and contributed projects yet.

Luckily we can take the PR for the issue used in the example https://github.com/drupalcommerce/commerce/pull/511 and add .patch to it to retrieve a patch file: https://github.com/drupalcommerce/commerce/pull/511.patch

We could then update our composer.json to use the pull request’s patch URL and always have up to date versions o the patch.

"extra": { "patches": { "drupal/commerce”: { "#2805625: Add a new service to manage the product variation rendering": "https://www.drupal.org/files/issues/add_a_new_service_to-2805625-4.patch" } } }
Categories: Drupal

Pantheon Blog: Turn on Twig Debug Mode in Drupal 8 on Pantheon

Planet Drupal - 10 October 2016 - 6:00am
When working on Drupal 8 theming, it is very helpful to have Twig debug mode on. Debug mode will cause twig to emit a lot of interesting information about which template generated each part of the page. The instructions for enabling debug mode can be found within the comments of the default.services.yml file, among other sources. In short, all you need is the following in your services.yml file:  
Categories: Drupal

Commerce Mangopay

New Drupal Modules - 10 October 2016 - 5:20am

Commerce Mangopay integrates Mangopay with Drupal Commerce 2.x payment

Categories: Drupal


Subscribe to As If Productions aggregator - Drupal