Prior to installing Drupal, it’s important to make sure that you can actually do so, and understand a bit about how Drupal is structured. The first lesson provides a checklist of Drupal’s requirements, and also highlights important things in the Drupal file structure that are worth knowing before diving into the installation process. We also explain and take a quick look at how you can use Drupal to run multiple sites from the code base, known in Drupal as a multisite installation.
Additional resources
Drupal installation requirements
Before we jump into building our first Drupal 7 site, we should also take a look at the great resources you have out there to help you on your journey. Being an open source project, Drupal has an amazing community of people who have paved this road before you. In this lesson we're going to look at the free community resources that you can use to not only find answers to your questions, but also connect with thousands of people around the world who are working in the same space you are. -- We are going to take a tour of the communtiy documentation, various Drupal forums, project issue queues, where you can glean a lot of useful information and help, Internet Relay Chat, or IRC, for real-time collaboration, and getting in touch with user groups of like-minded people around the world.
Additional resources
Drupal.org Troubleshooting Guide
Drupal Answers on Stack Exchange
Drupal Groups Site (groups.drupal.org)
Drupal is a great tool for working on the web, but to give it some context, in this lesson we're going to take a quick step back in time, and understand the history of working on the web and look at how the tools that Drupal provides match up with problems encountered over the years of web development.
Additional resources
In this lesson we're going to break down the "Drupal stack" to understand what pieces are working here and how they relate to each other. We'll take a tour of the major components of Drupal itself, like nodes and users, and then have a brief discussion about ways of organizing content.
Additional resources
What Is Drupal?
FreeTo learn more about how to get started with Drupal, also see our Introduction to Drupal guide.
In this lesson we take a look at Drupal, the open source Content Management System. We learn about the major components of a Drupal site and the library of constantly evolving tools available for working with Drupal. We find out how to see who uses it, by looking at DrupalShowcase.com and Drupal case studies on Drupal.org, among others. We look at Drupal's major features, such as Modules.
With this overview we have some context as we move forward into the series.
Additional resources
In this lesson, we are going to see how the book relates to each of the series we have, and how each of the individual series are organized. We will end up with thirteen series to cover the entire book. Then we will take a look at how you should use the videos with the book. If you don't have the book, not to worry, as the book would only act as supplementary material to the video lessons. You don't need the book to successfully follow these series. If you do have the book however, we want to make sure you understand how the lessons and book relate to each other.
Additional resources
Using Drupal comes with source code intended to be used throughout the lessons to make following the lessons much easier. In this lesson we're going to take a look at what that source code provides for us, where we can get a copy of, and how to use it. We'll go through the installation process, as well as see how we can switch between chapters in the source code without destroying work you've done on previous chapters. It is important to note that using the source code is very important if you want the lessons to match what is in the lessons. Drupal modules can change a lot over time, and the source code is designed to exactly match what is covered in the lessons. Once you've learned the basics of a chapter by working through the source code, you can upgrade your modules and explore the differences in newer versions, with the base understanding you've gained from the lesson.
Warning: Since this Drupal code is several years old, you must use PHP 5.3. PHP 5.4 or higher will not work. You will need to make sure your server is using PHP 5.3 in order to use this code properly. Many all-in-one servers, like WAMP, MAMP, and XAMPP provide older versions of PHP and a way to switch back and forth between versions.
Additional resources
The Using Drupal series of lessons walks through the O'Reilly book, Using Drupal, written by Angie Byron, Addison Berry, and Bruno de Bondt. We use the second edition, which covers Drupal 7. The book starts off with taking a look at Drupal Core and then works through various case studies using a wide range of contributed modules from the Drupal project.
The video series follows along with what's in the book, so if you have the book, the videos are really great supplemental material. Even without the book, you’ll get the full lessons here in the videos.
This series is intended for people who have worked with the web and understand how a website gets delivered, and in particular, how to get a website onto a web server so that people can actually see it and use it. The rest of this introductory series we have here will look at how the book relates to the video series we're going to be creating, and how you can use those 2 together.
Additional resources
Revisions are an important concept in a content management system. Keeping track of all the edits that have been made to a particular entity over the course of its lifetime. A paper trail or sorts. This lesson takes a look at what is required in order to make our Entities support revisions.
If you've worked with Drupal's node system and enabled revisions then you've seen Drupal's basic revision handling in action. Every time you save a node, it creates a new version of that node. You can roll back to previous versions and keep track of how a piece of content has changed over time. Entity API also supports the concept of revisions and in this lesson we're going to take a look at adding revision support for our video entities.
In order to take advantage of this feature, we'll need to modify our database schema to accommodate storing multiple versions of the same entity. We'll move all fields that we want to make "revisionable" into a separate table and set up a new unique version ID field so that we can keep track of revisions.
Then we will update our hook_entity_info implementation to tell the API that we want to use the revision system and make some changes to the code in our VideoEntityController so that when an entity is updated we save a revision instead of overwriting the current data.
Finally we'll need to write a simple UI for viewing older versions of our video entity because the Entity API does not provide us with this code by default.
If you've done any module development, you're probably familiar with hook_node_view and Drupal's arrays of doom. In this lesson we'll show you how to get easier access to the same information using entity metadata wrappers. We will use the entity_metadata_wrapper function to retrieve a new EntityMetaDataWrapper object that provides an interface for easily accessing an entities property and field values. We'll use the getPropertyInfo method to expose information about individual properties, and the getIterator method to access fields that contain multiple values, such as tags. You'll see that by using meta data wrappers you can also access properties on referenced entities, such as the email address of the author of a node, without having to load that information independently.
Metadata wrappers also provide a consistent way to access properties common to all entities. For example, every entity in Drupal has a unique ID property or a human readable label, but these properties often have different names. User name vs. node title. Metadata wrappers allow you to access this information in a consistent way.
Additional resources
In order to make the most of the entity APIs integration with other modules, such as Views, we need to describe the properties of our entity in more detail. The API can infer some information about a property based on our schema but we need to tell it that the integer stored in the updated_at column is actually a timestamp. We will do this by implementing hook_entity_property_info() and describing each of our entities properties. With these definitions in place you will be able to use the formatters in Views much like you would for individual fields on content types provided by core.
Note: Before you implement hook_entity_property_info() the API makes an educated guess about each property but once you've defined a single property, the API expects you to define all of the properties for your entity. Use the .install file in your module to get a complete list of the properties you need to define with hook_property_entity_info. You can also define additional properties that aren't mapped to fields in the database (these can be used for static properties).
Additional resources
This lesson takes a look at exposing the data in our entities to views. Lucky for us the entity API handles a lot of this for us. We’ll take a look at what we get for free, using the EntityDefaultViewsController class provided by Entity API module. We'll also discuss ways that we can customize this controller, which we'll tackle in a later lesson.
In this lesson we're going to take a more in-depth look at the UI controller we used earlier to create our administrative UI for the entity. We'll walk through how the controller adds menu paths and the like, without us needing to do any extra work, and then clean up our form-builder functions by overriding the UI controller's method, so that we can gain control of the name of the function that's called.
Probably the most common use case for view modes is teaser nodes. Or, a node being rendered in the teaser view mode. View modes allow entities to be displayed different depending on context, and also allow other modules like Field API that participate in the entity rendering process to adjust their behavior depending on the requested view mode.
In this lesson we’re going to take a look at an ‘authenticated’ view mode that we can use to adjust the display for any authenticated users. Then we’ll update Entity Controller class and make use of this new view mode in our ::view() method.
NOTE: in the video Joe forgot to change the 'member' label to "Member" and then later in the video when we view it in the UI it is corrected. The sample code included with this video has the correct label.
Bundles are an implementation of an entity type to which fields can be attached. In this lesson we’ll take a look at configuring a single bundle type for our entities in order to allow us to make them fieldable by hardcoding the bundle information into hook_entity_info(). This is the most basic implementation of bundles. Then we’ll look at adding the ability to attach fields to our newly created bundle.