Ghid de inițiere Django: Construiește rapid prima ta aplicație web

Django este un framework web Python de nivel înalt, cu scopul de a dezvolta rapid și cu un design concis. Acesta urmează arhitectura Model-Template-View (MTV), încurajând reutilizarea codului și modularizarea. Acest ghid te va ghida pas cu pas în crearea unei aplicații Django simple, pentru a te familiariza rapid cu acesta.

1. Configurarea mediului

În primul rând, trebuie să te asiguri că ai Python instalat pe sistemul tău. Django recomandă utilizarea Python 3.6 sau o versiune ulterioară.

1.1 Instalarea Python

Dacă sistemul tău nu are Python instalat, îl poți descărca și instala de pe site-ul oficial Python.

1.2 Crearea unui mediu virtual (Virtual Environment)

Pentru a izola dependențele dintre diferite proiecte, este puternic recomandat să folosești un mediu virtual.

Deschide un terminal sau o linie de comandă.
Creează un director de proiect, de exemplu myproject:
```
mkdir myproject
cd myproject
```
Creează și activează mediul virtual:
```
python3 -m venv venv  # Sau python -m venv venv
source venv/bin/activate  # Linux/macOS
venv\Scripts\activate  # Windows
```
După activarea mediului virtual, promptul terminalului tău va afișa (venv), indicând faptul că folosești mediul virtual.

1.3 Instalarea Django

În mediul virtual activat, folosește pip pentru a instala Django:

pip install Django

Verifică dacă instalarea a reușit:

python -m django --version

Ar trebui să poți vedea numărul versiunii Django.

2. Crearea unui proiect Django

După instalarea Django, poți crea un nou proiect Django.

Încă în directorul tău de proiect (myproject), rulează următoarea comandă:
```
django-admin startproject mysite
```
Aceasta va crea un director numit mysite în directorul myproject, care conține fișierele schelet ale proiectului Django.
Intră în directorul mysite:
```
cd mysite
```
Structura directorului proiectului Django este următoarea:
```
mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
```
- manage.py: Un instrument de linie de comandă pentru gestionarea proiectului Django.
- mysite/: Un pachet Python care conține configurația proiectului.
  - __init__.py: Un fișier gol care îi spune lui Python că directorul ar trebui considerat un pachet Python.
  - settings.py: Fișierul de configurare al proiectului, cum ar fi setările bazei de date, modul de depanare etc.
  - urls.py: Configurația rutelor URL, care mapează URL-urile la funcțiile de vizualizare.
  - asgi.py: Fișierul de configurare ASGI (Asynchronous Server Gateway Interface), utilizat pentru implementarea aplicațiilor asincrone.
  - wsgi.py: Fișierul de configurare WSGI (Web Server Gateway Interface), utilizat pentru implementarea aplicațiilor sincrone tradiționale.

3. Pornirea serverului de dezvoltare

Django vine cu un server de dezvoltare ușor, care este convenabil pentru dezvoltarea și testarea locală.

În directorul mysite, executați următoarea comandă:
```
python manage.py runserver
```
Deschideți browserul și accesați http://127.0.0.1:8000/. Ar trebui să vedeți pagina "It worked! Congratulations on your first Django-powered page.".

4. Crearea unei aplicații Django

Un proiect Django poate conține mai multe aplicații. Să creăm o aplicație numită myapp.

Deschideți o nouă fereastră de terminal (păstrați serverul de dezvoltare pornit).
În directorul mysite, executați următoarea comandă:
```
python manage.py startapp myapp
```
Aceasta va crea un director numit myapp în directorul mysite, care conține fișierele schelet ale aplicației Django.
Structura directorului aplicației Django este următoarea:
```
myapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```
- __init__.py: Un fișier gol care îi spune lui Python că directorul ar trebui tratat ca un pachet Python.
- admin.py: Folosit pentru a configura panoul de administrare Django.
- apps.py: Configurația aplicației.
- migrations/: Folosit pentru a gestiona migrațiile bazei de date.
- models.py: Definește modelele de date (tabelele bazei de date).
- tests.py: Scrie cazuri de testare.
- views.py: Definește funcțiile de vizualizare, gestionează cererile și returnează răspunsuri.

