def edit_admin(request, admin_id):
msg = ''
admin = User.objects.get(pk=admin_id)
if request.method == 'POST':
form = AdminForm(request.POST)
if form.is_valid():
admin.username = form.cleaned_data['username']
admin.first_name = form.cleaned_data['first_name']
admin.last_name = form.cleaned_data['last_name']
admin.email = form.cleaned_data['email']
admin.set_password(form.cleaned_data["password1"])
admin.save()
logout(request)
return redirect('http://127.0.0.1:8000/login/?edit_admit=pass')
else:
msg = 'no_pass'
else:
form = AdminForm(
initial={
'admin_id': admin.id,
'username': admin.username,
'first_name': admin.first_name,
'last_name': admin.last_name,
'email': admin.email,
})
context = {'form': form, 'msg': msg}
return render(request, 'edit_admin.html', context)
def __init__(self, formset, form, fieldsets, prepopulated_fields, original,
readonly_fields=None, model_admin=None):
self.formset = formset
self.model_admin = model_admin
self.original = original
self.show_url = original and hasattr(original, 'get_absolute_url')
AdminForm.__init__(self, form, fieldsets, prepopulated_fields,
readonly_fields, model_admin)
def __init__(self,
formset,
form,
fieldsets,
prepopulated_fields,
original,
readonly_fields=None,
model_admin=None):
self.formset = formset
self.model_admin = model_admin
self.original = original
self.show_url = original and hasattr(original, 'get_absolute_url')
AdminForm.__init__(self, form, fieldsets, prepopulated_fields,
readonly_fields, model_admin)
def admin_registration(request):
try:
emp = EmployeeInfo.objects.all().get(user = request.user )
except EmployeeInfo.DoesNotExist:
emp = None
if (request.session["count2"] - request.session["count1"] == -1) and emp is not None and emp.is_Admin:
if request.POST :
user = User.objects.all().get(username = request.session["username"] )
employee = EmployeeInfo(user = user ,is_Staff = False)
adminForm = AdminForm(request.POST,instance = employee )
if adminForm.is_valid():
adminForm.save()
request.session["count2"] += 1
t = get_template('added.html')
c = Context({'emp1':emp ,'employee':adminForm.save() })
return HttpResponse(t.render(c))
else :
#t = get_template('registration.html')
c = Context({'emp1':emp ,'form': adminForm})
return render_to_response('registration.html', context_instance=RequestContext(request,c))
else:
adminForm = AdminForm()
c = Context({'emp1':emp ,'form': adminForm})
return render_to_response('registration.html', context_instance=RequestContext(request,c))
else:
return HttpResponse('We are sorry but some error has occurred try to register again from the start ')
def import_items(request):
if request.method == 'POST':
form = ImportItemsForm(request.POST, request.FILES)
if form.is_valid():
items = form.cleaned_data['items']
for item in items:
item.save()
messages.success(
request,
ngettext('%(count)d invoice item imported.',
'%(count)d invoice items imported.', len(items)) %
{'count': len(items)})
else:
form = ImportItemsForm()
from django.contrib.admin.helpers import AdminForm
return TemplateResponse(
request,
'billing/admin/import_items.html',
{
'form':
form,
'adminform':
AdminForm(form=form,
fieldsets=[(None, {
'fields': form.fields
})],
prepopulated_fields={}),
# The admin templates depend on those variables
'add':
True,
'has_file_field':
True,
'errors':
form.errors,
})
def get_context_data(self, **kwargs):
kwargs = dict(self.modeladmin.admin_site.each_context(self.request),
**kwargs)
context = super(UploadCSVView, self).get_context_data(**kwargs)
context.update({
'adminform':
AdminForm(form=context['form'],
fieldsets=[(None, {
'fields': ['csv']
})],
prepopulated_fields={}),
'title':
'Import Invitations from Tito CSV',
'has_file_field':
True,
# garbage to make admin work
'opts':
self.modeladmin.opts,
'change':
False,
'is_popup':
False,
'save_as':
False,
'has_delete_permission':
True,
'has_add_permission':
True,
'has_change_permission':
True,
})
return context
def as_django_admin(form):
fieldsets = getattr(form, 'fieldsets', ())
prepopulated_fields = getattr(form, 'prepopulated_fields', {})
readonly_fields = getattr(form, 'readonly_fields', None)
model_admin = getattr(form, 'model_admin', None)
if not fieldsets:
fieldsets = [(None, {'fields': form.fields.keys()})]
try:
adminform = AdminForm(form, fieldsets, prepopulated_fields,
readonly_fields, model_admin)
except TypeError: # To old django
adminform = AdminForm(form, fieldsets, prepopulated_fields)
return render_to_string('formadmin/form_admin_django.html', {
'adminform': adminform,
})
def edit_field(self, request, object_id, language):
obj = self._get_object_for_single_field(object_id, language)
opts = obj.__class__._meta
saved_successfully = False
cancel_clicked = request.POST.get("_cancel", False)
raw_fields = request.GET.get("edit_fields")
fields = [field for field in raw_fields.split(",") if field in self.frontend_editable_fields]
if not fields:
context = {
'opts': opts,
'message': force_text(_("Field %s not found")) % raw_fields
}
return render(request, 'admin/cms/page/plugin/error_form.html', context)
if not request.user.has_perm("{0}.change_{1}".format(self.model._meta.app_label,
self.model._meta.model_name)):
context = {
'opts': opts,
'message': force_text(_("You do not have permission to edit this item"))
}
return render(request, 'admin/cms/page/plugin/error_form.html', context)
# Dynamically creates the form class with only `field_name` field
# enabled
form_class = self.get_form(request, obj, fields=fields)
if not cancel_clicked and request.method == 'POST':
form = form_class(instance=obj, data=request.POST)
if form.is_valid():
form.save()
saved_successfully = True
else:
form = form_class(instance=obj)
admin_form = AdminForm(form, fieldsets=[(None, {'fields': fields})], prepopulated_fields={},
model_admin=self)
media = self.media + admin_form.media
context = {
'CMS_MEDIA_URL': get_cms_setting('MEDIA_URL'),
'title': opts.verbose_name,
'plugin': None,
'plugin_id': None,
'adminform': admin_form,
'add': False,
'is_popup': True,
'media': media,
'opts': opts,
'change': True,
'save_as': False,
'has_add_permission': False,
'window_close_timeout': 10,
}
if cancel_clicked:
# cancel button was clicked
context.update({
'cancel': True,
})
return render(request, 'admin/cms/page/plugin/confirm_form.html', context)
if not cancel_clicked and request.method == 'POST' and saved_successfully:
return render(request, 'admin/cms/page/plugin/confirm_form.html', context)
return render(request, 'admin/cms/page/plugin/change_form.html', context)
def add_acl(self, request):
opts = self.model._meta
ctx = {
'opts': opts,
'add': False,
'has_view_permission': True,
'has_editable_inline_admin_formsets': True,
'app_label': opts.app_label,
'change': True,
'is_popup': False,
'save_as': False,
'media': self.media,
'has_delete_permission': False,
'has_add_permission': False,
'has_change_permission': True,
}
if request.method == 'POST':
form = GroupAccessControlForm(request.POST)
if form.is_valid():
services = form.cleaned_data.pop('services')
group = form.cleaned_data.pop('group')
overwrite_existing = form.cleaned_data.pop(
'overwrite_existing')
for service in services:
if overwrite_existing:
GroupAccessControl.objects.update_or_create(
service=service,
group=group,
defaults=form.cleaned_data)
else:
GroupAccessControl.objects.update_or_create(
service=service,
group=group,
defaults=form.cleaned_data)
self.message_user(request, 'ACLs created')
else:
form = GroupAccessControlForm(
initial={
'rate': '*',
'policy': AbstractAccessControl.POLICY_ALLOW,
'serializers': 'std'
})
ctx['adminform'] = AdminForm(form, [(None, {
'fields': [
'overwrite_existing', ['group', 'policy'], 'services',
['rate', 'serializers']
]
})], {})
ctx['media'] = self.media + form.media
return TemplateResponse(
request, 'admin/unicef_rest_framework/groupaccesscontrol/add.html',
ctx)
def setUp(self):
super(ChangeFormFieldsetTests, self).setUp()
request = self.create_http_request()
model_admin = admin_site.get_model_admin(User)
self.admin_form = AdminForm(
form=model_admin.get_form(request)(),
fieldsets=list(model_admin.get_fieldsets(request)),
prepopulated_fields=model_admin.get_prepopulated_fields(request),
readonly_fields=model_admin.get_readonly_fields(request),
model_admin=model_admin)
def get_context_data(self, form, **kwargs):
context = super(EmployerCreationWizard,
self).get_context_data(form=form, **kwargs)
context['opts'] = Employer._meta
from django.contrib.admin.helpers import AdminForm
# Wrap this form in an AdminForm so we get the fieldset stuff:
super_form = AdminForm(context['form'],
[('Step %d of %d' % (0 + 1, 2), {
'fields': form.base_fields.keys()
})], {})
context['super_form'] = super_form
return context
def fieldsets(form, fieldsets=None):
if not fieldsets:
fieldsets = getattr(form, "fieldsets", None)
if not fieldsets:
fieldsets = ((None, {"fields": form.fields.keyOrder}), )
for name, field in form.fields.items():
if isinstance(field.widget, (Textarea, TextInput)):
klass = field.widget.attrs.get('class')
if not klass:
field.widget.attrs['class'] = "form-control"
return AdminForm(form, fieldsets, {})
def test_repr(self):
fieldsets = (('My fields', {
'classes': ['collapse'],
'fields': ('url', 'title', 'content', 'sites'),
}), )
form = ArticleForm()
admin_form = AdminForm(form, fieldsets, {})
self.assertEqual(
repr(admin_form),
"<AdminForm: form=ArticleForm fieldsets=(('My fields', "
"{'classes': ['collapse'], "
"'fields': ('url', 'title', 'content', 'sites')}),)>",
)
def adminentry(request):
if request.method == "POST":
form = AdminForm(request.POST)
if form.is_valid():
try:
form.save()
return redirect('/adminlogin')
except:
pass
else:
form = AdminForm()
return render(request, "adminentry.html", {'form': form})
def add_view(self, request, form_url="", extra_context=None):
"""
Custom add view without inlines/formsets
"""
model = self.model
opts = model._meta
# FIXME: return 404 if request is non-ajax
if not self.has_add_permission(request):
raise PermissionDenied
c = request.GET.get("c", 1)
s = request.GET.get("s")
group = Group.objects.get(pk=s)
prefix = "plugin_%s" % c
ModelForm = self.get_form(request)
form = ModelForm(prefix=prefix)
adminForm = AdminForm(form, list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
adminForm.can_delete = False
adminForm.sortable_field_name = "position"
adminForm.verbose_name = self.model._meta.verbose_name
adminForm.original = None
adminForm.prefix = prefix
adminForm.app_label = self.model._meta.app_label
adminForm.model_name = self.model.__name__.lower() # FIXME: ModelBase ???
adminForm.inline_classes = adminForm.model_admin.inline_classes_add
context = {
"adminform": adminForm,
"pluginmedia": self.media,
"errors": AdminErrorList(form, []),
"app_label": opts.app_label,
}
context.update(extra_context or {})
return self.render_change_form(request, context, form_url=form_url, add=True)
def create_serving_papers(self, request, userid):
self._ensure_lob_integration()
sender = self._get_serving_papers_sender(userid)
go_back_href = reverse("admin:hpaction_hpuser_change",
args=(sender.pk, ))
ld = sender.landlord_details
if request.method == "POST":
form = ServingPapersForm(request.POST, request.FILES)
if form.is_valid():
papers = form.save(commit=False)
papers.uploaded_by = request.user
papers.sender = sender
self._send_papers(papers)
messages.success(
request,
"The recipient has been served! See below for more details."
)
slack.sendmsg_async(
f"{slack.escape(request.user.best_first_name)} has served "
f"{slack.hyperlink(text=sender.best_first_name, href=sender.admin_url)}'s "
"landlord!",
is_safe=True,
)
return HttpResponseRedirect(go_back_href)
else:
form = ServingPapersForm(initial={
"name": ld.name,
**ld.get_address_as_dict(),
})
# This makes it easier to manually test the form.
form.use_required_attribute = False
# http://www.dmertl.com/blog/?p=116
fieldsets = [(None, {"fields": form.base_fields})]
adminform = AdminForm(form, fieldsets, {})
ctx = {
**self.site.each_context(request),
"sender": sender,
"form": form,
"adminform": adminform,
"go_back_href": go_back_href,
}
return TemplateResponse(request,
"hpaction/admin/create-serving-papers.html",
ctx)
def render_template(self,
request,
form,
previous_fields,
step,
context=None):
from django.contrib.admin.helpers import AdminForm
# Wrap this form in an AdminForm so we get the fieldset stuff:
form = AdminForm(form,
[('Step %d of %d' % (step + 1, self.num_steps()), {
'fields': form.base_fields.keys()
})], {})
context = context or {}
context.update({'media': self._model_admin.media + form.media})
return super(AlertCreationWizard,
self).render_template(request, form, previous_fields,
step, context)
def add_type_view(self, request, form_url=""):
"""
Display a choice form to select which page type to add.
"""
if not self.has_add_permission(request):
raise PermissionDenied
extra_qs = ""
if request.META["QUERY_STRING"]:
# QUERY_STRING is bytes in Python 3, using force_str() to decode it as string.
# See QueryDict how Django deals with that.
extra_qs = "&{}".format(force_str(request.META["QUERY_STRING"]))
choices = self.get_child_type_choices(request, "add")
if len(choices) == 0:
raise PermissionDenied
if len(choices) == 1:
return HttpResponseRedirect(f"?ct_id={choices[0][0]}{extra_qs}")
# Create form
form = self.add_type_form(
data=request.POST if request.method == "POST" else None,
initial={"ct_id": choices[0][0]},
)
form.fields["ct_id"].choices = choices
if form.is_valid():
return HttpResponseRedirect("?ct_id={}{}".format(
form.cleaned_data["ct_id"], extra_qs))
# Wrap in all admin layout
fieldsets = ((None, {"fields": ("ct_id", )}), )
adminForm = AdminForm(form, fieldsets, {}, model_admin=self)
media = self.media + adminForm.media
opts = self.model._meta
context = {
"title": _("Add %s") % force_str(opts.verbose_name),
"adminform": adminForm,
"is_popup": ("_popup" in request.POST or "_popup" in request.GET),
"media": mark_safe(media),
"errors": AdminErrorList(form, ()),
"app_label": opts.app_label,
}
return self.render_add_type_form(request, context, form_url)
def test_repr(self):
fieldsets = (
(
"My fields",
{
"classes": ["collapse"],
"fields": ("url", "title", "content", "sites"),
},
),
)
form = ArticleForm()
admin_form = AdminForm(form, fieldsets, {})
self.assertEqual(
repr(admin_form),
"<AdminForm: form=ArticleForm fieldsets=(('My fields', "
"{'classes': ['collapse'], "
"'fields': ('url', 'title', 'content', 'sites')}),)>",
)
def add_type_view(self, request, form_url=''):
"""
Display a choice form to select which page type to add.
"""
if not self.has_add_permission(request):
raise PermissionDenied
extra_qs = ''
if request.META['QUERY_STRING']:
# QUERY_STRING is bytes in Python 3, using force_text() to decode it as string.
# See QueryDict how Django deals with that.
extra_qs = '&{0}'.format(force_text(request.META['QUERY_STRING']))
choices = self.get_child_type_choices(request, 'add')
if len(choices) == 1:
return HttpResponseRedirect('?ct_id={0}{1}'.format(choices[0][0], extra_qs))
# Create form
form = self.add_type_form(
data=request.POST if request.method == 'POST' else None,
initial={'ct_id': choices[0][0]}
)
form.fields['ct_id'].choices = choices
if form.is_valid():
return HttpResponseRedirect('?ct_id={0}{1}'.format(form.cleaned_data['ct_id'], extra_qs))
# Wrap in all admin layout
fieldsets = ((None, {'fields': ('ct_id',)}),)
adminForm = AdminForm(form, fieldsets, {}, model_admin=self)
media = self.media + adminForm.media
opts = self.model._meta
context = {
'title': _('Add %s') % force_text(opts.verbose_name),
'adminform': adminForm,
'is_popup': ("_popup" in request.POST or
"_popup" in request.GET),
'media': mark_safe(media),
'errors': AdminErrorList(form, ()),
'app_label': opts.app_label,
}
return self.render_add_type_form(request, context, form_url)
def select_site_view(self, request, form_url=''):
"""
Display a choice form to select which site to add settings.
"""
if not self.has_add_permission(request):
raise PermissionDenied
extra_qs = ''
if request.META['QUERY_STRING']:
extra_qs = '&' + request.META['QUERY_STRING']
site_choices = self.get_site_choices()
if len(site_choices) == 1:
return HttpResponseRedirect('?site_id={0}{1}'.format(
site_choices[0][0], extra_qs))
# Create form
form = self.select_site_form(
data=request.POST if request.method == 'POST' else None,
initial={'site': site_choices[0][0]})
form.fields['site'].choices = site_choices
if form.is_valid():
return HttpResponseRedirect('?site_id={0}{1}'.format(
form.cleaned_data['site'], extra_qs))
# Wrap in all admin layout
fieldsets = ((None, {'fields': ('site', )}), )
adminForm = AdminForm(form, fieldsets, {}, model_admin=self)
media = self.media + adminForm.media
context = {
'title': _('Add %s') % force_text(self.opts.verbose_name),
'adminform': adminForm,
'is_popup': '_popup' in request.GET,
'media': mark_safe(media),
'errors': AdminErrorList(form, ()),
'app_label': self.opts.app_label,
}
return self.render_select_site_form(request, context, form_url)
def changeform_view(self,
request,
object_id=None,
form_url='',
extra_context=None):
if request.method == 'GET' and request.GET.get('glossary'):
# Reached after the user changed the shared settings select field.
# This recreates a form for the given plugin using the selected shared fields
# as values for a faked object.
extra_context = dict(extra_context or {})
sharable_fields = {}
try:
shared_glossary = SharedGlossary.objects.get(
id=request.GET.get('glossary'))
except (ValueError, SharedGlossary.DoesNotExist):
pass
else:
for field_name in self.sharable_fields:
shared_val = shared_glossary.glossary.get(field_name)
if shared_val:
sharable_fields[field_name] = shared_val
if object_id:
obj = self.get_object(request, object_id)
glossary = deepcopy(obj.glossary)
glossary.update(sharable_fields)
# create fake object using values from shared fields to mimic the expected behaviour
fake_obj = CascadeElement(glossary=glossary)
ModelForm = self.get_form(request, fake_obj)
form = ModelForm(instance=fake_obj)
else:
ModelForm = self.get_form(request)
initial = self.get_changeform_initial_data(request)
initial.update(sharable_fields)
form = ModelForm(initial=initial)
extra_context['adminform'] = AdminForm(
form,
list(self.get_fieldsets(request, obj)), {}, [],
model_admin=self)
return super().changeform_view(request, object_id, form_url,
extra_context)
def _get_custom_form(self, request, form, title):
from django.contrib.admin.helpers import AdminForm, AdminErrorList
admin_form = AdminForm(form,
form.get_fieldsets(), {},
model_admin=self)
media = self.media + admin_form.media
inline_formsets = []
context = dict(
self.admin_site.each_context(request),
title=force_text(title),
media=media,
adminform=admin_form,
is_popup=False,
show_save_and_continue=False,
inline_admin_formsets=inline_formsets,
errors=AdminErrorList(form, inline_formsets),
)
return self.render_change_form(request, context, add=True)
def get_context_data(self, *args, **kwargs):
context = super(BulkUploadFormAdminView,
self).get_context_data(*args, **kwargs)
# We're constructing an AdminForm from the view's form so that we can
# use the admin templates that are shipped with Django out of the box.
# I used code from django.contrib.admin.options as an example for the
# following lines.
form = context['form']
fields = form.base_fields.keys()
fieldsets = [(None, {'fields': fields})]
bulkadminform = AdminForm(form, fieldsets, {}, model_admin=self)
opts = self.model_admin.model._meta
context.update({
'title':
u"Add many {0} from a CSV file".format(
force_unicode(opts.verbose_name_plural)),
'adminform':
bulkadminform,
})
return context
def change_own_profile(request):
user = request.user
if request.method == "POST":
form = ObForm(request.POST, request.FILES, instance=user)
if form.is_valid():
form.save()
if '_save' in request.POST:
return redirect('admin:index')
else:
form = ObForm(instance=user)
else:
form = ObForm(instance=user)
adminform = AdminForm(
form,
[(None, {'fields': (
'username', 'last_name', 'first_name', 'patronymic',
('email', 'show_email'),
('phone_number', 'show_phone_number'),
'photo', 'bio', 'show_at_company_page'), })],
{}, # Prepopulated fields
)
return render(request, 'accounts/change_profile.html', {
'user': user,
'has_permission': True,
'opts': RealEstateUser._meta,
'title': 'Изменение профиля',
'change': False,
'is_popup': False,
'save_as': False,
'has_delete_permission': False,
'has_add_permission': False,
'has_change_permission': True,
'has_file_field': True,
'link': user,
'form': form,
'adminform': adminform,
})
def add_type_view(self, request, form_url=''):
"""
Display a choice form to select which page type to add.
"""
extra_qs = ''
if request.META['QUERY_STRING']:
extra_qs = '&' + request.META['QUERY_STRING']
choices = self.get_child_type_choices()
if len(choices) == 1:
return HttpResponseRedirect('?ct_id={0}{1}'.format(
choices[0][0], extra_qs))
# Create form
form = self.add_type_form(
data=request.POST if request.method == 'POST' else None,
initial={'ct_id': choices[0][0]})
form.fields['ct_id'].choices = choices
if form.is_valid():
return HttpResponseRedirect('?ct_id={0}{1}'.format(
form.cleaned_data['ct_id'], extra_qs))
# Wrap in all admin layout
fieldsets = ((None, {'fields': ('ct_id', )}), )
adminForm = AdminForm(form, fieldsets, {}, model_admin=self)
media = self.media + adminForm.media
opts = self.model._meta
context = {
'title': _('Add %s') % force_unicode(opts.verbose_name),
'adminform': adminForm,
'is_popup': "_popup" in request.REQUEST,
'media': mark_safe(media),
'errors': AdminErrorList(form, ()),
'app_label': opts.app_label,
}
return self.render_add_type_form(request, context, form_url)
def render_modal_window(self, request, form):
"""
Render a modal popup window with a select box to edit the form
"""
opts = self.model._meta
fieldsets = [(None, {'fields': list(form.fields)})]
adminForm = AdminForm(form, fieldsets, {}, [])
context = {
**default_admin_site.each_context(request),
'title': form.title,
'adminform': adminForm,
'add': False,
'change': True,
'save_as': False,
'has_add_permission': False,
'has_change_permission': True,
'opts': opts,
'root_path': reverse('admin:index'),
'is_popup': True,
'app_label': opts.app_label,
'media': self.media + form.media,
}
return TemplateResponse(request, self.change_form_template, context)
def adminform(self):
if not self.fieldsets:
self.fieldsets = [(None, {'fields': self.fields.keys()})]
adminform = AdminForm(self, self.fieldsets, self.prepopulated_fields,
self.readonly_fields, self.model_admin)
return adminform
def change_view(self, request, object_id, form_url='', extra_context=None):
"The 'change' admin view for this model."
model = self.model
opts = model._meta
obj = self.get_object(request, unquote(object_id))
if not self.has_change_permission(request, obj):
raise PermissionDenied
if obj is None:
raise Http404(
_('%(name)s object with primary key %(key)r does not exist.') %
{
'name': force_unicode(opts.verbose_name),
'key': escape(object_id)
})
if request.method == 'POST' and "_saveasnew" in request.POST:
return self.add_view(
request,
form_url=reverse('admin:%s_%s_add' %
(opts.app_label, opts.module_name),
current_app=self.admin_site.name))
ModelForm = self.get_form(request, obj)
formsets = []
inline_instances = self.get_inline_instances(request, obj)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=True)
else:
form_validated = False
new_object = obj
prefixes = {}
for FormSet, inline in self._get_formsets(request, new_object):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(request.POST,
request.FILES,
instance=new_object,
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
if self.all_valid_with_nesting(formsets) and form_validated:
self.save_model(request, new_object, form, True)
self.save_related(request, form, formsets, True)
change_message = self.construct_change_message(
request, form, formsets)
self.log_change(request, new_object, change_message)
return self.response_change(request, new_object)
else:
form = ModelForm(instance=obj)
prefixes = {}
for FormSet, inline in self._get_formsets(request, obj):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=obj,
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
adminForm = AdminForm(form,
self.get_fieldsets(request, obj),
self.get_prepopulated_fields(request, obj),
self.get_readonly_fields(request, obj),
model_admin=self)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request, obj))
readonly = list(inline.get_readonly_fields(request, obj))
prepopulated = dict(inline.get_prepopulated_fields(request, obj))
inline_admin_formset = InlineAdminFormSet(inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
if inline.inlines:
media = media + self.wrap_nested_inline_formsets(
request, inline, formset)
context = {
'title': _('Change %s') % force_unicode(opts.verbose_name),
'adminform': adminForm,
'object_id': object_id,
'original': obj,
'is_popup': "_popup" in request.POST,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': AdminErrorList(form, formsets),
'app_label': opts.app_label,
'django_version_lt_1_6': DJANGO_VERSION < (1, 6)
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
change=True,
obj=obj,
form_url=form_url)
def add_view(self, request, form_url='', extra_context=None):
"The 'add' admin view for this model."
model = self.model
opts = model._meta
if not self.has_add_permission(request):
raise PermissionDenied
ModelForm = self.get_form(request)
formsets = []
inline_instances = self.get_inline_instances(request, None)
if request.method == 'POST':
form = ModelForm(request.POST, request.FILES)
if form.is_valid():
new_object = self.save_form(request, form, change=False)
form_validated = True
else:
form_validated = False
new_object = self.model()
prefixes = {}
for FormSet, inline in self._get_formsets(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(data=request.POST,
files=request.FILES,
instance=new_object,
save_as_new="_saveasnew" in request.POST,
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
if self.all_valid_with_nesting(formsets) and form_validated:
self.save_model(request, new_object, form, False)
self.save_related(request, form, formsets, False)
if DJANGO_VERSION < (1, 9):
change_message = self.construct_change_message(
request, form, formsets)
self.log_addition(request, new_object)
else:
change_message = self.construct_change_message(
request, form, formsets, True)
self.log_addition(request, new_object, change_message)
return self.response_add(request, new_object)
else:
# Prepare the dict of initial data from the request.
# We have to special-case M2Ms as a list of comma-separated PKs.
initial = dict(request.GET.items())
for k in initial:
try:
f = opts.get_field(k)
except models.FieldDoesNotExist:
continue
if isinstance(f, models.ManyToManyField):
initial[k] = initial[k].split(",")
form = ModelForm(initial=initial)
prefixes = {}
for FormSet, inline in self._get_formsets(request):
prefix = FormSet.get_default_prefix()
prefixes[prefix] = prefixes.get(prefix, 0) + 1
if prefixes[prefix] != 1 or not prefix:
prefix = "%s-%s" % (prefix, prefixes[prefix])
formset = FormSet(instance=self.model(),
prefix=prefix,
queryset=inline.get_queryset(request))
formsets.append(formset)
if inline.inlines:
self.add_nested_inline_formsets(request, inline, formset)
adminForm = AdminForm(form,
list(self.get_fieldsets(request)),
self.get_prepopulated_fields(request),
self.get_readonly_fields(request),
model_admin=self)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request))
readonly = list(inline.get_readonly_fields(request))
prepopulated = dict(inline.get_prepopulated_fields(request))
inline_admin_formset = InlineAdminFormSet(inline,
formset,
fieldsets,
prepopulated,
readonly,
model_admin=self)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
if inline.inlines:
media = media + self.wrap_nested_inline_formsets(
request, inline, formset)
context = {
'title': _('Add %s') % force_unicode(opts.verbose_name),
'adminform': adminForm,
'is_popup': "_popup" in request.POST,
'show_delete': False,
'media': media,
'inline_admin_formsets': inline_admin_formsets,
'errors': AdminErrorList(form, formsets),
'app_label': opts.app_label,
'django_version_lt_1_6': DJANGO_VERSION < (1, 6)
}
context.update(extra_context or {})
return self.render_change_form(request,
context,
form_url=form_url,
add=True)
def get_plugin_admin_form(self, request, prefix, model, modeladmin, form, group=None, obj=None):
"""
Returns a single admin form for a given container plugin
"""
#readonly_fields = modeladmin.get_readonly_fields(request)
readonly_fields = modeladmin.get_readonly_fields(request, obj)
af = AdminForm(form,
list(modeladmin.get_fieldsets(request, obj)),
modeladmin.get_prepopulated_fields(request, obj),
readonly_fields,
model_admin=modeladmin)
af.prefix = prefix
af.original = obj
af.group = group
af.can_delete = True
af.sortable_field_name = "position"
af.app_label = model._meta.app_label
af.model_name = model.__name__.lower()
af.verbose_name = model._meta.verbose_name
af.inline_classes = modeladmin.inline_classes_change
af.delete = request.POST.get("%s-DELETE" % prefix, 0)
af.adminmedia = modeladmin.media # important for ajax calls
return af
def get_admin_form(self, form):
return AdminForm(form, self.get_fieldsets(form), {})
def export_view(self, request, form_url=''):
"""The 'export' admin view for this model."""
info = self.opts.app_label, self.opts.model_name
if not self.has_export_permission(request):
raise PermissionDenied
form = SubmissionExportForm(
data=request.POST if request.method == 'POST' else None)
if form.is_valid():
data = form.cleaned_data
queryset = self.get_queryset(request) \
.filter(plugin_id=data.get('form')) \
.select_related('created_by', 'plugin', )
from_date, to_date = data.get('from_date'), data.get('to_date')
headers = data.get('headers', [])
if from_date:
queryset = queryset.filter(creation_date__gte=from_date)
if to_date:
queryset = queryset.filter(creation_date__lt=to_date +
datetime.timedelta(days=1))
if not queryset.exists():
message = _(
'No matching %s found for the given criteria. '
'Please try again.') % self.opts.verbose_name_plural
self.message_user(request, message, level=messages.WARNING)
if request.is_ajax():
data = {
'reloadBrowser': True,
'submissionCount': 0,
}
return JsonResponse(data)
return redirect('admin:%s_%s_export' % info)
latest_submission = queryset[:1].get()
dataset = Dataset(
title=Truncator(latest_submission.plugin.name).chars(31))
if not headers:
headers = [
field['label'].strip()
for field in latest_submission.form_data
]
for submission in queryset:
for field in submission.form_data:
label = field['label'].strip()
if label not in headers:
headers.append(label)
if request.is_ajax():
data = {
'reloadBrowser': False,
'submissionCount': queryset.count(),
'availableHeaders': headers,
}
return JsonResponse(data)
headers.extend(
['Submitted By', 'Submitted on', 'Sender IP', 'Referrer URL'])
dataset.headers = headers
def humanize(field):
value = field['value']
field_type = field['type']
if value in (None, '', [], (), {}):
return None
if field_type == 'checkbox':
value = yesno(bool(value),
u'{0},{1}'.format(_('Yes'), _('No')))
if field_type == 'checkbox_multiple':
value = ', '.join(list(value))
return value
for submission in queryset:
row = [None] * len(headers)
for field in submission.form_data:
label = field['label'].strip()
if label in headers:
row[headers.index(label)] = humanize(field)
row[-4] = force_text(submission.created_by or _('Unknown'))
row[-3] = submission.creation_date.strftime(
settings.DJANGOCMS_FORMS_DATETIME_FORMAT)
row[-2] = submission.ip
row[-1] = submission.referrer
dataset.append(row)
mimetype = {
'xlsx':
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'csv': 'text/csv',
'html': 'text/html',
'yaml': 'text/yaml',
'json': 'application/json',
}
file_type = data.get('file_type', 'xlsx')
filename = settings.DJANGOCMS_FORMS_EXPORT_FILENAME.format(
form_name=slugify(latest_submission.plugin.name))
filename = timezone.now().strftime(filename)
filename = '%s.%s' % (filename, file_type)
response = HttpResponse(
getattr(dataset, file_type), {
'content_type':
mimetype.get(file_type, 'application/octet-stream')
})
response[
'Content-Disposition'] = 'attachment; filename=%s' % filename
return response
# Wrap in all admin layout
fieldsets = ((None, {'fields': form.fields.keys()}), )
adminform = AdminForm(form, fieldsets, {}, model_admin=self)
media = self.media + adminform.media
context = {
'title':
_('Export %s') % force_text(self.opts.verbose_name_plural),
'adminform':
adminform,
'is_popup': (IS_POPUP_VAR in request.POST
or IS_POPUP_VAR in request.GET),
'media':
mark_safe(media),
'errors':
AdminErrorList(form, ()),
'app_label':
self.opts.app_label,
}
return self.render_export_form(request, context, form_url)
