Pubblicato il

ASP.NET MVC: PUBBLICAZIONE DI UN SITO

Visual Studio ci consente di pubblicare il nostro sito web su un web server interno (intranet) o su un web server esterno, per esempio ospitato su Azure.

Nel caso di un server in lan, su un web server avete creato tramite IIS un sito che risiede su una certa directory per adesso vuota. Altrimenti avete già pronto un sito esterno.

In Visual Studio, nel pannello a destra chiamato “Solution Explorer” facciamo click con il tasto destro del mouse sul nostro progetto e selezioniamo l’opzione “Publish“. Si apre la finestra “Publish” che riporta a sinistra i 4 step da fare per la pubblicazione.

Profile

Andate sul menu a tendina in alto al centro  e scegliete “New Custom Profile”. Inventatevi il nome di questo profilo. Una volta inserito, passerete direttamente allo step successivo.

Connection con il metodo “Web Deploy”

Publish Metod : scegliere Web Deploy sia che si pubblichi il sito in un server in lan, sia in un server esterno.

Server (web server in lan) : http://myserver

Server (esterno, per esempio Azure): mysite.azurewebsites.net:443

Site name (web server in lan) : nome della directory in cui deve risiedere il sito

Site name (esterno, per esempio Azure) : nome che avete dato al sito (mysite)

User Name e Password (web server in lan) : mettere uno username amministratore della macchina server. Se la macchina è in dominio usare un Amministratore locale.

User Name e Password (esterno) : ftp user

Destination Url : indirizzo del sito web. es : http://……………..

Settings

In questa tab il programma legge dal we.config le stringhe di connessione al database. Se nel vostro sito di destinazione il database è diverso, dovete specificare la giusta connessione. La pubblicazione sostituira le stringhe di destinazione alle stringhe di origine. Vedremo in seguito che esiste un metodo per inserire nel web.config ulteriori variazioni rispetto al web.config di origine.

Preview

Qui potete vedere i file che saranno inviati alla destinazione cioè i nuovi o  i modificati dopo l’ultimo invio. E potete pubblicare!


Configurazione del web.config

Il nostro sito web di destinazione può avere altre caratteristiche particolari, specificate nel web.config, diverse dal sito di partenza, oltre alle stringhe di connessione al database.
Ci possiamo creare un web.config specifico per ogni deploy.

Andate sul progetto. Nelle “Proprietà”, trovate la directory “PublishProfiles” che contiene i dati salvati precedentemente. Trovate un file .pubxml per ognuno dei deploy che avete creato. Andate su file che vi interessa, spingete il tasto destro del mouse e selezionate “Add Config Transform”.

Se andate nel web.config vedrete che esiste un file aggiuntivo che si chiama come il vostro deploy.  Vediamo alcuni esempi di quello che potete fare con tag che inserirete all’interno di <configuration>

<connectionStrings>
 <add name="MyDB"
 connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True"
 xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
 </connectionStrings>

Questa stringa sostituisce (xdt:Transform=”SetAttributes”) gli attributi del tag che si chiama (xdt:Locator=”Match(name)) “MyDB” con quelli che trova qui.

<appSettings><add key="myemail" value="info@contoso.com" xdt:Transform="SetAttributes" xdt:Locator="Match(key)"/></appSettings>

Questa stringa sostituisce gli attributi (xdt:Transform=”SetAttributes”) del tag che ha come key (xdt:Locator=”Match(key)) “myemai” con quelli che trova qui.

<system.net>
 <mailSettings xdt:Transform="Replace">
 <smtp deliveryMethod="Network" ........................
 </smtp>
 </mailSettings>
 </system.net>

Questa stringa trasforma (xdt:Transform=”Replace”) tutto il tag mailSettings ed il suo contenuto.

Download PDF
Pubblicato il

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

Download PDF
Pubblicato il

ASP.NET MVC LINQ MIGLIORATO

Linq è un elemento introdotto nel Framework 3.5. Attraverso di esso è possibile fare interrogazioni su liste, collezioni, tabella di database, file xml usando una notazione molto simile al linguaggio SQL.

Ritorniamo per esempio alla nostro modello Student.

[Table("STUDENTS")]
 public class Student
 {
 public int ID { get; set; }
 public string NAME { get; set; }
 public string SURNAME { get; set; }
 public int AGE {get;set;}
 }

Nel nostro context abbiamo l’istanza alla tabella

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

Attraverso Linq, possiamo chiedere :

var list = context.Studens.Where(s => s.NAME.StartsWith("M") and s.AGE > 18).OrderBy(s => s.SURNAME)

Il linguaggio Linq è lo strumento con cui il context, base dell’ASP.NET MVC, interroga il nostro database. Però Linq, a nostro avviso, proprio quando si lavora con le tabelle di un database ha dei limiti rispetto a SQL. Come vedete, la query sopra è preimpostata : cioè esiste un filtro sulla proprietà NAME e uno sulla AGE e un ordinamento sulla proprietà SURNAME. Questa base di dati sarà sempre ordinata così e al massimo potremo variare la query agendo sulla stringa “M”  e sul numero 18.

Le nostre query però sono variabili in genere. Immaginate di avere una griglia con colonne riordinabili. Usando linq dovreste gestire una query diversa per ognuna delle proprietà che possono essere ordinate ed inoltre dovreste gestire il verso. E se voleste mettere dei filtri ? Dovreste creare delle query in sequenza che, piano piano, filtrano i dati : una per la prima proprietà, uno per la seconda, etc.

Un pò scomodo.

A questo proposito ci viene in soccorso la libreria System.Linq.Dynamic https://github.com/kahanu/System.Linq.Dynamic

che ci permette di fare domande come :

var list = context.Studens.Where("NAME = \"JOHN\" and AGE >= 18 and  AGE <= 34").OrderBy(SURNAME asc, NAME)

Addio Linq , Grazie SQL.

Download PDF
Pubblicato il

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!

Download PDF
Pubblicato il

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

 

Download PDF
Pubblicato il

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

 

 

 

Download PDF
Pubblicato il

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

 

 

Download PDF
Pubblicato il

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.

 

Download PDF
Pubblicato il

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.

Download PDF
Pubblicato il

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.

 

 

Download PDF