The Views module provides listings of data on your site: users, comments, nodes, and more. Any listing of data provided by the Views module is called a view, and most Drupal websites today use Views in many different ways. In this lesson we'll get an overview of the Views module, including some specific concepts and terminology like Data Types and Displays, along with a tour of the major view settings and what they do.
Additional resources
The requirements of our site include two different main views. One view is a public-facing list, showing all the available jobs to users of the site. In this lesson we'll create our first view by enabling the modules we need, walking through the Views wizard to get our basic view in place, and then modifying various settings for our fields and working with contextual filters.
Additional resources
The Applications view will serve both as a tool for administrators and as a reference for users, with three different displays. In this lesson, we'll start to build the Applications view by creating the default display with our first listing, which is a master list of all the applications on the site. To pull in all of the information we're going to need, we'll begin working with Views relationships.
Additional resources
With our basic Applications view built, we have our default display. We also need another faculty display on the site. This second list will be largely the same as the default list, but it needs to show up as a tab on a job posting node, and only list the applications which relate to that particular job. We're going to need to create a new display, and override certain settings, plus add in a contextual filter, in order to get this view completed.
Additional resources
In this lesson we tackle the last display we need for our Applications view, by building a block for our applicants. This has us creating a new type of display, a block, as well as continuing to work with overrides. We also have to change the permissions on this particular display so regular users can see it, but at the same time we only want the view to show a user their own applications.
Additional resources
The basic job website that we’ve built only touches on the surface of the capability of Field and Views. There are a lot of possibilities for extending the functionality of this job site by adding more fields to both the Job and Job Application content types. In this lesson we'll review some other modules to explore:
- Automatic Node Titles
- Node Reference URL Widget
- Content Access
- Field Permissions
Additional resources
Views relationships let you add related information to your view. Here is how you can take advantage of various references, like node and user references, or file information. We'll be using relationships to add some contact details to our Job openings view.
Additional notes:
If you don't see the field "fields" under the dropdown menu when creating a Relationship for the contact person's phone number it's possible you don't have the Views module enabled. (Or perhaps you've missed enabling the Views UI module...make sure you have both). Then complete the following steps:
- Create and SAVE your view-relationship.
- Create a user reference where you want to reference the user.
- Now when you create the user reference it will have an option to reference your view.
This video series will continue the Job Board example from the Fields for Site Builders series where we will discover ways to display all of the job postings, allow people to find the one they are looking for and easily apply for it.
This lesson takes a look at working with the already existing entities in Drupal such as users and nodes and demonstrates some best practices for working with them in your own custom module. We'll focus on writing code that will work with any entity type and isn't hard coded to work with just nodes or just entities.
Additional notes:
There is a typo in the video. Joe created the variable $types = 'comment'; in one spot and then used it as entity_load($type, ... which obviously wouldn't work because the later is missing an 's' on the end. The downloadable code for this video doesn't have the typo.
Additional resources
In this video Michelle will give us a tour of our example site from the manager perspective, so we can see how you manage a group. We'll look at the extra administrative rights they have for the group, including accepting new members. We also talk about roles and permissions within a group, and briefly discuss the difference between permissions and access control.
Although the video uses the "dev" version of Organic Groups, there has since been a stable release of the 2.x branch.
Additional resources
In this chapter Karen Stevenson will cover getting some content and users into our site. She will achieve this using the Devel module, with a few tips and tricks because of all the references Organic Groups uses to work its magic. The reason we need this content is so we can understand how all the components of a group work. From a manager to member, and individual content, each has a different role in an Organic Group.
Additional notes:
Around 3:22 a new Announcement was made with Cardinals as a selectable option in the Team field. That option only appears if, as admin, you explicitly join the Cardinals group.
Additional resources
Converting an exisiting theme to Omega takes time and some planning, but Omega gives us plenty of options of moving things around the page all without touching a piece of code. When working with a grid layout we use Omega to set all of our content to span the proper columns all while moving our content from zone to zone so it is placed properly on the page. We will cover:
- Moving content from zone to zone
- Choosing proper zone column widths
- Splitting column amounts to create right and left columns
Once all of this is complete we are just a few steps away from getting into some CSS and really making our theme come together as an Omega sub-theme.
Additional notes:
If you want to touch code, you can edit the .info file as such (for the first part, moving branding zone):
settings[alpha_region_branding_zone] = 'header'
...
settings[alpha_region_branding_weight] = '3'
...
settings[alpha_region_header_first_weight] = '1'
...
settings[alpha_region_header_second_weight] = '2'
Responsive design is more than a just a buzzword these days but a standard practice of good web shops when building out a site. Omega provides a responsive design out of the box and gives lots of options to layout your content in the proper places and the ability to work with the break-points all with a User Interface. In this lesson we will cover:
- Omega responsive options
- Column settings for your grid layout
- Omega responsive layout settings
- Device viewports and media queries
We end the lesson getting our new sub-theme ready to handle our 960 robots theme and the 16 column setup we designed it with.
If you prefer working with code, instead of the web UI, you may configure your theme as follows to change your column settings from 12 grid columns to 16 in your theme's .info file:
Find and replace all the instances of:
_columns] = '12'
with:
_columns] = '16'
There may still be additional regions that also need to be set which weren't the full width. You can edit other regions as needed, such as:
_region_user_first_columns] = '8'
change to:
_region_user_first_columns] = '12'
This chapter shows how to cluster different form elements into fieldsets as well as how to expand the Forms API renderable array a tree that preserves the structure and hierarchy of the form. We'll expand the Form Fun example module and talk about the #tree property. This video uses krumo() and dsm() functions. You will need to download, install, and enable the devel module to use these functions. These functions allow you to see what variables are available to you. To accomplish the same task without using the devel module, you can add the following snippet to your module: drupal_set_message('' . print_r($vars, true) .'');
Note: There is a typo in the code used in this video. The function form_fun_tree() is missing a parameter, and should be as follows function form_fun_tree($form, &$form_state).
Deploying Your Code
FreeIn this lesson we will take the code we have committed to our remote repository and manually push it to our production server. We will cover how to setup deployments on beanstalkapp.com and the some of the advantages of using a tool like this.
A question we are commonly asked is: how did your production environment recognize the new feature?
Answer: Reverting a feature reverts it back to what is in code. So by updating the code it always looks to the code so there is no need to revert it. You usually revert a feature if you have made changes that are stored in the database and you need it to look back to the code as your database changes are not what you wanted or are wrong. If the changes you made in the database are what you want, then you update/recreate the feature.
Combining Conditions
FreeThis screencast explains how to use AND and OR groups in Rules to configure more complex conditions. This is demonstrated by creating a rule that notifies administrators when content is promoted to front page using an OR group. (The same procedure can be used to create an AND group.)
The screencast covers:
- How to combine conditions
- How to create an OR group
- Some advice about the order of conditions
- How to delete reaction rules
- Why you shouldn’t use the “send e-mail to all users in a role” action
- Why it might be useful to have messages printed out when configuring complex rules
Additional resources
Rules guide (Drupal.org)
This lesson demonstrates the bare minimum needed to create a custom entity type and to load an Entity from the database. We’ll look at implementing a minimum viable hook_entity_info, talk about the relationship between the Entity API and the Schema API and use entity_load to retrieve a single entity record from the database.
Note, although it would be considered best practices to name the entity with the name of the module, e.g. videoentity_video, we did not include the module name prefix here because it is tedious to type it all out and to say "videoentity_video" without confusing people.
In the next lesson we'll cover the various entity classes and how they work. However, if you just want to get straight to using your entity and doing things like $entity = entity_load(); you'll need to declare a controller for your new entity type. Simply add this 'controller class' => 'EntityAPIController' in hook_entity_info(). That will get you started, and well talk about what exactly that line does in the next lesson.
Note: the video doesn't mention the 'primary key' element in the schema array (although it is in the code). This bit is necessary for the schema to install properly and work with the Entity API so if you're following a long make sure you add that part as well.
Additional resources
In this lesson we cover the Insert Module along with FileField Sources Module. The Insert Module is a great module when combined with a few others and is setup right. It takes a few configurations but gives you lots of flexibility with your images and placing them into the text area. We also demonstrate how you can use the FileField Sources module to make the insert module that much better when it comes to media management.
Note: not all Drupal modules provide access to images that are uploaded using a different toolkit. Before committing to a specific suite of media management modules, you should create a test site and practice uploading images. Based on your tests you will be able to better evaluate if you have chosen the right tools for your content managers.
Additional resources
This video goes through the process of creating a configuration form in order to save settings to the variables table in the database, and how to integrate those variables into your module.
Correction
The $item array in the function demo_menu() should be named $items, to match the return $items; line. (Either that or return $items; should be fixed to return $item;.) Just make sure the array you are building matches the name of the variable you are returning.
Additional resources
This video walks through the handy devel module from http://drupal.org/project/devel and demonstrates the tools it provides for debugging, inspecting and analyzing the code and SQL queries happening on your site. In this video you'll also learn about some of the helper functions built into the devel module that make it simpler to inspect the large nested arrays that you'll commonly come across when writing code for Drupal.
You may not have heard of the function dsm() before now. It is a legacy function and dpm() is the newer name. The two functions are identical since dsm() is just a wrapper for dpm().
The idea is that dsm() was a poor name for the function, it's short for drupal set message, but what was later decided that drupal print (as in print_r) message was better.
The difference between those two and kpr() is that dpm() does a permissions check to make sure the current user has permission to view devel's output, and then puts the krumo'd variable dump into the message queue via drupal_set_message(). This means that dpm() will work and let you see the output even if you're redirected. Great for debugging forms. kpr() just krumo's and dumps the value right here, right now. No permission check, no regard for where the content is being spit out.
One thing we haven't looked at in our feature yet is Drupal roles and permissions. Here we will create a role associated with out Blog feature and look at how we can roll that important bit in.
In this video we are using the Environment Indicator module to visually distinguish between different environments.
Additional resources
Features project (Drupal.org)
Introduction to Drush Series (Drupalize.Me)
https://github.com/DrupalizeMe/drupalize-lullablog (GitHub.com)