def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if django.VERSION >= (1, 6): # From v1.6 on, using get_fieldsets is ok, as long as no 'fields' # argument was given. It allows dynamic fieldsets on admin form. if "fields" in kwargs: fields = kwargs.pop("fields") else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: # On previous versions, calling get_fieldsets triggers infinite recursion # and we should stick to statically declared fieldsets if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None exclude = tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + self.get_readonly_fields(request, obj) defaults = { "form": self.get_form(request, obj, fields=fields), "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude or None, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) language = self._language(request) return translatable_inlineformset_factory(language, self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if django.VERSION >= (1, 6): # From v1.6 on, using get_fieldsets is ok, as long as no 'fields' # argument was given. It allows dynamic fieldsets on admin form. if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: # On previous versions, calling get_fieldsets triggers infinite recursion # and we should stick to statically declared fieldsets if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None exclude = ( tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + self.get_readonly_fields(request, obj) ) old_formfield_callback = curry(self.formfield_for_dbfield, request=request) defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": old_formfield_callback, } defaults.update(kwargs) language = self._language(request) return translatable_modelform_factory(language, self.model, **defaults)
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ((None, {"fields": ("url", "title", ("content", "sites"))}),) self.assertEqual(flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]) fieldsets = ((None, {"fields": ("url", "title", ["content", "sites"])}),) self.assertEqual(flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"])
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ((None, { "fields": ("url", "title", ("content", "sites")) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]) fieldsets = ((None, { "fields": ("url", "title", ["content", "sites"]) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"])
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ((None, { 'fields': ('url', 'title', ('content', 'sites')) }), ) self.assertEqual( flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites']) fieldsets = ((None, { 'fields': ('url', 'title', ['content', 'sites']) }), ) self.assertEqual( flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
def test_flatten_fieldsets(self): """ Regression test for #18051 """ fieldsets = ((None, { 'fields': ('url', 'title', ('content', 'sites')) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites']) fieldsets = ((None, { 'fields': ('url', 'title', ['content', 'sites']) }), ) self.assertEqual(flatten_fieldsets(fieldsets), ['url', 'title', 'content', 'sites'])
def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if django.VERSION >= (1, 6): # From v1.6 on, using get_fieldsets is ok, as long as no 'fields' # argument was given. It allows dynamic fieldsets on admin form. if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: # On previous versions, calling get_fieldsets triggers infinite recursion # and we should stick to statically declared fieldsets if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None defaults = { "form": self.get_form(request, obj, fields=fields), #"formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) language = self._language(request) return translatable_inlineformset_factory(language, self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): self.form = modelform_factory( self.model, form=UserChangeForm, fields=models.Attribute.objects.values_list('name', flat=True)) self.add_form = modelform_factory( self.model, form=UserCreationForm, fields=models.Attribute.objects.filter(required=True).values_list( 'name', flat=True)) if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if obj: qs = models.Attribute.objects.all() else: qs = models.Attribute.objects.filter(required=True) non_model_fields = set([a.name for a in qs]) - set( ['first_name', 'last_name']) fields = list(set(fields) - set(non_model_fields)) kwargs['fields'] = fields return super(AuthenticUserAdmin, self).get_form(request, obj=obj, **kwargs)
def get_readonly_fields(self, request, obj=None): if self._changeable_fields(request, obj): return super(ReadonlyModeMixin, self).get_readonly_fields(request, obj) readonly_fields = flatten_fieldsets(self.get_fieldsets(request, obj)) return readonly_fields
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) new_form = translation_modelform_factory(self.model, **defaults) current_language = get_language_from_request(request) translation_obj = self.get_translation(request, obj) new_form.base_fields[self.language_field].widget = LanguageWidget( translation_of_obj=obj, translation_obj=translation_obj ) new_form.base_fields[self.language_field].initial = current_language return new_form
def get_readonly_fields(self, request, obj=None): if request.user.is_superuser: return self.readonly_fields if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many])) # class CustomFriendsTalkAdmin(admin.AdminSite): # # def get_urls(self): # urls = super(CustomFriendsTalkAdmin, self).get_urls() # custom_urls = [ # path('admin/', self.admin_view(self.send_talk_view), name="preview"), # ] # return urls + custom_urls # # def send_talk_view(self, request): # context = dict( # self.admin_site.each_contet(request), # # ) # return TemplateResponse(request, "kakao/friendstalk_create.html", context) # class TemplateAdmin(admin.ModelAdmin): # change_form_template = 'admin/preview_template.html' # # # CustomFriendsTalkAdmin.register(FriendsTalk, TemplateAdmin)
def get_formset(self, request, obj=None, **kwargs): if 'fields' not in kwargs and self.orderable_field: kwargs['fields'] = flatten_fieldsets( self.get_fieldsets(request, obj)) + [self.orderable_field] return super(SelectiveInlineMixin, self).get_formset(request, obj=obj, **kwargs)
def get_formset(self, request, obj=None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, self.formset, **defaults)
def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None defaults = { "form": self.form, "formset": self.formset, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) return inlineformset_factory(self.model, **defaults)
def test_add_fieldset(self): """Asserts returns fieldset with added fields.""" fs = Fieldsets(self.fieldsets) fs.add_fieldset(section="Hospitalisation", fields=("field1", "field2", "field3")) flatten = flatten_fieldsets(fs.fieldsets) self.assertEqual(flatten[-3:], ["field1", "field2", "field3"])
def get_readonly_fields(self, request, obj=None): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list( set([field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many]))
def get_formfields(self, request, unique=False, **kwargs): field_names = flatten_fieldsets(self.get_fieldsets(request)) readonly_fields = self.get_readonly_fields(request) opts = self.opts db_fields = [] for field_name in field_names: if field_name in readonly_fields: continue try: field = opts.get_field(field_name) except FieldDoesNotExist: continue if not field.editable or (field.unique and not unique): continue db_fields.append(field) form_fields = [] for dbfield in db_fields: formfield = self.formfield_for_dbfield(dbfield, request=request, **kwargs) if formfield is None: continue form_fields.append((dbfield, formfield)) return form_fields
def get_formset(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') elif self.get_fieldsets(request, obj): fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: fields = None # want to combine exclude arguments - can't do that if they're None # also, exclude starts as a tuple - need to make it a list exclude = list(kwargs.get("exclude", [])) exclude_2 = self.exclude or [] # but need exclude to be None if result is an empty list exclude = exclude.extend(list(exclude_2)) or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } kwargs.update(defaults) factory = reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **kwargs) if self.parent_model._meta.model_name == 'candidatevideopage' and self.model._meta.model_name == 'videopage': factory.form.base_fields['teach_item'].initial = obj.related_video_page.teach_item factory.form.base_fields['video_title'].initial = obj.video_title factory.form.base_fields['user'].initial = request.user return factory
def show_view(self, request, object_id, form_url='', extra_context=None): model = self.model opts = model._meta obj = self.get_object(request, unquote(object_id)) if not self.has_show_permission(request, obj): raise PermissionDenied if obj is None: raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % { 'name': force_text(opts.verbose_name), 'key': escape(object_id)}) ModelForm = self.get_form(request, obj) form = ModelForm(instance=obj) all_fields = flatten_fieldsets(self.get_fieldsets(request, obj)) adminForm = helpers.AdminForm( form, list(self.get_fieldsets(request, obj)), self.get_prepopulated_fields(request, obj), readonly_fields=all_fields, # All fields readonly model_admin=self) media = self.media + adminForm.media opts = self.model._meta formsets, inline_instances = self._create_formsets(request, obj, change=True) inline_formsets = self.get_show_inline_formsets(request, formsets, inline_instances, obj) for inline_formset in inline_formsets: media = media + inline_formset.media # Show Actions show_actions = self.get_show_actions(request, obj) view_on_site_url = self.get_view_on_site_url(obj) context = dict( self.admin_site.each_context(request), show_actions=show_actions, title=_(u'View {verbose_name}').format( verbose_name=force_unicode(opts.verbose_name)), adminform=adminForm, view_name='show', object_id=object_id, original=obj, is_popup=(IS_POPUP_VAR in request.POST or IS_POPUP_VAR in request.GET), media=media, inline_admin_formsets=inline_formsets, errors=helpers.AdminErrorList(form, []), app_label=opts.app_label, is_show_view=True, has_add_permission=self.has_add_permission(request), has_change_permission=self.has_change_permission(request, obj), has_delete_permission=self.has_delete_permission(request, obj), has_absolute_url=view_on_site_url is not None, absolute_url=view_on_site_url, opts=opts, ) context.update(extra_context or {}) self.log_show(request, obj) return TemplateResponse(request, self.get_show_object_template(), context)
def get_formset(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') elif self.get_fieldsets(request, obj): fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: fields = None # want to combine exclude arguments - can't do that if they're None # also, exclude starts as a tuple - need to make it a list exclude = list(kwargs.get("exclude", [])) exclude_2 = self.exclude or [] non_editable_fields = [f for f in self.model._meta.fields if not f.editable] exclude.extend(list(exclude_2)) exclude.extend(non_editable_fields) # but need exclude to be None if result is an empty list exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } kwargs.update(defaults) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **kwargs)
def get_formset(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') elif self.get_fieldsets(request, obj): fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: fields = None # want to combine exclude arguments - can't do that if they're None # also, exclude starts as a tuple - need to make it a list exclude = list(kwargs.get("exclude", [])) exclude_2 = self.exclude or [] non_editable_fields = [ f for f in self.model._meta.fields if not f.editable ] exclude.extend(list(exclude_2)) exclude.extend(non_editable_fields) # but need exclude to be None if result is an empty list exclude = exclude or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), } kwargs.update(defaults) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **kwargs)
def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) exclude = (tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + self.get_readonly_fields(request, obj)) defaults = { "form": self.get_form(request, obj, fields=fields), "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude or None, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) language = self._language(request) return translatable_inlineformset_factory(language, self.parent_model, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs): """Workaround bug http://code.djangoproject.com/ticket/9360.""" return super(PartnerSiteAdmin, self).get_form(request, obj, fields=flatten_fieldsets( self.get_fieldsets(request, obj)))
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) exclude = (tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + tuple(self.get_readonly_fields(request, obj) or ())) old_formfield_callback = curry(self.formfield_for_dbfield, request=request) defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": old_formfield_callback, } defaults.update(kwargs) language = self._language(request) if django.VERSION > (2, 1) and 'change' in defaults: del defaults['change'] return translatable_modelform_factory(language, self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if self.exclude is None: exclude = [] else: exclude = list(self.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = (exclude + kwargs.get('exclude', [])) or None defaults = { 'form': self.form, 'fields': fields, 'exclude': exclude, 'formfield_callback': functools.partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **defaults)
def get_form(self, request, obj=None, **kwargs): for i in dir(self): print i print "@@@@@@@@@@@" print "!!!", ' |self.form: ', type(self.form) for i in dir(self.form): print i print "!!!", ' |self.form.Meta: ', type(self.form.Meta) for i in dir(self.form.Meta): print i print "!!!", ' |self.form.Meta.fields: ', self.form.Meta.fields # print "!!!",' |self.formfield_for_choice_field: ',\ # self.formfield_for_choice_field() # print "!!!",' |self.formfield_for_dbfield: ',\ # type(self.formfield_for_dbfield) # print "!!!",' |self.formfield_for_foreignkey: ',\ # type(self.formfield_for_foreignkey) # print "!!!",' |self.formfield_for_manytomany: ',\ # type(self.formfield_for_manytomany) # print "!!!",' |self.formfield_overrides: ',\ # type(self.formfield_overrides) # print '!!!', ' self.form ', dir(self.form) # print '!!!!!!!!', ' self.form ', self.form.declared_fields # print '!!!!!!!!', ' self.clean ', type(self.form) kwargs['fields'] = flatten_fieldsets(self.fieldsets) return super(TestTabAdmin, self).get_form(request, obj, **kwargs)
def fields(self): fk = getattr(self.formset, "fk", None) for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)): if fk and fk.name == field_name: continue if field_name in self.readonly_fields: yield { 'label': label_for_field(field_name, self.opts.model, self.opts), 'widget': { 'is_hidden': False }, 'required': False, 'help_text': help_text_for_field(field_name, self.opts.model), } else: form_field = self.formset.form.base_fields[field_name] label = form_field.label if label is None: label = label_for_field(field_name, self.opts.model, self.opts) yield { 'label': label, 'widget': form_field.widget, 'required': form_field.required, 'help_text': form_field.help_text, }
def get_readonly_fields(self, request, obj=None): if hasattr(request, '--avoid-get_readonly_fields-recursion--'): return super(AccessControlMixin, self).get_readonly_fields(request, obj) if not obj: return super(AccessControlMixin, self).get_readonly_fields(request, obj) if not self.has_basic_change_permission(request): setattr(request, '--avoid-get_readonly_fields-recursion--', True) own_fields = flatten_fieldsets(self.get_fieldsets(request, obj)) delattr(request, '--avoid-get_readonly_fields-recursion--') return list_union(super(AccessControlMixin, self).get_readonly_fields(request, obj), own_fields) if not self.has_basic_change_permission(request, obj): setattr(request, '--avoid-get_readonly_fields-recursion--', True) own_fields = flatten_fieldsets(self.get_fieldsets(request, obj)) delattr(request, '--avoid-get_readonly_fields-recursion--') return list_union(super(AccessControlMixin, self).get_readonly_fields(request, obj), own_fields) return super(AccessControlMixin, self).get_readonly_fields(request, obj)
def table_header_row(inline_admin_formset): '''Similar to InlineAdminFormSet.fields but also returns field name Update the dict returned by InlineAdminFormSet.fields and update it with additional attributes that we need for adding sorting urls. ''' formset = inline_admin_formset.formset query_dict = formset.cl.params.copy() ordering = query_dict.getlist(formset.order_param, []) toggle_remove_urls = get_toggle_remove_urls(formset, ordering) try: fk_name = formset.fk.name except AttributeError: fk_name = None field_names = [ i for i in flatten_fieldsets(inline_admin_formset.fieldsets) if i != fk_name ] fields = [] for field_name, field in zip(field_names, inline_admin_formset.fields()): try: urls = toggle_remove_urls[field_name] except KeyError: toggle = get_updated_url(formset, None, field_name) urls = SortingUrl('', toggle, '') fields.append(SortableField(field_name, field, urls)) return { 'fields': fields, 'formset': formset, }
def get_formset(self, request, obj=None, **kwargs): """Returns a BaseInlineFormSet class for use in admin add/change views.""" if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) exclude = ( tuple(self.exclude or ()) + tuple(kwargs.pop("exclude", ())) + self.get_readonly_fields(request, obj) ) defaults = { "form": self.get_form(request, obj, fields=fields), "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude or None, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, "can_delete": self.can_delete, } defaults.update(kwargs) language = self._language(request) return translatable_inlineformset_factory(language, self.parent_model, self.model, **defaults)
def fields(self): fk = getattr(self.formset, "fk", None) empty_form = self.formset.empty_form meta_labels = empty_form._meta.labels or {} meta_help_texts = empty_form._meta.help_texts or {} for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)): if fk and fk.name == field_name: continue if not self.has_change_permission or field_name in self.readonly_fields: yield { 'label': meta_labels.get(field_name) or label_for_field(field_name, self.opts.model, self.opts), 'widget': { 'is_hidden': False }, 'required': False, 'help_text': meta_help_texts.get(field_name) or help_text_for_field(field_name, self.opts.model), } else: form_field = empty_form.fields[field_name] label = form_field.label if label is None: label = label_for_field(field_name, self.opts.model, self.opts) yield { 'label': label, 'widget': form_field.widget, 'required': form_field.required, 'help_text': form_field.help_text, }
def get_readonly_fields(self, request, obj=None, fields=None): is_add = obj is None readonly_fields = list(super().get_readonly_fields(request, obj)) if (is_add and not self.has_add_permission(request)) or \ (not is_add and not self.has_change_permission(request, obj)): return fields if fields is not None else self.get_list_display(request, False) readonly_fields_set = set(readonly_fields) if not is_add: for field in self.change_view_readonly_fields: if field not in readonly_fields_set: readonly_fields_set.add(field) readonly_fields.append(field) changeable_fields = self.get_changeable_fields(request, obj) if changeable_fields is not None: changeable_fields_set = set(changeable_fields) declared_fields = self.fieldsets if declared_fields: declared_fields = flatten_fieldsets(declared_fields) else: declared_fields = [f.name for f in self.opts._get_fields(reverse=False)] for field in declared_fields: if field not in changeable_fields_set and field not in readonly_fields_set: readonly_fields_set.add(field) readonly_fields.append(field) return readonly_fields
def get_readonly_fields(self, request, obj=None): args = get_func_args(self.has_add_permission) if 'obj' in args: has_add_permission = self.has_add_permission(request, obj) else: has_add_permission = self.has_add_permission(request) if obj is None and has_add_permission: return super().get_readonly_fields(request, obj) if self.fields or self.fieldsets: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: opts = self.model._meta sortable_private_fields = [f for f in opts.private_fields if isinstance(f, Field)] fields = [ field.name for field in sorted(chain(opts.concrete_fields, sortable_private_fields, opts.many_to_many)) if field.editable and not field.auto_created ] exclude = self.get_exclude(request, obj) editable_fields = self.get_editable_fields(request, obj) return [ field for field in fields if field not in editable_fields and field not in exclude ]
def get_formset(self, request, obj = None, **kwargs): if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = (exclude + kwargs.get("exclude", [])) or None defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": curry(self.formfield_for_dbfield, request=request), "instance": obj } defaults.update(kwargs) return reverse_inlineformset_factory(self.parent_model, self.model, self.parent_fk_name, **defaults)
def get_readonly_fields(self, request, obj=None, fields=None): if obj and self.has_edit_perm(request, obj): readonly_fields = list( super(ProxyModelAdmin, self).get_readonly_fields(request, obj)) readonly_fields_set = set(readonly_fields) for field in self.change_view_readonly_fields: if field not in readonly_fields_set: readonly_fields_set.add(field) readonly_fields.append(field) editable_fields = self.get_editable_fields(request, obj) if editable_fields is not None: editable_fields_set = set(editable_fields) declared_fields = self.fieldsets if declared_fields: declared_fields = flatten_fieldsets(declared_fields) else: declared_fields = [f.name for f in self.opts.fields] for field in declared_fields: if (field not in editable_fields_set and field not in readonly_fields_set): readonly_fields_set.add(field) readonly_fields.append(field) return readonly_fields elif not self.has_edit_perm(request, obj): return fields if fields is not None else self.get_list_display( request) else: return list( super(ProxyModelAdmin, self).get_readonly_fields(request, obj))
def fields(self): fk = getattr(self.formset, "fk", None) empty_form = self.formset.empty_form meta_labels = empty_form._meta.labels or {} meta_help_texts = empty_form._meta.help_texts or {} for i, field_name in enumerate(flatten_fieldsets(self.fieldsets)): if fk and fk.name == field_name: continue if not self.has_change_permission or field_name in self.readonly_fields: yield { 'label': meta_labels.get(field_name) or label_for_field(field_name, self.opts.model, self.opts), 'widget': {'is_hidden': False}, 'required': False, 'help_text': meta_help_texts.get(field_name) or help_text_for_field(field_name, self.opts.model), } else: form_field = empty_form.fields[field_name] label = form_field.label if label is None: label = label_for_field(field_name, self.opts.model, self.opts) yield { 'label': label, 'widget': form_field.widget, 'required': form_field.required, 'help_text': form_field.help_text, }
def get_form(self, request, obj=None, **kwargs): """Return the form class to use. This method mostly delegates to the superclass, but hints that we should use :py:attr:`add_form` (and its fields) when we are creating the Application. Args: request (django.http.HttpRequest): The current HTTP request. obj (reviewboard.oauth.models.Application, optional): The application being edited, if it exists. Returns: type: The form class to use. """ if obj is None: kwargs = kwargs.copy() kwargs['form'] = self.add_form kwargs['fields'] = flatten_fieldsets(self.add_fieldsets) return super(ApplicationAdmin, self).get_form(request, obj=obj, **kwargs)
def invite_user(self, request): """Sends an invitation email with a login token.""" # Check for add and change permission. has_add_permission = self.has_add_permission(request) has_change_permission = self.has_change_permission(request) try: has_view_permission = self.has_view_permission(request) except AttributeError: has_view_permission = True if not has_add_permission or not has_change_permission: raise PermissionDenied # Process the form. InviteForm = self.get_form( request, form=self.invite_form, fields=flatten_fieldsets(self.invite_fieldsets), ) if request.method == "POST": form = InviteForm(request.POST) if form.is_valid(): # Save the user, marked as inactive. user = form.save(commit=False) user.is_active = False user.is_staff = True user.save() form.save_m2m() # Send an invitation email. self.do_send_invitation_email(request, user) # Message the user. self.message_user(request, "An invitation email has been sent to {email}.".format( email=user.email, )) # Redirect as appropriate. # Using the superclass to avoid the built in munging of the add response. return super(UserAdminBase, self).response_add(request, user) else: form = InviteForm() # Create the admin form. admin_form = admin.helpers.AdminForm(form, self.invite_fieldsets, {}) # Render the template. media = self.media + admin_form.media return render(request, self.invite_form_template, dict( self.admin_site.each_context(request), title="Invite user", opts=self.model._meta, form=form, adminform=admin_form, media=media, add=True, change=False, is_popup=False, save_as=self.save_as, has_add_permission=has_add_permission, has_change_permission=has_change_permission, has_delete_permission=self.has_delete_permission(request), show_delete=False, has_view_permission=has_view_permission, has_editable_inline_admin_formsets=True, ))
def _get_form_factory_opts(self, request, obj=None, **kwargs): fieldsets = self.get_fieldsets(request, obj) if fieldsets: fields = flatten_fieldsets(fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # construct the form_opts from declared_fieldsets form_opts = self.app_form_opts.copy() if fields is not None: # put app_name prefixed fields into form_opts for f in fields: if '.' not in f: continue label, name = f.split('.') app_fields = form_opts.setdefault(label, {}).setdefault('fields', []) if name not in app_fields: app_fields.append(name) # .. and remove them from fields for the model form fields = [f for f in fields if '.' not in f] # do the same for exclude for f in exclude: if '.' not in f: continue label, name = f.split('.') app_fields = form_opts.setdefault(label, {}).setdefault('exclude', []) if name not in app_fields: app_fields.append(name) exclude = [f for f in exclude if '.' not in f] # if exclude is an empty list we pass None to be consistant with the # default on modelform_factory exclude = exclude or None defaults = { "form": self.form, "multiform": self.multiform, "form_opts": form_opts, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) if hasattr(forms, 'ALL_FIELDS'): # Django 1.7 if defaults['fields'] is None and not modelform_defines_fields(defaults['form']): defaults['fields'] = forms.ALL_FIELDS return defaults
def polymorphic_child_admin_class_factory( base_model, bases=None, admin_fields=None, admin_fieldsets=None): if not (isinstance(bases, tuple) or bases is None): raise TypeError('`bases` must be tuple.') if admin_fields and admin_fieldsets: raise ValueError('`admin_fields` and `admin_fieldsets` cannot be set at the same time.') admin_parent_class = bases[0] # FIXME: May need refactoring in future! fields = { '__module__': base_model.__module__, } if admin_parent_class.fields: parent_admin_fields = flatten(admin_parent_class.fields) else: parent_admin_fields = flatten_fieldsets(admin_parent_class.fieldsets) parent_admin_fields += ['id', 'pk', 'order', 'ordering', ] inheritor_admin_fields = [item.name for item in base_model._meta.fields] new_admin_fields = set(filter( lambda item: not (item.endswith('_ptr') or item.endswith('_ctype')), set(inheritor_admin_fields) - set(parent_admin_fields) )) if admin_parent_class.fields: if admin_fieldsets: raise ValueError( '{} does not allow `admin_fieldsets`, please use `admin_fields`.'.format(bases[0].__name__) ) if admin_fields: fields['get_fields'] = _get_fields(admin_fields) else: fields['get_fields'] = _get_fields(new_admin_fields) elif admin_parent_class.fieldsets: if admin_fields: raise ValueError( '{} does not allow `admin_fields`, please use `admin_fieldsets`.'.format(bases[0].__name__) ) if not admin_fieldsets: admin_fieldsets = ( (base_model.__name__, { 'fields': tuple(new_admin_fields), }), ) fields['get_fieldsets'] = _get_fieldsets(admin_fieldsets) else: raise NotImplementedError class_name = '{}ChildAdmin'.format(base_model.__name__) return type(class_name, bases, fields)
def get_readonly_fields(self, request, obj=None): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] ))
def _all_fields(self, request, obj=None): if self.fields: return self.fields if self.fieldsets: return flatten_fieldsets(self.get_fieldsets(request, obj)) fields = [field.name for field in self.opts.local_fields] if 'id' in fields: fields.remove('id') return fields
def get_form(self, request, obj=None, **kwargs): """ Use special form during user creation and prevent from modifying is_active and is_staff for superuser """ if obj is None: kwargs['form'] = self.add_form kwargs['fields'] = flatten_fieldsets(self.add_fieldsets) kwargs['exclude'] = self.add_exclude self.fieldsets = self.add_fieldsets self.readonly_fields = () else: kwargs['form'] = self.update_form kwargs['fields'] = flatten_fieldsets(self.update_fieldsets) if not obj.is_superuser: kwargs['exclude'] = self.update_exclude + self.update_readonly_fields self.readonly_fields = self.update_readonly_fields else: self.readonly_fields = kwargs['exclude'] = flatten_fieldsets(self.update_fieldsets) self.fieldsets = self.update_fieldsets return super(GenericUserAdmin, self).get_form(request, obj, **kwargs)
def get_readonly_fields(self, request, obj=None): if obj is None: return self.readonly_fields if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: form = self.get_formset(request, obj).form fields = form.base_fields.keys() return fields
def get_readonly_fields(self, request, obj=None): # untested, this could do: # readonly_fields = self.model._meta.get_all_field_names() # borrowed from ModelAdmin: if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: form = self.get_formset(request, obj).form fields = form.base_fields.keys() return fields
def get_readonly_fields(self, request, obj=None): if obj is not None and not obj.is_editable(): if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] )) return super(EncounterAdmin, self).get_readonly_fields(request, obj)
def get_form(self, request, obj=None, **kwargs): if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) excluded = self.get_exclude(request, obj) exclude = [] if excluded is None else list(excluded) readonly_fields = self.get_readonly_fields(request, obj) exclude.extend(readonly_fields) if excluded is None and hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we pass None to be consistent with the # default on modelform_factory exclude = exclude or None new_attrs = OrderedDict( (f, None) for f in readonly_fields if f in self.form.declared_fields ) form = type(self.form.__name__, (self.form,), new_attrs) try: model = obj.content_type.model_class() model_key = model._meta.pk.name except (AttributeError, ObjectDoesNotExist): model = self.model.content_type.field.formfield().choices.queryset[0].model_class() model_key = 'id' defaults = { "form": form, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), "widgets": { 'content_type': ContentTypeSelect, 'object_id': ForeignKeyRawIdWidget( rel=ManyToOneRel(model_key, model, 'id'), admin_site=admin.site ) } } defaults.update(kwargs) if defaults['fields'] is None and not modelform_defines_fields(defaults['form']): defaults['fields'] = forms.ALL_FIELDS try: return modelform_factory(self.model, **defaults) except FieldError as e: raise FieldError( '%s. Check fields/fieldsets/exclude attributes of class %s.' % (e, self.__class__.__name__) )
def get_form(self, request, obj=None, **kwargs): """ Use special form during creation """ defaults = {} if obj is None: defaults.update({ 'form': self.add_form, 'fields': flatten_fieldsets(self.add_fieldsets), }) defaults.update(kwargs) return super(ObjectDBAdmin, self).get_form(request, obj, **defaults)
def get_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin add view. This is used by add_view and change_view. """ if django.VERSION >= (1, 6): # From v1.6 on, using get_fieldsets is ok, as long as no 'fields' # argument was given. It allows dynamic fieldsets on admin form. if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) else: # On previous versions, calling get_fieldsets triggers infinite recursion # and we should stick to statically declared fieldsets if self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) else: fields = None if self.exclude is None: exclude = [] else: exclude = list(self.exclude) exclude.extend(kwargs.get("exclude", [])) exclude.extend(self.get_readonly_fields(request, obj)) # Exclude language_code, adding it again to the instance is done by # the LanguageAwareCleanMixin (see translatable_modelform_factory) exclude.append('language_code') old_formfield_callback = curry(self.formfield_for_dbfield, request=request) defaults = { "form": self.form, "fields": fields, "exclude": exclude, "formfield_callback": old_formfield_callback, } defaults.update(kwargs) language = self._language(request) return translatable_modelform_factory(language, self.model, **defaults)
def get_formset(self, request, obj=None, **kwargs): """ Returns a BaseInlineFormSet class for use in admin add/change views. """ if hasattr(self, "declared_fieldsets") and self.declared_fieldsets: fields = flatten_fieldsets(self.declared_fieldsets) elif "fields" in kwargs: fields = kwargs.pop("fields") else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if self.exclude is None: exclude = [] else: exclude = list(self.exclude) # exclude.extend(self.get_readonly_fields(request, obj)) if self.exclude is None and hasattr(self.form, "_meta") and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # InlineModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we use None, since that's the actual # default exclude = exclude or None # can_delete = self.can_delete and self.has_delete_permission(request, obj) defaults = { "form": self.form, "formset": self.formset, "fk_name": self.fk_name, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), "extra": self.extra, "max_num": self.max_num, # "can_delete": can_delete, } defaults.update(kwargs) result = genericm2m_inlineformset_factory(self.parent_model, self.model, **defaults) result.content_types = self.get_content_types() result.ct_fk_field = self.ct_fk_field return result
def get_readonly_fields(self, request, obj=None): """ Make all fields read-only """ if not self.all_fields_readonly or (request.user.is_superuser and self.superuser_skips_all_readonly): return self.readonly_fields if self.declared_fieldsets: return flatten_fieldsets(self.declared_fieldsets) else: return list(set( [field.name for field in self.opts.local_fields] + [field.name for field in self.opts.local_many_to_many] ))
def batch_upload_response(self, request): output_fields = flatten_fieldsets(self.fieldsets) media_file_name = get_media_file_name(self, self.model) #Disabling exception handling here @olivierdalang's feedback: # try: latest_log_entry = LogEntry.objects.filter(action_flag=ADDITION).order_by('-action_time')[0] ct = ContentType.objects.get_for_id(latest_log_entry.content_type_id) obj = ct.get_object_for_this_type(pk=latest_log_entry.object_id) if obj: object_data = {} mime = MimeTypes() media_file = get_media_file(self, self.model, obj) media_file_url = media_file.url #urllib.pathname2url(media_file.url) #Not sure why i had this, but it's escaping the URL mime_type = mime.guess_type(media_file_url) edit_url = reverse('admin:%s_%s_change' %(obj._meta.app_label, obj._meta.model_name), args=[obj.id] ) object_data['media_file_url'] = media_file_url object_data['media_file_size'] = media_file.size object_data['media_file_type'] = mime_type[0] object_data['edit_url'] = mark_safe(edit_url) field_values = {} for output_field in output_fields: value = str(self.get_field_contents(output_field, obj)) label = str(label_for_field(output_field, self.model, self)) field_values[output_field] = { 'label':label, 'value':value } object_data['field_values'] = field_values data = { "success":True, "files":[ object_data ] } json_dumped = json.dumps(data) return HttpResponse(json_dumped, content_type='application/json')
def invite_user(self, request): """Sends an invitation email with a login token.""" # Check for add and change permission. has_add_permission = self.has_add_permission(request) has_change_permission = self.has_change_permission(request) if not has_add_permission or not has_change_permission: raise PermissionDenied # Process the form. InviteForm = self.get_form(request, form = self.invite_form, fields = flatten_fieldsets(self.invite_fieldsets), ) if request.method == "POST": form = InviteForm(request.POST) if form.is_valid(): # Save the user, marked as inactive. user = form.save(commit=False) user.is_active = False user.is_staff = True user.save() form.save_m2m() # Send an invitation email. self.do_send_invitation_email(request, user) # Message the user. self.message_user(request, "An invitation email has been sent to {email}.".format( email = user.email, )) # Redirect as appropriate. return super(UserAdminBase, self).response_add(request, user) # Using the superclass to avoid the built in munging of the add response. else: form = InviteForm() # Create the admin form. admin_form = admin.helpers.AdminForm(form, self.invite_fieldsets, {}) # Render the template. media = self.media + admin_form.media return render(request, self.invite_form_template, { "title": "Invite user", "opts": self.model._meta, "form": form, "adminform": admin_form, "media": media, "add": True, "change": False, "is_popup": False, "save_as": self.save_as, "has_add_permission": has_add_permission, "has_change_permission": has_change_permission, "has_delete_permission": self.has_delete_permission(request), "show_delete": False, })
def get_form(self, request, obj=None, **kwargs): self.form = modelform_factory(self.model, form=UserChangeForm) self.add_form = modelform_factory(self.model, form=UserCreationForm) if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if obj: qs = models.Attribute.objects.all() else: qs = models.Attribute.objects.filter(required=True) non_model_fields = [a.name for a in qs] fields = list(set(fields) - set(non_model_fields)) kwargs['fields'] = fields return super(AuthenticUserAdmin, self).get_form(request, obj=obj, **kwargs)
def get_show_form(self, request, obj=None, **kwargs): """ Returns a Form class for use in the admin show view. This is used by show_view, and doesn't take into account the readonly_fields, as all will be shown as readonly by the admin form. """ if 'fields' in kwargs: fields = kwargs.pop('fields') else: fields = flatten_fieldsets(self.get_fieldsets(request, obj)) if self.exclude is None: exclude = [] else: exclude = list(self.exclude) if self.exclude is None and hasattr(self.form, '_meta') and self.form._meta.exclude: # Take the custom ModelForm's Meta.exclude into account only if the # ModelAdmin doesn't define its own. exclude.extend(self.form._meta.exclude) # if exclude is an empty list we pass None to be consistent with the # default on modelform_factory exclude = exclude or None # Remove declared form fields which are in readonly_fields. readonly_fields = self.get_readonly_fields(request, obj) new_attrs = OrderedDict( (f, None) for f in readonly_fields if f in self.form.declared_fields ) form = type(self.form.__name__, (self.form,), new_attrs) defaults = { "form": form, "fields": fields, "exclude": exclude, "formfield_callback": partial(self.formfield_for_dbfield, request=request), } defaults.update(kwargs) if defaults['fields'] is None and not modelform_defines_fields(defaults['form']): defaults['fields'] = forms.ALL_FIELDS try: return modelform_factory(self.model, **defaults) except FieldError as e: raise FieldError('%s. Check fields/fieldsets/exclude attributes of class %s.' % (e, self.__class__.__name__))
def get_inline_instances(old_func, self, request, *args): """ Skip generic-plus inlines if the field is not in fieldsets. Failing to do so causes ManagementForm validation errors on save. """ inline_instances = old_func(self, request, *args) fieldsets = flatten_fieldsets(self.get_fieldsets(request)) def skip_inline_instance(inline): f = getattr(inline, 'field', None) return isinstance(f, GenericForeignFileField) and f.name not in fieldsets if isinstance(inline_instances, types.GeneratorType): return (i for i in inline_instances if not(skip_inline_instance(i))) else: return [i for i in inline_instances if not(skip_inline_instance(i))]
def get_form(self, request, obj=None, **kwargs): """ Use special form during creation. Args: request (Request): Incoming request. obj (Object, optional): Database object. """ defaults = {} if obj is None: defaults.update({ 'form': self.add_form, 'fields': flatten_fieldsets(self.add_fieldsets), }) defaults.update(kwargs) return super(ObjectDBAdmin, self).get_form(request, obj, **defaults)