1-Descarga SQL Server Management Studio & Sql Server

 https://learn.microsoft.com/es-es/sql/ssms/download-sql-server-management-studio-
ssms?view=sql-server-ver16
 https://www.microsoft.com/es-es/sql-server/sql-server-downloads

CREAR BASE DE DATOS:

CREATE TABLE Familias (

Id INT NOT NULL IDENTITY PRIMARY KEY,

Nombre VARCHAR(100) NOT NULL

);

CREATE TABLE Productos (

Id INT NOT NULL IDENTITY PRIMARY KEY,

Nombre NVARCHAR (150) NOT NULL,

Precio DECIMAL (9, 2) NOT NULL,

FechaAlta DATE NULL,

Descatalogado BIT NOT NULL,

FotoURL NVARCHAR (MAX) NULL,

FamiliaId INT NOT NULL,

CONSTRAINT FK_Familias_Productos FOREIGN KEY (FamiliaId) REFERENCES Familias (Id)

);

2-CREAR PROYECTO: Nuevo proyecto (tipo Web Api para C#).

3-Añadir dependencias de Nugget al XML del proyecto:

<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.13" />

<PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.13"/>

4-Crear archivo scaffold.txt con el siguiente contenido:

Scaffold-DbContext "Data Source=(localdb)\mssqllocaldb;Initial Catalog=MiAlmacen;Integrated

Security=True" -Provider Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models -force -
project WebAPIAlmacen

En una sola línea.

5 - Personalización del archivo SCAFFOLD.TXT

Data Source= Ponemos nuestro servidor

Initial Catalog= Base de datos

-Provider hace referencia al motor de base de datos a emplear, en nuestro caso SQl Server. Para otras bases de
datos, buscar documentación

-OutputDir = Si queremos cambiar el nombre a la carpeta donde van a ir los modelos, cambiamos models por otro
nombre

-force sobrescribe los modelos anteriores

WebAPIAlmacen será el proyecto donde integrará los modelos

6-Crear wwwroot si procede un front agregar al program app.UseFileServer();

7-Empezar a agregar los copntroladores Web api vacíos.

8-Agregar al app.settings.Development.json

"Logging": {

"LogLevel": {

"Default": "Information",

"Microsoft.AspNetCore": "Warning"

},

"ConnectionStrings": {

"DefaultConnection": "Data Source=(localdb)\\mssqllocaldb;Initial Catalog=Almacen;Integrated Security=True"

9-Realizar las inyecciones de dependencias a los controladores:

private readonly MiAlmacenContext _context;

public FamiliasController(MiAlmacenContext context)

_context = context;

10-Agregar al program:

// Capturamos del app.settings la cadena de conexión a la base de datos

// Configuration.GetConnectionString va directamente a la propiedad ConnectionStrings y de ahí tomamos el valor de DefaultConnection

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

// Nuestros servicios resolverán dependencias de otras clases

// Registramos en el sistema de inyección de dependencias de la aplicación el ApplicationDbContext

// Conseguimos una instancia o configuración global de la base de datos para todo el proyecto

builder.Services.AddDbContext<MiAlmacenContext>(options => options.UseSqlServer(connectionString));

11-Agregar getters a los controladores.

12-Respecto a action result:

ActionResult es lo que debería devolver todo proceso asíncrono. Es lo que nos va a permitir devolver un código de éxito
(Ej. 200)

o fracaso (Ej. 400).

ActionResult puede ir acompañado del tipo de dato que el endpoint va a devolver. En este caso, devolvemos una lista de
familias. Un try / catch debe siempre codificarse en una operación asíncrona porque puede dar error. Un error que rompa de forma
abrupta

la ejecución del servidor. Nosotros haremos un try/catch global por medio de desarrollar un filtro de excepción

Devolvemos el ActionResult. Es un Ok que por detrás es una especificación del código 200

Si no ponemos Ok, por defecto, al resultado que devolvemos, le pone un código 200

return Ok(listaOrdenada);

En caso de error devolvemos un error. Esos errores están en diferentes objetos. BadRequest devuelve un 400

return BadRequest("Error en la operación");

/Si no recordamos el objeto podemos retornar un StatusCode de la enumeración StatusCodes. En el ejemplo, devolvemos
un 500

// return StatusCode(StatusCodes.Status500InternalServerError);

Si además queremos devolver un mensaje personalizado aparte del código de error, podemos crear un objeto ContentResult con
las características que queramos. En el ejemplo, un error 500 (InternalServerError) con un mensaje (Content) "Se ha producido un
error de acceso a la base de datos"

13-Deshabilitar el tracking añadiendo al program

builder.Services.AddDbContext<MiAlmacenContext>(options =>

options.UseSqlServer(connectionString);

// Esta opción deshabilita el tracking a nivel de proyecto (NoTracking).

// Por defecto siempre hace el tracking. Con esta configuración, no.

// En cada operación de modificación de datos en los controladores, deberemos habilitar el tracking en cada
operación

options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);

);

14-Poner métodos Put en los controladores, con tracking. Y métodos con paginación

15-Crear DTOs a partir de los modelosa conveniencia.

16- Métodos Delete y Post en los controladores. Métodos que agrupen, métodos con parámetros y sin parámetros.
Métodos que agreguen varios, métodos con sql de consulta, de inserción,

17-Comprobar que no haya dos endpoints con el mismo valor.

18 - DTOs personalizados para un filtro. Método con Queryable.

19- Añadir Servicios y validadores. Los servicios hay que añadirlos en el program:
builder.Services.AddTransient<GestorArchivosLocal>();

builder.Services.AddTransient<OperacionesService>();

20-Los validadores se añaden desde los DTOs o DTO que vayamos a usar:
[PesoArchivoValidacion(PesoMaximoEnMegaBytes: 4)]

[TipoArchivoValidacion(grupoTipoArchivo: GrupoTipoArchivo.Imagen)]

[PaginasValidacion(maxPaginas: 2000)]

21- Los métodos de los servicios se llaman desde los métodos de los controllers, también hayu que añadir la
inyección de dependencias en los constructores de los controladores:

private readonly MiBibliotecaContext _context;

private readonly GestorArchivosLocal _gestorArchivosLocal;

private readonly OperacionesService _operacionesService;

public LibrosController(MiBibliotecaContext context, GestorArchivosLocal gestorArchivosLocal, OperacionesService

operacionesService)

_context = context;

_gestorArchivosLocal = gestorArchivosLocal;

_operacionesService = operacionesService;

22 – Crear una interfaz en c# que determine los métodos que va a tener un servicio en específico, y añadir definición
al servicio en cuestión mediante herencia (Clase : Interface) y en el program:
builder.Services.AddTransient<IGestorArchivos,GestorArchivosLocal>();

22b -PARA AÑADIR UNA INTERFAZ QUE DEFINA UN SERVICIO Y AÑADIR UNA TAREA SINGLETON
1--CREAR UNA INTERFACE IGESTORARCHIVOS

2--Modificar el Servicio añadiendo implementación de la interfaz

3--Cambiar las definiciones de la clase GestorArchivosLocal por IGestorArchivos que es la interfaz, cambiar en la propiedad y en el
constructor

4--Cambiar la línea de añadir el servicio en el program:

builder.Services.AddTransient<IGestorArchivos, GestorArchivosLocal>();

5--Copiar o crear el servicio singleton partiendo de TareaProgramadaService.cs

6--Tocar las líneas del servicio:

a-EEl Timer con el tiempo tras el que

ejecutará la tarea

b-Cambiar el context al que estemos usando

c-Cambiar el método que realizará la tarea

7--Para que escriba el Servicio "Proceso finalizado" hay que iniciar el proyecto(run) seleccionando IIS Express en vez de http o
https, y luego detener el servidor desde la barra de tareas de Windows, abajo
23-AÑADIMOS UN MIDDLEWARE generando la clase(ejemplo:LogFileIPMiddleware.cs)

a. Crear carpeta middleware

b. Añadir o crear la clase
c. Añadir el middleware al program: // app.UseMiddleware<LogFileIPMiddleware>();

24- Añadimos el/los FILTROS DE EXCEPCIÓN generando la clase(ejemplo: FiltroDeExcepcion.cs)

a. Crear carpeta Filters

b. Añadir o crear la clase
c. Modificar el método
d. Añadir el filtro al program:
builder.Services.AddControllers(options =>
{
// Integramos el filtro de excepción para todos los controladores
options.Filters.Add(typeof(FiltroDeExcepcion));
}).AddJsonOptions(options => options.JsonSerializerOptions.ReferenceHandler =
ReferenceHandler.IgnoreCycles);

25-AÑADIR POLITICA CORS añadiendo los códigos en el program- Línea add cors y línea UseCors.

builder.Services.AddCors(options =>

options.AddDefaultPolicy(builder =>

builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();

});

});

