def wrapper(request, *args, **kwargs): output = function(request, *args, **kwargs) if not isinstance(output, dict): return output tmpl = output.pop('TEMPLATE', template) return render_to_response(tmpl, output, \ context_instance=RequestContext(request), mimetype=mimetype)
def njemacka_item_list(request): from django.db.models import Q from project.util import decode_cookie_value, str_to_int from project.meds.models import Artikal filter_search = decode_cookie_value( request.COOKIES.get("njemacko_trziste_filter_search", "")) q = Q() if len(filter_search) != 0: q &= Q(name__icontains=filter_search) if request.method == "POST": operation = request.POST.get("operation") if operation == "delete": ids = [ str_to_int(n) for n in request.POST.get("selected_items").split(",") if n ] Artikal.delete_objects(ids) return HttpResponseRedirect(request.path) return render_to_response("admin/meds/njemacka_list.html", { "items": Artikal.objects.filter(q), "filter_search": filter_search, "active_page": "meds", }, context_instance=RequestContext(request))
def email(request, **kwargs): form_class = kwargs.pop("form_class", AddEmailForm) template_name = kwargs.pop("template_name", "account/email.html") sync_user_email_addresses(request.user) if request.method == "POST" and request.user.is_authenticated(): if "action_add" in request.POST: add_email_form = form_class(request.user, request.POST) if add_email_form.is_valid(): email_address = add_email_form.save(request) get_adapter().add_message( request, messages.INFO, 'account/messages/email_confirmation_sent.txt', {'email': add_email_form.cleaned_data["email"]}) signals.email_added.send(sender=request.user.__class__, request=request, user=request.user, email_address=email_address) return HttpResponseRedirect(reverse('account_email')) else: add_email_form = form_class() if request.POST.get("email"): email = request.POST["email"] try: email_address = EmailAddress.objects.get(user=request.user, email=email) return _no_add_email_action(request, email_address) except EmailAddress.DoesNotExist: pass else: add_email_form = form_class() ctx = {"add_email_form": add_email_form} return render_to_response(template_name, RequestContext(request, ctx))
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME): "Displays the login form and handles the login action." redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == "POST": form = AuthenticationForm(data=request.POST) if form.is_valid(): # Light security check -- make sure redirect_to isn't garbage. if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL from django.contrib.auth import login login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() return HttpResponseRedirect(redirect_to) else: form = AuthenticationForm(request) request.session.set_test_cookie() if Site._meta.installed: current_site = Site.objects.get_current() else: current_site = RequestSite(request) return render_to_response(template_name, { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, }, context_instance=RequestContext(request))
def login(request): if 'openid' in request.GET or request.method == 'POST': form = LoginForm(request.REQUEST) if form.is_valid(): client = _openid_consumer(request) try: auth_request = client.begin(form.cleaned_data['openid']) if QUERY_EMAIL: sreg = SRegRequest() sreg.requestField(field_name=SRegField.EMAIL, required=True) auth_request.addExtension(sreg) ax = FetchRequest() ax.add(AttrInfo(AXAttribute.CONTACT_EMAIL, required=True)) auth_request.addExtension(ax) callback_url = reverse(callback) SocialLogin.stash_state(request) redirect_url = auth_request.redirectURL( request.build_absolute_uri('/'), request.build_absolute_uri(callback_url)) return HttpResponseRedirect(redirect_url) # UnicodeDecodeError: see https://github.com/necaris/python3-openid/issues/1 except (UnicodeDecodeError, DiscoveryFailure) as e: if request.method == 'POST': form._errors["openid"] = form.error_class([e]) else: return render_authentication_error(request) else: form = LoginForm() d = dict(form=form) return render_to_response('openid/login.html', d, context_instance=RequestContext(request))
def password_reset(request, is_admin_site=False, template_name='registration/password_reset_form.html', email_template_name=None, password_reset_form=PasswordResetForm, token_generator=default_token_generator, post_reset_redirect=None): if post_reset_redirect is None: post_reset_redirect = reverse('baph.auth.views.password_reset_done') if request.method == "POST": form = password_reset_form(request.POST) if form.is_valid(): if not email_template_name: email_template_name = 'registration/password_reset_email.html' opts = {} opts['use_https'] = request.is_secure() opts['token_generator'] = token_generator opts['email_template_name'] = email_template_name opts['request'] = request if is_admin_site: opts['domain_override'] = request.META['HTTP_HOST'] form.save(**opts) return HttpResponseRedirect(post_reset_redirect) else: form = password_reset_form() return render_to_response(template_name, { 'form': form, }, context_instance=RequestContext(request))
def signup_complete(request, template_name='registration/signup_complete.html', extra_context=None): if not extra_context: extra_context = dict() return render_to_response(template_name, extra_context, context_instance=RequestContext(request))
def ostala_trzista_item_edit(request, id=0): from project.order.models import ArtikalDrugoTrziste, Trziste from project.meds.models import AtcCode from project.util import str_to_float item, new_item = ArtikalDrugoTrziste.create_object(id) if request.method == "POST": post = lambda key: request.POST.get(key, "") item.set_string("ime", post("ime")) item.set_foreign_object("trziste", Trziste, post("trziste")) item.cijena = str_to_float(post("cijena")) item.set_string("kolicina", post("kolicina")) item.set_string("jedinice", post("jedinice")) atc_sifra = post('atc_sifra') if atc_sifra != None and len(atc_sifra) > 0: rs = AtcCode.objects.filter(sifra__iexact=atc_sifra) if rs.count() > 0: item.ATC = rs[0] else: item.ATC = None else: item.ATC = None item.save() return HttpResponseRedirect(post("backlink")) return render_to_response("admin/meds/ostala_trzista_item_edit.html", { "item": item, "trzista": Trziste.objects.all(), "active_page": "meds", }, context_instance=RequestContext(request))
def authorize_request_token(request, form_class=AuthorizeRequestTokenForm, template_name='piston/oauth/authorize.html', verification_template_name=DEFAULT_VERIFY_TPL): if 'oauth_token' not in request.REQUEST: return HttpResponseBadRequest('No request token specified.') oauth_request = get_oauth_request(request) try: request_token = store.get_request_token(request, oauth_request, request.REQUEST['oauth_token']) except InvalidTokenError: return HttpResponseBadRequest('Invalid request token.') consumer = store.get_consumer_for_request_token(request, oauth_request, request_token) if request.method == 'POST': form = form_class(request.POST) if form.is_valid() and form.cleaned_data['authorize_access']: request_token = store.authorize_request_token( request, oauth_request, request_token) if request_token.callback is not None and \ request_token.callback != 'oob': url = '%s&%s' % (request_token.get_callback_url(), urlencode({ 'oauth_token': request_token.key, })) return HttpResponseRedirect(url) else: return render_to_response( verification_template_name, { 'consumer': consumer, 'verification_code': request_token.verifier, }, RequestContext(request)) else: form = form_class(initial={ 'oauth_token': request_token.key, }) return render_to_response(template_name, { 'consumer': consumer, 'form': form, }, RequestContext(request))
def activate(request, activation_key, template_name='registration/activate_fail.html', retry_template_name='registration/activate_retry.html', success_url=django_settings.LOGIN_REDIRECT_URL, extra_context=None): session = orm.sessionmaker() signup = session.query(UserRegistration) \ .filter_by(activation_key=activation_key) \ .first() if not signup: if not extra_context: extra_context = dict() return render_to_response(template_name, extra_context, context_instance=RequestContext(request)) if (not signup.activation_key_expired() or not settings.BAPH_ACTIVATION_RETRY): user = SignupManager.activate_user(activation_key) if user: auth_user = authenticate(identification=user.email, check_password=False) login(request, auth_user) messages.success(request, _('Your account has been activated and ' 'you have been signed in.'), fail_silently=True) if success_url: redirect_to = success_url % {'username': user.username} else: redirect_to = reverse('userena_profile_detail', kwargs={'username': user.username}) #TODO this is broken return redirect(redirect_to) else: if not extra_context: extra_context = dict() return render_to_response(template_name, extra_context, context_instance=RequestContext(request)) else: if not extra_context: extra_context = dict() extra_context['activation_key'] = activation_key return render_to_response(retry_template_name, extra_context, context_instance=RequestContext(request))
def konta_item_list(request): from django.db.models import Q from project.util import decode_cookie_value, str_to_int from project.nabava.models import Konto return render_to_response("admin/meds/konta_list.html", { "items": Konto.objects.all(), "active_page": "meds", }, context_instance=RequestContext(request))
def _login_social_account(request, sociallogin): user = sociallogin.account.user if not user.is_active: ret = render_to_response('socialaccount/account_inactive.html', {}, context_instance=RequestContext(request)) else: ret = perform_login(request, user, email_verification=app_settings.EMAIL_VERIFICATION, redirect_url=sociallogin.get_redirect_url(request), signal_kwargs={"sociallogin": sociallogin}) return ret
def password_reset_done(request, template_name='registration/password_reset_done.html', current_app=None, extra_context=None): context = { 'title': _('Password reset successful'), } if extra_context is not None: context.update(extra_context) return render_to_response(template_name, context, context_instance=RequestContext(request))
def password_reset_confirm( request, uidb36=None, token=None, template_name='registration/password_reset_confirm.html', token_generator=default_token_generator, set_password_form=SetPasswordForm, post_reset_redirect=None, current_app=None, extra_context=None): '''View that checks the hash in a password reset link and presents a form for entering a new password. Doesn't need ``csrf_protect`` since no-one can guess the URL. ''' assert uidb36 is not None and token is not None # checked by URLconf if post_reset_redirect is None: post_reset_redirect = reverse('baph_password_change_complete') else: post_reset_redirect = resolve_url(post_reset_redirect) try: uid = base36_to_int(uidb36) user = get_object_or_404(User, id=uid) except (TypeError, ValueError, OverflowError): user = None if user is not None and token_generator.check_token(user, token): validlink = True title = _('Enter new password') if request.method == 'POST': form = set_password_form(user, request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(post_reset_redirect) else: form = set_password_form(user) else: validlink = False form = None title = _('Password reset unsuccessful') context = { 'form': form, 'title': title, 'validlink': validlink, } if extra_context is not None: context.update(extra_context) return render_to_response(template_name, context, context_instance=RequestContext(request))
def password_reset_complete( request, template_name='registration/password_reset_complete.html', current_app=None, extra_context=None): context = { 'login_url': resolve_url(settings.LOGIN_URL), 'title': _('Password reset complete'), } if extra_context is not None: context.update(extra_context) return render_to_response(template_name, context, context_instance=RequestContext(request))
def connections(request): form = None if request.method == 'POST': form = DisconnectForm(request.POST, request=request) if form.is_valid(): get_account_adapter().add_message( request, messages.INFO, 'socialaccount/messages/account_disconnected.txt') form.save() form = None if not form: form = DisconnectForm(request=request) d = dict(form=form) return render_to_response('socialaccount/connections.html', d, context_instance=RequestContext(request))
def email_confirm(request, confirmation_key, template_name='registration/email_confirm_fail.html', success_url=None, extra_context=None): """ Confirms an email address with a confirmation key. Confirms a new email address by running :func:`User.objects.confirm_email` method. If the method returns an :class:`User` the user will have his new e-mail address set and redirected to ``success_url``. If no ``User`` is returned the user will be represented with a fail message from ``template_name``. :param confirmation_key: String with a SHA1 representing the confirmation key used to verify a new email address. :param template_name: String containing the template name which should be rendered when confirmation fails. When confirmation is successful, no template is needed because the user will be redirected to ``success_url``. :param success_url: String containing the URL which is redirected to after a successful confirmation. Supplied argument must be able to be rendered by ``reverse`` function. :param extra_context: Dictionary of variables that are passed on to the template supplied by ``template_name``. """ user = SignupManager.confirm_email(confirmation_key) if user: messages.success(request, _('Your email address has been changed.'), fail_silently=True) if success_url: redirect_to = success_url else: redirect_to = reverse('baph_email_confirm_complete') return redirect(redirect_to) else: if not extra_context: extra_context = dict() return render_to_response(template_name, extra_context, context_instance=RequestContext(request))
def media_js(self, request): locale = self.get_locale_for_request(request) try: app = self.get_app(request) except SocialApp.DoesNotExist: raise ImproperlyConfigured("No Facebook app configured: please" " add a SocialApp using the Django" " admin") fb_login_options = self.get_fb_login_options(request) ctx = {'facebook_app': app, 'facebook_channel_url': request.build_absolute_uri(reverse('facebook_channel')), 'fb_login_options': mark_safe(json.dumps(fb_login_options)), 'facebook_jssdk_locale': locale} return render_to_string('facebook/fbconnect.html', ctx, RequestContext(request))
def activate_retry(request, activation_key, template_name='registration/activate_retry_success.html', extra_context=None): """ Reissue a new ``activation_key`` for the user with the expired ``activation_key``. If ``activation_key`` does not exists, or ``BAPH_ACTIVATION_RETRY`` is set to False and for any other error condition user is redirected to :func:`activate` for error message display. :param activation_key: String of a SHA1 string of 40 characters long. A SHA1 is always 160bit long, with 4 bits per character this makes it --160/4-- 40 characters long. :param template_name: String containing the template name that is used when new ``activation_key`` has been created. Defaults to ``userena/activate_retry_success.html``. :param extra_context: Dictionary containing variables which could be added to the template context. Default to an empty dictionary. """ if not settings.BAPH_ACTIVATION_RETRY: return redirect(reverse('baph_activate', args=(activation_key, ))) try: if SignupManager.check_expired_activation(activation_key): new_key = SignupManager.reissue_activation(activation_key) if new_key: if not extra_context: extra_context = dict() return render_to_response( template_name, extra_context, context_instance=RequestContext(request)) else: return redirect( reverse('baph_activate', args=(activation_key, ))) else: return redirect(reverse('baph_activate', args=(activation_key, ))) except NoResultFound: return redirect(reverse('baph_activate', args=(activation_key, )))
def logout(request, next_page=None, template_name='registration/logged_out.html', redirect_field_name=REDIRECT_FIELD_NAME): '''Logs out the user and displays 'You are logged out' message.''' auth_logout(request) if next_page is None: redirect_to = request.REQUEST.get(redirect_field_name, '') if redirect_to: return HttpResponseRedirect(redirect_to) else: return render_to_response(template_name, { 'title': _('Logged out'), }, context_instance=RequestContext(request)) else: # Redirect to this page until the session has been cleared. return HttpResponseRedirect(next_page or request.path)
def password_reset(request, **kwargs): form_class = kwargs.pop("form_class", ResetPasswordForm) template_name = kwargs.pop("template_name", "account/password_reset.html") if request.method == "POST": password_reset_form = form_class(request.POST) if password_reset_form.is_valid(): password_reset_form.save() return HttpResponseRedirect(reverse(password_reset_done)) else: password_reset_form = form_class() return render_to_response( template_name, RequestContext(request, { "password_reset_form": password_reset_form, }))
def login(request, template_name='registration/login.haml', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationForm): """Displays the login form and handles the login action.""" redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == "POST": form = authentication_form(data=request.POST) if form.is_valid(): # Light security check -- make sure redirect_to isn't garbage. if not redirect_to or ' ' in redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL # Heavier security check -- redirects to http://example.com should # not be allowed, but things like /view/?param=http://example.com # should be allowed. This regex checks if there is a '//' *before* a # question mark. elif '//' in redirect_to and re.match(r'[^\?]*//', redirect_to): redirect_to = settings.LOGIN_REDIRECT_URL # Okay, security checks complete. Log the user in. auth_login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) request.session.set_test_cookie() current_site = get_current_site(request) return render_to_response(template_name, { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, }, context_instance=RequestContext(request))
def complete_registration(request): if request.method == 'POST': return register(request, BACKEND) form = None if 'denied' in request.GET: template_name = 'twitter/auth/denied.html' elif 'oauth_token' in request.GET and 'oauth_verifier' in request.GET: form = TwitterRegistrationForm( initial={ 'oauth_token': request.GET['oauth_token'], 'oauth_verifier': request.GET['oauth_verifier'], }) template_name = 'twitter/auth/complete.html' else: return redirect('/', (), {}) return render_to_response(template_name, { 'form': form, }, context_instance=RequestContext(request))
def konta_item_edit(request, id=0): from project.nabava.models import Konto from project.util import str_to_int item, new_item = Konto.create_object(id) if request.method == "POST": post = lambda key: request.POST.get(key, "") item.set_string("name", post("name")) item.sifra = str_to_int(post("sifra")) item.set_string("kontakt", post("kontakt")) item.save() return HttpResponseRedirect(post("backlink")) return render_to_response("admin/meds/konta_item_edit.html", { "item": item, "active_page": "meds", }, context_instance=RequestContext(request))
def trzista_item_list(request): from project.util import str_to_float from project.meds.models import Trziste if request.method == "POST": cmd = request.POST.get("cmd") if cmd == "edit": id = request.POST.get("id") koeficijent_ljekarne = str_to_float(request.POST.get("koef_vpc")) koeficijent_pacijenti = str_to_float(request.POST.get("koef_mpc")) Trziste.objects.filter(id=id).update( koeficijent_ljekarne=koeficijent_ljekarne, koeficijent_pacijenti=koeficijent_pacijenti) return HttpResponseRedirect(request.path) return render_to_response("admin/meds/trzista_list.html", { "items": Trziste.objects.all().order_by("naziv"), "active_page": "meds", }, context_instance=RequestContext(request))
def njemacka_item_edit(request, id=0): from project.meds.models import Artikal from project.util import str_to_float item, new_item = Artikal.create_object(id) if request.method == "POST": post = lambda key: request.POST.get(key, "") item.set_string("name", post("name")) item.ApoEk = str_to_float(post("ApoEk")) * 100.0 item.ApoVk = str_to_float(post("ApoVk")) * 100.0 item.save() return HttpResponseRedirect(post("backlink")) return render_to_response("admin/meds/njemacka_edit.html", { "item": item, "active_page": "meds", }, context_instance=RequestContext(request))
def flatpage(request, url): """ Flat page view. Models: `flatpages.flatpages` Templates: Uses the template defined by the ``template_name`` field, or `flatpages/default.html` if template_name is not defined. Context: flatpage `flatpages.flatpages` object """ if not url.endswith('/') and settings.APPEND_SLASH: return HttpResponseRedirect("%s/" % request.path) if not url.startswith('/'): url = "/" + url f = get_object_or_404(FlatPage, url__exact=url, sites__id__exact=settings.SITE_ID) # If registration is required for accessing this page, and the user isn't # logged in, redirect to the login page. if f.registration_required and not request.user.is_authenticated(): from django.contrib.auth.views import redirect_to_login return redirect_to_login(request.path) if f.template_name: t = loader.select_template((f.template_name, DEFAULT_TEMPLATE)) else: t = loader.get_template(DEFAULT_TEMPLATE) # To avoid having to always use the "|safe" filter in flatpage templates, # mark the title and content as already safe (since they are raw HTML # content in the first place). f.title = mark_safe(f.title) f.content = mark_safe(f.content) c = RequestContext(request, { 'flatpage': f, }) response = HttpResponse(t.render(c)) populate_xheaders(request, response, FlatPage, f.id) return response
def password_reset_from_key(request, uidb36, key, **kwargs): form_class = kwargs.get("form_class", ResetPasswordKeyForm) template_name = kwargs.get("template_name", "account/password_reset_from_key.html") token_generator = kwargs.get("token_generator", default_token_generator) # pull out user try: uid_int = base36_to_int(uidb36) except ValueError: raise Http404 user = get_object_or_404(User, id=uid_int) if token_generator.check_token(user, key): if request.method == "POST": password_reset_key_form = form_class(request.POST, user=user, temp_key=key) if password_reset_key_form.is_valid(): password_reset_key_form.save() get_adapter().add_message( request, messages.SUCCESS, 'account/messages/password_changed.txt') signals.password_reset.send(sender=user.__class__, request=request, user=user) password_reset_key_form = None else: password_reset_key_form = form_class() ctx = { "form": password_reset_key_form, } else: ctx = { "token_fail": True, } return render_to_response(template_name, RequestContext(request, ctx))
def password_set(request, **kwargs): form_class = kwargs.pop("form_class", SetPasswordForm) template_name = kwargs.pop("template_name", "account/password_set.html") if request.user.has_usable_password(): return HttpResponseRedirect(reverse(password_change)) if request.method == "POST": password_set_form = form_class(request.user, request.POST) if password_set_form.is_valid(): password_set_form.save() get_adapter().add_message(request, messages.SUCCESS, 'account/messages/password_set.txt') signals.password_set.send(sender=request.user.__class__, request=request, user=request.user) return HttpResponseRedirect(reverse(password_change)) else: password_set_form = form_class(request.user) ctx = {"password_set_form": password_set_form} return render_to_response(template_name, RequestContext(request, ctx))
def password_reset_confirm(request, uidb36=None, token=None, template_name=None, token_generator=default_token_generator, set_password_form=SetPasswordForm, post_reset_redirect=None): '''View that checks the hash in a password reset link and presents a form for entering a new password. Doesn't need ``csrf_protect`` since no-one can guess the URL. ''' assert uidb36 is not None and token is not None # checked by URLconf if not template_name: template_name = 'registration/password_reset_confirm.html' if post_reset_redirect is None: post_reset_redirect = reverse( 'baph.auth.views.password_reset_complete') try: uid = UUID(int=base36_to_int(uidb36)) except ValueError: raise Http404 user = get_object_or_404(User, id=uid) context_instance = RequestContext(request) if token_generator.check_token(user, token): context_instance['validlink'] = True if request.method == 'POST': form = set_password_form(user, request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(post_reset_redirect) else: form = set_password_form(None) else: context_instance['validlink'] = False form = None context_instance['form'] = form return render_to_response(template_name, context_instance=context_instance)