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)
