admin/webservice/testclient_forms.php

   1 <?php
   2
   3 require_once($CFG->libdir.'/formslib.php');
   4
   5
   6 class webservice_test_client_form extends moodleform {
   7     public function definition() {
   8         global $CFG;
   9
  10         $mform = $this->_form;
  11         list($functions, $protocols) = $this->_customdata;
  12
  13         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
  14
  15         $authmethod = array('simple' => 'simple', 'token' => 'token');
  16         $mform->addElement('select', 'authmethod', get_string('authmethod', 'webservice'), $authmethod);
  17         $mform->setType('simple', PARAM_ALPHA);
  18
  19         $mform->addElement('select', 'protocol', get_string('protocol', 'webservice'), $protocols);
  20         $mform->setType('protocol', PARAM_ALPHA);
  21
  22         $mform->addElement('select', 'function', get_string('function', 'webservice'), $functions);
  23         $mform->setType('function', PARAM_PLUGIN);
  24
  25         $this->add_action_buttons(false, get_string('select'));
  26     }
  27 }
  28
  29 // === Test client forms ===
  30
  31 class moodle_user_create_users_form extends moodleform {
  32     public function definition() {
  33         global $CFG;
  34
  35         $mform = $this->_form;
  36
  37
  38         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
  39
  40         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
  41         $data = $this->_customdata;
  42         if ($data['authmethod'] == 'simple') {
  43             $mform->addElement('text', 'wsusername', 'wsusername');
  44             $mform->setType('wsusername', PARAM_USERNAME);
  45             $mform->addElement('text', 'wspassword', 'wspassword');
  46             $mform->setType('wspassword', PARAM_RAW);
  47         } else if ($data['authmethod'] == 'token') {
  48             $mform->addElement('text', 'token', 'token');
  49             $mform->setType('token', PARAM_RAW_TRIMMED);
  50         }
  51
  52         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
  53         $mform->setType('authmethod', PARAM_SAFEDIR);
  54
  55         /// specific to the create users function
  56         $mform->addElement('text', 'username', 'username');
  57         $mform->setType('username', PARAM_USERNAME);
  58         $mform->addElement('text', 'password', 'password');
  59         $mform->setType('password', PARAM_RAW);
  60         $mform->addElement('text', 'firstname', 'firstname');
  61         $mform->setType('firstname', PARAM_RAW);
  62         $mform->addElement('text', 'lastname', 'lastname');
  63         $mform->setType('lastname', PARAM_RAW);
  64         $mform->addElement('text', 'email', 'email');
  65         $mform->setType('email', PARAM_EMAIL);
  66
  67         $mform->addElement('text', 'customfieldtype', 'customfieldtype');
  68         $mform->setType('customfieldtype', PARAM_RAW);
  69         $mform->addElement('text', 'customfieldvalue', 'customfieldvalue');
  70         $mform->setType('customfieldvalue', PARAM_RAW);
  71
  72         $mform->addElement('hidden', 'function');
  73         $mform->setType('function', PARAM_PLUGIN);
  74
  75         $mform->addElement('hidden', 'protocol');
  76         $mform->setType('protocol', PARAM_ALPHA);
  77
  78
  79
  80         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
  81
  82         $this->add_action_buttons(true, get_string('execute', 'webservice'));
  83     }
  84
  85     public function get_params() {
  86         if (!$data = $this->get_data()) {
  87             return null;
  88         }
  89
  90         //set customfields
  91         if (!empty($data->customfieldtype)) {
  92             $data->customfields = array(array('type' => $data->customfieldtype, 'value' => $data->customfieldvalue));
  93         }
  94
  95         // remove unused from form data
  96         unset($data->submitbutton);
  97         unset($data->protocol);
  98         unset($data->function);
  99         unset($data->wsusername);
 100         unset($data->wspassword);
 101         unset($data->token);
 102         unset($data->authmethod);
 103         unset($data->customfieldtype);
 104         unset($data->customfieldvalue);
 105
 106         $params = array();
 107         $params['users'] = array();
 108         $params['users'][] = (array)$data;
 109
 110         return $params;
 111     }
 112 }
 113
 114
 115 class moodle_user_update_users_form extends moodleform {
 116     public function definition() {
 117         global $CFG;
 118
 119         $mform = $this->_form;
 120
 121
 122         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 123
 124         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 125         $data = $this->_customdata;
 126         if ($data['authmethod'] == 'simple') {
 127             $mform->addElement('text', 'wsusername', 'wsusername');
 128             $mform->setType('wsusername', PARAM_USERNAME);
 129             $mform->addElement('text', 'wspassword', 'wspassword');
 130             $mform->setType('wspassword', PARAM_RAW);
 131         } else if ($data['authmethod'] == 'token') {
 132             $mform->addElement('text', 'token', 'token');
 133             $mform->setType('token', PARAM_RAW_TRIMMED);
 134         }
 135
 136         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 137         $mform->setType('authmethod', PARAM_ALPHA);
 138
 139         /// specific to the create users function
 140         $mform->addElement('text', 'id', 'id');
 141         $mform->addRule('id', get_string('required'), 'required', null, 'client');
 142         $mform->setType('id', PARAM_INT);
 143         $mform->addElement('text', 'username', 'username');
 144         $mform->setType('username', PARAM_USERNAME);
 145         $mform->addElement('text', 'password', 'password');
 146         $mform->setType('password', PARAM_RAW);
 147         $mform->addElement('text', 'firstname', 'firstname');
 148         $mform->setType('firstname', PARAM_RAW);
 149         $mform->addElement('text', 'lastname', 'lastname');
 150         $mform->setType('lastname', PARAM_RAW);
 151         $mform->addElement('text', 'email', 'email');
 152         $mform->setType('email', PARAM_EMAIL);
 153
 154
 155         $mform->addElement('text', 'customfieldtype', 'customfieldtype');
 156         $mform->setType('customfieldtype', PARAM_RAW);
 157         $mform->addElement('text', 'customfieldvalue', 'customfieldvalue');
 158         $mform->setType('customfieldvalue', PARAM_RAW);
 159
 160         $mform->addElement('hidden', 'function');
 161         $mform->setType('function', PARAM_PLUGIN);
 162
 163         $mform->addElement('hidden', 'protocol');
 164         $mform->setType('protocol', PARAM_ALPHA);
 165
 166
 167
 168         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
 169
 170         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 171     }
 172
 173     public function get_params() {
 174         if (!$data = $this->get_data()) {
 175             return null;
 176         }
 177
 178         //set customfields
 179         if (!empty($data->customfieldtype)) {
 180             $data->customfields = array(array('type' => $data->customfieldtype, 'value' => $data->customfieldvalue));
 181         }
 182
 183         // remove unused from form data
 184         unset($data->submitbutton);
 185         unset($data->protocol);
 186         unset($data->function);
 187         unset($data->wsusername);
 188         unset($data->wspassword);
 189         unset($data->token);
 190         unset($data->authmethod);
 191         unset($data->customfieldtype);
 192         unset($data->customfieldvalue);
 193
 194         foreach($data as $key => $value) {
 195             if (empty($value)) {
 196                  unset($data->{$key});
 197             }
 198         }
 199
 200         $params = array();
 201         $params['users'] = array();
 202         $params['users'][] = (array)$data;
 203
 204         return $params;
 205     }
 206 }
 207
 208
 209 class moodle_user_delete_users_form extends moodleform {
 210     public function definition() {
 211         global $CFG;
 212
 213         $mform = $this->_form;
 214
 215
 216         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 217
 218         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 219         $data = $this->_customdata;
 220         if ($data['authmethod'] == 'simple') {
 221             $mform->addElement('text', 'wsusername', 'wsusername');
 222             $mform->setType('wsusername', PARAM_USERNAME);
 223             $mform->addElement('text', 'wspassword', 'wspassword');
 224             $mform->setType('wspassword', PARAM_RAW);
 225         } else if ($data['authmethod'] == 'token') {
 226             $mform->addElement('text', 'token', 'token');
 227             $mform->setType('token', PARAM_RAW_TRIMMED);
 228         }
 229
 230         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 231         $mform->setType('authmethod', PARAM_ALPHA);
 232
 233         /// beginning of specific code to the create users function
 234         $mform->addElement('text', 'userids[0]', 'userids[0]');
 235         $mform->addElement('text', 'userids[1]', 'userids[1]');
 236         $mform->addElement('text', 'userids[2]', 'userids[2]');
 237         $mform->addElement('text', 'userids[3]', 'userids[3]');
 238         $mform->setType('userids', PARAM_INT);
 239         /// end of specific code to the create users function
 240
 241         $mform->addElement('hidden', 'function');
 242         $mform->setType('function', PARAM_PLUGIN);
 243
 244         $mform->addElement('hidden', 'protocol');
 245         $mform->setType('protocol', PARAM_ALPHA);
 246
 247         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
 248
 249         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 250     }
 251
 252     public function get_params() {
 253         if (!$data = $this->get_data()) {
 254             return null;
 255         }
 256         // remove unused from form data
 257         unset($data->submitbutton);
 258         unset($data->protocol);
 259         unset($data->function);
 260         unset($data->wsusername);
 261         unset($data->wspassword);
 262         unset($data->token);
 263         unset($data->authmethod);
 264
 265         ///  beginning of specific code to the create users form
 266         $params = array();
 267         $params['userids'] = array();
 268         for ($i=0; $i<10; $i++) {
 269             if (empty($data->userids[$i])) {
 270                 continue;
 271             }
 272             $params['userids'][] = $data->userids[$i];
 273         }
 274         /// end of specific code to the create users function
 275
 276         return $params;
 277     }
 278 }
 279
 280
 281 class moodle_user_get_users_by_id_form extends moodleform {
 282     public function definition() {
 283         global $CFG;
 284
 285         $mform = $this->_form;
 286
 287
 288         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 289
 290         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 291         $data = $this->_customdata;
 292         if ($data['authmethod'] == 'simple') {
 293             $mform->addElement('text', 'wsusername', 'wsusername');
 294             $mform->setType('wsusername', PARAM_USERNAME);
 295             $mform->addElement('text', 'wspassword', 'wspassword');
 296             $mform->setType('wspassword', PARAM_RAW);
 297         } else if ($data['authmethod'] == 'token') {
 298             $mform->addElement('text', 'token', 'token');
 299             $mform->setType('token', PARAM_RAW_TRIMMED);
 300         }
 301
 302         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 303         $mform->setType('authmethod', PARAM_ALPHA);
 304
 305         /// beginning of specific code to the create users function
 306         $mform->addElement('text', 'userids[0]', 'userids[0]');
 307         $mform->addElement('text', 'userids[1]', 'userids[1]');
 308         $mform->addElement('text', 'userids[2]', 'userids[2]');
 309         $mform->addElement('text', 'userids[3]', 'userids[3]');
 310         $mform->setType('userids', PARAM_INT);
 311         /// end of specific code to the create users function
 312
 313         $mform->addElement('hidden', 'function');
 314         $mform->setType('function', PARAM_PLUGIN);
 315
 316         $mform->addElement('hidden', 'protocol');
 317         $mform->setType('protocol', PARAM_ALPHA);
 318
 319
 320
 321         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
 322
 323         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 324     }
 325
 326     public function get_params() {
 327         if (!$data = $this->get_data()) {
 328             return null;
 329         }
 330         // remove unused from form data
 331         unset($data->submitbutton);
 332         unset($data->protocol);
 333         unset($data->function);
 334         unset($data->wsusername);
 335         unset($data->wspassword);
 336         unset($data->token);
 337         unset($data->authmethod);
 338
 339         ///  beginning of specific code to the create users form
 340         $params = array();
 341         $params['userids'] = array();
 342         for ($i=0; $i<10; $i++) {
 343             if (empty($data->userids[$i])) {
 344                 continue;
 345             }
 346             $params['userids'][] = $data->userids[$i];
 347         }
 348         /// end of specific code to the create users function
 349
 350         return $params;
 351     }
 352 }
 353
 354 class moodle_group_create_groups_form extends moodleform {
 355     public function definition() {
 356         global $CFG;
 357
 358         $mform = $this->_form;
 359
 360
 361         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 362
 363         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 364         $data = $this->_customdata;
 365         if ($data['authmethod'] == 'simple') {
 366             $mform->addElement('text', 'wsusername', 'wsusername');
 367             $mform->setType('wsusername', PARAM_USERNAME);
 368             $mform->addElement('text', 'wspassword', 'wspassword');
 369             $mform->setType('wspassword', PARAM_RAW);
 370         } else if ($data['authmethod'] == 'token') {
 371             $mform->addElement('text', 'token', 'token');
 372             $mform->setType('token', PARAM_RAW_TRIMMED);
 373         }
 374
 375         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 376         $mform->setType('authmethod', PARAM_ALPHA);
 377
 378         $mform->addElement('text', 'courseid', 'courseid');
 379         $mform->setType('courseid', PARAM_INT);
 380         $mform->addElement('text', 'name', 'name');
 381         $mform->setType('name', PARAM_TEXT);
 382         $mform->addElement('text', 'description', 'description');
 383         $mform->setType('description', PARAM_TEXT);
 384         $mform->addElement('text', 'enrolmentkey', 'enrolmentkey');
 385         $mform->setType('enrolmentkey', PARAM_RAW);
 386
 387         $mform->addElement('hidden', 'function');
 388         $mform->setType('function', PARAM_PLUGIN);
 389
 390         $mform->addElement('hidden', 'protocol');
 391         $mform->setType('protocol', PARAM_ALPHA);
 392
 393
 394
 395         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
 396
 397         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 398     }
 399
 400     public function get_params() {
 401         if (!$data = $this->get_data()) {
 402             return null;
 403         }
 404         // remove unused from form data
 405         unset($data->submitbutton);
 406         unset($data->protocol);
 407         unset($data->function);
 408         unset($data->wsusername);
 409         unset($data->wspassword);
 410         unset($data->token);
 411         unset($data->authmethod);
 412
 413         $params = array();
 414         $params['groups'] = array();
 415         $params['groups'][] = (array)$data;
 416
 417         return $params;
 418     }
 419 }
 420
 421 class moodle_group_get_groups_form extends moodleform {
 422     public function definition() {
 423         global $CFG;
 424
 425         $mform = $this->_form;
 426
 427         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 428
 429         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 430         $data = $this->_customdata;
 431         if ($data['authmethod'] == 'simple') {
 432             $mform->addElement('text', 'wsusername', 'wsusername');
 433             $mform->setType('wsusername', PARAM_USERNAME);
 434             $mform->addElement('text', 'wspassword', 'wspassword');
 435             $mform->setType('wspassword', PARAM_RAW);
 436         } else if ($data['authmethod'] == 'token') {
 437             $mform->addElement('text', 'token', 'token');
 438             $mform->setType('token', PARAM_RAW_TRIMMED);
 439         }
 440
 441         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 442         $mform->setType('authmethod', PARAM_ALPHA);
 443         $mform->addElement('text', 'groupids[0]', 'groupids[0]');
 444         $mform->addElement('text', 'groupids[1]', 'groupids[1]');
 445         $mform->addElement('text', 'groupids[2]', 'groupids[2]');
 446         $mform->addElement('text', 'groupids[3]', 'groupids[3]');
 447         $mform->setType('groupids', PARAM_INT);
 448
 449         $mform->addElement('hidden', 'function');
 450         $mform->setType('function', PARAM_PLUGIN);
 451
 452         $mform->addElement('hidden', 'protocol');
 453         $mform->setType('protocol', PARAM_ALPHA);
 454
 455         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 456     }
 457
 458     public function get_params() {
 459         if (!$data = $this->get_data()) {
 460             return null;
 461         }
 462         // remove unused from form data
 463         unset($data->submitbutton);
 464         unset($data->protocol);
 465         unset($data->function);
 466         unset($data->wsusername);
 467         unset($data->wspassword);
 468         unset($data->token);
 469         unset($data->authmethod);
 470
 471         $params = array();
 472         $params['groupids'] = array();
 473         for ($i=0; $i<10; $i++) {
 474             if (empty($data->groupids[$i])) {
 475                 continue;
 476             }
 477             $params['groupids'][] = $data->groupids[$i];
 478         }
 479
 480         return $params;
 481     }
 482 }
 483
 484 class moodle_group_get_course_groups_form extends moodleform {
 485     public function definition() {
 486         global $CFG;
 487
 488         $mform = $this->_form;
 489
 490         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 491
 492         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 493         $data = $this->_customdata;
 494         if ($data['authmethod'] == 'simple') {
 495             $mform->addElement('text', 'wsusername', 'wsusername');
 496             $mform->setType('wsusername', PARAM_USERNAME);
 497             $mform->addElement('text', 'wspassword', 'wspassword');
 498             $mform->setType('wspassword', PARAM_RAW);
 499         } else if ($data['authmethod'] == 'token') {
 500             $mform->addElement('text', 'token', 'token');
 501             $mform->setType('token', PARAM_RAW_TRIMMED);
 502         }
 503
 504         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 505         $mform->setType('authmethod', PARAM_ALPHA);
 506         $mform->addElement('text', 'courseid', 'courseid');
 507
 508         $mform->addElement('hidden', 'function');
 509         $mform->setType('function', PARAM_PLUGIN);
 510
 511         $mform->addElement('hidden', 'protocol');
 512         $mform->setType('protocol', PARAM_ALPHA);
 513
 514         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 515     }
 516
 517     public function get_params() {
 518         if (!$data = $this->get_data()) {
 519             return null;
 520         }
 521         // remove unused from form data
 522         unset($data->submitbutton);
 523         unset($data->protocol);
 524         unset($data->function);
 525         unset($data->wsusername);
 526         unset($data->wspassword);
 527         unset($data->token);
 528         unset($data->authmethod);
 529
 530         $params = array();
 531         $params['courseid'] = $data->courseid;
 532
 533         return $params;
 534     }
 535 }
 536
 537 class moodle_group_delete_groups_form extends moodleform {
 538     public function definition() {
 539         global $CFG;
 540
 541         $mform = $this->_form;
 542
 543         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 544
 545         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 546         $data = $this->_customdata;
 547         if ($data['authmethod'] == 'simple') {
 548             $mform->addElement('text', 'wsusername', 'wsusername');
 549             $mform->setType('wsusername', PARAM_USERNAME);
 550             $mform->addElement('text', 'wspassword', 'wspassword');
 551             $mform->setType('wspassword', PARAM_RAW);
 552         } else if ($data['authmethod'] == 'token') {
 553             $mform->addElement('text', 'token', 'token');
 554             $mform->setType('token', PARAM_RAW_TRIMMED);
 555         }
 556
 557         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 558         $mform->setType('authmethod', PARAM_ALPHA);
 559         $mform->addElement('text', 'groupids[0]', 'groupids[0]');
 560         $mform->addElement('text', 'groupids[1]', 'groupids[1]');
 561         $mform->addElement('text', 'groupids[2]', 'groupids[2]');
 562         $mform->addElement('text', 'groupids[3]', 'groupids[3]');
 563         $mform->setType('groupids', PARAM_INT);
 564
 565         $mform->addElement('hidden', 'function');
 566         $mform->setType('function', PARAM_PLUGIN);
 567
 568         $mform->addElement('hidden', 'protocol');
 569         $mform->setType('protocol', PARAM_ALPHA);
 570
 571         $mform->addElement('static', 'warning', '', get_string('executewarnign', 'webservice'));
 572
 573         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 574     }
 575
 576     public function get_params() {
 577         if (!$data = $this->get_data()) {
 578             return null;
 579         }
 580         // remove unused from form data
 581         unset($data->submitbutton);
 582         unset($data->protocol);
 583         unset($data->function);
 584         unset($data->wsusername);
 585         unset($data->wspassword);
 586         unset($data->token);
 587         unset($data->authmethod);
 588
 589         $params = array();
 590         $params['groupids'] = array();
 591         for ($i=0; $i<10; $i++) {
 592             if (empty($data->groupids[$i])) {
 593                 continue;
 594             }
 595             $params['groupids'][] = $data->groupids[$i];
 596         }
 597
 598         return $params;
 599     }
 600 }
 601
 602 class moodle_group_get_groupmembers_form extends moodleform {
 603     public function definition() {
 604         global $CFG;
 605
 606         $mform = $this->_form;
 607
 608         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 609
 610         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 611         $data = $this->_customdata;
 612         if ($data['authmethod'] == 'simple') {
 613             $mform->addElement('text', 'wsusername', 'wsusername');
 614             $mform->setType('wsusername', PARAM_USERNAME);
 615             $mform->addElement('text', 'wspassword', 'wspassword');
 616             $mform->setType('wspassword', PARAM_RAW);
 617         } else if ($data['authmethod'] == 'token') {
 618             $mform->addElement('text', 'token', 'token');
 619             $mform->setType('token', PARAM_RAW_TRIMMED);
 620         }
 621
 622         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 623         $mform->setType('authmethod', PARAM_ALPHA);
 624         $mform->addElement('text', 'groupids[0]', 'groupids[0]');
 625         $mform->addElement('text', 'groupids[1]', 'groupids[1]');
 626         $mform->addElement('text', 'groupids[2]', 'groupids[2]');
 627         $mform->addElement('text', 'groupids[3]', 'groupids[3]');
 628         $mform->setType('groupids', PARAM_INT);
 629
 630         $mform->addElement('hidden', 'function');
 631         $mform->setType('function', PARAM_PLUGIN);
 632
 633         $mform->addElement('hidden', 'protocol');
 634         $mform->setType('protocol', PARAM_ALPHA);
 635
 636         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 637     }
 638
 639     public function get_params() {
 640         if (!$data = $this->get_data()) {
 641             return null;
 642         }
 643         // remove unused from form data
 644         unset($data->submitbutton);
 645         unset($data->protocol);
 646         unset($data->function);
 647         unset($data->wsusername);
 648         unset($data->wspassword);
 649         unset($data->token);
 650         unset($data->authmethod);
 651
 652         $params = array();
 653         $params['groupids'] = array();
 654         for ($i=0; $i<10; $i++) {
 655             if (empty($data->groupids[$i])) {
 656                 continue;
 657             }
 658             $params['groupids'][] = $data->groupids[$i];
 659         }
 660
 661         return $params;
 662     }
 663 }
 664
 665 class moodle_group_add_groupmembers_form extends moodleform {
 666     public function definition() {
 667         global $CFG;
 668
 669         $mform = $this->_form;
 670
 671         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 672
 673         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 674         $data = $this->_customdata;
 675         if ($data['authmethod'] == 'simple') {
 676             $mform->addElement('text', 'wsusername', 'wsusername');
 677             $mform->setType('wsusername', PARAM_USERNAME);
 678             $mform->addElement('text', 'wspassword', 'wspassword');
 679             $mform->setType('wspassword', PARAM_RAW);
 680         } else if ($data['authmethod'] == 'token') {
 681             $mform->addElement('text', 'token', 'token');
 682             $mform->setType('token', PARAM_RAW_TRIMMED);
 683         }
 684
 685         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 686         $mform->setType('authmethod', PARAM_SAFEDIR);
 687         $mform->addElement('text', 'userid[0]', 'userid[0]');
 688         $mform->addElement('text', 'groupid[0]', 'groupid[0]');
 689         $mform->addElement('text', 'userid[1]', 'userid[1]');
 690         $mform->addElement('text', 'groupid[1]', 'groupid[1]');
 691         $mform->setType('userid', PARAM_INT);
 692         $mform->setType('groupids', PARAM_INT);
 693
 694         $mform->addElement('hidden', 'function');
 695         $mform->setType('function', PARAM_PLUGIN);
 696
 697         $mform->addElement('hidden', 'protocol');
 698         $mform->setType('protocol', PARAM_ALPHA);
 699
 700         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 701     }
 702
 703     public function get_params() {
 704         if (!$data = $this->get_data()) {
 705             return null;
 706         }
 707         // remove unused from form data
 708         unset($data->submitbutton);
 709         unset($data->protocol);
 710         unset($data->function);
 711         unset($data->wsusername);
 712         unset($data->wspassword);
 713         unset($data->token);
 714         unset($data->authmethod);
 715
 716         $params = array();
 717         $params['members'] = array();
 718         for ($i=0; $i<10; $i++) {
 719             if (empty($data->groupid[$i]) or empty($data->userid[$i])) {
 720                 continue;
 721             }
 722             $params['members'][] = array('userid'=>$data->userid[$i], 'groupid'=>$data->groupid[$i]);
 723         }
 724
 725         return $params;
 726     }
 727 }
 728
 729 class moodle_group_delete_groupmembers_form extends moodleform {
 730     public function definition() {
 731         global $CFG;
 732
 733         $mform = $this->_form;
 734
 735         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 736
 737         //note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters
 738         $data = $this->_customdata;
 739         if ($data['authmethod'] == 'simple') {
 740             $mform->addElement('text', 'wsusername', 'wsusername');
 741             $mform->setType('wsusername', PARAM_USERNAME);
 742             $mform->addElement('text', 'wspassword', 'wspassword');
 743             $mform->setType('wspassword', PARAM_RAW);
 744         } else if ($data['authmethod'] == 'token') {
 745             $mform->addElement('text', 'token', 'token');
 746             $mform->setType('token', PARAM_RAW_TRIMMED);
 747         }
 748
 749         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 750         $mform->setType('authmethod', PARAM_ALPHA);
 751         $mform->addElement('text', 'userid[0]', 'userid[0]');
 752         $mform->addElement('text', 'groupid[0]', 'groupid[0]');
 753         $mform->addElement('text', 'userid[1]', 'userid[1]');
 754         $mform->addElement('text', 'groupid[1]', 'groupid[1]');
 755         $mform->setType('userid', PARAM_INT);
 756         $mform->setType('groupids', PARAM_INT);
 757
 758         $mform->addElement('hidden', 'function');
 759         $mform->setType('function', PARAM_PLUGIN);
 760
 761         $mform->addElement('hidden', 'protocol');
 762         $mform->setType('protocol', PARAM_ALPHA);
 763
 764         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 765     }
 766
 767     public function get_params() {
 768         if (!$data = $this->get_data()) {
 769             return null;
 770         }
 771         // remove unused from form data
 772         unset($data->submitbutton);
 773         unset($data->protocol);
 774         unset($data->function);
 775         unset($data->wsusername);
 776         unset($data->wspassword);
 777         unset($data->token);
 778         unset($data->authmethod);
 779
 780         $params = array();
 781         $params['members'] = array();
 782         for ($i=0; $i<10; $i++) {
 783             if (empty($data->groupid[$i]) or empty($data->userid[$i])) {
 784                 continue;
 785             }
 786             $params['members'][] = array('userid'=>$data->userid[$i], 'groupid'=>$data->groupid[$i]);
 787         }
 788
 789         return $params;
 790     }
 791 }
 792
 793 /**
 794  * Form class for create_categories() web service function test.
 795  *
 796  * @package   core_webservice
 797  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 798  * @copyright 2012 Fabio Souto
 799  */
 800 class core_course_create_categories_form extends moodleform {
 801     /**
 802      * The form definition.
 803      */
 804     public function definition() {
 805         global $CFG;
 806
 807         $mform = $this->_form;
 808
 809         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 810
 811         // Note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters.
 812         $data = $this->_customdata;
 813         if ($data['authmethod'] == 'simple') {
 814             $mform->addElement('text', 'wsusername', 'wsusername');
 815             $mform->setType('wsusername', PARAM_USERNAME);
 816             $mform->addElement('text', 'wspassword', 'wspassword');
 817             $mform->setType('wspassword', PARAM_RAW);
 818         } else if ($data['authmethod'] == 'token') {
 819             $mform->addElement('text', 'token', 'token');
 820             $mform->setType('token', PARAM_RAW_TRIMMED);
 821         }
 822
 823         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 824         $mform->setType('authmethod', PARAM_ALPHA);
 825         $mform->addElement('text', 'name[0]', 'name[0]');
 826         $mform->addElement('text', 'parent[0]', 'parent[0]');
 827         $mform->addElement('text', 'idnumber[0]', 'idnumber[0]');
 828         $mform->addElement('text', 'description[0]', 'description[0]');
 829         $mform->addElement('text', 'name[1]', 'name[1]');
 830         $mform->addElement('text', 'parent[1]', 'parent[1]');
 831         $mform->addElement('text', 'idnumber[1]', 'idnumber[1]');
 832         $mform->addElement('text', 'description[1]', 'description[1]');
 833         $mform->setType('name', PARAM_TEXT);
 834         $mform->setType('parent', PARAM_INT);
 835         $mform->setType('idnumber', PARAM_RAW);
 836         $mform->setType('description', PARAM_TEXT);
 837
 838         $mform->addElement('hidden', 'function');
 839         $mform->setType('function', PARAM_PLUGIN);
 840
 841         $mform->addElement('hidden', 'protocol');
 842         $mform->setType('protocol', PARAM_ALPHA);
 843
 844         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 845     }
 846
 847     /**
 848      * Get the parameters that the user submitted using the form.
 849      * @return array|null
 850      */
 851     public function get_params() {
 852         if (!$data = $this->get_data()) {
 853             return null;
 854         }
 855         // Remove unused from form data.
 856         unset($data->submitbutton);
 857         unset($data->protocol);
 858         unset($data->function);
 859         unset($data->wsusername);
 860         unset($data->wspassword);
 861         unset($data->token);
 862         unset($data->authmethod);
 863
 864         $params = array();
 865         $params['categories'] = array();
 866         for ($i=0; $i<10; $i++) {
 867             if (empty($data->name[$i]) or empty($data->parent[$i])) {
 868                 continue;
 869             }
 870             $params['categories'][] = array('name'=>$data->name[$i], 'parent'=>$data->parent[$i],
 871                                             'idnumber'=>$data->idnumber[$i], 'description'=>$data->description[$i]);
 872         }
 873         return $params;
 874     }
 875 }
 876
 877 /**
 878  * Form class for delete_categories() web service function test.
 879  *
 880  * @package   core_webservice
 881  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 882  * @copyright 2012 Fabio Souto
 883  */
 884 class core_course_delete_categories_form extends moodleform {
 885     /**
 886      * The form definition.
 887      */
 888     public function definition() {
 889         global $CFG;
 890
 891         $mform = $this->_form;
 892
 893         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 894
 895         // Note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters.
 896         $data = $this->_customdata;
 897         if ($data['authmethod'] == 'simple') {
 898             $mform->addElement('text', 'wsusername', 'wsusername');
 899             $mform->setType('wsusername', PARAM_USERNAME);
 900             $mform->addElement('text', 'wspassword', 'wspassword');
 901             $mform->setType('wspassword', PARAM_RAW);
 902         } else if ($data['authmethod'] == 'token') {
 903             $mform->addElement('text', 'token', 'token');
 904             $mform->setType('token', PARAM_RAW_TRIMMED);
 905         }
 906
 907         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 908         $mform->setType('authmethod', PARAM_ALPHA);
 909         $mform->addElement('text', 'id[0]', 'id[0]');
 910         $mform->addElement('text', 'newparent[0]', 'newparent[0]');
 911         $mform->addElement('text', 'recursive[0]', 'recursive[0]');
 912         $mform->addElement('text', 'id[1]', 'id[1]');
 913         $mform->addElement('text', 'newparent[1]', 'newparent[1]');
 914         $mform->addElement('text', 'recursive[1]', 'recursive[1]');
 915         $mform->setType('id', PARAM_INT);
 916         $mform->setType('newparent', PARAM_INT);
 917         $mform->setType('recursive', PARAM_BOOL);
 918
 919         $mform->addElement('hidden', 'function');
 920         $mform->setType('function', PARAM_PLUGIN);
 921
 922         $mform->addElement('hidden', 'protocol');
 923         $mform->setType('protocol', PARAM_ALPHA);
 924
 925         $this->add_action_buttons(true, get_string('execute', 'webservice'));
 926     }
 927
 928     /**
 929      * Get the parameters that the user submitted using the form.
 930      * @return array|null
 931      */
 932     public function get_params() {
 933         if (!$data = $this->get_data()) {
 934             return null;
 935         }
 936         // Remove unused from form data.
 937         unset($data->submitbutton);
 938         unset($data->protocol);
 939         unset($data->function);
 940         unset($data->wsusername);
 941         unset($data->wspassword);
 942         unset($data->token);
 943         unset($data->authmethod);
 944
 945         $params = array();
 946         $params['categories'] = array();
 947         for ($i=0; $i<10; $i++) {
 948             if (empty($data->id[$i])) {
 949                 continue;
 950             }
 951             $attrs = array();
 952             $attrs['id'] = $data->id[$i];
 953             if (!empty($data->newparent[$i])) {
 954                 $attrs['newparent'] = $data->newparent[$i];
 955             }
 956             if (!empty($data->recursive[$i])) {
 957                 $attrs['recursive'] = $data->recursive[$i];
 958             }
 959             $params['categories'][] = $attrs;
 960         }
 961         return $params;
 962     }
 963 }
 964
 965 /**
 966  * Form class for create_categories() web service function test.
 967  *
 968  * @package   core_webservice
 969  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 970  * @copyright 2012 Fabio Souto
 971  */
 972 class core_course_update_categories_form extends moodleform {
 973     /**
 974      * The form definition.
 975      */
 976     public function definition() {
 977         global $CFG;
 978
 979         $mform = $this->_form;
 980
 981         $mform->addElement('header', 'wstestclienthdr', get_string('testclient', 'webservice'));
 982
 983         // Note: these values are intentionally PARAM_RAW - we want users to test any rubbish as parameters.
 984         $data = $this->_customdata;
 985         if ($data['authmethod'] == 'simple') {
 986             $mform->addElement('text', 'wsusername', 'wsusername');
 987             $mform->setType('wsusername', PARAM_USERNAME);
 988             $mform->addElement('text', 'wspassword', 'wspassword');
 989             $mform->setType('wspassword', PARAM_RAW);
 990         } else if ($data['authmethod'] == 'token') {
 991             $mform->addElement('text', 'token', 'token');
 992             $mform->setType('token', PARAM_RAW_TRIMMED);
 993         }
 994
 995         $mform->addElement('hidden', 'authmethod', $data['authmethod']);
 996         $mform->setType('authmethod', PARAM_ALPHA);
 997         $mform->addElement('text', 'id[0]', 'id[0]');
 998         $mform->addElement('text', 'name[0]', 'name[0]');
 999         $mform->addElement('text', 'parent[0]', 'parent[0]');
1000         $mform->addElement('text', 'idnumber[0]', 'idnumber[0]');
1001         $mform->addElement('text', 'description[0]', 'description[0]');
1002         $mform->addElement('text', 'id[1]', 'id[1]');
1003         $mform->addElement('text', 'name[1]', 'name[1]');
1004         $mform->addElement('text', 'parent[1]', 'parent[1]');
1005         $mform->addElement('text', 'idnumber[1]', 'idnumber[1]');
1006         $mform->addElement('text', 'description[1]', 'description[1]');
1007         $mform->setType('id', PARAM_INT);
1008         $mform->setType('name', PARAM_TEXT);
1009         $mform->setType('parent', PARAM_INT);
1010         $mform->setType('idnumber', PARAM_RAW);
1011         $mform->setType('description', PARAM_TEXT);
1012
1013         $mform->addElement('hidden', 'function');
1014         $mform->setType('function', PARAM_PLUGIN);
1015
1016         $mform->addElement('hidden', 'protocol');
1017         $mform->setType('protocol', PARAM_ALPHA);
1018
1019         $this->add_action_buttons(true, get_string('execute', 'webservice'));
1020     }
1021
1022     /**
1023      * Get the parameters that the user submitted using the form.
1024      * @return array|null
1025      */
1026     public function get_params() {
1027         if (!$data = $this->get_data()) {
1028             return null;
1029         }
1030         // Remove unused from form data.
1031         unset($data->submitbutton);
1032         unset($data->protocol);
1033         unset($data->function);
1034         unset($data->wsusername);
1035         unset($data->wspassword);
1036         unset($data->token);
1037         unset($data->authmethod);
1038
1039         $params = array();
1040         $params['categories'] = array();
1041         for ($i=0; $i<10; $i++) {
1042
1043             if (empty($data->id[$i])) {
1044                 continue;
1045             }
1046             $attrs = array();
1047             $attrs['id'] = $data->id[$i];
1048             if (!empty($data->name[$i])) {
1049                 $attrs['name'] = $data->name[$i];
1050             }
1051             if (!empty($data->parent[$i])) {
1052                 $attrs['parent'] = $data->parent[$i];
1053             }
1054             if (!empty($data->idnumber[$i])) {
1055                 $attrs['idnumber'] = $data->idnumber[$i];
1056             }
1057             if (!empty($data->description[$i])) {
1058                 $attrs['description'] = $data->description[$i];
1059             }
1060             $params['categories'][] = $attrs;
1061         }
1062         return $params;
1063     }
1064 }