/// <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;
}
