Posted on Lascia un commento

ASP.NET MVC EMAIL DA SITO E PASSWORD DIMENTICATA

Il nostro sito ha necessità di inviare email ai suoi utenti, per esempio quando l’utente si dimentica la password di accesso. Per fare questo ci viene in soccorso la classe System.Net.Mail.SmtpClient.

Questa classe usa in automatico le impostazioni del smtp server memorizzate nel file Web.config. E’ sufficiente aggiungere a questo file i seguenti tag all’interno del configuration :

<system.net>
 <mailSettings>
 <smtp deliveryMethod="Network" from="mail_from">
 <network host="my_smtp_server" port="my_smtp_server_port" userName="user_name_smtp" password="password" clientDomain="my_domain" />
 </smtp>
 </mailSettings>
 </system.net>

PASSWORD DIMENTICATA

Nella view Account/Login , vedete in basso a sinistra il link a Account/ForgotPassword che è la pagina che permette all’utente il reset della password

Andate nel controller Account, nell’action post chiamata “ForgotPassword” e rendete operative, rimuovendole come commento, le linee di codice dedicate al recupero password.

Andate nel file IdentityConfig.cs, nella funzione

public Task SendAsync(IdentityMessage message)

e sostituite alla riga

return Task.FromResult(0);

le seguenti righe di codice

var sentFrom = "myemail@mydomain.com"
 //
 System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient();
 //
 client.EnableSsl = false;

// Create the message:
 var mail =
 new System.Net.Mail.MailMessage(sentFrom, message.Destination);

mail.Subject = message.Subject;
 mail.Body = message.Body;
 mail.IsBodyHtml = true;

// Send:
 return client.SendMailAsync(mail);

Avete attivato il recupero password

Posted on Lascia un commento

ASP.NET MVC: Risolvere i problemi di jQuery UI per Datapicker

In questo articolo spiegheremo come risolvere i problemi nell’utilizzo del Datapicker di jQuery UI all’interno dell’ambiente ASP.NET MVC (Model-View-Controller).

MVC effettua le chiamate ai vari file .js di  jQuery tramite il file BundleConfig.cs, presente all’interno della direcoty “App_Start“, questa modalità, configurata di default alla creazione di un progetto ASP.NET MVC, presenta purtroppo una limitazione nell’integrazione di tutte le funzionalità offerte da jQuery e jQuery UI, utili ad esempio per l’utilizzo del Datapicker (un comodo calendario per la selezione delle date, utile soprattutto in quanto ad oggi non tutti i browser – vedi Firefox – utilizzano l’imput type date secondo gli standard HTML 5).

Se con l’aggiunta di jQuery UI tramite lo strumento NuGet offerto da Visual Studio non dovessero funzionare tutte le funzionalità di jQuery UI potete procedere in questo modo:

dalla pagina _Layout.cshtml commentare la riga

@Scripts.Render("~/bundles/jquery")

che serve a caricare i file jQuery trmite il file BundleConfig.cs.
La nostra riga apparirà di conseguenza in questo modo

@*@Scripts.Render("~/bundles/jquery")*@

Ora posizionamoci all’interno del tag <head> ed effettuiamo le chiamate ai nostri file .js emplicemente trascinandoli dall’esplora soluzioni di VisualStudio.

Otteremo cosi gli include degli script necessari al corretto funzionamento di jQuery e jQuery UI:

<script src="~/Scripts/jquery-1.12.4.js"></script>
 <script src="~/Scripts/jquery-ui.js"></script>
 <link href="~/Content/jquery-ui.css" rel="stylesheet" />
 <script src="~/Scripts/datepicker-it.js"></script> @*Localizzazione per jquery ui*@

Ora possiamo utilizzare il nostro Datapicker senza problemi su tutti i browser in questo modo:

<input type="text" id="datepicker">

<script>
 $( function() {
 $( "#datepicker" ).datepicker();
 } );
 </script>
 </script>

Et voilà! Come per magia ora funziona tutto!

Posted on Lascia un commento

ASP.NET MVC: PERMESSI E RUOLI

Mediante i ruoli, posso decidere cosa può essere o meno fatto da un utente. Per esempio possiamo decidere di far vedere un pezzo di menu solo agli utenti con un certo ruolo. Nel file _Layout.cshtml, nella parte di menu, avremo una voce visibile solo se l’utente ha un ruolo “Admin” :

