Merge branch 'feature/abm-usuarios' into 'develop'

abm usuarios

See merge request !13

Tsi1.Api/Tsi1.Api/Controllers/UserController.cs

@@ -113,67 +113,177 @@ namespace Tsi1.Api.Controllers
             }
         }
 
-        [Authorize(Roles = UserTypes.FacultyAdmin)]
+        [Authorize(Roles = UserTypes.FacultyAdmin + ", " + UserTypes.UdelarAdmin)]
         [HttpPost("Register")]
-        public async Task<IActionResult> Register(UserRegisterDto dto)
+        public async Task<IActionResult> Register(UserRegisterDto dto, [FromQuery] int? tenantId = null)
         {
-            var tenantId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "TenantId").Value);
+            var myUserType = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Role).Value;
+
+            if (myUserType == UserTypes.UdelarAdmin && tenantId == null)
+            {
+                return BadRequest(string.Format(ErrorMessages.TenantDoesNotExist, tenantId));
+            }
+
+            if (myUserType == UserTypes.FacultyAdmin)
+            {
+                tenantId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "TenantId").Value);
+            }
 
             var userTypeResult = await _userTypeService.GetById(dto.UserTypeId);
 
+            if (userTypeResult.HasError)
+            {
+               return BadRequest(userTypeResult.Message);
+            }
+
+            var userType = userTypeResult.Data;
+
+            if (myUserType == UserTypes.UdelarAdmin &&
+                (userType.Name == UserTypes.Student ||
+                userType.Name == UserTypes.Professor))
+            {
+                return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
+            }
+
+            if (myUserType == UserTypes.FacultyAdmin &&
+                (userType.Name == UserTypes.UdelarAdmin ||
+                userType.Name == UserTypes.FacultyAdmin))
+            {
+                return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
+            }
+
+            var userServiceResult = await _userService.Create(dto, userType.Name, (int) tenantId);
+
+            if (userServiceResult.HasError)
+            {
+                BadRequest(userServiceResult.Message);
+            }
+
+            return Ok();
+        }
+
+        [Authorize(Roles = UserTypes.FacultyAdmin + ", " + UserTypes.UdelarAdmin)]
+        [HttpPut("Modify/{userId}")]
+        public async Task<IActionResult> Modify(UserModifyDto dto, int userId)
+        {
+            var myUserType = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Role).Value;
+
+            var userTypeResult = await _userService.GetUserType(userId);
+
             if (userTypeResult.HasError)
             {
                 return BadRequest(userTypeResult.Message);
             }
 
+            if (myUserType == UserTypes.FacultyAdmin)
+            {
+                var tenantId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "TenantId").Value);
+
+                var userTenant = await _userService.GetTenant(userId);
+
+                if (userTenant.HasError)
+                {
+                    return BadRequest(userTenant.Message);
+                }
+
+                if (userTenant.Data != tenantId)
+                {
+                    return BadRequest("No se puede modificar un usuario de otra facultad");
+                }
+            } 
+
             var userType = userTypeResult.Data;
 
-            if (userType.Name == UserTypes.UdelarAdmin ||
-                userType.Name == UserTypes.FacultyAdmin)
+            if (myUserType == UserTypes.UdelarAdmin &&
+                (userType.Name == UserTypes.Student ||
+                userType.Name == UserTypes.Professor))
+            {
+                return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
+            }
+
+            if (myUserType == UserTypes.FacultyAdmin &&
+                (userType.Name == UserTypes.UdelarAdmin ||
+                userType.Name == UserTypes.FacultyAdmin))
             {
                 return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
             }
 
-            var userServiceResult = await _userService.Create(dto, userType.Name, tenantId);
+            var userServiceResult = await _userService.Modify(dto, userType.Name, userId);
 
             if (userServiceResult.HasError)
             {
                 return BadRequest(userServiceResult.Message);
             }
 
+            if (userServiceResult.Data == false)
+            {
+                return NotFound(userServiceResult.Message);
+            }
+
             return Ok();
         }
 
