Django - Overriding get_form per personalizzare i moduli di amministrazione in base alla richiesta

Question

Ho provato vari metodi per raggiungere questo obiettivo.

Ho deciso di non sovrascrivere formfield_for_dbfield in quanto non ottiene una copia dell'oggetto richiesta e speravo di evitare l'hack thread_locals.

ho optato per l'override get_form nella mia classe ModelAdmin e provato quanto segue:

class PageOptions(admin.ModelAdmin): 
    def get_form(self, request, obj=None, **kwargs): 
     if request.user.is_superuser: 
      self.fieldsets = ((None, {'fields': ('title','name',),}),) 
     else: 
      self.fieldsets = ((None, {'fields': ('title',),}),) 
     return super(PageOptions,self).get_form(request, obj=None, **kwargs) 

Quando stampo fieldsets o declared_fieldsets dall'interno get_form ricevo Nessuno (o qualsiasi altra cosa ho impostato come valore iniziale in PageOptions).

Perché questo non funziona e c'è un modo migliore per farlo?

Answer 1

Non ho idea del perché la stampa la proprietà non dà volete appena assegnato (immagino può essere che dipende da dove si stampa, appunto), ma prova sovrascrivendo get_fieldsets invece. L'implementazione di base è simile al seguente:

def get_fieldsets(self, request, obj=None): 
    if self.declared_fieldsets: 
     return self.declared_fieldsets 
    form = self.get_formset(request).form 
    return [(None, {'fields': form.base_fields.keys()})] 

Vale a dire dovresti essere in grado di restituire le tue tuple.

MODIFICA da andybak. 4 anni dopo e ho trovato di nuovo la mia domanda quando cercavo di fare qualcosa di simile su un altro progetto. Questa volta sono andato con questo approccio, anche se leggermente modificato per evitare di dover ripetere fieldsets definizione:

def get_fieldsets(self, request, obj=None): 
    # Add 'item_type' on add forms and remove it on changeforms. 
    fieldsets = super(ItemAdmin, self).get_fieldsets(request, obj) 
    if not obj: # this is an add form 
     if 'item_type' not in fieldsets[0][1]['fields']: 
      fieldsets[0][1]['fields'] += ('item_type',) 
    else: # this is a change form 
     fieldsets[0][1]['fields'] = tuple(x for x in fieldsets[0][1]['fields'] if x!='item_type') 
    return fieldsets 

Answer 2

Ho un codice di esempio da un mio recente progetto che credo possa aiutarti. In questo esempio, i super user possono modificare ogni campo, mentre tutti gli altri hanno il campo "description" escluso.

Nota che penso che ci si aspetta che tu restituisca una classe Form da get_form, che potrebbe essere il motivo per cui il tuo non funzionava correttamente.

Ecco l'esempio:

class EventForm(forms.ModelForm): 
    class Meta: 
     model = models.Event 
     exclude = ['description',] 

class EventAdminForm(forms.ModelForm): 
    class Meta: 
     model = models.Event 

class EventAdmin(admin.ModelAdmin): 

    def get_form(self, request, obj=None, **kwargs): 
     if request.user.is_superuser: 
      return EventAdminForm 
     else: 
      return EventForm 

admin.site.register(models.Event, EventAdmin) 

Answer 3

Questa è la mia soluzione:

class MyModelAdmin(admin.ModelAdmin): 

    def get_form(self, request, obj=None, **kwargs): 
     if request.user.is_superuser: 
      self.exclude =() 
     else: 
      self.exclude = ('field_to_exclude',) 
     return super(MyModelAdmin, self).get_form(request, obj=None, **kwargs) 

La speranza può aiutare

Answer 4

non si modifica il valore di di auto attributi perché non è thread-safe. È necessario utilizzare qualunque hook per sovrascrivere tali valori.

Answer 5

Per creare moduli di amministrazione personalizzati abbiamo definito una nuova classe che può essere utilizzata come mixin.L'approccio è abbastanza flessibile:

• ModelAdmin: definire un fieldset contenente tutti campi

• ModelForm: restringono i campi essendo mostrati

• FlexibleModelAdmin: override get_fieldsets-metodo di ModelAdmin; restituisce un fieldset ridotta che contiene solo i campi definiti nella forma di amministrazione

class FlexibleModelAdmin(object): 
    ''' 
    adds the possibility to use a fieldset as template for the generated form 
    this class should be used as mix-in 
    ''' 

    def _filterFieldset(self, proposed, form): 
     ''' 
     remove fields from a fieldset that do not 
     occur in form itself. 
     ''' 

     allnewfields = [] 
     fields = form.base_fields.keys() 
     fieldset = [] 
     for fsname, fdict in proposed: 
      newfields = [] 
      for field in fdict.get('fields'): 
       if field in fields: 
        newfields.append(field) 
       allnewfields.extend(newfields) 
      if newfields: 
       newentry = {'fields': newfields} 
       fieldset.append([fsname, newentry]) 

     # nice solution but sets are not ordered ;) 
     # don't forget fields that are in a form but were forgotten 
     # in fieldset template 
     lostfields = list(set(fields).difference(allnewfields)) 
     if len(lostfields): 
      fieldset.append(['lost in space', {'fields': lostfields}]) 

     return fieldset 

    def get_fieldsets(self, request, obj=None): 
     ''' 
     Hook for specifying fieldsets for the add form. 
     ''' 

     if hasattr(self, 'fieldsets_proposed'): 
      form = self.get_form(request, obj) 
      return self._filterFieldset(self.fieldsets_proposed, form) 
     else: 
      return super(FlexibleModelAdmin, self).get_fieldsets(request, obj) 

Nel modello di amministrazione si definisce fieldsets_proposed che serve da modello e contiene tutti i campi.

class ReservationAdmin(FlexibleModelAdmin, admin.ModelAdmin): 

    list_display = ['id', 'displayFullName'] 
    list_display_links = ['id', 'displayFullName'] 
    date_hierarchy = 'reservation_start' 
    ordering = ['-reservation_start', 'vehicle'] 
    exclude = ['last_modified_by'] 

    # considered by FlexibleModelAdmin as template 
    fieldsets_proposed = (
     (_('General'), { 
      'fields': ('vehicle', 'reservation_start', 'reservation_end', 'purpose') # 'added_by' 
     }), 
     (_('Report'), { 
      'fields': ('mileage') 
     }), 
     (_('Status'), { 
      'fields': ('active', 'editable') 
     }), 
     (_('Notes'), { 
      'fields': ('note') 
     }), 
    ) 
    ....   

    def get_form(self, request, obj=None, **kwargs): 
     ''' 
     set the form depending on the role of the user for the particular group 
     ''' 

     if request.user.is_superuser: 
      self.form = ReservationAdminForm 
     else: 
      self.form = ReservationUserForm 

     return super(ReservationAdmin, self).get_form(request, obj, **kwargs) 

admin.site.register(Reservation, ReservationAdmin) 

nel modello costituisce ora è possibile definire i campi che devono essere esclusi/inclusi. get_fieldset() della classe mixin si assicura che vengano restituiti solo i campi definiti nel modulo.

class ReservationAdminForm(ModelForm): 
    class Meta: 
     model = Reservation 
     exclude = ('added_by', 'last_modified_by') 

class ReservationUserForm(BaseReservationForm): 
    class Meta: 
     model = Reservation 
     fields = ('vehicle', 'reservation_start', 'reservation_end', 'purpose', 'note') 

Answer 6

Si potrebbe fare fieldsets e form proprietà e li emettono segnali per ottenere i desiderati forme/fieldsets.