Planet Drupal

Often times it is needed to create module specific custom tables to store persistent data. Drupal offers a set of hooks in connection to this. Most commonly used among these are hook_schema() and hook_update_N(). First hook, hook_schema() holds the structure of table in the form of PHP array.

Google Plus One Linkedin Share Button Tweet Widget Facebook Like

Here's a quick video recap from Drupalcon Portland - Wednesday May 22nd. If you missed yesterday's recap, you can watch it here. 

Episode Number:  141 Post Topics:  Django Contrib Drupal Commerce Drupal 7 Site Building Drupal Planet

In this episode we continue learning about Drupal Commerce and dive into some of the layout aspects of building out Drupal Commerce product displays.

In this episode you will learn:

• How to modify the layout of a Drupal Commerce product display
• How fields are used to control the Drupal Commerce product display layout

DDoD Video: 

This Drupalcon has in many respects been about winning the hearts of the user: There's a constant UX track installed for the first time at a Drupalcon; Dries has used his keynote to talk about the importance of improving the web experience management (with some UXy slides!), UX expert Karen McGrane was invited to give today's keynote on the subject of multi-device content.

Her point: Lots of the tools that we build give the user the illusion that the web is print. Instead of using WYSIWYG and other (misleading) instruments, users should be able to add metadata with longer legs, making content multi channel capable. And if there's just one thing you want to watch today: Chris Blow's magically athwart presentation on Design Ops:

Here is one more conversation I had at Drupal Camp Alpe-Adria in April, 2013. Ranko Marinic is from Croatia and has some great perspectives. He works as an IT consultant with a wide range of technologies and with Drupal "by night". He is studying economics and has become interested in the economic effects on local communities of implementing open source software. Ranko also talks about the moment he really started believing in open source as a social movement.

ranko_final.mp3

Just a quick note that the St. Louis Drupal Users group chose to reschedule our normal meetup, which occurs every third Thursday of the month, to next week, the week after Drupalcon Portland. Last year, we had a meetup right after Drupalcon Denver and had a great turn out. Those who weren't able to attend learned what it's like to attend Drupalcon, and also got valuable insight into the sessions, keynotes, and other events surrounding this great event. This year, we have at least a few known members who are here at Drupalcon (along with myself for the first time), who will be sharing their experience with the group at next week's meetup.

So if you live in or around the St. Louis area, or know someone who does, please be sure to join us this Thursday, from 7p-9p at the Missouri History Musuem (more details about the meetup can be found here).

Tags

• drupal-planet
• drupalcon
• drupalcon2013
• meetups

Hey, that's not what I was thinking!

That's a very common complaint customers have with developers, when they receive the result of weeks or months of hard work. And it indicates a failure of planning.

We've found nothing that works better to avoid this result than to write up and discuss user stories in detail.

What's a user story? It's a description of the process a person goes through to get a specific result, and what happens along the way.

Tags: Drupal PlanetProcessUser StoriesUMLQualityIndustry: BusinessE-CommerceEducationHealth CareSoftwareStory Type: Sustainable/Open Business

Mike Gifford is President of OpenConcept Consulting Inc. and co-founder of Open Source Alliance of Canada.

 

Personal blog tags: Drupalcrowd fundingDrupal 8

Here comes the rain! DrupalCon Portland welcomes our attendees to Day 2, with breakfast sandwiches (look for the big black truck across the street from the Oregon Convention Center) and of course, cold and dreary Portland rain. Grab a Drupal branded hoodie and KeepCup from the DrupalCon bookstore (in room C121) to keep warm between sessions and so fellow Drupalers can spot you when running around the city later this week completing missions from our Photo Scavenger Hunt.

I'm sure the sentence 'There is nothing impossible in Drupal' is not something unfamiliar for your ears. This blog post is a proof of this statement. Here we, the Propeople Drupal Digital Agency team, will make an overview of the Organic Groups module, another useful and powerful module that is appreciated by many Drupal users and developers.

First of all: OG – what is this all about? I think the best example would be Facebook Groups. Have you heard about Facebook Groups? I bet you have. In most of the cases Organic Groups are similar. Creating groups – public or private, inviting members, posting content, commenting it. These sets of features are in the core of Facebook groups as well as in Organic Groups.

