Servicios REST con .NET Core
  • Servicios REST con ASP.NET Core y Entity Framework Core
  • 1. Introducción
    • 1.1 Instalación Visual Studio Community
    • 1.2 Instalación de SQL Server en Mac
    • 1.3 Extensión Intellicode
    • 1.4 Aplicación de ejemplo
  • 2. Explicación de Conceptos
    • 2.1 Servicios REST
      • 2.1.1 OData
      • 2.1.2 GraphQL
    • 2.2 Entity Framework para versiones de tu base de datos
    • 2.3 Paquetes Nuget
    • 2.4 Archivo de recursos
    • 2.5 Estructura de los Proyectos .Net Core
    • 2.6 Código Limpio
    • 2.7 Programación asíncrona
    • 2.8 Git
    • 2.9 ¿Qué es Scrum?
      • 2.9.1 Personas
      • 2.9.2 Roles Scrum
      • 2.9.3 Backlog
      • 2.9.4 Reuniones del Scrum
  • 3. Control de código fuente y Scrum con Azure DevOps
    • 3.1 Introducción a Azure DevOps
      • 3.1.1 Crear un nuevo Proyecto en Azure DevOps
      • 3.1.2 Agregando personas al equipo de trabajo
      • 3.1.3 Agregando los sprints y la capacidad de trabajo
      • 3.1.4 Crear el Backlog y asignar User Stories al Sprint
      • 3.1.5 Crear Prototipos
      • 3.1.6 Conectar a Azure DevOps desde Visual Studio
        • 3.1.6.1 Crear tu proyecto con Visual Studio Community y sincronizarlo a Azure DevOps
      • 3.1.7 Consultar tus tareas pendientes
        • 3.1.7.1 Tareas y Dashboards con Azure DevOps
        • 3.1.7.2 Consultar tus tareas desde Visual Studio Community
      • 3.1.8 Trabajando con Ramas (Branches)
        • 3.1.8.1 Crear la rama desarrollo desde Azure DevOps
          • 3.1.8.1 Crear una rama(branch) desde tu tarea en Azure DevOps
        • 3.1.8.2 Como trabajar con ramas (branches) desde Visual Studio Community
        • 3.1.8.3 Crear el Pull Request con Azure DevOps
      • 3.1.9 Retrospectiva del Sprint
      • 3.1.10 Agregando una Wiki
    • 3.2 Integrando tu código fuente a GitHub
      • 3.2.1 Trabajando con ramas en GitHub
      • 3.2.2 Sincronizar los cambios del código con GitHub y Visual Studio
      • 3.3 Trabajando con Branches (Ramas) con Visual Studio
        • 3.3.1 Branches con Visual Studio
        • 3.3.2 Creando un template para tus PR (Pull Request)
        • 3.3.3 Protegiendo tu branch
  • 4. Creando tu primer servicio
    • 4.1 Crear las base de datos y los usuarios en MySQL
    • 4.2 Crear la tabla Categoría y sus validaciones
    • 4.3 Creando el servicio Categorias
    • 4.4 Probando tus servicios con POSTMAN
    • 4.5 Documentar y Probar tus servicios con Swagger
      • 4.5.1 Configurar Swagger
      • 4.5.2 Comentarios XML
      • 4.5.3 Generando la página de documentación
    • 4.6 Agregando índices
    • 4.7 Mejorando tu código
      • 4.7.1 Creando Objetos de Accesos a Datos
      • 4.7.2 Creando tus mensajes de error en diferentes idiomas
      • 4.7.3 Cambiando el formato del Json de los servicios
  • 5. Agregando el servicio para los productos
    • 5.1 Crear la tabla de Productos
    • 5.2 Formas de cargar información de tablas relacionadas
    • 5.3 Crear llaves fóraneas e índices
    • 5.4 Creando el servicio Productos
    • 5.5 Validar Reglas Mejorando tu código
      • 5.5.1 Agregando una excepción a todos nuestros servicios
      • 5.5.2 Agregando clases genéricas para validar y/o consultar información
      • 5.5.3 Alternativa para validar reglas con ef core
  • 6. Cambiar de base de datos a SQL Server
    • 6.1 Cambiar la base de datos a SQL Server
    • 6.2 Cambiar a SQL Server en Azure
  • 7. Crear servicios con OData
    • 7.1.1 Creando el modelo Clientes
    • 7.1.2 Creando el modelo ClienteCategoría
    • 7.1.3 Agregando paquete Nuget para OData
    • 7.1.4 Configurar el EDM Model
    • 7.1.5 Configurar el servicio OData y llaves foráneas
    • 7.1.6 Creando el Controller para clientes
    • 7.1.7 Configurar y probar los servicios con OData
    • 7.1.8 Práctica Crear el servicio para ClientesCategorias
    • 7.1.9 Recomendaciones de seguridad y rendimiento a tomar en cuenta con OData
  • 8. GraphQL
    • 8.1.1 Creando la tabla Caducidad
    • 8.1.2 Creando el query
    • 8.1.3 Configurando y probando graphQL
    • 8.1.4 Creando la Mutation
    • 8.1.5 Probando nuestros servicios con Postman
  • 9. Seguridad
    • 9.1 Json Web Tokens
    • 9.2 Seguridad basada en roles y usuarios
      • 9.2.1 Creando nuestra tabla roles e insertando los roles principales
      • 9.2.2 Consideraciones de seguridad para almacenar tus passwords
      • 9.2.3 Creando las tablas para manejar la seguridad
      • 9.2.4 Agregando usuarios y roles
    • 9.3 Agregando seguridad a nuestros servicios
    • 9.4 Creando nuestro servicio de login y generar el token
    • 9.5 ¿Cómo agregar seguridad basada en roles a los Servicios REST?
      • 9.5.1 Seguridad basada en claims
      • 9.5.2 Creando las tablas para validar permisos por cada tabla
      • 9.5.3 Seguridad basada en directivas
      • 9.5.4 Seguridad con Action Filters
    • 9.6 Guardando el historial de cambios
    • 9.7 Refrescando tu token
    • 9.8 Seguridad Mejorando tu código
      • 9.8.1 ¿Cómo limitar el número de intentos incorrectos en el login?
      • 9.8.2 ¿Cómo obtener la ciudad del usuario por medio de la IP?
      • 9.8.3 Habilitando CORS
  • 10. Pruebas Unitarias
    • 10.1 Agregando el proyecto de pruebas unitarias
    • 10.2 Crear una prueba unitaria
      • 10.2.1 Ejecutando las pruebas unitarias
    • 10.3 Agregando una base de datos en memoria para nuestras pruebas unitarias
    • 10.4 Agregando la referencia de nuestro proyecto CaducaRest
      • 10.4.1 Agregando paquetes nuget necesarios
    • 10.5 Configurando Clases para Objetos Sustitutos
      • 10.5.1 Configurando el Contexto para utilizar la base de datos en Memoria
      • 10.5.2 Configurando el objeto para sustituir mensajes de Error por idioma
    • 10.6 Agregando pruebas para las Categorías
  • 11. Integración continua
    • 11.1 ¿Qué es la integración continua?
    • 11.2 Subir tu código fuente a BitBucket
      • 11.2.1 Integración continua y pruebas automáticas con Bitbucket
    • 11.3 Integración continua y pruebas automáticas en Azure DevOps
  • 12. Pruebas de integración
    • 12.1 ¿Qué es SpecFlow?
    • 12.2 Agregando el proyecto de pruebas de integración
    • 12.3 Configurando Specflow
    • 12.4 Creando pruebas para el login
    • 12.5 Agregando las pruebas de Integración a Azure Devops
    • 12.6 Specflow Mejorando tu código
      • 12.6.1 Cambiando las pruebas a español
      • 12.6.2 Pasando tablas a nuestras pruebas
      • 12.6.3 Agregar los passwords como variables de ambiente
      • 12.6.4 Probando con SQLite
      • 12.6.5 Agregando diferentes parámetros con MSTest
      • 12.6.6 Generando el reporte living doc de specflow
  • 13. Integración continua con Postman
    • 13.1 Recomendaciones para probar tus servicios
    • 13.2 Instrucciones básicas para probar con Postman
    • 13.3 Crear colecciones en Postman
    • 13.4 Agregar pruebas a tus servicios
    • 13.5 Crear environments
    • 13.6 Agregando datos de prueba con archivos .csv
    • 13.7 Exportando tus colecciones y ejecutarlas con Newman.
    • 13.8 Agregando las colecciones de postman al pipeline
  • 14. Pruebas de usuario
    • 14.1 Page Object Model
    • 14.2 ¿Qué es Selenium?
      • 14.2.1 Selenium Instrucciones básicas
      • 14.2.2 Agregando el proyecto de pruebas de usuario
    • 14.3 ¿Qué es Cypress?
      • 14.3.1 Cypress Instrucciones básicas
    • 14.4 ¿Qué es Playwright?
      • 14.4.1 Playwright Instrucciones básicas
  • 15. Despliegue Continuo con Azure DevOps y Azure
    • 15.1 Crear un App Service en Azure
    • 15.2 Generando Artifacts en Azure Pipelines
    • 15.3 Generando el Release en Azure Pipelines al App Service de Azure
    • 15.4 Ejecutando las colecciones de Postman después del release
    • 15.5 Agregando las pruebas de usuario en Azure Pipelines
  • 16. Instalación en Windows Server e IIS
    • 16.1 Instalar IIS en Windows Server
    • 16.2 Instalación del ASP.NET Core Module/Hosting Bundle
    • 16.3 Crea el Sitio Web en IIS
  • 17. Instalación en Linux
    • 17.1 Creando una máquina virtual linux en Azure
    • 17.2 Habilitando el acceso remoto
    • 17.3 Configura linux para .Net Core
    • 17.4 Instalando mysql
    • 17.5 Instalando Nginx y configurando tu servicio
    • 17.6 Instalando un certificado SSL gratuito con CertBot
    • 17.7 Agregando diferentes subdominios
  • 18. Docker
