def form_valid(self, form):
data = dict()
# Перед созданием новой записи проверяем есть ли видео
if Video.objects.all().exists():
data['video_exist'] = True
else:
data['video_exist'] = False
# Сохраняем новую запись
new_video = form.save(commit=False)
new_video.save()
# Будет использовано лишь один раз в начале, когда еще нет списка видео
data['html_videos'] = render_to_string(
'video/videos.html',
{
'videos': Video.objects.all(),
'perms': PermWrapper(self.request.user),
}
)
# Будет использоваться когда есть список видео
data['html_video'] = render_to_string(
'video/video.html',
{
'video': new_video,
'perms': PermWrapper(self.request.user),
}
)
data['video_id'] = new_video.id
data['form_is_valid'] = True
return JsonResponse(data)
def form_valid(self, form):
data = dict()
# Создаем новый вопрос
new_question = form.save(commit=False)
new_question.lang = self.kwargs.get('language')
new_question.save()
# После создания нового вопроса проверяем наличия вопросов по заданным параметрам
if FAQ.objects.filter(lang=self.kwargs.get('language')).count() == 1:
data['question_exist'] = True
# HTML вопросов
data['html_questions'] = render_to_string(
'faq/questions.html', {
'questions':
FAQ.objects.filter(event_lang=self.kwargs.get('language')),
'current_language':
self.kwargs.get('language'),
'perms':
PermWrapper(self.request.user),
})
else:
data['question_exist'] = False
# HTML нового вопроса
data['html_question'] = render_to_string(
'faq/question.html', {
'question': new_question,
'current_language': self.kwargs.get('language'),
'perms': PermWrapper(self.request.user),
},
request=self.request)
# Валидная форма
data['form_is_valid'] = True
return JsonResponse(data)
def post(self, request, *args, **kwargs):
val = self.request.POST.get("val", "")
sort = self.request.POST.get("sort", "-publish_time")
start = int(self.request.POST.get("start", 0))
end = int(self.request.POST.get("end", settings.PAGE_NUM))
if val == 'all':
category_list = Category.objects.all()
else:
category_list = Category.objects.filter(name=val).all()
article_list = self.get_queryset().filter(
category__in=category_list).annotate(comment_count=Count(
'comment_article')).order_by(sort).all()[start:end + 1]
is_end = len(article_list) != (end - start + 1)
article_list = article_list[0:end - start]
html = ""
for article in article_list:
html += get_template('article/article_item.html').render({
'article':
article,
'perms':
PermWrapper(request.user)
})
_dict = {"html": html, "isend": is_end}
return HttpResponse(json.dumps(_dict), content_type="application/json")
def form_valid(self, form):
user = form.save(commit=False)
selected_user_role = form.cleaned_data['user_role']
selected_use_wysiwyg_editor = form.cleaned_data['use_wysiwyg_editor']
if "0" in selected_user_role:
user.is_superuser = True
for permission in Permission.objects.exclude(
codename='use_wysiwyg_editor'):
user.user_permissions.add(permission)
elif "1" in selected_user_role:
user.is_staff = True
form.save_m2m()
elif "2" in selected_user_role:
user.is_superuser = False
user.is_staff = False
for permission in Permission.objects.exclude(
codename='use_wysiwyg_editor'):
user.user_permissions.remove(permission)
if selected_use_wysiwyg_editor:
user.user_permissions.add(
Permission.objects.get(codename='use_wysiwyg_editor'))
elif not selected_use_wysiwyg_editor:
user.user_permissions.remove(
Permission.objects.get(codename='use_wysiwyg_editor'))
user.save()
data = dict()
data['form_is_valid'] = True
context = {
'users': User.objects.order_by('username'),
'perms': PermWrapper(self.request.user),
}
data['html_users'] = render_to_string('users/users.html', context)
return JsonResponse(data)
def actions(self, fault_type):
c = {
'fault_type': fault_type,
'next': reverse('fault_type_list'),
'perms': PermWrapper(self.request.user),
}
return self.templates['actions'].render(c)
def post(self, *args, **kwargs):
start = int(self.request.POST.get("start"))
length = int(self.request.POST.get("length"))
search_term = self.request.POST.get("search[value]")
draw = int(self.request.POST.get("draw"))
queryset = self.get_queryset()
records_total = queryset.count()
if search_term:
queryset = filter_by_search_term(queryset, self.filtered_fields,
search_term)
records_filtered = queryset.count()
data = []
queryset_page = queryset[start:start + length]
for obj in queryset_page:
html = render_to_string(self.tr_template,
context={
'object': obj,
'user': self.request.user,
'perms': PermWrapper(self.request.user)
})
tds = split_html_by_tds(html)
data.append(tds)
return JsonResponse({
"draw": draw,
"recordsTotal": records_total,
"recordsFiltered": records_filtered,
"data": data
})
def package_list_ajax(request):
datatable = datatable_utils.PackageDataTable(request.GET)
data = []
csrf_token = get_token(request)
for package in datatable.records:
data.append(
get_template("snippets/package_row.html").render({
"package":
package,
"redirect_path":
request.META.get("HTTP_REFERER", request.path),
"csrf_token":
csrf_token,
"perms":
PermWrapper(request.user),
}).strip())
# these are the values that DataTables expects from the server
# see "Reply from the server" in http://legacy.datatables.net/usage/server-side
response = {
"iTotalRecords": datatable.total_records,
"iTotalDisplayRecords": datatable.total_display_records,
"sEcho": datatable.echo,
"aaData": data,
}
return HttpResponse(status=200,
content=json.dumps(response),
content_type="application/json")
def buttons(self):
context = {
'perms': PermWrapper(self.context['request'].user),
}
context.update(csrf(self.context['request']))
return self.render(
'netbox_vcenter/virtualmachine/vcenter_refresh.html', context)
def test_permwrapper_in(self):
"""
Test that 'something' in PermWrapper doesn't end up in endless loop.
"""
perms = PermWrapper(MockUser())
with self.assertRaises(TypeError):
self.EQLimiterObject() in perms
def left_page(self):
"""
An info-box with edit button for the vCenter settings
"""
return self.render(
'netbox_vcenter/cluster/vcenter_info.html',
{'perms': PermWrapper(self.context['request'].user)})
def get_actions(self, tli):
template = self.templates['actions']
c = Context({
"instance": tli,
"perms": PermWrapper(self.request.user),
"request": self.request
})
return template.render(c)
def get_context(self, window_info):
"""provide the same context data as the :mod:`django.contrib.auth.context_processors`:
* `user`: a user or :class:`django.contrib.auth.models.AnonymousUser`
* `perms`, with the same meaning
"""
user = window_info.user or AnonymousUser()
return {"user": user, "perms": PermWrapper(user)}
def general_info(request):
path = request.get_full_path()
return {
'nav_tab': FixedSimpleLazyObject(partial(__nav_tab, request.path)),
'nav_bar': NavigationBar.objects.all(),
'LOGIN_RETURN_PATH': '' if path.startswith('/accounts/') else path,
'perms': PermWrapper(request.user),
}
def last_instance_review_status(self, utc):
template = self.templates['review_status']
c = {
'instance': utc.last_instance,
'perms': PermWrapper(self.request.user),
'request': self.request
}
c.update(generate_review_status_context(utc.last_instance))
return template.render(c)
def get_review_status(self, tli):
template = self.templates['review_status']
c = Context({
"instance": tli,
"perms": PermWrapper(self.request.user),
"request": self.request
})
c.update(generate_review_status_context(tli))
return template.render(c)
def buttons(self):
"""
A button to force DNS re-provisioning
"""
context = {
'perms': PermWrapper(self.context['request'].user),
}
context.update(csrf(self.context['request']))
return self.render('netbox_ddns/ipaddress/dns_refresh_button.html', context)
def form_valid(self, form):
data = dict()
# Перед созданием нового документа проверяем наличия документов по заданным пользовательским параметрам
if Document.objects.filter(category=self.kwargs.get('category'),
tab=form.cleaned_data['tab'],
del_field=False).exists():
data['documents_exist'] = True
else:
data['documents_exist'] = False
# Проверяем для какой вкладки был создан новый документ
if str(form.cleaned_data['tab']) == str(self.kwargs.get('tab')):
data['equal_tab'] = True
else:
data['equal_tab'] = False
# Cоздание нового документа
new_document = form.save(commit=False)
new_document.category = self.kwargs.get('category')
new_document.author_id = self.request.user.id
if form.cleaned_data['src_url']:
new_document.src = urlparse(form.cleaned_data['src_url']).path[1:]
new_document.save()
# HTML нового документа
data['html_document'] = render_to_string(
'documents/document.html',
{
'node': new_document,
'perms': PermWrapper(self.request.user),
'current_category': self.kwargs.get('category'),
'current_tab': new_document.tab,
},
request=self.request,
)
# HTML списка вкладок
data['html_tabs'] = render_to_string(
'documents/tabs.html',
{
'tabs':
list(
set(
Document.objects.filter(
category=self.kwargs.get('category'),
del_field=False).values_list('tab', flat=True))),
'current_category':
self.kwargs.get('category'),
},
request=self.request,
)
# Валидная форма
data['form_is_valid'] = True
return JsonResponse(data)
def get_last_instance_review_status(self, utc):
template = self.templates['review_status']
c = Context({
"instance": utc.last_instance,
"perms": PermWrapper(self.request.user),
"request": self.request
})
c.update(generate_review_status_context(utc.last_instance))
return template.render(c)
def form_valid(self, form):
edited_event = form.save(commit=False)
edited_event.save()
data = dict()
data['event_id'] = edited_event.pk # Инициализируем pk события
# Загрузить изображения в указанную директорию
directory = EVENT_IMAGE_STORAGE + 'events/' + str(
edited_event.event_date.year) + '-' + edited_event.event_shortname
images = self.request.FILES.getlist('image_field')
for image in images:
if not os.path.exists(directory):
os.makedirs(directory)
filename, expansion = image.name.split('.')
if transliterate.detect_language(filename) == 'ru':
if os.path.exists(
directory + '/' +
transliterate.translit(filename, reversed=True) + '.' +
expansion):
with open(
directory + '/' +
transliterate.translit(filename, reversed=True) +
str(uuid.uuid4().hex) + '.' + expansion,
'wb+') as destination:
for chunk in image.chunks():
destination.write(chunk)
else:
with open(
directory + '/' +
transliterate.translit(filename, reversed=True) +
'.' + expansion, 'wb+') as destination:
for chunk in image.chunks():
destination.write(chunk)
else:
if os.path.exists(directory + '/' + image.name):
with open(
directory + '/' + filename +
str(uuid.uuid4().hex) + '.' + expansion,
'wb+') as destination:
for chunk in image.chunks():
destination.write(chunk)
else:
with open(directory + '/' + image.name,
'wb+') as destination:
for chunk in image.chunks():
destination.write(chunk)
# HTML редактируемого события
data['html_event'] = render_to_string(
'events/event.html', {
'event': edited_event,
'perms': PermWrapper(self.request.user),
'current_language': self.kwargs.get('language'),
'current_year': self.kwargs.get('year'),
},
request=self.request)
data['form_is_valid'] = True
return JsonResponse(data)
def actions(self, supplier):
template = get_template('parts/table_context_suppliers_actions.html')
mext = reverse('suppliers_list')
c = {
'supplier': supplier,
'request': self.request,
'next': mext,
'perms': PermWrapper(self.request.user),
}
return template.render(c)
def form_valid(self, form):
form.save()
data = dict()
data['form_is_valid'] = True
context = {
'users': User.objects.order_by('username'),
'perms': PermWrapper(self.request.user),
}
data['html_users'] = render_to_string('users/users.html', context)
return JsonResponse(data)
def test_permwrapper_in(self):
"""
'something' in PermWrapper works as expected.
"""
perms = PermWrapper(MockUser())
# Works for modules and full permissions.
self.assertIn("mockapp", perms)
self.assertNotIn("nonexistent", perms)
self.assertIn("mockapp.someperm", perms)
self.assertNotIn("mockapp.nonexistent", perms)
def actions(self, utc):
template = self.templates['actions']
perms = PermWrapper(self.request.user)
c = {
'utc': utc,
'request': self.request,
'action': self.action,
'perms': perms
}
return template.render(c)
def test_permwrapper_in(self):
"""
Test that 'something' in PermWrapper works as expected.
"""
perms = PermWrapper(MockUser())
# Works for modules and full permissions.
self.assertIn('mockapp', perms)
self.assertNotIn('nonexisting', perms)
self.assertIn('mockapp.someperm', perms)
self.assertNotIn('mockapp.nonexisting', perms)
def post(self, request, *args, **kwargs):
user = User.objects.get(pk=self.kwargs['pk'])
user.delete()
data = dict()
data['form_is_valid'] = True
context = {
'users': User.objects.order_by('username'),
'perms': PermWrapper(self.request.user),
}
data['html_users'] = render_to_string('users/users.html', context)
return JsonResponse(data)
def review_status(self, tli):
template = self.templates['review_status']
c = {
"instance": tli,
"perms": PermWrapper(self.request.user),
"request": self.request,
"show_label": settings.ICON_SETTINGS['SHOW_REVIEW_LABELS_LISTING'],
"show_icons": settings.ICON_SETTINGS['SHOW_STATUS_ICONS_REVIEW']
}
c.update(generate_review_status_context(tli))
return template.render(c)
def form_valid(self, form):
form.save()
section = FiniSection.objects.get(pk=self.kwargs['pk'])
data = dict()
data['section_id'] = section.id
data['html_section_header'] = render_to_string(
'indicators/section_header.html', {
'section': section,
'perms': PermWrapper(self.request.user),
})
data['form_is_valid'] = True
return JsonResponse(data)
def test_template_complexity(self):
tmpl = 'kanisa/management/users/_user_list.html'
users = list(get_user_model().objects.all())
user = get_user_model().objects.get(username='******')
perms = PermWrapper(user)
with self.assertNumQueries(0):
render_to_string(tmpl, {
'user_list': users,
'user': user,
'perms': perms
})
def get(self, request, *args, **kwargs):
question = FAQ.objects.get(pk=self.kwargs['pk'])
data = dict()
context = {
'question': question,
'current_language': self.kwargs.get('language'),
'perms': PermWrapper(self.request.user),
}
data['html_form'] = render_to_string('faq/delete_faq.html',
context,
request=request)
return JsonResponse(data)
def form_valid(self, form):
form.save()
indicator = FiniCode.objects.get(pk=self.kwargs['pk'])
data = dict()
data['indicator_id'] = indicator.id
data['html_indicator'] = render_to_string(
'indicators/indicator.html', {
'indicator': indicator,
'perms': PermWrapper(self.request.user),
})
data['form_is_valid'] = True
return JsonResponse(data)
