public IActionResult CourseSinglePage(int id)
{
var course = rCourse.GetBy(c => c.Id == id);
Cart cart = null;
CourseMember courseMember = new CourseMember();
if (User.Identity.IsAuthenticated) // Sepete ekle
{
int uyeid = Convert.ToInt32(User.Claims.FirstOrDefault(f => f.Type == ClaimTypes.Sid).Value);
cart = rCart.GetBy(
x => x.MemberId == uyeid &&
x.CourseId == id);
courseMember = rCourseMember.GetBy(
x => x.MemberId == uyeid &&
x.CourseId == id);
}
Course courses = rCourse.GetBy(x => x.Id == id);
int? educatid = courses.EducatorID;
Educator educators = rEducator.GetBy(x => x.ID == educatid);
List <Lesson> lesson = rLesson.GetAllLazy(x => x.CourseID == id, includeProperties: "Videos").ToList();
//Image getir
Image img = myContext.Images.FirstOrDefault(i => i.CourseID == courses.Id);
LessonCoursesVM lessonCourses = new LessonCoursesVM {
Lessons = lesson, Courses = courses, Educator = educators, Cart = cart, courseMember = courseMember
};
return(View(lessonCourses));
}
public async Task GetAllTest()
{
var courseMember1 = new CourseMember()
{
CourseId = 1, MemberId = 1, Day = "Monday"
};
var courseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Tuesday"
};
var courseMembers = new List <CourseMember> {
courseMember1, courseMember2
};
var fakeCourseMemberRepositoryMock = new Mock <ICourseMemberRepository>();
var fakeCourseRepositoryMock = new Mock <ICourseRepository>();
var fakeMemberRepositoryMock = new Mock <IMemberRepository>();
fakeCourseMemberRepositoryMock.Setup(x => x.GetAll()).ReturnsAsync(courseMembers);
var courseMemberService = new CourseMemberService(fakeCourseMemberRepositoryMock.Object, fakeCourseRepositoryMock.Object, fakeMemberRepositoryMock.Object);
var resultCourseMemberes = await courseMemberService.GetAllCourseMembers();
Assert.Collection(resultCourseMemberes, courseMember =>
{
Assert.Equal("Monday", courseMember.Day);
},
courseMember =>
{
Assert.Equal("Tuesday", courseMember.Day);
});
}
public async Task AddAndSaveTest()
{
var courseMember1 = new CourseMember()
{
CourseId = 1, MemberId = 1, Day = "Monday"
};
var courseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Tuesday"
};
var courseMembers = new List <CourseMember> {
courseMember1, courseMember2
};
var courseMember3 = new CourseMember()
{
CourseId = 3, MemberId = 3, Day = "Wednesday"
};
var fakeCourseMemberRepositoryMock = new Mock <ICourseMemberRepository>();
var fakeCourseRepositoryMock = new Mock <ICourseRepository>(); var fakeMemberRepositoryMock = new Mock <IMemberRepository>();
fakeCourseMemberRepositoryMock.Setup(x => x.Add(It.IsAny <CourseMember>())).Callback <CourseMember>(arg => courseMembers.Add(arg));
var courseMemberService = new CourseMemberService(fakeCourseMemberRepositoryMock.Object, fakeCourseRepositoryMock.Object, fakeMemberRepositoryMock.Object);
await courseMemberService.AddAndSave(courseMember3);
Assert.Equal(3, courseMembers.Count);
}
public async Task <IActionResult> Edit(long CourseId, long MemberId, [Bind("CourseId,MemberId,Day")] CourseMember courseMember)
{
if (CourseId != courseMember.CourseId || MemberId != courseMember.MemberId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _courseMemberService.UpdateAndSave(courseMember);
}
catch (DbUpdateConcurrencyException)
{
if (!_courseMemberService.CourseMemberExists(courseMember.CourseId, courseMember.MemberId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(await _courseMemberService.GetAllCourses(), "Id", "Name", courseMember.CourseId);
ViewData["MemberId"] = new SelectList(await _courseMemberService.GetAllMembers(), "Id", "Email", courseMember.MemberId);
ViewData["Days"] = new SelectList(Days);
return(View(courseMember));
}
public async Task UpdateAndSaveTest()
{
var courseMember1 = new CourseMember()
{
CourseId = 1, MemberId = 1, Day = "Monday"
};
var courseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Tuesday"
};
var courseMembers = new List <CourseMember> {
courseMember1, courseMember2
};
var newCourseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Wednesday"
};
var fakeCourseMemberRepositoryMock = new Mock <ICourseMemberRepository>();
var fakeCourseRepositoryMock = new Mock <ICourseRepository>(); var fakeMemberRepositoryMock = new Mock <IMemberRepository>();
fakeCourseMemberRepositoryMock.Setup(x => x.Update(It.IsAny <CourseMember>())).Callback <CourseMember>(arg => courseMembers[1] = arg);
var courseMemberService = new CourseMemberService(fakeCourseMemberRepositoryMock.Object, fakeCourseRepositoryMock.Object, fakeMemberRepositoryMock.Object);
await courseMemberService.UpdateAndSave(newCourseMember2);
Assert.Equal("Wednesday", courseMembers[1].Day);
}
public async Task RemoveCourseMemberAsync(int courseId, string teacherId)
{
CourseMember binding = await context.Set <CourseMember>()
.FirstAsync(b => b.TeacherId == teacherId && b.CourseId == courseId);
context.Set <CourseMember>().Remove(binding);
}
public async Task DeleteAndSaveTest()
{
var courseMember1 = new CourseMember()
{
CourseId = 1, MemberId = 1, Day = "Monday"
};
var courseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Tuesday"
};
var courseMembers = new List <CourseMember> {
courseMember1, courseMember2
};
var fakeCourseMemberRepositoryMock = new Mock <ICourseMemberRepository>();
var fakeCourseRepositoryMock = new Mock <ICourseRepository>(); var fakeMemberRepositoryMock = new Mock <IMemberRepository>();
fakeCourseMemberRepositoryMock.Setup(x => x.Delete(It.IsAny <long>(), It.IsAny <long>())).Callback(() => courseMembers.RemoveAt(1));
var courseMemberService = new CourseMemberService(fakeCourseMemberRepositoryMock.Object, fakeCourseRepositoryMock.Object, fakeMemberRepositoryMock.Object);
await courseMemberService.DeleteAndSave(courseMember2.CourseId, courseMember2.MemberId);
Assert.Single(courseMembers);
Assert.Equal("Monday", courseMembers[0].Day);
}
public async Task <CommandResult> Handle(EnrollCourseCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
return(request.Result);
}
StudyCourse course = await studyCourseRepository.GetById(request.Id);
if (course is null)
{
AddError("The course doesn't exists.");
return(request.Result);
}
bool userAlreadyEnroled = studyCourseRepository.CheckStudentEnrolled(request.Id, request.UserId);
if (userAlreadyEnroled)
{
AddError("User already enrolled to this course");
return(request.Result);
}
CourseMember student = new CourseMember
{
UserId = request.UserId
};
await studyCourseRepository.AddStudent(request.Id, student);
request.Result.Validation = await Commit(unitOfWork);
return(request.Result);
}
public async Task <IActionResult> Edit(int id, [Bind("CourseMemberID,UserID,CourseID")] CourseMember courseMember)
{
if (id != courseMember.CourseMemberID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(courseMember);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CourseMemberExists(courseMember.CourseMemberID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(courseMember));
}
/// <summary>
/// try to get <see cref="TestSubmission"/> that belongs to the given <see cref="CourseMember"/> and <see cref="CourseTest"/>
/// </summary>
/// <param name="courseMember">given <see cref="CourseMember"/> of the test submission</param>
/// <param name="courseTest">given <see cref="CourseTest"/> of the test submission</param>
/// <returns><see cref="TestSubmission"/> if exists, otherwise NULL</returns>
private TestSubmission TryGetSubmissionByCourseMemberAndTest(CourseMember courseMember, CourseTest courseTest)
{
var courseMemberSubmission = GetAllSubmittedWithTestAndStudent(true)
.Where(ts => ts.Student.Id == courseMember.Id);
return(courseMemberSubmission
.SingleOrDefault(ts => ts.Test.Id == courseTest.Id));
}
public async Task AddCourseMemberAsync(int courseId, string teacherId)
{
CourseMember binding = new CourseMember
{
CourseId = courseId,
TeacherId = teacherId
};
await context.Set <CourseMember>().AddAsync(binding);
}
public void AssignGrade(string memberId, AddGradeVM gradeVM)
{
CourseMember cm = courseMemberService.GetMemberWithUser(memberId);
Grade grade = new Grade(gradeVM.PercentualValue, gradeVM.Comment, gradeVM.Topic, gradeVM.Weight, cm);
gradeService.AssignGrade(grade);
gradeService.CommitChanges();
}
public async Task AddStudent(Guid courseId, CourseMember student)
{
student.Id = Guid.NewGuid();
FilterDefinition <StudyCourse> filter = Builders <StudyCourse> .Filter.Where(x => x.Id == courseId);
UpdateDefinition <StudyCourse> add = Builders <StudyCourse> .Update.AddToSet(c => c.Members, student);
await Context.AddCommand(() => DbSet.UpdateOneAsync(filter, add));
}
public async Task <IActionResult> Create([Bind("CourseMemberID,UserID,CourseID")] CourseMember courseMember)
{
if (ModelState.IsValid)
{
_context.Add(courseMember);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(courseMember));
}
public async Task <IActionResult> Create([Bind("CourseId,MemberId,Day")] CourseMember courseMember)
{
if (ModelState.IsValid)
{
await _courseMemberService.AddAndSave(courseMember);
return(RedirectToAction(nameof(Index)));
}
ViewData["CourseId"] = new SelectList(await _courseMemberService.GetAllCourses(), "Id", "Name", courseMember.CourseId);
ViewData["MemberId"] = new SelectList(await _courseMemberService.GetAllMembers(), "Id", "Email", courseMember.MemberId);
return(View(courseMember));
}
/// <summary>
/// create new empty <see cref="TestSubmission"/>
/// </summary>
/// <param name="courseMember"><see cref="CourseMember"/> of the test submission</param>
/// <param name="testWithQuestions">given <see cref="CourseTest"/> of the test submission</param>
/// <returns>empty <see cref="TestSubmission"/></returns>
private TestSubmission CreateEmptySubmission(CourseMember courseMember, CourseTest testWithQuestions)
{
var emptyAnswers = testWithQuestions.Questions.Select(
question => new TestSubmissionAnswer(question, string.Empty));
var emptyTestSubmission = new TestSubmission(testWithQuestions, courseMember,
emptyAnswers.ToList());
dbContext.TestSubmissions.Add(emptyTestSubmission);
return(emptyTestSubmission);
}
public async Task <bool> AddStudent(Guid courseId, CourseMember student)
{
student.Id = Guid.NewGuid();
FilterDefinition <StudyCourse> filter = Builders <StudyCourse> .Filter.Where(x => x.Id == courseId);
UpdateDefinition <StudyCourse> add = Builders <StudyCourse> .Update.AddToSet(c => c.Members, student);
UpdateResult result = await DbSet.UpdateOneAsync(filter, add);
return(result.IsAcknowledged && result.MatchedCount > 0);
}
/// <inheritdoc/>
public TestSubmission LoadOrCreateSubmission(CourseTest testWithQuestions, CourseMember courseMember)
{
var foundSubmission = TryGetSubmissionByCourseMemberAndTest(courseMember, testWithQuestions);
// submission not found -> create empty
if (foundSubmission == null)
{
return(CreateEmptySubmission(courseMember, testWithQuestions));
}
else
{
return(foundSubmission);
}
}
public async Task <bool> EnrollCourse(Guid userId, Guid courseId)
{
bool userAlreadyEnroled = studyCourseRepository.CheckStudentEnrolled(courseId, userId);
if (userAlreadyEnroled)
{
return(false);
}
CourseMember student = new CourseMember
{
UserId = userId
};
return(await studyCourseRepository.AddStudent(courseId, student));
}
public async Task UpdateStudent(Guid courseId, CourseMember student)
{
student.LastUpdateDate = DateTime.Now;
FilterDefinition <StudyCourse> filter = Builders <StudyCourse> .Filter.And(
Builders <StudyCourse> .Filter.Eq(x => x.Id, courseId),
Builders <StudyCourse> .Filter.ElemMatch(x => x.Members, x => x.UserId == student.Id));
UpdateDefinition <StudyCourse> update = Builders <StudyCourse> .Update
.Set(c => c.Members[-1].Accepted, student.Accepted)
.Set(c => c.Members[-1].PlanId, student.PlanId)
.Set(c => c.Members[-1].Passed, student.Passed)
.Set(c => c.Members[-1].FinalScore, student.FinalScore);
await Context.AddCommand(() => DbSet.UpdateOneAsync(filter, update));
}
public async Task <bool> UpdateStudent(Guid courseId, CourseMember student)
{
student.LastUpdateDate = DateTime.Now;
FilterDefinition <StudyCourse> filter = Builders <StudyCourse> .Filter.And(
Builders <StudyCourse> .Filter.Eq(x => x.Id, courseId),
Builders <StudyCourse> .Filter.ElemMatch(x => x.Members, x => x.UserId == student.Id));
UpdateDefinition <StudyCourse> update = Builders <StudyCourse> .Update
.Set(c => c.Members[-1].Accepted, student.Accepted)
.Set(c => c.Members[-1].PlanId, student.PlanId)
.Set(c => c.Members[-1].Passed, student.Passed)
.Set(c => c.Members[-1].FinalScore, student.FinalScore);
UpdateResult result = await DbSet.UpdateOneAsync(filter, update);
return(result.IsAcknowledged && result.ModifiedCount > 0);
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
if (_context.CourseMembers.Any(c => c.StudentId == id) != false)
{
CourseMember courseMember = _context.Set <CourseMember>().Where(c => c.StudentId == id).FirstOrDefault();
_context.Set <CourseMember>().Remove(courseMember);
}
if (_context.Ratings.Any(c => c.StudentId == id) != false)
{
var rating = _context.Set <Rating>().Where(c => c.StudentId == id).FirstOrDefault();
_context.Set <Rating>().Remove(rating);
}
await _context.SaveChangesAsync();
var student = await _context.Set <Student>().FindAsync(id);
_context.Set <Student>().Remove(student);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
private void BindUserItem(CourseMember mem, Label lblName, Label lblProgress,
System.Web.UI.WebControls.Image imgStatus,
System.Web.UI.WebControls.Image imgType, CheckBox chkSelect)
{
User user = mem.User;
imgType.ImageUrl = "../../attributes/user.gif";
lblName.Text = user.FullName + "(" + user.UserName + ")";
Users userda = new Users(Globals.CurrentIdentity);
Components.Submission sub = userda.GetLatestAsstSubmission(user.UserName, GetAsstID());
if (sub == null)
{
imgStatus.ImageUrl = "../../attributes/nosub.gif";
lblProgress.Text = "N/A";
chkSelect.Enabled = false;
}
else
{
switch (sub.Status)
{
case Components.Submission.GRADED:
imgStatus.ImageUrl = "../../attributes/subgrade.gif";
lblProgress.Text = "100%";
break;
case Components.Submission.INPROGRESS:
imgStatus.ImageUrl = "../../attributes/clock.gif";
lblProgress.Text = "??%";
break;
case Components.Submission.UNGRADED:
imgStatus.ImageUrl = "../../attributes/sub.gif";
lblProgress.Text = "0%";
break;
}
}
}
public async Task GetByIdTest()
{
var courseMember1 = new CourseMember()
{
CourseId = 1, MemberId = 1, Day = "Monday"
};
var courseMember2 = new CourseMember()
{
CourseId = 2, MemberId = 2, Day = "Tuesday"
};
var fakeCourseMemberRepositoryMock = new Mock <ICourseMemberRepository>();
var fakeCourseRepositoryMock = new Mock <ICourseRepository>(); var fakeMemberRepositoryMock = new Mock <IMemberRepository>();
fakeCourseMemberRepositoryMock.Setup(x => x.GetByID(1, 1)).ReturnsAsync(courseMember1);
var courseMemberService = new CourseMemberService(fakeCourseMemberRepositoryMock.Object, fakeCourseRepositoryMock.Object, fakeMemberRepositoryMock.Object);
var result = await courseMemberService.GetById(1, 1);
Assert.Equal("Monday", result.Day);
}
public async Task <IEnumerable <Course> > Leave(int courseId)
{
var course = await _context.Courses
.Where(x => x.Members.Any(y => y.MemberId == GetUserId()))
.Include(x => x.Members)
.SingleOrDefaultAsync(x => x.Id == courseId);
if (course == null)
{
throw new UserException("Course not found.", 404);
}
CourseMember courseMember = course.Members.FirstOrDefault(x => x.MemberId == GetUserId());
if (courseMember == null)
{
throw new UserException("No course found where you are a member.", 404);
}
course.Members.Remove(courseMember);
await _context.SaveChangesAsync();
return(await Get());
}
public IActionResult Lessons(int id)
{
Lesson lesson = rLesson.GetBy(x => x.Id == id);
//Courses.Where(x=>x.KategoriId == kategoriId).OrderByDescending(x => x.Id).Take(adet).ToList
Course course = rCourse.GetBy(x => x.Id == lesson.CourseID);
CourseMember courseMember = new CourseMember();
if (User.Identity.IsAuthenticated)
{
int uyeid = Convert.ToInt32(User.Claims.FirstOrDefault(f => f.Type == ClaimTypes.Sid).Value);
courseMember = rCourseMember.GetBy(x => x.CourseId == course.Id &&
x.MemberId == uyeid);
}
List <Lesson> lessons = rLesson.GetAll(x => x.CourseID == course.Id).ToList();
Educator educator = rEducator.GetBy(x => x.ID == course.EducatorID);
Videos video = rVideos.GetBy(x => x.LessonID == id);
List <Videos> videos = rVideos.GetAll(x => x.CourseID == course.Id).ToList();
LessonCoursesVM lessonCourses = new LessonCoursesVM {
Lessons = lessons, Courses = course, Educator = educator, Video = video, Lesson = lesson, Videos = videos, courseMember = courseMember
};
//return View(rCourse.GetAll(x=>x.CategoryID == id).ToList(), rCategory.GetAll().ToList());
return(View(lessonCourses));
}
public void Delete(long CourseId, long MemberId)
{
CourseMember courseMember = context.CourseMembers.Find(CourseId, MemberId);
context.CourseMembers.Remove(courseMember);
}
public void Update(CourseMember courseMember)
{
context.Entry(courseMember).State = EntityState.Modified;
}
public async Task UpdateAndSave(CourseMember courseMember)
{
_courseMemberRepo.Update(courseMember);
await _courseMemberRepo.Save();
}
public async Task AddAndSave(CourseMember courseMember)
{
_courseMemberRepo.Add(courseMember);
await _courseMemberRepo.Save();
}
private void BindUserItem(CourseMember mem, Label lblName, Label lblProgress,
System.Web.UI.WebControls.Image imgStatus,
System.Web.UI.WebControls.Image imgType, CheckBox chkSelect)
{
User user = mem.User;
imgType.ImageUrl = "../../attributes/user.gif";
lblName.Text = user.FullName + "(" + user.UserName + ")";
Users userda = new Users(Globals.CurrentIdentity);
Components.Submission sub = userda.GetLatestAsstSubmission(user.UserName, GetAsstID());
if (sub == null) {
imgStatus.ImageUrl = "../../attributes/nosub.gif";
lblProgress.Text = "N/A";
chkSelect.Enabled = false;
}
else {
switch (sub.Status) {
case Components.Submission.GRADED:
imgStatus.ImageUrl = "../../attributes/subgrade.gif";
lblProgress.Text = "100%";
break;
case Components.Submission.INPROGRESS:
imgStatus.ImageUrl = "../../attributes/clock.gif";
lblProgress.Text = "??%";
break;
case Components.Submission.UNGRADED:
imgStatus.ImageUrl = "../../attributes/sub.gif";
lblProgress.Text = "0%";
break;
}
}
}