Powered by GitBook
On this page
  • Obtener los datos del navegador
  • Obtener los datos de la ciudad por medio de la IP

Was this helpful?

  1. 9. Seguridad
  2. 9.8 Seguridad Mejorando tu código

9.8.2 ¿Cómo obtener la ciudad del usuario por medio de la IP?

Obtener los datos del navegador

En las peticiones a los servicios Rest en el header se suele incluir la versión del navegador en el Header User-Agent, aunque este método fácilmente lo pueden cambiar los hackers, lo podemos utilizar como estadística, o podemos agregar un nuevo Header que se llame por ejemplo Secreto y pedir a todos los clientes que se conecten a nuestros servicios que envíen un Header con el nombre Secreto

Para obtener datos acerca de la petición a nuestros servicios rest necesitamos un objeto de la clase necesitamos un objeto de la interfaz

IHttpContextAccessor

Agregamos a nuestra clase controller una variable y la pasamos en el constructor

UsuariosController.cs
public class UsuariosController : BaseController
{
    private IHttpContextAccessor _accessor;
    
    public UsuariosController(CaducaContext context,
                              LocService localize,
                              IConfiguration config,
                              IHostingEnvironment hostingEnvironment,
                              IHttpContextAccessor accessor) 
                              : base(context, localize)
    {           
        _config = config;
        _accessor = accessor;
        _hostingEnvironment = hostingEnvironment;
        usuarioDAO = new UsuarioDAO(context, localize,
                              _hostingEnvironment.ContentRootPath);
    }
}

