Merge branch 'feature/evaluation' into 'develop'

Feature/evaluation

See merge request !37

Tsi1.Api/Tsi1.Api/Controllers/ActivityController.cs

@@ -81,64 +81,5 @@ namespace Tsi1.Api.Controllers
             return Ok();
         }
 
-        [Authorize(Roles = UserTypes.Professor)]
-        [HttpPut("AddOrModifyGrade")]
-        public async Task<IActionResult> AddOrModifyGrade(GradeDto gradeDto)
-        {
-            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
-            var result = await _activityService.AddOrModifyGrade(gradeDto, userId);
-
-            if (result.HasError)
-            {
-                return BadRequest(result.Message);
-            }
-
-            return Ok(result.Data);
-        }
-
-        [Authorize(Roles = UserTypes.Professor)]
-        [HttpDelete("DeleteGrade/{activityId}/{userId}")]
-        public async Task<IActionResult> DeleteGrade(int activityId, int userId)
-        {
-            var myUserId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
-            var result = await _activityService.DeleteGrade(myUserId, activityId, userId);
-
-            if (result.HasError)
-            {
-                return BadRequest(result.Message);
-            }
-
-            return Ok();
-        }
-
-        [Authorize(Roles = UserTypes.Student)]
-        [HttpGet("GetMyGrades/{activityId}")]
-        public async Task<IActionResult> GetMyGrades(int activityId)
-        {
-            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
-            var result = await _activityService.GetMyGrades(activityId, userId);
-
-            if (result.HasError)
-            {
-                return BadRequest(result.Message);
-            }
-
-            return Ok(result.Data);
-        }
-
-        [Authorize(Roles = UserTypes.Professor + ", " + UserTypes.FacultyAdmin)]
-        [HttpGet("GetAllGrades/{activityId}")]
-        public async Task<IActionResult> GetAllGrades(int activityId)
-        {
-            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
-            var result = await _activityService.GetAllGrades(activityId, userId);
-
-            if (result.HasError)
-            {
-                return BadRequest(result.Message);
-            }
-
-            return Ok(result.Data);
-        }
     }
 }

Tsi1.Api/Tsi1.Api/Controllers/EvaluationController.cs

