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

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 : 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.

 

Posted on Lascia un commento

asp.net mvc facile facile . Introduzione – parte 1

nb. Se deciderete di lavorare con questa tecnologia, ogni volta che avete un dubbio o la necessità di un approfondimento, vi basta andare sul vostro motore di ricerca preferito e digitare la vostra ricerca (con parole in inglese) , preceduta dalle semplici parole ASP.NET MVC. Troverete tutte le risposte.

Quando parliamo di ASP.NET MVC intendiamo in generale la creazione di siti con Visual Studio, utilizzando il linguaggio c# ed impostando lo sviluppo secondo le norme di programmazione MVC.

MVC sta per Model – View – Controller. Nella pratica ogni vecchia pagina web è ora costruita utilizzando 3 file diversi. Oppure, i 3 file insieme costituiscono la pagina. Due di questi file sono codice c# puro ed hanno estensione .cs, il terzo è codice html e ha estensione .cshtml. In ognuno dei 3 file c’è un pezzo di codice. Scrivere le cose in questo modo vi permetterà di essere più rapidi nello sviluppo. Per ora vi dovete fidare.

Facciamo un esempio. Se cercate con il browser la pagina http://www.miodominio.com/Prodotti/Index,   il sito cercherà un file che si chiama ProdottiController.cs  (il primo dei nostri 3).  Nel file ProdottiController.cs c’è almeno la classe ProdottiController. All’interno di questa classe, in questo file, esiste una funzione di nome Index. A questo punto il Controller fa 2 cose: cerca nel sito un file chiamato Index.cshtml . Questo file (è la View) contiene il nostro html. In alcuni casi nella pagina del sito ci sono solo scritte statiche. Se invece è previsto che in questa pagina ci siano dati dinamici, il controller crea una rappresentazione dell’insieme dei dati partendo da un terzo file che può avere qualsiasi nome, per esempio Item.cs (il Model) e lo da in pasto al file Index.cshtml che ci appare infine sul browser. Spiegazione lunga ma funziona tutto in un attimo.

Dalla spiegazione capite che ci sono delle regole precise sui nomi dei file : ci viene quindi imposto un modo di organizzare i file, una strada da percorrere sempre uguale che renderà il nostro codice più ordinato, manutenibile e leggibile dai nostri colleghi programmatori.

Ora aprite Visual Studio e create il primo sito ASP.NET MVC. Trovate tantissime guide sul web ma potete anche provarci da soli. Analizziamo la struttura delle cartelle che compongono il sito e vediamo quello che ci potete fare. Nel sito trovate sicuramente queste 3 cartelle :

  •  Controller
  •  Model
  •  View

Nella cartella controller ci staranno, i file Controller. Potete dare a questi file qualsiasi nome nella forma QualcosaController.cs. All’interno delle cartella potete creare tutte le sottocartelle che volete e con qualsiasi nome per riordinare meglio i file Controller che andrete a creare.

Nella cartella Model ci staranno i file Model. Potete dare a quest file qualsiasi nome e creare tutte le sottocartelle che volete.

Nella Cartella View ci staranno le View. All’interno di questa cartella deve esistere, per ogni Controller, una sottocartella che si chiama esattamente come il Controller (senza Controller.cs). Nei nostri esempi avremo quindi una cartella Prodotti ed una cartella Qualcosa. All’interno di questa cartella ci saranno tanti file .cshtml quante sono le funzioni presenti nel file Controller o meglio le funzioni del Controller che volete siano utilizzate dall’esterno. Devono chiamarsi esattamente come la funzione. Nel nostro esempio avremo :

  •  Controller
    •  ProdottiController.cs
    •  QualcosaController.cs
  •  Model
    •  Item.cs
  •  View
    •  Prodotti
      •  Index.cshtml
    •  Qualcosa

Il bello di tutta questa gestione è che Visual Studio la fa per voi in automatico e tra un po vedremo come.

Posted on Lascia un commento

WordPress on Azure. CNAME Settings

After installing WordPress on Azure using this “how to” : https://azure.microsoft.com/it-it/documentation/articles/app-service-web-create-web-app-from-marketplace/

You will have a website with an address like this: http://examplewp.azurewebsites.net

Now you have to set the CNAME on the provider’s DNS of your hosting because you want your wordpress site points to http://www.mydomain.com. You can use this “how to” : https://azure.microsoft.com/en-us/documentation/articles/web-sites-custom-domain-name/

Now go into your wordpress site, in the general configuration.
You have to change WordPress address (URL) and Site address (URL). from http://examplewp.azurewebsites.net to http://www.mydomain.com

Posted on Lascia un commento

Storage e Azure Machine Learning

Se state pensando di provare il Microsoft Azure Machine Learning di Microsoft e avete intenzione di prelevare i dati che vi serviranno da uno storage Azure, ricordate che al momento (Agosto 2016) il AML può essere attivato solo in Asia Sud Orientale, Europa Occidentale e stati uniti centro meridionali.

Date quindi queste limitazioni fate attenzione di creare lo storage in una di queste 3 regioni.

Posted on Lascia un commento

Microsoft Azure Machine Learning prove di importazione csv

Per chi di voi fa esperimenti con Microsoft Azure Machine Learning, una breve nota sull’importazione di file csv per costruire il proprio dataset. Se producete un csv utilizzando Microsoft Excel in italiano, otterrete un file che ha “la virgola” (,) come separatore dei decimali ed “il punto e virgola” (;) come separatore dei campi.

Questo formato non è compatibile con AML e deve essere portato allo standard americano : “il punto” (.) come separatore dei decimali e “la virgola” (,) come separatore dei campi.

Aprite con notepad (blocco note) il vostro csv :

  1. Trasformate i separatori dei decimali : da virgola a punto
  2. Trasformate i separatori di campi : da punto e virgola a virgola