-        [Authorize(Roles = UserTypes.UdelarAdmin)]
-        [HttpPost("RegisterAdmin/{tenantId}")]
-        public async Task<IActionResult> RegisterAdmin(UserRegisterDto dto, int tenantId)
+        [Authorize(Roles = UserTypes.FacultyAdmin + ", " + UserTypes.UdelarAdmin)]
+        [HttpDelete("Delete/{userId}")]
+        public async Task<IActionResult> Delete(int userId)
         {
-            var userTypeResult = await _userTypeService.GetById(dto.UserTypeId);
+            var myUserType = HttpContext.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Role).Value;
+
+            if (myUserType == UserTypes.FacultyAdmin)
+            {
+                var tenantId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "TenantId").Value);
+
+                var userTenant = await _userService.GetTenant(userId);
+
+                if (userTenant.HasError)
+                {
+                    return BadRequest(userTenant.Message);
+                }
+
+                if (userTenant.Data != tenantId)
+                {
+                    return BadRequest("No se puede borrar un usuario de otra facultad");
+                }
+            }
+
+            var userTypeResult = await _userService.GetUserType(userId);
 
             if (userTypeResult.HasError)
             {
-                BadRequest(userTypeResult.Message);
+                return BadRequest(userTypeResult.Message);
             }
 
             var userType = userTypeResult.Data;
 
-            if (userType.Name == UserTypes.Student ||
-                userType.Name == UserTypes.Professor)
+            if (myUserType == UserTypes.UdelarAdmin &&
+                (userType.Name == UserTypes.Student ||
+                userType.Name == UserTypes.Professor))
+            {
+                return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
+            }
+
+            if (myUserType == UserTypes.FacultyAdmin &&
+                (userType.Name == UserTypes.UdelarAdmin ||
+                userType.Name == UserTypes.FacultyAdmin))
             {
                 return BadRequest(string.Format(ErrorMessages.InvalidUserType, userType.Name));
             }
 
-            var userServiceResult = await _userService.Create(dto, userType.Name, tenantId);
+            var userServiceResult = await _userService.Delete(userId);
 
             if (userServiceResult.HasError)
             {
-                BadRequest(userServiceResult.Message);
+                return BadRequest(userServiceResult.Message);
+            }
+
+            if (userServiceResult.Data == false)
+            {
+                return NotFound(userServiceResult.Message);
             }
 
             return Ok();
         }
 
-
         [Authorize(Roles = UserTypes.Student + ", " + UserTypes.Professor + ", " + UserTypes.FacultyAdmin)]
         [HttpGet("GetAll")]
         public async Task<IActionResult> GetAll()

Tsi1.Api/Tsi1.BusinessLayer/Dtos/UserModifyDto.cs

