< Summary

Information
Class: CoWorkingApp.Core.Application.Services.UserService
Assembly: CoWorkingApp.Core
File(s): H:\Vicentico\Proyectos\CoWorkingApp Project\CoWorkingApp\CoWorkingApp.Core\Application\Services\UserService.cs
Line coverage
100%
Covered lines: 84
Uncovered lines: 0
Coverable lines: 84
Total lines: 214
Line coverage: 100%
Branch coverage
100%
Covered branches: 36
Total branches: 36
Branch coverage: 100%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
.ctor(...)100%1100%
GetByEmailAsync()100%6100%
AuthenticateAsync()100%10100%
UpdateProperties(...)100%8100%
IsValid(...)100%8100%
EmailIsValid(...)100%2100%
PasswordIsValid(...)100%1100%
CredentialsIsValid(...)100%2100%

File(s)

H:\Vicentico\Proyectos\CoWorkingApp Project\CoWorkingApp\CoWorkingApp.Core\Application\Services\UserService.cs

#LineLine coverage
 1using CoWorkingApp.Core.Application.Abstracts;
 2using CoWorkingApp.Core.Application.Contracts.Adapters;
 3using CoWorkingApp.Core.Application.Contracts.Repositories;
 4using CoWorkingApp.Core.Application.Contracts.Services;
 5using CoWorkingApp.Core.Domain.DTOs;
 6using CoWorkingApp.Core.Domain.Entities;
 7using System.ComponentModel.DataAnnotations;
 8
 9namespace CoWorkingApp.Core.Application.Services
 10{
 11    /// <summary>
 12    /// Implementación concreta del servicio para la entidad User.
 13    /// </summary>
 14    public class UserService : ServiceGeneric<IUserRepository, User, UserRequest, UserResponse>, IUserService
 15    {
 16        /// <summary>
 17        /// Constructor de la clase UserService.
 18        /// </summary>
 19        /// <param name="repository">El repositorio de usuarios asociado al servicio.</param>
 22720        public UserService(IUserRepository repository, IMapperAdapter mapper) : base(repository, mapper) { }
 21
 22        // Implementación de métodos específicos de IUserService
 23
 24        /// <summary>
 25        /// Obtiene un usuario por su dirección de correo electrónico.
 26        /// </summary>
 27        /// <param name="email">La dirección de correo electrónico del usuario.</param>
 28        /// <returns>Un objeto UserResponse que representa al usuario encontrado.</returns>
 29        public async Task<UserResponse> GetByEmailAsync(string email)
 1030        {
 31            try
 1032            {
 33                // Verificar si el correo electrónico es nulo o vacío
 1034                if (string.IsNullOrEmpty(email))
 135                {
 36                    // Si es nulo o vacío, lanzar una excepción
 137                    throw new ArgumentNullException("The email cannot be null or empty");
 38                }
 39
 40                // Validar el formato del correo electrónico
 941                if (!EmailIsValid(email))
 342                {
 343                    throw new ValidationException("Argument is invalid.");
 44                }
 45
 46                // Obtener el usuario por su correo electrónico desde el repositorio. Si no, lanzar una excepción
 647                var user = await _repository.GetByEmailAsync(email) ?? throw new ArgumentException($"Email {email} not f
 48
 49                // Mapear el usuario a una respuesta de usuario y establecer el éxito en verdadero
 450                var response = _mapper.Map<User, UserResponse>(user);
 251                response.Success = true;
 252                return response;
 53            }
 154            catch (ArgumentNullException ex)
 155            {
 56                // Manejar la excepción de argumento nulo y generar una respuesta de error
 157                return HandleException(ex);
 58            }
 359            catch (ValidationException ex)
 360            {
 61                // Manejar la excepción de validación y generar una respuesta de error
 362                return HandleException(ex);
 63            }
 264            catch (ArgumentException ex)
 265            {
 66                // Manejar la excepción de argumento inválido y generar una respuesta de error
 267                return HandleException(ex);
 68            }
 269            catch (Exception ex)
 270            {
 71                // Manejar excepciones inesperadas y generar una respuesta de error
 272                var response = new UserResponse { Success = false, Message = ex.Message };
 273                response.Errors.Add(ex.Message);
 274                return response;
 75            }
 1076        }
 77
 78        /// <summary>
 79        /// Autentica a un usuario utilizando su dirección de correo electrónico y contraseña.
 80        /// </summary>
 81        /// <param name="request">La solicitud de autenticación que contiene la dirección de correo electrónico y la con
 82        /// <returns>Un objeto UserResponse que representa al usuario autenticado.</returns>
 83        public async Task<UserResponse> AuthenticateAsync(UserRequest request)
 2084        {
 85            try
 2086            {
 87                // Verificar si la solicitud es nula
 2088                if (request is null)
 189                {
 90                    // Si es nula, lanzar una excepción
 191                    throw new ArgumentNullException("The request object cannot be null or empty");
 92                }
 93
 94                // Verificar si el correo electrónico o la contraseña son nulos o vacíos
 1995                if (string.IsNullOrEmpty(request.Email) || string.IsNullOrEmpty(request.Password))
 896                {
 97                    // Si lo son, lanzar una excepción
 898                    throw new ArgumentNullException("The email or password cannot be null or empty");
 99                }
 100
 101                // Validar el formato del correo electrónico y la contraseña
 11102                if (!CredentialsIsValid(request.Email, request.Password))
 5103                {
 5104                    throw new ValidationException("Argument is invalid.");
 105                }
 106
 107                // Autenticar al usuario utilizando el correo electrónico y la contraseña proporcionados
 6108                var user = await _repository.AuthenticateAsync(request.Email, request.Password);
 109
 110                // Verificar si el usuario fue autenticado correctamente
 6111                if (user is null)
 2112                {
 113                    // Si no se autentica correctamente, lanzar una excepción
 2114                    throw new ArgumentException($"Credentials incorrect");
 115                }
 116
 117                // Mapear el usuario autenticado a una respuesta de usuario y establecer el éxito en verdadero
 4118                var response = _mapper.Map<User, UserResponse>(user);
 2119                response.Success = true;
 2120                return response;
 121            }
 9122            catch (ArgumentNullException ex)
 9123            {
 124                // Manejar la excepción de argumento nulo y generar una respuesta de error
 9125                return HandleException(ex);
 126            }
 5127            catch (ValidationException ex)
 5128            {
 129                // Manejar la excepción de validación y generar una respuesta de error
 5130                return HandleException(ex);
 131            }
 2132            catch (ArgumentException ex)
 2133            {
 134                // Manejar la excepción de argumento inválido y generar una respuesta de error
 2135                return HandleException(ex);
 136            }
 2137            catch (Exception ex)
 2138            {
 139                // Manejar excepciones inesperadas y generar una respuesta de error
 2140                return HandleException(ex);
 141            }
 20142        }
 143
 144        // Implementación de métodos abstractos de ServiceGeneric
 145
 146        /// <summary>
 147        /// ACTualiza las propiedades de un usuario existente con los valores de una solicitud de usuario.
 148        /// </summary>
 149        /// <param name="existingEntity">El usuario existente que se va a actualizar.</param>
 150        /// <param name="request">La solicitud de usuario con los nuevos valores.</param>
 151        /// <returns>El usuario actualizado.</returns>
 152        protected override User UpdateProperties(User existingEntity, UserRequest request)
 18153        {
 154            // ACTualizar las propiedades del usuario existente con los valores de la solicitud
 18155            return new User
 18156            {
 18157                Name = string.IsNullOrEmpty(request.Name) ? existingEntity.Name : request.Name,
 18158                LastName = string.IsNullOrEmpty(request.LastName) ? existingEntity.LastName : request.LastName,
 18159                Email = string.IsNullOrEmpty(request.Email) ? existingEntity.Email : request.Email,
 18160                Password = string.IsNullOrEmpty(request.Password) ? existingEntity.Password : request.Password,
 18161            };
 18162        }
 163
 164        /// <summary>
 165        /// Verifica si un usuario es válido.
 166        /// </summary>
 167        /// <param name="entity">El usuario que se va a validar.</param>
 168        /// <returns>True si el usuario es válido, de lo contrario False.</returns>
 169        protected override bool IsValid(User entity)
 28170        {
 171            // Verificar si el usuario es válido (ninguna propiedad debe ser nula o vacía)
 28172            return entity is not null
 28173                   && !string.IsNullOrEmpty(entity.Name)
 28174                   && !string.IsNullOrEmpty(entity.LastName)
 28175                   && !string.IsNullOrEmpty(entity.Email)
 28176                   && !string.IsNullOrEmpty(entity.Password);
 28177        }
 178
 179        // Métodos privados
 180
 181        /// <summary>
 182        /// Verifica si el formato de una dirección de correo electrónico es válido.
 183        /// </summary>
 184        /// <param name="email">La dirección de correo electrónico a validar.</param>
 185        /// <returns>True si el formato del correo electrónico es válido, de lo contrario False.</returns>
 186        private bool EmailIsValid(string email)
 20187        {
 188            // Verificar si el formato del correo electrónico es válido
 20189            return email.Length > 1 && email.Contains('@');
 20190        }
 191
 192        /// <summary>
 193        /// Verifica si una contraseña tiene una longitud mayor que 1.
 194        /// </summary>
 195        /// <param name="password">La contraseña a validar.</param>
 196        /// <returns>True si la contraseña tiene una longitud mayor que 1, de lo contrario False.</returns>
 197        private bool PasswordIsValid(string password)
 7198        {
 199            // Verificar si la contraseña tiene una longitud mayor que 1
 7200            return password.Length > 1;
 7201        }
 202
 203        /// <summary>
 204        /// Verifica si las credenciales de correo electrónico y contraseña son válidas.
 205        /// </summary>
 206        /// <param name="email">El correo electrónico a validar.</param>
 207        /// <param name="password">La contraseña a validar.</param>
 208        /// <returns>True si tanto el correo electrónico como la contraseña son válidos, de lo contrario False.</returns
 209        private bool CredentialsIsValid(string email, string password)
 11210        {
 11211            return EmailIsValid(email) && PasswordIsValid(password);
 11212        }
 213    }
 214}
Generated by: ReportGenerator 5.2.0.0
3/20/2024 - 5:49:01 PM
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoWorkingApp.Core.Application.Contracts.Repositories.IUserRepository,CoWorkingApp.Core.Application.Contracts.Adapters.IMapperAdapter)
GetByEmailAsync()
AuthenticateAsync()
UpdateProperties(CoWorkingApp.Core.Domain.Entities.User,CoWorkingApp.Core.Domain.DTOs.UserRequest)
IsValid(CoWorkingApp.Core.Domain.Entities.User)
EmailIsValid(System.String)
PasswordIsValid(System.String)
CredentialsIsValid(System.String,System.String)