def test_with_invalid_zone(self):
'''
@throttle throws an exception if an invalid zone is specified
'''
with self.assertRaises(ThrottleZoneNotDefined):
_throttled_view = throttle(_test_view_not_throttled, zone='oœuf')
_throttled_view(object)
def test_with_invalid_zone(self):
'''
@throttle throws an exception if an invalid zone is specified
'''
with self.assertRaises(ThrottleZoneNotDefined):
_throttled_view = throttle(_test_view_not_throttled, zone='oœuf')
_throttled_view(object)
class TestView(View):
@method_decorator(throttle(zone='default'))
def dispatch(self, *args, **kwargs):
return super(TestView, self).dispatch(*args, **kwargs)
def head(self, request, id):
return HttpResponse("Metadata")
def get(self, request, id):
return HttpResponse(str(id))
class Save_student_marks(View):
@method_decorator(throttle(zone='default'))
def dispatch(self, *args, **kwargs):
return super(Save_student_marks, self).dispatch(*args, **kwargs)
def post(self, request):
if validate_user(request):
academic = Academic_Year.objects.all().order_by(
'academic_year').reverse()[0]
teacher = get_object_or_404(Teacher,
username=request.session.get('user'))
data = request.POST
std_id = data.getlist('id')
obtain = data.getlist('obtain')
remark = data.getlist('remarks')
total = data.get('total')
subject = data.get('subject')
class_name = data.get('class')
section = data.get('section')
type = data.get('type')
cls = get_object_or_404(Class, class_name=class_name)
for _ in range(len(std_id)):
student = get_object_or_404(Students, pk=int(std_id[_]))
if student.section == section:
try:
marks = Marks.objects.get(academic_year=academic,
student=student,
class_name=cls,
section=section,
subject=subject,
exam_type=type,
added_by=teacher)
marks.obtain_marks = decimal.Decimal(obtain[_])
marks.total_marks = decimal.Decimal(total)
marks.remarks = remark[_]
marks.save()
except:
marks = Marks(academic_year=academic,
student=student,
class_name=cls,
section=section,
subject=subject,
obtain_marks=decimal.Decimal(obtain[_]),
total_marks=decimal.Decimal(total),
remarks=remark[_],
exam_type=type,
added_by=teacher)
marks.save()
return redirect('upload_marks')
else:
return redirect('teacher_login')
class MovieDetail(DetailView):
model = Movie
@method_decorator(throttle(zone='default'))
def get(self, request, *args, **kwargs):
response = super(MovieDetail, self).get(self, request, *args, **kwargs)
self.object.watch_nr = F('watch_nr') + 1
self.object.save()
return response
def get_context_data(self, *, object_list=None, **kwargs):
data = super().get_context_data(**kwargs)
category_options = list(Category.objects.all().values_list('name',
flat=True))
category_options = [
category.capitalize() for category in category_options
]
data['category_options'] = sort_accented_list(category_options)
return data
"""
Tests custom duration
"""
self.assertEquals(200, self.request(self.name_map['duration']).status_code)
self.assertEquals(200, self.request(self.name_map['duration']).status_code)
def index(request):
"""
Test view function
"""
return HttpResponse("Test view")
urlpatterns = [
url(r'^$', throttle(index), name='test_default'),
url(r'^method/$', throttle(index, method='GET'), name='test_method'),
url(r'^duration/$', throttle(index, duration=0), name='test_duration'),
url(r'^response/$', throttle(index, response=HttpResponse('Response', status=401)), name='test_response'),
url(r'^response/callable/$', throttle(index, response=lambda request: HttpResponse('Request Response', status=401)), name='test_response_callable'),
]
class IndexView(ThrottleMixin, View):
"""
Class based view for mixin test
"""
def get(self, request):
return index(request)
def post(self, request):
class LoginView(FormView):
template_name = 'sso_auth/login.html'
form_class = EmailAuthenticationForm
success_url = reverse_lazy('home')
is_two_factor_required = False
@method_decorator(revision_exempt)
@method_decorator(sensitive_post_parameters())
@method_decorator(never_cache)
@method_decorator(throttle(duration=30, max_calls=12))
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
self.is_two_factor_required = get_request_param(request, 'two_factor', False) is not False
user = request.user
if self.is_two_factor_required and user.is_authenticated and user.device_set.filter(confirmed=True).exists():
session = request.session
redirect_url = get_safe_login_redirect_url(request)
expiry = 0 if session.get_expire_at_browser_close() else settings.SESSION_COOKIE_AGE
backend = session[BACKEND_SESSION_KEY]
device_cls = is_otp_login(user, self.is_two_factor_required)
display = request.GET.get('display')
token_url = get_token_url(user.id, expiry, redirect_url, backend, display, device_cls.get_device_id())
return redirect(token_url)
return super().get(request, *args, **kwargs)
def get_initial(self):
initial = super().get_initial()
initial['remember_me'] = not self.request.session.get_expire_at_browser_close()
return initial
def form_valid(self, form):
user = form.get_user()
redirect_url = get_safe_login_redirect_url(self.request)
# if 2-nd factor available, send token
self.is_two_factor_required = get_request_param(self.request, TWO_FACTOR_PARAM, False) is not False
expiry = settings.SESSION_COOKIE_AGE if form.cleaned_data.get('remember_me', False) else 0
device_cls = is_otp_login(user, self.is_two_factor_required)
if device_cls:
try:
display = self.request.GET.get('display')
self.success_url = get_token_url(user.id, expiry, redirect_url, user.backend, display, device_cls.get_device_id())
except Exception as e:
messages.error(
self.request,
_('Device error, select another device. (%(error)s)') % {'error': force_str(e)})
return self.render_to_response(self.get_context_data(form=form))
else:
# remove the prompt login param, cause login was done here
self.success_url = remove_value_from_url_param(redirect_url, 'prompt', 'login')
user._auth_session_expiry = expiry # used to update the session in auth_login
auth_login(self.request, user)
return super().form_valid(form)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
redirect_url = get_safe_login_redirect_url(self.request)
context['cancel_url'] = get_oauth2_cancel_url(redirect_url)
context['site_name'] = settings.SSO_SITE_NAME
context['display'] = get_request_param(self.request, 'display', 'page')
return context
class TokenView(FormView):
template_name = 'sso_auth/token.html'
form_class = AuthenticationTokenForm
success_url = reverse_lazy('home')
user = None
device_cls = None
expiry = 0
challenges = None
@method_decorator(revision_exempt)
@method_decorator(sensitive_post_parameters())
@method_decorator(never_cache)
@method_decorator(throttle(duration=30, max_calls=12))
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)
def get_form_class(self):
state = signing.loads(self.kwargs['user_data'], salt=SALT)
self.expiry = state['expiry']
self.user = get_user_model().objects.get(pk=state['user_id'])
self.user.backend = state['backend']
self.device_cls = Device.get_subclass(self.kwargs['device_id'])
return self.device_cls.login_form_class()
def get_template_names(self):
try:
return self.device_cls.login_form_templates()
except RuntimeError:
return super().get_template_names()
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs['user'] = self.user
return kwargs
def post(self, request, *args, **kwargs):
if request.POST.get('resend_token'):
return redirect("%s?%s" % (self.request.path, self.request.GET.urlencode()))
return super().post(request, *args, **kwargs)
def get_context_data(self, **kwargs):
"""
Adds user's default and backup OTP devices to the context.
"""
context = super().get_context_data(**kwargs)
device_classes = get_device_classes_for_user(self.user)
other_devices = []
for device_cls in filter(lambda d: d != self.device_cls, device_classes):
device_info = {
'name': device_cls.default_name(),
'url': "%s?%s" % (
reverse('auth:token', kwargs={'user_data': self.kwargs['user_data'], 'device_id': device_cls.get_device_id()}),
self.request.GET.urlencode())
}
other_devices.append(device_info)
context['other_devices'] = other_devices
context['device_cls'] = self.device_cls
redirect_url = get_safe_login_redirect_url(self.request)
context['cancel_url'] = get_oauth2_cancel_url(redirect_url)
context['display'] = get_request_param(self.request, 'display', 'page')
return context
def get_initial(self):
initial = super().get_initial()
if self.request.method == 'GET':
initial.update({'challenges': self.device_cls.challenges(self.user)})
else:
initial.update({'challenges': self.request.POST.get('challenges')})
return initial
def form_valid(self, form):
redirect_url = get_safe_login_redirect_url(self.request)
user = form.user
user._auth_device_id = form.device.id
user._auth_session_expiry = self.expiry
auth_login(self.request, form.user)
# remove the prompt login param, cause login was done here
self.success_url = remove_value_from_url_param(redirect_url, 'prompt', 'login')
return super().form_valid(form)
from django.http import HttpResponse
from django.urls import re_path
from throttle.decorators import throttle
from throttle.tests import index
urlpatterns = [
re_path(r'^$', throttle()(index), name='test_default'),
re_path(r'^method/$', throttle(method='GET')(index), name='test_method'),
re_path(r'^duration/$', throttle(duration=0)(index), name='test_duration'),
re_path(r'^response/$', throttle(response=HttpResponse('Response', status=401))(index), name='test_response'),
re_path(r'^response/callable/$', throttle(response=lambda request: HttpResponse('Request Response', status=401))(index),
name='test_response_callable'),
]
class MovieList(ListView):
model = Movie
paginate_by = 12
@method_decorator(throttle(zone='default'))
def dispatch(self, *args, **kwargs):
return super(MovieList, self).dispatch(*args, **kwargs)
def get_context_data(self, *, object_list=None, **kwargs):
data = super().get_context_data(**kwargs)
category_options = list(Category.objects.all().values_list('name',
flat=True))
category_options = [
category.capitalize() for category in category_options
]
data['category_options'] = sort_accented_list(category_options)
data['end_minus_five'] = data['paginator'].page_range.stop - 5
data['last_page'] = data['paginator'].page_range.stop - 1
# data['before_last_page'] = data['paginator'].page_range.stop - 2
page_no = data['page_obj'].number
begin = page_no - 2 if page_no > 3 else 2
end = page_no + 3 if page_no < data['last_page'] - 2 else min(
page_no + 2, data['last_page'])
data['custom_page_range'] = range(begin, end)
data['get_string'] = '&'.join([
'{}={}'.format(key, quote(value))
for (key, value) in self.request.GET.items() if key != 'page'
])
data['root_page'] = self.request.GET == {}
return data
def get_queryset(self):
if not self.request.GET:
return self.model.objects.order_by('-watch_nr')[:12]
id = self.request.GET.get('id')
search_by = self.request.GET.get('search_by')
search = self.request.GET.get('search')
category = self.request.GET.get('category')
type = self.request.GET.get('type')
if id:
return Movie.objects.filter(id=id)
query_filter = []
if search:
# HUNGARIAN_CHAR_MAP_MATCH = {'a': 'aá', 'á': 'aá', 'e': 'eé', 'é': 'eé', 'i': 'ií', 'í': 'ií', 'o': 'oöóő',
# 'ö': 'oöóő', 'ó': 'oöóő', 'ő': 'oöóő', 'u': 'uüúű', 'ü': 'uüúű', 'ú': 'uüúű',
# 'ű': 'uüúű'}
HUNGARIAN_CHAR_MAP_MATCH = {
'a': 'aá',
'e': 'eé',
'i': 'ií',
'o': 'oöóő',
'u': 'uüúű'
}
for char in HUNGARIAN_CHAR_MAP_MATCH.keys():
search = search.replace(
char, '[{}]'.format(HUNGARIAN_CHAR_MAP_MATCH[char]))
if search_by == 'title':
query_filter.append(Q(title__iregex=search))
elif search_by == 'actors':
query_filter.append(Q(actors__name__iregex=search))
elif search_by == 'directors':
query_filter.append(Q(directors__name__iregex=search))
if category and category != 'all':
query_filter.append(Q(categories__name__icontains=category))
if type and type != 'all':
if type == 'movie':
query_filter.append(Q(is_series=False))
elif type == 'series':
query_filter.append(Q(is_series=True))
return self.model.objects.filter(*query_filter)
