def testCreateLazyUser(self, mock_resolve):
# If there isn't a setup session, then this middleware should create a user
# with the same name as the session key, and an unusable password.
f = allow_lazy_user(lambda: 1)
mock_resolve.return_value = (f, None, None)
self.m.process_request(self.request)
self.assertEqual(self.request.session.session_key[:30], self.request.user.username)
self.assertEqual(False, self.request.user.has_usable_password())
def testCreateLazyUser(self, mock_resolve):
# If there isn't a setup session, then this middleware should create a user
# with the same name as the session key, and an unusable password.
f = allow_lazy_user(lambda request: 1)
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(username_from_session(self.request.session.session_key), self.request.user.username)
self.assertEqual(False, self.request.user.has_usable_password())
def test_create_lazy_user(self, mock_resolve):
# If there isn't a setup session, then this middleware should create a
# user with a random username and an unusable password.
f = allow_lazy_user(lambda request: 1)
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(self.request.user.username is None)
self.assertEqual(False, self.request.user.has_usable_password())
def test_create_lazy_user(self, mock_resolve):
# If there isn't a setup session, then this middleware should create a
# user with a random username and an unusable password.
f = allow_lazy_user(lambda request: 1)
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(self.request.user.username is None)
self.assertEqual(False, self.request.user.has_usable_password())
def testBannedUserAgents(self, mock_resolve):
# If the client's user agent matches a regex in the banned
# list, then a user shouldn't be created.
self.request.META['HTTP_USER_AGENT'] = 'search engine'
f = allow_lazy_user(lambda: 1)
mock_resolve.return_value = (f, None, None)
self.m.process_request(self.request)
self.failIf(hasattr(self.request, 'user'))
self.assertEqual(0, len(User.objects.all()))
def test_bad_session_already_exists(self, mock_resolve):
# If the user id is already in the session, but the user doesn't
# exist, then a user should be created
f = allow_lazy_user(lambda request: 1)
self.request.session[SESSION_KEY] = 1000
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(self.request.user.username is None)
self.assertEqual(False, self.request.user.has_usable_password())
def testSessionAlreadyExists(self, mock_resolve):
# If the user id is already in the session, this decorator should do nothing.
f = allow_lazy_user(lambda request: 1)
user = User.objects.create_user("test", "*****@*****.**", "test")
self.request.user = AnonymousUser()
login(self.request, authenticate(username="******", password="******"))
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(user, self.request.user)
def test_banned_user_agents(self, mock_resolve):
# If the client's user agent matches a regex in the banned
# list, then a user shouldn't be created.
self.request.META['HTTP_USER_AGENT'] = 'search engine'
f = allow_lazy_user(lambda request: 1)
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(hasattr(self.request, 'user'))
self.assertEqual(0, len(get_user_model().objects.all()))
def test_banned_user_agents(self, mock_resolve):
# If the client's user agent matches a regex in the banned
# list, then a user shouldn't be created.
self.request.META['HTTP_USER_AGENT'] = 'search engine'
f = allow_lazy_user(lambda request: 1)
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(hasattr(self.request, 'user'))
self.assertEqual(0, len(get_user_model().objects.all()))
def test_bad_session_already_exists(self, mock_resolve):
# If the user id is already in the session, but the user doesn't
# exist, then a user should be created
f = allow_lazy_user(lambda request: 1)
self.request.session[SESSION_KEY] = 1000
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertFalse(self.request.user.username is None)
self.assertEqual(False, self.request.user.has_usable_password())
def testBadSessionAlreadyExists(self, mock_resolve):
# If the user id is already in the session, but the user doesn't exist,
# then a user should be created
f = allow_lazy_user(lambda: 1)
self.request.session[SESSION_KEY] = 1000
mock_resolve.return_value = (f, None, None)
self.m.process_request(self.request)
self.assertEqual(self.request.session.session_key[:30], self.request.user.username)
self.assertEqual(False, self.request.user.has_usable_password())
def testSessionAlreadyExists(self, mock_resolve):
# If the user id is already in the session, this middleware should do nothing.
f = allow_lazy_user(lambda: 1)
user = User.objects.create_user('test', '*****@*****.**', 'test')
self.request.user = AnonymousUser()
login(self.request, authenticate(username='******', password='******'))
mock_resolve.return_value = (f, None, None)
self.m.process_request(self.request)
self.assertEqual(user, self.request.user)
def testSessionAlreadyExists(self, mock_resolve):
# If the user id is already in the session, this decorator should do nothing.
f = allow_lazy_user(lambda request: 1)
user = User.objects.create_user('test', '*****@*****.**', 'test')
self.request.user = AnonymousUser()
login(self.request, authenticate(username='******', password='******'))
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(user, self.request.user)
def testBadSessionAlreadyExists(self, mock_resolve):
# If the user id is already in the session, but the user doesn't exist,
# then a user should be created
f = allow_lazy_user(lambda request: 1)
self.request.session[SESSION_KEY] = 1000
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(username_from_session(self.request.session.session_key), self.request.user.username)
self.assertEqual(False, self.request.user.has_usable_password())
def test_session_already_exists(self, mock_resolve):
# If the user id is already in the session, this decorator should do
# nothing.
f = allow_lazy_user(lambda request: 1)
user = get_user_model().objects.create_user('test', '*****@*****.**', 'test')
self.request.user = AnonymousUser()
login(self.request, authenticate(username='******', password='******'))
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(user, self.request.user)
def test_session_already_exists(self, mock_resolve):
# If the user id is already in the session, this decorator should do
# nothing.
f = allow_lazy_user(lambda request: 1)
user = get_user_model().objects.create_user("test", "*****@*****.**", "test")
self.request.user = AnonymousUser()
login(self.request, authenticate(username="******", password="******"))
mock_resolve.return_value = (f, None, None)
f(self.request)
self.assertEqual(user, self.request.user)
def view(request):
from django.http import HttpResponse
r = HttpResponse()
if request.user.is_authenticated():
r.status_code = 500
return r
def lazy_view(request):
from django.http import HttpResponse
r = HttpResponse()
if request.user.is_anonymous() or request.user.has_usable_password():
r.status_code = 500
return r
lazy_view = allow_lazy_user(lazy_view)
def no_lazysignup(func):
def wrapped(*args, **kwargs):
if hasattr(settings, 'LAZYSIGNUP_ENABLE'):
old = settings.LAZYSIGNUP_ENABLE
else:
old = _missing
settings.LAZYSIGNUP_ENABLE = False
try:
result = func(*args, **kwargs)
finally:
if old is _missing:
delattr(settings, 'LAZYSIGNUP_ENABLE')
else:
from django.contrib.auth import logout as auth_logout
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect
from django.views.generic.base import TemplateView
from lazysignup.decorators import allow_lazy_user
class Ego(TemplateView):
template_name = 'antisocial/ego.html'
ego = allow_lazy_user(Ego.as_view())
def logout(request):
auth_logout(request)
return HttpResponseRedirect(reverse('asn_home'))
try:
score = question.score(answers)
except Answer.DoesNotExist:
return HttpResponseBadRequest("Invalid answer '%s:%s'" % (question_slug, answers))
# save!
filter_attrs = {'user': request.user, 'question': question_slug}
attrs = {'answer': answers, 'score': score}
rows = Submission.objects.filter(**filter_attrs).update(**attrs)
if not rows:
attrs.update(filter_attrs)
Submission.objects.create(**attrs)
return HttpResponse("OK")
if getattr(settings, "SAQ_LAZYSIGNUP", False):
from lazysignup.decorators import allow_lazy_user
submit = allow_lazy_user(_submit)
else:
submit = login_required(_submit)
@require_GET
@never_cache
@login_required
def scores(request):
slugs = request.GET.getlist('q')
if slugs == []:
return HttpResponseBadRequest("No questions supplied")
submissions = Submission.objects.filter(user=request.user, question__in=slugs)
submissions = [[s.question, {'answer': s.answer, 'score': s.score}]
for s in submissions]
data = {
from django.urls import path
from lazysignup.decorators import allow_lazy_user
from ads import views
app_name = 'ads'
urlpatterns = [
path('', allow_lazy_user(views.IndexView()), name='index'),
path('search/autocomplete/',
allow_lazy_user(views.autocomplete),
name='autocomplete'),
path('url/', views.to_external_url, name='to_external_url'),
path('ads/<str:category>/<str:subcategory>',
views.AdsByCategoriesView.as_view(),
name='list_by_categories'),
path('ads/<str:category>',
views.AdsByMainCategoryView.as_view(),
name='list_by_main_category'),
path('view/<str:ad_slug>/', views.detail, name='detail'),
path('create', views.create, name='create'),
path('edit/<int:id>', views.edit, name='edit'),
path('delete/<int:id>', views.delete, name='delete'),
path('my_ads/', views.user_ads, name='user_ads'),
]
from django.conf.urls import url
from . import views
from lazysignup.decorators import allow_lazy_user
from lazysignup.views import convert
urlpatterns = [
url(r'^$', allow_lazy_user(views.HomeView.as_view()), name='home'),
url(r'^convert$',
convert, {'template_name': 'convert.html'},
name='lazysignup_convert'),
]
from django.http import HttpResponse
r = HttpResponse()
if request.user.is_authenticated():
r.status_code = 500
return r
def lazy_view(request):
from django.http import HttpResponse
r = HttpResponse()
if request.user.is_anonymous() or request.user.has_usable_password():
r.status_code = 500
return r
lazy_view = allow_lazy_user(lazy_view)
def no_lazysignup(func):
def wrapped(*args, **kwargs):
if hasattr(settings, 'LAZYSIGNUP_ENABLE'):
old = settings.LAZYSIGNUP_ENABLE
else:
old = _missing
settings.LAZYSIGNUP_ENABLE = False
try:
result = func(*args, **kwargs)
finally:
if old is _missing:
delattr(settings, 'LAZYSIGNUP_ENABLE')
else:
def __init__(self, get_response):
self.get_response = allow_lazy_user(get_response)
from django.conf.urls import patterns, include, url
from django.views.generic import TemplateView
from artless_calendar.views import AddEvent, CreateEvent, ListEvents, DetailView
from lazysignup.decorators import allow_lazy_user
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
# url(r'^$', TemplateView.as_view(template_name='sidebar.html')),
# url(r'^base/$', TemplateView.as_view(template_name='base.html')),
# url(r'^test/$', TemplateView.as_view(template_name='test.html')),
url(r'^$', TemplateView.as_view(template_name="msg2.html"), name='home'),
## url(r'^$', ListEvents.as_view(), name='home'),
url(r'^events/add/$', allow_lazy_user(CreateEvent.as_view()), name='add_event'),
#url(r'^addevent/$', AddEvent.as_view(), name='nt'),
#url(r'^submit/$', AddEvent.submit_form(), name='submit_event'),
url(r'^events/(?P<pk>[-_\w]+)/$', DetailView.as_view(), name='event_detail'),
url(r'^events/submitted$', TemplateView.as_view(template_name="success.html"), name='success'),
# url(r'^captcha/', include('captcha.urls')),
# url(r'^captcha/', include('captcha.urls')),
# blog:
url(r'^', include('zinnia_custom.urls')),
url(r'^', include('zinnia.urls')),
url(r'^comments/', include('django.contrib.comments.urls')),
url(r'^about/', TemplateView.as_view(template_name="about.html"), name="about"),
# Examples:
# url(r'^$', 'artless.views.home', name='home'),
from django.conf.urls import url, include
from django.contrib.auth.decorators import login_required
from lazysignup.decorators import allow_lazy_user
from . import views
urlpatterns = [
url('^accounts/', include('django.contrib.auth.urls')),
url(r'^convert/', include('lazysignup.urls')),
url(r'^$', allow_lazy_user(views.process_index), name='index'),
url(r'^overview$', allow_lazy_user(views.process_overview), name='overview'),
url(r'^(?P<process_id>\d+)/create$',
login_required(views.process_instance_create), name='instance_create'),
url(r'^(?P<process_id>\d+)/(?P<instance_id>\d+)/?$',
login_required(views.ProcessInstanceEditView.as_view()), name='instance_detail'), # REFACT rename instance_edit
]