+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+
+namespace Tsi1.Api.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class EvaluationController : ControllerBase
+    {
+        private readonly IEvaluationService _evaluationService;
+
+        public EvaluationController(IEvaluationService evaluationService)
+        {
+            _evaluationService = evaluationService;
+        }
+
+        [Authorize(Roles = UserTypes.Student)]
+        [HttpPost("Registration/{evaluationId}")]
+        public async Task<IActionResult> GetAll(int evaluationId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.Registration(evaluationId, userId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        [Authorize(Roles = UserTypes.Student)]
+        [HttpPost("CancelRegistration/{evaluationId}")]
+        public async Task<IActionResult> CancelRegistration(int evaluationId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.CancelRegistration(evaluationId, userId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        [Authorize(Roles = UserTypes.Student)]
+        [HttpPost("SubmitLaboratory/{evaluationId}")]
+        public async Task<IActionResult> SubmitLaboratory(FileDto fileDto, int evaluationId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.SubmitLaboratory(fileDto, evaluationId, userId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        [Authorize(Roles = UserTypes.Student)]
+        [HttpDelete("DeleteLaboratory/{submissionId}")]
+        public async Task<IActionResult> DeleteLaboratory(int submissionId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.DeleteLaboratory(submissionId, userId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        [Authorize(Roles = UserTypes.Student)]
+        [HttpGet("GetMyEvaluationInscriptions/{courseId}")]
+        public async Task<IActionResult> GetMyEvaluationInscriptions(int courseId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.GetMyEvaluationInscriptions(userId, courseId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        [Authorize(Roles = UserTypes.Professor)]
+        [HttpGet("GetAllEvaluationInscriptions/{evaluationId}")]
+        public async Task<IActionResult> GetAllEvaluationInscriptions(int evaluationId)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.GetAllEvaluationInscriptions(userId, evaluationId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+
+        //QualifyEvaluationInscription(EvaluationInscriptionModifyDto evaluationInscriptionDto, int userId);
+        [Authorize(Roles = UserTypes.Professor)]
+        [HttpPost("QualifyEvaluationInscription")]
+        public async Task<IActionResult> SubmitLaboratory(EvaluationInscriptionModifyDto evaluationInscriptionDto)
+        {
+            var userId = int.Parse(HttpContext.User.Claims.FirstOrDefault(x => x.Type == "Id").Value);
+
+            var result = await _evaluationService.QualifyEvaluationInscription(evaluationInscriptionDto, userId);
+
+            if (result.HasError)
+            {
+                return BadRequest(result.Message);
+            }
+
+            return Ok(result.Data);
+        }
+    }
+}

Tsi1.Api/Tsi1.Api/Startup.cs

@@ -106,6 +106,7 @@ namespace Tsi1.Api
             services.AddScoped<ICommunicationService, CommunicationService>();
             services.AddScoped<IChatService, ChatService>();
             services.AddScoped<IActivityService, ActivityService>();
+            services.AddScoped<IEvaluationService, EvaluationService>();
 
             services.AddSingleton<PresenceTracker>();
 

Tsi1.Api/Tsi1.BusinessLayer/Dtos/ActivityCreateDto.cs

@@ -11,5 +11,7 @@ namespace Tsi1.BusinessLayer.Dtos
         public bool IsVideoConference { get; set; }
 
         public int CourseId { get; set; }
+
+        public EvaluationCreateDto Evaluation { get; set; }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Dtos/ActivityModifyDto.cs

@@ -9,5 +9,7 @@ namespace Tsi1.BusinessLayer.Dtos
         public string Name { get; set; }
 
         public bool IsVideoConference { get; set; }
+
+        public EvaluationModifyDto Evaluation { get; set; }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationCreateDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class EvaluationCreateDto
+    {
+        public int EvaluationTypeId { get; set; }
+
+        public bool IsCompleted { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/GradeDto.cs → Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationDetailDto.cs

 using System;
 using System.Collections.Generic;
 using System.Text;
-using System.Text.Json.Serialization;
 
 namespace Tsi1.BusinessLayer.Dtos
 {
-    public class GradeDto
+    public class EvaluationDetailDto
     {
-        public int ActivityId { get; set; }
+        public int Id { get; set; }
 
-        public int UserId { get; set; }
+        public int EvaluationTypeId { get; set; }
+
+        public bool IsCompleted { get; set; }
 
-        public decimal Value { get; set; }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationInscriptionDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class EvaluationInscriptionDto
+    {
+        public int EvaluationId { get; set; }
+
+        public int StudentId { get; set; }
+
+        public decimal Grade { get; set; }
+
+        public bool HasAttended { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationInscriptionModifyDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class EvaluationInscriptionModifyDto
+    {
+        public int EvaluationId { get; set; }
+
+        public int StudentId { get; set; }
+
+        public decimal Grade { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationModifyDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class EvaluationModifyDto
+    {
+        public int Id { get; set; }
+
+        public int EvaluationTypeId { get; set; }
+
+        public bool IsCompleted { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/EvaluationTypeDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class EvaluationTypeDto
+    {
+        public int Id { get; set; }
+
+        public string Name { get; set; }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Dtos/MyEvaluationInscriptionDto.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Dtos
+{
+    public class MyEvaluationInscriptionDto
+    {
+        public string ActivityName { get; set; }
+
+        public int EvaluationTypeId { get; set; }
+
+        public string EvaluationType { get; set; }
+
+        public decimal Grade { get; set; }
+
+        public bool HasAttended { get; set; }
+
+    }
+}

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

@@ -69,5 +69,19 @@ namespace Tsi1.BusinessLayer.Helpers
         public const string ActivityDoesNotExist = "La actividad con id '{0}' no existe";
 
         public const string GradeDoesNotExist = "La nota para la actividad con id '{0}' y usuario con id '{0}' no existe";
+
+
+        public const string EvaluationTypeDoesNotExist = "El tipo de evaluación con id '{0}' no existe";
+        public const string EvaluationDoesNotExist = "La evaluación con id '{0}' no existe";
+        public const string EvaluationIsCompleted = "La evaluación con id '{0}' ha finalizado";
+        public const string EvaluationInscriptionAlreadyExists = "El estudiante con id '{0}' ya se inscribió a la evaluación con id '{1}'";
+        public const string EvaluationInscriptionDoesNotExists = "El estudiante con id '{0}' no esta inscripto en la evaluación con id '{1}'";
+        public const string EvaluationInscriptionHasAttended = "El estudiante con id '{0}' ya realizó la evaluación con id '{1}'";
+        public const string SubmissionDoesNotExists = "No existe ninguna tarea para el estudiante con id '{0}' en la evaluación con id '{1}'";
+        public const string SubmissionAlreadyExists = "Ya existe una tarea para el estudiante con id '{0}' en la evaluación con id '{1}'";
+        public const string InavalidUserSubmission = "La tarea con id '{0}' no pertenece al estudiante con id '{1}'";
+
+        public const string VideoConferenceIsNotEvaluation = "Una video conferencia no es una evaluación";
+
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Helpers/EvaluationTypes.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.BusinessLayer.Helpers
+{
+    public class EvaluationTypes
+    {
+        public const string Laboratory = nameof(Laboratory);
+        public const string Exam = nameof(Exam);
+        public const string MidTerm = nameof(MidTerm);
+    }
+}

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

@@ -61,7 +61,11 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<Activity, ActivityCreateDto>();
             CreateMap<Activity, ActivityModifyDto>();
             CreateMap<Activity, ActivityDto>();
-            CreateMap<Grade, GradeDto>();
+            CreateMap<EvaluationType, EvaluationTypeDto>();
+            CreateMap<Evaluation, EvaluationCreateDto>();
+            CreateMap<Evaluation, EvaluationModifyDto>();
+            CreateMap<Evaluation, EvaluationDetailDto>();
+            CreateMap<EvaluationInscription, EvaluationInscriptionDto>();
 
             CreateMap<ForumCreateDto, Forum>();
             CreateMap<ForumPreviewDto, Forum>();
@@ -109,7 +113,11 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<ActivityCreateDto, Activity>();
             CreateMap<ActivityModifyDto, Activity>();
             CreateMap<ActivityDto, Activity>();
-            CreateMap<GradeDto, Grade>();
+            CreateMap<EvaluationTypeDto, EvaluationType>();
+            CreateMap<EvaluationCreateDto, Evaluation>();
+            CreateMap<EvaluationModifyDto, Evaluation>().ForMember(x => x.Id, opt => opt.Ignore());
+            CreateMap<EvaluationDetailDto, Evaluation>();
+            CreateMap<EvaluationInscriptionDto, EvaluationInscription>();
         }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IActivityService.cs

@@ -15,10 +15,6 @@ namespace Tsi1.BusinessLayer.Interfaces
         Task<ServiceResult<int>> Modify(int activityId, ActivityModifyDto activityDto, int userId);
         Task<ServiceResult<int>> Delete(int activityId, int userId);
 
-        Task<ServiceResult<int>> ActivityValidation(int activityId, int userId);
-        Task<ServiceResult<GradeDto>> AddOrModifyGrade(GradeDto gradeDto, int userId);
-        Task<ServiceResult<int>> DeleteGrade(int myUserId, int activityId, int userId);
-        Task<ServiceResult<List<GradeDto>>> GetMyGrades(int activityId, int userId);
-        Task<ServiceResult<List<GradeDto>>> GetAllGrades(int activityId, int userId);
+        Task<ServiceResult<int>> ActivityValidation(int activityId, int userId); 
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IEvaluationService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IEvaluationService
+    {
+        Task<ServiceResult<bool>> Registration(int evaluationId, int userId);
+
+        Task<ServiceResult<bool>> CancelRegistration(int evaluationId, int userId);
+
+        Task<ServiceResult<bool>> SubmitLaboratory(FileDto fileDto, int evaluationId, int userId);
+
+        Task<ServiceResult<bool>> DeleteLaboratory(int submissionId, int userId);
+
+        Task<ServiceResult<List<MyEvaluationInscriptionDto>>> GetMyEvaluationInscriptions(int userId, int courseId);
+
+        Task<ServiceResult<List<EvaluationInscriptionDto>>> GetAllEvaluationInscriptions(int userId, int evaluationId);
+
+        Task<ServiceResult<bool>> QualifyEvaluationInscription(EvaluationInscriptionModifyDto evaluationInscriptionDto, int userId);
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IEvaluationTypeService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IEvaluationTypeService
+    {
+        public Task<ServiceResult<EvaluationTypeDto>> GetById(int id);
+
+        public Task<ServiceResult<List<EvaluationTypeDto>>> GetAll(string userType);
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/ActivityService.cs

@@ -179,38 +179,15 @@ namespace Tsi1.BusinessLayer.Services
                 return result;
             }
 
-            var activity = _mapper.Map<Activity>(newActivity);
-            _context.Activities.Add(activity);
-
-            await _context.SaveChangesAsync();
-
-            result.Data = activity.Id;
-            return result;
-        }
-
-        public async Task<ServiceResult<int>> Modify(int activityId, ActivityModifyDto activityDto, int userId)
-        {
-            var result = new ServiceResult<int>();
-
-            var activity = await _context.Activities.FirstOrDefaultAsync(x => x.Id == activityId);
-
-            if (activity == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.ActivityDoesNotExist, activityId));
-                return result;
-            }
-
-            var userTypeValidation = await this.UserTypeValidation(activity.CourseId, userId);
-
-            if (userTypeValidation.HasError)
+            if (newActivity.IsVideoConference && newActivity.Evaluation != null)
             {
                 result.HasError = true;
-                result.AddMessage(userTypeValidation.Message);
+                result.AddMessage(ErrorMessages.VideoConferenceIsNotEvaluation);
                 return result;
             }
 
-            _mapper.Map(activityDto, activity);
+            var activity = _mapper.Map<Activity>(newActivity);
+            _context.Activities.Add(activity);
 
             await _context.SaveChangesAsync();
 
@@ -218,7 +195,7 @@ namespace Tsi1.BusinessLayer.Services
             return result;
         }
 
-        public async Task<ServiceResult<int>> Delete(int activityId, int userId)
+        public async Task<ServiceResult<int>> Modify(int activityId, ActivityModifyDto activityDto, int userId)
         {
             var result = new ServiceResult<int>();
 
@@ -240,105 +217,25 @@ namespace Tsi1.BusinessLayer.Services
                 return result;
             }
 
-            _context.Activities.Remove(activity);
-
-            await _context.SaveChangesAsync();
-
-            result.Data = activity.Id;
-            return result;
-        }
-
-        public async Task<ServiceResult<GradeDto>> AddOrModifyGrade(GradeDto gradeDto, int userId)
-        {
-            var result = new ServiceResult<GradeDto>();
-
-            var activity = await _context.Activities.FirstOrDefaultAsync(x => x.Id == gradeDto.ActivityId);
-
-            if (activity == null)
+            if (activityDto.IsVideoConference && activityDto.Evaluation != null)
             {
                 result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.ActivityDoesNotExist, gradeDto.ActivityId));
+                result.AddMessage(ErrorMessages.VideoConferenceIsNotEvaluation);
                 return result;
             }
 
-            var userTypeValidation = await this.UserTypeValidation(activity.CourseId, userId);
-
-            if (userTypeValidation.HasError)
-            {
-                result.HasError = true;
-                result.AddMessage(userTypeValidation.Message);
-                return result;
-            }
-
-            var userStudent = await _context.Users
-                .Include(x => x.Student)
-                .FirstOrDefaultAsync(x => x.Id == gradeDto.UserId);
-
-            if (userStudent == null || userStudent.Student == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.StudentDoesNotExist, gradeDto.UserId));
-                return result;
-            }
-
-            var userStudentValidation = await this.UserTypeValidation(activity.CourseId, userStudent.Id);
-
-            if (userStudentValidation.HasError)
-            {
-                result.HasError = true;
-                result.AddMessage(userStudentValidation.Message);
-                return result;
-            }
-
-            var grade = await _context.Grades
-                .FirstOrDefaultAsync(x => x.ActivityId == gradeDto.ActivityId && x.StudentId == userStudent.StudentId);
-
-            if (grade == null)
-            {
-                grade = new Grade
-                {
-                    ActivityId = gradeDto.ActivityId,
-                    StudentId = (int)userStudent.StudentId
-                };
-
-                _context.Grades.Add(grade);
-            }
-            
-            grade.Value = gradeDto.Value;
+            _mapper.Map(activityDto, activity);
 
-            
             await _context.SaveChangesAsync();
 
-            result.Data = gradeDto;
+            result.Data = activity.Id;
             return result;
         }
 
-        public async Task<ServiceResult<int>> DeleteGrade(int myUserId, int activityId, int userId)
+        public async Task<ServiceResult<int>> Delete(int activityId, int userId)
         {
             var result = new ServiceResult<int>();
 
-            var userStudent = await _context.Users
-                .AsNoTracking()
-                .Include(x => x.Student)
-                .FirstOrDefaultAsync(x => x.Id == userId);
-
-            if (userStudent == null || userStudent.Student == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.StudentDoesNotExist, userStudent.Id));
-                return result;
-            }
-
-            var grade = await _context.Grades
-                .FirstOrDefaultAsync(x => x.ActivityId == activityId && x.StudentId == userStudent.StudentId);
-
-            if (grade == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.GradeDoesNotExist, activityId, userId));
-                return result;
-            }
-
             var activity = await _context.Activities.FirstOrDefaultAsync(x => x.Id == activityId);
 
             if (activity == null)
@@ -357,99 +254,13 @@ namespace Tsi1.BusinessLayer.Services
                 return result;
             }
 
-            _context.Grades.Remove(grade);
-            await _context.SaveChangesAsync();
-
-            return result;
-        }
-
-        public async Task<ServiceResult<List<GradeDto>>> GetMyGrades(int activityId, int userId)
-        {
-            var result = new ServiceResult<List<GradeDto>>();
-
-            var activity = await _context.Activities.AsNoTracking().FirstOrDefaultAsync(x => x.Id == activityId);
-
-            if (activity == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.ActivityDoesNotExist, activityId));
-                return result;
-            }
-
-            var userTypeValidation = await this.UserTypeValidation(activity.CourseId, userId);
-
-            if (userTypeValidation.HasError)
-            {
-                result.HasError = true;
-                result.AddMessage(userTypeValidation.Message);
-                return result;
-            }
-
-            var user = userTypeValidation.Data;
+            _context.Activities.Remove(activity);
 
-            var grades = await _context.Grades
-                .AsNoTracking()
-                .Where(x => x.ActivityId == activityId && x.StudentId == user.StudentId)
-                .ToListAsync();
+            await _context.SaveChangesAsync();
 
-            result.Data = _mapper.Map<List<GradeDto>>(grades);
+            result.Data = activity.Id;
             return result;
         }
 
-        public async Task<ServiceResult<List<GradeDto>>> GetAllGrades(int activityId, int userId)
-        {
-            var result = new ServiceResult<List<GradeDto>>();
-
-            var activity = await _context.Activities.AsNoTracking().FirstOrDefaultAsync(x => x.Id == activityId);
-
-            if (activity == null)
-            {
-                result.HasError = true;
-                result.AddMessage(string.Format(ErrorMessages.ActivityDoesNotExist, activityId));
-                return result;
-            }
-
-            var userTypeValidation = await this.UserTypeValidation(activity.CourseId, userId);
-
-            if (userTypeValidation.HasError)
-            {
-                result.HasError = true;
-                result.AddMessage(userTypeValidation.Message);
-                return result;
-            }
-
-            var user = userTypeValidation.Data;
-
-            var grades = await _context.Grades
-                .AsNoTracking()
-                .Where(x => x.ActivityId == activityId)
-                .ToListAsync();
-
-            var studentIds = grades.Select(x => x.StudentId).ToList();
-
-            var users = await _context.Users
-                .AsNoTracking()
-                .Where(x => studentIds.Contains((int)x.StudentId))
-                .ToListAsync();
-
-            var gradeDtos = new List<GradeDto>();
-
-            foreach (var grade in grades)
-            {
-                var userStudent = users.FirstOrDefault(x => x.StudentId == grade.StudentId);
-
-                var gradeDto = new GradeDto
-                {
-                    ActivityId = grade.ActivityId,
-                    UserId = userStudent.Id,
-                    Value = grade.Value
-                };
-
-                gradeDtos.Add(gradeDto);
-            }
-
-            result.Data = gradeDtos;
-            return result;
-        }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Services/EvaluationService.cs

+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class EvaluationService : IEvaluationService
+    {
+        private readonly Tsi1Context _context;
+        private readonly IMapper _mapper;
+        private readonly IFileService _fileService;
+
+        public EvaluationService(Tsi1Context context, IMapper mapper, IFileService fileService)
+        {
+            _context = context;
+            _mapper = mapper;
+            _fileService = fileService;
+        }
+
+        public async Task<ServiceResult<bool>> CancelRegistration(int evaluationId, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var validation = await this.StudentValidation(evaluationId, userId);
+
+            if (validation.HasError)
+            {
+                result.HasError = true;
+                result.AddMessage(validation.Message);
+                return result;
+            }
+
+            var studentId = validation.Data;
+
+            var evaluationInscription = await _context.EvaluationInscriptions
+                .FirstOrDefaultAsync(x => x.EvaluationId == evaluationId && x.StudentId == studentId);
+
+            if (evaluationInscription == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationInscriptionDoesNotExists, studentId, evaluationId));
+                return result;
+            }
+
+            if (evaluationInscription.HasAttended)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationInscriptionHasAttended, studentId, evaluationId));
+                return result;
+            }
+
+            _context.EvaluationInscriptions.Remove(evaluationInscription);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> DeleteLaboratory(int submissionId, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var user = await _context.Users
+                .AsNoTracking()
+                .Include(x => x.Student)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null || user.Student == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.UserDoesNotExist, userId));
+                return result;
+            }
+
+            var studentId = user.StudentId;
+
+            var submission = await _context.Submissions.FirstOrDefaultAsync(x => x.Id == submissionId);
+
+            if (submission == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.SubmissionDoesNotExists, submissionId));
+                return result;
+            }
+
+            if (submission.StudentId != studentId)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.InavalidUserSubmission, submissionId, studentId));
+                return result;
+            }
+
+            _context.Submissions.Remove(submission);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<EvaluationInscriptionDto>>> GetAllEvaluationInscriptions(int userId, int evaluationId)
+        {
+            var result = new ServiceResult<List<EvaluationInscriptionDto>>();
+
+            var validation = await this.ProfessorValidation(evaluationId, userId);
+
+            if (validation.HasError)
+            {
+                result.HasError = true;
+                result.AddMessage(validation.Message);
+                return result;
+            }
+
+            var evaluationInscriptions = await _context.EvaluationInscriptions
+                .Where(x => x.EvaluationId == evaluationId)
+                .ToListAsync();
+
+            result.Data = _mapper.Map<List<EvaluationInscriptionDto>>(evaluationInscriptions);
+            return result;
+        }
+
+        public async Task<ServiceResult<List<MyEvaluationInscriptionDto>>> GetMyEvaluationInscriptions(int userId, int courseId)
+        {
+            var result = new ServiceResult<List<MyEvaluationInscriptionDto>>();
+
+            var course = await _context.Courses
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.Id == courseId);
+
+            if (course == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.CourseDoesNotExist, courseId));
+                return result;
+            }
+
+            var user = await _context.Users
+                .AsNoTracking()
+                .Include(x => x.Student)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null || user.Student == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.UserDoesNotExist, userId));
+                return result;
+            }
+
+            var studentCourse = await _context.StudentCourses
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.StudentId == user.StudentId && x.CourseId == courseId);
+
+            if (studentCourse == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.StudentCourseDoesNotExists, user.StudentId, courseId));
+                return result;
+            }
+
+            var evaluationInscriptions = await _context.EvaluationInscriptions
+                .AsNoTracking()
+                .Include(x => x.Evaluation)
+                    .ThenInclude(x => x.Activity)
+                .Include(x => x.Evaluation)
+                    .ThenInclude(x => x.EvaluationType)
+                .Where(x => x.StudentId == user.StudentId)
+                .ToListAsync();
+
+            var myEvaluationInscriptionDtos = new List<MyEvaluationInscriptionDto>();
+
+            foreach (var evaluationInscription in evaluationInscriptions)
+            {
+                var myEvaluationInscriptionDto = new MyEvaluationInscriptionDto
+                {
+                    ActivityName = evaluationInscription.Evaluation.Activity.Name,
+                    EvaluationTypeId = evaluationInscription.EvaluationId,
+                    EvaluationType = evaluationInscription.Evaluation.EvaluationType.Name,
+                    Grade = evaluationInscription.Grade,
+                    HasAttended = evaluationInscription.HasAttended,
+                };
+
+                myEvaluationInscriptionDtos.Add(myEvaluationInscriptionDto);
+            }
+
+            result.Data = myEvaluationInscriptionDtos;
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> QualifyEvaluationInscription(EvaluationInscriptionModifyDto evaluationInscriptionDto, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var evaluationId = evaluationInscriptionDto.EvaluationId;
+            var studentId = evaluationInscriptionDto.StudentId;
+
+            var validation = await this.ProfessorValidation(evaluationId, userId);
+
+            if (validation.HasError)
+            {
+                result.HasError = true;
+                result.AddMessage(validation.Message);
+                return result;
+            }         
+
+            var evaluationInscription = await _context.EvaluationInscriptions
+                .FirstOrDefaultAsync(x => x.EvaluationId == evaluationId && x.StudentId == studentId);
+
+            if (evaluationInscription == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationInscriptionDoesNotExists, studentId, evaluationId));
+                return result;
+            }
+
+            evaluationInscription.Grade = evaluationInscriptionDto.Grade;
+            evaluationInscription.HasAttended = true;
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> Registration(int evaluationId, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var validation = await this.StudentValidation(evaluationId, userId);
+
+            if (validation.HasError)
+            {
+                result.HasError = true;
+                result.AddMessage(validation.Message);
+                return result;
+            }
+
+            var studentId = validation.Data;
+
+            var evaluationInscription = await _context.EvaluationInscriptions
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.EvaluationId == evaluationId && x.StudentId == studentId);
+
+            if (evaluationInscription != null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationInscriptionAlreadyExists, studentId, evaluationId));
+                return result;
+            }
+
+            var newEvaluationInscription = new EvaluationInscription
+            {
+                EvaluationId = evaluationId,
+                StudentId = studentId,
+                Grade = 0,
+                HasAttended = false,
+            };
+
+            _context.EvaluationInscriptions.Add(newEvaluationInscription);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> SubmitLaboratory(FileDto fileDto, int evaluationId, int userId)
+        {
+            var result = new ServiceResult<bool>();
+
+            var validation = await this.StudentValidation(evaluationId, userId);
+
+            if (validation.HasError)
+            {
+                result.HasError = true;
+                result.AddMessage(validation.Message);
+                return result;
+            }
+
+            var studentId = validation.Data;
+
+            var evaluation = await _context.Evaluations
+                .Include(x => x.Submissions)
+                .FirstOrDefaultAsync(x => x.Id == evaluationId);
+
+            var studentIds = evaluation.Submissions.Select(x => x.StudentId);
+
+            if (studentIds.Contains(studentId))
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.SubmissionAlreadyExists, studentId, evaluationId));
+                return result;
+            }
+
+            if (!_fileService.ExistFile(fileDto.Path))
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.FileDoesNotExist, fileDto.Path));
+                return result;
+            }
+
+            var file = _mapper.Map<File>(fileDto);
+
+            var newSubmission = new Submission
+            {
+                File = file,
+                StudentId = studentId,
+                Grade = 0,
+                IsCompleted = false,
+            };
+
+            evaluation.Submissions.Add(newSubmission);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        private async Task<ServiceResult<int>> StudentValidation(int evaluationId, int userId)
+        {
+            var result = new ServiceResult<int>();
+
+            var evaluation = await _context.Evaluations
+                .AsNoTracking()
+                .Include(x => x.Activity)
+                .FirstOrDefaultAsync(x => x.Id == evaluationId);
+
+            if (evaluation == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationDoesNotExist, evaluationId));
+                return result;
+            }
+
+            if (evaluation.IsCompleted)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationIsCompleted, evaluationId));
+                return result;
+            }
+
+            var user = await _context.Users
+                .AsNoTracking()
+                .Include(x => x.Student)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null || user.Student == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.UserDoesNotExist, userId));
+                return result;
+            }
+
+            var activityCourseId = evaluation.Activity.CourseId;
+
+            var studentCourse = await _context.StudentCourses
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.CourseId == activityCourseId && x.StudentId == user.StudentId);
+
+            if (studentCourse == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.StudentCourseDoesNotExists, user.StudentId, activityCourseId));
+                return result;
+            }
+
+            result.Data = (int)user.StudentId;
+            return result;
+        }
+
+        private async Task<ServiceResult<int>> ProfessorValidation(int evaluationId, int userId)
+        {
+            var result = new ServiceResult<int>();
+
+            var evaluation = await _context.Evaluations
+                .AsNoTracking()
+                .Include(x => x.Activity)
+                .FirstOrDefaultAsync(x => x.Id == evaluationId);
+
+            if (evaluation == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.EvaluationDoesNotExist, evaluationId));
+            }
+
+            var user = await _context.Users
+                .AsNoTracking()
+                .Include(x => x.Professor)
+                .FirstOrDefaultAsync(x => x.Id == userId);
+
+            if (user == null || user.Professor == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.ProfessorDoesNotExist, userId));
+                return result;
+            }
+
+            var activityCourseId = evaluation.Activity.CourseId;
+
+            var professorCourse = await _context.ProfessorCourses
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.CourseId == activityCourseId && x.ProfessorId == user.ProfessorId);
+
+            if (professorCourse == null)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.ProfessorCourseDoesNotExists, user.ProfessorId, activityCourseId));
+                return result;
+            }
+
+            result.Data = (int)user.ProfessorId;
+            return result;
+        }
+    }
+}