A nuestro método para el Login agregamos el método para obtener el navegador

UsuarioController.cs
public async Task<IActionResult> PostAsync([FromBody] LoginDTO loginDTO)
{
    var navegador=_accessor.HttpContext?.Request.Headers["User-Agent"];
    //Para obtener cualquier otro dato en el Header
    //var otroDato = _accessor.HttpContext?.Request.Headers["Secreto"];
}

Obtener los datos de la ciudad por medio de la IP

Otra recomendación es registrar las ciudades y dispositivos de donde se conecta el usuario normalmente y enviar un correo cuando se conecta de otra ciudad diferente.

Existen bases de datos gratuitas y de pago donde por medio de la ip te regresan la ciudad aproximada de donde se conectó el usuario.

Si deseas bajar tu base de datos aqui tienes una gratuita. Esta base de datos se actualiza constantemente.

Existen servicios rest en donde tu envías la ip y te regresan los datos de la ip, algunos ofrecen servicios gratuitos limitados a por ejemplo 1,000 peticiones por día o varía el precio de acuerdo al número de peticiones.

Algunos de los servicios gratuitos son los siguientes, los cuales te permiten 1,000 peticiones por día.

En mi ejemplo utilizare iplocate

Si deseas puedes guardar cada día las ip de los usuarios para consultar de tu base de datos en lugar del servicio, si varios usuarios se conectan del mismo lugar.

