← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/webapp/admin/user.py

  • Committer: William Grant
  • Date: 2010-02-26 03:36:30 UTC
  • Revision ID: grantw@unimelb.edu.au-20100226033630-gqoerwl59i10mbao
Add forgotten template.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/admin/user.py
21
21
import formencode.validators
22
22
from genshi.filters import HTMLFormFiller
23
23
 
 
24
from ivle.database import User
 
25
import ivle.date
 
26
from ivle.pulldown_subj import enrol_user
24
27
from ivle.webapp import ApplicationRoot
 
28
from ivle.webapp.base.forms import BaseFormView, URLNameValidator
25
29
from ivle.webapp.base.xhtml import XHTMLView
26
30
from ivle.webapp.base.plugins import ViewPlugin, MediaPlugin
27
31
from ivle.webapp.admin.publishing import root_to_user, user_url
28
 
from ivle.database import User
29
 
import ivle.date
30
32
 
31
33
 
32
34
class UsersView(XHTMLView):
48
50
    email = formencode.validators.Email(not_empty=False,
49
51
                                        if_missing=None)
50
52
 
51
 
class UserEditView(XHTMLView):
 
53
class UserEditView(BaseFormView):
52
54
    """A form to change a user's details."""
53
55
    template = 'templates/user-edit.html'
54
56
    tab = 'users'
55
57
    permission = 'edit'
56
58
 
57
 
    def filter(self, stream, ctx):
58
 
        return stream | HTMLFormFiller(data=ctx['data'])
 
59
    @property
 
60
    def validator(self):
 
61
        return UserEditSchema()
 
62
 
 
63
    def get_default_data(self, req):
 
64
        return {'nick': self.context.nick,
 
65
                'email': self.context.email
 
66
                }
 
67
 
 
68
    def save_object(self, req, data):
 
69
        self.context.nick = data['nick']
 
70
        self.context.email = unicode(data['email']) if data['email'] \
 
71
                             else None
 
72
        return self.context
59
73
 
60
74
    def populate(self, req, ctx):
61
 
        if req.method == 'POST':
62
 
            data = dict(req.get_fieldstorage())
63
 
            try:
64
 
                validator = UserEditSchema()
65
 
                data = validator.to_python(data, state=req)
66
 
                self.context.nick = data['nick']
67
 
                self.context.email = unicode(data['email']) if data['email'] \
68
 
                                     else None
69
 
                req.store.commit()
70
 
                req.throw_redirect(req.uri)
71
 
            except formencode.Invalid, e:
72
 
                errors = e.unpack_errors()
73
 
        else:
74
 
            data = {'nick': self.context.nick,
75
 
                    'email': self.context.email
76
 
                   }
77
 
            errors = {}
78
 
 
 
75
        super(UserEditView, self).populate(req, ctx)
79
76
        ctx['format_datetime'] = ivle.date.make_date_nice
80
77
        ctx['format_datetime_short'] = ivle.date.format_datetime_for_paragraph
81
78
 
82
 
        ctx['req'] = req
83
 
        ctx['user'] = self.context
84
 
        ctx['data'] = data
85
 
        ctx['errors'] = errors
86
79
 
87
80
class UserAdminSchema(formencode.Schema):
88
81
    admin = formencode.validators.StringBoolean(if_missing=False)
92
85
                                                    if_missing=None
93
86
                                                    )
94
87
 
95
 
class UserAdminView(XHTMLView):
 
88
class UserAdminView(BaseFormView):
96
89
    """A form for admins to change more of a user's details."""
97
90
    template = 'templates/user-admin.html'
98
91
    tab = 'users'
101
94
        """Only allow access if the requesting user is an admin."""
102
95
        return req.user and req.user.admin
103
96
 
104
 
    def filter(self, stream, ctx):
105
 
        return stream | HTMLFormFiller(data=ctx['data'])
 
97
    @property
 
98
    def validator(self):
 
99
        return UserAdminSchema()
 
100
 
 
101
    def get_default_data(self, req):
 
102
        return {'admin': self.context.admin,
 
103
                'disabled': self.context.state == u'disabled',
 
104
                'fullname': self.context.fullname,
 
105
                'studentid': self.context.studentid,
 
106
                }
 
107
 
 
108
    def save_object(self, req, data):
 
109
        if self.context is req.user:
 
110
            # Admin checkbox is disabled -- assume unchanged
 
111
            data['admin'] = self.context.admin
 
112
            data['disabled'] = self.context.state == u'disabled'
 
113
        else:
 
114
            self.context.admin = data['admin']
 
