Merge branch 'cgalvis/lib-230' into 'master'

Definir estructura de proyectos con ASP.NET

See merge request !5

docs/development-rules/README.md

@@ -8,6 +8,7 @@
 - [Marco de trabajo](sections/team-framework.md) 🤝 - ¡Conoce cómo organizamos nuestro trabajo en equipo! 🗓️ Este documento te explicará cómo colaboramos y nos coordinamos para lograr nuestros objetivos.
 - [Tareas (tickets)](sections/tickets.md) 🎫 - ¡Aprende cómo gestionamos nuestras tareas! 📝 Este documento te mostrará cómo utilizamos los tickets para organizar y priorizar nuestro trabajo.
 - [Versionamiento de código fuente](sections/code-versioning.md) 💾 - ¡Domina el control de versiones! 💪 Este documento te enseñará cómo versionamos nuestro código fuente para mantener un historial de cambios y colaborar de manera segura.
+- [Proyectos back end](sections/backend-structure.md) ⚙️ - ¡Definamos como será la estructura de proyectos back end!
 
 ## Secciones pendientes 🚧
 

docs/development-rules/sections/backend-structure.md

+# Estructura de proyectos back end
+
+### Proyectos con ASP.NET
+
+Para proyectos en ASP.NET, se ha implementado un patrón de arquitectura inspirado en [Arquitectura en cebolla (onion)](https://medium.com/@alessandro.traversi/understanding-onion-architecture-an-example-folder-structure-9c62208cc97d), siguiendo las recomendaciones de [Microsoft](https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures).
+
+Se recomienda entender el funcionamiento de los siguientes principios y patrones de diseño:
+
+- [Principios SOLID](https://www.digitalocean.com/community/conceptual-articles/s-o-l-i-d-the-first-five-principles-of-object-oriented-design)
+- [Patrón DTO (Data Transfer Object)](https://www.baeldung.com/java-dto-pattern)
+- [Patrón Repositorio (Repository)](https://medium.com/@pererikbergman/repository-design-pattern-e28c0f3e4a30)
+- [Patrón de Inyección de Dependencias (Dependency Injection - DI)](https://www.geeksforgeeks.org/system-design/dependency-injectiondi-design-pattern/)
+
+Este patrón de arquitectura utiliza las siguientes capas:
+
+> Fuente: [milanjovanovic.tech](https://www.milanjovanovic.tech/blog/clean-architecture-folder-structure)
+
+![Onion diagram](/resources/images/architecture-patterns/clean-architecture.png)
+
+Se recomienda que la estructura de carpetas de la solución sea así:
+
+```sh
+.
+├── .env                # Archivo con variables de entorno
+├── *.sln               # Archivo de la solución de .NET
+└── src                 # Código fuente
+    ├── Application
+    ├── Core
+    ├── Infrastructure
+    └── WebApi
+```
+
+#### Capa `Core`
+
+Esta capa contiene código del dominio y reglas de negocio que se reutilizan en la solución. Se debe evitar que esta capa tenga dependencias externas.
+
+```sh
+src/Core
+├── Core.csproj         # Archivo del proyecto de .NET
+├── Domain              # Archivos del dominio
+│   ├── Entities        # Clases de entidades de las bases de datos
+│   └── Utils           # Clases generales
+│       ├── Constants   # Clases con constantes
+│       └── Enums       # Clases con enumeraciones
+└── Interfaces          # Interfaces generales del sistema
+```
+
+#### Capa `Application`
+
+Capa en donde se maneja la lógica de negocio para los casos de uso.
+
+> **NOTA:** En esta capa se agregan los `DTOs`, ya que son adaptaciones de los datos que viajan entre el sistema y el exterior (`WebApi`). No se agregan en la capa `Core`, debido a que (usualmente) no es su responsabilidad conocer cómo se van a transformar los datos en capas externas.
+
+```sh
+src/Application
+├── Application.csproj  # Archivo del proyecto de .NET
+├── DTOs                # Clases de tipo DTO
+├── Interfaces          # Interfaces generales del sistema
+├── Mappings            # Clases para mapeo de entidades y DTOs
+├── Services            # Servicios del sistema
+├── Specifications      # Especificaciones de consultas en bases de datos
+├── Utils               # Utilidades generales del sistema
+└── Validators          # Reglas de validaciones de clases
+```
+
+#### Capa `Infrastructure`
+
+Capa en donde se manejarán conexiones con bases de datos y sistemas externos.
+
+```sh
+src/Infrastructure
+├── Infrastructure.csproj       # Archivo del proyecto de .NET
+├── Integrations                # Archivos de configuración de sistemas externos
+└── Persistence                 # Archivos para la base de datos principal (SQL)
+    ├── Config                  # Archivos de configuración
+    │   ├── DependencyRegistry  # Archivos de configuración para registro de dependencias
+    │   └── Entities            # Archivos de configuración de entidades de la base de datos
+    ├── GeneralContext.cs       # Contexto de base de datos (SQL)
+    ├── Migrations              # Migraciones de la base de datos
+    └── Repositories            # Repositorios de las entidades
+```
+
+#### Capa `WebApi`
+
+Capa de presentación.
+
+```sh
+src/WebApi
+├── WebApi.csproj           # Archivo del proyecto de .NET
+├── Config                  # Archivos de configuración (registro de dependencias, configuración de complementos, etc ...)
+│   ├── DependencyRegistry  # Archivos de configuración para registro de dependencias
+│   ├── DocsSetup           # Archivos de configuración del sistema de documentación (Swagger)
+│   └── LoggerSetup         # Archivos de configuración del sistema de registros (logs)
+├── Controllers             # Controladores del proyecto
+│   ├── Rest                # Controladores REST
+│   └── Tools               # Controladores personalizados (plantillas de correo electrónico, generadores de documentos, herramientas, etc ...)
+├── Interfaces              # Interfaces generales del sistema
+├── Program.cs              # Clase principal del proyecto
+├── Properties              # Carpeta de propiedades del proyecto (ASP.NET)
+└── Utils                   # Utilidades del proyecto
+```
+
+* volver al [inicio](/README.md)
+* volver a las [normas de desarrollo](/docs/development-rules/README.md)
\ No newline at end of file

docs/development-rules/sections/code-style.md

@@ -5,22 +5,27 @@
 Dependiendo del lenguaje, se deberá utilizar la convención de nombres por defecto del mismo. Algunos ejemplos son:
 
 | Lenguaje                     | Convención de nombres                                                                                                    |
-| ----- | ----- |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
 | Javascript, Typescript, Java | [camelCase](https://en.wikipedia.org/wiki/Camel_case)                                                                    |
 | Python                       | snake\_case y camelCase ([ver](https://peps.python.org/pep-0008/#naming-conventions))                                    |
 | Ruby                         | snake\_case y camelCase (ver guía de ruby y guía de RoR)                                                                 |
 | SQL                          | [snake\_case](https://en.wikipedia.org/wiki/Snake_case)                                                                  |
 | MongoDB                      | camelCase con [variaciones](https://www.mongodb.com/docs/manual/reference/limits/#naming-restrictions)                   |
+| C#                           | PascalCase con [variaciones](https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/identifier-names) |
 
 ## Lenguaje de marcado para comentarios
 
 Dependiendo del lenguaje, se deberá documentar el código con el formato por defecto del mismo. Algunos ejemplos son:
 
-| Lenguaje               | Convención de nombres                                                                 |
-| ---------------------- | ------------------------------------------------------------------------------------- |
+| Lenguaje               | Formato                                                                                                |
+| ---------------------- | ------------------------------------------------------------------------------------------------------ |
 | Javascript, Typescript | [JSDoc](https://jsdoc.app)                                                                             |
 | Java                   | [Javadoc](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javadoc.html)                  |
 | Python                 | [Docstring](https://peps.python.org/pep-0008/#documentation-strings)                                   |
 | Ruby                   | [RDoc](https://github.com/ruby/rdoc)                                                                   |
+| C#                     | [XML Docs](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/recommended-tags) |
+
+**NOTA:** Este tipo de documentación en el código fuente es obligatoria para clases, interfaces y funciones. Para las funciones, se deberán documentar también los tipos de parámetros y el tipo de retorno si aplica (incluyendo manejo de excepciones)
 
-**NOTA:** El uso de este tipo de comentarios será obligatorio para clases, interfaces y funciones. Para las funciones, se deberán documentar también los tipos de parámetros y el tipo de retorno si aplica (incluyendo manejo de excepciones)
\ No newline at end of file
+* volver al [inicio](/README.md)
+* volver a las [normas de desarrollo](/docs/development-rules/README.md)
\ No newline at end of file

docs/development-rules/sections/tools-and-frameworks.md

@@ -3,7 +3,7 @@
 El uso de diferentes herramientas y frameworks será determinado para cada proyecto, en conjunto con los miembros del equipo, a continuación se presentan algunas recomendaciones generales.
 
 ### Recomendaciones generales
-* Tener compatibilidad total con el sistema operativo *GNU/Linux* (para facilitar su contenerización y orquestación).
+* Tener compatibilidad total con el sistema operativo *GNU/Linux* (para facilitar su contenedorización y orquestación).
 
 ## Back end