Para mandar llamar el servicio puedes conectarte por postman o desde el navegador utilizando la siguiente petición

Te regresa un json similar a este

{
  "ip"          : "35.232.52.59",
  "country"     : "United States",
  "country_code": "US",
  "city"        : "Mountain View",
  "continent"   : "North America",
  "latitude"    : 37.4043,
  "longitude"   : -122.0748,
  "time_zone"   : "America/Los_Angeles",
  "postal_code" : "94043",
  "org"         : "Google LLC",
  "asn"         : "AS15169",
  "subdivision" : "California",
  "subdivision2": null
}

Puedes entrar a la siguiente página donde le copias el json regresado por algún servicio y te genera una clase en c# o puedes copiar el json a visual studio utilizando la opción Pegado Especial -> Pegar Json como Clase

Agregamos la clase generada en nuestra carpeta DTO

DatosIPDTO.cs
public class DatosIPDTO
{
    public string ip { get; set; }
    public string country { get; set; }
    public string country_code { get; set; }
    public string city { get; set; }
    public string continent { get; set; }
    public double latitude { get; set; }
    public double longitude { get; set; }
    public string time_zone { get; set; }
    public string postal_code { get; set; }
    public string org { get; set; }
    public string asn { get; set; }
    public string subdivision { get; set; }
    public object subdivision2 { get; set; }
}

Agregamos una clase IPLocate la cual llamará al servicio rest de IPLocate para a través de la IP nos regrese la ciudad.

IPLocate
public class IPLocate
{
    /// <summary>
    /// LLamamos al servicio IPLocate para obtener los datos de una ip
    /// </summary>
    /// <param name="ip">Ip del cliente</param>
    /// <returns></returns>
    public async Task<DatosIPDTO> ObtenerDatosPorIpAsync(string ip)
    {
        HttpClient client = new HttpClient();
        DatosIPDTO datosIP;
            
        var respuesta = await 
                client.GetStringAsync
                    ("https://www.iplocate.io/api/lookup/" + ip);
        datosIP = JsonConvert.DeserializeObject<DatosIPDTO>(respuesta);           
        return datosIP;
    }
}

Como una mejora, se puede crear una interfaz IPServicio con el método ObtenesDatosPorIpAsync para si a futuro se desea cambiar el método para obtener las IP lo deseamos cambiar a alguna de paga o de otra compañía.

Como en el modo de desarrollo desde visual studio el código para obtener la ip no funciona agregamos una ip por default, para obtener la ip podemos utilizar el objeto _accesor, la opción RemoteIpAdrress. Si se tiene un servidor Linux se puede configurar Nginx para guardar la IP en el header X-Real-IP en la sección de configuración de servidor en linux se explica como realizar este paso.

UsuariosController.cs
public class UsuariosController : BaseController
{
    public async Task<IActionResult> PostAsync([FromBody] LoginDTO loginDTO)
    {
       //Código del navegador
        string ip = "189.145.141.65"; //Set default ip
        if (_hostingEnvironment.IsProduction())        
             ip =_accessor.HttpContext?.Connection?
                                     .RemoteIpAddress?.ToString();
        //En servidores linux con nginx y el forward de X-Real-Ip
        //var ip = this.httpContextAccessor.HttpContext
        //          .Request.Headers["X-Real-IP"];        
    }
 }

En nuestra clase UsuarioAccesoDAO agregamos un método para obtener la ip llamado ObtenerDatosIPAsync

