Nella “Token based authentication”, l’applicazione client invia prima una richiesta all’endpoint del server di autenticazione con le credenziali dell’utente; se il nome utente e la password sono corretti, il server di autenticazione invia un token al client come risposta. Questo token contiene dati sufficienti per identificare un determinato utente e un tempo di scadenza. L’applicazione client utilizza quindi il token per accedere alle risorse nelle richieste successive fino a quando il token risulta ancora valido (non scaduto).
Classe per validare le richieste del client
Aggiungete una classe come questa :
using Microsoft.Owin.Security.OAuth;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity.Owin;
namespace Mysite.Helpers
{
public class MysiteAuthorizationServerProvider : OAuthAuthorizationServerProvider
{
public override async Task ValidateClientAuthentication(OAuthValidateClientAuthenticationContext context)
{
context.Validated(); //
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var userManager = context.OwinContext.GetUserManager<ApplicationUserManager>();
var user = await userManager.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(userManager,
OAuthDefaults.AuthenticationType);
context.Validated(oAuthIdentity);
}
}
}
Per attivare questa classe andate nel file App_Start/Startup.Auth.cs e aggiungete alla fine del metodo ConfigureAuth questo codice
var myProvider = new MysiteAuthorizationServerProvider();
OAuthAuthorizationServerOptions options = new OAuthAuthorizationServerOptions
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
Provider = myProvider
};
app.UseOAuthAuthorizationServer(options);
app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
In cui si definisce il link http://mysite/token che restituisce un token di durata 1 giorno.
Dovrete aggiungere nel file il riferimento
using Microsoft.Owin.Security.OAuth;
E’ necessario aggiungere un metodo all’autenticazione. Andate nel file IdentityModel.cs e aggiungete questo metodo :
public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager,
string authenticationType)
{
var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);
return userIdentity;
}
TEST CON POSTMAN
Per testare il tutto facilmente potete usare Postman .
Dovrete creare con Postman una chiamata post sul vostro link http://mysite/token. Nell’headers inserite la dicitura che vedete in figura :
Nel Body inserite il tipo di autneticazione (password) il vostro username e la vostra password.
Spingete “Send”. Se tutto ha funzionato riceverete il token
Utilizzo del Token
Una volta che il client ha ricevuto il token lo può utilizzare per tutte le successive operazioni senza dover passare lo username e la password: va passato solo il token che contiene queste informazioni. Facciamo una prova, creando un metodo che richiede autenticazione all’interno di un controller :
using System;
using System.Web.Http;
namespace MySite.Controllers
{
public class SampleController : ApiController
{
[Authorize]
[HttpGet]
public IHttpActionResult GetForAuthenticate()
{
var identity = (ClaimsIdentity)User.Identity;
return Ok("Hello " + identity.Name);
}
}
}
Usando postman, fate una chiamata GET al link : http://MySite/api/Sample/GetForAuhenticate
Dovrete passare al link il token che avete ottenuto qualche istante prima (nel nostro esempio è valido per 1 giorno). Per farlo in postman aggiungete la chiave Authorization con valore la parola Bearer seguita dal token.
Use NuGet Package Manager to install the Web API Client Libraries package :
Microsoft.AspNet.WebApi.Client
Microsoft.AspNet.WebApi.Core
Microsoft.AspNet.WebApi.WebHost
Define a Web API Routing Configuration
Add App_Start\WebApiConfig.cs
using System.Web.Http;
class WebApiConfig
{
public static void Register(HttpConfiguration configuration)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
}
Register the WebAPI Routing Configuration
If you added a new WebApiConfig.cs file, you need to register that on your Web Application’s main configuration class.
Import namespace System.Web.Http in Global.asax.cs.
Add this line before the registration of your classic routing
//api routing (before)
GlobalConfiguration.Configure(WebApiConfig.Register);
//existing normal route
RouteConfig.RegisterRoutes(RouteTable.Routes);
Create a sample Web API Controller
Create a new controller
using System;
using System.Web.Http;
namespace MySite.Controllers
{
public class SampleController : ApiController
{
[HttpGet]
public String Test()
{
return "Hello World!";
}
}
}
Based on the api routing you should call this method in your browser using
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.