add grade entity

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

@@ -80,5 +80,65 @@ 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.BusinessLayer/Dtos/GradeDto.cs

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

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

@@ -67,5 +67,7 @@ namespace Tsi1.BusinessLayer.Helpers
         public const string InvalidTenant = "El usuario no pertenece a la facultad con id '{0}'";
 
         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";
     }
 }

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

@@ -57,6 +57,7 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<Activity, ActivityCreateDto>();
             CreateMap<Activity, ActivityModifyDto>();
             CreateMap<Activity, ActivityDto>();
+            CreateMap<Grade, GradeDto>();
 
             CreateMap<ForumCreateDto, Forum>();
             CreateMap<ForumPreviewDto, Forum>();
@@ -103,6 +104,7 @@ namespace Tsi1.BusinessLayer.Helpers
             CreateMap<ActivityCreateDto, Activity>();
             CreateMap<ActivityModifyDto, Activity>();
             CreateMap<ActivityDto, Activity>();
+            CreateMap<GradeDto, Grade>();
         }
     }
 }

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

@@ -16,5 +16,9 @@ namespace Tsi1.BusinessLayer.Interfaces
         Task<ServiceResult<int>> Delete(int activityId, int userId);
 
         Task<ServiceResult<int>> ActivityValidation(int activityId);
+        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);
     }
 }

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

@@ -67,9 +67,9 @@ namespace Tsi1.BusinessLayer.Services
             return result;
         }
 
-        private async Task<ServiceResult<bool>> UserTypeValidation(int courseId, int userId)
+        private async Task<ServiceResult<User>> UserTypeValidation(int courseId, int userId)
         {
-            var result = new ServiceResult<bool>();
+            var result = new ServiceResult<User>();
 
             var user = await _context.Users.AsNoTracking()
                 .Include(x => x.UserType)
@@ -96,6 +96,21 @@ namespace Tsi1.BusinessLayer.Services
                 }
             }
 
+            if (user.UserType.Name == UserTypes.Student)
+            {
+                var isStudentCourse = await _context.StudentCourses
+                    .AsNoTracking()
+                    .AnyAsync(x => x.StudentId == user.StudentId && x.CourseId == courseId);
+
+                if (!isStudentCourse)
+                {
+                    result.HasError = true;
+                    result.AddMessage(string.Format(ErrorMessages.StudentCourseDoesNotExists, user.Id, courseId));
+
+                }
+            }
+
+            result.Data = user;
             return result;
         }
 
@@ -223,5 +238,209 @@ namespace Tsi1.BusinessLayer.Services
             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)
+            {
+                result.HasError = true;
+                result.AddMessage(string.Format(ErrorMessages.ActivityDoesNotExist, gradeDto.ActivityId));
+                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;
+
+            
+            await _context.SaveChangesAsync();
+
+            result.Data = gradeDto;
+            return result;
+        }
+
+        public async Task<ServiceResult<int>> DeleteGrade(int myUserId, 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)
+            {
+                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;
+            }
+
+            _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;
+
+            var grades = await _context.Grades
+                .AsNoTracking()
+                .Where(x => x.ActivityId == activityId && x.StudentId == user.StudentId)
+                .ToListAsync();
+
+            result.Data = _mapper.Map<List<GradeDto>>(grades);
+            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.DataLayer/Entities/Activity.cs

@@ -9,6 +9,7 @@ namespace Tsi1.DataLayer.Entities
         public Activity()
         {
             Attendances = new HashSet<Attendance>();
+            Grades = new HashSet<Grade>();
         }
 
         public int Id { get; set; }
@@ -22,5 +23,7 @@ namespace Tsi1.DataLayer.Entities
         public Course Course { get; set; }
 
         public ICollection<Attendance> Attendances { get; set; }
+
+        public ICollection<Grade> Grades { get; set; }
     }
 }

Tsi1.Api/Tsi1.DataLayer/Entities/Grade.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class Grade
+    {
+        public int ActivityId { get; set; }
+
+        public int StudentId { get; set; }
+
+        public decimal Value { get; set; }
+
+        public DateTime Date { get; set; }
+
+        public Student Student { get; set; }
+
+        public Activity Activity { get; set; }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/Student.cs

@@ -9,6 +9,7 @@ namespace Tsi1.DataLayer.Entities
         public Student()
         {
             StudentCourses = new HashSet<StudentCourse>();
+            Grades = new HashSet<Grade>();
         }
 
         public int Id { get; set; }
@@ -22,5 +23,7 @@ namespace Tsi1.DataLayer.Entities
         public Tenant Tenant { get; set; }
         public User User { get; set; }
         public ICollection<StudentCourse> StudentCourses { get; set; }
+
+        public ICollection<Grade> Grades { get; set; }
     }
 }

