Django
फार्म

ModelForm उदाहरण

एक मौजूदा मॉडल वर्ग से एक ModelForm बनाएँ, उपवर्गीकरण द्वारा ModelForm :

from django import forms

class OrderForm(forms.ModelForm):
    class Meta:
        model = Order
        fields = ['item', 'order_date', 'customer', 'status']

स्क्रैच (विगेट्स के साथ) से एक Django फॉर्म को परिभाषित करना

प्रपत्रों को मॉडल के समान तरीके से, django.forms.Form परिभाषित किया जा सकता है।
विभिन्न क्षेत्र इनपुट विकल्प उपलब्ध हैं जैसे कि CharField , URLField , IntegerField , आदि।

सरल संपर्क फ़ॉर्म को परिभाषित करना नीचे देखा जा सकता है:

from django import forms

class ContactForm(forms.Form):
    contact_name = forms.CharField(
        label="Your name", required=True,
        widget=forms.TextInput(attrs={'class': 'form-control'}))
    contact_email = forms.EmailField(
        label="Your Email Address", required=True,
        widget=forms.TextInput(attrs={'class': 'form-control'}))
    content = forms.CharField(
        label="Your Message", required=True,
        widget=forms.Textarea(attrs={'class': 'form-control'}))

विजेट HTML उपयोगकर्ता-इनपुट टैग का Django का प्रतिनिधित्व है और इसे फॉर्म फ़ील्ड के लिए कस्टम HTML को रेंडर करने के लिए इस्तेमाल किया जा सकता है (उदाहरण के लिए: सामग्री के इनपुट के लिए एक टेक्स्ट बॉक्स प्रदान किया गया है)

attrs वे विशेषताएँ हैं जिन्हें फ़ॉर्म के लिए रेंडर किए गए html पर कॉपी किया जाएगा।

जैसे: content.render("name", "Your Name") देता है

<input title="Your name" type="text" name="name" value="Your Name" class="form-control" />

किसी मॉडलफ़ॉर्म के फ़ील्ड को view.py से शर्त के आधार पर निकालना

यदि हमारे पास निम्नलिखित के रूप में एक मॉडल है,

from django.db import models
from django.contrib.auth.models import User

class UserModuleProfile(models.Model):
    user = models.OneToOneField(User)
    expired = models.DateTimeField()
    admin = models.BooleanField(default=False)
    employee_id = models.CharField(max_length=50)
    organisation_name = models.ForeignKey('Organizations', on_delete=models.PROTECT)
    country = models.CharField(max_length=100)
    position = models.CharField(max_length=100)

    def __str__(self):
        return self.user

और एक मॉडल फॉर्म जो इस मॉडल को निम्नलिखित के रूप में उपयोग करता है,

from .models import UserModuleProfile, from django.contrib.auth.models import User
from django import forms

class UserProfileForm(forms.ModelForm):
    admin = forms.BooleanField(label="Make this User Admin",widget=forms.CheckboxInput(),required=False)
    employee_id = forms.CharField(label="Employee Id ")
    organisation_name = forms.ModelChoiceField(label='Organisation Name',required=True,queryset=Organizations.objects.all(),empty_label="Select an Organization")
    country = forms.CharField(label="Country")
    position = forms.CharField(label="Position")

    class Meta:
        model = UserModuleProfile
        fields = ('admin','employee_id','organisation_name','country','position',)

    def __init__(self, *args, **kwargs):
        admin_check = kwargs.pop('admin_check', False)
        super(UserProfileForm, self).__init__(*args, **kwargs)
        if not admin_check:
            del self.fields['admin']

ध्यान दें कि मेटा क्लास के नीचे मैंने एक init फंक्शन जोड़ा था जिसे हम फॉर्म फील्ड (या कुछ अन्य एक्शन) को हटाने के लिए view.py के फॉर्म को इनिशिएट करते समय उपयोग कर सकते हैं। मैं इसे बाद में समझाऊंगा।

इसलिए इस फॉर्म का उपयोग उपयोगकर्ता पंजीकरण प्रयोजनों के लिए किया जा सकता है और हम चाहते हैं कि फॉर्म के मेटा क्लास में परिभाषित सभी फ़ील्ड हों। लेकिन क्या होगा यदि हम उपयोगकर्ता को संपादित करते समय उसी रूप का उपयोग करना चाहते हैं लेकिन जब हम करते हैं तो हम प्रपत्र के व्यवस्थापक क्षेत्र को दिखाना नहीं चाहते हैं?

