Year: 2010 Page 1 of 14

I’m currently programming up bim2, a new version of BIM to work with Moodle 2.0. I’m wondering whether a version of BIM for WordPress might be an idea.

A while ago Leigh Blackall wondered why BIM had to be inside an LMS. There were some reasons at the time. However, most no longer apply and I’m increasingly interested in moving beyond the LMS world. As a long-term WordPress user, a WordPress plugin might make some sense.

Such a plugin would be a small step away from BIM towards edufeedr. Both BIM and edufeedr are very similar in what they do. The main difference is the infrastructure they rely upon, BIM on Moodle and edufeedr on elgg (if I recollect correctly). WordPress is perhaps a little more mainstream Web than elgg and WordPress is being used by some playing with open-ish courses.

BIM as a WordPress plugin would retain the marking/management features, but should probably pay a bit more attention to re-purposing aggregated posts. Perhaps aggregated posts could be fed into the main blog and other locations?

Wonder if there’s a WordPress plugin that already does this? Would this be a good idea?

Am aware of this tutorial for WordPress plugins via @marksmithers. Seems a good place to start.

Will have to wait until bim2 for Moodle is done.

bim2 now has a working controller structure, but it doesn’t do anything. This post summarises initial attempts to implement the student controller so that it actually implements the state machine for the student interactions. It’s also the first attempt to implement some models and views with the MVC structure for bim2. This is liable to raise a range of questions about design, testing and other tasks.

A change?

The existing bim student set of interactions is limited to essentially two phases

1. Register a feed; and
2. View details of existing feed.
   This is the everything bim knows about the student and the feed on one page.

There is some room for improvement and Mark Pea has made some suggestions which are really good. Am thinking I’ll adopt and adapt them

Arising from that, current thinking is that there will be three main bim2 pages for students.

1. Activity details;
   This is the default bim2 activity home page for students. It would always show the description of the bim2 activity as entered by the person who created the activity. It would also show a summary of what is known about the individual student’s bim2 with three main options:
   1. Unregistered;
      Before the student has registered the URL for their feed, the page would show the textbox to enter the feed url and help information/links.
   2. Registered; and
      Once registered it would show a summary of the information known about the student’s participation in bim2 activity.
   3. Unable to register;
      In this state, the bim2 activity has been created, however, the creator has turned off (or not turned on) the ability for students to register their feed. This is actually a slight modification/cross cutting state to the other two options for this page.
2. Questions;
   This will be a summary of the questions the student has to respond to via their feed. the questions are created by the person creating the bim2 activity. This should probably show information about when/if the student has responded to the questions.
3. Your posts;
   This is where bim2 shows what posts it has mirrored from the student’s feed. It should also be where the student can allocate (unallocated) posts. This would be a new feature.

Mmm, am thinking it will be a good idea to create hard-coded prototypes for these pages to play around with the information that will be on them. This is a normal practice I got into with the previous development environment, but haven’t really gotten into with bim/Moodle.

Hard-coded views

