Beispiel #1
0
        public async Task <IActionResult> LevelUpdate(CourseLevelModel model)
        {
            if (!ModelState.IsValid)
            {
                return(Json(new DataSourceResult {
                    Errors = ModelState.SerializeErrors()
                }));
            }

            var level = await _courseLevelService.GetById(model.Id);

            level = model.ToEntity(level);
            await _courseLevelService.Update(level);

            return(new NullJsonResult());
        }
Beispiel #2
0
        public virtual async Task <CoursesModel> GetCoursesByCustomer(Customer customer, string storeId)
        {
            var model = new CoursesModel();

            model.CustomerId = customer.Id;
            var courses = await _courseService.GetByCustomer(customer, storeId);

            foreach (var item in courses)
            {
                var level = await _courseLevelService.GetById(item.LevelId);

                model.CourseList.Add(new CoursesModel.Course()
                {
                    Id               = item.Id,
                    Name             = item.Name,
                    SeName           = item.SeName,
                    ShortDescription = item.ShortDescription,
                    Level            = level?.Name,
                    Approved         = await IsApprovedCourse(item, customer),
                });
            }
            return(model);
        }
Beispiel #3
0
        public virtual async Task <CourseModel> PrepareCourseModel(Course course)
        {
            var model = course.ToModel(_workContext.WorkingLanguage);

            model.Level = (await _courseLevelService.GetById(course.LevelId))?.Name;

            var pictureSize = _mediaSettings.CourseThumbPictureSize;
            var picture     = await _pictureService.GetPictureById(course.PictureId);

            model.PictureUrl = await _pictureService.GetPictureUrl(picture, pictureSize);

            var subjects = await _courseSubjectService.GetByCourseId(course.Id);

            foreach (var item in subjects)
            {
                model.Subjects.Add(new CourseModel.Subject()
                {
                    Id           = item.Id,
                    Name         = item.Name,
                    DisplayOrder = item.DisplayOrder
                });
            }

            var lessonPictureSize = _mediaSettings.LessonThumbPictureSize;
            var lessons           = await _courseLessonService.GetByCourseId(course.Id);

            foreach (var item in lessons.Where(x => x.Published))
            {
                var lessonPicture = await _pictureService.GetPictureById(item.PictureId);

                var pictureUrl = await _pictureService.GetPictureUrl(lessonPicture, lessonPictureSize);

                var approved = await _courseActionService.CustomerLessonCompleted(_workContext.CurrentCustomer.Id, item.Id);

                model.Lessons.Add(new CourseModel.Lesson()
                {
                    Id               = item.Id,
                    SubjectId        = item.SubjectId,
                    Name             = item.Name,
                    ShortDescription = item.ShortDescription,
                    DisplayOrder     = item.DisplayOrder,
                    PictureUrl       = pictureUrl,
                    Approved         = approved
                });
            }
            model.Approved = !model.Lessons.Any(x => !x.Approved);
            return(model);
        }
        public async Task <CourseModel> Handle(GetCourse request, CancellationToken cancellationToken)
        {
            var model = request.Course.ToModel(request.Language);

            model.Level = (await _courseLevelService.GetById(request.Course.LevelId))?.Name;

            model.PictureUrl = await _pictureService.GetPictureUrl(request.Course.PictureId, _mediaSettings.CourseThumbPictureSize);

            var subjects = await _courseSubjectService.GetByCourseId(request.Course.Id);

            foreach (var item in subjects)
            {
                model.Subjects.Add(new CourseModel.Subject()
                {
                    Id           = item.Id,
                    Name         = item.Name,
                    DisplayOrder = item.DisplayOrder
                });
            }
            var lessons = await _courseLessonService.GetByCourseId(request.Course.Id);

            foreach (var item in lessons.Where(x => x.Published))
            {
                var pictureUrl = await _pictureService.GetPictureUrl(item.PictureId, _mediaSettings.LessonThumbPictureSize);

                var approved = await _courseActionService.CustomerLessonCompleted(request.Customer.Id, item.Id);

                model.Lessons.Add(new CourseModel.Lesson()
                {
                    Id               = item.Id,
                    SubjectId        = item.SubjectId,
                    Name             = item.Name,
                    ShortDescription = item.ShortDescription,
                    DisplayOrder     = item.DisplayOrder,
                    PictureUrl       = pictureUrl,
                    Approved         = approved
                });
            }
            model.Approved = !model.Lessons.Any(x => !x.Approved);
            return(model);
        }
Beispiel #5
0
        public async Task <CoursesModel> Handle(GetCourses request, CancellationToken cancellationToken)
        {
            var model = new CoursesModel();

            model.CustomerId = request.Customer.Id;
            var courses = await _courseService.GetByCustomer(request.Customer, request.Store.Id);

            foreach (var item in courses)
            {
                var level = await _courseLevelService.GetById(item.LevelId);

                model.CourseList.Add(new CoursesModel.Course()
                {
                    Id               = item.Id,
                    Name             = item.Name,
                    SeName           = item.SeName,
                    ShortDescription = item.ShortDescription,
                    Level            = level?.Name,
                    Approved         = await IsApprovedCourse(item, request.Customer),
                });
            }
            return(model);
        }
        public async Task <LessonModel> Handle(GetLesson request, CancellationToken cancellationToken)
        {
            var model = new LessonModel();

            var modelCourse = request.Course.ToModel(request.Language);

            model.Id                = request.Lesson.Id;
            model.CourseId          = modelCourse.Id;
            model.CourseDescription = modelCourse.Description;
            model.CourseName        = modelCourse.Name;
            model.CourseSeName      = modelCourse.SeName;
            model.MetaDescription   = modelCourse.MetaDescription;
            model.MetaKeywords      = model.MetaKeywords;
            model.MetaTitle         = model.MetaTitle;
            model.Name              = request.Lesson.Name;
            model.ShortDescription  = request.Lesson.ShortDescription;
            model.Description       = request.Lesson.Description;
            model.GenericAttributes = request.Lesson.GenericAttributes;
            model.CourseLevel       = (await _courseLevelService.GetById(request.Course.LevelId))?.Name;

            //prepare picture
            model.PictureUrl = await _pictureService.GetPictureUrl(request.Lesson.PictureId);

            model.Approved = await _courseActionService.CustomerLessonCompleted(request.Customer.Id, request.Lesson.Id);

            if (!string.IsNullOrEmpty(request.Lesson.AttachmentId))
            {
                model.DownloadFile = true;
            }

            if (!string.IsNullOrEmpty(request.Lesson.VideoFile))
            {
                model.VideoFile = true;
            }

            return(model);
        }