Moodle 1.9 Extension Development

Moodle 1.9 Extension Development
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
save 15%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Table of Contents
Sample Chapters
  • Develop your own blocks, activities, filters, and organize your content with secure code
  • Thoroughly covers key libraries of Moodle and best practices to use them
  • Explore the Moodle architectural concepts, how it is structured, and how it works
  • Detailed examples and screenshots for easy learning


Book Details

Language : English
Paperback : 320 pages [ 235mm x 191mm ]
Release Date : April 2010
ISBN : 1847194249
ISBN 13 : 9781847194244
Author(s) : Jonathan Moore, Michael Churchward
Topics and Technologies : All Books, Other, e-Learning, Moodle, Open Source

Table of Contents

Chapter 1: Moodle Architecture
Chapter 2: Creating and Modifying Blocks
Chapter 3: Creating and Modifying Filters
Chapter 4: Creating and Modifying Activity Modules
Chapter 5: Customizing the Look and Feel
Chapter 6: Developer's Guide to the Database
Chapter 7: Developing Pluggable Core Modules
Chapter 8: Creating Moodle Reports
Chapter 9: Integrating Moodle with Other Systems
Chapter 10: Writing Secure Code
Chapter 11: Sending Notifications to Users
Chapter 12: Constructing and Displaying Pages by Using the pagelib Library
Chapter 13: Building Forms with formslib
Chapter 14: Development for the Adventuresome: Web Services
  • Chapter 1: Moodle Architecture
    • Understanding the stack
      • Database
      • Operating system
      • Web server
    • Directory and system structure
      • Moodle code
      • Moodle database
      • Moodle data
    • Installing Moodle
    • Moodle program execution
      • Executing config.php
      • Including Moodle libraries
      • Getting our data
      • Displaying in Moodle
    • Configuring Moodle
      • Setting configuration variables
    • Moodle's API
    • Other important libraries
      • PEAR
      • ADOdb
      • YUI
      • XMLDB
    • Access control, logins, and roles
      • Moodle permission contexts
      • Capabilities
      • Moodle roles
        • Assigning roles
    • Summary
  • Chapter 2: Creating and Modifying Blocks
    • Creating a block from scratch
      • Assigning content to our block
    • Adding a language file
    • Working with capabilities
      • Testing for built-in capabilities
      • Hiding a block based on capabilities
      • Adding your own capability
      • Checking for our new capability
    • Adding instance configuration
      • Capturing your configuration content
      • Displaying your content
    • Adding scheduled actions to our block
    • Reviewing a real world block
      • Reviewing block_instructor_contact.php
      • Configuring the instructor contact block
    • Using a block as a code container
      • Creating a block stub for our container
      • Creating capabilities for our container
    • Summary
  • Chapter 3: Creating and Modifying Filters
    • How a filter works
    • Building a filter
      • Getting started
      • Creating the language file
      • Creating the filter code
      • Activating the filter
      • Adding configuration settings
      • Using our settings
    • Summary
  • Chapter 4: Creating and Modifying Activity Modules
    • The scope of creating an activity module
    • Our module—activity Foo!
    • Getting started with the NEWMODULE template
      • Completing mod_form.php
        • Defining input values
        • Using common form elements
    • Making version.php
    • Setting icon.gif
    • Generating install.xml
      • Using the XMLDB editor
      • Defining our activity database
      • Defining the foo_responses table
      • Defining log types
    • Creating access.php
    • Updating index.php
      • Adding clean language strings
      • Looking up response data
        • Displaying our table of activities
        • Displaying course sections
        • Committing output
    • Finishing view.php
      • Including submit_form.php
      • Your code goes here
      • Context control
      • Developing a form
        • Cancel option
        • Submitted data
      • Setting grades
      • Displaying submission form
      • Displaying submissions
      • Group support
    • Coding lib.php
      • Function add_instance
      • Function foo_delete_instance
      • Function foo_user_outline
      • Function foo_user_complete
      • Function foo_get_participants
      • Function reset_course_form_definition
      • Function foo_reset_course_form_defaults
      • Function foo_reset_userdata
      • Inserting grades into the gradebook
        • Using grade_update
    • Upgrading our activity database
      • Using the XMLDB editor for database upgrades
      • Updating upgrade.php
    • Creating backup and restore support
      • Exploring backuplib.php functions
        • Common backup functions
        • Internal backup functions
      • Exploring restorelib.php functions
        • Common restore functions
        • Internal restore functions
    • Summary
  • Chapter 5: Customizing the Look and Feel
    • Themes
      • How themes work
      • Headers and footers
        • header.html
        • footer.html
      • Project 1: Changing the navigation breadcrumbs
        • Creating our own theme
        • Adding the category link
        • The navigation string
      • Project 2: Adding a standard footer with site links
        • Creating the code
        • Running the code
    • Course formats
      • How course formats work
      • Creating our own course format
        • Creating the course format language file
        • Modifying our course format function
        • Changing the forum display
    • Summary
  • Chapter 6: Developer's Guide to the Database
    • The database structure
    • Maintaining Moodle tables
      • install.xml
      • upgrade.php
      • Maintaining local database customization
      • The XMLDB editor
    • Using the Moodle database in your code
      • Retrieving data
        • Query by parameters
        • Query by "where" string
        • Query by full SQL
      • Storing data
        • set_field and set_field_select
        • insert_record and update_record
    • Common tables and relationships
      • Course and module relationships
    • Programming best practices
      • Take only what you need
      • Limiting your returned data
      • Using recordsets
      • Optimizing carefully with joins
      • Testing on more than one database engine
    • Summary
  • Chapter 7: Developing Pluggable Core Modules
    • Assignment types
      • What is an assignment type
      • Identifying assignment types
      • Assignment type basics
      • Building our own assignment type
        • Getting started
        • Planning our data
        • Adding custom settings
        • Making it do something useful
    • Resource types
      • What is a resource type?
      • Identifying resource types
      • Resource type basics
    • Question types
      • What is a question type?
      • Identifying question types
      • Question type basics
        • The main class
        • The editing form
        • The main language file
      • Other important question constructs
        • Grading
        • Backup and restore functions
        • Import and export function support
        • CSS and JavaScript support
    • Where to get more help
    • Summary
  • Chapter 8: Creating Moodle Reports
    • Creating course reports
      • Defining the non-participants report
      • Getting started
      • Updating mod.php
      • Controlling access
      • Language strings
      • Changes to Moodle's API
      • Exploring the People block
        • Setting $select
        • Setting $from
        • Setting $where
        • Making the query call
      • Modifying index.php
        • Making text substitutions
        • Changing the logical structure
        • Tracking active users using a hash array
        • Displaying the report
        • Cleaning up the final display
        • Using flexible_table
      • An exercise for you
    • Creating gradebook reports
      • Required components
        • Creating our report folder
        • Creating access.php
        • Assigning language strings
        • index.php requirements
        • Using version.php
      • Using the grade_report class
      • Fixing the outcomes report
        • Digging into the code
        • Reviewing our new report
    • Creating administrator reports
      • Generating the Hello World administrator report
      • Tweaking index.php
        • Viewing our administrator report
      • An exercise for you
    • Other output formats
    • Summary
  • Chapter 9: Integrating Moodle with Other Systems
    • Built-in services and plugins
      • Batch upload
      • Built-in authentication plugins
        • Manual/Internal authentication
      • LDAP/Active directory authentication
      • External database authentication
        • E-mail account based authentication plugins
      • Built-in enrollment plugins
        • LDAP enrollment plugin
        • External database enrollment plugin
      • E-commerce based enrollment plugins
      • Web services
        • Activity plugin as an integration bridge
    • Creating user authentication plugins
      • Exploring authentication requirements
        • Looking at auth.php
        • Making the language file
        • Testing simple authentication
        • Adding optional functionality to authentication
      • Creating the RLLDAP authentication plugin
        • Coding RLLDAP
    • Implementing Single Sign On
      • Creating a URL-based SSO
        • Digging into the code
        • Finding the user's account
        • Confirming that the login criteria have been met
        • Completing login
        • Redirecting the user to the correct location
      • Testing the URL SSO
    • Creating user enrollment plugins
      • Reviewing plugin requirements
        • Creating enrol.php
        • Creating the setup_enrolments function
        • Making the language file
        • Other requirements
        • Making the 'simple' enrollment plugin
      • Using optional enrollment functions
      • Assigning enrollment plugins to courses
    • Grade or completion passing
      • Working with the built-in import/export plugins
      • Creating grade import/export plugins
        • An exercise for you
    • Summary
  • Chapter 10: Writing Secure Code
    • User access issues
      • Making sure that a user has logged in
      • Making sure that the user's session is the current one
      • Making sure that the user has appropriate capabilities
    • SQL issues
      • Taking a look at vulnerable code
      • Quote protection
      • Database API
      • Use of addslashes
    • Form issues
      • The Moodle formslib library
        • Specifying a type
        • Validation rules
      • 'param' functions
    • File system issues
      • Course file areas
      • User file areas
      • Other file areas
      • Getting a file URL
    • Screen output issues
      • The p() and s() functions
      • The format_text() and format_string() functions
    • Logging your actions
    • Summary
  • Chapter 11: Sending Notifications to Users
    • Requirements
    • Setup
    • Using e-mail
      • Send e-mail API
      • Creating the subject text
      • Creating the message text
      • Sending the e-mail
    • Using Moodle messaging
      • Moodle messaging internals
      • Creating the message
      • Sending the message
    • Using RSS feeds
      • Setup
      • Creating the RSS XML file
      • Viewing the RSS feed
    • Summary
  • Chapter 12: Constructing and Displaying Pages by Using the pagelib Library
    • Introduction to pagelib
      • Class page_base
      • Class page_course
      • Class page_generic_activity
    • Core modules that use pagelib
    • Using pagelib factory functions
      • page_import_types
      • page_create_instance
      • page_create_object
      • page_map_class
    • page_base member functions
      • page_base() and construct()
      • get_id()
      • get_body_class()
      • get_body_id()
      • edit_always()
      • init_quick()
      • init_full()
      • user_allowed_editing()
      • user_is_editing()
      • print_header()
      • get_type()
      • get_format_name()
      • url_get_path()
      • url_get_parameters()
      • blocks_get_positions()
      • blocks_default_position()
      • blocks_get_default()
      • blocks_move_position()
    • Meeting pagelib requirements
      • Looking at page setup
      • Examining requirements by reviewing quiz's view.php
        • Working with quiz blocks
        • Investigating quiz page display
    • Converting activity Foo! to pagelib
      • Creating a local pagelib.php
      • Updating view.php
        • Initializing $PAGE
        • Outputting blocks
        • Outputting the middle column
        • Viewing the results
    • Related libraries
      • weblib
      • blocklib
      • graphlib
    • Summary
  • Chapter 13: Building Forms with formslib
    • Using formslib
    • Form definition and elements
      • addElement and createElement
        • Buttons
        • Checkboxes
        • Uploading and/or choosing a file
        • Date and time
        • htmleditor, textarea, and text
        • modgrade
        • password and passwordunmask
        • radio
        • select, multi-select, and selectyesno
        • hidden, html, and static text
        • Groups
    • Rules and validation
      • Rules
        • addRule
        • registerRule
      • Validation
    • Summary
  • Chapter 14: Development for the Adventuresome: Web Services
    • Using Remote-Learner Web Services
      • Advantages
      • Disadvantages
      • Installation
        • Server-side setup
        • Client setup
        • Testing with ppdemo_trace.php
      • Setting up your Web Services connection
        • Debugging setup
      • Managing users
        • Creating users
        • Updating users
        • Deleting users
      • Creating a Web Services based Single Sign On
        • Creating our HTML wrapper
        • Web service connection setup
        • Processing SSO parameters
        • Using authenticate_user()
        • Closing wrapper
      • Enrollment management
        • Creating enrollstudent.php
        • Using enrol_students()
        • Creating unenrollstudent.php
      • Grade passing
        • Creating the CSV grade script
    • Using Moodle Networking
      • Advantages
      • Disadvantages
      • What is XML-RPC?
        • MNet XML-RPC supported service types
        • MNet XML-RPC security model
        • Using MNet in activity modules
        • Using MNet in auth/enrol plugins
        • MNet SSO model
    • Summary

