Presupunem ca fisierul nostru models.py este urmatorul:

from django.db import models

class Status(models.Model):
    text = models.CharField(max_length=200)
    date_added = models.DateTimeField(auto_now_add=True)
    author = models.CharField(default="Eau de Web", max_length=50)

    def __unicode__(self):
        return '{} by {}'.format(self.text, self.author)

class Comment(models.Model):
    text = models.CharField(max_length=200)
    date_added = models.DateTimeField(auto_now_add=True)
    author = models.CharField(default="Eau de Web", max_length=50)
    status = models.ForeignKey(Status)

Insert

>>> first_status = Status(text="Exemplu Insert")
>>> first_status.save()
>>> comm = Comment(text="Am invatat cum sa facem insert", status=first_status)
>>> comm.save()

Update

>>> modified_status = Status.objects.get(pk=1)
>>> modified_status.text = "Exemplu update"
>>> modified_status.save()
>>> comment = Comment.status.get(status=modified_status)
>>> comment.text = "Am invatat cum sa facem update"
>>> comment.save()

Delete

>>> s = Status.objects.get(pk=1)
>>> s.delete()
>>> Status.objects.all().delete()    #se vor sterge si obiectele Comment care au FK catre Status

Select

>>> Status.objects.filter(text="Exemplu insert")
>>> Status.objects.filter(text__startswith="E")
>>> Status.objects.filter(text__contains="insert")
>>> Status.objects.all()[:3]     #intoarce o lista cu primele 3 Status-uri
>>> Status.objects.first()       #echivalet cu Status.objects.all()[0]
>>> Status.objects.last()
>>> Comment.objects.order_by('date_added')[0]     #intoarce cel mai vechi comentariu (primul adaugat)

HTML forms

In HTML, un formular este o colecție de elemente din interiorul tagului <form> ... </ form>, care permit unui utilizator să facă lucruri cum ar fi introducerea de text, selectarea de opțiuni, manipularea obiectelor și așa mai departe, pentru ca apoi să trimită aceste informații înapoi la server. Unele dintre elementele form-ului (introducerea de text sau selectarea de opțiuni) sunt destul de simple și sunt construite în HTML.

Pe langă elementele de tip <input>, un formular trebuie să mai specifice doua lucruri:

unde: URL-ul către care vor fi returnate datele introduse de utilizator
cum: metoda HTTP prin care trebuie returnate datele

GET and POST

GET și POST sunt singurele metode HTTP folosite în lucrul cu formulare. Cele două metode sunt în general folosite în scopuri diferite. Orice cerere care ar putea fi folosită pentru a schimba starea sistemului - de exemplu, o cerere care face modificări în baza de date - ar trebui să utilizeze POST. GET trebuie utilizat numai pentru solicitările care nu afectează starea sistemului.

Formulare în Django

Django Form class

Cam în același mod în care un model Django descrie structura logică a unui obiect, comportamentul și modul în care părțile sale ne sunt prezentate, un Form class descrie un formular și determină modul în care acesta funcționează și este reprezentat.

Similar cu modul în care câmpurile unei clase de tip Model sunt mapate peste câmpurile unei baze de date, câmpurile unui Form class sunt mapate peste elementele de tip <input> ale unui formular HTML. Câmpul unui formular (un Form Field) este el însuși o clasă; ele gestionează datele din formular și îl validează atunci când acesta este trimis către server.

Mai multe detalii despre tipurile de Form Fields din Django aici.

Construirea unui formular în Django

forms.py

from django import forms

class NameForm(forms.Form):
    your_name = forms.CharField(max_length=100)

Această clasă definește un formular cu un singur câmp (your_name).

Lungimea maximă a câmpului este data de max_length. Asta înseamnă două lucruri: se pune un maxlength = “100” în tag-ul HTML <input> (deci browser-ul ar trebui să împiedice utilizatorul să introducă un număr mai mare de caractere, în primul rând). De asemenea, asta înseamnă că, atunci când Django primește formularul înapoi din browser, acesta va valida lungimea datelor.

O instanță a clasei Form are metoda is_valid() ce execută o rutină de validare pentru toate câmpurile acesteia. După ce metoda a fost apelată, dacă toate câmpurile conțin date valide, aceasta va:

returna True
plasa datele formularului în atributul său, cleaned_data

View-ul unui formular

Pentru a putea lucra cu un formular, avem nevoie să instanțiem un view pentru URL-ul unde acesta va fi publicat.

from django.shortcuts import render
from django.http import HttpResponseRedirect

from .forms import NameForm

def get_name(request):
    # if this is a POST request we need to process the form data
    if request.method == 'POST':
        # create a form instance and populate it with data from the request:
        form = NameForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            # process the data in form.cleaned_data as required
            # ...
            # redirect to a new URL:
            return HttpResponseRedirect('/thanks/')

    # if a GET (or any other method) we'll create a blank form
    else:
        form = NameForm()

    return render(request, 'name.html', {'form': form})

Template-ul unui formular

Cel mai simplu template pentru formularul nostru este următorul:

<form action="/your-name/" method="post">
    {% csrf_token %}
    
    <input type="submit" value="Submit" />
</form>

Toate câmpurile formularului și atributele lor vor fi puse în markup HTML folosind {{ form }}. csrf_token este folosit ca protecție împotriva Cross Site Request Forgery.

Mai multe detalii despre lucrul cu formulare în template-uri aici

PurePython's Wiki