By using Organic Groups we can build an entire community platform similar to a forum, but with more social networking features such as notifications and connection between members. We also have advanced access management via roles and permissions, and the flexibility to create various types of content. On the project page we can see a list of websites that use Organic Groups, quite a few big names can be spotted.

Before creating an Organic Groups platform from scratch or implement it in an existing website, we have to figure out what do we want to have as main features and if they can be by the OG module pack.

Here is a list of necessary points and a short description for each of them on how to configure it in Drupal:

 

Creating Groups – the site administrator should be able to create group rooms.

After enabling the OG module we can define each content type, new or existing, as a group or as a group content. On the content type edit page we have a vertical tab called Organic Groups.



Groups are entities. Every user with the right permissions will be able to create groups. We can define multiple types of groups. If we create Public group and Private group content types we have different content types, so we can set different permissions and access levels.

 

Appoint a group owner – the site administrator should be able to appoint an owner of the group who will manage all the group settings, membership and content.

By default, the group owner is the author of the group node. But it is configurable. Every group node has an interface for managing subscribed people.

 

Group posts or group content - define various types of content and relate it with groups.

Defining group content is similar to defining groups. Organic Groups vertical tab that appears on the edit page of the content type has an option - Group Content where can set the target bundles. In other words we choose which group types to use as group content. Posting content in groups can be restricted via roles and permissions.

 

Commenting in groups – all group members should be able to comment.

As a node itself, groups and group content have the option to enable comments. Commenting in groups can be restricted via roles and permissions. Defining roles and setting permissions will give us the control we need.

 

Listing group content and group members.

OG modules pack comes with predefined views. We can use them to list group content or group members. Displays are Block and Content Pane so we have what we need. Great!

 

Notifications – send emails when user is subscribing and adding content.

The OG modules pack also comes with a predefined set of rules. We can send emails to user subscription. For adding content we need to define custom rules.

 

So, if you need a social-based flexible forum-like website, or you are just curious about the module, do not hesitate to install and configure Organic Groups today.

Don’t miss a post about Drupal world, follow us on Twitter, Facebook and subscribe to Propeople RSS feed.

Language English Tags: DrupalDevelopmentTutorialsCheck this option to include this post in Planet Drupal aggregator: planet

More and more projects today are using CSS preprocessors, with Sass being one of the most popular out there. What exactly is a CSS preprocessor? It is a scripting language based on CSS that lets you do amazing things with your CSS. We have a new series out, Learning Sass and Compass, to get you up to speed on this new cool tool for front-end development.

Sooner, not later, you will end up in the Issue Queue on d.o. Its practically unavoidable if you want to get the most out of your relation with Drupal.

The more involved you get, particularly as a code developer or themer, you will find that you spend more and more of your time working on and jumping around between issues. The list of issues you are active in and/or monitoring is constantly growing.

At this point you have turned the issues queue into: Your Workplace!

Read the full "Our Drupal Workplace: The Issue Queue" post on www.tsvenson.com

Here's a quick video recap from Drupalcon Portland - Tuesday, May 21st. 

The hook_requirements (API Doc) hook allows you to define custom requirements for modules. The hook can be used to simply notify a site builder with an alert, this is how the Update manager module works. If you have the Update manager module installed and it discovers an out of date module, it'll display an alert that certain modules need updating.

As another example, in the past I've used the hook to display an alert if API login credentials were not available.

You can also define very strict requirements where the installation of a module is aborted when requirements are not met.

In this article we'll look at how to use the hook for install requirements that aborts an installation if the requirements are not met. Then we'll look at how to display an alert, similar to how the Update manager displays alerts.

Tweet Widget Facebook Like Google Plus One Linkedin Share Button

On a recent large Drupal project we were finding that the variable table was holding around 4 MB of data. The issue of course with this is that this is loaded into memory on each page request regardless of whether or not you use it. Another issue is that the variable table holds serialized data, and there is an additional CPU overhead of actually de-serializing the data as well.

Introducing Variable debug

So I wrote a module Variable debug that is a straight forward and simple module that attempts to do only two things (at the moment):

1. A list of the highest memory usage variables stored in the {variable} table sorted by highest to lowest. There is also a list of links to Drupal.org issues to help resolve some known high usage offenders. If you know of an issue that exists that aims to resolve in-efficient usage of the variable table, please raise a new issue in the issue queue for this module.

