1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import unittest, time, os, datetime
23 import tempfile
24
25 import omero
26
27 from django.conf import settings
28 from request_factory import fakeRequest
29
30 from webgateway import views as webgateway_views
31 from webadmin import views as webadmin_views
32 from webadmin.webadmin_utils import toBoolean
33 from webadmin.forms import LoginForm, GroupForm, ExperimenterForm, \
34 ContainedExperimentersForm, ChangePassword
35
36 from webadmin.controller.experimenter import BaseExperimenter
37 from webadmin.controller.group import BaseGroup
38 from webadmin_test_library import WebTest, WebAdminClientTest
39
40 from django.core.urlresolvers import reverse
41
42
44
46 params = {
47 'username': 'root',
48 'password': self.root_password,
49 'server':self.server_id,
50 'ssl':'on'
51 }
52
53 response = self.client.post(reverse(viewname="walogin"), params)
54
55 self.failUnlessEqual(response.status_code, 302)
56 self.failUnlessEqual(response['Location'], reverse(viewname="waindex"))
57
59 self.client.login('root', self.root_password)
60
61
62 response = self.client.get(reverse(viewname="waexperimenters"))
63 self.failUnlessEqual(response.status_code, 200)
64
65
66 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["new"]))
67 self.failUnlessEqual(response.status_code, 200)
68
69
70 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["create"]))
71 self.failUnlessEqual(response.status_code, 302)
72 self.failUnlessEqual(response['Location'], reverse(viewname="wamanageexperimenterid", args=["new"]))
73
74
75 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["edit", "1"]))
76 self.failUnlessEqual(response.status_code, 200)
77
78
79 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["save", "1"]))
80 self.failUnlessEqual(response.status_code, 302)
81 self.failUnlessEqual(response['Location'], reverse(viewname="wamanageexperimenterid", args=["edit", "1"]))
82
83
84 response = self.client.get(reverse(viewname="wagroups"))
85 self.failUnlessEqual(response.status_code, 200)
86
87
88 response = self.client.get(reverse(viewname="wamanagegroupid", args=["new"]))
89 self.failUnlessEqual(response.status_code, 200)
90
91
92 response = self.client.get(reverse(viewname="wamanagegroupid", args=["create"]))
93 self.failUnlessEqual(response.status_code, 302)
94 self.failUnlessEqual(response['Location'], reverse(viewname="wamanagegroupid", args=["new"]))
95
96
97 response = self.client.get(reverse(viewname="wamanagegroupid", args=["edit", "2"]))
98 self.failUnlessEqual(response.status_code, 200)
99
100
101 response = self.client.get(reverse(viewname="wamanagegroupid", args=["save", "2"]))
102 self.failUnlessEqual(response.status_code, 302)
103 self.failUnlessEqual(response['Location'], reverse(viewname="wamanagegroupid", args=["edit", "2"]))
104
105
106 response = self.client.get(reverse(viewname="wamanagechangepasswordid", args=["1"]))
107 self.failUnlessEqual(response.status_code, 200)
108
109
111 conn = self.rootconn
112 uuid = conn._sessionUuid
113
114
115 params = {
116 "name":"webadmin_test_group_private %s" % uuid,
117 "description":"test group",
118 "owners": [0L],
119 "permissions":0
120 }
121 request = fakeRequest(method="post", params=params)
122 gid = _createGroup(request, conn)
123
124 params = {
125 "omename":"webadmin_test_user %s" % uuid,
126 "first_name":uuid,
127 "middle_name": uuid,
128 "last_name":uuid,
129 "email":"user_%s@domain.com" % uuid,
130 "institution":"Laboratory",
131 "active":True,
132 "default_group":gid,
133 "other_groups":[gid],
134 "password":"123",
135 "confirmation":"123"
136 }
137 request = fakeRequest(method="post", params=params)
138 eid = _createExperimenter(request, conn)
139
140
141 self.client.login("webadmin_test_user %s" % uuid, '123')
142
143
144 response = self.client.get(reverse(viewname="wamyaccount"))
145 self.failUnlessEqual(response.status_code, 200)
146
147 response = self.client.get(reverse(viewname="wadrivespace"))
148 self.failUnlessEqual(response.status_code, 200)
149
150 response = self.client.get(reverse(viewname="wamyphoto"))
151 self.failUnlessEqual(response.status_code, 200)
152
153 response = self.client.get(reverse(viewname="wamanagechangepasswordid", args=["4"]))
154 self.failUnlessEqual(response.status_code, 200)
155
156
157 response = self.client.get(reverse(viewname="waexperimenters"))
158 self.failUnlessEqual(response.status_code, 404)
159
160 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["new"]))
161 self.failUnlessEqual(response.status_code, 404)
162
163 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["create"]))
164 self.failUnlessEqual(response.status_code, 404)
165
166 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["edit", "1"]))
167 self.failUnlessEqual(response.status_code, 404)
168
169 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["save", "1"]))
170 self.failUnlessEqual(response.status_code, 404)
171
172 response = self.client.get(reverse(viewname="wagroups"))
173 self.failUnlessEqual(response.status_code, 404)
174
175 response = self.client.get(reverse(viewname="wamanagegroupid", args=["new"]))
176 self.failUnlessEqual(response.status_code, 404)
177
178 response = self.client.get(reverse(viewname="wamanagegroupid", args=["create"]))
179 self.failUnlessEqual(response.status_code, 404)
180
181 response = self.client.get(reverse(viewname="wamanagegroupid", args=["edit", "2"]))
182 self.failUnlessEqual(response.status_code, 404)
183
184 response = self.client.get(reverse(viewname="wamanagegroupid", args=["save", "2"]))
185 self.failUnlessEqual(response.status_code, 404)
186
207
208
210
234
265
292
294 conn = self.rootconn
295 uuid = conn._sessionUuid
296
297
298 params = {
299 "name":u"русский_алфавит %s" % uuid,
300 "description":u"Frühstück-Śniadanie. Tschüß-Cześć",
301 "owners": [0L],
302 "permissions":0
303 }
304 request = fakeRequest(method="post", params=params)
305 gid = _createGroup(request, conn)
306
307
308 controller = BaseGroup(conn, gid)
309 perm = controller.getActualPermissions()
310 self.assertEquals(params['name'], controller.group.name)
311 self.assertEquals(params['description'], controller.group.description)
312 self.assertEquals(sorted(params['owners']), sorted(controller.owners))
313 self.assertEquals(params['permissions'], perm)
314 self.assertEquals(False, controller.isReadOnly())
315
317 conn = self.rootconn
318 uuid = conn._sessionUuid
319
320
321 params = {
322 "name":"webadmin_test_group_private %s" % uuid,
323 "description":"test group",
324 "owners": [0L],
325 "permissions":0
326 }
327 request = fakeRequest(method="post", params=params)
328 gid = _createGroup(request, conn)
329
330
331 controller = BaseGroup(conn, gid)
332 perm = controller.getActualPermissions()
333 self.assertEquals(params['name'], controller.group.name)
334 self.assertEquals(params['description'], controller.group.description)
335 self.assertEquals(sorted(params['owners']), sorted(controller.owners))
336 self.assertEquals(params['permissions'], perm)
337 self.assertEquals(False, controller.isReadOnly())
338
339
340 params = {
341 "name":"webadmin_test_group_read-only %s" % uuid,
342 "description":"test group",
343 "owners": [0L],
344 "permissions":1,
345 "readonly":True
346 }
347 request = fakeRequest(method="post", params=params)
348 gid = _createGroup(request, conn)
349
350
351 controller = BaseGroup(conn, gid)
352 perm = controller.getActualPermissions()
353 self.assertEquals(params['name'], controller.group.name)
354 self.assertEquals(params['description'], controller.group.description)
355 self.assertEquals(sorted(params['owners']), sorted(controller.owners))
356 self.assertEquals(params['permissions'], perm)
357 self.assertEquals(params['readonly'], controller.isReadOnly())
358
360 conn = self.rootconn
361 uuid = conn._sessionUuid
362
363
364 params = {
365 "name":"webadmin_test_group_private %s" % uuid,
366 "description":"test group",
367 "owners": [0L],
368 "permissions":0
369 }
370 request = fakeRequest(method="post", params=params)
371 gid = _createGroup(request, conn)
372
373
374 params = {
375 "omename":"webadmin_test_owner %s" % uuid,
376 "first_name":uuid,
377 "middle_name": uuid,
378 "last_name":uuid,
379 "email":"owner_%s@domain.com" % uuid,
380 "institution":"Laboratory",
381 "active":True,
382 "default_group":gid,
383 "other_groups":[gid],
384 "password":"123",
385 "confirmation":"123"
386 }
387 request = fakeRequest(method="post", params=params)
388 eid = _createExperimenter(request, conn)
389
390
391
392 params = {
393 "name":"webadmin_test_group_read-only %s" % uuid,
394 "description":"test group changed",
395 "owners": [0, eid],
396 "permissions":1,
397 "readonly":True
398 }
399 request = fakeRequest(method="post", params=params)
400 _updateGroup(request, conn, gid)
401
402
403 controller = BaseGroup(conn, gid)
404 perm = controller.getActualPermissions()
405 self.assertEquals(params['name'], controller.group.name)
406 self.assertEquals(params['description'], controller.group.description)
407 self.assertEquals(sorted(params['owners']), sorted(controller.owners))
408 self.assertEquals(params['permissions'], perm)
409 self.assertEquals(params['readonly'], controller.isReadOnly())
410
412 conn = self.rootconn
413 uuid = conn._sessionUuid
414
415
416 params = {
417 "name":"webadmin_test_group_private %s" % uuid,
418 "description":"test group",
419 "owners": [0L],
420 "permissions":0
421 }
422 request = fakeRequest(method="post", params=params)
423 gid = _createGroup(request, conn)
424
425
426
427 params = {
428 "name":"webadmin_test_default %s" % uuid,
429 "description":"test group default",
430 "owners": [0L],
431 "permissions":0
432 }
433 request = fakeRequest(method="post", params=params)
434 default_gid = _createGroup(request, conn)
435
436
437 params = {
438 "omename":"webadmin_test_user1 %s" % uuid,
439 "first_name":uuid,
440 "middle_name": uuid,
441 "last_name":uuid,
442 "email":"user1_%s@domain.com" % uuid,
443 "institution":"Laboratory",
444 "active":True,
445 "default_group":default_gid,
446 "other_groups":[default_gid],
447 "password":"123",
448 "confirmation":"123"
449 }
450 request = fakeRequest(method="post", params=params)
451 eid1 = _createExperimenter(request, conn)
452
453
454 params = {
455 "omename":"webadmin_test_user2 %s" % uuid,
456 "first_name":uuid,
457 "middle_name": uuid,
458 "last_name":uuid,
459 "email":"user2_%s@domain.com" % uuid,
460 "institution":"Laboratory",
461 "active":True,
462 "default_group":default_gid,
463 "other_groups":[default_gid],
464 "password":"123",
465 "confirmation":"123"
466 }
467 request = fakeRequest(method="post", params=params)
468 eid2 = _createExperimenter(request, conn)
469
470
471
472 params = {
473 'available':[],
474 'members':[0,eid1,eid2]
475 }
476 request = fakeRequest(method="post", params=params)
477
478 controller = BaseGroup(conn, gid)
479 controller.containedExperimenters()
480 form = ContainedExperimentersForm(initial={'members':controller.members, 'available':controller.available})
481 if not form.is_valid():
482
483 available = request.POST.getlist('available')
484
485 members = request.POST.getlist('members')
486 controller.setMembersOfGroup(available, members)
487
488
489 controller = BaseGroup(conn, gid)
490 controller.containedExperimenters()
491 self.assertEquals(sorted(params['members']), sorted([e.id for e in controller.members]))
492
493
494 params = {
495 'available':[eid1,eid2],
496 'members':[0]
497 }
498 request = fakeRequest(method="post", params=params)
499
500 controller = BaseGroup(conn, gid)
501 controller.containedExperimenters()
502 form = ContainedExperimentersForm(initial={'members':controller.members, 'available':controller.available})
503 if not form.is_valid():
504
505 available = request.POST.getlist('available')
506
507 members = request.POST.getlist('members')
508 controller.setMembersOfGroup(available, members)
509
510
511 controller = BaseGroup(conn, gid)
512 controller.containedExperimenters()
513 self.assertEquals(sorted(params['members']), sorted([e.id for e in controller.members]))
514
516 conn = self.rootconn
517 uuid = conn._sessionUuid
518
519
520 params = {
521 "name":"webadmin_test_group_private %s" % uuid,
522 "description":"test group",
523 "owners": [0L],
524 "permissions":0
525 }
526 request = fakeRequest(method="post", params=params)
527 gid = _createGroup(request, conn)
528
529 params = {
530 "omename":"webadmin_test_user %s" % uuid,
531 "first_name":uuid,
532 "middle_name": uuid,
533 "last_name":uuid,
534 "email":"user_%s@domain.com" % uuid,
535 "institution":"Laboratory",
536 "active":True,
537 "default_group":gid,
538 "other_groups":[gid],
539 "password":"123",
540 "confirmation":"123"
541 }
542 request = fakeRequest(method="post", params=params)
543 eid = _createExperimenter(request, conn)
544
545
546 controller = BaseExperimenter(conn, eid)
547 self.assertEquals(params['omename'], controller.experimenter.omeName)
548 self.assertEquals(params['first_name'], controller.experimenter.firstName)
549 self.assertEquals(params['middle_name'], controller.experimenter.middleName)
550 self.assertEquals(params['last_name'], controller.experimenter.lastName)
551 self.assertEquals(params['email'], controller.experimenter.email)
552 self.assertEquals(params['institution'], controller.experimenter.institution)
553 self.assert_(not controller.experimenter.isAdmin())
554 self.assertEquals(params['active'], controller.experimenter.isActive())
555 self.assertEquals(params['default_group'], controller.defaultGroup)
556 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups))
557
558 params = {
559 "omename":"webadmin_test_admin %s" % uuid,
560 "first_name":uuid,
561 "middle_name": uuid,
562 "last_name":uuid,
563 "email":"admin_%s@domain.com" % uuid,
564 "institution":"Laboratory",
565 "administrator": True,
566 "active":True,
567 "default_group":gid,
568 "other_groups":[0,gid],
569 "password":"123",
570 "confirmation":"123"
571 }
572 request = fakeRequest(method="post", params=params)
573 eid = _createExperimenter(request, conn)
574
575
576 controller = BaseExperimenter(conn, eid)
577 self.assertEquals(params['omename'], controller.experimenter.omeName)
578 self.assertEquals(params['first_name'], controller.experimenter.firstName)
579 self.assertEquals(params['middle_name'], controller.experimenter.middleName)
580 self.assertEquals(params['last_name'], controller.experimenter.lastName)
581 self.assertEquals(params['email'], controller.experimenter.email)
582 self.assertEquals(params['institution'], controller.experimenter.institution)
583 self.assertEquals(params['administrator'], controller.experimenter.isAdmin())
584 self.assertEquals(params['active'], controller.experimenter.isActive())
585 self.assertEquals(params['default_group'], controller.defaultGroup)
586 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups))
587
588 params = {
589 "omename":"webadmin_test_off %s" % uuid,
590 "first_name":uuid,
591 "middle_name": uuid,
592 "last_name":uuid,
593 "email":"off_%s@domain.com" % uuid,
594 "institution":"Laboratory",
595 "default_group":gid,
596 "other_groups":[gid],
597 "password":"123",
598 "confirmation":"123"
599 }
600 request = fakeRequest(method="post", params=params)
601 eid = _createExperimenter(request, conn)
602
603
604 controller = BaseExperimenter(conn, eid)
605 self.assertEquals(params['omename'], controller.experimenter.omeName)
606 self.assertEquals(params['first_name'], controller.experimenter.firstName)
607 self.assertEquals(params['middle_name'], controller.experimenter.middleName)
608 self.assertEquals(params['last_name'], controller.experimenter.lastName)
609 self.assertEquals(params['email'], controller.experimenter.email)
610 self.assertEquals(params['institution'], controller.experimenter.institution)
611 self.assert_(not controller.experimenter.isAdmin())
612 self.assert_(not controller.experimenter.isActive())
613 self.assertEquals(params['default_group'], controller.defaultGroup)
614 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups))
615
617 conn = self.rootconn
618 uuid = conn._sessionUuid
619
620
621 params = {
622 "name":"webadmin_test_group_private %s" % uuid,
623 "description":"test group",
624 "owners": [0L],
625 "permissions":0
626 }
627
628 request = fakeRequest(method="post", params=params)
629 gid = _createGroup(request, conn)
630
631
632 params = {
633 "name":"webadmin_test_default %s" % uuid,
634 "description":"test group default",
635 "owners": [0L],
636 "permissions":0
637 }
638 request = fakeRequest(method="post", params=params)
639 default_gid = _createGroup(request, conn)
640
641
642 params = {
643 "omename":"webadmin_test_user %s" % uuid,
644 "first_name":uuid,
645 "middle_name": uuid,
646 "last_name":uuid,
647 "email":"user_%s@domain.com" % uuid,
648 "institution":"Laboratory",
649 "active":True,
650 "default_group":gid,
651 "other_groups":[gid],
652 "password":"123",
653 "confirmation":"123"
654 }
655 request = fakeRequest(method="post", params=params)
656 eid = _createExperimenter(request, conn)
657
658
659 params = {
660 "omename":"webadmin_test_admin %s" % uuid,
661 "first_name":uuid,
662 "middle_name": uuid,
663 "last_name":uuid,
664 "email":"admin_%s@domain.com" % uuid,
665 "institution":"Laboratory",
666 "administrator": True,
667 "active":True,
668 "default_group":default_gid,
669 "other_groups":[0,gid,default_gid],
670 "password":"123",
671 "confirmation":"123"
672 }
673 request = fakeRequest(method="post", params=params)
674 _updateExperimenter(request, conn, eid)
675
676
677 controller = BaseExperimenter(conn, eid)
678 self.assertEquals(params['omename'], controller.experimenter.omeName)
679 self.assertEquals(params['first_name'], controller.experimenter.firstName)
680 self.assertEquals(params['middle_name'], controller.experimenter.middleName)
681 self.assertEquals(params['last_name'], controller.experimenter.lastName)
682 self.assertEquals(params['email'], controller.experimenter.email)
683 self.assertEquals(params['institution'], controller.experimenter.institution)
684 self.assertEquals(params['administrator'], controller.experimenter.isAdmin())
685 self.assertEquals(params['active'], controller.experimenter.isActive())
686 self.assertEquals(params['default_group'], controller.defaultGroup)
687 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups))
688
689
690 params = {
691 "omename":"webadmin_test_admin %s" % uuid,
692 "first_name":uuid,
693 "middle_name": uuid,
694 "last_name":uuid,
695 "email":"admin_%s@domain.com" % uuid,
696 "institution":"Laboratory",
697 "administrator": False,
698 "active":False,
699 "default_group":default_gid,
700 "other_groups":[gid,default_gid],
701 "password":"123",
702 "confirmation":"123"
703 }
704 request = fakeRequest(method="post", params=params)
705 _updateExperimenter(request, conn, eid)
706
707
708 controller = BaseExperimenter(conn, eid)
709 self.assertEquals(params['omename'], controller.experimenter.omeName)
710 self.assertEquals(params['first_name'], controller.experimenter.firstName)
711 self.assertEquals(params['middle_name'], controller.experimenter.middleName)
712 self.assertEquals(params['last_name'], controller.experimenter.lastName)
713 self.assertEquals(params['email'], controller.experimenter.email)
714 self.assertEquals(params['institution'], controller.experimenter.institution)
715 self.assert_(not controller.experimenter.isAdmin())
716 self.assert_(not controller.experimenter.isActive())
717 self.assertEquals(params['default_group'], controller.defaultGroup)
718 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups))
719
720 try:
721 self.loginAsUser(params['omename'], params['password'])
722 self.fail('This user was deactivated. Login failure error!')
723 except:
724 pass
725
727 conn = self.rootconn
728 uuid = conn._sessionUuid
729
730
731 params = {
732 "name": uuid,
733 "description":"password test",
734 "owners": [0L],
735 "permissions":0
736 }
737
738 request = fakeRequest(method="post", params=params)
739 gid = _createGroup(request, conn)
740
741
742 params = {
743 "omename":'password%s' % uuid,
744 "first_name":uuid,
745 "middle_name": uuid,
746 "last_name":uuid,
747 "email":"password_%s@domain.com" % uuid,
748 "institution":"Laboratory",
749 "active":True,
750 "default_group":gid,
751 "other_groups":[gid],
752 "password":"123",
753 "confirmation":"123"
754 }
755 request = fakeRequest(method="post", params=params)
756 eid = _createExperimenter(request, conn)
757
758
759 params_passwd = {
760 "password":"abc",
761 "confirmation":"abc",
762 "old_password":self.root_password
763 }
764 request = fakeRequest(method="post", params=params_passwd)
765 _changePassword(request, conn, eid)
766
767
768 user_conn = self.loginAsUser(params['omename'], params_passwd['password'])
769 params_passwd = {
770 "old_password":"abc",
771 "password":"foo",
772 "confirmation":"foo"
773 }
774 request = fakeRequest(method="post", params=params_passwd)
775 _changePassword(request, user_conn)
776
777 self.loginAsUser(params['omename'], params_passwd['password'])
778
779
780
781
794
809
824
826
827 controller = BaseExperimenter(conn)
828 name_check = conn.checkOmeName(request.REQUEST.get('omename'))
829 email_check = conn.checkEmail(request.REQUEST.get('email'))
830
831 initial={'with_password':True}
832
833 exclude = list()
834 if len(request.REQUEST.getlist('other_groups')) > 0:
835 others = controller.getSelectedGroups(request.REQUEST.getlist('other_groups'))
836 initial['others'] = others
837 initial['default'] = [(g.id, g.name) for g in others]
838 exclude.extend([g.id for g in others])
839
840 available = controller.otherGroupsInitialList(exclude)
841 initial['available'] = available
842 form = ExperimenterForm(initial=initial, data=request.REQUEST.copy(), name_check=name_check, email_check=email_check)
843 if form.is_valid():
844 omename = form.cleaned_data['omename']
845 firstName = form.cleaned_data['first_name']
846 middleName = form.cleaned_data['middle_name']
847 lastName = form.cleaned_data['last_name']
848 email = form.cleaned_data['email']
849 institution = form.cleaned_data['institution']
850 admin = toBoolean(form.cleaned_data['administrator'])
851 active = toBoolean(form.cleaned_data['active'])
852 defaultGroup = form.cleaned_data['default_group']
853 otherGroups = form.cleaned_data['other_groups']
854 password = form.cleaned_data['password']
855 return controller.createExperimenter(omename, firstName, lastName, email, admin, active, defaultGroup, otherGroups, password, middleName, institution)
856 else:
857 raise Exception(form.errors.as_text())
858
860
861 controller = BaseExperimenter(conn, eid)
862 name_check = conn.checkOmeName(request.REQUEST.get('omename'), controller.experimenter.omeName)
863 email_check = conn.checkEmail(request.REQUEST.get('email'), controller.experimenter.email)
864
865 initial={'active':True}
866 exclude = list()
867
868 if len(request.REQUEST.getlist('other_groups')) > 0:
869 others = controller.getSelectedGroups(request.REQUEST.getlist('other_groups'))
870 initial['others'] = others
871 initial['default'] = [(g.id, g.name) for g in others]
872 exclude.extend([g.id for g in others])
873
874 available = controller.otherGroupsInitialList(exclude)
875 initial['available'] = available
876
877 form = ExperimenterForm(initial=initial, data=request.POST.copy(), name_check=name_check, email_check=email_check)
878
879 if form.is_valid():
880 omename = form.cleaned_data['omename']
881 firstName = form.cleaned_data['first_name']
882 middleName = form.cleaned_data['middle_name']
883 lastName = form.cleaned_data['last_name']
884 email = form.cleaned_data['email']
885 institution = form.cleaned_data['institution']
886 admin = toBoolean(form.cleaned_data['administrator'])
887 active = toBoolean(form.cleaned_data['active'])
888 defaultGroup = form.cleaned_data['default_group']
889 otherGroups = form.cleaned_data['other_groups']
890 controller.updateExperimenter(omename, firstName, lastName, email, admin, active, defaultGroup, otherGroups, middleName, institution)
891 else:
892 raise Exception(form.errors.as_text())
893