private TestResultViewModel CreateTestResultViewModel(int id, int resultId, TestViewModel viewModel, bool isTimeOut = false)
{
DateTime finished = DateTime.UtcNow;
var usersAnswers = viewModel?.UsersAnswers;
var test = _TestService.GetTest(id);
// check answers
int rightAnswers = ValidateTestsResults.Check(usersAnswers, test);
// get user
var user = _userManager.GetUserAsync(HttpContext.User).Result;
// create testResult in database
var testResult = _TestResultService.GetTestResult(resultId);
if (testResult != null)
{
if (testResult.Finished == DateTime.Parse("05/15/2001") && testResult.Finished - testResult.Started <= TimeSpan.FromMinutes(test.Time))
{
testResult.Finished = finished;
testResult.RightAnswers = rightAnswers;
_TestResultService.Update(testResult);
}
// create viewModel
var resultViewModel = new TestResultViewModel()
{
RightAnswers = testResult.RightAnswers,
Finished = testResult.Finished,
Test = test,
User = user,
Answers = test.Questions.Count(),
IsTimeout = isTimeOut,
Started = testResult.Started
};
return(resultViewModel);
}
return(null);
}
private void TestResultView_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
{
TestResultViewModel model = DataContext as TestResultViewModel;
if (model != null)
{
_currModel = model;
if (model.Status == TestStatus.Passed)
{
ButtonSaveAsExpected.Visibility = Visibility.Collapsed;
}
else
{
ButtonSaveAsExpected.Visibility = Visibility.Visible;
switch (model.Status)
{
case TestStatus.Failed:
case TestStatus.FailedButSourceWasChanged:
ButtonSaveAsExpected.Content = "Accept new version";
break;
case TestStatus.Passed:
ButtonSaveAsExpected.Content = "Set as expected";
break;
}
}
ButtonCompareCard.Visibility = model.DidCardPayloadChange ? Visibility.Visible : Visibility.Collapsed;
ButtonCompareHostConfig.Visibility = model.DidHostConfigChange ? Visibility.Visible : Visibility.Collapsed;
}
}
public async Task <IActionResult> AddTestResult([FromBody] TestResultViewModel formdata)
{
try
{
if (formdata == null)
{
return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
}
else if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object sent from client."));
}
var testResult = _mapper.Map <TestResultDto>(formdata);
var testResultData = await _testResultService.AddTestResult(testResult);
if (testResultData == -1)
{
return(NotFound());
}
testResult.Id = testResultData;
var addedTestresult = _mapper.Map <TestResultViewModel>(testResult);
return(CreatedAtAction(nameof(GetTestResult), new { id = testResultData }, addedTestresult));
}
catch (Exception e)
{
return(StatusCode(500, $"Something went wrong inside add testresult action: {e.Message}"));
}
}
public async Task <IActionResult> TestResult(int buildId, int testResultId)
{
if (!Project.ExplicitSubmissionRequired)
{
return(NotFound());
}
var testResult = await BuildService.GetTestResultAsync
(
ClassroomName,
ProjectName,
testResultId
);
if (testResult == null || testResult.BuildId != buildId)
{
return(NotFound());
}
if (testResult.Build.Commit.UserId != User.Id && ClassroomRole < ClassroomRole.Admin)
{
return(Forbid());
}
var viewModel = new TestResultViewModel(testResult);
return(View(viewModel));
}
async public Task TestCard(FileViewModel hostConfigFile, FileViewModel cardFile)
{
var renderResult = await UWPTestLibrary.RenderTestHelpers.RenderCard(cardFile, hostConfigFile);
if (renderResult.Tree != null)
{
UWPTestLibrary.ImageWaiter imageWaiter = new ImageWaiter(renderResult.Tree);
StackPanel stackPanel = new StackPanel();
stackPanel.Children.Add(renderResult.Tree);
Border border = new Border();
border.Width = renderResult.CardWidth;
border.Child = stackPanel;
ScrollViewer scrollViewer = new ScrollViewer();
scrollViewer.Content = border;
(Window.Current.Content as Frame).Content = scrollViewer;
await imageWaiter.WaitOnAllImagesAsync();
}
StorageFile imageResultFile = null;
StorageFile jsonResultFile = null;
if (renderResult.Error == null)
{
imageResultFile = await _tempResultsFolder.CreateFileAsync("Result.png", CreationCollisionOption.GenerateUniqueName);
jsonResultFile = await _tempResultsFolder.CreateFileAsync("Result.json", CreationCollisionOption.GenerateUniqueName);
await UWPTestLibrary.RenderTestHelpers.ResultsToFile(imageResultFile, jsonResultFile, renderResult.RoundTrippedJSON, renderResult.Tree);
}
await Task.Delay(10);
TestResultViewModel result = await TestResultViewModel.CreateAsync(
cardFile : cardFile,
hostConfigFile : hostConfigFile,
renderedTestResult : renderResult,
actualImageFile : imageResultFile,
actualJsonFile : jsonResultFile,
expectedFolder : _expectedFolder,
sourceHostConfigsFolder : _sourceHostConfigsFolder,
sourceCardsFolder : _sourceCardsFolder);
// For the unit test, only check that the renderer succeeded (or not) as expected, and that the round tripped json is unchanged.
// Image comparison for the time being is not quite stable enough to run as a unit test.
// Allow new cards to pass as long as they don't have an error
bool testPass =
result.Status.MatchedViaError ||
result.Status.JsonRoundTripMatched ||
(result.Status.NewCard && (result.Status.Error == null));
if (!testPass)
{
throw new Exception(result.Status.ToString() + ": " + result.HostConfigName + "\\" + result.CardName);
}
}
public async Task <IActionResult> UpdateTestResult(int id, [FromBody] TestResultViewModel formdata)
{
try
{
if (formdata == null)
{
return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
}
if (id <= 0)
{
return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
}
if (id != formdata.Id)
{
return(BadRequest(new JsonResult(new { message = "please ensure you are updating right object" })));
}
if (!ModelState.IsValid)
{
return(BadRequest("Invalid model object sent from client."));
}
var testResult = _mapper.Map <TestResultDto>(formdata);
var testResultId = await _testResultService.UpdateTestResult(testResult);
if (testResultId == -1)
{
return(NotFound());
}
testResult.Id = testResultId;
return(CreatedAtAction(nameof(GetTestResult), new { id = testResultId }, _mapper.Map <TestResultViewModel>(testResult)));
}
catch (Exception e)
{
return(StatusCode(500, new JsonResult(new { message = $"Something went wrong inside update TestResult action: {e.Message}" })));
}
}
public LastXBuildsStat GetLastXBuildDataByTestResult(TestResultViewModel sr, bool forModal)
{
if (forModal)
{
string id = $"{sr.TestResult.TestRunMetaData.FlytApplicationType}-{sr.TestResult.TestRunMetaData.BuildNumber}";
if (existingModals.Contains(id))
{
return(null);
}
existingModals.Add(id);
}
switch (sr.TestResult.TestRunMetaData.FlytApplicationType)
{
case FlytApplication.BV: return(GetLastXBuildStat(TestStats.BVLastXBuildsDict, sr.TestResult.TestRunMetaData.BuildNumber));
case FlytApplication.BVV: return(GetLastXBuildStat(TestStats.BVVLastXBuildsDict, sr.TestResult.TestRunMetaData.BuildNumber));
case FlytApplication.CAR: return(GetLastXBuildStat(TestStats.CARLastXBuildsDict, sr.TestResult.TestRunMetaData.BuildNumber));
case FlytApplication.PPT: return(GetLastXBuildStat(TestStats.PPTLastXBuildsDict, sr.TestResult.TestRunMetaData.BuildNumber));
case FlytApplication.SCC: return(GetLastXBuildStat(TestStats.SCCLastXBuildsDict, sr.TestResult.TestRunMetaData.BuildNumber));
default: throw new Exception($"unknown application type: {sr.TestResult.TestRunMetaData.FlytApplicationType}");
}
}
public ViewResult TestResult()
{
Database.SetInitializer(new DropCreateDatabaseIfModelChanges <EFTestDbContext>());
ViewBag.Error = "";
if (Request["answer" + 1] != null)
{
int CurTest = 0;
int i = 2;
var result = Request["answer" + 1];
int LastLength = 0;
int NewLength = 0;
do
{
LastLength = result.Length;
if (i == 2)
{
result += ",";
}
result += Request.Unvalidated["answer" + (i)];
NewLength = result.Length;
if (NewLength > LastLength)
{
result += ",";
}
i++;
}while (NewLength > LastLength);
result = result.Remove(result.Length - 1, 1);
string[] answer = result.Split(',');
int NumOfQuestions = answer.Length;
i = 0;
foreach (string a in answer)
{
string[] b = a.Split(':');
if (b[1] == "yes")
{
i++;
//SelAnswers.Add(answers.Answers.First(x => x.Id == Convert.ToInt32(b[2])));
}
CurTest = int.Parse(b[4]);
}
TestResultViewModel model = new TestResultViewModel();
TestPreview MyTest = test.Tests.First(x => x.Id == CurTest);
model.Answers = answers.Answers;
model.Questions = question.Question;
model.ResultStrings = answer;
ViewBag.Result = result + "NumOfQ=" + NumOfQuestions + "NumOfCorr=" + i + "TestID=" + CurTest;
ViewBag.Questions = NumOfQuestions;
ViewBag.Correct = i;
ViewBag.TestTheme = MyTest.Theme;
ViewBag.TestID = CurTest;
return(View(model));
}
else
{
ViewBag.Error = "Error";
return(View(new TestResultViewModel()));
}
}
public void IsDetailedSectionVisibile_Is_Colapsed_By_Default_Test()
{
TestResult result = new TestResult();
result.Passed = true;
TestResultViewModel viewModel = new TestResultViewModel(result);
Confirm.Equal(Visibility.Collapsed, viewModel.IsDetailedSectionVisibile);
}
public void ErrorVisibility_Will_Return_Visibility_Colapsed_If_Test_Passed_Test()
{
TestResult result = new TestResult();
result.Passed = true;
TestResultViewModel viewModel = new TestResultViewModel(result);
Confirm.Equal(Visibility.Collapsed, viewModel.ErrorVisibility);
}
private async void ButtonCompareHostConfig_Click(object sender, RoutedEventArgs e)
{
TestResultViewModel model = DataContext as TestResultViewModel;
if (model != null)
{
ShowComparison(await model.GetOldHostConfigContentsAsync(), model.HostConfigFile.Contents);
}
}
public void DurationVisibility_Will_Return_Visibility_Colapsed_If_Test_Failed_Test()
{
TestResult result = new TestResult();
result.Passed = false;
TestResultViewModel viewModel = new TestResultViewModel(result);
Confirm.Equal(Visibility.Collapsed, viewModel.DurationVisibility);
}
public IActionResult Index()
{
TestResultViewModel result = new TestResultViewModel()
{
FoodParcels = this.TestResultService.GetFoodParcels()
};
return(View(result));
}
private async void ButtonRoundTrippedJson_Click(object sender, RoutedEventArgs e)
{
TestResultViewModel model = DataContext as TestResultViewModel;
if (model != null)
{
ShowComparison(model.ExpectedRoundtrippedJsonModel.Contents, model.RoundtrippedJsonModel.Contents);
}
}
public void ErrorVisibility_Will_Return_Visibility_Visible_If_Test_Failed_Test()
{
TestResult result = new TestResult();
result.Passed = false;
TestResultViewModel viewModel = new TestResultViewModel(result);
Confirm.Equal(Visibility.Visible, viewModel.ErrorVisibility);
}
public void DurationVisibility_Will_Return_Visibility_Visible_If_Test_Passed_Test()
{
TestResult result = new TestResult();
result.Passed = true;
TestResultViewModel viewModel = new TestResultViewModel(result);
Confirm.Equal(Visibility.Visible, viewModel.DurationVisibility);
}
public void SectionVisibilityCommand_Will_Fire_And_Toggle_Detail_Section_To_Visible_Test()
{
TestResult result = new TestResult();
result.Passed = true;
TestResultViewModel viewModel = new TestResultViewModel(result);
viewModel.SectionVisibilityCommand.Execute(null);
Confirm.Equal(Visibility.Visible, viewModel.IsDetailedSectionVisibile);
}
public TestResultDetailsView()
{
InitializeComponent();
if (!DesignerProperties.GetIsInDesignMode(this))
{
TestResultViewModel testResultViewModel = (App.Current as App).Container.GetService <TestResultViewModel>();
testResultViewModel.OnLoadTestResults();
this.DataContext = testResultViewModel;
}
}
private void TestResultView_DataContextChanged(FrameworkElement sender, DataContextChangedEventArgs args)
{
TestResultViewModel model = DataContext as TestResultViewModel;
if (model != null)
{
_currModel = model;
ButtonUpdateImage.Visibility = Visibility.Collapsed;
ButtonUpdateJson.Visibility = Visibility.Collapsed;
ButtonUpdateOriginals.Visibility = Visibility.Collapsed;
ButtonUpdateAll.Visibility = Visibility.Collapsed;
if (model.Status.NewCard)
{
// For a new card, only let them update "all"
ButtonUpdateAll.Visibility = Visibility.Visible;
}
else if (model.Status.MatchedViaError)
{
// If they matched via error nothing to update except possibly the original
ButtonUpdateOriginals.Visibility = model.Status.OriginalMatched ? Visibility.Collapsed : Visibility.Visible;
}
else
{
// Provide the appropriate buttons to update as needed
uint buttonsShown = 0;
if (!model.Status.ImageMatched)
{
ButtonUpdateImage.Visibility = Visibility.Visible;
buttonsShown++;
}
if (!model.Status.JsonRoundTripMatched)
{
ButtonUpdateJson.Visibility = Visibility.Visible;
buttonsShown++;
}
if (!model.Status.OriginalMatched)
{
ButtonUpdateOriginals.Visibility = Visibility.Visible;
buttonsShown++;
}
// Only show the update all button if we have more than one thing to update
if (buttonsShown > 1)
{
ButtonUpdateAll.Visibility = Visibility.Visible;
}
}
ButtonCompareCard.Visibility = model.DidCardPayloadChange ? Visibility.Visible : Visibility.Collapsed;
ButtonCompareHostConfig.Visibility = model.DidHostConfigChange ? Visibility.Visible : Visibility.Collapsed;
ButtonRoundTrippedJson.Visibility = model.DidRoundtrippedJsonChange ? Visibility.Visible : Visibility.Collapsed;
}
}
public ActionResult ShowResult(int resultId)
{
TestResultViewModel model = new TestResultViewModel
{
Resul = ResultService.GetResultEntityById(resultId).ToMvcResult(),
Test = TestService.GetTestEntity(ResultService.GetResultEntityById(resultId)
.ToMvcResult().TestId).ToMvcTest()
};
return(View(model));
}
public void Create(TestResultViewModel model)
{
var item = new TestResult()
{
Result = model.Result, StudentEmail = model.StudentEmail, TaskId = model.TaskId
};
_DB.TestResults.Add(item);
_DB.SaveChanges();
model.Id = item.Id;
}
public ActionResult TestResult(int testId)
{
var questions = DataAcess.TestManagment.GetQuestionList(testId);
TestResultViewModel testResult = new TestResultViewModel
{
TestId = testId,
TestName = DataAcess.TestManagment.GetTest(testId).TestName,
TotalQuestions = questions.Count
};
foreach (var questionid in questions)
{
var questionResult = new QuestionResultViewModel {
QuestionId = questionid
};
var question = DataAcess.TestManagment.GetQuestion(testId, questionid);
int userRightAnswered = 0;
foreach (var option in question.UserChoice)
{
if (!questionResult.UserAnswer.Contains(option))
{
questionResult.UserAnswer.Add(option);
}
foreach (var answer in question.RightAnswer)
{
if (!questionResult.RightAnswer.Contains(answer))
{
questionResult.RightAnswer.Add(answer);
}
if (option.ToLower().Contains(answer.ToLower()))
{
userRightAnswered++;
}
}
}
if (userRightAnswered == question.RightAnswer.Count)
{
testResult.UserRightAnswered++;
}
if (question.UserChoice.Count > 0)
{
testResult.UserAnswered++;
}
if (DataAcess.TestManagment.GetUser(User.Identity.Name).Role.Contains(DataAcess.DomainModels.Role.Admin))
{
testResult.QuestionInfo.Add(questionResult);
}
}
return(View(testResult));
}
internal static OperationDetails CalculateTestResults(Dictionary <int, List <UserAnswer> > allAnswers,
Dictionary <int, List <UserAnswer> > userAnswers,
List <UserQuestionAnswersViewModel> questionList,
out TestResultViewModel testResult)
{
object lockObj = new object();
lock (lockObj)
{
testResult = null;
try
{
// I. Check.
if (allAnswers.Count == 0 || userAnswers.Count == 0)
{
return(new OperationDetails(false, "Parameters allAnswers and (or) userAnswers is empty.", "PLRepository.CalculateTestResults"));
}
// II. Get the test results and set them to testResult var .
testResult = new TestResultViewModel();
TestResultDetailViewModel testResultDetail;
int testScore = 0;
int questionWeight = 0;
bool isProperAnswer = false;
int maxScore = 0;
foreach (var item in allAnswers)
{
isProperAnswer = IsProperAnswer(questionList.Find(question => question.QuestionId == item.Key).AnswerType,
userAnswers[item.Key],
allAnswers[item.Key]);
testResultDetail = new TestResultDetailViewModel()
{
QuestionId = item.Key,
IsProperAnswer = isProperAnswer
};
questionWeight = questionList.Find(question => question.QuestionId == item.Key).QuestionWeight;
if (isProperAnswer)
{
testScore += questionWeight;
}
maxScore += questionWeight;
testResult.TestResultDetails.Add(testResultDetail);
}
testResult.MaxScore = maxScore;
testResult.Result = testScore;
return(new OperationDetails(true, "Method completed successfully.", "PLRepository.CalculateTestResults"));
}
catch (Exception ex)
{
testResult = null;
return(new OperationDetails(false, ex.Message, "PLRepository.CalculateTestResults"));
}
}
}
public async Task <IActionResult> Testing(TestingViewModel model)
{
List <Answer> answers = new List <Answer>();
if (model.Var1IsCorrect)
{
answers.Add(new Answer {
AttemptId = model.AttemptId, VariantId = model.Var1Id
});
}
if (model.Var2IsCorrect)
{
answers.Add(new Answer {
AttemptId = model.AttemptId, VariantId = model.Var2Id
});
}
if (model.Var3IsCorrect)
{
answers.Add(new Answer {
AttemptId = model.AttemptId, VariantId = model.Var3Id
});
}
if (model.Var4IsCorrect)
{
answers.Add(new Answer {
AttemptId = model.AttemptId, VariantId = model.Var4Id
});
}
await db.Answers.AddRangeAsync(answers);
db.SaveChanges();
Test test = await db.Tests.Include("Questions").Include("Questions.Variants").FirstOrDefaultAsync(t => t.Id == model.TestId);
if (model.Numb != test.Questions.Count - 1)
{
TestingViewModel newModel = GetQuest(model.Numb + 1, model.TestId, model.AttemptId);
return(View(newModel));
}
else
{
Attempt attempt = await db.Attempts.Include("Answers").Include("Answers.Variant").FirstOrDefaultAsync(t => t.Id == model.AttemptId);
int a = attempt.Answers.Where(t => t.Variant.IsCorrect).Count();
int b = attempt.Answers.Count;
TestResultViewModel result = new TestResultViewModel
{
Id = model.TestId,
TestName = test.Name,
Result = (double)a / b * 100
};
return(View("TestResult", result));
}
}
public bool SaveTestResult(TestResultViewModel testResult, int userId, int?topicId)
{
context.Scores.Add(new Score()
{
Detail = testResult.Detail,
Score1 = testResult.Score,
TestDate = DateTime.Now,
TopicId = topicId,
UserId = userId
});
return(context.SaveChanges() > 0);
}
public static TestResultDTO ToBllTestResult(this TestResultViewModel testResultViewModel)
{
return(new TestResultDTO()
{
Id = testResultViewModel.Id,
Name = testResultViewModel.Name,
GoodAnswers = testResultViewModel.GoodAnswers,
BadAnswers = testResultViewModel.BadAnswers,
DateCompleted = testResultViewModel.DateComleted,
User = testResultViewModel.User
});
}
async public Task TestCard(FileViewModel hostConfigFile, FileViewModel cardFile)
{
var renderResult = await UWPTestLibrary.RenderTestHelpers.RenderCard(cardFile, hostConfigFile, new Dictionary <string, AdaptiveCards.Rendering.Uwp.IAdaptiveCardResourceResolver>());
if (renderResult.Tree != null)
{
UWPTestLibrary.ImageWaiter imageWaiter = new ImageWaiter(renderResult.Tree);
StackPanel stackPanel = new StackPanel();
stackPanel.Children.Add(renderResult.Tree);
Border border = new Border();
border.Width = renderResult.CardWidth;
border.Child = stackPanel;
(Window.Current.Content as Frame).Content = border;
await imageWaiter.WaitOnAllImagesAsync();
}
StorageFile imageResultFile = null;
StorageFile jsonResultFile = null;
if (renderResult.Error == null)
{
imageResultFile = await _tempResultsFolder.CreateFileAsync("Result.png", CreationCollisionOption.GenerateUniqueName);
jsonResultFile = await _tempResultsFolder.CreateFileAsync("Result.json", CreationCollisionOption.GenerateUniqueName);
await UWPTestLibrary.RenderTestHelpers.ResultsToFile(imageResultFile, jsonResultFile, renderResult.RoundTrippedJSON, renderResult.Tree);
}
await Task.Delay(10);
var result = await TestResultViewModel.CreateAsync(
cardFile : cardFile,
hostConfigFile : hostConfigFile,
renderedTestResult : renderResult,
actualImageFile : imageResultFile,
actualJsonFile : jsonResultFile,
expectedFolder : _expectedFolder,
sourceHostConfigsFolder : _sourceHostConfigsFolder,
sourceCardsFolder : _sourceCardsFolder);
// We pass if it's not a new or changed card, and if either the image and json match or they match via error
bool testPass = !result.Status.NewCard && !result.Status.OriginalMatched &&
((result.Status.ImageMatched && result.Status.JsonRoundTripMatched) || result.Status.MatchedViaError);
if (!testPass)
{
throw new Exception(result.Status.ToString() + ": " + result.HostConfigName + "\\" + result.CardName);
}
}
// Topic test result details list.
public async Task <ActionResult> TopicTestResultDetails(int?id)
{
try
{
// I.Checks.
// Check id.
if (!int.TryParse(id.ToString(), out int intId))
{
return(RedirectToAction("Index"));
}
// Get TestResultDTO object.
TestResultDTO testResultDTO = await TestResultService.GetAsync(intId);
if (testResultDTO == null)
{
return(RedirectToAction("Index"));
}
// II. AutoMapper Setup.
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <TestResultDTO, TestResultViewModel>()
.ForMember("Id", opt => opt.MapFrom(tr => tr.TestResultId))
.ForMember("TestTitle", opt => opt.MapFrom(tr => tr.TestResultDetails.FirstOrDefault().Question.Topic.TopicTitle))
.ForMember(tr => tr.UserEmail, option => option.Ignore());
cfg.CreateMap <TestResultDetailDTO, TestResultDetailViewModel>()
.ForMember("Question", opt => opt.MapFrom(trd => trd.Question.QuestionText))
.ForMember("Topic", opt => opt.MapFrom(trd => trd.Question.Topic.TopicTitle));
});
IMapper iMapper = config.CreateMapper();
// III. Set ViewBag properties.
TestResultViewModel testResult = iMapper.Map <TestResultDTO, TestResultViewModel>(testResultDTO);
ViewBag.CourseName = testResultDTO.TestResultDetails.FirstOrDefault().Question.Topic.Course.CourseTitle;
ViewBag.TopicName = testResultDTO.TestResultDetails.FirstOrDefault().Question.Topic.TopicTitle;
ViewBag.Result = testResult.Result * 1000 / testResult.MaxScore;
ViewBag.MaxScore = 1000;
ViewBag.ParentId = testResultDTO.TestResultDetails.FirstOrDefault().Question.Topic.CourseId;
// IV. Get data for a view.
IEnumerable <TestResultDetailDTO> source = TestResultDetailService.Find(trd => trd.TestResultId == intId);//.ToList();
IEnumerable <TestResultDetailViewModel> testResultDetailList = iMapper.Map <IEnumerable <TestResultDetailDTO>, IEnumerable <TestResultDetailViewModel> >(source).OrderBy(trd => trd.Topic);
// V.
return(View(testResultDetailList));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// Maps TestResultViewModel entity to BllTestResult entity.
/// </summary>
/// <param name="testResult"> TestResultViewModel instance.</param>
/// <returns> BllTestResult instance.</returns>
public static BllTestResult ToBllTestResult(this TestResultViewModel testResult)
{
return(new BllTestResult
{
Id = testResult.Id,
DateTime = testResult.DateTime,
Grade = testResult.Grade,
TimeSpent = testResult.TimeSpent,
UserId = testResult.UserId,
Test = new BllTest {
Id = testResult.TestId.GetValueOrDefault()
}
});
}
async public Task TestCard(FileViewModel hostConfigFile, FileViewModel cardFile)
{
var renderResult = await UWPTestLibrary.RenderTestHelpers.RenderCard(cardFile, hostConfigFile);
if (renderResult.Item3 != null)
{
UWPTestLibrary.ImageWaiter imageWaiter = new ImageWaiter(renderResult.Item3);
StackPanel stackPanel = new StackPanel();
stackPanel.Children.Add(renderResult.Item3);
Border border = new Border();
border.Width = renderResult.Item4;
border.Child = stackPanel;
(Window.Current.Content as Frame).Content = border;
await imageWaiter.WaitOnAllImagesAsync();
}
StorageFile imageResultFile = null;
StorageFile jsonResultFile = null;
if (renderResult.Item1 == null)
{
imageResultFile = await _tempResultsFolder.CreateFileAsync("Result.png", CreationCollisionOption.GenerateUniqueName);
jsonResultFile = await _tempResultsFolder.CreateFileAsync("Result.json", CreationCollisionOption.GenerateUniqueName);
await UWPTestLibrary.RenderTestHelpers.ResultsToFile(imageResultFile, jsonResultFile, renderResult.Item2, renderResult.Item3);
}
await Task.Delay(10);
var result = await TestResultViewModel.CreateAsync(
cardFile : cardFile,
hostConfigFile : hostConfigFile,
actualError : renderResult.Item1,
actualImageFile : imageResultFile,
actualJsonFile : jsonResultFile,
xamlCard : renderResult.Item3,
expectedFolder : _expectedFolder,
sourceHostConfigsFolder : _sourceHostConfigsFolder,
sourceCardsFolder : _sourceCardsFolder);
if ((result.Status != TestStatus.Passed) &&
(result.Status != TestStatus.PassedButSourceWasChanged))
{
throw new Exception(result.Status.ToString() + ": " + result.HostConfigName + "\\" + result.CardName);
}
}