हम केवल एक अतिरिक्त तर्क भेज सकते हैं जब हम कुछ लॉजिक के आधार पर फॉर्म को इनिशियलाइज़ करते हैं और बैकएंड से एडमिन फील्ड को हटाते हैं।

def edit_profile(request,user_id):
    context = RequestContext(request)
    user = get_object_or_404(User, id=user_id)
    profile = get_object_or_404(UserModuleProfile, user_id=user_id)
    admin_check = False
    if request.user.is_superuser:
        admin_check = True
    # If it's a HTTP POST, we're interested in processing form data.
    if request.method == 'POST':
        # Attempt to grab information from the raw form information.
        profile_form = UserProfileForm(data=request.POST,instance=profile,admin_check=admin_check)
        # If the form is valid...
        if profile_form.is_valid():
            form_bool = request.POST.get("admin", "xxx")
            if form_bool == "xxx":
                form_bool_value = False
            else:
                form_bool_value = True
            profile = profile_form.save(commit=False)
            profile.user = user
            profile.admin = form_bool_value
            profile.save()
            edited = True
        else:
            print profile_form.errors

    # Not a HTTP POST, so we render our form using ModelForm instance.
    # These forms will be blank, ready for user input.
    else:
        profile_form = UserProfileForm(instance = profile,admin_check=admin_check)

    return render_to_response(
            'usermodule/edit_user.html',
            {'id':user_id, 'profile_form': profile_form, 'edited': edited, 'user':user},
            context)

जैसा कि आप देख सकते हैं कि मैंने यहां पहले बनाए गए फॉर्म का उपयोग करके एक सरल संपादन उदाहरण दिखाया है। ध्यान दें कि जब मैंने फॉर्म को इनिशियलाइज़ किया तो मैंने एक अतिरिक्त admin_check वैरिएबल पास किया जिसमें True या False ।

profile_form = UserProfileForm(instance = profile,admin_check=admin_check)

अब यदि आप हमारे द्वारा पहले लिखे गए फॉर्म को देखते हैं, तो आप देख सकते हैं कि init में हम admin_check को पकड़ने की कोशिश करते हैं जो हम यहाँ से पास करते हैं। यदि मान गलत है तो हम केवल admin फ़ील्ड को फ़ॉर्म से हटाते हैं और उसका उपयोग करते हैं। और चूँकि यह एक मॉडल फॉर्म है व्यवस्थापक क्षेत्र मॉडल में शून्य नहीं हो सकता है हम केवल यह देखते हैं कि क्या फॉर्म पोस्ट में फॉर्म फ़ील्ड में व्यवस्थापक फ़ील्ड था, यदि हम इसे दृश्य कोड के दृश्य कोड में False सेट नहीं करते हैं।

form_bool = request.POST.get("admin", "xxx")
if form_bool == "xxx":
    form_bool_value = False
else:
    form_bool_value = True

Django प्रपत्र के साथ फ़ाइल अपलोड

सबसे पहले हमें अपनी settings.py file में MEDIA_ROOT और MEDIA_URL को जोड़ना MEDIA_ROOT

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

इसके अलावा यहां आप ImageField साथ काम करेंगे, इसलिए याद रखें कि ऐसे मामलों में पिलो लाइब्रेरी ( pip install pillow ) pip install pillow । अन्यथा, आपको ऐसी त्रुटि होगी:

ImportError: No module named PIL

पिलो पीआईएल, पायथन इमेजिंग लाइब्रेरी का एक कांटा है, जिसे अब नहीं रखा गया है। पिलो पीआईएल के साथ पीछे की ओर संगत है।

Django सर्वर पर फाइल अपलोड करने के लिए दो फॉर्म फील्ड के साथ आता है, FileField और ImageField , हमारे फॉर्म में इन दो फील्ड का उपयोग करने का एक उदाहरण है

forms.py:

from django import forms


class UploadDocumentForm(forms.Form):
    file = forms.FileField()
    image = forms.ImageField()

views.py:

from django.shortcuts import render
from .forms import UploadDocumentForm


def upload_doc(request):
    form = UploadDocumentForm()
    if request.method == 'POST':
        form = UploadDocumentForm(request.POST, request.FILES)  # Do not forget to add: request.FILES
        if form.is_valid():
            # Do something with our files or simply save them
            # if saved, our files would be located in media/ folder under the project's base folder
            form.save()
    return render(request, 'upload_doc.html', locals())

upload_doc.html:

<html>
    <head>File Uploads</head>
    <body>
        <form enctype="multipart/form-data" action="" method="post"> <!-- Do not forget to add: enctype="multipart/form-data" -->
            {% csrf_token %}
            {{ form }}
            <input type="submit" value="Save">
        </form>
    </body>
</html>

खेतों का सत्यापन और मॉडल के लिए प्रतिबद्ध (उपयोगकर्ता ई-मेल बदलें)

उपयोगकर्ता का पासवर्ड बदलने के लिए Django के भीतर पहले से ही लागू फॉर्म हैं, एक उदाहरण SetPasswordForm है ।

हालांकि, उपयोगकर्ता ई-मेल को संशोधित करने के लिए फॉर्म नहीं हैं और मुझे लगता है कि किसी फॉर्म का सही तरीके से उपयोग करने के लिए निम्न उदाहरण को समझना महत्वपूर्ण है।

निम्नलिखित उदाहरण निम्नलिखित जांच करता है:

• ई-मेल वास्तव में बदल गया है - बहुत उपयोगी है अगर आपको ई-मेल को सत्यापित करने या मेल चिम्प को अपडेट करने की आवश्यकता है;
• ई-मेल और कन्फर्मेशन ई-मेल दोनों समान हैं - फॉर्म में ई-मेल के लिए दो फ़ील्ड हैं, इसलिए अपडेट कम त्रुटि वाला है।

और अंत में, यह उपयोगकर्ता ऑब्जेक्ट में नया ई-मेल बचाता है (उपयोगकर्ता ई-मेल को अपडेट करता है)। ध्यान दें कि __init__() विधि के लिए उपयोगकर्ता ऑब्जेक्ट की आवश्यकता होती है।

class EmailChangeForm(forms.Form):
    """
    A form that lets a user change set their email while checking for a change in the 
    e-mail.
    """
    error_messages = {
        'email_mismatch': _("The two email addresses fields didn't match."),
        'not_changed': _("The email address is the same as the one already defined."),
    }

    new_email1 = forms.EmailField(
        label=_("New email address"),
        widget=forms.EmailInput,
    )

    new_email2 = forms.EmailField(
        label=_("New email address confirmation"),
        widget=forms.EmailInput,
    )

    def __init__(self, user, *args, **kwargs):
        self.user = user
        super(EmailChangeForm, self).__init__(*args, **kwargs)

    def clean_new_email1(self):
        old_email = self.user.email
        new_email1 = self.cleaned_data.get('new_email1')
        if new_email1 and old_email:
            if new_email1 == old_email:
                raise forms.ValidationError(
                    self.error_messages['not_changed'],
                    code='not_changed',
                )
        return new_email1

    def clean_new_email2(self):
        new_email1 = self.cleaned_data.get('new_email1')
        new_email2 = self.cleaned_data.get('new_email2')
        if new_email1 and new_email2:
            if new_email1 != new_email2:
                raise forms.ValidationError(
                    self.error_messages['email_mismatch'],
                    code='email_mismatch',
                )
        return new_email2

    def save(self, commit=True):
        email = self.cleaned_data["new_email1"]
        self.user.email = email
        if commit:
            self.user.save()
        return self.user



def email_change(request):
    form = EmailChangeForm()
    if request.method=='POST':
        form = Email_Change_Form(user,request.POST)
        if form.is_valid():
            if request.user.is_authenticated:
                if form.cleaned_data['email1']  == form.cleaned_data['email2']:
                    user = request.user
                    u = User.objects.get(username=user)
                    # get the proper user
                    u.email = form.cleaned_data['email1'] 
                    u.save()
                    return HttpResponseRedirect("/accounts/profile/")
    else:
        return render_to_response("email_change.html", {'form':form},
                                   context_instance=RequestContext(request))