Sari la conținutul principal

Laborator 4 - server web

In cadrul acestui laborator vom implementa un server web care sa poata fi extins pentru diverse proiecte. Serverul va implementa paradigma MVC (Model-View-Controller), acest lucru inseamna ca avem trei tipuri de componente in aplicatie pentru a afisa pagina utilizatorilor:

  • Model - sunt structurile de date care contin inforamatiile ce trebuie afisate. Acestea sunt de obicei obiecte de transfer de date (data transfer objects), obiecte ce traiesc liber fata de sistemul de persistenta (ex. baza de date) si sunt folosite pentru transferul de informatii intre diferite componente.
  • View - sunt sabloane pentru pagini sau componente folosite in pagini web asociate cu un model si un endpoint al unui controller. Un view este un fisier .cshtml cu o sintaxa extinsa a HTML prin care putem obtine modifica HTML-ul rezultat folosind datele din model.
  • Controller - reprezinta o colectie de endpoint-uri care returneaza paginile web. Controller-ul preia un model si populeaza un view cu datele din model dupa care il proceseaza si il transforma intr-o pagina HTML.

Un server MVC este o aplicatie de tip MPA (Multi-Page Application), adica pentru fiecare URI serverul proceseaza cererea si trimite cate o pagina separata.

Structura proiectului​

Pentru a initializa proiectul se incepe un proiect nou in .NET 10 de tip Web App (Model-View-Controller). In proiectul nou vor aparea urmatoarele fisiere si directoare:

  • Properties - contine launchSettings.json unde se specifica configuratiile de pornire a serverului, pentru noi este importanta doar configuratia de "http".
  • wwwroot - aici vor sta fisiere servite static cum sunt imagini generale, fisiere CSS sau scripturi in JavaScript.
  • Controllers - contine controller-ele, atunci cand vream sa implementam acces la o resursa cum ar fi utilizatorii vom crea un nou controller care va servi HTML-ul.
  • Models - in acest director vom pune doar modelele, obiectele care populeaza view-urile.
  • Views - contine mai multe directoare, in general va exista cate un director pentru fiecare controller cu view-uri corespunzatoare la fiecare endpoint din controller.

Pe langa aceste fisiere si directoare vom adauga alte directoare care vor contine alte tipuri de componente.

Proiectul, asa cum este initializat, poate fi pornit si va afisa primile pagini dar fara functionalitati. Serverul va avea trei nivele:

  • Persistenta/Date - vom folosi o baza de date, la inceput va fi o baza de date in memorie si apoi vom folosi una reala. Pentru acest lucru vom folosi EntityFramework, ORM-ul (Object-Relational Mapping) de facto din .NET.
  • Logica - va fi compus din componente pe care le numim generic servicii, aceste componente sunt cele care trebuie sa implementeze logica aplicatiei.
  • Prezentare - view-urile si controller-ele constituie acest nivel.

Ca sa pastram o structura modulara vom adauga urmatoarele directoare:

  • Services - vom tine aici componentele de tip serviciu care for implementa majoritatea logicii aplicatiei.
    • Abstractions - aici punem interfetele pentru servicii pe care le vom referentia unde este nevoie in interiorul aplicatiei iar implementarile se vor folosi de aceste abstractizari.
    • Implementations - implementarile de servicii vor implementa interfetele mentionate anterior si vor implementa logica aplicatiei dar nu vor fi referentiate in restul proiectului.
  • Database - vom tine aici obiectele legate la accesul catre baza de date.
    • Entities - aici vom tine entitatile care abstractizeaza tabelele din baza de date.
    • EntityConfiguration - aici vom tine configurarile pentru baza de date.

Implementarea de functionalitati noi​

Vom construi aplicatia de la nivelul de date peste care venim cu nivelul logic si apoi expunem datele prin nivelul de prezentare.

Pentru a incepe dezvoltarea serverului mai intai vom avea nevoie de o baza de date. Pentru moment vom folosi o baza de date in memorie pe care ulterior o vom inlocui cu una reala. Baza de date va fi folosita pentru a mentine starea aplicatiei, adica se vor depozita in aceasta date venite de la clientii serverului si care se pot interoga. Serverul nu doar ca va putea intermedia acest transfer de date dar cu baza de date poate mentine o evidenta a logicii aplicatiei cu persitenta starii acesteia.

Pentru a lucra cu o baza de date vom adauga packetul Microsoft.EntityFrameworkCore.InMemory. EntityFramework este un ORM, acesta realizeaza prin reflectie asocierea claselor si a campurilor din aceasta cu tabelele, respectiv coloanele din baza de date.

