← Back to branch summary

~deej/django-openid-auth/deb-build

« back to all changes in this revision

Viewing changes to django_openid_auth/views.py

  • Committer: Natalia
  • Date: 2015-04-23 20:02:39 UTC
  • mto: This revision was merged to the branch mainline in revision 113.
  • Revision ID: natalia.bidart@ubuntu.com-20150423200239-398aidg4rl3bolj8
Fully test suite passing on djangos from 1.4 to 1.8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
django_openid_auth/views.py
62
62
 
63
63
next_url_re = re.compile('^/[-\w/]+$')
64
64
 
 
65
 
65
66
def is_valid_next_url(next):
66
67
    # When we allow this:
67
68
    #   /openid/?next=/welcome/
78
79
        is_valid = False
79
80
    elif '//' in redirect_to:
80
81
        # Allow the redirect URL to be external if it's a permitted domain
81
 
        allowed_domains = getattr(settings,
82
 
            "ALLOWED_EXTERNAL_OPENID_REDIRECT_DOMAINS", [])
 
82
        allowed_domains = getattr(
 
83
            settings, "ALLOWED_EXTERNAL_OPENID_REDIRECT_DOMAINS", [])
83
84
        s, netloc, p, q, f = urlsplit(redirect_to)
84
85
        # allow it if netloc is blank or if the domain is allowed
85
86
        if netloc:
113
114
    if openid_request.shouldSendRedirect():
114
115
        redirect_url = openid_request.redirectURL(
115
116
            trust_root, return_to)
116
 
        return HttpResponseRedirect(redirect_url)
 
117
        response = HttpResponseRedirect(redirect_url)
117
118
    else:
118
119
        form_html = openid_request.htmlMarkup(
119
120
            trust_root, return_to, form_tag_attrs={'id': 'openid_message'})
120
 
        return HttpResponse(form_html, content_type='text/html;charset=UTF-8')
 
121
        response = HttpResponse(
 
122
            form_html, content_type='text/html;charset=UTF-8')
 
123
    return response
121
124
 
122
125
 
123
126
def default_render_failure(request, message, status=403,
133
136
def parse_openid_response(request):
134
137
    """Parse an OpenID response from a Django request."""
135
138
    # Short cut if there is no request parameters.
136
 
    #if len(request.REQUEST) == 0:
 
139
    # if len(request.REQUEST) == 0:
137
140
    #    return None
138
141
 
139
142
    current_url = request.build_absolute_uri()
164
167
 
165
168
        # Invalid or no form data:
166
169
        if openid_url is None:
167
 
            return render_to_response(template_name, {
168
 
                    'form': login_form,
169
 
                    redirect_field_name: redirect_to
170
 
                    }, context_instance=RequestContext(request))
 
170
            context = {'form': login_form, redirect_field_name: redirect_to}
 
171
            return render_to_response(
 
172
                template_name, context,
 
173
                context_instance=RequestContext(request))
171
174
 
172
175
    consumer = make_consumer(request)
173
176
    try:
174
177
        openid_request = consumer.begin(openid_url)
175
 
    except DiscoveryFailure, exc:
 
178
    except DiscoveryFailure as exc:
176
179
        return render_failure(
177
180
            request, "OpenID discovery error: %s" % (str(exc),), status=500,
178
181
            exception=exc)
222
225
        sreg_optional_fields.extend(
223
226
            getattr(settings, 'OPENID_SREG_EXTRA_FIELDS', []))
224
227
        sreg_optional_fields = [
225
 
            field for field in sreg_optional_fields if (
226
 
                not field in sreg_required_fields)]
 
228
            field for field in sreg_optional_fields
 
229
            if field not in sreg_required_fields]
227
230
        openid_request.addExtension(
228
231
            sreg.SRegRequest(optional=sreg_optional_fields,
229
 
                required=sreg_required_fields))
 
232
                             required=sreg_required_fields))
230
233
 
231
234
    if getattr(settings, 'OPENID_PHYSICAL_MULTIFACTOR_REQUIRED', False):
232
235
        preferred_auth = [
236
239
        openid_request.addExtension(pape_request)
237
240
 
238
241
    # Request team info
239
 
    teams_mapping_auto = getattr(settings, 'OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO', False)
240
 
    teams_mapping_auto_blacklist = getattr(settings, 'OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO_BLACKLIST', [])
 
242
    teams_mapping_auto = getattr(
 
243
        settings, 'OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO', False)
 
244
    teams_mapping_auto_blacklist = getattr(
 
245
        settings, 'OPENID_LAUNCHPAD_TEAMS_MAPPING_AUTO_BLACKLIST', [])
241
246
    launchpad_teams = getattr(settings, 'OPENID_LAUNCHPAD_TEAMS_MAPPING', {})
242
247
    if teams_mapping_auto:
243
 
        #ignore launchpad teams. use all django-groups
 
248
        # ignore launchpad teams. use all django-groups
244
249
        launchpad_teams = dict()
245
 
        all_groups = Group.objects.exclude(name__in=teams_mapping_auto_blacklist)
 
250
        all_groups = Group.objects.exclude(
 
251
            name__in=teams_mapping_auto_blacklist)
246
252
        for group in all_groups:
247
253
            launchpad_teams[group.name] = group.name
248
254
 
270
276
def login_complete(request, redirect_field_name=REDIRECT_FIELD_NAME,
271
277
                   render_failure=None):
272
278
    redirect_to = request.REQUEST.get(redirect_field_name, '')
273
 
    render_failure = render_failure or \
274
 
                     getattr(settings, 'OPENID_RENDER_FAILURE', None) or \
275
 
                     default_render_failure
 
279
    render_failure = (
 
280
        render_failure or getattr(settings, 'OPENID_RENDER_FAILURE', None) or
 
281
        default_render_failure)
276
282
 
277
283
    openid_response = parse_openid_response(request)
278
284
    if not openid_response:
288
294
        if user is not None:
289
295
            if user.is_active:
290
296
                auth_login(request, user)
291
 
                response = HttpResponseRedirect(sanitise_redirect_url(redirect_to))
 
297
                response = HttpResponseRedirect(
 
298
                    sanitise_redirect_url(redirect_to))
292
299
 
293
300
                # Notify any listeners that we successfully logged in.
294
 
                openid_login_complete.send(sender=UserOpenID, request=request,
 
301
                openid_login_complete.send(
 
302
                    sender=UserOpenID, request=request,
295
303
                    openid_response=openid_response)
296
304
 
297
305
                return response