Manual Para seguridad de Web Api por Token

1. Instalar en el proyecto web Api la librería System.IdentityModel.Tokens, para esto dar

clik derecho sobre el Proyecto Web Api y escoger Manage NuGet Packages

Pulsar instalar, y .Net procede a actualizar las librerías para usar la autenticación por
Token.

2. Crear en la BD una tabla que almacenara los datos de los clientes autorizados para acceder
a los servicios Api, llamada UsuariosApi que tenga la siguiente estructura.
Codigo int
UserName varchar(20)
Clave Varchar(80)
Nombre varchar(160)
Rol varchar(80)
3. Crear en la capa de entidades carpeta Core la clase que mapee a los usuarios del servicio
web

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Serialization;

namespace ABB.Catalogo.Entidades.Core
{
[DataContract]
[Serializable]

public class UsuariosApi

{
[DataMember]
public int Codigo { get; set; }
[DataMember]
public string UserName { get; set; }
[DataMember]
public string Clave { get; set; }
[DataMember]
public string Nombre { get; set; }
[DataMember]
public string Rol { get; set; }

}
}
4. Crear en la capa de entidades Carpeta Core dos clase TokenResponse, para
guardar la clave token creada, y CustomError para guardar los errores.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ABB.Catalogo.Entidades.Core
{
public class TokenResponse
{
public string User { get; set; }
public string Token { get; set; }
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 namespace ABB.Catalogo.Entidades.Core
{
public class CustomError
{
public int Codigo { get; set; }
public string Detalle { get; set; }
}
}

5. En el web config del Servicio web api actualizar el tag de

<appSettings>
<add key="webpages:Version" value="3.0.0.0" />
<add key="webpages:Enabled" value="false" />
<add key="ClientValidationEnabled" value="true" />
<add key="UnobtrusiveJavaScriptEnabled" value="true" />
<add key="cnnSql" value="SQL" />
<add key="JWT_SECRET_KEY" value="OLAh6Yh5KwNFvOqgltw7" />
<add key="JWT_AUDIENCE_TOKEN" value="AvanzaSoluciones.com" />
<add key="JWT_ISSUER_TOKEN" value="GrupoMuya.com" />
<add key="JWT_EXPIRE_MINUTES" value="30" />
</appSettings>

Issuer: (JWT_ISSUER_TOKEN) Debe indicar quien es un emisor válido para el

Token. Normalmente indicaremos el Dominio desde el cual se emite el
Token.
Audience:( JWT_AUDIENCE_TOKEN) Debe indicar la audiencia o destinatario a
los que se dirige el Token.
ClaveSecreta: Obviamente es el parámetro de configuración más
importante, ya que será la Clave que utilizaremos tanto para firmar
digitalmente el Token al enviarlo, como para comprobar la validez de la
firma al recibirlo.
Expire : tiempo de vida del token
6. En el proyecto web api crear el controlador Auth encargada de crear el
token de autenticación, para lo cual desde la carpeta Controller
dar clik derecho y agregar un controlador Api en blanco.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace WebServicesAbb.Controllers
{
public class AuthController : ApiController
{
}
}

Crearemos un método Post llamado Valida que se encargara de validar

las credenciales que el cliente nos envía en caso que sea válido se
 genera el Token. Al crear el método Valida se debe ir actualizando los
using respectivos.
using ABB.Catalogo.Entidades.Core;
using ABB.Catalogo.LogicaNegocio.Core;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Text;
using System.Web.Http;

namespace WebServicesAbb.Controllers
{
public class AuthController : ApiController
{
[HttpPost]
public IHttpActionResult Valida([FromBody] UsuariosApi usuarioAutentica)
{
//validaciones antes de procesar
if (string.IsNullOrEmpty(usuarioAutentica.Clave)
|| string.IsNullOrEmpty(usuarioAutentica.UserName))
{
return BadRequest("Debe enviar la clave o codigo");
}

//validas los datos

//validacion contra la bd
UsuariosApi usuarioapi = new UsuariosApi();
usuarioapi = new UsuarioApiLN().BuscaUsuarioApi(usuarioAutentica);

if ((usuarioapi.Codigo <= 0))

{
return BadRequest("Credenciales no validas");

}
var expireTime = ConfigurationManager.AppSettings["JWT_EXPIRE_MINUTES"];

//crear la semilla
string clave = ConfigurationManager.AppSettings["JWT_SECRET_KEY"];
byte[] claveEnBytes = Encoding.UTF8.GetBytes(clave);
//para convertir la clave que esta como un arreglo de bytes en simetrica
SymmetricSecurityKey key = new SymmetricSecurityKey(claveEnBytes);

//generar algoritmo de ofuscacion

SigningCredentials cred = new SigningCredentials(key,
SecurityAlgorithms.HmacSha256);

//payload
var _Claims = new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.NameId,
usuarioAutentica.UserName.ToString()),
 //new Claim("nombre", "David"),
new Claim("nombre", usuarioapi.Nombre),
// new Claim("apellidos", "Espinoza"),
new Claim("rol", usuarioapi.Rol),
// new Claim(JwtRegisteredClaimNames.Email,
"despinoza@avanza....com"),
// new Claim(ClaimTypes.Role, "admin")
};

//encriptador
JwtSecurityToken jwtSecurityToken = new JwtSecurityToken(
audience: ConfigurationManager.AppSettings["JWT_AUDIENCE_TOKEN"],
issuer: ConfigurationManager.AppSettings["JWT_ISSUER_TOKEN"],
expires: DateTime.UtcNow.AddMinutes(Convert.ToInt32(expireTime)),
//DateTime.Now.AddMinutes(10),
claims: _Claims,
signingCredentials: cred
);

string token = new

JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);

return Ok(new TokenResponse

{
Token = token,
User = usuarioAutentica.UserName

});
}
}
}