În mysite/settings.py, adăugați myapp la lista INSTALLED_APPS:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'myapp',  # Adăugați myapp
]

5. Crearea unei vizualizări simple

Acum vom crea o vizualizare simplă care afișează "Hello, Django!" în browser.

Editați fișierul myapp/views.py și adăugați următorul cod:

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, Django!")

Creați un fișier myapp/urls.py și mapați URL-ul la funcția de vizualizare:

   from django.urls import path
   from . import views

   urlpatterns = [
       path('', views.index, name='index'),
   ]
   ```

3.  Includeți `myapp/urls.py` în `mysite/urls.py`:

   ```python
   from django.urls import include, path
   from django.contrib import admin

   urlpatterns = [
       path('admin/', admin.site.urls),
       path('myapp/', include('myapp.urls')),  # Adăugați configurația URL pentru myapp
   ]
   ```

4.  Accesați `http://127.0.0.1:8000/myapp/`. Ar trebui să vedeți pagina "Hello, Django!".

## 6. Crearea unui model

Să creăm un model simplu pentru a stoca date.

1.  Editați fișierul `myapp/models.py`, adăugați următorul cod:

   ```python
   from django.db import models

   class Question(models.Model):
       question_text = models.CharField(max_length=200)
       pub_date = models.DateTimeField('date published')

       def __str__(self):
           return self.question_text
   ```

   Aceasta definește un model numit `Question`, care conține două câmpuri: `question_text` (CharField) și `pub_date` (DateTimeField).

2.  Creați și aplicați migrațiile bazei de date:

   ```bash
   python manage.py makemigrations myapp
   python manage.py migrate
   ```

   Comanda `makemigrations` va crea fișiere de migrație pe baza modelului dvs., iar comanda `migrate` va aplica migrațiile la baza de date.

## 7. Utilizarea panoului de administrare Django

Django oferă un panou de administrare puternic, care vă permite să vă gestionați datele cu ușurință.

1.  Creați un superutilizator:

   ```bash
   python manage.py createsuperuser
   ```

   Urmați instrucțiunile pentru a introduce numele de utilizator, adresa de e-mail și parola.

2.  Editați fișierul `myapp/admin.py`, înregistrați modelul `Question`:

   ```python
   from django.contrib import admin
   from .models import Question

   admin.site.register(Question)
   ```

3.  Accesați `http://127.0.0.1:8000/admin/`, conectați-vă cu superutilizatorul pe care l-ați creat. Ar trebui să vedeți modulul "Questions", unde puteți adăuga, edita și șterge întrebări.

## 8. Utilizarea șabloanelor

Utilizarea șabloanelor vă permite să generați pagini HTML mai flexibile.
1. În directorul `myapp`, creați un director numit `templates` și, în directorul `templates`, creați un director numit `myapp` ( `myapp/templates/myapp` ).

2. În directorul `myapp/templates/myapp`, creați un fișier numit `index.html` și adăugați următorul cod:

   ```html
   
   
       
           Hello, Django!
       
       The current time is: {{ current_time }}
   
   ```

3. Editați fișierul `myapp/views.py` și utilizați șablonul:

   ```python
   from django.shortcuts import render
   import datetime

   def index(request):
       now = datetime.datetime.now()
       return render(request, 'myapp/index.html', {'current_time': now})
   ```

   Funcția `render` va încărca șablonul și va transmite datele către șablon pentru a fi redate (renderizate).

4. Reaccesați `http://127.0.0.1:8000/myapp/`. Ar trebui să vedeți o pagină care conține ora curentă.

## 9. Concluzie

Prin acest ghid, ați înțeles conceptele de bază ale Django și modul de utilizare, inclusiv configurarea mediului, crearea de proiecte și aplicații, definirea modelelor, crearea de vizualizări și utilizarea șabloanelor. Acesta este doar un început, Django oferă funcții bogate, puteți continua să învățați și să explorați pentru a construi aplicații web mai complexe.