// GET: Lectures/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction("Index", "Courses"));
}
Lecture lecture = LTDbApi.GetLecture(id.Value);
if (lecture == null)
{
return(HttpNotFound());
}
var currentUser = LTDbApi.GetUser(User.Identity.Name);
if (!currentUser.IsAdmin && currentUser.Id != lecture.Course.Lecturer.LTUserId)
{
return(RedirectToAction("Details", new { id = id }));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
LectureViewModel model = new LectureViewModel
{
AdditionalContent = lecture.AdditionalContent,
Content = lecture.Content,
Id = lecture.Id,
LectureName = lecture.LectureName,
VideoLink = lecture.VideoLink
};
ViewBag.CourseId = lecture.CourseId;
return(View(model));
}
private List <LectureViewModel> _getLectures(string userId)
{
var lecturer = _lecturerDataService.GetByUserId(userId);
var lectures = _lectureDataService.GetByLecturerId(lecturer.Id);
var mappedLectures = new List <LectureViewModel>();
foreach (var lecture in lectures)
{
foreach (var occurence in lecture.Occurences)
{
var mappedLecture = new LectureViewModel
{
Id = lecture.Id,
Auditorium = lecture.Auditorium.Name,
Lecturer = lecture.Lecturer.Name + " " + lecture.Lecturer.Surname,
Date = occurence.Date,
LectureTime = lecture.LectureTime,
LectureType = lecture.LectureType.Type,
Subject = lecture.Subject,
Group = lecture.Group
};
mappedLectures.Add(mappedLecture);
}
}
return(mappedLectures);
}
public async Task <ActionResult> Edit(LectureViewModel lectureModel)
{
if (!string.IsNullOrEmpty(lectureModel.VideoLink) && !lectureModel.VideoLink.Contains("watch?v=") && !lectureModel.VideoLink.Contains("embed/"))
{
ModelState.AddModelError(string.Empty, "Link to youtube video must contain \"watch?v=\" or \"embed/\" part, just like this: https://www.youtube.com/watch?v=dQw4w9WgXcQ");
}
if (ModelState.IsValid)
{
var currentUser = LTDbApi.GetUser(User.Identity.Name);
var lecture = LTDbApi.GetLecture(lectureModel.Id);
if (!currentUser.IsAdmin && currentUser.Id != lecture.Course.Lecturer.LTUserId)
{
return(RedirectToAction("Details", new { id = lecture.Id }));
//return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
lecture.AdditionalContent = lectureModel.AdditionalContent;
lecture.Content = lectureModel.Content;
lecture.LectureName = lectureModel.LectureName;
if (!string.IsNullOrEmpty(lectureModel.VideoLink) && lectureModel.VideoLink.Contains("watch?v="))
{
lecture.VideoLink = lectureModel.VideoLink.Replace("watch?v=", "embed/");
}
LTDbApi.UpdateLecture(lecture);
return(RedirectToAction("Details", "Courses", new { id = lecture.CourseId }));
}
return(View(lectureModel));
}
public async Task <ActionResult> SaveScore(int score)
{
var userId = User.Identity.GetUserId().ToString();
if (score >= 0 && score <= 10)
{
TodayWord word = TempData["Word"] as TodayWord;
IList <TodayWord> todayWords = TempData["ListWords"] as IList <TodayWord>;
LectureViewModel model = new LectureViewModel(word, todayWords);
// increase exp;
await m_expService.AddExpForLearnWordAsync(userId, word.WordId, score, word.WordId); // comple word
// save learnword result
var result = m_learnWordService.SaveLearnWordResult(model.TodayWord, score);
await m_expService.AddExpForContinuousLearningAsync(userId, todayWords); // continues if complete all words
TempData["ListWordToDay"] = todayWords;
// Update partial view
if (result == ServiceResult.Success)
{
return(PartialView("_ListTodayWordPartial", todayWords));
}
}
return(Json("error", JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> AddLecture(LectureViewModel objLecture)
{
if (ModelState.IsValid)
{
string uniqueFileName = Utility.ProcessUploadedFile(objLecture.Lecture_File, _hostingEnvironment, "Lectures");
var classSectionObj = await _tPClassReposiroty.GetClassSectionById(objLecture.Class_Id, objLecture.Section_Id);
if (classSectionObj != null)
{
var classSubjectObj = await _tPClassReposiroty.GetClassSubjectById(classSectionObj.ClassSection_id, objLecture.Subject_Id);
if (classSectionObj != null)
{
Lecture newLecture = new Lecture
{
Lecture_Name = objLecture.Lecture_Name,
Lecture_Detail = objLecture.Lecture_Detail,
Lecture_File = uniqueFileName,
LecturePost_Date = objLecture.LecturePost_Date.ToString("yyyyMMdd"), //DateTime.Now.ToString(),
Teacher_Id = HttpContext.Session.GetInt32("UserId") ?? 1,
ClassSubject_Id = classSubjectObj.ClassSubject_Id
};
int result = await _LectureRepository.AddLecture(newLecture);
if (result == 1)
{
TempData["Success"] = " Lecture Added Successfully";
//return RedirectToAction("Index", "lecture", new { area = "teachers" });
return(RedirectToAction("subjects", "class", new { ClassSectionId = classSectionObj.ClassSection_id, area = "teachers" }));
}
else
{
TempData["Error"] = "Adding Lecture Failed";
///return RedirectToAction("Index", "lecture", new { area = "teachers" });
return(RedirectToAction("subjects", "class", new { ClassSectionId = classSectionObj.ClassSection_id, area = "teachers" }));
}
}
else
{
TempData["Error"] = "Class And Section Dont Have Seleceted Subject";
//return RedirectToAction("Index", "lecture", new { area = "teachers" });
return(RedirectToAction("subjects", "class", new { ClassSectionId = classSectionObj.ClassSection_id, area = "teachers" }));
}
}
else
{
TempData["Error"] = "Class With Section Didn't Find";
//return RedirectToAction("Index", "lecture", new { area = "teachers" });
return(RedirectToAction("subjects", "class", new { ClassSectionId = classSectionObj.ClassSection_id, area = "teachers" }));
}
}
return(View());
}
public JsonResult UpdateLecture([DataSourceRequest] DataSourceRequest request, LectureViewModel lecture)
{
if (lecture == null || !ModelState.IsValid)
{
return Json(new[] { lecture }.ToDataSourceResult(request, ModelState), JsonRequestBehavior.AllowGet);
}
var updatedLecture = this.lecturesServices.UpdateLecture(lecture);
return Json((new[] { updatedLecture }.ToDataSourceResult(request, ModelState)), JsonRequestBehavior.AllowGet);
}
private static async Task <LectureViewModel> ViewModel()
{
var lecture = new LectureViewModel
{
Id = 1,
Name = "Math",
ProfessorId = 1,
};
return(lecture);
}
public async Task <ActionResult <Lecture> > Post(LectureViewModel lectureViewModel)
{
if (lectureViewModel == null)
{
return(BadRequest());
}
var lecture = _mapper.Map <LectureDTO>(lectureViewModel);
await _db.CreateAsync(lecture);
return(Ok(lectureViewModel));
}
public IActionResult AdminIndex(int?page)
{
var audio = dbContext.Lectures
.Select(x => new Audio {
ID = x.ID, Title = x.Title, Date = x.Date
})
.ToList();
var pager = new Pager(audio.Count(), page);
audioView = new LectureViewModel()
{
Audios = audio.Skip((pager.CurrentPage - 1) * pager.PageSize).Take(pager.PageSize),
PagerView = pager
};
return(View(audioView));
}
public LectureViewModel UpdateLecture(LectureViewModel lecture)
{
var lectureFromDb = this.Data.Lectures
.GetById(lecture.Id);
lectureFromDb.Title = lecture.Title;
lectureFromDb.Description = lecture.Description;
lectureFromDb.VideoUrl = lecture.VideoUrl;
lectureFromDb.DemoUrl = lecture.DemoUrl;
lectureFromDb.PresentationUrl = lecture.PresentationUrl;
this.Data.SaveChanges();
var updatedLecture = this.GetLectureById(lecture.Id);
return updatedLecture;
}
// GET: /<controller>/
public IActionResult Index()
{
explanation = new ExplanationViewModel()
{
Explains = dbContext.Explanations
.Select(x => new Explain {
Title = x.Title, BookName = x.BookName, ID = x.ID, Date = x.Date
})
.Take(5)
.ToList()
};
writing = new WritingViewModel()
{
Books = dbContext.Writings
.Select(x => new Book {
ID = x.ID, Category = x.Category, Title = x.Title
})
.Take(5)
.ToList()
};
lecture = new LectureViewModel()
{
Audios = dbContext.Lectures
.Select(x => new Audio {
ID = x.ID, Title = x.Title, Date = x.Date
})
.Take(5)
.ToList()
};
article = new ArticleViewModel()
{
Articles = dbContext.Articles.Take(5).ToList()
};
homeView = new HomeViewModel()
{
ExplanationViews = explanation,
WritingViews = writing,
LectureViews = lecture,
ArticleViews = article
};
return(View(homeView));
}
public IActionResult Post([FromBody] LectureViewModel obj)
{
DigitalBoardMarkerContext db = new DigitalBoardMarkerContext();
Lectures l = new Lectures();
if (!db.Courses.Any(b => b.Id == obj.courseId))
{
ModelState.AddModelError("", "Course with course id doesn't exist");
return(BadRequest(ModelState));
}
l.CourseId = obj.courseId;
l.Name = obj.Name;
db.Add(l);
db.SaveChanges();
return(Ok());
}
public IActionResult UploadLectureVideo([FromBody] LectureViewModel obj)
{
string tempFilePath = obj.FilePath;
obj.FilePath = "Resources/Videos/";
obj.FilePath = obj.FilePath + tempFilePath;
DigitalBoardMarkerContext db = new DigitalBoardMarkerContext();
Video v = new Video();
v.CourseId = obj.courseId;
v.Titel = obj.Name;
v.Lectureid = obj.LectureId;
v.VideoFilePath = obj.FilePath;
db.Add(v);
db.SaveChanges();
return(Ok());
}
public async Task <ActionResult <LectureDTO> > Put(LectureViewModel lectureViewModel)
{
if (lectureViewModel == null)
{
return(BadRequest());
}
if (!_db.Find(l => l.Id == lectureViewModel.Id).Any())
{
return(NotFound());
}
var lecture = _mapper.Map <LectureDTO>(lectureViewModel);
await _db.UpdateAsync(lecture);
return(Ok(lectureViewModel));
}
public IEnumerable <LectureViewModel> getLectureNotes(int lectureId)
{
DigitalBoardMarkerContext db = new DigitalBoardMarkerContext();
List <LectureViewModel> list = new List <LectureViewModel>();
foreach (Notes v in db.Notes)
{
if (v.Lectureid == lectureId)
{
LectureViewModel lc = new LectureViewModel();
lc.Name = v.Title;
lc.Id = v.Id;
lc.FilePath = v.FilePath;
list.Add(lc);
}
}
return(list);
}
public IActionResult UploadLectureNotes([FromBody] LectureViewModel obj)
{
string tempFilePath = obj.FilePath;
obj.FilePath = "Resources/Notes/";
obj.FilePath = obj.FilePath + tempFilePath;
DigitalBoardMarkerContext db = new DigitalBoardMarkerContext();
Notes v = new Notes();
v.CourseId = obj.courseId;
v.Title = obj.Name;
v.Lectureid = obj.LectureId;
v.FilePath = obj.FilePath;
v.UpdatedBy = db.Users.Where(a => a.Email == obj.userId).FirstOrDefault().Id;
v.CreatedBy = db.Users.Where(a => a.Email == obj.userId).FirstOrDefault().Id;
v.UpdatedOn = DateTime.Now;
v.CreatedOn = DateTime.Now;
db.Add(v);
db.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Update([FromBody] LectureViewModel lectureViewModel)
{
try
{
Lecture lectureMapped = mapper.Map <Lecture>(lectureViewModel);
await lectureRepository.Update(lectureMapped);
return(Ok(new
{
Results = lectureMapped
}));
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
public ActionResult Create(LectureViewModel model)
{
if (ModelState.IsValid)
{
Lecture lecture = new Lecture()
{
ClassRoomID = model.ClassRoomID,
GroupID = model.GroupID,
LectureTimeID = model.LectureTimeID == 0 ? null : model.LectureTimeID,
SubjectID = model.SubjectID,
TeacherID = model.TeacherID,
WeekdayID = model.WeekdayID == 0 ? null : model.WeekdayID,
Type = model.Type,
IsPcRequired = model.IsPCRequired
};
db.Lectures.Add(lecture);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public LectureViewModel Get(int id)
{
LectureViewModel vm = new LectureViewModel();
var lec = (from l in db.Lectures
where l.ID == id
select l).FirstOrDefault();
vm.Title = lec.Name;
vm.ID = id;
vm.VideoURL = lec.LectureURL;
var result = (from c in db.Comments
where c.Lecture.ID == id
select c).AsEnumerable().Reverse();
if (result == null)
throw new FieldAccessException("Nothing found in db.Comments");
foreach( Comment c in result) {
CommentContainer cc = new CommentContainer();
cc.AuthorName = c.Poster.FullName;
cc.PublishedDate = c.DatePublished.ToUniversalTime().ToString();
cc.CommentText = c.CommentText;
vm.comments.Add(cc);
}
return vm;
}
public override ActionResult Index(RenderModel model)
{
IPublishedContent course = model.Content.AncestorOrSelf(nameof(Course));
int courseId = _coursesContentService.GetCourseId(course);
bool isDemoLecture = model.Content.GetPropertyValue <bool>(nameof(Lecture.IsDemo));
if (!isDemoLecture && !_subscriptions.HasActiveSubscription(User.Identity.Name, courseId))
{
TempData["ErrorMessage"] = "Моля, запишете се за курса, за да имате достъп до лекциите";
return(Redirect(course.Url));
}
IPublishedContent[] lectures = model.Content.AncestorsOrSelf(nameof(Course)).DescendantsOrSelf(nameof(Lecture)).ToArray();
LectureViewModel lectureViewModel = new LectureViewModel();
IPublishedContent precedingLecture = null;
IPublishedContent followingLecture = null;
for (int i = 0; i < lectures.Length; i++)
{
if (lectures[i].Id == model.Content.Id)
{
if (i > 0)
{
precedingLecture = lectures[i - 1];
}
if (i < lectures.Length - 1)
{
followingLecture = lectures[i + 1];
}
break;
}
}
if (precedingLecture != null)
{
lectureViewModel.PreviousLecture = new LectureLinkViewModel();
_mapper.Map(precedingLecture, lectureViewModel.PreviousLecture);
}
if (followingLecture != null)
{
lectureViewModel.NextLecture = new LectureLinkViewModel();
_mapper.Map(followingLecture, lectureViewModel.NextLecture);
}
lectureViewModel.Content = model.Content.GetPropertyValue <string>(nameof(Lecture.Content));
lectureViewModel.Id = model.Content.Id;
Dictionary <int, ModuleViewModel> modulesDictionary = new Dictionary <int, ModuleViewModel>();
foreach (IPublishedContent lectureContent in lectures)
{
int currentModuleId = lectureContent.Parent.Id;
if (!modulesDictionary.ContainsKey(currentModuleId))
{
modulesDictionary.Add(currentModuleId, new ModuleViewModel {
Name = lectureContent.Parent.Name
});
}
LectureLinkViewModel lecture = new LectureLinkViewModel();
_mapper.Map(lectureContent, lecture);
if (lectureContent.Id == model.Content.Id)
{
lecture.IsCurrent = true;
}
modulesDictionary[currentModuleId].LectureLinks.Add(lecture);
}
lectureViewModel.Modules = modulesDictionary.Values;
lectureViewModel.AssesmentUrl = Url.RouteUrl("Assessment", new { courseNiceUrl = model.Content.Parent.Parent.UrlName });
if (User.Identity.IsAuthenticated)
{
_lectures.TrackLectureVisit(User.Identity.Name, model.Content.Id);
}
return(CurrentTemplate(lectureViewModel));
}
protected override SaveableViewModel GetViewModel(EntitiesDTO.BaseEntityDTO entity)
{
if (entity == null)
return null;
SaveableViewModel viewModel;
if (entity is TeacherDTO && !(lastViewModel is TeacherPracticesViewModel))
viewModel = new TeacherLecturesViewModel(UserInterop, ControllerInterop, Dispatcher, entity as TeacherDTO);
else if (entity is TeacherDTO)
viewModel = new TeacherPracticesViewModel(UserInterop, ControllerInterop, Dispatcher, entity as TeacherDTO);
else if (entity is LectureDTO)
viewModel = new LectureViewModel(UserInterop, ControllerInterop, Dispatcher, entity as LectureDTO);
else if (entity is PracticeTeacherDTO)
viewModel = new PracticeTeacherViewModel(UserInterop, ControllerInterop, Dispatcher, entity as PracticeTeacherDTO);
else
viewModel = null;
OnIsVisibleChanged();
return viewModel;
}
public async Task <ActionResult> Lecture(string classId, string wordId)
{
DateTime start = DateTime.Now;
// begin action
// Init values
bool isAllowView = true;
bool isAllowLearn = true;
bool isAllowResume = true;
IList <TodayWord> _todayWords = new List <TodayWord>();
TodayWord startToDay = new TodayWord();
// get user id
string userId = User.Identity.GetUserId();
//Check user release date before learn (check in LearnWordController action Lecture and in AccountController action GetActiveHistory)
// await m_userService.CheckUserReleaseAsync(userId);
// get data
TodayWord word = TempData["FirstWord"] as TodayWord;
IList <TodayWord> todayWords = TempData["ListWordToDay"] as IList <TodayWord>;
ViewWordViewModel viewWordVM = new ViewWordViewModel();
// If resume class
if (word != null && todayWords != null)
{
// Loading to view model
LectureViewModel model = new LectureViewModel(word, todayWords);
// Passing into next request
TempData["ListWords"] = todayWords;
TempData["Word"] = word;
System.Diagnostics.Debug.WriteLine("Lecture {0}", (DateTime.Now - start));
// return view
return(View(model));
}
// if user calls by url
else
{
// get list word of today
_todayWords = await m_learnWordService.GetListWordsTodayAsync(userId, classId);
// Check if user has learn this word or not
isAllowView = await m_learnWordService.IsAllowToViewAsync(_todayWords, wordId);
isAllowLearn = await this.m_learnWordService.IsUserLearnWordBeforeAsync(userId, wordId);
isAllowResume = await this.m_classService.IsUserRegisteredClassAsync(userId, classId);
// continues
// Get word to start
startToDay = await m_learnWordService.GetTodayWordAsync(userId, classId, wordId);
// if word not found, this is anonymous access
if (startToDay == null)
{
Word w = await m_learnWordService.GetWordByIdAsync(wordId);
startToDay = EntityFactory.CreateTodayWord(userId, classId, w, true, false);
}
else
{
// Do nothing
}
}
// If anonymous type, load comment only
viewWordVM = await this.GetWordDetailsVM(userId, wordId);
// Loading to view model
LectureViewModel md = new LectureViewModel(startToDay, _todayWords, viewWordVM, isAllowView, isAllowLearn, isAllowResume);
// Passing into next request
TempData["ListWords"] = _todayWords;
TempData["Word"] = startToDay;
System.Diagnostics.Debug.WriteLine("Lecture {0}", (DateTime.Now - start));
// return view
return(View(md));
}
public JsonResult DestroyLecture([DataSourceRequest] DataSourceRequest request, LectureViewModel lecture)
{
var deletedLecture = this.lecturesServices.DestroyLecture(lecture.Id);
return Json(new[] { deletedLecture }, JsonRequestBehavior.AllowGet);
}
/// <summary>
/// Sukuria irasa duombazėje
/// </summary>
/// <returns>View modeli</returns>
/// [AdminAuthorize]
public ActionResult Create()
{
List <SelectListItem> types = new List <SelectListItem>();
types.Add(new SelectListItem()
{
Text = "Teorinė",
Value = "Teorinė"
});
types.Add(new SelectListItem()
{
Text = "Praktinė",
Value = "Praktinė"
});
types.Add(new SelectListItem()
{
Text = "-",
Value = "",
Selected = true
});
LectureViewModel model = new LectureViewModel()
{
Teachers = db.Teachers.ToList().Select(x => new SelectListItem()
{
Text = string.Format("{0} {1}", x.FirstName, x.LastName),
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
ClassRooms = db.ClassRooms.ToList().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
Groups = db.Groups.ToList().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
Subjects = db.Subjects.ToList().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
LectureTimes = db.LectureTimes.ToList().Select(x => new SelectListItem()
{
Text = string.Format("{0} - {1}", x.Start, x.End),
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
Weekdays = db.Weekdays.ToList().Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList().AddDefaultItem(),
TypesList = types
};
return(View(model));
}
