301 lines
12 KiB
C#
Executable File
301 lines
12 KiB
C#
Executable File
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Mvc.Rendering;
|
|
using Nop.Core;
|
|
using Nop.Services.Catalog;
|
|
using Nop.Services.Customers;
|
|
using Nop.Services.Localization;
|
|
using Nop.Web.Areas.Admin.Infrastructure.Mapper.Extensions;
|
|
using Nop.Web.Framework.Models.Extensions;
|
|
using Nop.Plugin.Misc.SimpleLMS.Areas.Admin.Models;
|
|
using Nop.Plugin.Misc.SimpleLMS.Domains;
|
|
using Nop.Plugin.Misc.SimpleLMS.Services;
|
|
|
|
namespace Nop.Plugin.Misc.SimpleLMS.Areas.Admin.Factories
|
|
{
|
|
public partial class AdminCourseModelFactory
|
|
{
|
|
|
|
private readonly CourseService _courseService;
|
|
private readonly ICustomerService _customerService;
|
|
private readonly ILocalizationService _localizationService;
|
|
private readonly IProductService _productService;
|
|
private readonly IWorkContext _workContext;
|
|
|
|
public AdminCourseModelFactory(
|
|
IProductService productService,
|
|
ILocalizationService localizationService,
|
|
IWorkContext workContext,
|
|
ICustomerService customerService,
|
|
CourseService courseService)
|
|
{
|
|
_productService = productService;
|
|
_workContext = workContext;
|
|
_localizationService = localizationService;
|
|
_customerService = customerService;
|
|
_courseService = courseService;
|
|
}
|
|
|
|
public async Task<CourseListModel> PrepareCourseListModelAsync(CourseSearchModel searchModel)
|
|
{
|
|
if (searchModel == null)
|
|
throw new ArgumentNullException(nameof(searchModel));
|
|
|
|
|
|
//get courses
|
|
var courses = await _courseService.SearchCoursesAsync(pageIndex: searchModel.Page - 1,
|
|
pageSize: searchModel.PageSize,
|
|
keyword: searchModel.SearchCourseName,
|
|
instructorGUID: searchModel.InstructorGUID);
|
|
|
|
//prepare list model
|
|
var model = await new CourseListModel().PrepareToGridAsync(searchModel, courses, () =>
|
|
{
|
|
return courses.SelectAwait(async course =>
|
|
{
|
|
//fill in model values from the entity
|
|
var courseModel = course.ToModel<CourseModel>();
|
|
|
|
|
|
//fill in additional values (not existing in the entity)
|
|
courseModel.Category = string.Empty;
|
|
|
|
var product = await _productService.GetProductByIdAsync(course.ProductId);
|
|
courseModel.ParentProductName = product.Name;
|
|
courseModel.Price = product.Price;
|
|
courseModel.Status = product.Published ? "Published" : "Unpublished";
|
|
|
|
var customer = await _customerService.GetCustomerByIdAsync(course.InstructorId);
|
|
|
|
courseModel.Instructor = customer.Username;
|
|
|
|
var courseStat = await _courseService.GetCourseStatsByCourseIdAsync(course.Id);
|
|
|
|
courseModel.LessonsTotal = courseStat.Lessons;
|
|
courseModel.SectionsTotal = courseStat.Sections;
|
|
courseModel.EnrolledStudents = courseStat.EnrolledStudents;
|
|
|
|
|
|
|
|
return courseModel;
|
|
});
|
|
});
|
|
|
|
return model;
|
|
}
|
|
|
|
public async Task<CourseModel> PrepareCourseModelAsync(CourseModel courseModel, Course course)
|
|
{
|
|
if (courseModel == null)
|
|
throw new ArgumentNullException(nameof(courseModel));
|
|
|
|
if (course != null)
|
|
{
|
|
//fill in model values from the entity
|
|
if (course != null)
|
|
{
|
|
courseModel = course.ToModel<CourseModel>();
|
|
}
|
|
|
|
var parentProduct = await _productService.GetProductByIdAsync(course.ProductId);
|
|
|
|
if (parentProduct != null)
|
|
{
|
|
courseModel.ParentProductName = parentProduct.Name;
|
|
courseModel.ProductId = parentProduct.Id;
|
|
}
|
|
|
|
courseModel.Sections = (await _courseService.GetSectionsByCourseIdAsync(courseModel.Id)).OrderBy(p => p.DisplayOrder).Select(p =>
|
|
new SectionModel
|
|
{
|
|
CourseName = courseModel.Name,
|
|
DisplayOrder = p.DisplayOrder,
|
|
Id = p.Id,
|
|
IsFree = p.IsFree,
|
|
Title = p.Title,
|
|
CourseId = course.Id,
|
|
Lessons = _courseService.GetLessonsBySectionIdAsync(p.Id)
|
|
.GetAwaiter().GetResult().Select(l => l.ToModel<LessonModel>()).ToList()
|
|
}).ToList();
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < courseModel.Sections.Count; i++)
|
|
{
|
|
var sectionLessons = await _courseService.GetSectionLessonsBySectionIdAsync(courseModel.Sections[i].Id);
|
|
|
|
for (int j = 0; j < courseModel.Sections[i].Lessons.Count; j++)
|
|
{
|
|
courseModel.Sections[i].Lessons[j].SectionId = courseModel.Sections[i].Id;
|
|
courseModel.Sections[i].Lessons[j].CourseId = courseModel.Id;
|
|
courseModel.Sections[i].Lessons[j].DisplayOrder
|
|
= sectionLessons.Where(p => p.LessonId == courseModel.Sections[i].Lessons[j].Id).SingleOrDefault().DisplayOrder;
|
|
}
|
|
|
|
courseModel.Sections[i].Lessons = courseModel.Sections[i].Lessons.OrderBy(p => p.DisplayOrder).ToList();
|
|
}
|
|
|
|
}
|
|
|
|
courseModel.AvailableProducts = await _courseService.GetProductsByCurrentUserAsync();
|
|
courseModel.AvailableProducts.Insert(0, new SelectListItem { Text = await _localizationService.GetResourceAsync("SimpleLMS.Select"), Value = "" });
|
|
|
|
return courseModel;
|
|
}
|
|
|
|
protected IList<LessonModel> GetLessonsBySectionIdForAdmin(int id)
|
|
{
|
|
var task = _courseService.GetLessonsBySectionIdAsync(id);
|
|
task.RunSynchronously();
|
|
var result = task.Result.Select(p => p.ToModel<LessonModel>());
|
|
return result.ToList();
|
|
}
|
|
|
|
|
|
public async Task<CourseSearchModel> PrepareCourseSearchModelAsync(CourseSearchModel searchModel)
|
|
{
|
|
if (searchModel == null)
|
|
throw new ArgumentNullException(nameof(searchModel));
|
|
|
|
var customer = await _workContext.GetCurrentCustomerAsync();
|
|
searchModel.InstructorGUID = customer.CustomerGuid.ToString();
|
|
|
|
searchModel.SetGridPageSize();
|
|
|
|
return searchModel;
|
|
}
|
|
|
|
public async Task<SectionModel> PrepareSectionModelAsync(SectionModel sectionModel, Course course, Section section, bool loadLessons = false)
|
|
{
|
|
if (sectionModel == null)
|
|
throw new ArgumentNullException(nameof(sectionModel));
|
|
|
|
if (course == null)
|
|
throw new ArgumentNullException(nameof(course));
|
|
|
|
if (section != null)
|
|
{
|
|
sectionModel = section.ToModel<SectionModel>();
|
|
sectionModel.CourseId = section.CourseId;
|
|
|
|
//if (loadLessons)
|
|
//{
|
|
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
sectionModel.CourseId = course.Id;
|
|
|
|
//load display order
|
|
var sections = await _courseService.GetSectionsByCourseIdAsync(course.Id);
|
|
if (sections != null && sections.Count > 0)
|
|
{
|
|
sectionModel.DisplayOrder = sections.Max(p => p.DisplayOrder) + 1;
|
|
}
|
|
if (sectionModel.DisplayOrder == 0)
|
|
{
|
|
sectionModel.DisplayOrder = 1;
|
|
}
|
|
}
|
|
|
|
return sectionModel;
|
|
}
|
|
|
|
public async Task<LessonModel> PrepareLessonModelAsync(LessonModel lessonModel, Section section, Course course, Lesson lesson)
|
|
{
|
|
if (lessonModel == null)
|
|
throw new ArgumentNullException(nameof(lessonModel));
|
|
|
|
if (course == null)
|
|
throw new ArgumentNullException(nameof(course));
|
|
|
|
if (section == null)
|
|
throw new ArgumentNullException(nameof(section));
|
|
|
|
if (lesson != null)
|
|
{
|
|
lessonModel = lesson.ToModel<LessonModel>();
|
|
|
|
if (lessonModel.LessonType == LessonType.Video)
|
|
{
|
|
var video = await _courseService.GetVideoByLessonIdAsync(lessonModel.Id);
|
|
lessonModel.VideoIdFromProvider = video.VideoIdFromProvider;
|
|
lessonModel.VideoType = video.VideoType;
|
|
lessonModel.Duration = video.Duration;
|
|
}
|
|
}
|
|
|
|
var sls = await _courseService.GetSectionLessonsBySectionIdAsync(section.Id);
|
|
if (sls != null && sls.Count > 0)
|
|
{
|
|
if (lesson != null)
|
|
{
|
|
lessonModel.DisplayOrder = sls.Where(p => p.LessonId == lesson.Id).SingleOrDefault().DisplayOrder;
|
|
}
|
|
else
|
|
{
|
|
lessonModel.DisplayOrder = sls.Max(p => p.DisplayOrder) + 1;
|
|
if (lessonModel.DisplayOrder == 0)
|
|
{
|
|
lessonModel.DisplayOrder = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lessonModel.DisplayOrder == 0)
|
|
{
|
|
lessonModel.DisplayOrder = 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
lessonModel.SectionId = section.Id;
|
|
lessonModel.CourseId = course.Id;
|
|
|
|
|
|
lessonModel.AvailableLessonTypes.Add(new SelectListItem { Value = ((int)LessonType.Video).ToString(), Text = LessonType.Video.ToString() });
|
|
lessonModel.AvailableLessonTypes.Add(new SelectListItem { Value = ((int)LessonType.Text).ToString(), Text = LessonType.Text.ToString() });
|
|
//lessonModel.AvailableLessonTypes.Add(new SelectListItem { Value = ((int)LessonType.Document).ToString(), Text = LessonType.Document.ToString() });
|
|
|
|
|
|
lessonModel.AvailableVideoTypes.Add(new SelectListItem { Value = ((int)VideoType.Youtube).ToString(), Text = VideoType.Youtube.ToString() });
|
|
lessonModel.AvailableVideoTypes.Add(new SelectListItem { Value = ((int)VideoType.Vimeo).ToString(), Text = VideoType.Vimeo.ToString() });
|
|
//lessonModel.AvailableVideoTypes.Add(new SelectListItem { Value = ((int)VideoType.VdoCipher).ToString(), Text = VideoType.VdoCipher.ToString() });
|
|
//lessonModel.AvailableVideoTypes.Add(new SelectListItem { Value = ((int)VideoType.Hosted).ToString(), Text = VideoType.Hosted.ToString() });
|
|
//lessonModel.AvailableVideoTypes.Add(new SelectListItem { Value = ((int)VideoType.AWS).ToString(), Text = VideoType.AWS.ToString() });
|
|
|
|
lessonModel.AvailableAttachmentTypes.Add(new SelectListItem { Value = ((int)AttachmentType.Pdf).ToString(), Text = AttachmentType.Pdf.ToString() });
|
|
//lessonModel.AvailableAttachmentTypes.Add(new SelectListItem { Value = ((int)AttachmentType.Others).ToString(), Text = AttachmentType.Others.ToString() });
|
|
|
|
return lessonModel;
|
|
}
|
|
|
|
public async Task<SortableEntity> PrepareSortableEntityModelAsync(SortableEntity sortableEntity, IEnumerable<IDisplayOrderRecord> models, SortRecordType sortRecordType, int parentId)
|
|
{
|
|
if (sortableEntity == null)
|
|
throw new ArgumentNullException(nameof(sortableEntity));
|
|
|
|
sortableEntity.ParentId = parentId;
|
|
sortableEntity.SortRecords = await (from p in models
|
|
orderby p.DisplayOrder
|
|
select new SortRecord
|
|
{
|
|
Id = p.Id,
|
|
ExistingSortOrder = p.DisplayOrder,
|
|
NewSortOrder = p.DisplayOrder,
|
|
DisplayText = p.DisplayText
|
|
}).ToListAsync();
|
|
|
|
sortableEntity.SortRecordType = sortRecordType;
|
|
|
|
return sortableEntity;
|
|
}
|
|
}
|
|
|
|
}
|