Para validar las credenciales del usuario Web Api, se debe crear en la
capa LogicaNegocios y AccesoDatos las respectivas clases de
UsuarioApiLN y UsuarioApiAD con su método de BuscaUsuarioApi() que
recibe una clase de tipo UsuarioApi que trae las credenciales en sus
atributos UserName y Clave.

La clase UsuarioApiLN en la capa LogicaNegocios seria:

using ABB.Catalogo.Entidades.Base;
using ABB.Catalogo.Entidades.Core;
using ABB.Catalogo.AccesoDatos.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ABB.Catalogo.LogicaNegocio.Core
{
public class UsuarioApiLN : BaseLN
{
public UsuariosApi BuscaUsuarioApi(UsuariosApi PamUsuarioApi)
 {
return new UsuarioApiAD().BuscaUsuarioApi(PamUsuarioApi);
}

}
}

La clase UsuarioApiAd en la capa AccesoDatos seria:

using ABB.Catalogo.Entidades.Core;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ABB.Catalogo.AccesoDatos.Core
{
public class UsuarioApiAD
{
public UsuariosApi BuscaUsuarioApi(UsuariosApi ParamUserApi)
{
UsuariosApi entidad = new UsuariosApi();

using (SqlConnection conexion = new

SqlConnection(ConfigurationManager.ConnectionStrings[ConfigurationManager.AppSetting
s["cnnSql"]].ConnectionString))
{

using (SqlCommand comando = new SqlCommand("users_UsuarioApi",

conexion))
{
comando.CommandType = System.Data.CommandType.StoredProcedure;
comando.Parameters.AddWithValue("@Codigo", ParamUserApi.Codigo);
comando.Parameters.AddWithValue("@UserName",
ParamUserApi.UserName);
comando.Parameters.AddWithValue("@Clave", ParamUserApi.Clave);
comando.Parameters.AddWithValue("@Nombre", ParamUserApi.Nombre);
comando.Parameters.AddWithValue("@Rol", ParamUserApi.Rol);
conexion.Open();
SqlDataReader reader = comando.ExecuteReader();
while (reader.Read())
{
entidad = new UsuariosApi();
entidad.Codigo = Convert.ToInt32(reader["Codigo"]);
entidad.UserName = reader["UserName"].ToString();
entidad.Clave = reader["Clave"].ToString();
entidad.Nombre = reader["Nombre"].ToString();
entidad.Rol = reader["Rol"].ToString();

conexion.Close();
 }
}
return entidad;

}
}
}

7. Proceso para filtrar cuando recuperamos el Token, nos permite comparar el token
generado con el enviado por el cliente y poder filtar los pedidos valido. Crear en el
proyecto web api una carpeta llamada Filters y dentro una clase llamada FIlterJWT
con métodos para filtrar los tokens válidos.

La clase quedaría asi. Debe resolverse los using respectivos cuando aparezcan los
errores.
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
namespace WebServicesAbb.Filters
{
public class FIlterJWT : DelegatingHandler
{
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage
request, CancellationToken cancellationToken)
{
HttpStatusCode statusCode;
string token;

if (!TryRetrieveToken(request, out token))

{
statusCode = HttpStatusCode.Unauthorized;
return base.SendAsync(request, cancellationToken);
}

try
{

string clave = ConfigurationManager.AppSettings["JWT_SECRET_KEY"];

byte[] claveEnBytes = Encoding.UTF8.GetBytes(clave);
SymmetricSecurityKey key = new SymmetricSecurityKey(claveEnBytes);

//var claveSecreta = ConfigurationManager.AppSettings["JwtSecret"];

var issuerToken =
ConfigurationManager.AppSettings["JWT_ISSUER_TOKEN"];
var audienceToken =
ConfigurationManager.AppSettings["JWT_AUDIENCE_TOKEN"];

//var securityKey = new SymmetricSecurityKey(

// System.Text.Encoding.Default.GetBytes(claveSecreta));

SecurityToken securityToken;
var tokenHandler = new
System.IdentityModel.Tokens.Jwt.JwtSecurityTokenHandler();
TokenValidationParameters validationParameters = new
TokenValidationParameters()
{
ValidAudience = audienceToken,
ValidIssuer = issuerToken,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
IssuerSigningKey = key
};

// COMPRUEBA LA VALIDEZ DEL TOKEN

Thread.CurrentPrincipal = tokenHandler.ValidateToken(token,

validationParameters,
out
securityToken);
HttpContext.Current.User = tokenHandler.ValidateToken(token,

validationParameters,
 out
securityToken);

return base.SendAsync(request, cancellationToken);

}
catch (SecurityTokenValidationException)
{
statusCode = HttpStatusCode.Unauthorized;
}
catch (Exception)
{
statusCode = HttpStatusCode.InternalServerError;
}

return Task<HttpResponseMessage>.Factory.StartNew(() =>

new HttpResponseMessage(statusCode) { });
}

// RECUPERA EL TOKEN DE LA PETICIÓN

private static bool TryRetrieveToken(HttpRequestMessage request, out string
token)
{
token = null;
IEnumerable<string> authzHeaders;
if (!request.Headers.TryGetValues("Authorization", out authzHeaders) ||
authzHeaders.Count() > 1)
{
return false;
}
var bearerToken = authzHeaders.ElementAt(0);
token = bearerToken.StartsWith("Bearer ") ?
bearerToken.Substring(7) : bearerToken;
return true;
}

}
}

