public async Task Handle_should_enroll_student()
{
await using var dbContext = _fixture.BuildDbContext();
var student = new Student(Guid.NewGuid(), "student", "to enroll");
dbContext.Students.Add(student);
var course = new Course(Guid.NewGuid(), "course");
dbContext.Courses.Add(course);
await dbContext.SaveChangesAsync();
//dbContext.Entry(student).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
//dbContext.Entry(course).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
var studentsRepo = new StudentsRepository(dbContext);
var coursesRepo = new CoursesRepository(dbContext);
var messagesRepository = NSubstitute.Substitute.For <IMessagesRepository>();
var eventSerializer = NSubstitute.Substitute.For <IEventSerializer>();
var unitOfWork = new SchoolUnitOfWork(dbContext, coursesRepo, studentsRepo, messagesRepository, eventSerializer);
var sut = new EnrollHandler(new FakeValidator <Enroll>(), unitOfWork);
var command = new Enroll(course.Id, student.Id);
await sut.Handle(command, CancellationToken.None);
var loadedStudent = await dbContext.Students.FindAsync(student.Id);
loadedStudent.Courses.Count.Should().Be(1);
}
public void DeleteCourses(int id)
{
CoursesRepository coursesRepository = new CoursesRepository();
Courses obj = coursesRepository.PrintOne(id);
coursesRepository.Delete(obj);
}
private void InitRepositories()
{
Consts = new ConstsRepository(Context);
Courses = new CoursesRepository(Context);
Posts = new PostsRepository(Context);
Users = new UsersRepository(Context);
}
public ActionResult CreateAssignment(Assignment assignment, int CourseId)
{
CoursesRepository repository = new CoursesRepository();
Course course = db.Courses.Where(c => c.CourseId == CourseId).SingleOrDefault();
if (!repository.CheckIfAssignmentExists(assignment, CourseId))
{
ApplicationUser teacher = db.Users.Find(course.Teacher.Id);
List <Assignment> assignments = course.Assignments.ToList();
assignment.Filename = Path.GetFileName(assignment.AssignmentFile.FileName);
string fileName = Path.Combine(Server.MapPath("~/Users/" + teacher.UserName + "/" + course.CourseName), assignment.Filename);
assignment.AssignmentFile.SaveAs(fileName);
assignment.Path = fileName;
assignment.DueDate = DateTime.Now;
var path = new System.IO.DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "Users\\" + teacher.UserName + "\\" + course.CourseName + "\\Submits\\" + assignment.AssignmentName);
DirectoryInfo di = Directory.CreateDirectory(path.ToString());
assignment.Course = course;
db.Assignments.Add(assignment);
db.SaveChanges();
return(RedirectToAction("CourseHome", "Courses", course.CourseId));
}
else
{
TempData["Error"] = "Assignment already exists! Try again";
return(RedirectToAction("CourseHome", "Courses", course));
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
CoursesRepository c = new CoursesRepository();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
c.UpdateRole(model.Role, model.Email);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public List <Courses> GetAllCourses()
{
CoursesRepository courseRepository = new CoursesRepository();
var course = courseRepository.PrintAll();
return(course);
}
public CommentsController()
{
commentsRepo = new CommentsRepository(db);
projectTasksRepo = new ProjectTasksRepository(db);
usersRepo = new UsersRepository(db);
coursesRepo = new CoursesRepository(db);
}
public DetailsModel(IConfiguration configuration)
{
this.configuration = configuration;
var connectionString = configuration.GetConnectionString("DefaultConnection");
repository = new CoursesRepository(connectionString);
}
public ActionResult Modules(int?id)
{
CoursesRepository Repository = new CoursesRepository();
if (Request.IsAuthenticated)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
int Id = (int)id;
List <Modules> data = Repository.GetCourseModules_Single_User(@User.Identity.GetUserName(), Id);
foreach (var a in data)
{
var path = @"/Courses" + "/" + a.CourseName + "/" + "Modules/" + a.ModuleName;
//var task = Task.
// ((Func<Task>)HomeController.Run(8));
//task.Wait();
//Task.Run(Run(8));
}
ViewBag.CourseId = id;
return(View());
}
else
{
return(RedirectToAction("Login", "Account"));
}
}
public async Task CommitAsync_should_create_messages_from_domain_events()
{
await using var dbContext = _fixture.BuildDbContext();
var studentsRepo = new StudentsRepository(dbContext);
var coursesRepo = new CoursesRepository(dbContext);
var messagesRepository = NSubstitute.Substitute.For <IMessagesRepository>();
var eventSerializer = NSubstitute.Substitute.For <IEventSerializer>();
var sut = new SchoolUnitOfWork(dbContext, coursesRepo, studentsRepo, messagesRepository, eventSerializer);
var course = new Course(Guid.NewGuid(), "course");
await sut.CoursesRepository.CreateAsync(course, CancellationToken.None);
var student = new Student(Guid.NewGuid(), "firstname", "lastname");
student.Enroll(course);
student.Complete(course);
await sut.StudentsRepository.CreateAsync(student, CancellationToken.None);
await sut.CommitAsync(CancellationToken.None);
var messages = await dbContext.Messages.ToListAsync();
messages.Should().HaveCount(2);
}
// POST: Courses/Delete/5
//[HttpPost, ActionName("Delete")]
//[ValidateAntiForgeryToken]
public ActionResult Delete(int id)
{
Course course = db.Courses.Find(id);
ApplicationUser teacher = course.Teacher;
CoursesRepository repository = new CoursesRepository();
if (course == null)
{
return(HttpNotFound());
}
try
{
var path = teacher.Path + "\\" + course.CourseName;
Directory.Delete(path.ToString(), true);
repository.RemoveAssignments(course);
repository.RemoveLectures(course);
repository.DeleteCoursesEnrollments(course);
db.Courses.Remove(course);
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
return(RedirectToAction("Index"));
}
public ActionResult GetCourses(string Category, int?StudentID)
{
if (string.IsNullOrEmpty(Category))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CoursesRepository coursesRepository = new CoursesRepository();
CourseRuleViewModel Courses = new CourseRuleViewModel();
if (StudentID == null)
{
//Create Request
//get Courses list
Courses = coursesRepository.GetCourseByCategory(Category);
}
else
{
Courses = coursesRepository.GetCourseByCategory(Category, Convert.ToInt32(StudentID));
}
if (Request.IsAjaxRequest())
{
return(PartialView("/Views/Students/_PartialCourseList.cshtml", Courses));
}
else
{
return(Json(Courses, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Create(Lecture lecture, int CourseId)
{
CoursesRepository repository = new CoursesRepository();
Course course = db.Courses.Where(c => c.CourseId == CourseId).SingleOrDefault();
if (!repository.CheckIfLectureExists(lecture, CourseId))
{
ApplicationUser teacher = db.Users.Find(course.Teacher.Id);
List <Lecture> lectures = course.Lectures.ToList();
try
{
lecture.Filename = Path.GetFileName(lecture.LectureFile.FileName);
string fileName = Path.Combine(Server.MapPath("~/Users/" + teacher.UserName + "/" + course.CourseName + "/Lectures/"), lecture.Filename);
lecture.LectureFile.SaveAs(fileName);
lecture.Path = fileName;
lecture.Course = course;
db.Lectures.Add(lecture);
db.SaveChanges();
return(RedirectToAction("CourseHome", "Courses", course.CourseId));
}
catch (Exception e)
{
throw e;
}
}
else
{
TempData["Errormsg"] = "Lecture already exists! Try again";
return(RedirectToAction("CourseHome", "Courses", course));
}
}
public async Task <ActionResult <Course> > GetCourseWithID(int courseID)
{
if (Validation.IsAnyInputObjectDataNotSpecified(new List <object> {
courseID
}))
{
return(BadRequest("Error: course ID must be specified (with non-zero value)"));
}
using (var connection = new SqlConnection(Configuration.GetConnectionString("DefaultConnection")))
{
try
{
connection.Open();
var course = await CoursesRepository.GetDefiniteCourse(connection, courseID);
if (course == null)
{
return(NotFound("There isn't course with such ID in database"));
}
return(course);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
}
public async Task <IActionResult> DeleteCourseWithID(int courseID)
{
if (Validation.IsAnyInputObjectDataNotSpecified(new List <object> {
courseID
}))
{
return(BadRequest("Error: course ID must be specified (with non-zero value)"));
}
using (var connection = new SqlConnection(Configuration.GetConnectionString("DefaultConnection")))
{
try
{
connection.Open();
var numberOfAffectedRows = await CoursesRepository.DeleteCourseAsync(connection, courseID);
if (numberOfAffectedRows == 0)
{
return(NotFound("Course with such id isn't found in database"));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
return(NoContent());
}
public HomeController()
{
projectsRepository = new ProjectsRepository(db);
coursesRepository = new CoursesRepository(db);
usersRepository = new UsersRepository(db);
submissionsRepository = new SubmissionsRepository(db);
}
public CoursesServiceImpl(TransactionManager transactionManager, CoursesRepository productRepo, CoursesMaker productMaker, FacultyRepository facultyRepository, IHostingEnvironment hostingEnvironment)
{
_facultyRepository = facultyRepository;
_transactionManager = transactionManager;
_productRepo = productRepo;
_productMaker = productMaker;
_hostingEnvironment = hostingEnvironment;
}
public DataAccess()
{
_context = new UniversityDbContext();
_coursesRepository = new CoursesRepository(_context);
_departmentsRepository = new DepartmentsRepository(_context);
_studentsRepository = new StudentsRepository(_context);
_enrollemntsRepository = new EnrollementsRepository(_context);
}
public ProjectTasksController()
{
projectTasksRepository = new ProjectTasksRepository(db);
coursesRepository = new CoursesRepository(db);
projectsRepository = new ProjectsRepository(db);
submissionsRepository = new SubmissionsRepository(db);
userCoursesRepostiory = new UserCoursesRepository(db);
}
public override void SetUp()
{
base.SetUp();
TeachersRepository.Add(Arg.Any <Teacher>()).Returns(new VoidResult());
CoursesRepository.Add(Arg.Any <Course>()).Returns(new VoidResult())
.AndDoes(ci => _course = ci.ArgAt <Course>(0));
}
public override void SetUp()
{
base.SetUp();
_course = CoursesRepository.FoundEntity();
CourseDetails.Id = _course.Id;
CourseDetails.Teacher.Id = Guid.Empty;
}
public void ListAll_ListIsCalled()
{
// Arrange
// Act
var result = Service.ListAll();
// Assert
CoursesRepository.Received().List();
}
public UsersController()
{
store = new UserStore <ApplicationUser>(db);
userManager = new UserManager <ApplicationUser>(store);
usersRepository = new UsersRepository(db);
userCoursesRepository = new UserCoursesRepository(db);
coursesRepository = new CoursesRepository(db);
submissionsRepository = new SubmissionsRepository(db);
}
public async Task <ActionResult> Index(string order = "Ascending Course", string theme = "All Themes")
{
ViewBag.order = order;
ViewBag.theme = theme;
IEnumerable <Course> courses = null;
using (_courseRepository = new CoursesRepository())
{
courses = await _courseRepository.GetListWithEnrollmentsAndThemesAsync();
if (theme != "All Themes")
{
courses = from x in courses where x.CourseTheme.ThemeName == theme select x;
}
switch (order)
{
case "Ascending Course":
{
courses = from x in courses orderby x.Title select x;
break;
}
case "Descending Course":
{
courses = from x in courses orderby x.Title descending select x;
break;
}
case "Ascending Students":
{
courses = from x in courses orderby x.Enrollments.Count select x;
break;
}
case "Descending Students":
{
courses = from x in courses orderby x.Enrollments.Count descending select x;
break;
}
case "Ascending Monthes":
{
courses = from x in courses orderby x.TotalMonths() select x;
break;
}
case "Descending Monthes":
{
courses = from x in courses orderby x.TotalMonths() descending select x;
break;
}
}
}
return(View(courses.ToList()));;
}
public CoursesController(CoursesRepository productRepo, CoursesService productService, IMapper mapper, FileHelper fileHelper, PaginatedMetaService paginatedMetaService, FacultyRepository facultyRepository)
{
_productRepo = productRepo;
_productService = productService;
_mapper = mapper;
_fileHelper = fileHelper;
_paginatedMetaService = paginatedMetaService;
_facultyRepository = facultyRepository;
}
public void AddCourses(Courses entity)
{
CoursesRepository courseRepository = new CoursesRepository();
DepartmentsRepository departmentsRepository = new DepartmentsRepository();
Departments departments = departmentsRepository.PrintOne(entity.DepartmentID);
entity.Departments = departments;
courseRepository.Add(entity);
}
public CoursesController()
{
var coursesContext = new CoursesContext();
var coursesUnitOfWork = new CoursesUnitOfWork(coursesContext);
var coursesRespository = new CoursesRepository(coursesUnitOfWork);
this._coursesAppService = new CoursesAppService(coursesRespository);
}
// DI DbContext into Unit Of Work
public UnitOfWork(ApplicationDBContext _myAppDbContext)
{
myAppDbContext = _myAppDbContext;
/* Initialise all our repositories
* Declare Instance of Repositories implementing the Repositories interface */
Student = new StudentRepository(myAppDbContext);
Teacher = new TeachersRepository(myAppDbContext);
Course = new CoursesRepository(myAppDbContext);
}
public IHttpActionResult Delete(Course id)
{
bool deleted = new CoursesRepository().Delete(id.ID);
if (!deleted)
{
return(BadRequest("Course couldn't be Deleted"));
}
return(Ok());
}
private void CoursesComboBox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
ICoursesRepository coursesService =
new CoursesRepository(AppConfig.ServiceUrl, _accountService);
Course selectedCourse = coursesService.Get((int)CoursesComboBox.SelectedValue);
WindowCreator.GetCurseMenuPanel(_accountService, selectedCourse);
InitCourseTreeView(selectedCourse);
}
private void InitCourses()
{
ICoursesRepository coursesService = new CoursesRepository(AppConfig.ServiceUrl, _accountService);
var courses = coursesService.GetList();
CoursesComboBox.ItemsSource = courses.data;
CoursesComboBox.DisplayMemberPath = "name";
CoursesComboBox.SelectedValuePath = "id";
}
public async Task <IActionResult> Post([FromBody] Dictionary <string, string> course)
{
if (Validation.IsAnyInputObjectDataNotSpecified(new List <object> {
course.ContainsKey("Name") ? course["Name"] : null,
course.ContainsKey("StartDate") ? course["StartDate"] : null, course.ContainsKey("EndDate") ? course["EndDate"] : null,
course.ContainsKey("PassingScore") ? course["PassingScore"] : null
}))
{
return(BadRequest("Error: all course input data must be specified"));
}
course["Name"] = course["Name"].Trim();
course["StartDate"] = course["StartDate"].Trim();
course["EndDate"] = course["EndDate"].Trim();
course["PassingScore"] = course["PassingScore"].Trim();
if (!Validation.ValidateDateTimeAndGetParsed(course["StartDate"], out DateTime resultStartDate))
{
return(BadRequest("Error: start date is incorrect"));
}
if (!Validation.ValidateDateTimeAndGetParsed(course["EndDate"], out DateTime resultEndDate))
{
return(BadRequest("Error: end date is incorrect"));
}
if (!Validation.ValidateIntAndGetParsed(course["PassingScore"], out int resultPassingScore) || resultPassingScore <= 0)
{
return(BadRequest("Error: passing score is incorrect"));
}
var resultCourse = new Course
{
Name = course["Name"],
StartDate = resultStartDate,
EndDate = resultEndDate,
PassingScore = resultPassingScore
};
using (var connection = new SqlConnection(Configuration.GetConnectionString("DefaultConnection")))
{
try
{
connection.Open();
await CoursesRepository.CreateCourseAsync(connection, resultCourse);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
return(Ok(resultCourse));
}
public void Delete_CourseDeleted_Saved()
{
// Arrange
var course = CoursesRepository.CanDelete();
// Act
var result = Service.Delete(course.Id);
// Assert
UnitOfWork.Received().SaveChanges();
}