The idea here is to get a version of bim2 code working with hard-coded templates. i.e. I (or anyone else who downloads it from git can see what is planned. Hopefully, the following outlines the implementation of this plan. It essentially means that I need to get the basic models and views for the student controller implemented.

But first, that means putting a bit more meat on the bones of the controller, which is essentially an empty function with some “hello world” code.

First step is how to identify the specific page to be displayed. With bim there are three components that are combined to figure out what to show the user

1. The type of user;
2. The “tab” to show;
   The staff interfaces are “tabbed”. The value for the tab parameter specifies which tab.
3. The “screen”;
   A particular tab may have a set of operations that can be operated. This specifies which one. Screen was the wrong choice, will go for op instead.

So, the idea is that the student controller’s process function has to examine the value of the parameter tab and then the parameter op to figure out what to do. Given this is what each controller will do, makes sense to put this into the base controller class and get the constructor to do it automatically….if that’s how php OO features work. Let’s test. Yep, that’s how it works.

Of course, this raises the point that perhaps somewhere in here, checking the valid values for tab and op can be semi-automated. That includes the idea of actually calling the appropriate function to handle the task based on the value of tab and op. e.g. what was used in the perl-based system I worked on was a hash of hashes leading to a function name. If there wasn’t a value for the particular combination of tab and op an error was produced. If there was, the function name was called to produce the necessary output. (The question fast approaching here will be how this works with the form processing in Moodle).

Ahh, the data structure approach to calling methods seems to work in PHP

[sourcecode lang=”php”]
function process() {
$methods = array( "hello" => "doit" );
$this->$methods[‘hello’]();
}

function doit() {
[/sourcecode]

Playing around a bit more I get the following for the student controller

[sourcecode lang=”php”]

function process() {
$methods = array(
"default" => array( "default" => "activity_details" ),
"activity" => array( "default" => "activity_details" ),
"questions" => array( "default" => "questions" ),
"posts" => array( "default" => "posts" )
);

if ( isset( $methods[$this->tab][$this->op] )) {
$function = $methods[$this->tab][$this->op];
$this->$function();
}
}
[/sourcecode]

The idea is that the methods array defines the set of valid methods and parameters for the student controller. So, if tab=activity and op=default then the activity_details method would be called. I’ve added in some more smarts into the base controller class. If tab or op are empty strings, it automatically sets them to default.

The actual code for calling the functions should probably be in the base controller class with the method data being specified in the constructor in the specific controller. Wonder if that will work? Yep, that works. So the “isset” stuff is in the base controller and the student controller has a constructor that sets up methods.

This is almost certainly reinventing the wheel (with a few corners) and sounding like a waste of time. But the theory is that this bit of work at the beginning will make for a more flexible bim2. i.e. it will be quicker to improve and change bim2. This is fast becoming an experiment on whether this is likely to happen. It feel’s like I’m trading the complexity of large procedural functions for the complexity of class relationships.

A “working” bim2 for students

So with this basic infrastructure in place, time to move onto getting the methods in place to display some appropriate information for the students.

So, bim2 is up and going, at least in terms of being able to create an instance of the activity within a course. The trouble is that it can’t do anything. This post starts the process of implementing the design of the user interactions with bim2. The intent is to go with a Model-View-Controller type structure in the hope that this will improve flexibility and reuse.

The plan is to reuse some of the very early work that was done with the indicators module (work that has yet to be completed). The plan here is hopefully to have the basic structure of the MVC approach working in bim2, however, it won’t actually do anything real. The idea is that once the structure is in place, I can work on each of the user groups separately.

Users and state machines

The fundamental assumption of this approach is that the way in which a user can interact with bim2 can be described as a state machine. The idea is that there are a given set of web pages any user can see and a specific set of possible transitions from one web page to the next. In addition, with bim2 there are groups of users. The state machine used by a user depends on the group they belong to and perhaps where they are up to in using bim2.

For example, initially a student must complete the “register a feed” process (state machine). Once that’s complete, they will be able to view details. A staff member marking blogs has one process to go through while the staff member in charge of the course has another.

The intent is to model the state machines for each group of users as a separate controller implemented using some simple models and views. The student state machine is the simplest, so I’ll start with it. By doing so most of the structure will be put in place.

Controller factory

But first, before doing that I need to put in place the structure to create the controllers. At the moment, the view.php script for bim has the following code at the core
[sourcecode lang=”php”]
if ( has_capability( ‘mod/bim:coordinator’, $context)) {
// administrator can the configure stuff
show_coordinator( $bim, $userid, $cm, $course );
}else if (has_capability(‘mod/bim:student’, $context)) {
// student can see details of their registered blog
show_student($bim, $userid, $cm, $course );
} else if ( has_capability( ‘mod/bim:marker’, $context )) {
show_marker( $bim, $userid, $cm, $course );
} else {
error( "No capability to access this page" );
}
[/sourcecode]

All this basically does is check to see what type of user is trying to use the activity and if this is determined, call an appropriate function to handle what they may want to be doing.

I’m hoping I can change this, and much of what precedes it (in total view.php in bim has 108 lines of code) into something much smaller, something like this.

[sourcecode lang=”php”]
$factory = bimtwo_ControllerFactory::create( $context );
if ( $factory !== NULL ) {
$factory->process();
}
[/sourcecode]
($context in the above may not make sense in a Moodle module.) Also need to identify how error checking should be done properly, doubt that testing for NULL is the way to go.

Coding standards

All of the above work was done yesterday while I was without a network connection. So some of it probably doesn’t follow the Moodle coding style. Time to revisit the work so far and bring it into line. This includes the error checking/exceptions.

First off is that class names should be lower-case english words separate by underscores.

Ahh, class member variables need to be declared. Also passing in DB, OUTPUT etc should probably be done via global.

Capabilities – identifying type of user

The type of user within a bim2 activity is determined by the bim2 capabilities the user has. So, first I need to become familiar with how capabilities have changed in Moodle 2 (if they have) and then figure out what changes need to be done to bim2 in order to get the appropriate controller being created.

Yea, have got the old bim capabilities working fine within bimtwo. No changes required from Moodle 2.0. Just had to update for the new name of bimtwo. After lunch, shall use this to get the various controllers going – it’s just doing “prints” at the moment.

Getting the controller stuff working

So, a touch more tweaking and the controller structure appears to be working. I’ll describe it below. There is a strong chance that the first reaction of many will be along the lines of “Isn’t that all just a waste of time, adding yet more abstraction/indirection?”. I’d be lying if I said it doesn’t feel like that at times. I wonder if I’m wasting my time. However, my prior experience was positive with this approach, so I remain hopeful. Time will tell.

The main view.php file, this is what Moodle calls when a user clicks on the bim2 activity, looks like this now.

[sourcecode lang=”php”]

require_once(dirname(dirname(dirname(__FILE__))).’/config.php’);
require_once(dirname(__FILE__).’/lib.php’);

require_once( $CFG->dirroot.’/mod/bimtwo/factory/controller.php’ );

$factory = new bimtwo_controller_factory();
$controller = $factory->produce();
$controller->process();
[/sourcecode]

That’s it, and that’s all it should ever be.

The idea is that the bimtwo_controller_factory examines the input and determines what type of user is making the request. Based on the type of user it then creates a $controller appropriate for that user. The process function for each controller then examines the input a bit more to figure out what the user is trying to do. It then calls the appropriate functions – implemented through a model and controller – to carry out that activity.

Determining what type of user is done using capabilities in the produce function of the factory class. It looks like this.

[sourcecode lang=”php”]
public function produce() {

global $CFG;
$path = $CFG->dirroot."/mod/bimtwo";

if ( has_capability( ‘mod/bimtwo:coordinator’, $this->context)) {
// administrator can the configure stuff
require_once "$path/coordinator/controller.php";
return new bimtwo_coordinator_controller( $this );
} else if (has_capability(‘mod/bimtwo:student’, $this->context)) {
// student can see details of their registered blog
require_once "$path/student/controller.php";
return new bimtwo_student_controller( $this );
} else if ( has_capability( ‘mod/bimtwo:marker’, $this->context )) {
require_once "$path/marker/controller.php";
return new bimtwo_marker_controller( $this );
} else {
require_once "$path/factory/controller_error.php";
return new bimtwo_error_controller( $this );
}
[/sourcecode]

At the moment, the controllers for each group of user simply produces some simply output indicating what type of user it thinks it is.

The next major task will be getting some models and views working, perhaps for the student as its the simplest class of user. But before that, I should probably return to some of the outstanding prior work.

Ahh, help files and help strings. Changes committed to git, onto help.

Okay, so after fixing up the naming problems with bim2 etc, it’s time to actually get the code going.

To do

A list of things to do once I get back online

• DONE mod_form.php needs to be modified to use the new editor element for Moodle 2.0
  Actually, this looks to have been created by a typo or other problem within the bim2 mod_form.php. It is now working.
• DONE Check the location/process for help files.
  Seems like in Moodle 2.0, help files are being converted to strings and reside in the language file.
• DONE Update lib.php:add_instance to call grade_item_update
• See what Rolley can do about making the bim icon transparent.

mod_form.php

When someone chooses to add a bim2 activity into a Moodle course, the first thing they see is the form provided by mod_form.php. I’m hoping/wondering if this can essentially stay the same as that used in bim. So let’s copy that across. No, empty page.

Ahh, I have to get the database for bim2 up and going. Seems the transition to bimTwo as the internal Moodle name for bim2 doesn’t work entirely. The table name regular expression check doesn’t like table names with uppercase characters, so for the tables it will have to be bimtwo

So, the tables are created now. Does the mod_form.php work? No still empty. Something not working here, solving this should be interesting as I’m currently without Internet access. How about commenting out the entire bim2 contents from mod_form.php. Seems the problem is a bit earlier.

~/course/modedit.php is where this is run from, let’s have a look there. Let’s stick some debugging stuff in and find out where we get up to. Or, alternatively you could try running the mod_form.php file through PHP from the commmand line and discover where the syntax error is in the file. i.e.
[sourcecode lang=”bash”]
david-joness-macbook-pro-2:~ david$ php mod_form.php

Parse error: syntax error, unexpected ‘,’ in mod_form.php on line 89
[/sourcecode]

This is why, on one-hand, it would be good to be developing in PHP/Moodle more often. I wouldn’t be making so many newbie misassumptions and mistakes.

Ahh, nice, I think. Fixed up the syntax error and no get this error in the browser

Coding error detected, it must be fixed by a programmer: MFORMS: Coding error, text formats are handled only by new editor element.

My immediate assumption here is that this is being caused by the original bim code including some Moodle 1.x specific code around the use of the HTML editor and its inclusion in forms. I’m offline so can’t check the syntax for this, will solve for now by commenting out the offending elements.

Next step is to update the get_string data. This is how Moodle separates text to be displayed on a web page into separate language files. I haven’t updated the bim2 english language file to include the labels used in mod_form.php.

Somewhat related to this are the help files, most of these should be able to come over, at least at the start. Ahh, appears the naming/directory structure may be a little different (or I’ve made a simple tranlsation mistake)

So, the form is basically working (minus the HTML editor field). Can I submit, well no, that’s the next step.

add_instance

The add_instance function in ~/mod/bimTwo/lib.php defines what should happen when the mod_form.php is submitted. Currently, it is empty/boilerplate. Will have to update it. This is again getting into the area of “Moodle 2 conversion problems”. As the database API is one place I believe that has undergone some change.

Actually, the NEWMODULE stuff looks like it might already have been updated. But I’m getting the error

Coding error detected, it must be fixed by a programmer: moodle_database::insert_record_raw() no fields found.

This is happening in this statement
[sourcecode lang=”php”]
$DB->insert_record(‘bimTwo’, $bimTwo);
[/sourcecode]

$bimTwo has the contents from the form, and it all appears good. So, some problem in the insert_record function. Ahh, wonder if this is where the database naming problem crops up, the ‘bimTwo’ that is the first parameter, should probably be without the upper case T

Yep, that appears to have fixed up the original error, now I’m getting Incorrect function. Ahh, wasn’t returning the id. Done. Now a problem Error reading from database I think that may well be another table naming problem.

course/modedit.php

The error is cropping up when this file is being run. Yep, almost certainly the problem with the different names. Am going to have to revert back to bimtwo as the name for everything.

Yep, that’s fixed it. It is now possible to add a bim2 activity (not that it will do anything useful) to Moodle 2. As you can see in the following image.

And the edit button basically works as well, in that it shows the mod_form.php output yet again and allows changes.

Ahh, but the information about the BIM settings is not being saved from the form to the database. Something is missing. Mmmm, most of the bim specific fields are missing from the basic bimtwo table, have to update that in xmldb. The browser form memory remembers the fields, but it appears that I didn’t hit the magic ‘Save’ in xmldb

Yep, that did it.

To do

Have a lot of clearing up to do when I can get back online.

The next major step, however, is to start implementing the main user interface of bim2. i.e. the process and output that staff and students see when they actually try to use the bim2 activity, rather than simply create it.

It is here where I’m hoping that I will be making the largest changes between bim2 and bim. It’s also where I’m hoping the changes will be worthwhile and not introduce new and interesting problems.

The last post covered the initial steps in starting bim2. Including the choice of the name bim2. But there is a problem.

The problem

It’s starting to look like the choice of bim2 as a name might not have been great. It appears Moodle may not like a digit in the name of a module. Confirmed

When creating a new module, the new name of the module must not contain numbers or other special characters!

The end result is that the “Add an activity” menu in Moodle only ever shows bim and not bim2 which means adding the activity won’t work.

The name will have to change. At least within Moodle.

This is just a bit of a bugger. Will mean I have to change the name of the git repository and a whole lot of other mucking around. I can’t really go back to use bim as the repo name, as that name is already taken by the Moodle 1.9 version of bim. I really don’t like this, both the need to change and the limited knowledge of mine resulting in the need for the change.

Name change?

So, should the name be bimTwo? It’s probably the best compromise. But still ugly. Especially since the #bim2 tag is already being used and makes the most sense.

Solution? For now, I think the plan will be to use bimTwo internal to Moodle, but encourage and use bim2 elsewhere. Maybe bim_two instead?

What do you think? Is there a better solution?

Actually, it will have to be bimtwo due

• underscore being a special character and not working within a Moodle module name;
• uppercase characters don’t work/aren’t supported in table names in the Moodle database.

The following records some of the initial steps in actually coding bim2. It includes

• A new name?;
• The new github repo for bim2;
• Resources for Moodle 2 module development; and
• Initial coding steps for bim2.

A new name?

bim2 is going to be very different from version 1 of bim. Beyond working for a different version of Moodle, I’m hoping bim2 will be a significant improvement in terms of code design and provide a foundation for some interesting stuff. Consequently, I want to keep the distinction between the two systems clear.

Hence, as you can probably guess, I’m using the title bim2 for version 2.0. This matches the name of the github repo and subsequently the directory on the Moodle server. Am hoping the consistency will work well…..time will tel.

New github repo for bim2

The code for bim2 will be/is available from a new github repository. There’s only the README there at the moment, however, as I progress I will be updating the repo.

I’m using github, because the experience with bim was just so simple and effective.

Resources for Moodle 2 development

The first step is finding out just how different Moodle 2 module development is from Moodle 1.9. My vague understanding is that it isn’t that different, however, I am planning to start from scratch with bim2, rather than port BIM into Moodle 2. The main reason for this is that I want to experiment with a better design for the structure of bim2.

What I’m really after is enough information to get a test/dummy Moodle 2 module up and going ASAP. The skeleton/foundation for bim2.

Category:Moodle 2.0 seems to be the place for an overview of available documentation.

As with my initial Moodle experience, I am finding it hard to get my head around the apparently disjointed collection of resources and insights on the moodle.org site. It appears that the NEWMODULE.zip approach might work with Moodle 2.0. So, I’ll move onto that.

Initial coding steps for bim2

So, this has essentially become the process for following the NEWMODULE.zip readme and getting a dummy bim2 up and going.

1. Get all the files NEWMODULE.zip files into the bim2 directory.
2. Change newmodule to bim2 in all the files.
3. Rename the lang/en_utf8/newmodule.php file to bim2.php.
4. Log into Moodle as admin.
5. Remember about modifying version.php to have a version number that represents the current date.
   Not sure I need this, at the moment, but I got bitten by this mistake with BIM.
6. Success “bim2” installed.
7. Let’s add a course and see if I can add an activity?
   Mmm, not liking the manual enrol for users in a course. No obvious save/submit/ok button when finished enrolling. I have to hit the close window widget, which (for me at least) suggests losing changes.
8. Yep, it’s there, but error about database table modules. This matches the instructions in NEWMODULE.zip. Need to modify the module’s tables. Ahhh, death by XMLDB….
9. The current plan is to re-use the existing BIM database tables. Let’s see if I can brave XMLDB to do that. All done. Success.

That will do for now. Next step will be to start actively modifying the NEWMODULE stuff into bim2 specific code.

This might seem like a bit of procrastination preventing progress on BIM 2.0, but it’s part of the whole Moodle 2 familiarisation process and also checking out the work of a friend. What follows is an attempt to install the universite theme for Moodle 2 onto a local instance.

Zip files and mac GUI users

So, am unpacking the theme zip file into the right place and discover Rolley is still suffering from us Mac GUI background. Apart from the expected universite directory, I also get the good old __MACOSX directory. There’s got to be a switch that turns that off.

Configuration

Okay, so the theme appears in the right place in the Moodle 2 admin settings. Let’s choose it and configure it. Okay, have to read a file on from the desktop. Is this common for Moodle themes? Or do they more often use online/web-based help? Should they?

The header is up and it all looks nice. So, I get to choose colours. Given I’m illiterate around colour schemes, I’ll leave the defaults.

So, that’s it. Not much there. Must need to read that config file. Mmm, not a lot of information there. Did I have the right file? Ohh, can’t check again. Time to trawl the files. Ahh, and I quote

ses the JQuery theme roller to allow the administrator to re-skin the background images. For instructions/notes please see the config.php file

No instructions in config.php though. Am at a loss, my ignorance of things CSS and JQuery is showing. Would like to put in some custom images. Not sure how.

Ahh, appears I have to use a jQuery theme roller

This is what it looks like

So Rolley, what have I missed/screwed up?