8. Despliegue la carpeta App_Start y despliegue la clase WebApiConfig. En la

parte final agregue la referencia al fitro creado.
La clase esta asi
public static void Register(HttpConfiguration config)
{
// Web API configuration and services

// Web API routes

config.MapHttpAttributeRoutes();

config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
 );
}
Se agrega la línea : config.MessageHandlers.Add(new FIlterJWT());
Y quedara así

public static void Register(HttpConfiguration config)

{
// Web API configuration and services

// Web API routes

config.MapHttpAttributeRoutes();

config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);

config.MessageHandlers.Add(new FIlterJWT());
}

9. En los controladores Apis que se construyan debe ponerse en la cabecera una

directiva de Autorización para indicar que los métodos cuando se invoquen deben
se validar los tokens respectivos. Además los métodos Get,Post, Put, Deleted
deben se de tipo IHttpActionResult
10. Cambios a realizar en los controladores apis construidos .

En el controlador Api Usuarios

using ABB.Catalogo.Entidades.Core;
using ABB.Catalogo.LogicaNegocio.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace WebServicesAbb.Controllers
{
[Authorize]
public class UsuariosController : ApiController
{
// GET: api/Usuarios
[HttpGet]
public IEnumerable<Usuarios> Get()
{
List<Usuarios> usuarios = new List<Usuarios>();
usuarios = new UsuariosLN().ListarUsuarios();

return usuarios;
}
[HttpGet]
 public IHttpActionResult Get([FromUri] string pUsuario, [FromUri] string
pPassword)
{
if (pUsuario == null || pPassword == null)
{
return BadRequest ("Debe enviar las credenciales correctas");
}

try
{
UsuariosLN usuario = new UsuariosLN();
var rsp = usuario.GetUsuarioId(pUsuario, pPassword);
return Ok(Convert.ToString(rsp));
// return usuario.GetUsuarioId(pUsuario, pPassword);
}
catch (Exception ex)
{
string innerException = (ex.InnerException == null) ? "" :
ex.InnerException.ToString();
//Logger.paginaNombre = this.GetType().Name;
//Logger.Escribir("Error en Logica de Negocio: " + ex.Message + ". "
+ ex.StackTrace + ". " + innerException);
throw ex;
}

[HttpGet]
// public Usuarios GetUserId([FromUri] int IdUsuario)
public IHttpActionResult GetUserId([FromUri] int IdUsuario)
{
if (IdUsuario <= 0)
{
return BadRequest("el Id debe ser mayor que 0");
}

try
{
Usuarios usu = new Usuarios();
UsuariosLN usuario = new UsuariosLN();
usu= usuario.BuscaUsuarioId(IdUsuario);
return Ok(usu);
}
catch (Exception ex)
{
string innerException = (ex.InnerException == null) ? "" :
ex.InnerException.ToString();
//Logger.paginaNombre = this.GetType().Name;
//Logger.Escribir("Error en Logica de Negocio: " + ex.Message + ". "
+ ex.StackTrace + ". " + innerException);
throw;
}

// POST: api/Usuarios
 [HttpPost]
// public void Post([FromBody]Usuarios value)
public IHttpActionResult Post([FromBody]Usuarios value)
{
if (value.CodUsuario == null)
{
return BadRequest("CodUsuario es nulo");
}
if (value.ClaveTxt == null)
{
return BadRequest("ClaveTxt es nulo");
}
if (value.Nombres == null)
{
return BadRequest("Nombres es nulo");
}
if (value.IdRol <= 0)
{
return BadRequest("IdRol es nulo");
}
Usuarios usuario = new UsuariosLN().InsertarUsuario(value);
return Ok(usuario);
}

// PUT: api/Usuarios/5
[HttpPut]

//public void Put(int id, [FromBody]Usuarios value)

public IHttpActionResult Put(int id, [FromBody]Usuarios value)
{
if (id <= 0)
{
return BadRequest("CodUsuario es nulo");
}
Usuarios usuario = new Usuarios();
usuario = new UsuariosLN().ModificarUsuario(id,value);
return Ok(usuario);
}

// DELETE: api/Usuarios/5
[HttpDelete]
public void Delete(int id)
{
}
}
}