UsuarioDAO.cs
public class UsuarioAccesoDAO
{
    private DatosIPDTO datosIP;
        
    public async Task<DatosIPDTO> ObtenerDatosIPAsync(string ip)
    {
        var ipLocate = new IPLocate();
        return  await ipLocate.ObtenerDatosPorIpAsync(ip);           
    }

En nuestro método LoginAsync agregamos el parámetro de la ip y el navegador y guardamos los valores

UsuarioDAO.cs
public async Task<bool> GuardarAccesoAsync(TokenDTO tokenDTO, 
                           int usuarioId, string ip, string navegador)
{           
    if (datosIP == null)
        datosIP = await ObtenerDatosIPAsync(ip);
}

Agregamos otra función en nuestra clase UsurioAccesoDAO para revisar si el usuario tiene mas de un acceso registrado revisamos si el usuario se ha conectado de una nueva ip o de una nueva ciudad

UsuarioAccesoDAO.cs
public async Task<bool> GuardarAccesoAsync(TokenDTO tokenDTO, int usuarioId, string ip, string navegador)
{           
    if (datosIP == null)
        datosIP = await ObtenerDatosIPAsync(ip);
    var usuarioAcceso = new UsuarioAcceso();
    usuarioAcceso.Ciudad = datosIP.city;
    usuarioAcceso.Estado = datosIP.subdivision;
    usuarioAcceso.Navegador = navegador;
    //Demás código
}

Agregamos funciones para validar si el usuario se registra de una nueva ciudad o navegador

UsuarioAccesoDAO.cs
public async Task<bool> EsOtraCiudadAsync(string ip, int usuarioId)
{
    //Obtenemos los datos de la ip
    datosIP = await this.ObtenerDatosIPAsync(ip);
    //Revisamos si ya registro algún acceso, si no tiene
    //accesos no se debe enviar ningún correo 
    var acceso = contexto.UsuarioAcceso
             .FirstOrDefault(u => u.UsuarioId == usuarioId);
    if (acceso == null)
        return false;
    //Revisamos si tiene un registro en otra ciudad
    acceso = contexto.UsuarioAcceso
                 .FirstOrDefault(u => u.UsuarioId == usuarioId
                                 && u.Ciudad!=datosIP.city);
    //Si ya tiene un acceso para esa ciudad regresamos false
    return acceso!=null;
}

public bool EsOtroNavegadorAsync(string navegador, int usuarioId)
{
     //Revisamos si ya registro algún acceso, si no tiene
    //accesos no se debe enviar ningún correo 
    var acceso = contexto.UsuarioAcceso
                    .FirstOrDefault(u => u.UsuarioId == usuarioId);
    if (acceso == null)
        return false;
    //Revisamos si tiene un registro en otra ciudad
    acceso = contexto.UsuarioAcceso
                      .FirstOrDefault(u => u.UsuarioId == usuarioId
                                      && u.Navegador != navegador);
    //Si ya tiene un acceso para esa ciudad regresamos false
    return acceso != null;
}

Creamos otro método para enviar el correo en caso de encontrar un nuevo acceso en otra ciudad o Navegador.

Agregamos un nuevo template para enviar el correo de aviso de sesión. En nuestra carpeta Templates creamos un archivo NuevoAcceso.html

NuevoAcceso.html
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <style>
        body {
            font-size: 1.3rem;
            color: #05678e;
        }

        .acceso {
            border-radius: 10px;
            border: solid 1px #ccc;
            padding: 20px;
        }

        label {
            display: inline-block;
            width: 130px;
            font-weight: bold;
        }