Acest pachet ne va furniza primitive pentru a interactiona cu baza de date. Interactiunea se va face printr-un DbContext si cream o clasa care o mosteneste in Database/WebAppDatabaseContext.cs:

WebAppDatabaseContext.cs
public sealed class WebAppDatabaseContext(DbContextOptions<WebAppDatabaseContext> options) : DbContext(options)
{
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
// Partea aceasta va fi importanta pentru configurarea si maparea automata a entitatilor la tabela din baza de date
modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
}
}

Trebuie sa mentionam ca clasele care mostenesc DbContext sunt clienti pentru baza de date si vom interactiona prin acestea cu baza de date.

Pentru a avea si tabele in baza de date vom crea o clasa care reprezinta o tablea pentru utilizatori in Database/Entities/User.cs:

User.cs
public class User
{
public Guid Id { get; set; }
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
public string Email { get; set; } = null!;
}

Aceasta clasa va corespunde la o tabela cu acelasi nume, campurile vor fi asociate cu coloanele iar obiectele for fi intraile din baza de date. Ca sa fie asociate cu tabela vom crea configurari de entitari, pentru User vom implementa configurarea in Database/EntityConfigurations/UserConfiguration.cs

UserConfiguration.cs
public class UserConfiguration : IEntityTypeConfiguration<User>
{
public void Configure(EntityTypeBuilder<User> builder)
{
// Asa declaram o cheie primara intr-o tabela
builder.HasKey(e => e.Id);
builder.Property(e => e.Id).IsRequired();
// Aici declaram coloane de tip text cu lungime maxima si care nu pot fi null
builder.Property(e => e.FirstName).HasMaxLength(255).IsRequired();
builder.Property(e => e.LastName).HasMaxLength(255).IsRequired();
builder.Property(e => e.Email).HasMaxLength(255).IsRequired();
}
}

Ultimul lucru pe care trebuie sa-l facem acum este ca WebAppDatabaseContext sa poata fi folosit prin dependency injection. Functia main din proiect arata initial asa:

Program.cs
public static class Program
{
public static void Main(string[] args)
{
// Se initiaza builder-ul de aplicatie
var builder = WebApplication.CreateBuilder(args);
// Adaugam controller-ele si view-urile
builder.Services.AddControllersWithViews();

// Construim aplicatia si apoi o configuram
var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Home/Error");
app.UseHsts();
}

app.UseHttpsRedirection();
app.UseRouting();

app.UseAuthorization();

app.MapStaticAssets();

app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}")
.WithStaticAssets();

// Pornim aplicatia, acesta metoda va porni serverul care va astepta clienti HTTP care se vor conecta la acesta.
app.Run();
}
}

Vedem ca avem un builder pentru aplicatie prin care putem configura DI-ul. Pentru a adauga WebAppDatabaseContext in DI doar trebuie adaugata urmatoarea linie de cod:

builder.Services.AddDbContext<WebAppDatabaseContext>(e => e.UseInMemoryDatabase("database"));

Avand contextul de baza de date putem acum implementa logica aplicatiei in servicii. Mai intai implementam obiecte de transfer, aceste trebuie sa fie distincte fata de entitatile bazei de date pentru ca nu vrem sa fie legate la baza de date din motive de securitate si respectarea responsabilitatii unice a claselor. Folosim clasele cu responsabilitati specifice, aici obiectele de transfer se ocupa de transportul datelor intre aplicatie si exteriorul acesteia. Cream cate o clasa pentru operatiile de citire, inserare si actualizare a utilizatorilor in Models. Motivul pentru care avem clase diferite pentru fiecare operatie chiar daca sunt foarte similare este ca acestea sa poata fi modificate independent, acestea pot avea independent mai mult sau mai putine campuri.

UserRecord.cs
public class UserRecord
{
public Guid Id { get; set; }
public required string FirstName { get; set; }
public required string LastName { get; set; }
public required string Email { get; set; }
}
UserAddRecord.cs
public class UserRecord
{
public Guid Id { get; set; }
public required string FirstName { get; set; }
public required string LastName { get; set; }
public required string Email { get; set; }
}
UserUpdateRecord.cs
public class UserUpdateRecord
{
// Pentru a trimite aceasta clasa catre server trebuie sa existe un constructor fara parametri
public UserUpdateRecord()
{
}

// Acest constructor va fi folosit pentru a popula cu date obiectul pentru actualizare din date luate de pe server
public UserUpdateRecord(UserRecord record)
{
Id = record.Id;
Email = record.Email;
FirstName = record.FirstName;
LastName = record.LastName;
}

public Guid Id { get; set; }
public string FirstName { get; set; } = null!;
public string LastName { get; set; } = null!;
public string Email { get; set; } = null!;
}