app.UseCors();

25- Añadir la tabla Usuarios a la base de datos:

CREATE TABLE Usuarios (

Email NVARCHAR(100) not null PRIMARY KEY,

Password NVARCHAR(100) not null,

Salt VARBINARY(MAX) not null,

);

26- Realizar Scaffolding para integrar la tabla en el proyecto.

27- Crear un servicio de Hash que encripte la contraseña de un usuario(Clase HashService).

28-Crear un controller para los usuarios. Con métodos AddUsuario y login.

29-Añadir al program las líneas de autenticación por token y al swagger la posibilidad de añadir tokens.

30 - Comprobar el app setting.json que tenga la ConnectionString y las líneas para gestionar el token, mirar proyecto
almacén.
EXTRA AÑADIR SERILOG
A continuación se hará un tutorial extra para añadir Serilog a nuestra aplicación.

1- Incluir dependencias con los paquetes:

<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="7.0.9" />
<PackageReference Include="Serilog.AspNetCore" Version="7.0.0" />
<PackageReference Include="Serilog.Settings.Configuration" Version="7.0.1" />
<PackageReference Include="Serilog.Sinks.MSSqlServer" Version="6.3.0" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
2- Añadir al appsettings.Develovment.json la siguiente información
a.
"Serilog": {
"MinimumLevel": "Information",
"WriteTo": [
{
"Name": "MSSqlServer",
"Args": {
"connectionString": "Data Source=WENDIGOW11;Initial Catalog=MiFacturacion;Integrated
Security=True;TrustServerCertificate=True",
"tableName": "Logs",
"autoCreateSqlTable": true
}
}
]
}
3- Añadir al program la siguiente instrucción:
// Serilog
Log.Logger = new
LoggerConfiguration().ReadFrom.Configuration(builder.Configuration).CreateLogger();
builder.Host.UseSerilog();

