public ActionResult Index(string option)
        {
            if (option != null)
            {
                switch (option.ToLower())
                {
                case "wordform":
                {
                    _viewModel = new WordFormViewModel();
                    CreateLayoutView("Từ vựng");
                    break;
                }

                case "listening":
                {
                    _viewModel = new ListeningViewModel();
                    CreateLayoutView("Tập nghe");
                    break;
                }

                case "reading":
                {
                    _viewModel = new ReadingViewModel();
                    CreateLayoutView("Tập đọc");
                    break;
                }

                case "grammar":
                {
                    _viewModel = new GrammarViewModel();
                    CreateLayoutView("Ngữ pháp");
                    break;
                }

                case "multiplechoice":
                {
                    _viewModel = new MultipleChoiceViewModel();
                    CreateLayoutView("Trắc nghiệm");
                    break;
                }

                default:
                {
                    _viewModel = new LearningViewModel();
                    CreateLayoutView("Tự học");
                    break;
                }
                }
            }
            else
            {
                _viewModel = new LearningViewModel();
                CreateLayoutView("Tự học");
                ViewBag.page = "Index";
                return(View(_viewModel));
            }

            return(View("Index", "~/Views/Layout/_LearningLayout.cshtml", _viewModel));
        }
Example #2
0
        public async Task <ResponseMessage> LearnedArticle(LearningViewModel model)
        {
            try
            {
                var userId         = User.Identity.GetUserId();
                var userPackageBox = await db.UserPackageBoxes.FirstOrDefaultAsync(x =>
                                                                                   x.BoxId == model.BoxId && x.UserPackage.UserId == userId);

                //var userPackageBox = await db.UserPackageBoxes.FindAsync(model.UserBoxId);

                if (userPackageBox == null)
                {
                    LogThis.BaseLog(Request, LogLevel.Warn, Actions.LearnedArticle,
                                    new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, model.BoxId },
                        { LogProperties.IdType, typeof(Box) },
                        { LogProperties.Message, ErrorMessages.UserPackageBoxNotFound },
                        { LogProperties.AdditionalData, model.Order }
                    });
                    return(new ResponseMessage(Tools.ResponseMessage.ResponseCode.NotFound, ErrorMessages.UserPackageBoxNotFound));
                }

                if (userPackageBox.State == BoxState.NotOwned)
                {
                    LogThis.BaseLog(Request, LogLevel.Warn, Actions.LearnedArticle,
                                    new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, userPackageBox.Id },
                        { LogProperties.IdType, typeof(UserPackageBox) },
                        { LogProperties.Message, ErrorMessages.UserNotOwnedBox },
                        { LogProperties.AdditionalData, model.Order },
                        { LogProperties.State, BoxState.NotOwned }
                    });
                    return(new ResponseMessage(Tools.ResponseMessage.ResponseCode.UserStatusFaild, ErrorMessages.UserNotOwnedBox));
                }

                var articles = userPackageBox.Box.Articles.ToList();
                var article  = articles.FirstOrDefault(x => x.Order == model.Order);
                if (article == null)
                {
                    LogThis.BaseLog(Request, LogLevel.Warn, Actions.LearnedArticle,
                                    new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, userPackageBox.Id },
                        { LogProperties.IdType, typeof(UserPackageBox) },
                        { LogProperties.Message, ErrorMessages.ArticleNotFound },
                        { LogProperties.AdditionalData, model.Order }
                    });
                    return(new ResponseMessage(Tools.ResponseMessage.ResponseCode.NotFound, ErrorMessages.ArticleNotFound));
                }
                var articleIndex = articles.IndexOf(article) + 1;
                if (userPackageBox.State != BoxState.Learning || articleIndex <= userPackageBox.StateValue)
                {
                    LogThis.BaseLog(Request, LogLevel.Info, Actions.LearnedArticle,
                                    new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, userPackageBox.Id },
                        { LogProperties.IdType, typeof(UserPackageBox) },
                        { LogProperties.Message, ErrorMessages.ArticleLearnRepeated },
                        { LogProperties.AdditionalData, model.Order },
                        { LogProperties.State, userPackageBox.State }
                    });
                    return(Tools.ResponseMessage.OkWithMessage(ErrorMessages.ArticleLearnRepeated)); //todo: review this message is correct?
                }
                db.Users.Find(userId).AddScore(ScoreReason.ArticleRead);
                LogThis.BaseLog(Request, LogLevel.Info, Actions.ChangeBoxStateValue,
                                new Dictionary <LogProperties, object>
                {
                    { LogProperties.Id, userPackageBox.Id },
                    { LogProperties.IdType, typeof(UserPackageBox) },
                    { LogProperties.Message, ErrorMessages.ArticleLearned },
                    { LogProperties.AdditionalData, model.Order },
                    { LogProperties.State, userPackageBox.State },
                    { LogProperties.From, userPackageBox.StateValue },
                    { LogProperties.To, articleIndex }
                });
                userPackageBox.StateValue++;

                if (userPackageBox.Box.Articles.Count == userPackageBox.StateValue)
                {
                    LogThis.BaseLog(Request, LogLevel.Info, Actions.ChangeBoxState, new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, userPackageBox.Id },
                        { LogProperties.IdType, typeof(UserPackageBox) },
                        { LogProperties.Message, ErrorMessages.UserBoxStateChanged },
                        { LogProperties.AdditionalData, model.Order },
                        { LogProperties.From, BoxState.Learning },
                        { LogProperties.To, BoxState.Examing }
                    });
                    userPackageBox.State = BoxState.Examing;
                    LogThis.BaseLog(Request, LogLevel.Info, Actions.ChangeBoxStateValue,
                                    new Dictionary <LogProperties, object>
                    {
                        { LogProperties.Id, userPackageBox.Id },
                        { LogProperties.IdType, typeof(UserPackageBox) },
                        { LogProperties.Message, ErrorMessages.UserBoxStateValueChange },
                        { LogProperties.AdditionalData, model.Order },
                        { LogProperties.State, userPackageBox.State },
                        { LogProperties.From, userPackageBox.StateValue },
                        { LogProperties.To, 0 }
                    });
                    userPackageBox.StateValue = 0;
                    db.SaveChanges();
                    return(Tools.ResponseMessage.OkWithMessage(ErrorMessages.UserBoxStateChanged));
                }

                db.SaveChanges();
                return(Tools.ResponseMessage.OkWithMessage(ErrorMessages.ArticleLearned));
            }
            catch (Exception e)
            {
                LogThis.BaseLog(Request, LogLevel.Error, Actions.UserPackageBoxQuestionsRequested, new Dictionary <LogProperties, object>
                {
                    { LogProperties.Error, e }
                });
                return(Tools.ResponseMessage.InternalError);
            }
        }
Example #3
0
 public LearningPage()
 {
     this.InitializeComponent();
     ViewModel   = new LearningViewModel(CoursesPivot);
     DataContext = ViewModel;
 }
 public LearningPage()
 {
     InitializeComponent();
     BindingContext = viewModel = new LearningViewModel();
 }
        private void AlgorithmClickExecute(object[] parameters)
        {
            Window currentWindow = parameters[0] as Window;
            string algorithmName = parameters[1] as string;
            IModalDialogViewModel dialogViewModel = null;

            currentWindow.Visibility = Visibility.Hidden;

            if ( this.WindowTitle.StartsWith("Tryb nauki") )
            {
                dialogViewModel = new LearningViewModel(algorithmName);
            }
            else if ( this.WindowTitle.StartsWith("Tryb egzaminu") )
            {
                dialogViewModel = new ExamViewModel(algorithmName);
            }
            else if ( this.WindowTitle.StartsWith("Tryb grafu niestandardowego") )
            {
                dialogViewModel = new CustomGraphViewModel(algorithmName, _graph);
            }

            if (dialogViewModel.DialogResult == true)
                _dialogService.ShowDialog(this, dialogViewModel);

            currentWindow.Close();
        }