2. A list of all suspected orphaned variables in the variable table. This is determined by whether or not the variable is:

   1. Not a variable provided by Drupal core
   2. Does not start with an enabled module name

   This can help you find and remove potential abandoned variables that are of no use to you and your site.

Symptoms of rogue variables

Sometimes Drupal contributed modules use the variable table as a dumping ground for large variables that really should be stored in dedicated tables. Here is an example from one of our websites using the SQL query:

SELECT LENGTH(value) AS length, name FROM variable ORDER BY length ASC;

And the end of the result:

| 534 | hs_config_taxonomy-17 | | 551 | subscription_mail_status_activated_body | | 561 | hs_config_taxonomy-13 | | 573 | googleanalytics_custom_var | | 580 | article_import_known_columnists | | 600 | menu_masks | | 617 | order_completion_text_digital_auth | | 620 | menu_default_active_menus | | 622 | order_completion_text_corporate_auth | | 626 | user_mail_register_no_approval_required_body | | 638 | menu_minipanels_hover | | 660 | field_bundle_settings_node__page | | 666 | article_import_known_agencies | | 700 | field_bundle_settings_node__collection | | 702 | field_bundle_settings_node__article | | 733 | order_completion_text_print_auth | | 781 | field_bundle_settings_node__promotion | | 869 | order_completion_text_digital | | 903 | subscription_activation_text_unverified | | 939 | order_completion_text_print | | 955 | order_completion_text_corporate | | 991 | field_bundle_settings_node__subscription | | 1012 | subscription_activation_text_pending | | 1073 | field_bundle_settings_commerce_product__subscription_product | | 1278 | entityreference:base-tables | | 1783 | high_risk_districts | | 1988 | commerce_enabled_currencies | | 2356 | metered_useragent_whitelist | | 2515 | rules_empty_sets | | 2796 | apachesolr_index_last | | 3178 | memcache_wildcard_flushes | | 3673 | drupal_js_cache_files | | 7804 | features_codecache | | 14840 | drupal_css_cache_files | | 852329 | imagefield_crop_info | +--------+-----------------------------------------------------------------+ 1207 rows in set (0.02 sec)

Anything over several hundred bytes in the variable table really has to take a step back any look at better utilising cache tables.

Integration with Drupal.org issues

The next feature I added to the module was known large variables, and links to Drupal.org issue queue items that contain patches to resolve the large memory usage.

Here is a screenshot showing the functionality.

Questions

Let me know in the comments if this helps you, also if you have any other known rogue variables that have Drupal.org issues, that would also be welcome.

Tags drupal drupalplanet debugging code development Source Variable debug Category Tutorial

We just launched Zact, one of our largest design projects to date at Chapter Three. We designed nearly 200 comps, including an e-commerce workflow, a customer dashboard that mirrors the functionality of the phone’s software, a Support section built on ZenDesk, and a consumer-facing website.

A disruptive new cell phone provider, Zact is a new company looking to redefine how customers purchase mobile services by making your plan 100% customizable right from your phone with no overage fees or contracts. They even give you a refund every month for any unused minutes, texts or data.

Helping Zact overcome business hurdles
As a new company in a major market, Zact turned to Chapter Three to help them solve some of their immediate business hurdles online.

• Establishing brand trust
  To overcome lack of brand recognition and to educate new customers about the key advantages of the service, we created the “Why we're different” and “How it works” sections as a way for new customers to get to know us.
• Paying full price for the phone
  To educate customers about the long term savings of buying the phone at full price, we created an interactive Savings Calculator. The calculator allows customers to compare various plan and phone options to their current bill to show their dollar amount saved over a two year period.
• Buying a phone online
  Without the ability to physically touch the phone customers are buying, we needed to build in extra guarantees to make customers feel comfortable purchasing a device online. We featured a “satisfaction guarantee” statement prominently throughout the site, promising a refund within 30 days if the customer did not like the phone.

Herculean feats of UX strength
The complexity of interactions across the site gave us an opportunity to flex our UX chops. We collaborated with Zact’s usability specialist, incorporating feedback from weekly usability tests to iteratively improve our designs.

• Customer dashboard
  To provide the functionality of the phone’s software on the website, we designed a web-specific interpretation of the phone software that empowers customers to access and control the full breadth of Zact’s service offerings. Because the software was being developed in parallel with our web design, we adopted an agile design approach to iterate in sync with the development team.