En el Controlador Api Productos (este controller api solo tiene implementado el método
get, realizar los otros métodos.)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using ABB.Catalogo.Entidades.Core;
using ABB.Catalogo.LogicaNegocio.Core;

namespace WebServicesAbb.Controllers
{
[Authorize]
public class ProductosController : ApiController
{
// GET: api/Productos
[HttpGet]
public IEnumerable<Producto> Get()
{
List<Producto> catalogo = new List<Producto>();
catalogo = new ProductoLN().ListarProductos();

return catalogo;
}

// GET: api/Productos/5
public string Get(int id)
{
return "value";
}

// POST: api/Productos
public void Post([FromBody]string value)
{
}

// PUT: api/Productos/5
public void Put(int id, [FromBody]string value)
{
}

// DELETE: api/Productos/5
public void Delete(int id)
{
}
}
}

11. Compilar la aplicación correr y probarlo en el Postman

Para obtener el token

Copiar el token generado de la cabecera sin las comillas, Pegarlo en la
cabecera del controlador que se va ha invocar. Y en body poner los parámetros
y pulsar Send. Probaremos con Controlador Usuarios Get.

Como se observa en Header se debe poner en la colunna Key la palabra reservada

Authorization.
En la colunna Value la palabra reservada Bearer un espacio y pegrar el token
generado.
En Body es none pues el metodo Get de Usuarios no pide parametros, este
metodo lista todos los usuarios de la DB.pulsar Send para ejecutar.
12. Probar el buscar un usuario en particular. Usar el método Get de Usuarios con
parámetros.
13. Prueba de usuario pasando usuario y password
14. Pruebe el Método Put en el postman (tarea).
15. Consumir los Métodos Api desde el cliente Web. Para esto se hará algunos
cambios en los controladores del cliente. Lo primero es instalar en el proyecto
cliente web los paquetes System.Net.http versión 4.3.3 o superior además
Microsoft.AspNet.WebApi.Client versión 5.2.6 o superior (esto sobre todo para
hacer cambios en el método Put). Hacerlo desde el Administrador NuGet
Para el System.Net.Http

