Source for file configure_object.php

Documentation is available at configure_object.php

  1. <?php
  2.     /**
  3.     * Sloodle object configuration/authorization page.
  4.     *
  5.     * Allows users in Moodle to authorize or deny in-world objects' access to Moodle,
  6.     *  and to select the configuration settings.
  7.     *
  8.     * @package sloodleclassroom
  9.     * @copyright Copyright (c) 2007-8 Sloodle (various contributors)
  10.     * @license http://www.gnu.org/licenses/gpl-3.0.html GNU GPL v3
  11.     *
  12.     * @contributor Edmund Edgar
  13.     * @contributor Peter R. Bloomfield
  14.     *
  15.     */
  16.     
  17.     // Initially, the script should be accessed with a single parameter:
  18.     //
  19.     //  sloodleauthid = the integer ID of an (unauthorised) entry in the Sloodle 'active objects' table
  20.     //
  21.     // When the user clicks "yes" or "no" to confirm or deny the object's authorisation,
  22.     //  the following additional parameters will be added:
  23.     //
  24.     //  sloodlecontrollerid = the ID of the controller which is to be used
  25.     //  action = either 'auth' or 'cancel'
  26.     //
  27.     // If the action is 'confirm' then the object is authorised. Otherwise, its entry is deleted.
  28.     //
  29.     // The following parameter will usually also need to be specified:
  30.     //
  31.     //  sloodleobjtype = gives the type identifier of the object (not necessary if type is already registered)
  32.     
  33.     /** Grab the Sloodle/Moodle configuration. */
  34.     require_once('../sl_config.php');
  35.     /** Include the Sloodle PHP API. */
  36.     require_once(SLOODLE_LIBROOT.'/sloodle_session.php');
  37.     require_once(SLOODLE_LIBROOT.'/general.php');
  38.     
  39.     // Make sure the user is logged-in
  40.     sloodle_require_login_no_guest();
  41.     
  42.     // We need to know which object is being authorised and/or configured
  43.     $sloodleauthid = required_param('sloodleauthid', PARAM_INT);
  44.     $auth_obj = SloodleController::get_object($sloodleauthid);
  45.     if (!$auth_obj) {
  46.         error(get_string('objectauthnotfound','sloodle'));
  47.         exit();
  48.     }
  49.     // Is the object already authorised?
  50.     $object_authorised = $auth_obj->course->controller->is_loaded();
  51.     
  52.     // Get the object type (only necessary if it was not already in the database)
  53.     $sloodleobjtype = null;
  54.     if (empty($auth_obj->type)) {
  55.         $sloodleobjtype = required_param('sloodleobjtype', PARAM_TEXT);
  56.     } else {
  57.         $sloodleobjtype = optional_param('sloodleobjtype', null, PARAM_TEXT);
  58.     }
  59.     
  60.     // Treat this like a Sloodle session, but do not authenticate anything
  61.     $sloodle = new SloodleSession();
  62.     // Was a controller loaded by the request?
  63.     $loaded_controller = false;
  64.     if ($sloodle->course->controller->is_loaded()) {
  65.         $loaded_controller = true;
  66.     } else {
  67.         // If a controller was already specified for the object, then use that
  68.         if ($auth_obj->course->controller->is_loaded()) {
  69.             $loaded_controller = true;
  70.             $sloodle->course = $auth_obj->course;
  71.         }
  72.     }
  73.     
  74.     // Load the user
  75.     $sloodle->user->load_user($USER->id);
  76.     $sloodle->user->load_linked_avatar();
  77.     
  78.     // Fetch localization strings
  79.     $stryes = get_string('yes');
  80.     $strno = get_string('no');
  81.     
  82.     // Check if the confirmation action has been specified
  83.     $action = optional_param('action', '', PARAM_TEXT);
  84.     // If the action was not recognised, then ignore it
  85.     if ($action != 'auth' && $action != 'cancel') $action = '';
  86.     
  87.     // Determine the page name - it should be authorisation or configuration
  88.     $pagename = get_string('objectauth','sloodle');
  89.     if ($object_authorised == true || $action == 'auth') $pagename = get_string('objectconfiguration','sloodle');
  90.     
  91.     // Construct a breadcrumb navigation menu
  92.     $nav = get_string('modulename', 'sloodle').' -> ';
  93.     $nav .= $pagename;
  94.     // Display the page header
  95.     print_header($pagename, $pagename, $nav, '', '', false);
  96.     
  97.     
  98. //------------------------------------------------------------
  99. // AUTHORISATION STEP
  100.     
  101.     // Was an action specified? (Don't do this if the object was already authorised)
  102.     $action_success = false;
  103.     if (!empty($action) && $object_authorised == false) {
  104.         // Check if we were instructed to authorise, and also that we have a controller to authorise on
  105.         if ($action == 'auth' && $loaded_controller == true) {
  106.             // Make sure the user is allowed to authorise objects
  107.             $module_context = get_context_instance(CONTEXT_MODULE, $sloodle->course->controller->get_id());
  108.             require_capability('mod/sloodle:objectauth', $module_context);
  109.         
  110.             // Indicate that we are attempting authorisation
  111.             echo '<div style="text-align:center;">';
  112.             echo get_string('authorizingfor', 'sloodle').$sloodle->course->get_full_name().' &gt; '.$sloodle->course->controller->get_name().'<br><br>';
  113.         
  114.             // Attempt to authorise the entry
  115.             if ($sloodle->course->controller->authorise_object($auth_obj->uuid, $sloodle->user, $sloodleobjtype)) {
  116.                 echo '<span style="font-weight:bold; color:green;">'.get_string('objectauthsuccessful','sloodle').'</span><br>';
  117.                 $action_success = true;
  118.                 $object_authorised = true;
  119.                 // Reload the object data
  120.                 $auth_obj = SloodleController::get_object($sloodleauthid);
  121.                 
  122.             } else {
  123.                 echo '<span style="font-weight:bold; color:red;">'.get_string('objectauthfailed','sloodle').'</span><br>';
  124.             }
  125.             
  126.             echo "</div><br>\n";
  127.             
  128.         } else if ($action == 'cancel') {
  129.             // Attempt to delete the entry
  130.             $sloodle->course->controller->remove_object($sloodleauthid);
  131.             // Display the result
  132.             print_box(get_string('objectauthcancelled', 'sloodle'), 'generalbox boxaligncenter boxwidthnarrow');
  133.             $action_success = true;
  134.         }
  135.     } else if ($object_authorised) {
  136.         // If the object has already been authorised, then display a message about it
  137.         print_box_start('generalbox boxwidthnarrow boxaligncenter');
  138.         echo '<span style="color:red; font-weight:bold; text-align:center;">'.get_string('objectauthalready','sloodle').'</span>';
  139.         print_box_end();
  140.     }
  141.     
  142. //------------------------------------------------------------
  143. // OBJECT INFO
  144.     
  145.     // Display the information about the object
  146.     print_box_start('generalbox boxaligncenter boxwidthnarrow');
  147.     echo '<div style="text-align:center;">';
  148.     echo '<span style="font-weight:bold; font-size:110%;">'.get_string('objectdetails','sloodle').'</span><br>';
  149.     
  150.     echo get_string('objectname','sloodle').': '.$auth_obj->name.'<br>';
  151.     echo get_string('objectuuid','sloodle').': '.$auth_obj->uuid.'<br>';
  152.     echo get_string('objecttype','sloodle').': ';
  153.     if (!empty($sloodleobjtype)) echo $sloodleobjtype.'<br>';
  154.     else if (!empty($auth_obj->type)) echo $auth_obj->type.'<br>';
  155.     else echo '-<br>';
  156.     
  157.     echo '</div>';
  158.     print_box_end();
  159.     echo '<br>';
  160.     
  161. //------------------------------------------------------------
  162. // AUTHORISATION FORM
  163.     
  164.     // If the action was not performed or successful, then display the authorisation form
  165.     if ($action_success == false && $object_authorised == false) {
  166.         print_box_start('generalbox boxaligncenter boxwidthnormal');
  167.         echo '<div style="text-align:center;">';
  168.         echo '<h3>'.get_string('objectauth','sloodle').'</h3>';
  169.  
  170.         // If an authorisation action was attempted but the controller failed to load, then display an error message
  171.         if ($action == 'auth' && $loaded_controller = false) {
  172.             echo '<span style="font-weight:bold;color:red;">'.get_string('failedauth-trydifferent','sloodle').'</span>';
  173.         }
  174.         
  175.         // Get a list of controllers which the user is permitted to authorise objects on
  176.         // (It will be a 2d array - top level will be course ID's, 2nd level will be coursemodule ID's, containing database objects from the 'sloodle' table)
  177.         $controllers = array();
  178.         $recs = get_records('sloodle', 'type', SLOODLE_TYPE_CTRL);
  179.         // Make sure we have at least one controller
  180.         if ($recs == false || count($recs) == 0) {
  181.             error(get_string('objectauthnocontrollers','sloodle'));
  182.             exit();
  183.         }
  184.         foreach ($recs as $r) {
  185.             // Fetch the course module
  186.             $cm = get_coursemodule_from_instance('sloodle', $r->id);
  187.             // Check that the person can authorise objects of this module
  188.             if (has_capability('mod/sloodle:objectauth', get_context_instance(CONTEXT_MODULE, $cm->id))) {
  189.                 // Store this controller
  190.                 $controllers[$cm->course][$cm->id] = $r;
  191.             }
  192.         }
  193.         
  194.         // Make sure that permission came through on at least one controller
  195.         if (count($controllers) == 0) {
  196.             error(get_string('objectauthnopermission','sloodle'));
  197.             exit();
  198.         }
  199.         
  200.         // Construct the list of course names
  201.         $coursenames = array();
  202.         foreach ($controllers as $cid => $ctrl) {
  203.             $courserec = get_record('course', 'id', $cid, '','', '','', 'id,shortname,fullname');
  204.             if (!$courserec) $coursenames[$cid] = "(unknown)";
  205.             else $coursenames[$cid] = $courserec->fullname;
  206.         }
  207.         
  208.         // Sort the list alphabetically
  209.         natcasesort($coursenames);
  210.         
  211.         // Attempt to get our current controller, if possible, so we can pre-select it in the list
  212.         $cur_controller_id = 0;
  213.         if ($loaded_controller) {
  214.             $cur_controller_id = $sloodle->course->controller->get_id();
  215.         }
  216.         
  217.         // Display an authorisation form
  218.         echo '<form action="" method="GET">';
  219.         if (SLOODLE_DEBUG) echo '<input type="hidden" name="sloodledebug" value="true"/>';
  220.         if (!empty($sloodleauthid)) echo '<input type="hidden" name="sloodleauthid" value="'.$sloodleauthid.'"/>';
  221.         if (!empty($sloodleobjtype)) echo '<input type="hidden" name="sloodleobjtype" value="'.$sloodleobjtype.'"/>';
  222.         
  223.         // Ask the user to select a controller to authorise on
  224.         echo get_string('selectcontroller','sloodle').':<br><br>';
  225.         echo '<select name="sloodlecontrollerid" size="6">';
  226.         // Go through each course
  227.         foreach ($coursenames as $cid => $cname) { // We want to use the alphabetic sorting; get the course ID and name
  228.             // Output a disabled entry to act as a course header
  229.             echo "<option disabled=\"true\" style=\"font-weight:bold; font-style:italic; background-color:#eeeeee;\">{$cid}. $cname</option>\n";
  230.             
  231.             // Go through each controller in this course
  232.             foreach ($controllers[$cid] as $cmid => $ctrl) { // Get each controller in the course; get the course module ID and controller data
  233.                 echo "<option ";
  234.                 if ($cmid == $cur_controller_id) echo 'selected="true" ';
  235.                 echo "style=\"margin-left:8px;\" value=\"$cmid\">{$ctrl->name}</option>\n";
  236.             }
  237.         }
  238.         echo '</select><br><br>';
  239.         
  240.         // Ask the user if they want to confirm or deny the authorisation
  241.         echo get_string('confirmobjectauth', 'sloodle').' ';
  242.         echo '<select name="action" size="1">';
  243.         echo '<option style="color:green; font-weight:bold;" value="auth" selected="true">'.$stryes.'</option>';
  244.         echo '<option style="color:red; font-weight:bold;" value="cancel">'.$strno.'</option>';
  245.         echo '</select><br><br>';
  246.         
  247.         echo '<input type="submit" value="'.get_string('submit','sloodle').'"/>';
  248.         echo "</form>\n";
  249.         
  250.         echo '</div>';
  251.         print_box_end();
  252.     }
  253.     
  254.     
  255. //------------------------------------------------------------
  256. // CONFIGURATION FORM
  257.  
  258.     // Get the type
  259.     $usetype = "";
  260.     if (!empty($auth_obj->type)) $usetype = $auth_obj->type;
  261.     else $usetype = $sloodleobjtype;    
  262.     
  263.  
  264.     // If the object is now authorised, we can display its configuration form
  265.     if ($object_authorised && !empty($usetype)) {
  266.         // Make sure the user has permission to manage activities on this course
  267.         $course_context = get_context_instance(CONTEXT_COURSE, $auth_obj->course->get_course_id());
  268.         require_capability('moodle/course:manageactivities', $course_context);
  269.         
  270.         // Make sure the type value is stored in the database too
  271.         $sloodle->course->controller->update_object_type($auth_obj->uuid, $usetype);
  272.     
  273.         // Make sure the type exists
  274.         $objectpath = SLOODLE_DIRROOT."/mod/$usetype";
  275.         if (!file_exists($objectpath)) error(get_string('objectnotinstalled','sloodle'));
  276.         // Determine if we have a custom configuration page
  277.         $customconfig = $objectpath.'/object_config.php';
  278.         $hascustomconfig = file_exists($customconfig);
  279.         
  280.         // Display the configuration section
  281.         print_box_start('generalbox boxwidthnormal boxaligncenter');
  282.         echo '<div style="text-align:center;"><h2>'.get_string('objectconfiguration','sloodle').'</h2>';
  283.         
  284.         // Do we have custom configuration settings?
  285.         if ($hascustomconfig) {
  286.             // Display our configuration form
  287.             echo '<form action="'.SLOODLE_WWWROOT.'/classroom/store_object_config.php" method="POST">';
  288.             // Add a hidden field to store the object's type
  289.             echo '<input type="hidden" name="sloodleobjtype" value="'.$usetype.'"/>';
  290.             
  291.             
  292.             // Include the form elements
  293.             require($customconfig);
  294.             
  295.             
  296.             // Add this object's authorisation ID, and a submit button
  297.             echo '<br><input type="hidden" name="sloodleauthid" value="'.$sloodleauthid.'"/>';
  298.             if (SLOODLE_DEBUG) echo '<input type="hidden" name="sloodledebug" value="true"/>';
  299.             echo '<input type="submit" value="'.get_string('submit','sloodle').'"/>';
  300.             echo '</form>';
  301.             
  302.         } else {
  303.             // No configuration settings for this object
  304.             print_string('noobjectconfig','sloodle');
  305.             
  306.             // Add or udpate a configuration value to store this object's type
  307.             $cfgtype = get_record('sloodle_object_config', 'object', $sloodleauthid, 'name', 'sloodleobjtype');
  308.             if (!$cfgtype) {
  309.                 $cfgtype = new stdClass();
  310.                 $cfgtype->object = $sloodleauthid;
  311.                 $cfgtype->name = 'sloodleobjtype';
  312.                 $cfgtype->value = $usetype;
  313.                 insert_record('sloodle_object_config', $cfgtype);
  314.             } else {
  315.                 $cfgtype->value =  $usetype;
  316.                 update_record('sloodle_object_config', $cfgtype);
  317.             }
  318.         }
  319.         
  320.         echo '</div>';
  321.         print_box_end();
  322.     }
  323.     
  324.     
  325.     // Finish
  326.     print_footer();
  327.  
  328. ?>

Documentation generated on Fri, 17 Jul 2009 11:01:06 +0100 by phpDocumentor 1.4.0