• E-commerce
  Our team worked with Zact’s usability specialist to implement a checkout flow pulling from best practices across the web. We delivered a solution that pushes the capabilities of Drupal Commerce and its ability to integrate with third-party systems.

Agile design
An agile design process was critical in the success of this project. We needed to be flexible as requirements and scope were changing daily. We met with the client daily via WebEx with new design deliverables for review, which allowed us to gather feedback often and respond quickly. For any given page, we were able to explore a number of options on a high level before focusing on a more final solution.

In fact, some of the best ideas on the project came directly from the client, as a result of organic discussion during those meetings. The Savings Calculator, which allows users to more visually understand how they will save money over time with Zact, grew out of a conversation we facilitated.

Our first iterations of the Savings Calculator were pretty skeletal and didn’t quite feel right; the user had to fill out the form and click a button before seeing results. After further discussion, the client suggested that we make the actual dollar savings visible and dynamic throughout the page, so that as you interact with the form you can directly see how your savings are affected. This minor design change immediately made the page more engaging and an effective tool in communicating why Zact is a viable alternative to a traditional phone contract.

Starting up in Silicon Valley with Drupal
One of the most exciting and challenging parts of the project was the rapid pace of startup culture. The level of expertise and web savvy amongst Zact’s staff allowed for a flourishing partnership where we were able to push boundaries and do great work together. So far, the site has been covered by some major press outlets, including Gizmodo, Engadget, Forbes and TechCrunch.

The site is finally live, but our work isn’t over yet. We’re continuing to evaluate and optimize the usability of the site and will continue to roll out design updates over the coming weeks. We look forward to working further with Zact and seeing how users will react to the new site.