Para Microsoft.AspNet.WebApi.Client
16. En el web config del proyecto cliente llamado ABB.Catalogo.ClienteWeb actualizar
el tag <appSettings> poniendo allí las credenciales del UsuarioApi. (este es el
usuario que podrá invocar los servicios web)
<appSettings>
<add key="webpages:Version" value="3.0.0.0" />
<add key="webpages:Enabled" value="false" />
<add key="ClientValidationEnabled" value="true" />
<add key="UnobtrusiveJavaScriptEnabled" value="true" />
<add key="cnnSql" value="SQL" />
<add key="UsuApiCodigo" value="0" />
<add key="UsuApiUserName" value="ggutierrez" />
<add key="UsuApiClave" value="abc1234" />
<add key="UsuApiNombre" value="Gladys Gutierrez" />
<add key="UsuApiRol" value="Admin" />
</appSettings>
Los keys UsuApiCodigo, UsuApiUserName, UsuApiClave, UsuApiNombre, UsuApiRol
deben tener valores validos existente en la tabla UsuariosApi de la BD.

17. En el controlador de Usuarios se realizaran los siguientes cambios.

a. Se creara un método llamado Respuesta() este método tendrá como
función invocar al controlador web api llamado Auth que genera la clave
token de autenticación.
b. En cada método del controlador Usuarios se debe llamar al método
Respuesta() que retorna la clave token en un objeto de la clase
TokenResponse (esta clase fue creada con antelación en la capa de
entidades).
c. La clave token retornada se debe poner en la cabecera cuando se invoque
los método get, post, put, deleted del web services.
 18. La actualización del controlador Usuarios seria:
El método Respuesta():
private TokenResponse Respuest()
{
TokenResponse respuesta = new TokenResponse();
string controladora = "Auth";
string metodo = "Post";
var resultado = "";
UsuariosApi usuapi = new UsuariosApi();
usuapi.Codigo =
Convert.ToInt32(ConfigurationManager.AppSettings["UsuApiCodigo"]);
usuapi.UserName = ConfigurationManager.AppSettings["UsuApiUserName"];
usuapi.Clave = ConfigurationManager.AppSettings["UsuApiClave"];
usuapi.Nombre = ConfigurationManager.AppSettings["UsuApiNombre"];
usuapi.Rol = ConfigurationManager.AppSettings["UsuApiRol"];
using (WebClient usuarioapi = new WebClient())
{
usuarioapi.Headers.Clear();//borra datos anteriores
//establece el tipo de dato de tranferencia
usuarioapi.Headers[HttpRequestHeader.ContentType] = jsonMediaType;
//typo de decodificador reconocimiento carecteres especiales
usuarioapi.Encoding = UTF8Encoding.UTF8;
//convierte el objeto de tipo Usuarios a una trama Json
var usuarioJson = JsonConvert.SerializeObject(usuapi);
string rutacompleta = RutaApi + controladora;
resultado = usuarioapi.UploadString(new Uri(rutacompleta),
usuarioJson);
respuesta = JsonConvert.DeserializeObject<TokenResponse>(resultado);
}
return respuesta;
}

