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
  • Validaciones
  • Crear el modelo
  • Crear el DBContext
  • Crear la Migración Inicial y actualizar la base de datos
  • Generar las clases de una base de datos existente

Was this helpful?

  1. 4. Creando tu primer servicio

4.2 Crear la tabla Categoría y sus validaciones

Con la base de datos creada vamos a crear nuestro primer modelo. Por convención todas las clases de las tablas estarán dentro de la carpeta Models.

Entity Framework incluye validaciones predefinidas que puedes utilizar, las mas comunes son:

Validaciones

Validación
Descripción

[Required]

El campo es obligatorio

[StringLength(30)]

El campo tiene máximo 30 caracteres

[Range(0,999.99)]

El campo acepta valores de 0 a 999.99. El campo debe ser de tipo decimal

[Compare("Password")]

El valor del campo debe ser igual al valor del campo Password.

[RegularExpression(@"^[SMAsma][0-9]{4}$"

Permite especificar una expresión a validar. En este caso la expresión regular indica que el campo debe empezar con cualquiera de las siguientes letras SMAsma y debe seguir de 4 números. Ejemplo S1801. Este campo podría indicar que es la semana 1 del año 2018

[Url]

El campo debe tener formato de URL

[Phone]

El campo debe ser un número de teléfono

[EmailAddress]

El campo debe tener formato de correo electrónico

[CreditCard]

El campo debe tener formato de tarjeta de crédito

Adicionalmente puedes crear validaciones personalizadas. Por ejemplo puedes agregar una validación que revise si una venta esta cancelada, se deben capturar los motivos de cancelación.

Primero vamos a crear la tabla en este caso crearemos la tabla Categoría.

Crear el modelo

  1. En el proyecto de Visual Studio agregamos una nueva carpeta llamada Models

  2. Dentro de la carpeta Models agregamos una nueva clase llamada Categoria.cs

  3. Tecleamos los nombres de los campos como propiedades públicas

    Categoria.cs
    public class Categoria 
    { 
        public int Id { get; set; }
            
        public int Clave { get; set; }
    
        public string Nombre { get; set; }
    }
  4. Agregamos las validaciones de cada campo

  5. Categoria.cs
    public class Categoria
    {
        public int Id { get; set; }
            
        [Required(ErrorMessage = "Por favor teclea el campo Clave")]
        [Range(1,999)]
        public int Clave { get; set; }
    
        [Required(ErrorMessage = "Por favor teclea el campo Nombre")]
        public string Nombre { get; set; }
    }

5. Para MySql debemos agregar el tipo de dato para los campos varchar o text e indicar que el campo Id es identity.

Categoria.cs
public class Categoria 
{ 
    [Key] 
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)] 
    public int Id { get; set; }
        
    [Required(ErrorMessage = "Por favor teclea el campo Clave")]
    [Range(1,999)]
    public int Clave { get; set; }
    
    [StringLength(80)]
    [Required(ErrorMessage = "Por favor teclea el campo Nombre")]
    [Column(TypeName = "VARCHAR(80)")]
    public string Nombre { get; set; }
}

Crear el DBContext

.NET cuenta con la clase DBContext que te permite interactuar con la base de datos. Todas las tablas que necesites en tu base de datos se irán agregando a esta clase.

  1. Dentro de la carpeta Models agrega una nueva clase llamada CaducaContext que herede de la clase DBContext. Puedes presionar la tecla Control y el . (punto) para agregar automáticamente el import.

  2. Agregamos el constructor el cual recibe como parámetro un DBContextOptions el cual indicará las opciones de la base de datos a utilizar.

    CaducaContext.cs
    public class : DbContext
    {
        public CaducaContext(DbContextOptions<CaducaContext> options) : base(options)
        {
        }      
    }
  3. Agregamos la tabla como virtual DbSet

    CaducaContext.cs
    public class CaducaContext : DbContext
    {
        public CaducaContext(DbContextOptions<CaducaContext> options)
                                                  : base(options)
        {
        }
        public virtual DbSet<Categoria> Categoria { get; set; }
    }
  4. Agregamos la cadena de conexión en el archivo appsetings. En este caso agregamos el usuario administrador.

appsettings.json
{ 
   "ConnectionStrings": {
     "DefaultConnection":"server=localhost;port=3306;database=caduca;
user=AdminCaduca;Password=StKRV6MR6A;sslMode=none"
   },
   "Logging": {
     "LogLevel": {
           "Default": "Warning"
     }
   },
   "AllowedHosts": "*"
}

5. En el archivo startup.cs configuramos que nuestra clase CadudaContext utilizará una base de datos MySQL y la cadena de conexión de nuestro archivo appsetings. Esto lo agregamos en el método ConfigureServices en este método estaremos configurando los servicios de nuestros servicios REST.

Startup.cs
public void ConfigureServices(IServiceCollection services) 
{    
   services.AddMvc().SetCompatibilityVersion(
   CompatibilityVersion.Version_2_2); 
   services.AddDbContext<CaducaContext>(options => 
                  options.UseMySql(Configuration
                         .GetConnectionString("DefaultConnection"))); 
}

Crear la Migración Inicial y actualizar la base de datos

Comandos para las migraciones

Para actualizar tu base de datos necesitamos ejecutar una serie de comandos. Se tienen 2 conjuntos de comandos desde el administrador de Paquetes que esta en visual Studio Comunity o desde la consola si estas en mac.

Los comandos para las migraciones desde Visual Studio Comunity son:

Comando

Descripción

Add-Migration nombre

Permite agregar una migración. Esta migración contiene todos los cambios realizados a los modelos de la base de datos.

Remove-Migration

En caso de encontrar algún error en la migración creado, lo podemos borrar con este comando. Solamente puedes revertir la última migración no aplicada

Update-Database

Permite actualizar la base de datos

Update-Database nombre

Permite actualizar la base de datos a la migración con el nombre de la migración pasado como parámetro

Script-Migration

Permite generar el script para crear y/o actualizar la base de datos

Creando la primer migración desde Visual Studio Comunity

Vamos a crear nuestra primer migración.

  1. Abrimos la consola del Administrador de Paquetes. Desde Visual Studio damos clic en Herramientas -> Administrador de Paquetes Nuget -> Consola del Administrador de Paquetes

  2. Ejecutamos el comando Add-Migration CreacionInicial. Esta instrucción nos creará una carpeta Migrations la cual contiene el código para crear la tabla categoría. Revisamos el archivo para ver que todo este correcto.

  3. Ejecutamos el comando Update-Database para crear la tabla. Si consultas tu base de datos de MySQL adicional a la tabla Categoría se crea la tabla __efmigrationshistory la cual guarda el registro de las migraciones aplicadas a la base de datos

Generar las clases de una base de datos existente

Si ya cuentas con tu base de datos, puedes utilizar el comando en la Consola del Administrador de Paquetes. Para esto crea un nuevo proyecto y agrega los paquetes del capítulo 2.3 Paquetes Nuget

La base de datos de la cual vamos a generar las clases es sakila la cual es una base de datos de ejemplo de mysql

El comando para generar las clases es:

Scaffold-DbContext 
"server=localhost;port=3306;user=AdminSakila;password=mypass;database=sakila"
MySql.Data.EntityFrameworkCore -OutputDir sakila -f
Previous4.1 Crear las base de datos y los usuarios en MySQLNext4.3 Creando el servicio Categorias

Last updated 9 months ago

Was this helpful?

Puedes ver la documentación oficial para las migraciones .

Puedes descargar el script de la base de datos sakila . Recuerda crear un usuario administrador para conectarte a la base de datos Sakila.

aqui
aqui