4- Añadir el objeto logger como propiedad al controlador que se desee:

private readonly ILogger<FamiliasController> _logger;
5- Inyectarlo y asignarlo en el CONSTRUCTOR, no olvidar.
6- Añadir instrucciones del logger en los endpoints:

_logger.LogInformation("Obteniendo clientes"); // Ejecutar y ver el resultado en consola o en ventana

salida
// Si en el appsettings.Development.json marcamos un nivel de log superior al information, por
ejemplo // Warning, los mensajes
// de información no se van a ver
_logger.LogWarning("Obteniendo clientes");
var lista = await _context.Clientes.ToListAsync();
_logger.LogWarning("Primer cliente: " + lista[0].Nombre);
 APPS EN TIEMPO REAL TUTORIAL SIGNAL CON HUBS
1- Crear proyecto ASP.NET Core Web Api pero sin implementar openApi y añadiendo controladores si se
muestra la opción.
2- Eliminamos el controller y la clase de demostración.
3- Crear la carpeta wwwroot en la raíz del proyecto(no de la solución).
4- Crear un archivo index.html
5- Añadir en el launchSettings.json index.html donde ponía forecast lanchurl.
6- Añadir la línea al program app.UseStaticFiles();
7- Crear carpeta Hubs y la clase ChatHub, o el componente que queramos desarrollar. Es necesario que la
carpeta sea Hubs y no Hub para que no colisione con la clase Hub.
8- Añadimos al program.cs la línea a continuación justo antes del builder.Build()
builder.Services.AddSignalR();
9- Añadir la línea: app.UseRouting(); para poder tener una relación cliente servidor, especificando una ruta
con el siguiente bloque de código:

app.UseEndpoints(endpoints =>
{
endpoints.MapHub<ChatHub>("/chatHub"); // El acceso al hub sería vía
https://localhost:puerto/chatHub
});

10- Crear carpeta JS en la carpeta wwwroot y crear archivo chat.js. Desarrollar nuestro componente en ese
archivo.
11- Probar la conexión.
12- Asegurarse de incluir la librería de SignalR en el html.
<script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/7.0.14/signalr.min.js"></script>
13- Crear carpeta clases y crear la clase Message.
14- Crear una interfaz para el hub (ICHAT) con métodos.
15- Agregar la interface al Hub Hub<IChat>.
16- Cambiar el Hub.
17- Añadir código al chat.js si no se ha añadido(btn desconectar/conectar)
18- Crear clase Connection(Id, User).
19- Utilizar la clase conection en el back(chatHub.cs)
20- Métodos connection y diconnect
21- Comprobar que tenemos todo el código correcto y no da errores.

PARTE 2
1- Vamos a añadir métodos nuevos - añadimos método get users a la interface IChat
Task GetUsers(List<Connection> connections);
2- Añadir la llamada al método anterior a los métodos SendMessage y OnDisconnectedAsync
await Clients.All.GetUsers(conexiones);
3- Añadir una lista de usuarios a la vista HTML5
4- Añadir llamada al método en el chat.js

ADAPTAR UN PROYECTO AL USO DE SIGNALR

ADAPTAR PROYECTO A SIGNALR

1- Copiar index.html al index.html de la biblioteca con los cambios.(interfaz mejorada)

2-Copiar chat.js al chat.js de la biblioteca(añade métodos e instrucciones)

3-Copiar clases Connection y Message(cambiar namespaces)

