public void Create(TestVM model)
{
_unitOfWork.Tests.Create(new Test {
Name = model.Name, ThemeId = model.ThemeId
});
_unitOfWork.Save();
}
public void SuppressNotificationsInside()
{
var counter = 0;
var vm = new TestVM();
vm.PropertyChanged += (s, a) => counter++;
// initial value
vm.MyProperty = 0;
counter = 0;
vm.SuppressNotificationsInside(() => vm.MyProperty, () =>
{
vm.MyProperty = 42;
vm.MyProperty = 21;
vm.MyProperty = 0;
// last value is different than initial value, to PropertyChanged should call
vm.MyProperty = 42;
});
Assert.AreEqual(42, vm.MyProperty);
Assert.AreEqual(1, counter, "PropertyChanged was raised more or less than once.");
}
public void BaseVM_AcceptChangedProperties()
{
var vm = new TestVM();
vm.String = "MyString";
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(1, vm.ChangedProperties.Count);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("String"));
Assert.AreEqual("MyString", vm.ChangedProperties["String"]);
vm.AcceptChangedProperties();
vm.Int = 13;
vm.Double = 3.1456;
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(2, vm.ChangedProperties.Count);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Int"));
Assert.AreEqual(13, vm.ChangedProperties["Int"]);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Double"));
Assert.AreEqual(3.1456, vm.ChangedProperties["Double"]);
vm.AcceptChangedProperties();
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(0, vm.ChangedProperties.Count);
}
public void Setup()
{
VM = new TestVM();
InvalidValidationResult = new ValidationResult(
CreateValidationError("Invalid validation result", VM, TestVM.ClassDescriptor.Property)
);
}
public double GetSelectedTestFee(TestVM test)
{
Query = "SELECT Fee FROM Test WHERE Name = @name";
Command = new SqlCommand(Query, Connection);
Connection.Open();
Command.Parameters.Clear();
Command.Parameters.Add("name", SqlDbType.VarChar);
Command.Parameters["name"].Value = test.Name;
Reader = Command.ExecuteReader();
TestVM aTest = null;
while (Reader.Read())
{
aTest = new TestVM();
aTest.Fee = Convert.ToDouble(Reader["Fee"]);
}
Reader.Close();
Connection.Close();
return(aTest.Fee);
}
public async Task Extended_interface_contract_changes_can_be_detected()
{
var ct = CancellationToken.None;
IStackNavigator navigator = new BlindStackNavigator();
// If the extension methods available in the abstraction package change their signatures, we get compilation errors here.
TestVM vmAfterNavigate = await navigator.Navigate(ct, () => new TestVM(), suppressTransition : false);
TestVM vmAfterNavigateAndClear = await navigator.NavigateAndClear(ct, () => new TestVM(), suppressTransition : false);
INavigableViewModel vm = navigator.GetActiveViewModel();
bool canGoBack = navigator.CanNavigateBack();
// Navigate twice so that RemovePrevious works.
await navigator.Navigate(ct, () => new TestVM(), suppressTransition : false);
await navigator.Navigate(ct, () => new TestVM(), suppressTransition : false);
await navigator.RemovePrevious(ct);
bool didNavigateBack = await navigator.TryNavigateBackTo <TestVM>(ct);
await navigator.ProcessRequest(ct, StackNavigatorRequest.GetNavigateRequest(() => new TestVM(), false, false));
IObservable <EventPattern <StackNavigatorEventArgs> > ob1 = navigator.ObserveStateChanged();
IObservable <StackNavigatorState> ob2 = navigator.ObserveCurrentState();
}
public IHttpActionResult GetTest(int testId)
{
TestVM test = new TestVM();
Test t = db.Test.Where(x => x.TestID == testId).SingleOrDefault();
test.BrojPitanja = t.BrojPitanja;
test.KategorijaID = t.KategorijaID;
test.Naziv = t.Naziv;
test.TestID = t.TestID;
foreach (Pitanje p in db.Pitanje.Where(z => z.TestID == test.TestID).ToList())
{
PitanjeVM pvm = new PitanjeVM();
pvm.Bod = p.Bod;
pvm.PitanjeID = p.PitanjeID;
pvm.PitanjeTekst = p.PitanjeTekst;
pvm.TestID = p.TestID;
//pvm.Odgovori = db.Odgovori.Where(y => y.PitanjeID == pvm.PitanjeID).ToList();
test.Pitanja.Add(pvm);
}
return(Ok(test));
}
protected void saveButton_Click(object sender, EventArgs e)
{
TestVM aTest = new TestVM();
aTest.Name = testNameTextBox.Value;
aTest.Fee = Convert.ToDouble(feeTextBox.Value);
aTest.TypeName = testTypeDropDownList.SelectedItem.Text;
aTest.TypeId = Convert.ToInt32(testTypeDropDownList.SelectedValue);
string msg = aTestManager.Save(aTest);
if (msg == "1")
{
messageLabel.InnerText = "Test saved successfully..";
}
else if (msg == "2")
{
messageLabel2.InnerText = "Test already exists";
}
else if (msg == "3")
{
messageLabel2.InnerText = "Saving failed..";
}
else
{
messageLabel2.InnerText = "";
}
ClearTextField();
PopulateTestGridView();
}
public HttpResponseMessage Create(HttpRequestMessage request, TestVM testVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
if (_testsRepository.TestExists(testVM.Name))
{
ModelState.AddModelError("Invalid user", "Email or Name already exists");
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
}
else
{
Test newTest = new Test();
newTest = AutoMapper.Map <TestVM, Test>(testVM);
_testsRepository.Insert(newTest);
_testsRepository.Commit();
// Update view model
testVM = AutoMapper.Map <Test, TestVM>(newTest);
response = request.CreateResponse <TestVM>(HttpStatusCode.Created, testVM);
}
}
return response;
}));
}
public void DispatcherServiceTest()
{
TestVM vm = new TestVM();
UserControl control = new UserControl()
{
DataContext = vm
};
DispatcherService service = new DispatcherService();
Interactivity.Interaction.GetBehaviors(control).Add(service);
Window.Content = control;
EnqueueShowWindow();
EnqueueCallback(() => {
Assert.IsFalse(vm.IsProgress);
vm.Calculate();
Assert.IsTrue(vm.IsProgress);
});
EnqueueWait(() => vm.Task.IsCompleted);
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
DispatcherHelper.DoEvents();
Assert.IsFalse(vm.IsProgress);
Assert.IsTrue(vm.IsCompleted);
});
EnqueueTestComplete();
}
private static void AssertBehaviorResults(TestVM vm, ExpectedResults results)
{
ValidationAssert.AreEqual(
results.Properties,
vm.GetResultFromBehavior(ValidationResultScope.PropertiesOnly)
);
ValidationAssert.AreEqual(
results.ViewModel,
vm.GetResultFromBehavior(ValidationResultScope.ViewModelValidationsOnly)
);
ValidationAssert.AreEqual(
results.Self,
vm.GetResultFromBehavior(ValidationResultScope.Self)
);
ValidationAssert.AreEqual(
results.Descenants,
vm.GetResultFromBehavior(ValidationResultScope.Descendants)
);
ValidationAssert.AreEqual(
results.All,
vm.GetResultFromBehavior(ValidationResultScope.All)
);
}
public void GetValueOfSourceProperty_LoadsRequiredPropertyBeforeSourceProperty()
{
var vm = new TestVM(TestVM.ClassDescriptor);
vm.Load(x => x.SourceProperty);
Assert.IsTrue(vm.IsLoaded(x => x.CollectionRequiredBySourceProperty));
}
public HttpResponseMessage Delete(HttpRequestMessage request, TestVM testVM)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest,
ModelState.Keys.SelectMany(k => ModelState[k].Errors)
.Select(m => m.ErrorMessage).ToArray());
}
else
{
testVM.IsDeleted = true;
Test _test = _testsRepository.GetSingleByTestID(testVM.ID);
_test.UpdateTest(testVM);
_testsRepository.Commit();
response = request.CreateResponse(HttpStatusCode.OK);
}
return response;
}));
}
public void BaseVM_AcceptChangedProperties()
{
var vm = new TestVM();
vm.String = "MyString";
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(1, vm.ChangedProperties.Count);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("String"));
Assert.AreEqual("MyString", vm.ChangedProperties["String"]);
vm.AcceptChangedProperties();
vm.Int = 13;
vm.Double = 3.1456;
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(2, vm.ChangedProperties.Count);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Int"));
Assert.AreEqual(13, vm.ChangedProperties["Int"]);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Double"));
Assert.AreEqual(3.1456, vm.ChangedProperties["Double"]);
vm.AcceptChangedProperties();
Assert.IsNotNull(vm.ChangedProperties);
Assert.AreEqual(0, vm.ChangedProperties.Count);
}
public void BaseVM_CRUD()
{
var vm = new TestVM();
vm.AddList(() => vm.Sequence, new TestObject {
Id = 4, Name = "Four"
});
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_add"));
Assert.IsNotNull(vm.ChangedProperties["Sequence_add"] as TestObject);
Assert.AreEqual(4, (vm.ChangedProperties["Sequence_add"] as TestObject).Id);
Assert.AreEqual("Four", (vm.ChangedProperties["Sequence_add"] as TestObject).Name);
vm.UpdateList(() => vm.Sequence, new TestObject {
Id = 2, Name = "Two"
});
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_update"));
Assert.IsNotNull(vm.ChangedProperties["Sequence_update"] as TestObject);
Assert.AreEqual(2, (vm.ChangedProperties["Sequence_update"] as TestObject).Id);
Assert.AreEqual("Two", (vm.ChangedProperties["Sequence_update"] as TestObject).Name);
vm.RemoveList(() => vm.Sequence, 3);
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_remove"));
Assert.AreEqual(3, vm.ChangedProperties["Sequence_remove"]);
}
public void DispatcherServiceTest() {
#endif
TestVM vm = new TestVM();
UserControl control = new UserControl() { DataContext = vm };
DispatcherService service = new DispatcherService();
Interactivity.Interaction.GetBehaviors(control).Add(service);
Window.Content = control;
#if NETFX_CORE
await EnqueueShowWindow();
#else
EnqueueShowWindow();
#endif
EnqueueCallback(() => {
Assert.IsFalse(vm.IsProgress);
vm.Calculate();
Assert.IsTrue(vm.IsProgress);
});
#if NETFX_CORE
await WaitConditional(() => vm.Task.IsCompleted);
#else
EnqueueWait(() => vm.Task.IsCompleted);
#endif
EnqueueWindowUpdateLayout();
EnqueueCallback(() => {
#if !NETFX_CORE
DispatcherHelper.DoEvents();
#endif
Assert.IsFalse(vm.IsProgress);
Assert.IsTrue(vm.IsCompleted);
});
EnqueueTestComplete();
}
//
// GET: /Test/
public ActionResult Index()
{
TestVM vm = new TestVM();
var products = db.Products
.Include(p => p.Test)
.OrderBy(p => p.Test.Abbreviation)
.ThenBy(p => p.Name)
.ToList();
var allTests = (from t in db.Tests
select new {
t.Id, t.Abbreviation
}).OrderBy(x => x.Abbreviation).ToList();
foreach (var item in allTests)
{
TestVM.Test test = new TestVM.Test {
Id = item.Id,
Abbreviation = item.Abbreviation
};
var productsByTestId = from p in products
where p.TestId == item.Id
select p;
vm.ProductsByTest.AddRange(productsByTestId);
vm.Tests.Add(test);
}
return(View(vm));
}
public override void TestInitialize()
{
base.TestInitialize();
// _RootVM=new RootVM();
// provider = (MappedDataProvider<TestData, int>) _RootVM.TestObject.Number.Metadata.DataProvider;
_TestVM = new TestVM();
provider = (MappedDataProvider <TestData, int>)_TestVM.Number.Metadata.DataProvider;
}
public void TryInitializeView_WorksWithModelInterfaces()
{
var view = new TestView();
var vm = new TestVM();
Assert.IsTrue(ViewFactory.TryInitializeView(view, vm));
Assert.AreEqual(vm, view.Model);
}
public List <string> GetBreadCrumbs(TestVM model)
{
var breadcrumb = new List <string>();
breadcrumb.Add(_helper.Url().Tests().ToString());
model.Sections.ForEach(x => breadcrumb.Add(_helper.Url().TestSectionLink(x).ToString()));
return(breadcrumb);
}
public IActionResult Handler([FromBody] TestVM test)
{
var claim = HttpContext.User.Claims.ElementAt(0);
string userName = claim.Value;
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
return(new ObjectResult(new { test.FirstName, test.LastName, userId }));
}
public void Update(TestVM model)
{
_unitOfWork.Tests.Update(new Test {
TestId = model.TestId, Name = model.Name, ThemeId = model.ThemeId
});
_unitOfWork.Save();
}
public static void UpdateTest(this Test test, TestVM testVM)
{
test.Name = testVM.Name;
test.Description = testVM.Description;
test.ModifiedBy = testVM.ModifiedBy;
test.ModifiedOn = testVM.ModifiedOn;
test.IsDeleted = testVM.IsDeleted;
}
public NewTest(User user, Test test)
{
InitializeComponent();
this.Title += user.Name + " " + user.Surname;
ObservableCollection <Question> questions = Connection.GetQuestions(test.TestID);
this.test = test;
DataContext = new TestVM(this, test, questions);
}
public void HandleChange_WithPropertyChangedOfOwnViewModelProperty_UpdatesCachedResults()
{
var owner = new TestVM();
owner.MakePropertiesAndViewModelInvalid();
var expected = owner.GetCurrentlySetupResults();
// S E T C H I L D
var firstChild = new ViewModelStub {
ValidationResult = CreateValidationResult("First child error")
};
var propertyChangedArgs = ChangeArgs
.ViewModelPropertyChanged(
owner.SecondProperty,
ValueStage.ValidatedValue,
oldValue: null,
newValue: firstChild)
.PrependViewModel(owner);
owner.CallHandleChangeWith(propertyChangedArgs);
expected.Descenants = firstChild.ValidationResult;
AssertBehaviorResults(owner, expected);
// C H A N G E C H I L D
var secondChild = new ViewModelStub {
ValidationResult = CreateValidationResult("Second child error")
};
propertyChangedArgs = ChangeArgs
.ViewModelPropertyChanged(
owner.SecondProperty,
ValueStage.ValidatedValue,
oldValue: firstChild,
newValue: secondChild)
.PrependViewModel(owner);
owner.CallHandleChangeWith(propertyChangedArgs);
expected.Descenants = secondChild.ValidationResult;
AssertBehaviorResults(owner, expected);
// S E T C H I L D T O N U L L
propertyChangedArgs = ChangeArgs
.ViewModelPropertyChanged(
owner.SecondProperty,
ValueStage.ValidatedValue,
oldValue: secondChild,
newValue: null)
.PrependViewModel(owner);
owner.CallHandleChangeWith(propertyChangedArgs);
expected.Descenants = ValidationResult.Valid;
AssertBehaviorResults(owner, expected);
}
private void GetFee()
{
TestVM aTest = new TestVM();
aTest.Name = selectTestDropDownList.SelectedItem.Text;
double fee = aTestManager.GetSelectedTestFee(aTest);
feeTextBox.Value = Convert.ToString(fee);
}
public IHttpActionResult Post([FromBody] TestVM testVM)
{
if (testVM == null || !testVM.isWalid())
{
return(BadRequest());
}
_testService.AddTest(Mapper.Map <TestDTO>(testVM));
return(Ok());
}
public string Update(TestVM aTestVm)
{
int rowAffected = aTestGateway.UpdateTest(aTestVm);
if (rowAffected > 0)
{
return("1");
}
return("3");
}
public void DeleteTest(string name)
{
int tId;
TestVM test = aTestGateway.GetTest(name);
tId = test.Id;
aPatientTestGateway.DeleteFromPatientTest(tId);
aPatientGateway.DeleteTest(tId);
}
public void BaseVM_PushUpdates()
{
var vm = new TestVM();
bool request = false;
vm.RequestPushUpdates += (sender, e) => request = true;
vm.PushUpdates();
Assert.IsTrue(request);
}
public void BaseVM_IgnoredProperties()
{
var vm = new TestVM();
Assert.IsNotNull(vm.IgnoredProperties);
Assert.IsTrue(vm.IgnoredProperties.Contains("IgnoreMe"));
Assert.IsFalse(vm.IgnoredProperties.Contains("Bool"));
vm.Ignore(() => vm.Bool);
Assert.IsTrue(vm.IgnoredProperties.Contains("Bool"));
}
public void BaseVM_IgnoredProperties()
{
var vm = new TestVM();
Assert.IsNotNull(vm.IgnoredProperties);
Assert.IsTrue(vm.IgnoredProperties.Contains("IgnoreMe"));
Assert.IsFalse(vm.IgnoredProperties.Contains("Bool"));
vm.Ignore(() => vm.Bool);
Assert.IsTrue(vm.IgnoredProperties.Contains("Bool"));
}
public void BaseVM_PushUpdates()
{
var vm = new TestVM();
bool request = false;
vm.RequestPushUpdates += (sender, e) => request = true;
vm.PushUpdates();
Assert.IsTrue(request);
}
public async Task LoadAsync_Toggles_Loading()
{
var vm = new TestVM();
try
{
await vm.LoadDataAsync();
}
catch { }
Assert.IsTrue(vm.IsLoading);
}
public void BaseVM_GetSubVM()
{
var vm = new TestVM();
var test1 = vm.GetSubVM(typeof(TestVM).Name) as TestVM;
Assert.IsNotNull(test1);
Assert.AreEqual("TestVM", test1.String);
var test2 = vm.GetSubVM(typeof(TestVM).Name, "1") as TestVM;
Assert.IsNotNull(test2);
Assert.AreEqual("TestVM1", test2.String);
}
public void After_Two_Navigates_I_Am_Able_To_Go_Back()
{
var uiTask = Observable.Start(() =>
{
var app = new AppBootstrapper();
//var app = new AppLifetime();
//app.OnLaunching();
//var vm = Locator.Current.GetService<MainViewModel>();
var vm = new TestVM();
Screen.Router.Navigate.Execute(vm);
Screen.Router.Navigate.Execute(vm);
//vm.AddSubscriptionCommand.Execute(null);
Screen.Router.NavigationStack.ItemsAdded.Take(2).Wait();
var canGoBack = Screen.Router.NavigateBack.CanExecute(null);
Assert.IsTrue(canGoBack);
}, RxApp.MainThreadScheduler).FirstOrDefaultAsync();
uiTask.Wait();
}
public void BaseVM_CRUD()
{
var vm = new TestVM();
vm.AddList(() => vm.Sequence, new TestObject { Id = 4, Name = "Four" });
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_add"));
Assert.IsNotNull(vm.ChangedProperties["Sequence_add"] as TestObject);
Assert.AreEqual(4, (vm.ChangedProperties["Sequence_add"] as TestObject).Id);
Assert.AreEqual("Four", (vm.ChangedProperties["Sequence_add"] as TestObject).Name);
vm.UpdateList(() => vm.Sequence, new TestObject { Id = 2, Name = "Two" });
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_update"));
Assert.IsNotNull(vm.ChangedProperties["Sequence_update"] as TestObject);
Assert.AreEqual(2, (vm.ChangedProperties["Sequence_update"] as TestObject).Id);
Assert.AreEqual("Two", (vm.ChangedProperties["Sequence_update"] as TestObject).Name);
vm.RemoveList(() => vm.Sequence, 3);
Assert.IsNotNull(vm.ChangedProperties);
Assert.IsTrue(vm.ChangedProperties.ContainsKey("Sequence_remove"));
Assert.AreEqual(3, vm.ChangedProperties["Sequence_remove"]);
}