Este método invoca el controlador Auth; del web servicies para generar el
token. Se envía como parámetros las credenciales del usuario autorizado que
fueron puesto en el web config; retorma un objeto de tipo TokenResponse con
el valor de la clave Token.
Poner el token en la cabecera cuando se invoca los metos get, post del web
services.
Como se ve En el método Index() se crea una instancia de la clase
TokenResponse, y se llama al método Respuesta(), el token devuelto se coloca
en la cabecera de la llamada el método del web service; esto hace con la
clausula
usuario.Headers[HttpRequestHeader.Authorization]= "Bearer " +
tokenrsp.Token;

Lo mismo se hace en los métodos HttpPost Create() y en Edit().

 Cuando se invoca el HttpPost Edit() que va ha realizar el método Put el web
services se realizan cambios en la forma de invocar este método Put usando
HttpClient(); esta función que invoca al web service tiene otra forma de
llenar la cabecera pasar los parámetros, pero puede invocar de manera
específica al metod Put y Deleted de web services.Tarea completar los método
Details y Delete.
public ActionResult Index()
{
string controladora = "";
string metodo = "";
TokenResponse tokenrsp = new TokenResponse();
//llamada al web Api de Autorizacion.
tokenrsp = Respuest();
//llamada al Web Api para listar Usuarios.
controladora = "Usuarios";
metodo = "Get";
List<Usuarios> listausuarios = new List<Usuarios>();
using (WebClient usuario = new WebClient())
{
usuario.Headers.Clear();//borra datos anteriores
//establece el token de autorizacion en la cabecera
usuario.Headers[HttpRequestHeader.Authorization]= "Bearer " +
tokenrsp.Token;
//establece el tipo de dato de tranferencia
usuario.Headers[HttpRequestHeader.ContentType] = jsonMediaType;
//typo de decodificador reconocimiento carecteres especiales
usuario.Encoding = UTF8Encoding.UTF8;
string rutacompleta = RutaApi + controladora;
//ejecuta la busqueda en la web api usando metodo GET
var data = usuario.DownloadString(new Uri(rutacompleta));
// convierte los datos traidos por la api a tipo lista de usuarios
listausuarios = JsonConvert.DeserializeObject<List<Usuarios>>(data);
}

return View(listausuarios);
}

// GET: Usuarios/Details/5
public ActionResult Details(int id)
{
return View();
}

// GET: Usuarios/Create
public ActionResult Create()
{
Usuarios usuario = new Usuarios();// se crea uns instancia de la clase
usuario

List<Rol> listarol = new List<Rol>();

listarol = new RolLN().ListaRol();
listarol.Add(new Rol() { IdRol = 0, DesRol = "[Seleccione Rol...]" });
ViewBag.listaRoles = listarol;
 return View(usuario);
}

// POST: Usuarios/Create
[HttpPost]
public ActionResult Create(Usuarios collection)
{

string controladora = "Usuarios";

try
{
TokenResponse tokenrsp = new TokenResponse();
//llamada al web Api de Autorizacion.
tokenrsp = Respuest();
// TODO: Add insert logic here
using (WebClient usuario = new WebClient())
{
usuario.Headers.Clear();//borra datos anteriores
//establece el token de autorizacion en la cabecera
usuario.Headers[HttpRequestHeader.Authorization] = "Bearer " +
tokenrsp.Token;
//establece el tipo de dato de tranferencia
usuario.Headers[HttpRequestHeader.ContentType] = jsonMediaType;
//typo de decodificador reconocimiento carecteres especiales
usuario.Encoding = UTF8Encoding.UTF8;
//convierte el objeto de tipo Usuarios a una trama Json
var usuarioJson = JsonConvert.SerializeObject(collection);
string rutacompleta = RutaApi + controladora;
var resultado = usuario.UploadString(new Uri(rutacompleta),
usuarioJson);
}

return RedirectToAction("Index");
}
catch
{
return View();
}
}

