Ministerul Educației, Culturii și Cercetării

Departamentul Ingineria Software și Automatica

Task Manager Minimal

A efectuat:​ ​ ​ ​ ​ st. gr. TI-235 Surdu Nichita

​
​ ​ ​ ​ ​ ​

Coordonator intreprindere:​ ​ ​ ​ ​ Dumitrașcu Marius​

Coordonator​ universitate:​ ​ ​ ​ ​ Cojocaru Sergiu, Lector Univ.

Chişinău 2025

1
 CUPRINS

INTRODUCERE ....................................................................................................................3

I CONSIDERAȚII TEORETICE
​
1 INTRODUCERE ÎN CONCEPT ..........................................................................................4
1.1 EXEMPLE ȘI PARTICULARITĂȚI .................................................................................5
2 ASPECTE TEHNICE ...........................................................................................................7
2.1 STRAT DE PREZENTARE (UI BLAZOR) ......................................................................8
2.2 STRAT DE SERVICII ȘI BUSINESS LOGIC ..................................................................9
2.3 STRAT DE DATE (DB CONTEXT, ENTITĂȚI, MIGRAȚII) .........................................11
2.4 SERVICIUL DE E-MAIL ..................................................................................................12
2.5 FLUX DE FUNCȚIONARE ..............................................................................................14
2.6 CONSIDERAȚII DE SECURITATE .................................................................................15
2.7 CONTAINERIZAREA CU DOCKER ...............................................................................16

II REALIZAREA APLICAȚIEI

1 CERINȚE GENERALE CĂTRE FUNCȚIONAREA APLICAȚIEI ..................................17

1.1 STRAT DE PREZENTARE (UI BLAZOR) ......................................................................18
1.2 STRAT DE SERVICII ȘI BUSINESS LOGIC ..................................................................21
1.3 STRAT DE DATE (DB CONTEXT, ENTITĂȚI, MIGRAȚII) .........................................24
1.4 SERVICIUL DE E-MAIL ..................................................................................................28

III TESTAREA APLICAȚIEI

CONCLUZIE .......................................................................................................................32
BIBLIOGRAFIE ..................................................................................................................34

2
 INTRODUCERE

Organizarea activităților zilnice este o provocare pentru mulți utilizatori, iar un Task
Manager simplu, accesibil din browser, reprezintă o soluție eficientă pentru a urmări sarcinile
personale sau profesionale. În loc să depindă de aplicații complexe ori de soluții cu abonament, o
aplicație web minimalistă oferă un mediu rapid, intuitiv și ușor de întreținut.
Tehnologia Blazor Server a fost aleasă pentru a permite dezvoltarea interfeței utilizatorului
în C# și Razor, eliminând nevoia de framework-uri JavaScript suplimentare. Astfel, logica de
prezentare și cea de business pot fi implementate într-un singur limbaj, simplificând procesul de
mentenanță și reducând erorile.
Pentru stocarea datelor, aplicația folosește Entity Framework Core împreună cu o bază de
date SQLite, o alegere potrivită pentru proiecte mici și medii datorită portabilității și configurării
minime.
Scopul principal al aplicației este oferirea unei platforme minimaliste de gestionare a
sarcinilor zilnice, care să includă:
1.​ Operații CRUD pentru fiecare task;
2.​ Posibilitatea de a marca sarcinile ca „În lucru” sau „Finalizat”;
3.​ Filtrarea rapidă a listei de sarcini în funcție de statut.

Aplicația servește și ca bază de cod reutilizabilă pentru viitoare proiecte web dezvoltate cu
Blazor, ea poate fi extinsă ulterior cu funcționalități precum autentificare, trimitere de notificări sau
sincronizare între dispozitive.
Public țintă:
1.​ Utilizatorilor individuali care doresc să își gestioneze activitățile zilnice într-un mod simplu,
fără dependențe de servicii externe.
2.​ Echipe mici ce au nevoie de o soluție ușoară pentru urmărirea progresului sarcinilor
comune, fără costuri de licență.
3.​ Dezvoltatorilor care caută un punct de plecare pentru proiecte mai complexe bazate pe
Blazor și EF Core.​

Scenarii de utilizare:
1.​ Crearea unei liste zilnice de activități personale (ex.: cumpărături, sarcini casnice).
2.​ Gestionarea unui mini-proiect intern, unde fiecare membru poate adăuga sau marca taskuri
finalizate.

3
 3.​ Demonstrarea principiilor CRUD și a integrării Blazor–Entity Framework Core în contexte
educaționale sau de prototipare rapidă.​

Prin simplitatea designului și alegerea unor tehnologii moderne, Task Manager Minimal
devine o aplicație utilă atât pentru utilizatorii finali, cât și pentru dezvoltatori. Blazor Server permite
o experiență interactivă fluidă, EF Core asigură persistența datelor, iar baza de date SQLite oferă
portabilitate maximă. Aceste caracteristici fac din aplicație un exemplu potrivit de proiect educativ
și o bază solidă pentru dezvoltări ulterioare.

I CONSIDERAȚII TEORETICE

1 INRODUCERE ÎN CONCEPT

Într-o lume tot mai digitalizată, gestionarea timpului și organizarea eficientă a activităților
zilnice au devenit priorități pentru oameni din diverse domenii – de la studenți și angajați, până la
manageri, freelanceri și chiar pentru uz personal. Ritmul alert al vieții moderne, diversitatea
sarcinilor pe care trebuie să le realizăm și multitudinea de informații cu care interacționăm zilnic
creează o nevoie constantă de instrumente care să ajute la structurarea și monitorizarea activităților.
În acest context, aplicațiile și site-urile specializate în task management au câștigat
popularitate, fiind utilizate atât la nivel individual, cât și în cadrul echipelor sau organizațiilor.
Aceste instrumente se bazează pe un principiu simplu, dar extrem de eficient: utilizatorul își
notează sarcinile (tasks), cel mai adesea sub forma unor scurte descrieri textuale, și le marchează
drept finalizate după ce sunt îndeplinite. Această metodă de lucru nu doar că oferă o privire clară
asupra progresului activităților, dar contribuie și la crearea unei discipline personale, reducerea
uitărilor și gestionarea mai bună a priorităților.

Mecanismul de funcționare este relativ comun pentru majoritatea acestor aplicații:

1.​ Utilizatorul notează ceea ce are de făcut (de exemplu: „Trimite raportul de vânzări”, „Plimbă
câinele” sau „Învață pentru examen”);
2.​ Unele aplicații permit adăugarea unor termene limită, alocarea de resurse, stabilirea
nivelului de prioritate sau chiar atașarea unor fișiere și linkuri;

4
 3.​ Fiecare sarcină poate fi urmărită individual, iar unele platforme oferă vizualizări grafice sau
statistici privind eficiența și progresul;
4.​ Momentul în care activitatea este închisă, ceea ce oferă utilizatorului o satisfacție vizibilă și
o evidență clară a ceea ce a realizat.​

Un alt aspect important este faptul că aceste aplicații pot fi utilizate atât pe dispozitive
mobile, cât și pe desktop, iar multe dintre ele oferă sincronizare în cloud, ceea ce înseamnă că
utilizatorul are acces la lista sa de sarcini de pe orice dispozitiv.
Pe lângă funcția de bază – gestionarea taskurilor – aplicațiile moderne pentru organizare
includ adesea și funcționalități avansate precum colaborarea în echipă, integrarea cu alte servicii (de
exemplu, Google Calendar, Slack, Microsoft Outlook), notificări inteligente sau chiar elemente de
gamificare care motivează utilizatorul să fie mai productiv.
Astfel, aceste instrumente digitale reprezintă o combinație între un jurnal clasic de activități
și un asistent personal virtual, având ca scop principal creșterea eficienței și organizarea mai bună a
timpului.

1.1 EXEMPLE ȘI PARTICULARITĂȚI