4-Copiamos interfaz IChat a nuestra biblioteca(en Hubs o en carpeta interfaces(crear si se quiere)) recuerda los
namespaces.

5-Copiar el chatHub.cs que ha pasado JL a las 10:27(el hub con metodos conected y disconected) comprobar
namespaces, y obserbar cambios en la clase-recomendacion-

6-En el hub(backEnd), comprobar que utilizamos la clase Connection y las llamadas a las conexiones en el
chat.js(frontEnd)

1- Crear la carpeta wwwroot en la raíz del proyecto(no de la solución).

2- Crear un archivo index.html
3- Añadir en el launchSettings.json index.html donde ponía forecast lanchurl.
4- Añadir la línea al program app.UseStaticFiles();
5- Crear carpeta Hubs y la clase ChatHub, o el componente que queramos desarrollar. Es necesario que la
carpeta sea Hubs y no Hub para que no colisione con la clase Hub.
6- Añadimos al program.cs la línea a continuación justo antes del builder.Build()
builder.Services.AddSignalR();
7- Añadir la línea: app.UseRouting(); para poder tener una relación cliente servidor, especificando una ruta
con el siguiente bloque de código:

app.UseEndpoints(endpoints =>
{
endpoints.MapHub<ChatHub>("/chatHub"); // El acceso al hub sería vía
https://localhost:puerto/chatHub

});

AÑADIR UN AVATAR A NUESTRA APLICACIÓN

AÑADIR UN MICROSERVICIO
1. Crear un proyecto junto al almacen. De tipo Web API también. Sin openAPI.
2. Crear carpeta wwwroot. Crear index.html
3. Añadir al program - app.UseStaticFiles();.
4. Crear carpeta services.
5. Copiar un servicio del proyecto almacen GestorArchivosLocal. Quitar implementación interfaz.
6. Añadir el servicio en el program con AddTransient< GestorArchivosLocal >();.
7. Crear carpeta Controllers y crear un controlador WebApi en blanco. Le llamamos
ArchivosController.
8. Crear carpeta DTOs. Añadir DTOArchivos.
9. Copiar contenido del controller que pasó Juan Luis.
10. Cambiar IP en el controller y en el launchSettings.
11. Configurar proyectos para que inicien los dos a la vez.
 AÑADIR UN gRPC

1. Crear proyecto gRPC. Tipo gRPC

2. Microsoft.EntityFrameworkCore.SqlServer, Microsoft.EntityFrameworkCore.Tools,
Microsoft.Extensions.Configuration.FileExtensions y Microsoft.Extensions.Configuration.Json
Los dos primeros son para EF y los dos últimos para utilizar Iconfiguration
3. Comprobar appSettings.json para la connectionstring.
4. Hacer scaffolding desde la base de datos.
5. Borramos greeter.proto y greeterServcice.
6. En la carpeta protos creamos un nuevo “Archivo de buffer de protocolo” familia_grpc.proto.
7. En el proto, hay que crear los *message* para las request y las replies.
8. Las propiedades de las Requetest y repllies deben de ser asignadas a un número correlativo en
cada propiedad, pero se puede alterar el orden en el que van numeradas esas propiedades.
9. DOCUMENTACIÓN DE GOOGLE:
https://developers.google.com/protocol-buffers/docs/proto3
10. Añadimos el paquete Protobuf al ItemGroup del archivo del proyecto:

<Protobuf Include="Protos\familia_grpc.proto" GrpcServices="Server" />

11. Creamos un nuevo servicio gRPC en la carpeta Services, añadir herencia de

FamiliaGrpc.FamiliaGrpcBase que se podrá añadir si hemos añadido con éxito el paquete
Protobuf en el ItemGroup.
12. Copiar el contenido que pasa Juan Luis al interior del GRPCSERVICE anterior.
13. Cambiar el servicio GreeterService en el program por nuestro servicio, y añadir el context con
las líneas:

var connectionString = builder.Configuration.GetConnectionString("defaultConnection");

builder.Services.AddDbContext<MiAlmacenContext>(options =>
options.UseSqlServer(connectionString));
app.MapGrpcService<FamiliaGrpcService>();

14. Agregamos los paguetes Nuget Google.Protobuf, Grpc.Net.Client y Grpc.Tools al proyecto

WEBAPI.
15. En el proyecto web api creamos la carpeta PROTOS. Y el proto del gRPC lo copiamos tal cual a
esa carpeta.
16. Añadimos la línea al archivo de proyecto WEB API:

<Protobuf Include="Protos\familia_grpc.proto" GrpcServices="Client" />

17. Añadimos métodos al controller del modelo cuyos datos vamos a tratar, en este caso
FamiliasController.
18.