Jonathan Moore

Jonathan Moore is currently the Vice President of , and a special projects manager. Jonathan formerly served as the Director of Technology for Winfield Public Schools. He served in this capacity for almost ten years and has developed a broad set of educational technology and project management skills over the course of his career. His student technology program (Student Technology Assistance Team STAT) was recognized nationally by Comptia as the best Rural student technology program.

Michael Churchward

Michael Churchward is currently President and CTO of Remote Learner, a Moodle partner based in the US and Canada. Mike has been a developer of Moodle since 2004 and contributes both core code and add-on functions to the Open Source project. Mike and his development team are currently working on other extensions to Moodle and helping define the new Moodle 2.0 architecture.

Code Downloads

Download the code and support files for this book.

Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

Frequently bought together

Moodle 1.9 Extension Development +    Implementing Microsoft Dynamics NAV 2009 =
50% Off
the second eBook
Price for both: $45.60

Buy both these recommended eBooks together and get 50% off the cheapest eBook.

What you will learn from this book

  • Add activities and grading components to keep a track of students’ progress automatically
  • Create Moodle Filters to process and filter the contents of the database
  • Customize the look and feel of your Moodle site using powerful plug-ins
  • Customize Moodle reports to assess the performance of a student easily
  • Allow integration with third-party systems such as HR and student information systems to access any data directly
  • Automate notifications for any updates in the courses
  • Customize forms to be filled by students using ‘formlib’ library
  • Extend Moodle beyond its boundaries using web services and explore the features of SOAP-based and XMM-RPC-based web services