@if (User.IsInRole("Admin"))
 {
 <li>@Html.ActionLink("General Manag., "Index", "DB")</li> }

In questo modo l’utente non si trova il menu che porta alla Action “Index” del Controller “DB”. Però potrebbe sempre conoscere l’indirizzo e digitarlo (http://mysite.com/DB/Index)

Per evitare che l’utente acceda a contenuti protetti, possiamo agire direttamente sul Controller. Per esempio possiamo impedire l’accesso a chi non ha effettuato il login al sito

[Authorize]
 public class AccountController : Controller
 {

Oppure, deve aver effettuato l’accesso ed avere un certo Ruolo :

[Authorize(Roles = "Admin")]
 public class AccountController : Controller
 {

Per altre informazioni sui permessi, vedi il manuale Microsoft

 

Posted on Lascia un commento

ASP.NET MVC: APPSETTINGS

Vogliamo introdurre nel nostro sito alcune variabili che dovranno essere utilizzate in diversi punti del codice. Per esempio il nome del sito.

Andiamo nel web.config nella sezione

<configuration> <appSettings>

e inseriamo un nuovo tag, per esempio :

<add key="SiteName" value="My First Site in ASP" />

A questo, punto per esempio nel file

_Layout.cshtml, al posto della voce che mostra il titolo del sito

 @Html.ActionLink("Application name", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })

potete mettere,

 @Html.ActionLink(System.Configuration.ConfigurationManager.AppSettings["SiteName"].ToString(), "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })

In cui vedete proprio l’uso della classe/funzione necessaria a recuperare i dati dal web.ConfigSystem.Configuration.ConfigurationManager.AppSettings

 

 

 

Posted on Lascia un commento

ASP.NET MVC : GESTIONE UTENTE E RUOLI E ACCESSO

Nelle lezioni precedenti abbiamo visto le tabelle create dall’Entity Framework per gestire utenti e ruoli. Avete registrato un utente ed eseguito un login. Facciamo qualche personalizzazione.

Regole delle password.

Potete cambiare tali regole nel file IdentityConfig.cs nella directory App_Start. Nella funzione Create della classe ApplicationUserManager, trovate :

//REGOLE DI COSTRUZIONE PASSWORD
 manager.PasswordValidator = new PasswordValidator
 {
     RequiredLength = 6,
     RequireNonLetterOrDigit = false,    //RequireNonLetterOrDigit = true,
     RequireDigit = false, 
//RequireDigit = true,
     RequireLowercase = false, 
//RequireLowercase = true,
     RequireUppercase = false, 
//RequireUppercase = true,
 };

Potete vedere un impostazione meno restrittiva delle password. Commentati vi vedete i valori di sicurezza di default.


Inserimento di Ruoli e Utenti via codice.

Il nostro obbiettivo e quello che il programma crei per noi i ruoli che andremo a gestire nel database e anche un utente “nostro”, senza dover effettuare una prima registrazione.:un nostro utente amministratore creato in automatico.

Nel file Startup.cs troviamo una classe eseguita alla partenza dell’applicazione.

public partial class Startup
 {
    public void Configuration(IAppBuilder app)
   {
        ConfigureAuth(app);
   }
 }

In questa funzione, inseriamo anche la chiamata ad una nostra funzione createRolesandUsers();

private void createRolesandUsers()
 {
 ApplicationDbContext context = new ApplicationDbContext();
 
 var roleManager = new RoleManager<IdentityRole>(new     RoleStore<IdentityRole>(context));
 var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));

// In Startup iam creating first Admin Role and creating a default Admin User
 if (!roleManager.RoleExists("Admin"))
 {

// first we create Admin rool
 var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
 role.Name = "Admin";
 roleManager.Create(role);

//Here we create a Admin super user who will maintain the website 
 var user = new ApplicationUser();
 user.UserName = "myUser";
 user.Email = "myuser@mcontoso.com";

string userPWD = "123456789";
 var chkUser = UserManager.Create(user, userPWD);

//Add default User to Role Admin
 if (chkUser.Succeeded)
 {
 var result1 = UserManager.AddToRole(user.Id, "Admin");
 }
 }
 // creating Creating Manager role
 if (!roleManager.RoleExists("Teacher"))
 {
    var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
   role.Name = "Teacher";
 roleManager.Create(role);
 }

// creating Creating Employee role
 if (!roleManager.RoleExists("Student"))
 {
 var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
 role.Name = "Student";
 roleManager.Create(role);
 }
 }

Lanciate l’applicazione e vedrete che potrete loggarvi con l’utente creato via codice.

Per una trattazione molto più dettagliata consiglio l’ottimo articolo di Syed Shanu su Code Project

 

 

Posted on Lascia un commento

ASP.NET MVC: SHARED VIEW

Nella cartella View/Shared sono contenuti tutti i controlli visuali che devono essere visualizzati (utilizzati) in diversi punti del sito : sono i vecchi “controlli utenti”. Tali controlli possono essere richiamati programmaticamente oppure chiamati dal sito stesso automaticamente.

In questo secondo caso, immaginate di creare il modello “Studente”. Nella cartella View/Shared devono esistere (se non esistono, createle) le cartelle :

  • DisplayTemplates
  • EditorTemplates

Se inserite nelle 2 cartelle, 2 view dedicate alla visualizzazione del modello “Studente” nelle 2 forme di visualizzazione e di  modifica, entrambe chiamate Studente.cshtml, il sito si occuperà di mostrarvi il vostro controllo personalizzato.

 

Posted on Lascia un commento

ASP.NET MVC – Il primo Controller

Il Controller di un Model, lo crea Visual Studio. Vediamo come.

Dopo aver creato il Model, Student.cs, nel progetto, in Visual Studio, posizionatevi sulla directory Controllers. Tasto destro del mouse e premete “Add” -> “Controller”. Vi compare una maschera che vi propone di scegliere il tipo di controller che volete creare. Il primo della lista è un controller vuoto, cioè una classe che dovrete costruire in autonomia. Il terzo dovrebbe essere un Controller di tipo “Controller with View, using Entity Framwork“. Visual Studio, partendo dal nostro Model crea per noi il Controller e tutte le view delle operazioni CRUD. Scegliete questo tipo.

Ora compare una maschera molto importante. Partendo dall’alto vi viene chiesto di scegliere :

  • Model Class. C’è un menu a tendina che si è automaticamente riempito con tutte le classi presenti nel Model (e con tutte le classi presenti nel vostro progetto). Scegliete Student.
  • Data context Class. Dovete scegliere la connessione al database che contiene la vostra tabella. Il menu a tendina presenta tutte le classi nel progetto, derivate dalla classe DbContext,
  • Check “Generate Views” e “use a Layout Page“.
  • Controller name. Visual Studio ve ne propone uno in base al Model che avete selezionato. Potete modificare il nome, ma lasciate la parola Controller alla fine. (es. StudentsController)

Prima di crearvi il Controller, Visual Studio controlla che tutto ciò che avete scritto nei modelli e nel dbcontext sia “giusto”. Se l’operazione va a buon fine ora, nella directory Controllers vi trovate il file StudentsController.cs.

Esaminiamo questo file. Vi trovate dentro la classe StudentsController derivata da Controller.

public class StudentsController : Controller
 {
 private ApplicationDbContext db = new ApplicationDbContext();

// GET: Students
 public ActionResult Index()
 {
 return View(db.Students.ToList());
 }

La classe inizializza subito una connessione al database (db).

La prima funzione che vediamo è Index(). E’ stata creata i automatico e ci permetterà di vedere la lista dei nostri Studenti. Ogni funzione di questo tipo viene chiamata “Action”. Quando, nel nostro sito richiediamo la lista degli Studenti, lanciamo la funzione index del controller Students secondo questo percorso :

http://www.mysite.com/Students/Index

La funzione Index, richiede alla connessione al database, tutti gli studenti (db.Students) e li trasforma in un lista (db.Students.ToList()). A questo punto manda la nostra lista degli studenti alla view (return View(db.Students.ToList());) Come vedete non è presente il nome della view ma solo un generico View. Il Controller va a cercare nella lista delle view quella che si chiama esattamente come la funzione (Index) e … noi vediamo gli studenti.

Nel progetto spostatevi nella directory Views. Qui troverete una cartella Student con una lista di file creati in automatico (analizzeremo le view prossimamente). Nella directory Views trovate la directory Shared. Possiamo dire che questa directory contiene tutti i  “Controlli Utente” cioè tutti i pezzi di interfaccia che intendiamo utilizzare in più pagine; contiene tutte le view che vengono utilizzate da altre view. Anche quella che nel passato chiamavamo “master page” si trova qui, sotto forma di “layout”. Cercate il file _Layout.cshtml.  Questa è la grafica del vostro sito (la analizzeremo dettagliatamente, prossimamente). Cercate questo pezzo di codice :

<ul class="nav navbar-nav">
 <li>@Html.ActionLink("Home", "Index", "Home")</li>
 <li>@Html.ActionLink("About", "About", "Home")</li>
 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>

Questi sono i pulsanti che vedete in alto, quando lanciate il sito. Dobbiamo inseriren un nuovo pulsante per richiamare la pagina degli studenti.

Aggiungete a questa lista html :

<li>@Html.ActionLink("My Student", "Index", "Students")</li>

Analizziamo quindi il componente ActionLink.

ActionLink(“Testo Visualizzato”, “Nome della Action, “Nome del Controller”). Avremo quindi un pulsante che una volta spinto ci porterà alla pagina http://www.mysite.com/Students/Index.

Provate a lanciare l’applicazione ed ad effettuare un login per testare che tutto funzioni.

Posted on Lascia un commento

ASP.NET MVC. first Model – Code first

In questo articolo cominceremo a creare qualcosa di nuovo nel nostro progetto . Utilizzeremo l’approccio “Code First”, cioè prima scriveremo il codice. Sembra banale dirlo,  ma Visual Studio consente, per esempio, anche l’approccio “Database First”.

Andate nella directory Model e create una nuova classe per esempio Student.cs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MySite.Models
{
 public class Student
 {
 }
}

Aggiungete questo namespace

using System.ComponentModel.DataAnnotations.Schema;

Il nostro modello / classe è la rappresentazione, attraverso le sue proprietà, di una tabella che andremo a costruire su un database. Prima di tutto diciamo alla classe come si chiama la tabella che vogliamo.

[Table("STUDENTS")]
 public class Student
 {
 }

Poi creiamo le proprietà – campi della tabella. Aggiungete questo namespace :

using System.ComponentModel.DataAnnotations;

la nostra tabella è composta da 3 campi

[Table("STUDENTS")]
 public class Student
 {
 [Key]
 [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
 public int ID { get; set; }

[Required]
 [StringLength(200)]
 [Display(Name = "Name")]
 public string NAME { get; set; }

[StringLength(300)]
 [Display(Name = "Surname")]
 public string SURNAME { get; set; }
 }

Le DataAnnotation sopra le proprietà definiscono le caratteristiche dei campi della tabella : ID sarà la chiave primaria (key), e SQLServer si occuperà di assegnare il numero (DatabaseGeneratedOption.Identity). NAME è un campo obbligatorio (Required) di lunghezza 200, la cui descrizione in visualizzazione sarà “Name”.etc.

Ora dobbiamo aggiungere al DBContext la presenza di questa tabella. Aprite la classe ApplicationDbContext e aggiungete come proprietà la nuova tabella :

public DbSet<Student> Students { get; set; }

Provate a lanciare l’applicazione ed ad effettuare un login per testare che tutto funzioni. Andate sul database e costruite le tabella rispettando i nomi.

 

 

Posted on Lascia un commento

ASP.NET MVC : ACCESSO AI DATI

ApplicationDbContext

Nell’articolo precedente abbiamo introdotto la classe ApplicationDbContext.

Cercatela nel progetto. Dovreste trovarla all’interno del file IdentityModels.cs. Questa classe deriva dalla classe IdentityDbContext che a sua volta deriva da DbContext.

DbContext è la classe di accesso ad un database. Il costruttore della classe ha come parametro il nome della stringa di connessione che avevamo precedentemente trovato nel file Web.config.

public ApplicationDbContext() : base("DefaultConnection")
 {
 }

Soffermiamoci su questa informazione : nel Web.config potete inserire più stringhe di connessione e quindi testare l’applicazione su database diversi, cambiando il parametro qui sopra, oppure creare una applicazione che si connette a diversi database definendo più di un DbContext.

All’interno di un DbContext dovranno essere referenziate tutte le tabelle del database che vogliamo usare nella nostra applicazione: o meglio, tutte le tabelle che hanno dei vincoli tra loro.

Se per esempio volessimo legare alla tabella degli utenti creata da Visual Studio, una seconda tabella creata da noi, le 2 tabelle dovrebbero fare parte dello stesso DbContext. Ma noi non sappiamo niente delle tabelle per la gestione degli utenti create in automatico. La classe IdentityDbContext contiene i riferimenti a queste tabelle. Per questo motivo il nostro ApplicationDbContext non deriva da DbContext ma da IdentityDBContext che contiene, appunto, qualche informazione in più.

Mano a mano che aggiungerete tabelle alla applicazione andrete a lavorare sulla classe ApplicationDbContext. Per rendere il codice più ordinato, nella directory Models andate a creare un nuovo file ApplicationDbContext.cs e copiate in questa classe il codice di ApplicationDbContext (solo quello) che era presente in IdentityModels.cs.

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
 {
     public ApplicationDbContext()
     : base("DefaultConnection")
     {
     }

     public static ApplicationDbContext Create()
     {
       return new ApplicationDbContext();
     }
 }

Provate a lanciare l’applicazione ed ad effettuare un login per testare che tutto funzioni.

 

Posted on Lascia un commento

asp.net mvc facile facile – Database

Il database di default

Avete creato il vostro primo progetto ASP.NET MVC. Potete eseguirlo attraverso Visual Studio. Il sito è perfettamente funzionante e vi permette già la registrazione di un nuovo utente ed il login. Se potete registrarvi ed accedere significa che “sotto” al sito è già presente un database. Per sapere dove è il database e quali tabelle compongono la gestione utenti, aprite in Visual Studio SQL Server Object Explorer e vedrete il vostro database sotto

localdb – DefaultConnection

DefaultConnection è il nome della stringa di connessione usata dalla vostra applicazione per collegarsi al Database. Se osservate il contenuto di Tables vedete tabelle che gestiscono gli utenti. Se avete creato il sito usando il Framework 4.5.1 o 4.5.2 queste tabelle sono 6.

Il nostro database SQL Server

Noi non vogliamo lavorare sul  database di default, bensì su un database di SQL Server sulla nostra macchina o in rete. Creiamo un database di SQL Server da qualche parte. Ora dobbiamo fare puntare il nostro sito a questo database. Aprite il file web.config e cercate il tag connectionStrings. Sostituite la stringa di connessione con una valida connessione al vostro database SQL Server (in rete trovate le stringhe di connessione). Lasciate il nome del tag a “DefaultConnection”. Lanciate l’applicazione attraverso Visual Studio.

Questo è un nuovo database quindi l’utente che avete creato prima sul database di default non esiste. Dovete ri-effettuare la registrazione e, a questo punto, potrete effettuare il login. Se ora controllate il contenuto del vostro database SQL Server (con Visual Studio SQL Server Object Explorer oppure con SQL Server Management Studio) vedrete che ci sono anche qui le 6 tabelle che permettono la gestione degli utenti. Create dal sito stesso.

Nel vostro progetto infatti esistono i modelli delle tabelle che consentono la gestione degli utenti (nella directory Models), e il vostro sito, vedendo che sul database non esistevano le tabelle relative , le ha create per voi. Molto comodo.

Da qui in poi creerete i vostri modelli, cioè i contenitori dei vostri dati e il sito tenterà sempre di creare le tabelle relative per voi. Questo non è una procedura comoda perchè non vi consente errori o ripensamenti mentre create il vostro modello. E’ meglio dire al sito di non stare da qui in poi a controllare la reciprocità modello – tabella: costruirete i vostri modelli a mano e quindi le vostre tabelle su SQL Server. Per comunicare questo al sito, aprite il file Global.asax.cs e nella funzione Application_Start(), aggiungete questa riga :

Database.SetInitializer<YourSite.Models.ApplicationDbContext>(null);

Dove ApplicationDbContext è il nome della classe che si connette al database usando la stringa DefaultConnection. Cercatela nel sito.