        .titulo {
            font-size: 1.5rem;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <p>
        ¡Hola {{usuario}}!
        <h3>Alguien accedió a tu cuenta en una nueva ciudad y/o 
        navegador</h3>
    </p>
    <div class="acceso">
        <span class="titulo">
            Nuevo acceso en:
        </span>
        <br />
        <label>Navegador:</label>{{navegador}}
        <br />
        <label>El:</label>{{fecha}}
        <br />
        <label>Cerca de:</label>{{ciudad}}, {{estado}}, {{pais}}
        <br />
        <label> Ip:</label>{{ip}}
        <hr />
        <p>
            Te enviamos este correo electrónico para asegurarnos de
            que hayas sido tú.
            Si no fuiste tú, por favor comunícate con nosotros.
        </p>
    </div>
</body>
</html>
UsuarioDAO.cs
private void EnviaCorreoNuevoAcceso(string path, string usuario, 
                                    string email, 
                                    DatosIPDTO datosIP, 
                                    string ip, 
                                    string navegador)
{
    string body = System.IO.File.ReadAllText(Path.Combine(path, "Templates", "NuevoAcceso.html"));
    body = body.Replace("{{usuario}}", usuario);
    body = body.Replace("{{ciudad}}", datosIP.city);
    body = body.Replace("{{estado}}", datosIP.subdivision);
    body = body.Replace("{{pais}}", datosIP.country);
    body = body.Replace("{{ip}}", ip);
    body = body.Replace("{{navegador}}", navegador);
            
    Correo mail = new Correo()
    {
        Para = email,
        Mensaje = body,
        Asunto = "Tu cuenta ha sido bloqueada"
    };
    try
    {
        mail.Enviar();
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.InnerException);
    }
}

Por último agregamos las funciones para registrar si el usuario se conecta de una nueva ciudad o ip.

UsuarioDAO.cs
public async Task<TokenDTO> LoginAsync(LoginDTO loginDTO, 
                    IConfiguration config, string ip, string navegador)
{
    //Demás código
    var esOtroNavegador = usuarioAccesoDAO
               .EsOtroNavegador(navegador, usuario.Id);
    var esOtraCiudad = await usuarioAccesoDAO
               .EsOtraCiudadAsync(ip, usuario.Id);
    if (esOtroNavegador || esOtraCiudad)
        EnviaCorreoNuevoAcceso(_path, usuario.Clave, usuario.Email, usuarioAccesoDAO.datosIP, ip, navegador);
    //Demás código para guardar el acceso
}

Para practicar puedes agregar otra validación para detectar el sistema operativo.

Como mejora se puede crear una interfaz que tenga una variable string y un método para validar el acceso, para realizar la mismas validaciones como se hizo con la interfaz IRegla

Otra mejora puede ser registrar las ips y su ciudad para no hacer tantas peticiones al servicio y ahorras costos.

Para poder reemplazar el servicio rest

  1. Crea una interfaz IPLocation con una función para obtener los datos de la IP

  2. Crea una clase IPGeoLocation que implemente la interfaz IPLocation para obtener los datos de la IP y regrese el mismo objeto DatosIPDto

  3. En UsuarioAccesoDAO agrega la siguiente función para recibir un objeto de la interfaz IPLocation.

public async Task<DatosIPDTO> ObtenerDatosIPAsync
                               (string ip, IPLocation ipLocation)
{
     return await ipLocation.ObtenerDatosPorIpAsync(ip);
}

4. Cambia la función EsOtraCiudadAsync para pasar como parámetro un objeto de la nueva clase IPGeoLocation.

public async Task<bool> EsOtraCiudadAsync(string ip, int usuarioId)
{
    IPGeoLocation ipGeoLocation = new IPGeoLocation();
    //Obtenemos los datos de la ip
    datosIP = await this.ObtenerDatosIPAsync(ip, ipGeoLocation);

De esta forma si en el futuro deseas agregar otro proveedor, solo debes crear la clase que implemente la interfaz IPLocation y agregarlo como parámetro

Previous9.8.1 ¿Cómo limitar el número de intentos incorrectos en el login?Next9.8.3 Habilitando CORS

Last updated 2 years ago

Was this helpful?

Como practica puedes conectarte al servicio .

https://www.iplocate.io/api/lookup/35.232.52.59
https://api.ipgeolocation.io/ipgeo
Free IP Geolocation DatabaseIP2Location
Logo
IP Geolocation API PricingIP Geolocation API
Logo
Free IP Address Geolocation API - Find country, city, ISP with IPLocate.io
https://www.jsonutils.comwww.jsonutils.com