• Flight arrived late Sunday night and took the Portland MAX light rail to the hotel. Grabbed something to eat and went to bed 4PM EST!
• Had a descent breakfast at the hotel
• Went on the "Secrets of Portlandia" free walking tour (http://secretsofportlandia.com). This was a great tour. I highly recommend it if you come to Portland.
• Lunch (frozen yogurt!)
• Took a walk across the river to the Burnside Skate Park that Brent Dunn wanted to checkout.
• We then made it over the the Oregon Convention Center to get our registrations
• Met with greggles to discuss keynoting DrupalCamp Charlotte and some Classic security related questions. including security audits and Guardr/Hardened Drupal
• Worked on the DrupalCamp Charlotte website
• Dinner at a local brewery
• Worked more on the DrupalCamp Charlotte website

Blog Category: Drupal var switchTo5x=false;stLight.options({publisher:'dr-4334ed90-d702-124d-3358-aea68cdffdd9'});

Dries Buytaert, Drupal's founder and project lead, presents his six-monthly keynote at Drupalcon, and sets out where he thinks Drupal needs to go.

Dries starts by talking about a highly visible sign of growth in Drupal — 8 years ago he and half of the conference delegates were able to fit into one hotel room for drinks on the night before the event opened. This year, over 3,000 delegates took over and filled up most of the bars in Portland, Oregon.

Next he shows how the users of Drupal have grown too. He says that 3-5 years ago it was just a hope that one day the White House website, and major broadcasters like NBC would use Drupal. 

Dries then returns to a theme he has raised in previous keynotes — summed up by the phrase "Do Well, Do Good". He says that as a result of Drupal's success, and the success of the businesses and careers of those who work on it, the world is benefiting. Hundreds of thousands of charities and non-profits are able to download Drupal for free and adapt it for their needs, to better achieve their aims — raising money, organising volunteers and campaigning.

But also, there are now over a hundred countries whose governments use Drupal to help provide better public services online to citizens. 

The White House Case Study

To illustrate this, Dries introduces a video in which Macon Phillips, the Director of Digital Strategy at The White House, speaks about their use of Drupal.

Macon says that they launched WhiteHouse.gov on Drupal in October 2009. They did a lot of work to assess the best system for them to use, and whether they could adopt open source. They have had great success with their choice of Drupal. As a result they've been keen to give back to the community, and have contributed a number of modules, and hosted a 'hack day' at the White House.

He gives the example of the 'We The People' petitioning application. It allows anyone to start a petition, and anyone to sign it online. The executive has pledged to respond to petitions that get enough signatures. Since its launch in September 2011 over 8 milion people have signed a petition on the site. Something that would only be possible online. It's a new way to scale civic participation.

The open nature of Drupal means they can now extend this even further, and they have launched a Read API to allow other websites to pull in data about petitions. They are now also planning a Write API to allow other applications to help people create and sign petitions.

Context

Dries next moves to talking about context. He says it's the availability of these petitions online that enables more people to engage with them. What's true in government is also true in business. People need the right content, in the right place, at the right time. Context is key.

He gives the examples of Amazon and Netflix. Able to personalise their sites and give recommendations and related content to users. As a result they've been able to massively disrupt their markets.

However, most organisations are currently really bad at this.

Dries shows a google search for 'flight to London'. The first result is actually from Icelandair which does really well — when he clicks through to the site, it prefills the form with 'London' as the destination for him, shows images of London to get him excited, and even knows that he wants to get there from Boston where he is now. Meanwhile, the next result Google presents, Continental, just takes him to a blank search form when he clicks through.

Context can be about many things. Some examples are geography, past behaviour, intent, device used, the time of day, and many more.

By responding to the context, you provide a much better experience to the user — what is becoming known as Web Experience Management (WEM).

Web Experience Management

Owners of websites want to do this in three stages, each of which requires integration with other systems:

• Stage 1: Attract — by using SEO, mobile platforms, social networks
• Stage 2: Convert — using CRM systems, email, ecommerce, personalisation and marketing automation systems
• Stage 3: Analyse — using CRM, analytics and marketing automation

So the Content Management System needs to integrate with all these other systems.

But, Dries cites recent research that shows that marketers are really unhappy with the state of integrations between CMSs and other systems such as CRM, ecommerce, personalisation etc. Just 6% of those surveyed were able to describe the integration between their CMS and their CRM as excellent.

At the moment these kinds of sites are using big proprietary systems, and Dries says this level of disatisfaction presents a great opportunity for Open Source, and Drupal in particular.

How To Address WEM With Drupal

So how could we develop Drupal to serve the future needs of these organisations?

1. The Drupal community could build these kinds of CRM and marketing automation tools ourselves. That's what competitors are doing — creating proprietary product suites to try to handle it all.
2. Drupal could focus on being very good at integrating with other systems. There are many good integration modules already, but these could be extended and improved.

Dries says that research supports the second option. End users want 'best of breed' tools that work well together. So, if we don't go the route of building everything ourselves, what do we need to do?

What Clients Want from a CMS

The research, says Dries, shows that clients want three things from a CMS:

1. Integrate best of breed tools
2. Deliver a great mobile experience
3. Ease of Use & Content Authoring

Dries says that all of these are addressed in Drupal modules — but what's more they are all addressed in Drupal 8 core:

 

1. Integrate best of breed tools: Web services are now provided in core to facilitate these integrations; all content can be exported as JSON or XML easily.
2. Deliver a great mobile experience: Responsive theming makes for better user experience on mobile; the web services mean better integration with mobile apps; even the admin and editing interface is mobile ready or can be managed via an app.
3. Ease of Use & Content Authoring: The admin user interface and content editing forms have been completely redesigned; In-place editing allows content to be edited at a click in the frontend; Images can be added to pages with drag and drop; there is now a true Preview of content, and they are working on enabling this to preview at different screen sizes.

The first alpha of Drupal 8 will be released during this week, and the developers are working towards the code freeze deadline of 1st July 2013. The aim is to have a stable release by the end of 2013 or early 2014. Sites will be able to use Drupal 8 in 2014.

Dries summarises by saying it is important for Drupal to 'skate to where the puck is', and that it is no longer enough to simply manage content. Drupal has to be a key part in enabling site owners to manage the whole experience for users.

By moving in this direction, Dries says that developers get to work on what matters, Drupal companies get to deliver what clients want, Drupal users can improve their business by shifting more of it to digital, and for the world we'll be doing well, and doing good.

Today was a tribute to the Druplicon, our community's iconic Drupal drop: Lashing rain and a river of 3300 Drupalistas (biggest Drupalcon ever) flowing into a sea of attractions: Sessions and BOFs, the exhibit hall, a hilarious game-show moderated by Rob and JAM, Holly Ross' and Dries' keynote, the group picture, you name them. It's just amazing to see how the Drupal community is growing from year to year; Kudos to the Drupal Association for doing a great job. Before I let you enjoy Michel's pictures further down, Dries' key messages from the keynote: The future of Drupal is not about managing content, but web experience management / Drupal 8 timeline: Code freeze scheduled for 1 July 2013. Expect Drupal 8 to go into production in 2014.

         

I'm getting ready to head in to DrupalCon, where over the next few days I'll be talking education and open learning with anyone who is interested.

And as I'm heading in, I have MOOCs on the brain - not because I'm particularly a fan of MOOCs, but because of the tendency to take a great thing (in this case, information and interpersonal exchanges distributed broadly over the web) and reduce it into something that feels more manageable, but is ultimately something lesser (in this case, MOOC platforms). More on this later.

The Web Is Your MOOC

Part of the reason that I'm thinking these thoughts prior to heading into DrupalCon is that I've long held the notion that open source communities have been engaging in effective peer-supported learning, even while many for-profit companies and academic communities have been struggling to distill the process of peer-supported learning into something resembling a replicable product. From having participated in and built many types of learning communities over the years, simpler is often better - many open source communities have done amazing work with listservs and issue queues, and many more feature-rich platforms have withered because, over time, a site owners "must-have" feature is the post launch usability nightmare. There's a moral in there about user-centered design and user testing, but that's a subject for another post.

But getting back to MOOCs, the early MOOCs - the ones run by Stephen Downes, Alec Couros, Dave Cormier, George Siemens, (and yes, I know I'm forgetting people - please fill in the gaps in the comments) etc - encouraged participation from anywhere. If you had a blog with an RSS feed, you were in. Participants remained in control of their work (depending, of course, on the publishing tool they were using. Open source platforms generally offer more options for data ownership and portability than their closed brethren). The MOOC was like a marauding mob of information, with the potential to sprout anywhere.

It's All About The Portfolio

In the post-lifestream, post-MOOC era, it's been rare to see much excitement about portfolios. This doesn't surprise me, because like all good ideas, portfolios have been around for a while, and thus lack the shiny newness that generates great marketing copy. However, the need for the concept hasn't diminished - any time you see a site that promises to collect the sources of your learning into a single location, so you can show your employers what you know! - you should think, "portfolio." All of the sites that promise to simplify collecting and curating your digital footprint? Portfolios. A lot of the conversations around documenting and receiving credit for informal learning have their roots (and possibly solutions) in portfolios.

In the conversations we have had about portfolios over the years, we have seen three main barriers, or areas of misunderstanding:

• Distinguishing between a working and a presentation portfolio: simply put, the working portfolio is a running collection of just about everything you do. The presentation portfolio is a selection of elements from the working portfolio selected for a specific purpose. Portfolios can serve different purposes for different reasons, and the relationship between the working portfolio and the presentation portfolio is key.
• Portfolios need care and feeding over time: as mentioned before, the working portfolio is messy. Periodically, the working portfolio needs to be pruned and cleaned up. But, messy is great, and if it's not messy, that could be a sign that things aren't working as they should.
• Ownership and control of the portfolio: because most portfolio implementations are paid for by an organization, the organization usually controls access to the portfolio and any information in it. Organizational control is also seen as an essential element to assessment. However, this flies in the face of learner control and ownership of the means by which they learn. Ultimately, this is a data portability issue with implications for the learning experience. More on this later.

Concluding Thoughts

One of the things that has been particularly underwhelming about the corporate MOOCs that have cropped up is their uncanny resemblance to an LMS with an open enrollment policy. While there are many differences between the platform-stylehttps://chronicle.com/article/Providers-of-Free-MOOCs-Now/136117/ MOOCs and the original versions, the lack of learner control is a key element. Like Vegas, work in a MOOC stays in a MOOC (unless, of course, a company pays money to study student data).

In the platform-style MOOCs, the open web is missing. From a learner perspective, the portfolio is MIA. For a learner, throwing the evidence of your learning into a space that someone else controls isn't a viable long term strategy.

So, if you're at DrupalCon and want to talk open learning, let's make some time and sit down together. Open source, and the methodologies that support sustainable open source development, have a lot in common with open learning. I'd love to hear what other people are doing in this space.