Pentru a înțelege mai bine cum funcționează aceste aplicații și ce le face utile, putem analiza
câteva dintre cele mai populare soluții existente pe piață.
Todoist este una dintre cele mai cunoscute aplicații de tip to-do list. Interfața este simplă și
intuitivă, bazată pe adăugarea rapidă de taskuri și organizarea lor în proiecte. Printre
funcționalitățile sale se numără: setarea de termene limită, crearea de sarcini recurente, utilizarea
etichetelor (tags) și posibilitatea de colaborare cu alți utilizatori. O particularitate a Todoist este
folosirea unui sistem de punctaj numit Karma, care motivează utilizatorul să-și îndeplinească
sarcinile constant.
Microsoft To Do este o aplicație dezvoltată de Microsoft și se integrează foarte bine cu alte
produse din ecosistemul său, precum Outlook sau Microsoft 365. Microsoft To Do oferă
posibilitatea de a organiza sarcinile în liste tematice, de a seta notificări și alerte, precum și de a
sincroniza activitățile între dispozitive. Este apreciată în special de utilizatorii care lucrează deja cu
suita Microsoft, datorită integrării fluide.
Trello se diferențiază prin modul vizual de organizare: utilizează panouri (boards), liste și
carduri pentru gestionarea sarcinilor. Fiecare card poate conține descrieri, checklisturi, fișiere
atașate sau comentarii, ceea ce îl face foarte util pentru munca în echipă. Este des folosit în proiecte

5
colaborative, în special în mediile de dezvoltare software sau marketing. În comparație cu
aplicațiile clasice de tip listă, Trello oferă o imagine de ansamblu mult mai clară asupra etapelor
unui proiect.
Google Keep este o aplicație minimalistă de luare de notițe și gestionare de sarcini. Spre
deosebire de altele, se concentrează pe simplitate: utilizatorii pot adăuga liste de activități, note
rapide, imagini sau înregistrări vocale. Este foarte ușor de folosit, dar nu are funcții complexe de
management de proiect. Punctul său forte este integrarea cu Google Drive și Google Calendar.
Asana este o platformă orientată în special spre echipe și proiecte mai complexe. Permite
crearea de sarcini, atribuirea acestora către membri ai echipei, stabilirea unor deadline-uri,
urmărirea progresului și chiar vizualizarea activităților sub formă de cronograme (timelines). În
comparație cu Todoist sau Microsoft To Do, Asana este mult mai robust și mai potrivit pentru
organizații mari.

Asemănări:

1.​ Toate aceste aplicații permit crearea de sarcini sub formă de text;
2.​ Majoritatea oferă posibilitatea de a seta termene limită și notificări;
3.​ Sincronizarea între dispozitive și accesul la listă din cloud este o caracteristică comună;
4.​ Oferă un sentiment de progres și motivație prin marcarea sarcinilor ca finalizate.​

Diferențe:

1.​ Aplicații precum Google Keep sunt minimaliste, în timp ce Asana sau Trello oferă
instrumente complexe pentru echipe;
2.​ Unele sunt gândite pentru uz personal (ex. Microsoft To Do, Todoist), altele pentru
colaborare de echipă (ex. Trello, Asana);
3.​ Trello se bazează pe carduri vizuale, Google Keep pe note simple, iar Todoist pe liste
structurate;
4.​ Integrarea cu alte servicii – Microsoft To Do se leagă de ecosistemul Microsoft, Google
Keep de ecosistemul Google, iar Asana oferă integrare cu numeroase aplicații terțe.

6
​
2 ASPECTE TEHNICE