Tsi1.Api/Tsi1.DataLayer/EntityConfiguration/GradeConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.DataLayer.EntityConfiguration
+{
+    public class GradeConfiguration : IEntityTypeConfiguration<Grade>
+    {
+        public void Configure(EntityTypeBuilder<Grade> builder)
+        {
+            builder.HasKey(x => new { x.ActivityId, x.StudentId});
+
+            builder.Property(x => x.Value)
+                .IsRequired()
+                .HasColumnType("NUMERIC(5,2)");
+
+            builder.HasOne(x => x.Activity)
+                .WithMany(x => x.Grades)
+                .HasForeignKey(x => x.ActivityId);
+
+            builder.HasOne(x => x.Student)
+                .WithMany(x => x.Grades)
+                .HasForeignKey(x => x.StudentId);
+        }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Migrations/20201130004426_add-grade-entity.cs

+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Tsi1.DataLayer.Migrations
+{
+    public partial class addgradeentity : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Grades",
+                columns: table => new
+                {
+                    ActivityId = table.Column<int>(nullable: false),
+                    StudentId = table.Column<int>(nullable: false),
+                    Value = table.Column<decimal>(type: "NUMERIC(5,2)", nullable: false),
+                    Date = table.Column<DateTime>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Grades", x => new { x.ActivityId, x.StudentId });
+                    table.ForeignKey(
+                        name: "FK_Grades_Activities_ActivityId",
+                        column: x => x.ActivityId,
+                        principalTable: "Activities",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Grades_Students_StudentId",
+                        column: x => x.StudentId,
+                        principalTable: "Students",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Grades_StudentId",
+                table: "Grades",
+                column: "StudentId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Grades");
+        }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Migrations/Tsi1ContextModelSnapshot.cs

@@ -219,6 +219,27 @@ namespace Tsi1.DataLayer.Migrations
                     b.ToTable("ForumUsers");
                 });
 
+            modelBuilder.Entity("Tsi1.DataLayer.Entities.Grade", b =>
+                {
+                    b.Property<int>("ActivityId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("StudentId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal>("Value")
+                        .HasColumnType("NUMERIC(5,2)");
+
+                    b.HasKey("ActivityId", "StudentId");
+
+                    b.HasIndex("StudentId");
+
+                    b.ToTable("Grades");
+                });
+
             modelBuilder.Entity("Tsi1.DataLayer.Entities.Group", b =>
                 {
                     b.Property<string>("Name")
@@ -709,6 +730,21 @@ namespace Tsi1.DataLayer.Migrations
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Tsi1.DataLayer.Entities.Grade", b =>
+                {
+                    b.HasOne("Tsi1.DataLayer.Entities.Activity", "Activity")
+                        .WithMany("Grades")
+                        .HasForeignKey("ActivityId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Tsi1.DataLayer.Entities.Student", "Student")
+                        .WithMany("Grades")
+                        .HasForeignKey("StudentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Tsi1.DataLayer.Entities.Post", b =>
                 {
                     b.HasOne("Tsi1.DataLayer.Entities.Forum", "Forum")

Tsi1.Api/Tsi1.DataLayer/Tsi1Context.cs

@@ -36,6 +36,8 @@ namespace Tsi1.DataLayer
         public DbSet<Activity> Activities { get; set; }
         public DbSet<Attendance> Attendances { get; set; }
 
+        public DbSet<Grade> Grades { get; set; }
+
 
 
         public Tsi1Context(DbContextOptions options) : base(options) { }
@@ -68,6 +70,7 @@ namespace Tsi1.DataLayer
             modelBuilder.ApplyConfiguration(new CommunicationConfiguration());
             modelBuilder.ApplyConfiguration(new ActivityConfiguration());
             modelBuilder.ApplyConfiguration(new AttendanceConfiguration());
+            modelBuilder.ApplyConfiguration(new GradeConfiguration());
         }
     }
 }