// GET: Usuarios/Edit/5
public ActionResult Edit(int id)
{

string controladora = "Usuarios";

string metodo = "GetUserId";
TokenResponse tokenrsp = new TokenResponse();
//llamada al web Api de Autorizacion.
tokenrsp = Respuest();

Usuarios users = new Usuarios();

using (WebClient usuario = new WebClient())
{
usuario.Headers.Clear();//borra datos anteriores
//establece el token de autorizacion en la cabecera
usuario.Headers[HttpRequestHeader.Authorization] = "Bearer " +
tokenrsp.Token;
//establece el tipo de dato de tranferencia
 usuario.Headers[HttpRequestHeader.ContentType] = jsonMediaType;
//typo de decodificador reconocimiento carecteres especiales
usuario.Encoding = UTF8Encoding.UTF8;
string rutacompleta = RutaApi + controladora + "?IdUsuario=" + id;
//ejecuta la busqueda en la web api usando metodo GET
var data = usuario.DownloadString(new Uri(rutacompleta));

// convierte los datos traidos por la api a tipo lista de usuarios

users = JsonConvert.DeserializeObject<Usuarios>(data);
}

List<Rol> listarol = new List<Rol>();

listarol = new RolLN().ListaRol();
listarol.Add(new Rol() { IdRol = 0, DesRol = "[Seleccione Rol...]" });
ViewBag.listaRoles = listarol;

return View(users);
}

// POST: Usuarios/Edit/5
[HttpPost]
// [HttpPut]
public ActionResult Edit(int Id,Usuarios collection)
{
string controladora = "Usuarios";
collection.IdUsuario = Id;
collection.ClaveTxt = "";
collection.Clave = null;
collection.DesRol = "";

string metodo = "Put";

TokenResponse tokenrsp = new TokenResponse();
try
{
//llamada al web Api de Autorizacion.
tokenrsp = Respuest();
// TODO: Add update logic here

using (var client = new HttpClient())

{
client.DefaultRequestHeaders.Clear();
//client.DefaultRequestHeaders.Add("token", "Bearer " +
tokenrsp.Token);
client.DefaultRequestHeaders.Authorization = new
System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",tokenrsp.Token);
client.BaseAddress = new Uri(RutaApi);
string rutacompleta = RutaApi + controladora + "/" + Id;
// var putTask =
client.PutAsJsonAsync($"Usuarios/{collection.IdUsuario}", collection);
var putTask = client.PutAsJsonAsync(rutacompleta, collection);
putTask.Wait();
var result = putTask.Result;

if (result.IsSuccessStatusCode)
{
return RedirectToAction("Index");
}
 return RedirectToAction("Index");
}

// using (WebClient usuario = new WebClient())

//{
// usuario.Headers.Clear();//borra datos anteriores
// //establece el token de autorizacion en la cabecera
// usuario.Headers[HttpRequestHeader.Authorization] = "Bearer " +
tokenrsp.Token;
// //establece el tipo de dato de tranferencia
// usuario.Headers[HttpRequestHeader.ContentType] =
jsonMediaType;
//typo de decodificador reconocimiento carecteres especiales
//usuario.QueryString = "PUT";
// usuario.Encoding = UTF8Encoding.UTF8;
//convierte el objeto de tipo Usuarios a una trama Json
// var usuarioJson = JsonConvert.SerializeObject(collection);
// string rutacompleta = RutaApi + controladora + "?IdUsuario=" +
Id;
// string rutacompleta = RutaApi + controladora + "?=" + Id;
// var resultado = usuario.UploadString((rutacompleta),metodo,
usuarioJson);

// }

// return RedirectToAction("Index");
}
catch (Exception ex)
{
var msg = ex.Message;
return RedirectToAction("Index");
// return View();
}
}

// GET: Usuarios/Delete/5
public ActionResult Delete(int id)
{
return View();
}

// POST: Usuarios/Delete/5
[HttpPost]
public ActionResult Delete(int id, FormCollection collection)
{
try
{
// TODO: Add delete logic here

return RedirectToAction("Index");
}
catch
{
return View();
}
}
19. Ponga como inicial el proyecto web cliente compile la aplicación y pruébelo.