Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 4.0.x will end 8 May 2023 (12 months).
- Bug fixes for security issues in 4.0.x will end 13 November 2023 (18 months).
- PHP version: minimum PHP 7.3.0 Note: the minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is also supported.
/mod/lesson/ -> locallib.php (source)
Differences Between: [Versions 310 and 400] [Versions 311 and 400] [Versions 39 and 400] [Versions 400 and 401] [Versions 400 and 402] [Versions 400 and 403]
Local library file for Lesson. These are non-standard functions that are used only by Lesson.
| Copyright: | 1999 onwards Martin Dougiamas {@link http://moodle.com} |
| License: | http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or late |
| File Size: | 5376 lines (214 kb) |
| Included or required: | 0 times |
| Referenced: | 16 times |
| Includes or requires: | 0 files |
Defines 7 classes
lesson_add_page_form_base:: (10 methods):
custom_definition()
get_answer_format()
get_response_format()
is_standard()
definition()
add_jumpto()
add_score()
add_answer()
add_response()
construction_override()
lesson:: (59 methods):
__construct()
create()
load()
delete()
delete_override()
delete_all_overrides()
is_participant()
show_only_active_users()
update_effective_access()
get_messages()
get_attempts()
get_content_pages_viewed()
get_firstpage()
get_lastpage()
get_firstpageid()
get_lastpageid()
get_next_page()
add_message()
is_accessible()
start_timer()
update_timer()
stop_timer()
has_pages()
link_for_activitylink()
load_page()
load_all_pages()
duplicate_page()
copy_page_files()
jumpto_is_correct()
time_remaining()
cluster_jump()
get_sub_pages_of()
is_sub_page_of_type()
resort_pages()
get_context()
set_cm()
get_cm()
set_courserecord()
get_courserecord()
can_manage()
get_time_restriction_status()
get_password_restriction_status()
get_dependencies_restriction_status()
is_in_review_mode()
get_last_page_seen()
count_user_retries()
left_during_timed_session()
set_module_viewed()
get_user_timers()
check_time()
add_messages_on_page_view()
get_ongoing_score_message()
calculate_progress()
prepare_page_and_contents()
calculate_new_page_on_jump()
process_page_responses()
add_messages_on_page_process()
process_eol_page()
get_last_attempt()
lesson_base:: (5 methods):
__construct()
__set()
__get()
__isset()
properties()
lesson_page:: (40 methods):
create()
load()
delete()
move()
get_answers()
get_lesson()
get_type()
record_attempt()
format_answer()
format_response()
get_jump_name()
__construct()
earned_score()
callback_on_view()
save_answers_files()
rewrite_answers_urls()
update()
add_page_link()
is_unseen()
is_unanswered()
create_answers()
check_answer()
on_after_write_attempt()
has_option()
max_answers()
properties()
get_jumptooptions()
get_contents()
get_displayinmenublock()
option_description_string()
display_answers()
get_grayout()
stats()
report_answers()
get_jumps()
requires_manual_grading()
override_next_page()
valid_page_and_view()
get_files()
update_form_data()
lesson_page_answer:: (3 methods):
load()
create()
get_files()
lesson_page_type_manager:: (8 methods):
get()
load_lesson_types()
get_page_type_strings()
get_page_type_idstring()
load_page()
check_page_order()
load_all_pages()
get_page_form()
requested:: (1 method):
get_add_page_type_links()
Defines 1 function
lesson_display_teacher_warning()
lesson_unseen_question_jump()
lesson_unseen_branch_jump()
lesson_random_question_jump()
lesson_grade()
lesson_displayleftif()
lesson_add_fake_blocks()
lesson_mediafile_block_contents()
lesson_clock_block_contents()
lesson_menu_block_contents()
lesson_add_header_buttons()
lesson_get_media_html()
lesson_process_group_deleted_in_course()
lesson_get_overview_report_table_and_data()
lesson_get_user_detailed_report_data()
lesson_get_user_deadline()
lesson_unseen_question_jump()
lesson_unseen_branch_jump()
lesson_random_question_jump()
lesson_grade()
lesson_displayleftif()
lesson_add_fake_blocks()
lesson_mediafile_block_contents()
lesson_clock_block_contents()
lesson_menu_block_contents()
lesson_add_header_buttons()
lesson_get_media_html()
lesson_process_group_deleted_in_course()
lesson_get_overview_report_table_and_data()
lesson_get_user_detailed_report_data()
lesson_get_user_deadline()
Class: lesson_add_page_form_base - X-Ref
Abstract class that page type's MUST inherit from.This is the abstract class that ALL add page type forms must extend.
You will notice that all but two of the methods this class contains are final.
Essentially the only thing that extending classes can do is extend custom_definition.
OR if it has a special requirement on creation it can extend construction_override
| custom_definition() X-Ref |
| Each page type can and should override this to add any custom elements to the basic form that they want |
| get_answer_format() X-Ref |
| Returns answer format used by question type. |
| get_response_format() X-Ref |
| Returns response format used by question type. |
| is_standard() X-Ref |
| Used to determine if this is a standard page or a special page return: bool |
| definition() X-Ref |
| Add the required basic elements to the form. This method adds the basic elements to the form including title and contents and then calls custom_definition(); |
| add_jumpto($name, $label=null, $selected=LESSON_NEXTPAGE) X-Ref |
| Convenience function: Adds a jumpto select element param: string $name param: string|null $label param: int $selected The page to select by default |
| add_score($name, $label=null, $value=null) X-Ref |
| Convenience function: Adds a score input element param: string $name param: string|null $label param: mixed $value The default value |
| add_answer($count, $label = null, $required = false, $format= '', array $help = []) X-Ref |
| Convenience function: Adds an answer editor return: void param: int $count The count of the element to add param: string $label, null means default param: bool $required param: string $format param: array $help Add help text via the addHelpButton. Must be an array which contains the string identifier and |
| add_response($count, $label = null, $required = false) X-Ref |
| Convenience function: Adds an response editor return: void param: int $count The count of the element to add param: string $label, null means default param: bool $required |
| construction_override($pageid, lesson $lesson) X-Ref |
| A function that gets called upon init of this object by the calling script. This can be used to process an immediate action if required. Currently it is only used in special cases by non-standard page types. return: bool |
Class representation of a lesson
This class is used the interact with, and manage a lesson once instantiated.
If you need to fetch a lesson object you can do so by calling
<code>
lesson::load($lessonid);
// or
$lessonrecord = $DB->get_record('lesson', $lessonid);
$lesson = new lesson($lessonrecord);
</code>
The class itself extends lesson_base as all classes within the lesson module should
These properties are from the database
This class is used the interact with, and manage a lesson once instantiated.
If you need to fetch a lesson object you can do so by calling
<code>
lesson::load($lessonid);
// or
$lessonrecord = $DB->get_record('lesson', $lessonid);
$lesson = new lesson($lessonrecord);
</code>
The class itself extends lesson_base as all classes within the lesson module should
These properties are from the database
| __construct($properties, $cm = null, $course = null) X-Ref |
| Constructor method param: object $properties param: stdClass $cm course module object param: stdClass $course course object |
| create($properties) X-Ref |
| Simply generates a lesson object given an array/object of properties Overrides {@see lesson_base->create()} return: lesson param: object|array $properties |
| load($lessonid) X-Ref |
| Generates a lesson object from the database given its id return: lesson param: int $lessonid |
| delete() X-Ref |
| Deletes this lesson from the database |
| delete_override($overrideid) X-Ref |
| Deletes a lesson override from the database and clears any corresponding calendar events return: bool true on success param: int $overrideid The id of the override being deleted |
| delete_all_overrides() X-Ref |
| Deletes all lesson overrides from the database and clears any corresponding calendar events |
| is_participant($userid) X-Ref |
| Checks user enrollment in the current course. return: null|stdClass user record param: int $userid |
| show_only_active_users() X-Ref |
| Check is only active users in course should be shown. return: bool true if only active users should be shown. |
| update_effective_access($userid) X-Ref |
| Updates the lesson properties with override information for a user. Algorithm: For each lesson setting, if there is a matching user-specific override, then use that otherwise, if there are group-specific overrides, return the most lenient combination of them. If neither applies, leave the quiz setting unchanged. Special case: if there is more than one password that applies to the user, then lesson->extrapasswords will contain an array of strings giving the remaining passwords. param: int $userid The userid. |
| get_messages() X-Ref |
| Fetches messages from the session that may have been set in previous page actions. <code> // Do not call this method directly instead use $lesson->messages; </code> return: array |
| get_attempts($retries, $correct=false, $pageid=null, $userid=null) X-Ref |
| Get all of the attempts for the current user. return: array|false param: int $retries param: bool $correct Optional: only fetch correct attempts param: int $pageid Optional: only fetch attempts at the given page param: int $userid Optional: defaults to the current user if not set |
| get_content_pages_viewed($lessonattempt, $userid = null, $sort = '', $fields = '*') X-Ref |
| Get a list of content pages (formerly known as branch tables) viewed in the lesson for the given user during an attempt. return: array of pages param: int $lessonattempt the lesson attempt number (also known as retries) param: int $userid the user id to retrieve the data from param: string $sort an order to sort the results in (a valid SQL ORDER BY parameter) param: string $fields a comma separated list of fields to return |
| get_firstpage() X-Ref |
| Returns the first page for the lesson or false if there isn't one. This method should be called via the magic method __get(); <code> $firstpage = $lesson->firstpage; </code> return: lesson_page|bool Returns the lesson_page specialised object or false |
| get_lastpage() X-Ref |
| Returns the last page for the lesson or false if there isn't one. This method should be called via the magic method __get(); <code> $lastpage = $lesson->lastpage; </code> return: lesson_page|bool Returns the lesson_page specialised object or false |
| get_firstpageid() X-Ref |
| Returns the id of the first page of this lesson. (prevpageid = 0) return: int |
| get_lastpageid() X-Ref |
| Returns the id of the last page of this lesson. (nextpageid = 0) return: int |
| get_next_page($nextpageid) X-Ref |
| Gets the next page id to display after the one that is provided. return: bool param: int $nextpageid |
| add_message($message, $class="notifyproblem", $align='center') X-Ref |
| Sets a message against the session for this lesson that will displayed next time the lesson processes messages return: bool param: string $message param: string $class param: string $align |
| is_accessible() X-Ref |
| Check if the lesson is accessible at the present time return: bool True if the lesson is accessible, false otherwise |
| start_timer() X-Ref |
| Starts the lesson time for the current user return: bool Returns true |
| update_timer($restart=false, $continue=false, $endreached =false) X-Ref |
| Updates the timer to the current time and returns the new timer object return: stdClass The new timer param: bool $restart If set to true the timer is restarted param: bool $continue If set to true AND $restart=true then the timer |
| stop_timer() X-Ref |
| Updates the timer to the current time then stops it by unsetting the user var return: bool Returns true |
| has_pages() X-Ref |
| Checks to see if the lesson has pages |
| link_for_activitylink() X-Ref |
| Returns the link for the related activity return: string |
| load_page($pageid) X-Ref |
| Loads the requested page. This function will return the requested page id as either a specialised lesson_page object OR as a generic lesson_page. If the page has been loaded previously it will be returned from the pages array, otherwise it will be loaded from the database first return: lesson_page A lesson_page object or an object that extends it param: int $pageid |
| load_all_pages() X-Ref |
| Loads ALL of the pages for this lesson return: array An array containing all pages from this lesson |
| duplicate_page($pageid) X-Ref |
| Duplicate the lesson page. return: void. param: int $pageid Page ID of the page to duplicate. |
| copy_page_files($filearea, $itemid, $newitemid, $contextid) X-Ref |
| Copy the files from one page to another. return: void. param: string $filearea Area that the files are stored. param: int $itemid Item ID. param: int $newitemid The item ID for the new page. param: int $contextid Context ID for this page. |
| jumpto_is_correct($pageid, $jumpto) X-Ref |
| Determines if a jumpto value is correct or not. returns true if jumpto page is (logically) after the pageid page or if the jumpto value is a special value. Returns false in all other cases. return: boolean True or false after a series of tests. param: int $pageid Id of the page from which you are jumping from. param: int $jumpto The jumpto number. |
| time_remaining($starttime) X-Ref |
| Returns the time a user has remaining on this lesson return: string param: int $starttime Starttime timestamp |
| cluster_jump($pageid, $userid=null) X-Ref |
| Interprets LESSON_CLUSTERJUMP jumpto value. This will select a page randomly and the page selected will be inbetween a cluster page and end of clutter or end of lesson and the page selected will be a page that has not been viewed already and if any pages are within a branch table or end of branch then only 1 page within the branch table or end of branch will be randomly selected (sub clustering). return: int The id of the next page. param: int $pageid Id of the current page from which we are jumping from. param: int $userid Id of the user. |
| get_sub_pages_of($pageid, array $ends) X-Ref |
| Finds all pages that appear to be a subtype of the provided pageid until an end point specified within $ends is encountered or no more pages exist return: array An array of specialised lesson_page objects param: int $pageid param: array $ends An array of LESSON_PAGE_* types that signify an end of |
| is_sub_page_of_type($pageid, array $types, array $ends) X-Ref |
| Checks to see if the specified page[id] is a subpage of a type specified in the $types array, until either there are no more pages of we find a type corresponding to that of a type specified in $ends return: bool param: int $pageid The id of the page to check param: array $types An array of types that would signify this page was a subpage param: array $ends An array of types that mean this is not a subpage |
| resort_pages($pageid, $after) X-Ref |
| Move a page resorting all other pages. return: void param: int $pageid param: int $after |
| get_context() X-Ref |
| Return the lesson context object. return: stdClass context |
| set_cm($cm) X-Ref |
| Set the lesson course module object. param: stdClass $cm course module objct |
| get_cm() X-Ref |
| Return the lesson course module object. return: stdClass course module |
| set_courserecord($course) X-Ref |
| Set the lesson course object. param: stdClass $course course objct |
| get_courserecord() X-Ref |
| Return the lesson course object. return: stdClass course |
| can_manage() X-Ref |
| Check if the user can manage the lesson activity. return: bool true if the user can manage the lesson |
| get_time_restriction_status() X-Ref |
| Check if time restriction is applied. return: mixed false if there aren't restrictions or an object with the restriction information |
| get_password_restriction_status($userpassword) X-Ref |
| Check if password restriction is applied. return: mixed false if there aren't restrictions or an object with the restriction information param: string $userpassword the user password to check (if the restriction is set) |
| get_dependencies_restriction_status() X-Ref |
| Check if dependencies restrictions are applied. return: mixed false if there aren't restrictions or an object with the restriction information |
| is_in_review_mode() X-Ref |
| Check if the lesson is in review mode. (The user already finished it and retakes are not allowed). return: bool true if is in review mode |
| get_last_page_seen($retriescount) X-Ref |
| Return the last page the current user saw. return: mixed false if the user didn't see the lesson or the last page id param: int $retriescount the number of retries for the lesson (the last retry number). |
| count_user_retries($userid) X-Ref |
| Return the number of retries in a lesson for a given user. return: int the retries count param: int $userid the user id |
| left_during_timed_session($retriescount) X-Ref |
| Check if a user left a timed session. return: true if the user left the timed session param: int $retriescount the number of retries for the lesson (the last retry number). |
| set_module_viewed() X-Ref |
| Trigger module viewed event and set the module viewed for completion. |
| get_user_timers($userid = null, $sort = '', $fields = '*', $limitfrom = 0, $limitnum = 0) X-Ref |
| Return the timers in the current lesson for the given user. return: array list of timers for the given user in the lesson param: int $userid the user id param: string $sort an order to sort the results in (optional, a valid SQL ORDER BY parameter). param: string $fields a comma separated list of fields to return param: int $limitfrom return a subset of records, starting at this point (optional). param: int $limitnum return a subset comprising this many records in total (optional, required if $limitfrom is set). |
| check_time($timer) X-Ref |
| Check if the user is out of time in a timed lesson. return: bool True if the user is on time, false is the user ran out of time param: stdClass $timer timer object |
| add_messages_on_page_view(lesson_page $page, $reviewmode) X-Ref |
| Add different informative messages to the given page. param: lesson_page $page page object param: reviewmode $bool whether we are in review mode or not |
| get_ongoing_score_message() X-Ref |
| Get the ongoing score message for the user (depending on the user permission and lesson settings). return: str the ongoing score message |
| calculate_progress() X-Ref |
| Calculate the progress of the current user in the lesson. return: int the progress (scale 0-100) |
| prepare_page_and_contents($pageid, $lessonoutput, $reviewmode, $redirect = true) X-Ref |
| Calculate the correct page and prepare contents for a given page id (could be a page jump id). return: array the page object and contents param: int $pageid the given page id param: mod_lesson_renderer $lessonoutput the lesson output rendered param: bool $reviewmode whether we are in review mode or not param: bool $redirect Optional, default to true. Set to false to avoid redirection and return the page to redirect. |
| calculate_new_page_on_jump(lesson_page $page, $newpageid) X-Ref |
| This returns a real page id to jump to (or LESSON_EOL) after processing page responses. return: int the real page to jump to (or end of lesson) param: lesson_page $page lesson page param: int $newpageid the new page id |
| process_page_responses(lesson_page $page) X-Ref |
| Process page responses. param: lesson_page $page page object |
| add_messages_on_page_process(lesson_page $page, $result, $reviewmode) X-Ref |
| Add different informative messages to the given page. param: lesson_page $page page object param: stdClass $result the page processing result object param: bool $reviewmode whether we are in review mode or not |
| process_eol_page($outoftime) X-Ref |
| Process and return all the information for the end of lesson page. return: stdclass an object with all the page data ready for rendering param: string $outoftime used to check to see if the student ran out of time |
| get_last_attempt(array $attempts) X-Ref |
| Returns the last "legal" attempt from the list of student attempts. return: stdClass The updated fom data. param: array $attempts The list of student attempts. |
Class: lesson_base - X-Ref
Abstract class to provide a core functions to the all lesson classesThis class should be abstracted by ALL classes with the lesson module to ensure
that all classes within this module can be interacted with in the same way.
This class provides the user with a basic properties array that can be fetched
or set via magic methods, or alternatively by defining methods get_blah() or
set_blah() within the extending object.
| __construct($properties) X-Ref |
| The constructor param: stdClass $properties |
| __set($key, $value) X-Ref |
| Magic property method Attempts to call a set_$key method if one exists otherwise falls back to simply set the property param: string $key param: mixed $value |
| __get($key) X-Ref |
| Magic get method Attempts to call a get_$key method to return the property and ralls over to return the raw property return: mixed param: str $key |
| __isset($key) X-Ref |
| Stupid PHP needs an isset magic method if you use the get magic method and still want empty calls to work.... blah ~! return: bool param: string $key |
| properties() X-Ref |
| Fetches all of the properties of the object return: stdClass |
Class: lesson_page - X-Ref
Abstract class representation of a page associated with a lesson.This class should MUST be extended by all specialised page types defined in
mod/lesson/pagetypes/.
There are a handful of abstract methods that need to be defined as well as
severl methods that can optionally be defined in order to make the page type
operate in the desired way
Database properties
| create($properties, lesson $lesson, $context, $maxbytes) X-Ref |
| Creates a new lesson_page within the database and returns the correct pagetype object to use to interact with the new lesson return: lesson_page Specialised object that extends lesson_page param: object $properties param: lesson $lesson |
| load($id, lesson $lesson) X-Ref |
| This method loads a page object from the database and returns it as a specialised object that extends lesson_page return: lesson_page Specialised lesson_page object param: int $id param: lesson $lesson |
| delete() X-Ref |
| Deletes a lesson_page from the database as well as any associated records. return: bool |
| move($nextpageid=null, $prevpageid=null) X-Ref |
| Moves a page by updating its nextpageid and prevpageid values within the database param: int $nextpageid param: int $prevpageid |
| get_answers() X-Ref |
| Returns the answers that are associated with this page in the database return: array |
| get_lesson() X-Ref |
| Returns the lesson this page is associated with return: lesson |
| get_type() X-Ref |
| Returns the type of page this is. Not to be confused with page type return: int |
| record_attempt($context) X-Ref |
| Records an attempt at this page return: stdClass Returns the result of the attempt param: stdClass $context |
| format_answer($answer, $context, $answerformat, $options = []) X-Ref |
| Formats the answer. Override for custom formatting. return: string Returns formatted string param: string $answer param: context $context param: int $answerformat |
| format_response($response, $context, $responseformat, $answerid, $options) X-Ref |
| Formats the response return: string Returns formatted string param: string $response param: context $context param: int $responseformat param: int $answerid param: stdClass $options |
| get_jump_name($jumpto) X-Ref |
| Returns the string for a jump name return: string param: int $jumpto Jump code or page ID |
| __construct($properties, lesson $lesson) X-Ref |
| Constructor method param: object $properties param: lesson $lesson |
| earned_score($answers, $attempt) X-Ref |
| Returns the score for the attempt This may be overridden by page types that require manual grading return: int param: array $answers param: object $attempt |
| callback_on_view($canmanage, $redirect = true) X-Ref |
| This is a callback method that can be override and gets called when ever a page is viewed return: mixed param: bool $canmanage True if the user has the manage cap param: bool $redirect Optional, default to true. Set to false to avoid redirection and return the page to redirect. |
| save_answers_files($context, $maxbytes, &$answer, $answereditor = '', $responseeditor = '') X-Ref |
| save editor answers files and update answer record param: object $context param: int $maxbytes param: object $answer param: object $answereditor param: object $responseeditor |
| rewrite_answers_urls($answer, $rewriteanswer = true) X-Ref |
| Rewrite urls in response and optionality answer of a question answer return: object answer with rewritten urls param: object $answer param: bool $rewriteanswer must rewrite answer |
| update($properties, $context = null, $maxbytes = null) X-Ref |
| Updates a lesson page and its answers within the database return: bool param: object $properties |
| add_page_link($previd) X-Ref |
| Can be set to true if the page requires a static link to create a new instance instead of simply being included in the dropdown return: bool param: int $previd |
| is_unseen($param) X-Ref |
| Returns true if a page has been viewed before return: bool param: array|int $param Either an array of pages that have been seen or the |
| is_unanswered($nretakes) X-Ref |
| Checks to see if a page has been answered previously return: bool param: int $nretakes |
| create_answers($properties) X-Ref |
| Creates answers within the database for this lesson_page. Usually only ever called when creating a new page instance return: array param: object $properties |
| check_answer() X-Ref |
| This method MUST be overridden by all question page types, or page types that wish to score a page. The structure of result should always be the same so it is a good idea when overriding this method on a page type to call <code> $result = parent::check_answer(); </code> before modifying it as required. return: stdClass |
| on_after_write_attempt($attempt, $result) X-Ref |
| Do any post persistence processing logic of an attempt. E.g. in cases where we need update file urls in an editor and we need to have the id of the stored attempt. Should be overridden in each individual child pagetype on a as required basis return: array False if nothing to be modified, updated $attempt and $result if update required. param: object $attempt The attempt corresponding to the db record param: object $result The result from the 'check_answer' method |
| has_option() X-Ref |
| True if the page uses a custom option Should be override and set to true if the page uses a custom option. return: bool |
| max_answers($default) X-Ref |
| Returns the maximum number of answers for this page given the maximum number of answers permitted by the lesson. return: int param: int $default |
| properties() X-Ref |
| Returns the properties of this lesson page as an object return: stdClass; |
| get_jumptooptions($pageid, lesson $lesson) X-Ref |
| Returns an array of options to display when choosing the jumpto for a page/answer return: array param: int $pageid param: lesson $lesson |
| get_contents() X-Ref |
| Returns the contents field for the page properly formatted and with plugin file url's converted return: string |
| get_displayinmenublock() X-Ref |
| Set to true if this page should display in the menu block return: bool |
| option_description_string() X-Ref |
| Get the string that describes the options of this page type return: string |
| display_answers(html_table $table) X-Ref |
| Updates a table with the answers for this page return: html_table param: html_table $table |
| get_grayout() X-Ref |
| Determines if this page should be grayed out on the management/report screens return: int 0 or 1 |
| stats(array &$pagestats, $tries) X-Ref |
| Adds stats for this page to the &pagestats object. This should be defined for all page types that grade return: bool param: array $pagestats param: int $tries |
| report_answers($answerpage, $answerdata, $useranswer, $pagestats, &$i, &$n) X-Ref |
| Formats the answers of this page for a report return: object The answer page for this param: object $answerpage param: object $answerdata param: object $useranswer param: array $pagestats param: int $i Count of first level answers param: int $n Count of second level answers |
| get_jumps() X-Ref |
| Gets an array of the jumps used by the answers of this page return: array |
| requires_manual_grading() X-Ref |
| Informs whether this page type require manual grading or not return: bool |
| override_next_page() X-Ref |
| A callback method that allows a page to override the next page a user will see during when this page is being completed. return: false|int |
| valid_page_and_view(&$validpages, &$pageviews) X-Ref |
| This method is used to determine if this page is a valid page return: int The next page id to check param: array $validpages param: array $pageviews |
| get_files($includedirs = true, $updatedsince = 0) X-Ref |
| Get files from the page area file. return: array list of stored_file objects param: bool $includedirs whether or not include directories param: int $updatedsince return files updated since this time |
| update_form_data(stdClass $data) X-Ref |
| Make updates to the form data if required. return: stdClass The updated fom data. param: stdClass $data The form data to update. |
Class: lesson_page_answer - X-Ref
Class used to represent an answer to a page| load($id) X-Ref |
| Loads an page answer from the DB return: lesson_page_answer param: int $id |
| create($properties, lesson_page $page) X-Ref |
| Given an object of properties and a page created answer(s) and saves them in the database. return: array param: stdClass $properties param: lesson_page $page |
| get_files($includedirs = true, $updatedsince = 0) X-Ref |
| Get files from the answer area file. return: array list of stored_file objects param: bool $includedirs whether or not include directories param: int $updatedsince return files updated since this time |
Class: lesson_page_type_manager - X-Ref
A management class for page typesThis class is responsible for managing the different pages. A manager object can
be retrieved by calling the following line of code:
<code>
$manager = lesson_page_type_manager::get($lesson);
</code>
The first time the page type manager is retrieved the it includes all of the
different page types located in mod/lesson/pagetypes.
| get(lesson $lesson) X-Ref |
| Retrieves the lesson page type manager object If the object hasn't yet been created it is created here. return: lesson_page_type_manager param: lesson $lesson |
| load_lesson_types(lesson $lesson) X-Ref |
| Finds and loads all lesson page types in mod/lesson/pagetypes param: lesson $lesson |
| get_page_type_strings($type=null, $special=true) X-Ref |
| Returns an array of strings to describe the loaded page types return: array param: int $type Can be used to return JUST the string for the requested type |
| get_page_type_idstring($id) X-Ref |
| Returns the basic string used to identify a page type provided with an id This string can be used to instantiate or identify the page type class. If the page type id is unknown then 'unknown' is returned return: string param: int $id |
| load_page($pageid, lesson $lesson) X-Ref |
| Loads a page for the provided lesson given it's id This function loads a page from the lesson when given both the lesson it belongs to as well as the page's id. If the page doesn't exist an error is thrown return: lesson_page A class that extends lesson_page param: int $pageid The id of the page to load param: lesson $lesson The lesson the page belongs to |
| check_page_order($page1, $page2) X-Ref |
| This function detects errors in the ordering between 2 pages and updates the page records. param: stdClass $page1 Either the first of 2 pages or null if the $page2 param is the first in the list. param: stdClass $page1 Either the second of 2 pages or null if the $page1 param is the last in the list. |
| load_all_pages(lesson $lesson) X-Ref |
| This function loads ALL pages that belong to the lesson. return: array An array of lesson_page_type_* param: lesson $lesson |
| get_page_form($type, $arguments) X-Ref |
| Fetches an mform that can be used to create/edit an page return: lesson_add_page_form_base param: int $type The id for the page type param: array $arguments Any arguments to pass to the mform |
| get_add_page_type_links($previd) X-Ref |
| Returns an array of links to use as add page links return: array param: int $previd The id of the previous page |
Functions that are not part of a class:
| lesson_display_teacher_warning($lesson) X-Ref |
| Checks to see if a LESSON_CLUSTERJUMP or a LESSON_UNSEENBRANCHPAGE is used in a lesson. This function is only executed when a teacher is checking the navigation for a lesson. return: boolean True or false. param: stdClass $lesson Id of the lesson that is to be checked. |
| lesson_unseen_question_jump($lesson, $user, $pageid) X-Ref |
| Interprets the LESSON_UNSEENBRANCHPAGE jump. will return the pageid of a random unseen page that is within a branch return: int Id of the next page. param: lesson $lesson param: int $userid Id of the user. param: int $pageid Id of the page from which we are jumping. |
| lesson_unseen_branch_jump($lesson, $userid) X-Ref |
| Handles the unseen branch table jump. return: int Will return the page id of a branch table or end of lesson param: lesson $lesson param: int $userid User id. |
| lesson_random_question_jump($lesson, $pageid) X-Ref |
| Handles the random jump between a branch table and end of branch or end of lesson (LESSON_RANDOMPAGE). return: int The pageid of a random page that is within a branch table param: lesson $lesson param: int $pageid The id of the page that we are jumping from (?) |
| lesson_grade($lesson, $ntries, $userid = 0) X-Ref |
| Calculates a user's grade for a lesson. return: object { nquestions => number of questions answered param: object $lesson The lesson that the user is taking. param: int $retries The attempt number. param: int $userid Id of the user (optional, default current user). |
| lesson_displayleftif($lesson) X-Ref |
| Determines if a user can view the left menu. The determining factor is whether a user has a grade greater than or equal to the lesson setting of displayleftif return: boolean 0 if the user cannot see, or $lesson->displayleft to keep displayleft unchanged param: object $lesson Lesson object of the current lesson |
| lesson_add_fake_blocks($page, $cm, $lesson, $timer = null) X-Ref |
return: unknown_type param: $cm param: $lesson param: $page |
| lesson_mediafile_block_contents($cmid, $lesson) X-Ref |
| If there is a media file associated with this lesson, return a block_contents that displays it. return: block_contents param: int $cmid Course Module ID for this lesson param: object $lesson Full lesson record object |
| lesson_clock_block_contents($cmid, $lesson, $timer, $page) X-Ref |
| If a timed lesson and not a teacher, then return a block_contents containing the clock. return: block_contents param: int $cmid Course Module ID for this lesson param: object $lesson Full lesson record object param: object $timer Full timer record object |
| lesson_menu_block_contents($cmid, $lesson) X-Ref |
| If left menu is turned on, then this will print the menu in a block return: void param: int $cmid Course Module ID for this lesson param: lesson $lesson Full lesson record object |
| lesson_add_header_buttons($cm, $context, $extraeditbuttons=false, $lessonpageid=null) X-Ref |
| Adds header buttons to the page for the lesson param: object $cm param: object $context param: bool $extraeditbuttons param: int $lessonpageid |
| lesson_get_media_html($lesson, $context) X-Ref |
| This is a function used to detect media types and generate html code. return: string $code the html code of media param: object $lesson param: object $context |
| lesson_process_group_deleted_in_course($courseid, $groupid = null) X-Ref |
| Logic to happen when a/some group(s) has/have been deleted in a course. return: void param: int $courseid The course ID. param: int $groupid The group id if it is known |
| lesson_get_overview_report_table_and_data(lesson $lesson, $currentgroup) X-Ref |
| Return the overview report table and data. return: mixed false if there is no information otherwise html_table and stdClass with the table and data param: lesson $lesson lesson instance param: mixed $currentgroup false if not group used, 0 for all groups, group id (int) to filter by that groups |
| lesson_get_user_detailed_report_data(lesson $lesson, $userid, $attempt) X-Ref |
| Return information about one user attempt (including answers) return: array the user answers (array) and user data stats (object) param: lesson $lesson lesson instance param: int $userid the user id param: int $attempt the attempt number |
| lesson_get_user_deadline($courseid) X-Ref |
| Return user's deadline for all lessons in a course, hereby taking into account group and user overrides. return: object An object with of all lessonsids and close unixdates in this course, param: int $courseid the course id. |
