Überschreiben Django-Formular-Feld name attr

Habe ich gebaut, eine Django-Formular senden zu einer Seite auf einer anderen domain (die ich nicht kontrollieren). Die Idee ist, dass ich eine schön gestaltete, sauber generiert, form, passt in meiner eigenen Website und führt den Nutzer woanders, wenn es eingereicht wird.

Jedoch

Wenn die andere form ändert die Namen der Felder, die ich ändern müssen die Namen der Felder in meinem Formular, und ändern Sie dann die Namen, die überall in meiner Anwendung - da die name attr gekoppelt ist, um den Namen der Eigenschaft für das Feld.
Wenn der remote-Formular verwendet, dumme Namen dann meine form-Objekt muss ebenfalls über Eigenschaften verfügen mit dummen Namen, die verpestet meine Anwendung code.
Sollten diese Namen zufällig reservierte Wörter in Python (z.B. from), dann ist es schwierig oder unmöglich, zum erstellen einer Django-Formular-Objekt-Darstellung.

Gibt es eine Möglichkeit, wenn Sie eine andere Zeichenfolge verwenden, für die 'name' - Attribut, wenn das Feld angezeigt wird? Also, Entkopplung des HTML-Formulars von der Klasse, die Sie repräsentiert.

Diesem würde müssen zwei Komponenten:

Überschreiben der name-Wert im widget
Das Formular Lesen Sie diesen Wert aus Anfrage.POST, wenn es gebunden ist

Brauche ich nur Schritt 1 in diesem Fall, aber Schritt 2 ist, relevante Probleme zu lösen, die ich oben aufgelistet allgemein

InformationsquelleAutor der Frage adamnfish | 2012-01-10

28

Dies ist eine ziemlich schreckliche Missbrauch der API, aber es gibt eine Formular-Methode genannt add_prefix aufgerufen wird, um zu bestimmen, was die HTML-Namen der einzelnen Felder werden sollte, unter Berücksichtigung der form Präfix, falls vorhanden. Könnte man überschreiben, so dass es aussieht, bis das Feld name in einem Wörterbuch irgendwo und gibt den Namen, den Sie wollen - nicht zu vergessen, um die Erhaltung der bestehenden Präfix Verhalten:
```
FIELD_NAME_MAPPING = {
    'field1': 'html_field1',
    'field2': 'html_field2'
}

class MyForm(forms.ModelForm):
    def add_prefix(self, field_name):
        # look up field name; return original if not found
        field_name = FIELD_NAME_MAPPING.get(field_name, field_name)
        return super(MyForm, self).add_prefix(field_name)
```
InformationsquelleAutor der Antwort Daniel Roseman

Ich habe implementiert eine einfache Funktion, die überschreibt das widget render Methode und weist Ihr einen benutzerdefinierten Namen:

def namedWidget(input_name, widget=forms.CharField):
    if isinstance(widget, type):
        widget = widget()

    render = widget.render

    widget.render = lambda name, value, attrs=None: \
        render(input_name, value, attrs)

    return widget

Die Nutzung ist einfach:

class AliasCreationForm(forms.Form):
    merchant_id = forms.CharField(
        max_length=30,
        widget=namedWidget('PSPID', forms.HiddenInput),
    )

InformationsquelleAutor der Antwort GaretJax

3

der name attr gekoppelt ist, um den Namen der Eigenschaft für das Feld.

Ihrer Beschreibung ("Wenn die andere form ändert die Namen der Felder, die ich ändern müssen die Namen der Felder in meinem Formular, und ändern Sie dann die Namen, die überall in meiner Anwendung - da ", "Wenn der remote-Formular verwendet, dumme Namen dann meine form-Objekt muss ebenfalls über Eigenschaften verfügen mit dummen Namen, die verpestet meine Anwendung code.") Sie erkennen dies als eine fragile design-Entscheidung.

Sollten Sie Bedenken, dass Ihr view-Funktion völlig löst dieses problem, in einer trivialen Weise.

Eher als align-Namen zwischen die remote-Anwendung und Ihre Anwendung, verwenden, Ihre view-Funktionen zum anzeigen von Ihrem schönen Namen, deren schreckliche Namen.

Dies ist, was die view-Funktionen sind für.

Nehmen es einen Schritt weiter, Ihre view-Funktion macht drei Dinge.
1. Überprüfen von Eingaben. Vielleicht bestehen Sie in einigen lokalen Datenbank.
2. Map-Daten aus dem Formular, um Ihre Anfrage Struktur.
3. Stellen Sie die remote-Anforderung (über httplib oder urllib2 oder was auch immer).
Positionen 1 und 3 nicht viel ändern.

Element 2 ist eine Feld-für-Feld-mapping von der Anfrage.BEITRAG zu einem Wörterbuch mit dem du dann die url lib.urlencode zum erstellen der POST-Anforderung. (Oder was auch immer das Protokoll ist.)

Ausbrechen, damit Punkt 2 in eine flexible Sache, Sie geben in Ihren Einstellungen.

Einstellungen
```
MY_MAPPING_FUNCTION = module.function
```
In Ihrem views.py
```
def submit( request ):
   if request.method == POST:
       form = SomeForm( request.POST )
       if is_valid(form):
           form.save() 
           to_be_submitted = settings.MY_MAPPING_FUNCTION( form )
           remote_post( to_be_submitted ) # or whatever your protocol is
```
Hinzufügen der mapping-Modul zu Ihrer Applikation

module.py
```
def version_1_2( form ):
    return { 
        'silly_name_1': form.cleaned_data['your_nice_name'], 
        'from': form.cleaned_data['another_nice_name'],
    }

def version_2_1( form ):
    return {
         'much_worse_name': form.cleaned_data['your_nice_name'], 
         'from': form.cleaned_data['another_nice_name'],
    }
```
InformationsquelleAutor der Antwort S.Lott
1

Merke ich, diese Frage ist alt, aber hier ist eine andere (möglicherweise sauberer) Weg, es zu tun. Die meisten Antworten hier beteiligen monkey-patching oder überschreiben einer superclass-Methode. Dies gilt als gut, aber ich denke, es ist eine saubere Art und Weise, es zu tun.

Erstellen Sie ein neues Widget, erstreckt sich das widget, das Sie benötigen, wie TextInput:
```
class TextInputSansName(forms.TextInput):
    def build_attrs(self, extra_attrs=None, **kwargs):
        if extra_attrs:
            extra_attrs.pop('name', None)
        kwargs.pop('name', None)
        return super().build_attrs(extra_attrs, **kwargs)
```
Django nennt build_attrs auf ein widget, während die render () - operation. In der Methode, ich bin entfernen 'name', wenn es in die Wörterbücher. Dies entfernt effektiv den Namen, kurz bevor es gerendert wird.

Diese Antwort überschreibt, so wenig wie möglich von der Django-API.

In eine meiner Websites, die Zahlung Prozessor braucht inputs zu sein, ohne Namen. Hier ist die control-Deklaration in der form-Klasse:
```
card_number = forms.IntegerField(
    label='Card Number', 
    widget=TextInputSansName(attrs={ 'data-stripe': 'number' })
) 
```
Cheers.

InformationsquelleAutor der Antwort Conan Albrecht

Ist es einfach. Nutzen Sie einfach das Attribut 'Etiketten' class Meta:

class AuthorForm(ModelForm):
    class Meta:
        model = Author
        fields = ('name', 'title', 'birth_date')
        labels = {
            'name': 'new_name',
        }

wo 'neuer name' wird der name angezeigt, im html.

InformationsquelleAutor der Antwort Bruno Cordeiro

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.