In Detail

Moodle gives you the power to create and customize feature-rich plug-ins. If you can write Moodle plug-ins, you can make it do just about anything. From making the site easier to administer, to new features, to completely changing the way it looks; plug-ins are the method Moodle offers to customize and extend its functionality.

This book will show you how to build all sorts of Moodle plug-ins: admin plug-ins, Blocks, Activities, Grading components, Reports, Fliters that change the way your site works and looks. You will develop standard Moodle plug-ins such as Activities, Filters, and Blocks by creating functioning code that you can execute in your own Moodle installation. Writing modular plug-ins for Moodle will be a large focus of this book.
This book will take you inside Moodle and provide you with the ability to develop code the “Moodle way”.

This book will expose you to all of the core code functions in Moodle, in a progressive, understandable way. You will learn what libraries are available, what the API calls are, how it is structured and how it can be expanded beyond the plug-in system.
You will begin by getting an understanding of the basic architecture that Moodle uses to operate in. Next you will build your first plug-in; a block. You will carry on building other Moodle plug-ins, gaining knowledge of the “Moodle way” of coding, before plunging deeper into the API and inner libraries. Lastly, you will learn how to integrate Moodle with other systems using a variety of methods.

When you have completed, you will have a solid understanding of Moodle programming and knowledge of how to extend its functionality in whatever way you want.

A practical guide to creating feature-rich extensions for your website using Moodle plug-ins


The author’s experience as a Moodle developer enables him to combine a simple, descriptive how-to approach with enthusiastic insights into the rich potential of customizing Moodle according to your needs. The chapters gradually build up your skills and by the end of the book you will be confident enough to customize Moodle on your own.

Who this book is for

This book is written for technologists who are interested in expanding Moodle's functions through programming, either for their own organizations or to contribute to the open source project.
You should be familiar with Moodle's basic technologies: PHP, MySQL ,and HTML/CSS.

Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software