115
            if self.context.state in (u'enabled', u'disabled'):
 
116
                self.context.state = (u'disabled' if data['disabled']
 
117
                        else u'enabled')
 
118
        self.context.fullname = data['fullname'] \
 
119
                                if data['fullname'] else None
 
120
        self.context.studentid = data['studentid'] \
 
121
                                 if data['studentid'] else None
 
122
        return self.context
106
123
 
107
124
    def populate(self, req, ctx):
108
 
        if req.method == 'POST':
109
 
            data = dict(req.get_fieldstorage())
110
 
            try:
111
 
                validator = UserAdminSchema()
112
 
                data = validator.to_python(data, state=req)
113
 
 
114
 
                if self.context is req.user:
115
 
                    # Admin checkbox is disabled -- assume unchanged
116
 
                    data['admin'] = self.context.admin
117
 
                    data['disabled'] = self.context.state == u'disabled'
118
 
                else:
119
 
                    self.context.admin = data['admin']
120
 
                    if self.context.state in (u'enabled', u'disabled'):
121
 
                        self.context.state = (u'disabled' if data['disabled']
122
 
                                else u'enabled')
123
 
                self.context.fullname = data['fullname'] \
124
 
                                        if data['fullname'] else None
125
 
                self.context.studentid = data['studentid'] \
126
 
                                         if data['studentid'] else None
127
 
                req.store.commit()
128
 
                req.throw_redirect(req.uri)
129
 
            except formencode.Invalid, e:
130
 
                errors = e.unpack_errors()
131
 
        else:
132
 
            data = {'admin': self.context.admin,
133
 
                    'disabled': self.context.state == u'disabled',
134
 
                    'fullname': self.context.fullname,
135
 
                    'studentid': self.context.studentid,
136
 
                   }
137
 
            errors = {}
138
 
 
139
 
        ctx['req'] = req
140
 
        ctx['user'] = self.context
141
 
        # Disable the Admin checkbox if editing oneself
 
125
        super(UserAdminView, self).populate(req, ctx)
 
126
 
 
127
        # Disable the admin checkbox if editing oneself
142
128
        ctx['disable_admin'] = self.context is req.user
143
 
        ctx['data'] = data
144
 
        ctx['errors'] = errors
145
129
 
146
130
class PasswordChangeView(XHTMLView):
147
131
    """A form to change a user's password, with knowledge of the old one."""
202
186
        ctx['user'] = self.context
203
187
        ctx['error'] = error
204
188
 
 
189
 
 
190
class UserNewSchema(formencode.Schema):
 
191
    login = URLNameValidator() # XXX: Validate uniqueness.
 
192
    admin = formencode.validators.StringBoolean(if_missing=False)
 
193
    fullname = formencode.validators.UnicodeString(not_empty=True)
 
194
    studentid = formencode.validators.UnicodeString(not_empty=False,
 
195
                                                    if_missing=None
 
196
                                                    )
 
197
    email = formencode.validators.Email(not_empty=False,
 
198
                                        if_missing=None)
 
199
 
 
200
 
 
201
class UserNewView(BaseFormView):
 
202
    """A form for admins to create new users."""
 
203
    template = 'templates/user-new.html'
 
204
    tab = 'users'
 
205
 
 
206
    def authorize(self, req):
 
207
        """Only allow access if the requesting user is an admin."""
 
208
        return req.user and req.user.admin
 
209
 
 
210
    @property
 
211
    def validator(self):
 
212
        return UserNewSchema()
 
213
 
 
214
    def get_default_data(self, req):
 
215
        return {}
 
216
 
 
217
    def save_object(self, req, data):
 
218
        data['nick'] = data['fullname']
 
219
        data['email'] = unicode(data['email']) if data['email'] else None
 
220
        userobj = User(**data)
 
221
        req.store.add(userobj)
 
222
        enrol_user(req.config, req.store, userobj)
 
223
 
 
224
        return userobj
 
225
 
 
226
 
205
227
class Plugin(ViewPlugin, MediaPlugin):
206
228
    """
207
229
    The Plugin class for the user plugin.
209
231
 
210
232
    forward_routes = (root_to_user,)
211
233
    reverse_routes = (user_url,)
212
 
    views = [(ApplicationRoot, 'users', UsersView),
 
234
    views = [(ApplicationRoot, ('users', '+index'), UsersView),
 
235
             (ApplicationRoot, ('users', '+new'), UserNewView),
213
236
             (User, '+index', UserEditView),
214
237
             (User, '+admin', UserAdminView),
215
238
             (User, '+changepassword', PasswordChangeView),