Acum putem crea o interfata pentru serviciul de gestiune a utilizatorilor in Services/Abstractions/IUserService.cs ca operatii CRUD (Create, Read, Update, Delete):

IUserService.cs
public interface IUserService
{
// Citim utilizatorii
public List<UserRecord> GetUsers();
// Adaugam un utilizator
public void AddUser(UserAddRecord user);
// Actualizam un utilizator
public void UpdateUser(UserUpdateRecord user);
// Stergem un utilizator dupa ID
public void DeleteUser(Guid id);
}

Si implementam serviciul folosind contextul de baza de date Services/Implementations/UserService.cs:

UserService.cs
// Implementarea va primi prin DI contextul de baza de date
public class UserService(WebAppDatabaseContext context) : IUserService
{
public List<UserRecord> GetUsers()
{
// Prin Set<User>() avem acces la datele din tabela
// Select efectueaza proiectia si mapeaza datele
return context.Set<User>().Select(e => new UserRecord
{
Id = e.Id,
FirstName = e.FirstName,
LastName = e.LastName,
Email = e.Email
}).ToList();
}

public void AddUser(UserAddRecord user)
{
// Pentru insert in baza de date cream intrarea de tip User
var entry = new User
{
Id = Guid.NewGuid(),
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName
};

// Adaugam intrarea in tabela prin adaugarea intrarii in contextul de baza de date
context.Set<User>().Add(entry);
// Salvam modificarile, fara SaveChanges() nu se vor trimite datele catre baza de date
context.SaveChanges();
}

public void UpdateUser(UserUpdateRecord user)
{
// Pentru update, prima data cautam intrarea din baza de date
var entry = context.Set<User>().FirstOrDefault(e => e.Id == user.Id);
if (entry == null)
{
return;
}

// Actualizam campurile din intrare
entry.FirstName = user.FirstName;
entry.LastName = user.LastName;
entry.Email = user.Email;

// Actualizam intrarea
context.Set<User>().Update(entry);
// Salvam modificarile
context.SaveChanges();
}

public void DeleteUser(Guid id)
{
// Pentru stergere, prima data cautam intrarea din baza de date ca la update
var entry = context.Set<User>().FirstOrDefault(e => e.Id == id);
if (entry == null)
{
return;
}

// Stergem intrarea din context
context.Set<User>().Remove(entry);
// Salvam modificarile
context.SaveChanges();
}
}

Avand serviciul implementat il putem adauga in DI:

builder.Services.AddScoped<IUserService, UserService>();

Acum avem pregatite nivelele de date si logica si mai ramane nivelul de prezentare de implementat. Pentru asta vom crea un controller pentru pagina de utilizatori in Controolers/UserController.cs:

UserController.cs
// Controller-ul trebuie sa mosteneasca clasa Controller si trimitem serviciul prin DI in controller
public class UserController(IUserService userService) : Controller
{
// Declaram o functie decorata cu atributul HttpGet pentru a servi pagina
[HttpGet]
public IActionResult GetUsers()
{
// Luam lista de utilizatori prin serviciu
var users = userService.GetUsers();

// Optional, daca vrem sa avem macar un utilizator la prima citire
if (users.Count == 0)
{
userService.AddUser(new()
{
Email = "test@mail.com",
FirstName = "Test",
LastName = "Test"
});

users = userService.GetUsers();
}

// Functia View va popula view-ul cu modelul nostru si va trimite pagina HTML
return View(users);
}

// Operatiile de modificare de date vor fi decorate cu HttpPost
[HttpPost]
// ValidateAntiForgeryToken va asigura ca o alta aplicatie nu poate timite cereri catre server
[ValidateAntiForgeryToken]
public IActionResult AddUser(UserAddRecord user)
{
// Daca datele primite de la client sunt invalide tratam acest lucru
if (!ModelState.IsValid)
{
// Setam codul de raspuns ca fiind BadRequest
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
// Trimitem cu PartialView componenta cu erorile gasite, de obicei va fi un formular care este un view partial, adica este o componenta si nu o intreaga pagina
return PartialView(user);
}

// Trimitem datele pentru persistare in serviciu
userService.AddUser(user);

// RedirectToAction va trimite catre browser comanda sa ceara din nou pagina de la GetUsers
return RedirectToAction(nameof(GetUsers));
}

// Actualizarea datelor va fi similara cu endpointul precedent
[HttpPost]
[ValidateAntiForgeryToken]
public IActionResult UpdateUser(UserUpdateRecord user)
{
if (!ModelState.IsValid)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.BadRequest;
return PartialView(user);
}

userService.UpdateUser(user);

return RedirectToAction(nameof(GetUsers));

}

