Presupunem ca fisierul nostru **models.py** este urmatorul: ```python 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 ```python >>> first_status = Status(text="Exemplu Insert") >>> first_status.save() >>> comm = Comment(text="Am invatat cum sa facem insert", status=first_status) >>> comm.save() ``` ## Update ```python >>> 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 ```python >>> s = Status.objects.get(pk=1) >>> s.delete() >>> Status.objects.all().delete() #se vor sterge si obiectele Comment care au FK catre Status ``` ## Select ```python >>> 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 ```
... ```, 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 **\**, 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 **\** 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](https://docs.djangoproject.com/en/1.10/ref/forms/fields/)._ ### Construirea unui formular în Django **forms.py** ```python 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 **\** (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()](https://docs.djangoproject.com/en/1.10/ref/forms/api/#django.forms.Form.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](https://docs.djangoproject.com/en/1.10/ref/forms/api/#django.forms.Form.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. ```python 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: ```html {{ "{% csrf_token " }}%} {{ 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](https://docs.djangoproject.com/en/1.10/ref/csrf/). _Mai multe detalii despre lucrul cu formulare în template-uri [aici](https://docs.djangoproject.com/en/1.10/topics/forms/#working-with-form-templates)_