Aplicația creată se bazează pe tehnologii moderne din ecosistemul .NET, care permit
dezvoltarea rapidă și eficientă a aplicațiilor web interactive. Alegerea combinației dintre Blazor,
Entity Framework Core și SQLite oferă un echilibru între simplitate, performanță și ușurința în
gestionarea datelor.​
​ Blazor reprezintă o tehnologie dezvoltată de Microsoft ce permite construirea de aplicații
web moderne folosind limbajul C#, fără a fi necesar JavaScript pentru logica de interfață. În cazul
acestei aplicații, Blazor a fost utilizat pentru a implementa partea vizuală și interactivă, respectiv
pentru crearea componentelor care gestionează sarcinile (tasks). Utilizatorul are posibilitatea de a
adăuga, edita și marca activitățile ca finalizate, toate aceste acțiuni fiind gestionate printr-o interfață
reactivă și prietenoasă. Un avantaj important al Blazor este faptul că logica aplicației și partea de
interfață se bazează pe același limbaj (C#), ceea ce reduce complexitatea și îmbunătățește
mentenanța codului.​
​ Pentru gestionarea datelor, aplicația utilizează Entity Framework Core (EF Core), un ORM
(Object Relational Mapper) puternic și flexibil. Acesta permite dezvoltatorului să lucreze cu obiecte
și clase C# în loc de a scrie manual interogări SQL complexe. În cadrul aplicației, EF Core a fost
folosit pentru a crea modelul de date (de exemplu, clasa Task care conține câmpuri precum Id, Titlu,
Descriere, DataLimita, EsteFinalizat) și pentru a gestiona operațiile CRUD (Create, Read, Update,
Delete). Acest lucru asigură o integrare fluentă între partea de interfață (Blazor) și baza de date,
reducând riscul de erori și simplificând accesul la date.​
​ Pentru stocarea datelor, a fost aleasă baza de date SQLite, cunoscută pentru simplitatea și
portabilitatea sa. SQLite este o bază de date relațională, dar spre deosebire de soluții mai complexe
precum SQL Server sau PostgreSQL, aceasta se bazează pe un singur fișier stocat local, ceea ce o
face extrem de ușor de configurat și distribuit. În aplicația dezvoltată, SQLite gestionează toate
înregistrările privind sarcinile utilizatorului, inclusiv statusul lor (finalizat/nefinalizat). Această
alegere este potrivită pentru aplicațiile de dimensiuni mici și medii, unde nu este necesară o
infrastructură complexă de baze de date.​
​ Fluxul aplicației funcționează astfel: atunci când utilizatorul introduce o sarcină nouă prin
interfața Blazor, aceasta este transmisă către modelul de date gestionat de EF Core, care la rândul
său actualizează baza de date SQLite. Operațiunile inverse, cum ar fi afișarea sarcinilor existente
sau marcarea lor ca finalizate, se realizează prin interogări EF Core, rezultatele fiind afișate dinamic

7
pe interfață. Datorită acestei integrări, utilizatorul percepe aplicația ca pe un sistem fluid și imediat
responsiv.

Avantaje tehnice:

1.​ Cod unificat în C;

2.​ Simplitate în implementare și mentenanță;
3.​ Portabilitate și ușurință de distribuire datorită SQLite;
4.​ Interfață modernă și reactivă prin Blazor;​

Prin combinația acestor tehnologii, aplicația obține un nivel ridicat de eficiență, fiind în
același timp ușor de extins și întreținut. Aceasta poate reprezenta un punct de pornire solid pentru
dezvoltarea unor aplicații mai complexe de tip task management sau chiar pentru soluții orientate
spre echipe și colaborare.

2.1 STRAT DE PREZENTARE (UI BLAZOR)

Stratul de prezentare (UI – User Interface) reprezintă componenta vizibilă și interactivă a

unei aplicații, partea cu care utilizatorul interacționează direct. În cazul unei aplicații dezvoltate cu
Blazor, acest strat joacă un rol esențial, întrucât permite construirea interfeței grafice folosind
limbajul C#, fără a fi necesară utilizarea intensivă a JavaScript-ului, așa cum se întâmplă în alte
frameworkuri front-end. Blazor aduce în ecosistemul .NET o modalitate modernă de a dezvolta
aplicații web interactive, combinând avantajele programării cu C# și structura componentelor
reutilizabile.
Un prim aspect al stratului de prezentare în Blazor este modelul bazat pe componente.
Interfața aplicației este alcătuită din componente independente (de exemplu: formular pentru
adăugarea unui task, listă de sarcini, buton pentru marcarea ca finalizat), care pot fi reutilizate și
combinate pentru a construi pagini complexe. Fiecare componentă Blazor este definită într-un fișier
.razor și conține atât codul pentru afișarea elementelor HTML, cât și logica necesară pentru
gestionarea evenimentelor (click, input, submit etc.). Această abordare permite separarea clară a
responsabilităților și o mai bună organizare a codului.
Un al doilea element important este data binding-ul (legătura dintre date și interfață). Blazor
oferă mecanisme bidirecționale de legare a datelor, ceea ce înseamnă că atunci când utilizatorul
introduce sau modifică informații (de exemplu, adaugă un nou task într-un câmp de text), acestea

8
sunt actualizate automat în modelul de date. În același timp, orice schimbare a datelor din backend
este reflectată imediat în interfață, fără a fi nevoie de reîncărcarea paginii.
Stratul de prezentare Blazor se remarcă și prin interactivitate în timp real. Acest lucru este
posibil datorită mecanismului de rendering dinamic și a arhitecturii bazate pe SignalR (în cazul
Blazor Server) sau pe WebAssembly (în cazul Blazor WebAssembly). În contextul aplicațiilor de tip
task management, acest lucru se traduce printr-o experiență fluidă: când un utilizator adaugă sau
finalizează o sarcină, interfața este actualizată instantaneu, fără întreruperi vizibile.
De asemenea, Blazor permite integrarea cu CSS și librării front-end existente, ceea ce ajută
la crearea unor interfețe atractive și adaptabile la diferite tipuri de dispozitive (desktop, tabletă,
mobil). Astfel, stratul UI nu doar afișează datele, ci și asigură o experiență vizuală plăcută și
accesibilă.
În concluzie, stratul de prezentare UI în Blazor reprezintă puntea dintre utilizator și logica
aplicației. Prin utilizarea componentelor, a data binding-ului și a mecanismelor de rendering reactiv,
Blazor oferă un mediu robust pentru dezvoltarea unor interfețe moderne, interactive și ușor de
întreținut. Într-o aplicație de tip task management, acest strat face posibilă gestionarea intuitivă a
activităților zilnice, transformând interacțiunea utilizatorului într-o experiență simplă și eficientă.

2.2 STRAT DE SERVICII ȘI BUSINESS LOGIC

În arhitectura unei aplicații moderne, stratul de servicii și business logic ocupă un rol
central, asigurând legătura dintre interfața utilizatorului (UI) și nivelul de stocare a datelor (baza de
date). Într-o aplicație de tip task management, acest strat nu se limitează la transmiterea datelor între
interfață și baza de date, ci implementează logica de afaceri – adică regulile, validările și fluxurile
care definesc modul în care aplicația trebuie să funcționeze dincolo de simpla persistență a
informației.​
​ Stratul de servicii are ca scop abstractizarea accesului la date și oferirea unui set de metode
clare pentru interacțiunea cu acestea. În loc ca interfața să acceseze direct baza de date, aceasta
apelează serviciile care, la rândul lor, gestionează operațiile de creare, citire, actualizare și ștergere
(CRUD) prin intermediul Entity Framework Core. Într-un exemplu concret, pentru adăugarea unui
nou task, interfața trimite cererea către un serviciu, iar acesta se ocupă de validarea datelor și
persistarea lor în baza SQLite.
​
​ Logica de business definește regulile prin care aplicația funcționează. În cazul aplicației,
aceasta include:

9
 1.​ stabilirea unor condiții pentru crearea unui task (de exemplu, titlul să nu fie gol sau data
limită să fie validă);
2.​ marcarea corectă a unui task ca „finalizat” și actualizarea stării sale;
3.​ gestionarea sarcinilor recurente sau a notificărilor;
4.​ sortarea și filtrarea listelor de activități în funcție de priorități sau termene limită.​

Aceste reguli sunt implementate în clasele de servicii, care asigură că datele introduse de
utilizator respectă logica stabilită și că acțiunile efectuate în interfață se traduc în operații corecte
asupra bazei de date.
​
​ Un avantaj important al stratului de servicii și business logic este separarea
responsabilităților: interfața se ocupă doar de prezentare, iar serviciile gestionează regulile
aplicației. Această structură face ca aplicația să fie mai ușor de întreținut și extins. De exemplu,
dacă în viitor se dorește integrarea cu un serviciu extern de trimitere notificări prin e-mail, acest
lucru se poate realiza adăugând o nouă metodă în stratul de servicii, fără a modifica interfața.​
​ Serviciile utilizează Entity Framework Core pentru a accesa baza de date SQLite, dar ascund
complexitatea interogărilor de restul aplicației. Astfel, dacă într-o etapă ulterioară baza de date ar fi
schimbată (de exemplu, de la SQLite la SQL Server), modificările ar afecta doar stratul de servicii,
interfața rămânând neschimbată.

Avantaje ale acestui strat:

1.​ Crește modularitatea și claritatea aplicației.

2.​ Permite validarea centralizată a datelor și aplicarea consecventă a regulilor de business.
3.​ Simplifică procesul de testare, întrucât logica de business poate fi verificată independent de
UI.
4.​ Oferă flexibilitate pentru extinderea funcționalităților în viitor.​

În concluzie, stratul de servicii și business logic reprezintă fundamentul care asigură

coerența și funcționalitatea unei aplicații web. În contextul unui site de gestionare a sarcinilor,
acesta este responsabil pentru aplicarea regulilor, validarea datelor și coordonarea fluxurilor dintre
interfață și baza de date, garantând astfel o experiență corectă și fiabilă pentru utilizator.

2.3 STRAT DE DATE (DB CONTEXT, ENTITĂȚI, MIGRAȚII)

10
 În arhitectura unei aplicații moderne, stratul de date reprezintă nivelul responsabil de
gestionarea interacțiunii cu baza de date și de stocarea informațiilor într-un mod structurat. Într-o
aplicație de tip task management realizată cu Blazor, Entity Framework Core și SQLite, acest strat
joacă un rol fundamental, deoarece asigură persistența activităților introduse de utilizatori și permite
recuperarea lor ulterioară. Principalele componente care definesc stratul de date sunt DbContext,
entitățile și migrațiile.​
​ Clasa DbContext este elementul central al stratului de date. Ea acționează ca un intermediar
între aplicație și baza de date, gestionând conexiunea, tranzacțiile și transformarea obiectelor C# în
tabele relaționale (și invers). În cadrul aplicației, DbContext conține colecții de tip DbSet<T>, unde
fiecare T reprezintă o entitate. De exemplu, pentru o aplicație de gestionare a sarcinilor,
DbSet<Task> definește colecția de sarcini care va fi mapată într-un tabel al bazei de date SQLite.
Pe lângă accesul direct la date, DbContext oferă și posibilitatea de a configura relațiile dintre
entități și regulile de validare prin metoda OnModelCreating.​
​ Entitățile sunt clase C# care modelează obiectele reale din aplicație și care sunt transpuse în
tabele ale bazei de date. Fiecare proprietate a unei entități corespunde unei coloane din tabel. De
exemplu, o entitate Task poate conține câmpuri precum Id, Titlu, Descriere, DataLimita și
EsteFinalizat. Id joacă rol de cheie primară, iar celelalte proprietăți definesc atributele unei sarcini.
Avantajul acestei abordări este că dezvoltatorul lucrează cu obiecte orientate pe obiect (OOP), iar
transformarea lor în structuri relaționale este gestionată automat de Entity Framework Core,
eliminând necesitatea scrierii manuale a interogărilor SQL.​
​ Migrațiile sunt mecanismul prin care structura bazei de date evoluează odată cu modificările
aduse în codul sursă. În loc de a modifica manual schema bazei de date, EF Core generează automat
scripturi SQL care aplică schimbările necesare. De exemplu, dacă entitatea Task este modificată
prin adăugarea unui nou câmp Prioritate, o migrație va genera instrucțiunile SQL corespunzătoare
pentru a adăuga coloana respectivă în tabelul din SQLite. Migrațiile asigură consistența dintre cod
și baza de date și oferă posibilitatea de a reveni la versiuni anterioare ale schemei, facilitând astfel
procesul de dezvoltare și testare.​
​ Fluxul tipic de lucru în stratul de date este următorul: interfața (Blazor) transmite datele
către stratul de servicii, acesta le procesează și apelează metodele definite în DbContext. Datele
sunt apoi mapate pe entități și persistate în baza de date SQLite. În sens invers, atunci când
utilizatorul solicită afișarea sarcinilor, DbContext interoghează baza, transformă rezultatele în
obiecte Task, iar acestea sunt trimise mai departe spre interfață.

11
 Avantaje ale stratului de date cu EF Core și SQLite:

1.​ Dezvoltatorul lucrează cu entități C#;

2.​ Baza de date SQLite poate fi înlocuită ușor cu SQL Server sau PostgreSQL;
3.​ Evoluție controlată – migrațiile permit actualizarea treptată a schemei bazei de date;
4.​ Integrare fluidă – DbContext asigură un flux clar între aplicație și date.

Stratul de date construit pe baza DbContext, a entităților și a migrațiilor reprezintă

fundamentul pe care se sprijină aplicația. El garantează persistența și consistența datelor, asigurând
o punte sigură și flexibilă între logica aplicației și infrastructura de stocare.

2.4 SERVICIUL DE E-MAIL

În cadrul aplicației dezvoltate pe platforma Blazor, cu .NET Entity Framework Core

și SQLite, serviciul Mail Sender joacă un rol esențial în asigurarea comunicării eficiente între
aplicație și utilizatori. Acesta este un modul integrat, responsabil de trimiterea automată sau
manuală a mesajelor de tip e-mail, fie că este vorba despre notificări, confirmări de cont,
rapoarte generate de sistem sau mesaje personalizate.

Funcționalități principale:

1.​ Trimitere e-mailuri tranzacționale;

2.​ Notificări automate;
3.​ Mesaje personalizate;
4.​ Jurnalizare e-mailuri;
5.​ Sistem de coadă (queue);
6.​ Integrarea cu Entity Framework Core.

Serviciul este conectat la baza de date SQLite prin intermediul Entity Framework
Core, unde sunt gestionate informații precum:

1.​ destinatarii mesajelor;

2.​ statusul trimiterii (reuşit/eșuat);
3.​ data și ora expediției;

12
 4.​ șabloanele utilizate pentru compunerea mesajelor.

Această abordare permite o monitorizare centralizată și o administrare eficientă a

tuturor comunicărilor efectuate prin aplicație.

Beneficii:

1.​ Fiecare mesaj trimis este înregistrat, astfel încât administratorii pot verifica istoricul
comunicărilor;
2.​ Serviciul poate fi extins cu suport pentru mai multe servere SMTP sau integrat cu
servicii cloud (SendGrid, Mailgun, Amazon SES);
3.​ Se pot defini reguli pentru trimiterea automată a mesajelor pe baza evenimentelor din
sistem;
4.​ Prin interfața Blazor, administratorii pot configura rapid parametrii de trimitere
(SMTP, port, autentificare) și pot gestiona șabloanele de e-mail;​

Considerații de securitate
Pentru protejarea datelor, autentificarea SMTP se face cu parole criptate, iar conținutul
mesajelor poate fi securizat prin protocoale TLS/SSL. De asemenea, accesul la modulul Mail
Sender este restricționat doar utilizatorilor cu drepturi administrative.

2.5 FLUX DE FUNCȚIONARE

Fluxul de funcționare al unui site dezvoltat pe arhitectura stratificată cu Blazor se bazează pe

o succesiune logică de interacțiuni între utilizator și aplicație, care trec prin straturile de Prezentare
(UI), Servicii și Business Logic, și Date (DB Context, Entități, Migrații). Acest flux asigură atât o
experiență interactivă pentru utilizator, cât și o procesare corectă și sigură a datelor.
Procesul începe cu interacțiunea utilizatorului în interfața Blazor – de exemplu, prin completarea
unui formular, apăsarea unui buton sau navigarea între pagini. Evenimentul generat este preluat de
componenta UI, care invocă metode din stratul de servicii. În acest punct, stratul de Business Logic
verifică regulile aplicației (validări, calcule, filtre) și decide cum trebuie gestionată cererea. Dacă
este necesară accesarea bazei de date, logica de business apelează stratul de date prin intermediul
DbContext din Entity Framework Core.

13
 În stratul de date, entitățile definesc structura obiectelor ce corespund tabelelor din baza de
date, iar DbContext gestionează tranzacțiile și maparea obiect-relatională (ORM). Dacă există
modificări în structură, acestea sunt propagate prin migrații, care actualizează schema bazei de date
fără a pierde informațiile existente. Rezultatul interogării sau al operației (de exemplu, salvarea unui
nou client) este trimis înapoi către stratul de servicii, unde este prelucrat și pregătit pentru a fi afișat
utilizatorului.
În final, datele revin la stratul de prezentare, unde componenta Blazor actualizează interfața
în timp real, fără a reîncărca întreaga pagină, datorită mecanismului de renderizare reactivă. Astfel,
fluxul de funcționare al aplicației este unul bidirecțional: utilizatorul trimite acțiuni, aplicația le
procesează prin straturile sale, iar rezultatul este redat instantaneu în interfață.
Această abordare stratificată asigură separarea responsabilităților, ceea ce face sistemul mai ușor de
întreținut, extins și testat. În plus, fluxul este scalabil și poate integra servicii suplimentare, cum ar fi
autentificare, notificări sau procesare în cloud.

2.6 CONSIDERAȚII DE SECURITATE

Un site construit pe tehnologia Blazor și pe o arhitectură stratificată (Prezentare, Servicii &

Business Logic, Date) trebuie să fie proiectat ținând cont de un set clar de măsuri de securitate,
deoarece aplicațiile web sunt expuse permanent la atacuri și riscuri. Lipsa unor politici de securitate
bine definite poate conduce la pierderea datelor, compromiterea confidențialității utilizatorilor sau
chiar la întreruperea serviciului.
În primul rând, securitatea trebuie abordată în stratul de prezentare (UI). Deoarece interfața
este punctul principal de contact cu utilizatorul, trebuie implementate mecanisme de autentificare și
autorizare. Blazor oferă suport pentru Identity și integrare cu OAuth2, OpenID Connect sau alți
furnizori de autentificare externă (Google, Microsoft, Facebook). Autentificarea garantează că doar
utilizatorii legitimi au acces la site, iar autorizarea asigură faptul că fiecare utilizator poate accesa
doar resursele permise de rolul său. Tot aici, se aplică și măsuri de prevenire împotriva atacurilor de
tip Cross-Site Scripting (XSS) prin validarea și filtrarea inputului utilizatorilor.
În stratul de servicii și Business Logic, securitatea se concentrează pe protejarea regulilor
aplicației și a datelor procesate. Este recomandată folosirea validărilor suplimentare la nivel de
servicii, chiar dacă acestea există deja în interfață, pentru a preveni tentativele de manipulare a
cererilor prin instrumente externe. De asemenea, logica de business trebuie să fie rezistentă la
atacuri de tip Injection (SQL Injection, Command Injection), prin utilizarea exclusivă a
interogărilor parametrizate și a ORM-ului (Entity Framework Core).

14
 În stratul de date, accentul cade pe protecția bazei de date și a tranzacțiilor. Este important să
se aplice principiul Least Privilege, oferind aplicației doar permisiunile strict necesare. De
asemenea, trebuie configurată criptarea datelor sensibile (ex. parole, date bancare), atât în tranzit
(prin TLS/HTTPS), cât și la nivel de stocare. Migrațiile trebuie gestionate cu grijă pentru a preveni
pierderile de informații și pentru a evita expunerea accidentală a schemelor interne.
Un alt aspect important îl reprezintă gestionarea sesiunilor și token-urilor de autentificare.
Acestea trebuie să aibă un timp limitat de viață, să fie stocate în siguranță (de preferat în cookies
protejate cu flag-urile HttpOnly și Secure) și reînnoite periodic pentru a reduce riscul de furt de
identitate.
Nu în ultimul rând, trebuie implementate măsuri de monitorizare și audit. Logarea acțiunilor
utilizatorilor și a evenimentelor critice (login eșuat, acces neautorizat, modificări ale datelor) este
esențială pentru detectarea tentativelor de atac și pentru reacții rapide.
Prin urmare, considerațiile de securitate pentru un site realizat cu Blazor se bazează pe o
combinație de practici: autentificare și autorizare robustă, validare multiplă a datelor, criptare,
gestionarea responsabilă a permisiunilor și monitorizare constantă. Aceste măsuri integrate pe toate
straturile arhitecturii garantează un nivel ridicat de protecție și încredere pentru utilizatori.

2.7 CONTAINERIZAREA CU DOCKER

Containerizarea cu Docker reprezintă o soluție modernă și eficientă pentru dezvoltarea,

distribuirea și rularea aplicațiilor web, inclusiv a unui site realizat cu Blazor, Entity Framework
Core și o bază de date SQLite. Conceptul de containerizare presupune ambalarea aplicației
împreună cu toate dependențele sale (framework-uri, librării, runtime, configurări) într-o unitate
izolată, numită container, care poate fi rulată pe orice mediu compatibil Docker, indiferent de
sistemul de operare sau configurația mașinii gazdă.
Un avantaj major al folosirii Docker pentru un astfel de site este portabilitatea. Odată
construită imaginea Docker, aplicația Blazor poate fi distribuită și rulată pe diverse servere sau în
cloud (AWS, Azure, Google Cloud) fără a necesita instalarea manuală a SDK-ului .NET sau
configurări suplimentare. Aceasta reduce riscul erorilor de compatibilitate între mediul de
dezvoltare și cel de producție, eliminând celebrul „merge la mine, dar nu merge la tine”.
Un alt beneficiu este izolarea mediului de execuție. Fiecare container rulează independent,
ceea ce înseamnă că mai multe versiuni ale aceleiași aplicații sau chiar aplicații diferite pot fi rulate
pe același server, fără conflicte. În cazul aplicației Blazor, aceasta poate rula într-un container
separat de cel care găzduiește baza de date SQLite sau de alte servicii auxiliare.

15
 Procesul de containerizare presupune scrierea unui fișier Dockerfile, unde se definesc pașii
necesari pentru a construi imaginea aplicației: alegerea unei imagini de bază (ex.
[Link]/dotnet/aspnet:8.0 pentru rularea aplicației Blazor), copierea codului sursă,
restaurarea dependențelor, compilarea și expunerea portului pe care aplicația ascultă. Ulterior,
imaginea rezultată poate fi rulată ca un container folosind comenzi simple, precum docker run.
Pentru aplicațiile mai complexe, care implică mai multe componente, se utilizează Docker
Compose, un instrument ce permite definirea și gestionarea mai multor containere într-un singur
fișier YAML. De exemplu, site-ul Blazor poate rula într-un container, baza de date SQLite sau un
alt sistem de baze de date (ex. PostgreSQL, SQL Server) într-un alt container, iar serviciile
suplimentare (monitorizare, caching) în altele. Acestea comunică între ele prin rețele Docker
interne, asigurând o arhitectură modulară și ușor de scalat.
Un alt aspect important este scalabilitatea. Dacă aplicația este distribuită pe mai mulți
utilizatori sau se așteaptă trafic ridicat, containerele Docker pot fi orchestrate cu Kubernetes sau alte
platforme similare, pentru a crea instanțe multiple ale aplicației și a le distribui eficient în funcție de
sarcină.
În concluzie, containerizarea cu Docker aduce beneficii majore pentru dezvoltarea și
implementarea unui site construit cu Blazor: portabilitate, izolare, consistență între medii, ușurință
în configurare și scalabilitate. Aceasta transformă procesul de livrare a aplicației într-un flux mult
mai rapid, mai sigur și mai predictibil, facilitând atât dezvoltarea locală, cât și implementarea în
producție.

II REALIZAREA APLICAȚIEI

[Link]ȚE GENERALE CĂTRE FUNCȚIONAREA APLICAȚIEI

Pentru dezvoltarea aplicației Task Manager Minimal, echipa și-a propus respectarea unui set
de cerințe generale care să asigure atât funcționalitatea de bază, cât și extinderea ulterioară a
proiectului. Aceste cerințe au fost stabilite în faza de proiectare și au fost implementate treptat pe
parcursul dezvoltării aplicației.
În primul rând, a fost necesară implementarea operațiilor CRUD (Create, Read, Update,
Delete) pentru gestionarea sarcinilor. Am creat posibilitatea de a adăuga un nou task printr-un
formular simplu, de a afișa lista de activități existente, de a modifica detaliile unei sarcini deja
introduse și de a șterge sarcinile care nu mai sunt relevante. Aceste operații reprezintă nucleul

16
aplicației și au fost implementate prin integrarea componentelor Blazor cu logica de business și
baza de date SQLite.
Un al doilea obiectiv a fost introducerea posibilității de a seta statusul sarcinilor. Fiecare task
poate fi marcat ca „În lucru” sau „Finalizat”, iar această informație este salvată în baza de date și
actualizată în timp real în interfață. Pentru o mai bună organizare, am adăugat și o funcționalitate de
filtrare, astfel încât utilizatorul poate alege să vizualizeze doar sarcinile aflate în lucru, doar pe cele
finalizate sau întreaga listă.
Pe lângă cerințele funcționale, am urmărit și respectarea unor cerințe de utilizabilitate.
Interfața trebuia să fie minimalistă, intuitivă și rapid de folosit, fără elemente grafice inutile. În
acest sens, am proiectat o structură simplă, în care partea de sus conține formularul pentru
introducerea sarcinilor, iar zona centrală afișează lista activităților. Am folosit CSS de bază pentru a
păstra o prezentare clară și compatibilă cu diverse rezoluții.
Din punct de vedere al arhitecturii, aplicația a fost gândită în mod stratificat, conform
cerințelor inițiale. Am separat clar stratul de prezentare (UI Blazor), stratul de servicii și business
logic și stratul de date (Entity Framework Core + SQLite). Această separare ne-a permis să
menținem codul modular și ușor de extins. De exemplu, în viitor se poate înlocui SQLite cu SQL
Server fără a modifica interfața sau logica aplicației.
Un alt set de cerințe a vizat securitatea și consistența datelor. Chiar dacă aplicația nu include
încă autentificare și autorizare, am validat datele introduse de utilizatori și am tratat corect
operațiile CRUD pentru a preveni erorile sau pierderile de informații. Totodată, arhitectura este
pregătită pentru a integra un sistem de autentificare bazat pe Identity, în cazul în care aplicația va fi
extinsă.
Extensibilitatea a reprezentat o altă cerință importantă. Pe lângă funcțiile de bază, am
planificat integrarea unui serviciu de trimitere e-mail pentru notificări și confirmări. De asemenea,
aplicația a fost pregătită pentru containerizare cu Docker, ceea ce ne permite să rulăm proiectul în
medii diferite fără configurări suplimentare și să îl integrăm ușor într-un flux DevOps sau într-un
pipeline CI/CD.

1.1 STRAT DE PREZENTARE (UI BLAZOR)

Stratul de prezentare al aplicației Task Manager Minimal a fost realizat folosind tehnologia
Blazor Server, care ne-a permis să dezvoltăm interfața utilizatorului în C# și Razor, fără a depinde
de framework-uri suplimentare de tip JavaScript. Alegerea Blazor a avut ca scop menținerea unui

17
cod unificat pe partea de interfață și logică, ceea ce a simplificat dezvoltarea și mentenanța
proiectului.

Interfața a fost structurată pe componente Blazor (.razor), fiecare responsabilă pentru o

anumită funcționalitate. Astfel, am creat o componentă pentru formularul de adăugare a unei
sarcini, unde utilizatorul introduce titlul și descrierea, o altă componentă a fost realizată pentru lista
de sarcini, unde sunt afișate toate taskurile existente, în cadrul listei, fiecare sarcină are butoane
dedicate pentru editare, ștergere sau schimbarea statusului („În lucru” / „Finalizat”).

Pentru afișarea și actualizarea datelor, am folosit data binding bidirecțional, astfel încât
atunci când utilizatorul introduce sau modifică informații în formular, acestea sunt reflectate
imediat în modelul de date. În același timp, modificările operate asupra bazei de date prin
intermediul Entity Framework Core sunt vizibile instantaneu în interfață, fără reîncărcarea paginii.

De asemenea, a fost implementată o funcționalitate de filtrare care permite afișarea

taskurilor în funcție de status. Aceasta a fost realizată printr-un dropdown select, unde utilizatorul
poate alege între „Toate”, „În lucru” sau „Finalizate”. Lista de sarcini se actualizează automat în
funcție de opțiunea selectată.

Din punct de vedere vizual, ne-am propus o interfață minimalistă și ușor de utilizat. Am
folosit un design simplu, fără elemente grafice complexe, pentru a pune accentul pe funcționalitate
și claritate. Layout-ul principal include un meniu de navigare, un formular de adăugare și o zonă
centrală unde se afișează lista sarcinilor. Pentru stilizare s-a utilizat CSS clasic, integrat direct în
Blazor, ceea ce asigură compatibilitate cu diferite rezoluții și dispozitive.

Un alt avantaj oferit de Blazor Server este actualizarea în timp real a interfeței prin
intermediul SignalR. Acest mecanism a fost exploatat pentru a asigura o experiență interactivă
fluidă: atunci când un utilizator adaugă sau finalizează o sarcină, lista este actualizată instantaneu,
fără refresh-uri vizibile.

Stratul de prezentare a fost construit pentru a oferi utilizatorilor o experiență simplă,

intuitivă și reactivă. Prin împărțirea pe componente, folosirea data binding-ului și implementarea
unor funcții precum filtrarea și actualizarea statusului, aplicația permite gestionarea rapidă și
eficientă a sarcinilor zilnice, respectând totodată principiile de simplitate și modularitate care au stat
la baza proiectului.

18
1.1.1 Principii de proiectare a interfeței

La proiectarea stratului de prezentare, s-au avut în vedere mai multe principii fundamentale:

1.​ Interfața trebuie să fie intuitivă și să nu supraîncarce utilizatorul cu elemente inutile.

2.​ Aplicația trebuie să fie ușor utilizabilă de persoane cu diferite niveluri de competență
tehnologică.
3.​ UI trebuie să se adapteze la diferite dimensiuni de ecran (desktop, tabletă, telefon).
4.​ Utilizatorul trebuie să primească răspuns vizual pentru acțiunile efectuate (ex. adăugarea
unei sarcini).

1.1.2 Beneficii aduse de Blazor

1.​ Unificarea codului: același limbaj (C#) atât pentru UI, cât și pentru logică.
2.​ Componentizare: interfața este împărțită în componente reutilizabile.
3.​ Performanță: Blazor WebAssembly rulează direct în browser.
4.​ Integrare facilă: comunicare simplă cu API-urile backend.​

Exemplu de scenariu de utilizare

Un utilizator intră în aplicație, vizualizează sarcinile sale zilnice într-un panou central, aplică
un filtru pentru a vedea doar cele urgente și adaugă rapid o nouă sarcină prin formularul din
interfață. Toate aceste acțiuni sunt gestionate instant, fără reîncărcarea paginii, datorită
mecanismelor de data binding Blazor.

1.1.3 Exemplu simplu de componentă Blazor pentru afișarea și adăugarea unei sarcini

<h3>Lista sarcinilor</h3>

<ul>

@foreach (var task in Tasks)

<li>

<b>@[Link]</b> - @[Link]()

<span style="color:@([Link] ? "green" : "red")">

19
 (@([Link] ? "Finalizat" : "În desfășurare"))

</span>

</li>

</ul>

<h4>Adaugă o sarcină nouă</h4>

<input @bind="newTaskTitle" placeholder="Titlu sarcină" />

<input type="date" @bind="newTaskDate" />

<button @onclick="AddTask">Adaugă</button>

@code {

private List<TaskModel> Tasks = new();

private string newTaskTitle;

private DateTime newTaskDate = [Link];

private void AddTask()

if ()

[Link](new TaskModel

Title = newTaskTitle,

DueDate = newTaskDate,

IsCompleted = false

});

newTaskTitle = [Link];

public class TaskModel

20
 {

public string Title { get; set; }

public DateTime DueDate { get; set; }

public bool IsCompleted { get; set; }

1.2 STRAT DE SERVICII ȘI BUSINESS LOGIC

Stratul de servicii și business logic reprezintă legătura dintre interfața utilizatorului și baza
de date, având rolul de a implementa regulile de funcționare ale aplicației. În cadrul proiectului
Task Manager Minimal, acest strat a fost responsabil pentru gestionarea corectă a operațiilor asupra
sarcinilor și pentru validarea datelor introduse de utilizatori.

Pentru a păstra arhitectura curată și modulară, am separat logica aplicației în servicii

dedicate, care sunt apelate din componentele Blazor. Aceste servicii expun metode clare pentru
operațiile principale:

1.​ Adăugarea unui task – înainte de salvare, se verifică dacă titlul sarcinii nu este gol și dacă
informațiile introduse respectă regulile de validare;
2.​ Editarea unui task – serviciul actualizează în baza de date titlul, descrierea și statusul,
asigurând consistența datelor;
3.​ Ștergerea unui task – logica se ocupă de eliminarea corectă a înregistrării, astfel încât să nu
rămână date orfane;
4.​ Schimbarea statusului – atunci când un task este marcat ca „Finalizat” sau „În lucru”,
serviciul actualizează starea acestuia și notifică interfața pentru reîmprospătarea listei;
5.​ Filtrarea sarcinilor – am implementat metode care returnează lista de taskuri în funcție de
criteriul selectat de utilizator („Toate”, „În lucru”, „Finalizate”).

Un aspect important a fost implementarea validărilor la nivel de business logic, și nu doar în

interfață. De exemplu, chiar dacă utilizatorul încearcă să ocolească formularul, serviciul verifică din
nou ca sarcina să aibă un titlu valid înainte de a fi salvată. Această abordare previne introducerea
datelor corupte și sporește securitatea aplicației.

21
 Pentru gestionarea datelor, serviciile comunică cu Entity Framework Core și baza de date
SQLite. Interfața nu accesează direct DbContext-ul, ci trimite cererile către servicii, care se ocupă
de maparea obiectelor și de executarea operațiilor. Această separare face ca aplicația să fie mai ușor
de extins: dacă în viitor se dorește schimbarea tipului de bază de date sau integrarea unui API
extern, modificările vor fi făcute doar la nivelul serviciilor, fără a afecta UI-ul.

Stratul de servicii are și rolul de a facilita extensibilitatea aplicației. De exemplu, am pregătit

structura pentru integrarea unui serviciu de e-mail. Acesta poate fi folosit pentru notificări automate
(de tip „task aproape de deadline” sau „task finalizat”) fără a modifica logica principală a aplicației.
Tot aici poate fi adăugată în viitor și funcționalitatea de autentificare, prin implementarea unui
serviciu dedicat gestionării utilizatorilor și rolurilor.

Stratul de servicii și business logic din Task Manager Minimal asigură respectarea regulilor
aplicației și coordonarea corectă a fluxului de date între interfață și baza de date. El oferă validări
suplimentare, separă clar responsabilitățile și face posibilă extinderea aplicației cu funcționalități
noi, fără a compromite structura existentă. Astfel, acest strat reprezintă fundamentul care garantează
consistența și fiabilitatea întregului sistem.

1.2.1 Flux de date între UI și servicii

1.​ Utilizatorul adaugă o sarcină prin UI;

2.​ UI trimite datele către TaskService;
3.​ TaskService validează sarcina și o transmite mai departe către stratul de date;
4.​ Răspunsul (success/fail) este returnat către UI și afișat utilizatorului.​

1.2.2 Avantajele separării logicii de business

1.​ Claritate și modularitate: codul este mai ușor de întreținut;

2.​ Testabilitate: serviciile pot fi testate independent;
3.​ Extensibilitate: ușor de adăugat funcționalități noi fără a afecta interfața;
4.​ Reutilizare: aceleași servicii pot fi folosite și într-o aplicație mobilă sau desktop.​

Exemplu de scenariu de utilizare

22
 Un utilizator setează o sarcină cu termen pentru ziua următoare. TaskService verifică
validitatea termenului și salvează sarcina în baza de date. În paralel, NotificationService adaugă
această sarcină în lista celor ce necesită remindere, iar a doua zi trimite o notificare prin UI sau
e-mail.

1.2.3 Exemplu simplu de serviciu pentru gestionarea sarcinilor, scris în C#:

public class Task

{
public int Id { get; set; }
public string Title { get; set; }
public DateTime DueDate { get; set; }
public bool IsCompleted { get; set; }
}

public interface ITaskService

{
IEnumerable<Task> GetAllTasks();
Task GetTaskById(int id);
void AddTask(Task task);
void CompleteTask(int id);
IEnumerable<Task> GetUpcomingTasks();
}

public class TaskService : ITaskService

{
private readonly List<Task> _tasks = new();

public IEnumerable<Task> GetAllTasks() => _tasks;

public Task GetTaskById(int id) => _tasks.FirstOrDefault(t => [Link] == id);

public void AddTask(Task task)

{
if ([Link]([Link]))
throw new ArgumentException("Titlul nu poate fi gol.");

if ([Link] < [Link])

throw new ArgumentException("Data nu poate fi în trecut.");

[Link] = _tasks.Count + 1;
_tasks.Add(task);
}

public void CompleteTask(int id)

{
var task = GetTaskById(id);

23
 if (task != null)
[Link] = true;
}

public IEnumerable<Task> GetUpcomingTasks() =>

_tasks.Where(t => [Link] <= [Link](2) && ![Link]);
}

1.3 STRAT DE DATE (DB CONTEXT, ENTITĂȚI, MIGRAȚII)

Stratul de date al aplicației Task Manager Minimal este responsabil pentru gestionarea
persistenței informațiilor și pentru menținerea consistenței acestora. Implementarea s-a realizat
folosind Entity Framework Core (EF Core) ca ORM și SQLite ca sistem de gestiune a bazei de
date. Alegerea SQLite a fost făcută datorită simplității de configurare, a portabilității și a faptului că
baza de date este stocată într-un singur fișier, ceea ce o face ideală pentru proiecte educaționale și
aplicații de dimensiuni reduse.
La baza stratului de date se află clasa DbContext, care gestionează conexiunea cu baza și
expune colecții de tip DbSet. În cadrul proiectului am definit un TaskDbContext, ce conține un
DbSet<TaskItem>. Acesta reprezintă tabelul principal al aplicației, în care sunt stocate toate
sarcinile introduse de utilizatori.
Entitățile definesc structura obiectelor ce urmează să fie mapate în tabele. Pentru aplicația
noastră, am creat entitatea TaskItem, care conține următoarele câmpuri:
-​ Id, care este un identificator unic al sarcinii, setat ca cheie primară;
-​ Titlu, ce reprezintă titlul sarcinii, obligatoriu;
-​ Descriere, detalii suplimentare privind activitatea;
-​ DataCrearii, momentul în care taskul a fost adăugat;
-​ EsteFinalizat, câmp boolean care marchează statusul sarcinii.
Această structură a fost aleasă pentru a răspunde cerințelor de bază, dar poate fi extinsă
ulterior prin adăugarea de câmpuri suplimentare (ex. prioritate, termen limită, utilizator asociat).
Pentru gestionarea evoluției bazei de date am folosit mecanismul de migrații al EF Core. La
fiecare modificare a entităților (ex. adăugarea unui nou câmp), am generat o migrație care
actualizează schema bazei de date. Acest proces ne-a permis să păstrăm consistența dintre cod și
baza de date fără a fi nevoie să scriem manual interogări SQL. De exemplu, în momentul adăugării
câmpului DataCrearii, migrația a creat automat coloana corespunzătoare în tabelul SQLite.

24
 Fluxul de lucru al stratului de date este simplu și clar: atunci când utilizatorul introduce o
nouă sarcină din interfață, datele sunt trimise către stratul de servicii, care apelează metodele
definite în DbContext. Entitățile sunt mapate la nivel de obiecte C#, iar EF Core le transformă
automat în instrucțiuni SQL ce actualizează baza SQLite. La interogări, procesul se desfășoară
invers: datele sunt preluate din tabel și transformate în obiecte TaskItem, care apoi sunt afișate în
interfața Blazor.
Stratul de date din Task Manager Minimal oferă un mecanism robust și simplificat pentru
gestionarea informațiilor. Prin utilizarea EF Core și a migrațiilor, aplicația rămâne flexibilă, ușor de
întreținut și pregătită pentru extindere, atât la nivelul entităților, cât și prin migrarea către alte tipuri
de baze de date mai complexe.

1.3.1 Principii de proiectare a stratului de date

1.​ Fiecare entitate reflectă un concept din domeniul aplicației (Task, Category, User);
2.​ Relațiile dintre entități (one-to-many, many-to-many) sunt configurate clar în model;
3.​ Baza de date evoluează odată cu aplicația, folosind mecanisme automate de migrare;
4.​ Utilizarea indexurilor și a lazy loading pentru performanță crescută.

1.3.2 Exemple:

Entități principale

Entitatea TaskEntity

Reprezintă sarcina creată de [Link] class TaskEntity

public int Id { get; set; }

public string Title { get; set; }

public string Description { get; set; }

public DateTime DueDate { get; set; }

public bool IsCompleted { get; set; }

25
 // Relație cu categoria

public int CategoryId { get; set; }

public CategoryEntity Category { get; set; }

// Relație cu utilizatorul

public int UserId { get; set; }

public UserEntity User { get; set; }

Entitatea CategoryEntity

Gruparea sarcinilor pe categorii.

public class CategoryEntity

public int Id { get; set; }

public string Name { get; set; }

// O categorie poate avea mai multe sarcini

public ICollection<TaskEntity> Tasks { get; set; }

Entitatea UserEntity

Gestionarea utilizatorilor aplicației.

public class UserEntity

public int Id { get; set; }

public string Username { get; set; }

public string Email { get; set; }

26
 // Un utilizator are mai multe sarcini

public ICollection<TaskEntity> Tasks { get; set; }

DB Context și configurare

DB Context este clasa centrală care gestionează comunicarea cu baza de date.

public class AppDbContext : DbContext

public DbSet<TaskEntity> Tasks { get; set; }

public DbSet<CategoryEntity> Categories { get; set; }

public DbSet<UserEntity> Users { get; set; }

public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

protected override void OnModelCreating(ModelBuilder modelBuilder)

[Link]<TaskEntity>()

.HasOne(t => [Link])

.WithMany(c => [Link])

.HasForeignKey(t => [Link]);

[Link]<TaskEntity>()

.HasOne(t => [Link])

.WithMany(u => [Link])

.HasForeignKey(t => [Link]);

27
Migrații și evoluția bazei de date

Add-Migration InitialCreate

Update-Database

1.3.3 Beneficii ale stratului de date

-​ Claritate și ușurință în lucrul cu date complexe;

-​ Migrații automate care elimină nevoia de scripturi SQL manuale;
-​ Integrare nativă cu servicii și UI;
-​ Flexibilitate în alegerea motorului de baze de date.

1.4 SERVICIUL DE E-MAIL

Serviciul de e-mail adaugă o funcționalitate critică pentru aplicația de gestionare a

sarcinilor: posibilitatea de a notifica utilizatorii prin mesaje automate. Astfel, aplicația devine mai
interactivă și mai utilă, reamintind utilizatorilor de sarcinile importante și menținându-le
productivitatea.

1.4.1 Rolul serviciului de e-mail

1.​ Reminder pentru sarcini: trimiterea de notificări pentru sarcinile apropiate de termen;
2.​ Confirmare și activare cont: dacă aplicația gestionează utilizatori cu autentificare;
3.​ Rapoarte periodice: trimiterea unui rezumat al activităților săptămânale/lunare;
4.​ Notificări personalizate: în funcție de preferințele utilizatorului.

1.4.2 Principii de implementare

1.​ Serviciul de e-mail trebuie să fie independent și reutilizabil;

2.​ Datele de autentificare SMTP sunt stocate în fișiere securizate ([Link]);
3.​ Posibilitatea de a schimba providerul (Gmail, Outlook, SendGrid);
4.​ Trimiterea mesajelor se face asincron, pentru a nu bloca aplicația.

Configurare în [Link]

28
{

"EmailSettings": {

"SmtpServer": "[Link]",

"Port": 587,

"SenderName": "Task Manager App",

"SenderEmail": "taskmanager@[Link]",

"Username": "taskmanager@[Link]",

"Password": "parola_securizata"

Serviciul de e-mail în C#

public class EmailService

private readonly IConfiguration _config;

public EmailService(IConfiguration config)

_config = config;

public async Task SendEmailAsync(string to, string subject, string body)

var smtpServer = _config["EmailSettings:SmtpServer"];

var port = [Link](_config["EmailSettings:Port"]);

var username = _config["EmailSettings:Username"];

var password = _config["EmailSettings:Password"];

var from = _config["EmailSettings:SenderEmail"];

using var client = new SmtpClient(smtpServer, port)

29
 {

Credentials = new NetworkCredential(username, password),

EnableSsl = true

};

var mailMessage = new MailMessage(from, to, subject, body)

IsBodyHtml = true

};

await [Link](mailMessage);

Exemplu de utilizare a serviciului

public class NotificationService

private readonly EmailService _emailService;

public NotificationService(EmailService emailService)

_emailService = emailService;

public async Task SendTaskReminder(TaskEntity task, string userEmail)

var subject = $"Reminder: {[Link]}";

var body = $"Sarcina ta '{[Link]}' are termen limită la {[Link]}.";

await _emailService.SendEmailAsync(userEmail, subject, body);

30
III TESTAREA APLICAȚIEI

Diagrama Use Case – Autentificare și gestionare cont

Diagrama de Secventa – Trimitere e-mail

31
 Diagrama Use Case – Administrare și monitorizare Docker

CONCLUZIE

Proiectul Task Manager Minimal a demonstrat modul în care poate fi construită o

aplicație web modernă și utilă, pornind de la cerințe simple și folosind tehnologii actuale din
ecosistemul .NET. Scopul principal al acestuia a fost realizarea unui instrument practic, care
să ajute utilizatorii să își organizeze mai bine activitățile zilnice și să își urmărească progresul
într-un mod simplu și intuitiv.

32
 Unul dintre cele mai importante aspecte ale proiectului a fost alegerea tehnologiilor
potrivite. Folosirea Blazor Server a permis dezvoltarea interfeței utilizatorului direct în C#,
fără a fi necesare framework-uri suplimentare bazate pe JavaScript. Acest lucru a făcut ca
aplicația să fie mai ușor de întreținut și de extins, iar experiența de lucru să fie unitară. Entity
Framework Core a simplificat lucrul cu datele și a oferit posibilitatea implementării rapide a
operațiilor de tip CRUD (Create, Read, Update, Delete), esențiale pentru gestionarea
sarcinilor. Alegerea unei baze de date SQLite a adus portabilitate și simplitate, fiind ușor de
configurat și ideală pentru aplicații de dimensiuni mici și medii.

Pe parcursul dezvoltării s-a urmărit respectarea unei arhitecturi stratificate, cu

separarea clară a responsabilităților: stratul de prezentare pentru interfață, stratul de servicii și
business logic pentru regulile aplicației și stratul de date pentru stocarea informațiilor.
Această structură a asigurat claritate, modularitate și posibilitatea de a face modificări sau
adăugiri fără a afecta întreg sistemul. De exemplu, dacă pe viitor se dorește schimbarea
tipului de bază de date sau adăugarea unui sistem de autentificare, acest lucru se poate realiza
fără a rescrie întreaga aplicație.

Funcționalitățile incluse în versiunea actuală răspund nevoilor de bază ale unui

utilizator obișnuit: crearea, editarea și ștergerea sarcinilor, marcarea acestora ca „În lucru” sau
„Finalizat”, precum și filtrarea rapidă după status. Interfața a fost gândită minimalist, astfel
încât aplicația să fie ușor de folosit de către oricine, indiferent de nivelul de experiență
tehnologică. Totodată, proiectul a fost pregătit pentru extinderi viitoare, cum ar fi integrarea
unui serviciu de trimitere notificări prin e-mail sau implementarea autentificării utilizatorilor.

Un alt punct important al proiectului a fost integrarea containerizării cu Docker, ceea

ce face aplicația portabilă și ușor de implementat pe diferite platforme, fie local, fie în cloud.
Această abordare permite includerea proiectului într-un flux DevOps sau într-un pipeline
CI/CD, ceea ce îl face potrivit și pentru scenarii profesionale, nu doar educaționale.

Prin realizarea acestui proiect, echipa a reușit să combine partea teoretică, legată de
conceptele de task management și arhitectura în straturi, cu partea practică, concretizată într-o
aplicație funcțională. Rezultatul final este un produs software care îmbină utilitatea practică
cu valoarea educativă. Pe de o parte, aplicația poate fi folosită direct de către utilizatori
pentru organizarea activităților zilnice. Pe de altă parte, ea reprezintă un exemplu de cod

33
reutilizabil și o bază solidă pentru dezvoltarea unor proiecte mai complexe, fiind astfel o
resursă valoroasă pentru viitorii dezvoltatori.

În concluzie, Task Manager Minimal nu este doar un exercițiu tehnic, ci și un model

de bune practici în dezvoltarea software. El arată cum o echipă de studenți poate planifica,
structura și implementa o aplicație completă, respectând principiile de modularitate, claritate
și extensibilitate. Proiectul demonstrează că, prin alegerea corectă a tehnologiilor și printr-o
organizare atentă, se poate obține un rezultat util, simplu de folosit și pregătit pentru
îmbunătățiri viitoare.

BIBLIOGRAFIE
1.​ Microsoft Docs – [Link] Core Blazor documentation.
[Link]
2.​ Microsoft Docs – Entity Framework Core documentation.
[Link]
3.​ SQLite – Official Documentation. Disponibil la: [Link]
4.​ Docker – Get Started Documentation. [Link]
5.​ Fowler, Martin – Patterns of Enterprise Application Architecture. Addison-Wesley,
2002.
6.​ Freeman, Adam; Sanderson, Steve – Pro [Link] Core 8: MVC, Blazor, and Razor
Pages for C# Developers. Apress, 2024.
7.​ Todoist – The Ultimate Guide to Task Management.
[Link]
8.​ Trello – How to Use Trello for Task Management. [Link]
9.​ Microsoft To Do – Official Overview. [Link]

34