// Pentru stergere doar trimitem ID-ul catre serviciu si cerem din nou pagina de utilizatori
[HttpPost]
[ValidateAntiForgeryToken]
public IActionResult DeleteUser(Guid id)
{
userService.DeleteUser(id);

return RedirectToAction(nameof(GetUsers));
}
}

Avand controller-ul si obiectelele de transfer pe post de modele ne mai trebuie si view-urile ca sa afisam datele si sa interactionam cu ele. Mai intai vom adauga cateva biblioteci si fisiere ajutatoare pentru devoltarea interfetei. Vom folosi biblioteca Materialize pentru componente prestilizate, pentru a o folosi adaugam in tagul de head din Views/Shared/_Layout.cshtml urmatoarele linkuri:

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/css/materialize.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/materialize/1.0.0/js/materialize.min.js"></script>

Iar in wwwroot/js/site.js adaugam aceste functii:

document.addEventListener('DOMContentLoaded', function() {
const elems = document.querySelectorAll('.modal');
const instances = M.Modal.init(elems, {});
});

$(document).ready(function(){
$('.modal').modal();
});

$(document).on('submit', 'form.modal-form', function (e) {
e.preventDefault();
const $form = $(this);
const $modalDiv = $form.closest('.modal');

$.ajax({
url: $form.attr('action'),
type: 'POST',
data: $form.serialize(),
success: function (response) {
const instance = M.Modal.getInstance($modalDiv[0]);
if (instance) {
instance.close();
}
location.reload();
},
error: function (xhr) {
// Daca primim componenta cu erori ca modelul este invalid inlocuim HTML-ul
if (xhr.status === 400) {
$modalDiv.html(xhr.responseText);
$.validator.unobtrusive.parse($modalDiv);
const instance = M.Modal.getInstance($modalDiv[0]);
if (instance) {
instance.open();
}
} else {
alert("An unexpected error occurred.");
}
}
});
});

Acum trebuie sa asociem la controller un view-uri facem un director cu acelasi nume Views/User si adaugam un view cu numele endpoint-ului pentru lista de utilizatori:

Users.cshtml
// Cu @model declaram tipul de date pentru modelul ales
@model List<UserRecord>

@{
// Putem declara valori in acest dictionar pentru afisare daca dorim
ViewData["Title"] = "Users";
}
<h1>@ViewData["Title"]</h1>

<div class="card">
<!-- Definim o tabela ca in HTML classic pentru a afisa utilizatorii-->
<table>
<thead>
<tr>
<th>Id</th>
<th>First name</th>
<th>Last name</th>
<th>Email</th>
</tr>
</thead>
<tbody>
<!-- Pentru ca modelul este o lista o putem parcurge si genera HTML pentru fiecare intrare-->
@foreach (var user in Model)
{
<tr>
<td>
@user.Id
</td>
<td>
@user.FirstName
</td>
<td>
@user.LastName
</td>
<td>
@user.Email
</td>
</tr>
}
</tbody>
</table>
</div>

Pentru a putea naviga la pagina aceasta adaugam in bara de naviare o noua intrare in lista din meniul din Views/Shared/_Layout.cshtml:

<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="User" asp-action="GetUsers">Users</a>
</li>

Pornind aplicatia va aparea noua intrare in bara de navigare iar pagina deschisa de aceasta va afisa lista o lista de utilizatori in care putem vedea momentan un singur utilizator.

Ca sa adaugam si actiuni in acesta pagina, cum ar fi butoane de adaugare, actualizare si stergere vom face un view partial pentru butoanele care vor fi inserate in pagina de utilizatori.

Pentru adaugarea de utilizatori facem un fisier Views/Users/AddGetUsers.cshtml:

AddGetUsers.cshtml
@model UserAddRecord