+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class UserModifyDto
+    {
+        [Required]
+        public string Username { get; set; }
+
+        [Required]
+        public string Password { get; set; }
+
+        [Required]
+        public string FirstName { get; set; }
+
+        [Required]
+        public string LastName { get; set; }
+
+        [Required]
+        public string Email { get; set; }
+
+        [Required]
+        public string IdentityCard { get; set; }
+
+        public int Age { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Helpers/ErrorMessages.cs

@@ -16,6 +16,7 @@ namespace Tsi1.BusinessLayer.Helpers
         public const string ProfessorCourseAlreadyExists = "El profesor '{0}' ya es docente del curso '{1}'";
         public const string ProfessorCourseDoesNotExists = "El profesor '{0}' no es docente del curso '{1}'";
         public const string InvalidUsername = "El nombre de usuario debe ser de la forma: 'usuario@facultad'";
+        public const string DuplicateUsername = "Ya existe un usuario con username '{0}'";
 
 
         public const string ForumDoesNotExist = "El foro con id '{0}' no existe";

Tsi1.Api/Tsi1.BusinessLayer/Helpers/MappingProfile.cs

@@ -22,6 +22,7 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<Message, MessageCreateDto>();
             CreateMap<User, UserPreviewDto>();
             CreateMap<User, UserRegisterDto>();
+            CreateMap<User, UserModifyDto>();
             CreateMap<Student, StudentPreviewDto>();
             CreateMap<Professor, ProfessorPreviewDto>();
             CreateMap<Course, CourseCreateDto>();
@@ -40,6 +41,7 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<MessageCreateDto, Message>();
             CreateMap<UserPreviewDto, User>();
             CreateMap<UserRegisterDto, User>();
+            CreateMap<UserModifyDto, User>();
             CreateMap<StudentPreviewDto, Student>();
             CreateMap<ProfessorPreviewDto, Professor>();
             CreateMap<CourseCreateDto, Course>().ForMember(x => x.TenantId, opt => opt.Ignore());

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IUserService.cs

@@ -21,5 +21,13 @@ namespace Tsi1.BusinessLayer.Interfaces
         Task<ServiceResult<User>> GetByUsername(string username, int tenantId);
 
         Task<ServiceResult<bool>> UpdatePassword(int userId, string password);
+
+        Task<ServiceResult<bool>> Modify(UserModifyDto dto, string type, int userId);
+
+        Task<ServiceResult<int>> GetTenant(int userId);
+
+        Task<ServiceResult<bool>> Delete(int userId);
+
+        Task<ServiceResult<UserTypeDto>> GetUserType(int userId);
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Services/UserService.cs

@@ -57,6 +57,7 @@ namespace Tsi1.BusinessLayer.Services
             var result = new ServiceResult<User>();
 
             var user = _mapper.Map<User>(dto);
+
             user.TenantId = tenantId;
     
             if (type == UserTypes.Student)
@@ -85,6 +86,55 @@ namespace Tsi1.BusinessLayer.Services
             return result;
         }
 
+        public async Task<ServiceResult<bool>> Modify(UserModifyDto dto, string type, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var user = await _context.Users
+                .Include(x => x.Student)
+                .Include(x => x.Professor)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null)
+            {
+                result.Message = string.Format(ErrorMessages.UserDoesNotExist, userId);
+                return result;
+            }
+
+            if (dto.Username != user.Username)
+            {
+                var existingUser = await _context.Users
+                    .FirstOrDefaultAsync(x => x.Username == dto.Username 
+                        && x.TenantId == user.TenantId);
+
+                if (existingUser != null)
+                {
+                    result.HasError = true;
+                    result.Message = string.Format(ErrorMessages.DuplicateUsername, dto.Username);
+                    return result;
+                }
+            }
+
+            _mapper.Map(dto, user);
+
+            if (type == UserTypes.Student)
+            {
+                user.Student.IdentityCard = dto.IdentityCard;
+                user.Student.Age = dto.Age;
+            }
+
+            if (type == UserTypes.Professor)
+            {
+                user.Professor.IdentityCard = dto.IdentityCard;
+            }
+
+            await _context.SaveChangesAsync();
+
+            result.Data = true;
+
+            return result;
+        }
+
         public async Task<ServiceResult<List<UserPreviewDto>>> GetAll(int tenantId)
         {
             var result = new ServiceResult<List<UserPreviewDto>>();
@@ -194,5 +244,63 @@ namespace Tsi1.BusinessLayer.Services
 
             return result;
         }
+
+        public async Task<ServiceResult<int>> GetTenant(int userId)
+        {
+            var result = new ServiceResult<int>();
+
+            var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.UserDoesNotExist, userId);
+                return result;
+            }
+
+            result.Data = user.TenantId;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> Delete(int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var user = await _context.Users.FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null)
+            {
+                result.Message = string.Format(ErrorMessages.UserDoesNotExist, userId);
+                return result;
+            }
+
+            _context.Users.Remove(user);
+
+            await _context.SaveChangesAsync();
+
+            result.Data = true;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<UserTypeDto>> GetUserType(int userId)
+        {
+            var result = new ServiceResult<UserTypeDto>();
+
+            var user = await _context.Users
+                .Include(x => x.UserType)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.UserDoesNotExist, userId);
+            }
+
+            result.Data = _mapper.Map<UserTypeDto>(user.UserType);
+
+            return result;
+        }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Services/UserTypeService.cs

@@ -67,6 +67,5 @@ namespace Tsi1.BusinessLayer.Services
 
             return result;
         }
-
     }
 }