public async Task CommandsAreInitializedCorrectlyTest()
{
Card card = new Card()
{
CardId = 1, DeckId = 2
};
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>()
{
card
}, new List <Deck>());
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock)
{
SelectedEntity = card
};
await viewModel.InitializeAsync();
Assert.IsNotNull(viewModel.NewCommand.CommandText);
Assert.IsNotNull(viewModel.NewCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/New", viewModel.NewCommand.TargetUriFactory.Invoke(null));
Assert.IsNotNull(viewModel.EditCommand.CommandText);
Assert.IsNotNull(viewModel.EditCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/1", viewModel.EditCommand.TargetUriFactory.Invoke(card));
Assert.IsNotNull(viewModel.ShowStatisticsCommand.CommandText);
Assert.IsNotNull(viewModel.ShowStatisticsCommand.ToolTip);
Assert.AreEqual("/Decks/2/Cards/1/Statistics", viewModel.ShowStatisticsCommand.TargetUriFactory.Invoke(card));
Assert.IsNotNull(viewModel.DeleteCommand.CommandText);
Assert.IsNotNull(viewModel.DeleteCommand.ToolTip);
}
public async Task NewCommandEnabledTest()
{
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>(), new List <Deck>());
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
await viewModel.InitializeAsync();
Assert.IsFalse(viewModel.NewCommand.IsEnabled);
viewModel.SelectedEntity = new Card();
Assert.IsTrue(viewModel.NewCommand.IsEnabled);
}
public async Task DoesExecuteSearchOnInitializeTest()
{
Card card = new Card();
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>()
{
card
}, new List <Deck>());
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(1, viewModel.SearchResults.Count);
Assert.AreSame(card, viewModel.SearchResults[0]);
}
public AuthorViewModel()
{
CardSearch = new CardSearchViewModel();
Cards = new ObservableCollection <CardViewModel>();
CardSearch.CardOpened += (s, e) =>
{
var existing = Cards.FirstOrDefault(p => p.Id == e.CardOpened.Id);
if (existing == null)
{
existing = e.CardOpened;
Cards.Add(existing);
}
SelectedCard = existing;
};
}
public async Task LoadsAvailableDecksErrorTest()
{
ApiConnectorMock mock = CreateMockForInitialize(false, true, new List <Card>(),
new List <Deck>()
{
new Deck()
{
DeckId = 1, Title = "test"
}
});
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsFalse(result);
Assert.AreEqual("test-error", notificationProviderMock.Message);
Assert.AreEqual(NotificationKind.ErrorNotification, notificationProviderMock.NotificationKind);
}
public async Task LoadsAvailableDecksOnInitializeTest()
{
ApiConnectorMock mock = CreateMockForInitialize(true, true, new List <Card>(),
new List <Deck>()
{
new Deck()
{
DeckId = 1, Title = "test"
}
});
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
bool result = await viewModel.InitializeAsync();
Assert.IsTrue(result);
Assert.AreEqual(2, viewModel.AvailableDecks.Count);
Assert.IsTrue(viewModel.AvailableDecks.Contains("test"));
Assert.IsTrue(viewModel.AvailableDecks.Contains(Messages.All));
Assert.IsTrue(viewModel.DeckSelectable);
}
public async Task ExecuteSearchParametersTest()
{
ApiConnectorMock mock = new ApiConnectorMock();
CardSearchViewModel viewModel = new CardSearchViewModel(navigationManagerMock, mock);
mock.Replies.Push(new ApiReply <List <Card> >()
{
WasSuccessful = true,
Result = new List <Card>()
});
await viewModel.SearchAsync();
Dictionary <string, object> parameters = mock.Parameters.Pop() as Dictionary <string, object>;
Assert.AreEqual(0, parameters.Count);
viewModel.SearchText = "text";
mock.Replies.Push(new ApiReply <List <Card> >()
{
WasSuccessful = true,
Result = new List <Card>()
});
await viewModel.SearchAsync();
parameters = mock.Parameters.Pop() as Dictionary <string, object>;
Assert.AreEqual(1, parameters.Count);
Assert.AreEqual("text", parameters[nameof(viewModel.SearchText)]);
viewModel.DeckId = 1;
mock.Replies.Push(new ApiReply <List <Card> >()
{
WasSuccessful = true,
Result = new List <Card>()
});
await viewModel.SearchAsync();
parameters = mock.Parameters.Pop() as Dictionary <string, object>;
Assert.AreEqual(2, parameters.Count);
Assert.AreEqual((long)1, parameters[nameof(Deck.DeckId)]);
}
public async Task <IActionResult> Search(string Id, string returnUrl, string search)
{
var pacient = await _pacientService.GetPacientByIdAsync(Id, false, false, false);
var card = await _cardService.GetCardByIdAsync(Id);
IQueryable <Allergy> allergy;
IQueryable <Examination> exam;
IQueryable <PacientVaccination> vaccinations;
IQueryable <Diagnose> diagnoses;
IQueryable <DiagnoseHistory> dHistorys;
IQueryable <Reccomendation> reccomendations;
if (string.IsNullOrEmpty(search))
{
allergy = _cardService.GetAllergies(card.Id);
exam = _cardService.GetExaminations(card.Id);
vaccinations = _cardService.GetPacientVaccinations(card.Id);
diagnoses = _cardService.GetDiagnoses(card.Id);
dHistorys = _cardService.GetDiagnoseHistories(card.Id);
reccomendations = _cardService.GetReccomendations(card.Id);
}
else
{
allergy = _cardService.SearchAllergies(card.Id, search);
exam = _cardService.SearchExaminations(card.Id, search);
vaccinations = _cardService.SearchPacientVaccinations(card.Id, search);
diagnoses = _cardService.SearchDiagnoses(card.Id, search);
dHistorys = _cardService.SearchDiagnoseHistories(card.Id, search);
reccomendations = _cardService.SearchReccomendations(card.Id, search);
}
card.Allergies = await allergy.OrderBy(x => x.DateOfIssue).Take(10).ToListAsync();
card.Examinations = await exam.OrderBy(x => x.ExaminationDate).Take(10).ToListAsync();
card.Vaccinations = await vaccinations.OrderBy(x => x.Date)
.Include(x => x.Vaccination).Take(10).ToListAsync();
card.Diagnoses = await diagnoses
.OrderBy(x => x.EstablisheDate).Take(10)
.Include(x => x.DoctorEstablishe)
.Include(x => x.DoctorConfirm).ToListAsync();
card.Reccomendations = await reccomendations.OrderBy(x => x.Start).Take(10).ToArrayAsync();
var vm = new CardSearchViewModel
{
Search = search,
Pacient = pacient,
Card = card,
ReturnUrl = returnUrl,
AllrgeysCount = await allergy.CountAsync(),
DiagnoseHistoryCount = await dHistorys.CountAsync(),
DiggnosesCount = await diagnoses.CountAsync(),
ExaminationsCount = await exam.CountAsync(),
VaccinationsCount = await vaccinations.CountAsync(),
ReccomendationsCount = await vaccinations.CountAsync()
};
vm.DiagnoseHistories = dHistorys.OrderBy(x => x.ConclusionDate).Take(10);
return(View(vm));
}
public IActionResult Search(CardSearchViewModel viewModel)
{
return(RedirectToAction(nameof(Search), new { Id = viewModel.Pacient.Id,
returnUrl = viewModel.ReturnUrl, search = viewModel.Search }));
}