<!--Declaram un formular care va folosi endpointul AddUser din UserController cu methoda Post-->
@using (Html.BeginForm("AddUser", "User", FormMethod.Post, new { @class = "modal-form" }))
{
<!-- Formularul va fi intr-o modal, adica o componenta de tip dialog-->
<div class="modal-content">
<!-- Adaugam si verificarea de AntiForgery-->
@Html.AntiForgeryToken()

<h4>Add User</h4>

<!-- Facem cate un camp pentru fiecare proprietate din UserAddRecord-->
<div class="form-group">
<!-- Adaugam un label-->
@Html.LabelFor(m => m.FirstName)
<!-- Legam valoare dintr-un textbox cu o proprietate-->
@Html.TextBoxFor(m => m.FirstName, new { @class = "form-control" })
<!-- Adaugam validarea pentru acest camp-->
@Html.ValidationMessageFor(m => m.FirstName, "", new { @class = "text-danger" })
</div>

<div class="form-group">
@Html.LabelFor(m => m.LastName)
@Html.TextBoxFor(m => m.LastName, new { @class = "form-control" })
@Html.ValidationMessageFor(m => m.LastName, "", new { @class = "text-danger" })
</div>

<div class="form-group">
@Html.LabelFor(m => m.Email)
@Html.TextBoxFor(m => m.Email, new { @class = "form-control", type = "email" })
@Html.ValidationMessageFor(m => m.Email, "", new { @class = "text-danger" })
</div>
</div>

<div class="modal-footer">
<!-- Declaram butonul de tip submit care sa trimita datele catre server-->
<button type="submit" class="waves-effect waves-green btn">Add</button>
<!-- Adaugam si un buton de anulare-->
<button type="button" class="modal-close waves-effect waves-grey btn-flat">Cancel</button>
</div>
}

Similar, implementam formularul pentru actualizarea utilizatorilor in fisierul Views/Users/UpdateGetUsers.cshtml:

UpdateGetUsers.cshtml
@model UserUpdateRecord

@using (Html.BeginForm("UpdateUser", "User", FormMethod.Post, new { @class = "modal-form" }))
{
<div class="modal-content">
@Html.AntiForgeryToken()
<!-- Pentru ca Id-ul este necesar la actualizare dar nu trebuie sa apara in formular il vom face hidden-->
@Html.HiddenFor(m => m.Id)

<h4>Update User</h4>

<div class="form-group">
@Html.LabelFor(m => m.FirstName)
@Html.TextBoxFor(m => m.FirstName, new { @class = "form-control" })
@Html.ValidationMessageFor(m => m.FirstName, "", new { @class = "text-danger" })
</div>

<div class="form-group">
@Html.LabelFor(m => m.LastName)
@Html.TextBoxFor(m => m.LastName, new { @class = "form-control" })
@Html.ValidationMessageFor(m => m.LastName, "", new { @class = "text-danger" })
</div>

<div class="form-group">
@Html.LabelFor(m => m.Email)
@Html.TextBoxFor(m => m.Email, new { @class = "form-control", type = "email" })
@Html.ValidationMessageFor(m => m.Email, "", new { @class = "text-danger" })
</div>
</div>

<div class="modal-footer">
<button type="submit" class="waves-effect waves-green btn">Update</button>
<button type="button" class="modal-close waves-effect waves-grey btn-flat">Cancel</button>
</div>
}

Pentru a finaliza vom adauga aceste view-uri partiale in pagina de utilizatori in felul urmator:

GetUsers.cshtml
@model List<UserRecord>

@{
ViewData["Title"] = "Users";
}
<h1>@ViewData["Title"]</h1>

<!--Adaugam modala cu un buton care va deschide formularul-->
<a class="waves-effect waves-light btn modal-trigger" href="#modalAddUser">Add User</a>
<div id="modalAddUser" class="modal">
<!-- Aici declaram view-ul partial initializat cu un obiect nou de tip UserAddRecord-->
<partial name="AddUser" model="new UserAddRecord()"/>
</div>

<div class="card">
<table>
<thead>
<tr>
<th>Id</th>
<th>First name</th>
<th>Last name</th>
<th>Email</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
@foreach (var user in Model)
{
<tr>
<td>
@user.Id
</td>
<td>
@user.FirstName
</td>
<td>
@user.LastName
</td>
<td>
@user.Email
</td>
<td>
<!-- Similar, adaugam si modala pentru actualizare, atentie la ID-ul componentei care asigura legatura intre buton si modala, acesta trebuie sa fie unic-->
<a class="waves-effect waves-light btn modal-trigger" href="#modalUpdateUser{@user.Id}">Update User</a>
<div id="modalUpdateUser{@user.Id}" class="modal">
<partial name="UpdateUser" model="new UserUpdateRecord(user)"/>
</div>
<!-- Pentru stergere nu mai cream un view partial, doar il declaram aici pentru cea este initializat doar cu ID-ul intrari care trebuie stearsa-->
@using (Html.BeginForm("DeleteUser", "User", new { id = user.Id }, FormMethod.Post))
{
@Html.AntiForgeryToken()
<button type="submit" class="btn red waves-effect waves-light">Delete</button>
}
</td>
</tr>
}
</tbody>
</table>
</div>

Dupa actualizarile mentionate in pagina de utilizatori trebuie sa apara noile butoane prin care se pot adauga/actualiza/sterge utilizatori.