/// <summary> /// Converts an <see cref="Activity"/> to the most specific subclass of <see cref="Exercise"/> and fills in the /// relevant details. /// </summary> /// <param name="activity">An instance of <see cref="Activity"/> containing the data returned by an API /// endpoint.</param> /// <returns>A subclass of <see cref="Exercise"/> containing the data converted from <paramref name="activity"/>. /// </returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="activity"/> is <c>null</c>.</exception> /// <exception cref="NotImplementedException">Thrown if <paramref name="activity"/> is an activity type that is /// not supported by the app at this time.</exception> public static Exercise ConvertActivityToExercise(Activity activity) { if (activity == null) { throw new ArgumentNullException("activity"); } if (activity.GetType() == typeof(ActivityEssay)) { ActivityEssay resultEssay = (ActivityEssay)activity; EssayExercise essay = new EssayExercise() { Title = resultEssay.Title, Description = resultEssay.Description, MinimumWords = resultEssay.MinimumWords, MaximumWords = resultEssay.MaximumWords, Contents = resultEssay.PreliminaryText, Featured = resultEssay.Featured, Uid = resultEssay.Id, Language = resultEssay.Language, Level = resultEssay.Level }; foreach (string tag in resultEssay.Tags) { essay.Tags.Add(tag); } return(essay); } // TODO: support dictionary searches throw new NotImplementedException("The returned exercise type is not supported yet"); }
/// <summary> /// Fill the fields with the appropriate data /// </summary> /// <param name="essex"><see cref="EssayExercise"/> param</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns> private async Task FillData(EssayExercise essex) { this.ex = essex; this.Title = this.ExTypeOfExercise + " " + this.ExLevel; this.ExTitleLabel.Text = this.ExTitle; this.ExDescriptionLabel.Text = string.Format(Properties.Resources.EssayExercise_MinMaxWords, this.ex.MinimumWords, this.ex.MaximumWords); this.ExContentEditor.Text = this.ExContent; // FIXME this.ProgressBar.BackgroundColor = this.ex.StatusColor; this.ExContentEditor.TextChanged += this.ExContentEditor_TextChanged; // Reanalize only if the exercise was already (partially) done if (this.ex.Contents.Length > 0) { try { await this.AnalyzeText(); } catch (OperationCanceledException ex) { Tools.Logger.Log(this.GetType().ToString(), ex); } } }
/// <summary> /// Called when an item in the exercise list is tapped. /// </summary> /// <param name="sender">The object sending the event.</param> /// <param name="e">The event parameters.</param> private async void ExerciseList_ItemTapped(object sender, ItemTappedEventArgs e) { if (await ConnectivityCheck.AskToEnableConnectivity(this)) { // TODO: support other exercise types try { ExerciseApi exerciseEndpoint = new ExerciseApi(App.OAuth2Account, ((EssayExercise)e.Item).Uid); EssayExercise essay = await Task.Run(async() => await exerciseEndpoint.CallEndpointAsExerciseModel()) as EssayExercise; if (essay == null) { await this.DisplayAlert(Properties.Resources.Error, Properties.Resources.Exercise_UnableToDisplay, Properties.Resources.ButtonOK); } else { await this.Navigation.PushAsync(new EssayExerciseView(essay)); } } catch (UnsuccessfulApiCallException ex) { Tools.Logger.Log("ExerciseList_ItemTapped", ex); await this.DisplayAlert(Properties.Resources.Error, Properties.Resources.Exercise_UnableToDisplay, Properties.Resources.ButtonOK); } } }
public LogicResult <EssayExercise> CreateEssayExercise(EssayExercise essayExercise) { try { if (essayExercise is null) { return(new LogicResult <EssayExercise> { IsSuccess = false, Errors = new List <string> { "Annotation can not be empty." } }); } _unitOfWork.EssayExerciseRepository.AddAsync(essayExercise); _unitOfWork.SaveChangesAsync(); return(new LogicResult <EssayExercise> { IsSuccess = true, Data = essayExercise }); } catch (Exception ex) { return(new LogicResult <EssayExercise> { IsSuccess = false, Errors = new List <string> { "Unable to save changes.", ex.Message } }); } }
public async Task <EssayExercise> AddAsync(EssayExercise entity) { await _unitOfWork.EssayExerciseRepository.AddAsync(entity); await _unitOfWork.SaveChangesAsync(); return(entity); }
public async Task <IActionResult> CreateTestContainsExercises([FromBody] TestContainerModel model) { var newTest = new Test(); try { if (!ModelState.IsValid) { ValidModel(); } //Add Test newTest = new Test() { Type = (ApplicationCore.Entities.TestAggregate.TestType)model.Type, Name = model.Name }; await _service.TestService.AddAsync(newTest); //add multiple exercise foreach (var multipleExercise in model.MultipleChoicesExerciseModels) { var newMultipleExercise = new MultipleChoicesExercise() { TestId = newTest.Id, RightResult = multipleExercise.RightResult, FalseResult1 = multipleExercise.FalseResult1, FalseResult2 = multipleExercise.FalseResult2, FalseResult3 = multipleExercise.FalseResult3, Title = multipleExercise.Title }; await _service.MultipleChoicesExerciseService.AddAsync(newMultipleExercise); } //add essay exercise foreach (var essayExercise in model.EssayExerciseModels) { var newEssayExerecise = new EssayExercise() { TestId = newTest.Id, Title = essayExercise.Title, Result = essayExercise.Result }; await _service.EssayExerciseService.AddAsync(newEssayExerecise); } } catch (Exception e) { return(ErrorResult(e.Message)); } return(SuccessResult(newTest, "Created Test successfully.")); }
/// <summary> /// Initializes a new instance of the <see cref="ExerciseAnalysis"/> class. /// </summary> /// <param name="ex">EssayExercise object</param> public ExerciseAnalysis(EssayExercise ex) { this.ex = ex; this.InitializeComponent(); this.analysisButton.Icon = "toolbar_analysis.png"; this.analysisButton.Clicked += this.AnalysisButton_Clicked; this.ExTitleLabel.Text = this.ExTitle; this.ExTitleSub.Text = this.ExSub; // FIXME: initialize these asynchronously! this._initSectionsRelatedToOfflineContent(); this._initSectionsRelatedToOnlineContent(); }
/// <summary> /// Initializes a new instance of the <see cref="EssayExerciseView"/> class. /// </summary> /// <param name="essay">EssayExercise object</param> public EssayExerciseView(EssayExercise essay) { if (essay == null) { throw new ArgumentNullException("ex"); } this.InitializeComponent(); this.FillData(essay); this.searchButton.Icon = "toolbar_search.png"; this.analysisButton.Icon = "toolbar_analysis.png"; this.analysisButton.Clicked += this.AnalysisButton_Clicked; this.searchButton.Clicked += this.SearchButton_Clicked; this.submitButton.Clicked += this.SubmitButton_Clicked; this.saveButton.Clicked += this.SaveButton_Clicked; this.loadButton.Clicked += this.LoadButton_Clicked; this._changeActivityIndicatorsStatus(false); }
/// <summary> /// Initializes a new instance of the <see cref="ExerciseAnalysis"/> class. /// </summary> /// <param name="ex">The <see cref="EssayExercise"/> containing the exercise to be analyzed.</param> public ExerciseAnalysis(EssayExercise ex) { ex.ExcludeFunctionalWords = false; this.currentLanguage = ex.Language; ExerciseAnalysisDataModel binding = new ExerciseAnalysisDataModel(ex); this.BindingContext = binding; this.InitializeComponent(); // TODO: move these settings to XAML. Use a syntax similar to this one (which, however, does not work): // BackgroundColor = "{Binding Converter={enums:LanguageLevelClassificationToColorConverter}, ConverterParameter={x:Static enums:LanguageLevelClassification.A1}}" // This is tracked in <https://github.com/TellOP/APP/issues/1> LanguageLevelClassificationToColorConverter langToColorConverter = new LanguageLevelClassificationToColorConverter(); this.A1Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.A1, typeof(Color), null, CultureInfo.CurrentUICulture); this.A2Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.A2, typeof(Color), null, CultureInfo.CurrentUICulture); this.B1Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.B1, typeof(Color), null, CultureInfo.CurrentUICulture); this.B2Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.B2, typeof(Color), null, CultureInfo.CurrentUICulture); this.C1Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.C1, typeof(Color), null, CultureInfo.CurrentUICulture); this.C2Frame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.C2, typeof(Color), null, CultureInfo.CurrentUICulture); this.UNKNOWNFrame.BackgroundColor = (Color)langToColorConverter.Convert(LanguageLevelClassification.Unknown, typeof(Color), null, CultureInfo.CurrentUICulture); }
public async Task <IActionResult> CreateEssayExercise([FromBody] EssayExerciseModel model) { var newEssayExercise = new EssayExercise(); try { if (!ModelState.IsValid) { ValidModel(); } newEssayExercise = new EssayExercise() { Result = model.Result, TestId = model.TestId, Title = model.Title }; await _service.EssayExerciseService.AddAsync(newEssayExercise); } catch (Exception e) { return(ErrorResult(e.Message)); } return(SuccessResult(newEssayExercise, "Created Essay Exercise successfully.")); }
/// <summary> /// Converts an <see cref="Activity"/> to the most specific subclass of <see cref="Exercise"/> and fills in the /// relevant details. /// </summary> /// <param name="activity">An instance of <see cref="Activity"/> containing the data returned by an API /// endpoint.</param> /// <returns>A subclass of <see cref="Exercise"/> containing the data converted from <paramref name="activity"/>. /// </returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="activity"/> is <c>null</c>.</exception> /// <exception cref="NotImplementedException">Thrown if <paramref name="activity"/> is an activity type that is /// not supported by the app at this time.</exception> public static Exercise ConvertActivityToExercise(Activity activity) { if (activity == null) { throw new ArgumentNullException("activity"); } if (activity.GetType() == typeof(ActivityEssay)) { ActivityEssay resultEssay = (ActivityEssay)activity; EssayExercise essay = new EssayExercise() { Title = resultEssay.Title, Description = resultEssay.Description, MinimumWords = resultEssay.MinimumWords, MaximumWords = resultEssay.MaximumWords, PreliminaryText = resultEssay.PreliminaryText, Contents = (resultEssay.UserActivity != null) ? ((UserActivityEssay)resultEssay.UserActivity).Text : string.Empty, Featured = resultEssay.Featured, Uid = resultEssay.Id, Language = resultEssay.Language, Level = resultEssay.Level }; foreach (string tag in resultEssay.Tags) { essay.Tags.Add(tag); } UserActivity uActivity = resultEssay.UserActivity; if (uActivity != null) { UserActivityEssay uActivityEss = uActivity as UserActivityEssay; if (uActivityEss != null) { if (!string.IsNullOrEmpty(uActivityEss.Text)) { essay.Contents = uActivityEss.Text; } } } return(essay); } if (activity.GetType() == typeof(ActivityDictionarySearch)) { ActivityDictionarySearch resultDictSearch = (ActivityDictionarySearch)activity; DictionarySearchExercise dictionarySearch = new DictionarySearchExercise() { Featured = resultDictSearch.Featured, Uid = resultDictSearch.Id, Language = resultDictSearch.Language, Level = resultDictSearch.Level }; UserActivity uActivity = resultDictSearch.UserActivity; if (uActivity != null) { UserActivityDictionarySearch uActivityDs = uActivity as UserActivityDictionarySearch; if (uActivityDs != null) { if (!string.IsNullOrEmpty(uActivityDs.Word)) { dictionarySearch.Word = uActivityDs.Word; } } } return(dictionarySearch); } throw new NotImplementedException("The returned exercise type is not supported yet"); }
/// <summary> /// Initializes a new instance of the <see cref="ExerciseAnalysisDataModel"/> class. /// </summary> /// <param name="exercise">The <see cref="EssayExercise"/> to analyze.</param> public ExerciseAnalysisDataModel(EssayExercise exercise) { this.Exercise = exercise; }