public async Task <IActionResult> Create([FromForm] CreateCourseApplicationRequest request)
{
if (request == null)
{
return(BadRequest());
}
var courseTypes = await _courseRepository.GetCourseTypes();
if (courseTypes.All(ct => ct.Id != request.CourseTypeId))
{
return(BadRequest());
}
var courseApplication = new CourseApplication
{
Name = request.Name,
ShortDescription = request.ShortDescription,
Active = true,
CourseType = courseTypes.Single(ct => ct.Id == request.CourseTypeId),
CreatedDate = DateTime.UtcNow,
UserId = (int)GetUserId()
};
var courseApplicationId = await _courseApplicationRepository.Create(courseApplication);
return(RedirectToAction("Index", new { courseApplicationId }));
}
// Delete a ClassSchema from the database
public void DeleteCourseApplication(int id)
{
CourseApplication courseApplication = db.CourseApplications.Find(id);
db.CourseApplications.Remove(courseApplication);
db.SaveChanges();
}
public async Task ShouldReturnCorrectInactiveCourseApplication()
{
// Given
var courseApplicationId = 123;
var userId = 789;
var courseApplication = new CourseApplication
{
Id = courseApplicationId,
Name = "Some name",
ShortDescription = "Some description",
Active = false,
CreatedDate = DateTime.UtcNow,
CourseType = new CourseType
{
Id = 1,
Type = "Maths"
},
UserId = 456
};
_courseApplicationRepositoryMock
.Setup(_ => _.Find(courseApplicationId))
.ReturnsAsync(courseApplication)
.Verifiable();
_userRepositoryMock
.Setup(_ => _.GetUserIdByEmail(It.IsAny <string>()))
.Returns(userId)
.Verifiable();
// When
var result = await _courseApplicationController.Index(courseApplicationId);
// Then
Mock.Verify(_courseApplicationRepositoryMock);
result.Should().BeOfType <ViewResult>();
var viewResult = (ViewResult)result;
viewResult.Model.Should().BeOfType <CourseApplicationController.CourseApplicationInfoViewModel>();
var viewModel = (CourseApplicationController.CourseApplicationInfoViewModel)viewResult.Model;
viewModel.Application.Id.Should().Be(courseApplication.Id);
viewModel.Application.Name.Should().Be(courseApplication.Name);
viewModel.Application.ShortDescription.Should().Be(courseApplication.ShortDescription);
viewModel.Application.UserId.Should().Be(courseApplication.UserId);
viewModel.Application.Active.Should().Be(viewModel.Application.Active);
viewModel.Application.CreatedDate.Should().Be(courseApplication.CreatedDate);
viewModel.Application.CourseType.Id.Should().Be(courseApplication.CourseType.Id);
viewModel.Application.CourseType.Type.Should().Be(courseApplication.CourseType.Type);
viewModel.UserId.Should().Be(userId);
viewModel.CanAcceptCourse.Should().BeFalse();
}
public void ReturnsCorrectSearchedCourses()
{
// Given
var name = "Name";
var courseTypeIds = new List <int> {
1
};
var pageNumber = 1;
var pageSize = 1;
var courseApplication = new CourseApplication
{
Id = 1,
Active = true,
CourseType = new CourseType
{
Id = 1,
Type = "Biology"
},
CreatedDate = DateTime.Now,
Name = "Name",
ShortDescription = "Short description"
};
_courseApplicationRepositoryMock
.Setup(_ => _.Search(It.IsAny <long>(), name, courseTypeIds))
.Returns(new List <CourseApplication> {
courseApplication
})
.Verifiable();
// When
var result = _courseApplicationController.GetCourses(name, courseTypeIds, pageNumber, pageSize);
// Then
Mock.Verify(_courseRepositoryMock);
result.Should().BeOfType <OkObjectResult>();
var objectResult = (OkObjectResult)result;
objectResult.Value.Should().BeOfType <List <CourseApplication> >();
((List <CourseApplication>)objectResult.Value).Should().Contain(courseApplication);
}
public async Task <int> Create(CourseApplication application)
{
using (var connection = new SqlConnection(_connectionString))
{
return(await connection.QuerySingleAsync <int>(
@"INSERT INTO [dbo].[CourseApplication]
(Name, ShortDescription, ApplicantId, CourseTypeId, CreatedDate, Active)
VALUES (@Name, @ShortDescription, @UserId, @CourseTypeId, @CreatedDate, @Active);
SELECT IDENT_CURRENT('dbo.CourseApplication');",
new
{
application.Name,
application.ShortDescription,
application.UserId,
CourseTypeId = application.CourseType.Id,
application.CreatedDate,
application.Active
}));
}
}
public ActionResult Apply(int id = 0, string message = "")
{
var course = LMSRepo.GetCourseByID(id);
var userManager = LMSRepo.GetUserManager();
var roleManager = LMSRepo.GetRoleManager();
var student = userManager.FindById(User.Identity.GetUserId());
var users = userManager.Users.ToList();
var teachers = new List <ApplicationUser>();
//If the student is already enrolled in a course
if (course.Students.Contains(student))
{
return(View("_ApplicationForbidden"));
}
//Filters only course teachers
foreach (var teacher in users)
{
if (userManager.IsInRole(teacher.Id, "teacher") && teacher.Courses.Contains(course))
{
teachers.Add(teacher);
}
}
CourseApplication application = new CourseApplication
{
Message = message,
EvaluationDate = null,
IsAccepted = false,
Course = course,
ProgramClass = null,
Student = student,
Teachers = teachers,
CreationDate = DateTime.Now,
Status = false // Pending application by default
};
LMSRepo.AddCourseApplication(application);
return(RedirectToAction("Details", "Course", new { id = course.ID }));
}
public async Task <ActionResult> CreateCourseApplication([FromBody, BindRequired] CourseApplicationModel model)
{
if (!ModelState.IsValid)
{
return(JsonResponse(HttpStatusCode.BadRequest, ModelState.Values.SelectMany(x => x.Errors)));
}
try
{
var selectedCourse = await _courseService.GetCourseByIdAsync(model.CourseId);
var selectedDate = selectedCourse.CourseDates.Single(x => x.Id == model.DateId);
var courseApplication = new CourseApplication()
{
CompanyName = model.CompanyName,
CompanyEmail = model.CompanyEmail,
CompanyPhoneNumber = model.CompanyPhone,
Course = selectedCourse,
CourseDate = selectedDate,
CourseApplicationParticipants = model.Participants.Select(x => new CourseApplicationParticipant()
{
Name = x.Name,
Email = x.Email,
PhoneNumber = x.Phone
}).ToList()
};
await _courseService.CreateCourseApplicationAsync(courseApplication);
return(JsonResponse(HttpStatusCode.OK, "Application succesfully created"));
}
catch (Exception ex)
{
return(JsonResponse(HttpStatusCode.InternalServerError, new string[] { "Internal Server Error", ex.Message }));
}
}
public async Task ShouldStoreCorrectCourseApplication()
{
// Given
var userId = 123;
var courseTypes = new[]
{
new CourseType
{
Id = 1,
Type = "Maths"
}
};
var expectedCourseApplication = new CourseApplication
{
Id = 456,
Name = "Some name",
ShortDescription = "Some description",
Active = true,
UserId = userId,
CourseType = new CourseType
{
Id = 1,
Type = "Maths"
}
};
CourseApplication actualCourseApplication = null;
_courseRepositoryMock
.Setup(_ => _.GetCourseTypes())
.ReturnsAsync(courseTypes)
.Verifiable();
_userInfoProviderMock
.Setup(_ => _.GetUserEmail(It.IsAny <ClaimsPrincipal>()))
.Returns("*****@*****.**")
.Verifiable();
_userRepositoryMock
.Setup(_ => _.GetUserIdByEmail(It.IsAny <string>()))
.Returns(userId)
.Verifiable();
_courseApplicationRepositoryMock
.Setup(_ => _.Create(It.IsAny <CourseApplication>()))
.ReturnsAsync(expectedCourseApplication.Id)
.Callback((CourseApplication a) => actualCourseApplication = a)
.Verifiable();
// When
var result = await _courseApplicationController.Create(
new CourseApplicationController.CreateCourseApplicationRequest
{
CourseTypeId = courseTypes[0].Id,
Name = expectedCourseApplication.Name,
ShortDescription = expectedCourseApplication.ShortDescription
});
// Then
Mock.Verify(
_courseRepositoryMock,
_userRepositoryMock,
_courseApplicationRepositoryMock,
_userInfoProviderMock);
result.Should().BeOfType <RedirectToActionResult>();
actualCourseApplication.Name.Should().Be(expectedCourseApplication.Name);
actualCourseApplication.ShortDescription.Should().Be(expectedCourseApplication.ShortDescription);
actualCourseApplication.UserId.Should().Be(expectedCourseApplication.UserId);
actualCourseApplication.Active.Should().Be(expectedCourseApplication.Active);
actualCourseApplication.CourseType.Id.Should().Be(expectedCourseApplication.CourseType.Id);
actualCourseApplication.CourseType.Type.Should().Be(expectedCourseApplication.CourseType.Type);
}
public Task CreateCourseApplicationAsync(CourseApplication courseApplication)
{
_dbContext.CourseApplications.Add(courseApplication);
return(_dbContext.SaveChangesAsync());
}
public async Task ShouldReturnRedirectWhenApplicationSuccessfullyAccepted()
{
// Given
var courseApplication = new CourseApplication
{
Id = 101112,
UserId = 456,
ShortDescription = "Short description",
Name = "Some name",
Active = true,
CourseType = new CourseType
{
Id = 1,
Type = "Maths"
}
};
_courseApplicationRepositoryMock
.Setup(_ => _.Find(It.IsAny <int>()))
.ReturnsAsync(courseApplication)
.Verifiable();
_tutorRepositoryMock
.Setup(_ => _.Find(It.IsAny <int>()))
.ReturnsAsync(new Tutor
{
Id = 123
})
.Verifiable();
_userRepositoryMock
.Setup(_ => _.GetUserIdByEmail(It.IsAny <string>()))
.Returns(123)
.Verifiable();
_tutorRepositoryMock
.Setup(_ => _.GetCourses(It.IsAny <int>()))
.ReturnsAsync(new[]
{
new CourseType
{
Id = 1,
Type = "Maths"
}
})
.Verifiable();
Course actualCourse = null;
var courseId = 123;
_courseRepositoryMock
.Setup(_ => _.CreateCourse(It.IsAny <Course>()))
.ReturnsAsync(courseId)
.Callback((Course c) => actualCourse = c)
.Verifiable();
// When
var response = await _courseApplicationController.AcceptApplication(new CourseApplicationController.AcceptCourseApplicationRequest
{
TutorId = 123,
CourseApplicationId = courseApplication.Id
});
// Then
Mock.Verify(
_courseApplicationRepositoryMock,
_tutorRepositoryMock,
_userRepositoryMock,
_courseRepositoryMock);
response.Should().BeOfType <RedirectToActionResult>();
actualCourse.Name.Should().Be(courseApplication.Name);
actualCourse.Description.Should().Be(courseApplication.ShortDescription);
actualCourse.Active.Should().BeTrue();
actualCourse.CourseTypeId.Should().Be(courseApplication.CourseType.Id);
actualCourse.CustomerId.Should().Be(courseApplication.UserId);
actualCourse.TutorId.Should().Be(123);
actualCourse.CourseApplicationId.Should().Be(courseApplication.Id);
}
// Edit a ClassSchema in the database
public void EditCourseApplication(CourseApplication courseApplication)
{
db.Entry(courseApplication).State = EntityState.Modified;
db.SaveChanges();
}
// Add a ClassSchemas to the database
public void AddCourseApplication(CourseApplication courseApplication)
{
db.CourseApplications.Add(courseApplication);
db.SaveChanges();
}
