public ActionResult Index()
{
var vmFactory = new ViewModelFactory();
var viewModel = vmFactory.Create <OrganizationViewModel>(RenderingContext.Current.Rendering);
return(View(viewModel));
}
public void The_factory_should_handle_an_array_of_complex_objects()
{
//arrange+
var model = new Model {
ChildArray = new[] { new Child()
{
Name = "1"
}, new Child()
{
Name = "2"
}, new Child(), new Child(), new Child()
{
Name = "5"
}, }
};
var factory = new ViewModelFactory <Model>(CreateHelper(model),
MvcContrib.UI.InputBuilder.InputBuilder.Conventions.ToArray(),
new DefaultNameConvention(), MvcContrib.UI.InputBuilder.InputBuilder.TypeConventions.ToArray());
//act
PropertyViewModel inputModelProperty = factory.Create(m => m.ChildArray);
//assert
Assert.AreEqual(inputModelProperty.Type, typeof(Child[]));
Assert.AreEqual(inputModelProperty.Name, "ChildArray");
Assert.AreEqual(inputModelProperty.HasExample(), false);
Assert.AreEqual(inputModelProperty.PropertyIsRequired, false);
Assert.AreEqual(inputModelProperty.PartialName, "Array");
Assert.AreEqual(inputModelProperty.Layout, "Array");
Assert.IsInstanceOf <IEnumerable <TypeViewModel> >(inputModelProperty.Value);
}
private async Task <List <VmCustomer> > getCustomersAsync(int?id, string name)
{
var custVms = new List <VmCustomer>();
try
{
var predicateRole = PredicateBuilder.New <Customer>();
if (id.HasValue)
{
predicateRole = predicateRole.And(x => x.Id == id.Value);
}
if (!string.IsNullOrEmpty(name))
{
predicateRole = predicateRole.And(x => x.Name.IndexOf(name) >= 0);
}
using (var custService = new CustomerService(DbContextFactory.Create()))
{
var custs = custService.GetAll().AsExpandable().Where(predicateRole).ToList();
custs.ForEach(x => custVms.Add(ViewModelFactory.Create <Customer, VmCustomer>(x)));
return(custVms);
}
}
catch (Exception ex)
{
this._logger.Error(ex.Message);
throw;
}
}
private void AttachViewModel()
{
if (DesignerProperties.GetIsInDesignMode(this))
{
return;
}
if (this.ViewModelType != null && this._viewModel == null)
{
this._viewModel = ViewModelFactory.Create(this.ViewModelType, this.FactoryContext);
}
if (this._viewModel != null)
{
this._viewModel.Model = this.DataContext;
this._viewModel.View = this.Child;
}
FrameworkElement childElement = this.Child as FrameworkElement;
if (childElement != null)
{
childElement.DataContext = this._viewModel;
}
}
public ActionResult Index()
{
var vmFactory = new ViewModelFactory();
var planetViewModel = vmFactory.Create <PlanetViewModel>(RenderingContext.Current.Rendering);
return(View(planetViewModel));
}
public ActionResult Index()
{
var vmFactory = new ViewModelFactory();
var characterViewModel = vmFactory.Create <CharacterViewModel>(RenderingContext.Current.Rendering);
ViewBag.SerializedModel = JsonConvert.SerializeObject(characterViewModel, Formatting.Indented);
return(View(characterViewModel));
}
public void Compare_BothNull_AreEqual()
{
var vm = ViewModelFactory.Create(_lessThan, _lessThan);
Assert.AreEqual(0, vm.RelPathComparison);
Assert.AreEqual(0, vm.LastWriteComparison);
Assert.AreEqual(0, vm.SizeComparison);
}
public void Compare_LeftNull_RightIsGreaterThanNull()
{
var vm = ViewModelFactory.Create(null, _greaterThan);
Assert.IsTrue(vm.RelPathComparison < 0);
Assert.IsTrue(vm.LastWriteComparison < 0);
Assert.IsTrue(vm.SizeComparison < 0);
}
public void Compare_RightNull_LeftIsGreaterThanNull()
{
var vm = ViewModelFactory.Create(_lessThan, null);
Assert.IsTrue(vm.RelPathComparison > 0);
Assert.IsTrue(vm.LastWriteComparison > 0);
Assert.IsTrue(vm.SizeComparison > 0);
}
public async Task ReadTargetsViewModel()
{
var vm = ViewModelFactory.Create <TargetsViewModel>();
await vm.LoadTargets();
Assert.AreEqual(2, vm.Targets.Count);
Assert.AreEqual(3, vm.Targets.SelectMany(t => t.Tests).Count());
}
public void Create_WhenGivenScreen_ReturnsExpectedViewModel()
{
var screen = ModifyVocabularyWordScreen.ForNewWord();
var viewModel = _factory.Create(screen);
viewModel.Should().NotBeNull();
viewModel.Should().BeOfType <ModifyVocabularyWordViewModel>();
}
//protected override void Validate()
//{
// base.Validate();
// if (Odes.Count == 0)
// {
// AddBrokenConstraint(KanonasRuleBusinessConstraint.OdiRequired);
// }
// //ищем KOdi с одинаковым номером
// var sameOdes = Odes.Where(str => Odes.Count(s => s.Number == str.Number) > 1);
// if (sameOdes?.Count() > 0)
// {
// AddBrokenConstraint(KanonasRuleBusinessConstraint.OdesWithSameNumber);
// }
// //ищем KAfterRule с одинаковым номером
// var sameAfterRules = AfterRules.Where(str => AfterRules.Count(s => s.OdiNumber == str.OdiNumber) > 1);
// if (sameAfterRules?.Count() > 0)
// {
// AddBrokenConstraint(KanonasRuleBusinessConstraint.AfterRulesWithSameNumber);
// }
//}
public void CreateViewModel(IRuleHandler handler, Action <OutputSectionModelCollection> append)
{
ViewModelFactory.Create(new CreateViewModelRequest <KanonasRule>()
{
Element = this,
Handler = handler,
AppendModelAction = append
});
}
public void Compare_LeftLastWriteTimeUtcIsMOreRecent_LeftLastWriteGreater()
{
_greaterThan.RelativePath = _lessThan.RelativePath;
_greaterThan.Length = _lessThan.Length;
var vm = ViewModelFactory.Create(_greaterThan, _lessThan);
Assert.IsTrue(vm.LastWriteComparison > 0);
Assert.AreEqual(0, vm.RelPathComparison);
Assert.AreEqual(0, vm.SizeComparison);
}
public void Compare_LeftFileLengthIsBigger_LeftLengthGreater()
{
_greaterThan.RelativePath = _lessThan.RelativePath;
_greaterThan.LastWriteTimeUtc = _lessThan.LastWriteTimeUtc;
var vm = ViewModelFactory.Create(_greaterThan, _lessThan);
Assert.IsTrue(vm.SizeComparison > 0);
Assert.AreEqual(0, vm.RelPathComparison);
Assert.AreEqual(0, vm.LastWriteComparison);
}
public void Compare_RightHashIsGreater_RightHashGreater()
{
_greaterThan.LastWriteTimeUtc = _lessThan.LastWriteTimeUtc;
_greaterThan.Length = _lessThan.Length;
var vm = ViewModelFactory.Create(_lessThan, _greaterThan);
Assert.IsTrue(vm.RelPathComparison < 0);
Assert.AreEqual(0, vm.LastWriteComparison);
Assert.AreEqual(0, vm.SizeComparison);
}
private void Click(object sender, RoutedEventArgs e)
{
Button button = (Button)sender;
string tag = (string)button.Tag;
//Window window = WindowFactory.CreateWindow(tag, Identity.IsAuthorized(), new EFDbContext());
//window.ShowDialog();
using (EFDbContext context = new EFDbContext())
{
ViewModelFactory.Create(tag, context);
}
}
public async Task <IActionResult> Create([FromForm] Participant participant)
{
if (ModelState.IsValid)
{
participant.Id = default;
context.Participants.Add(participant);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(ParticipantsList)));
}
return(View("ParticipantEditor", ViewModelFactory.Create(participant)));
}
public async Task <IActionResult> Create([FromForm] Product product)
{
if (ModelState.IsValid)
{
product.ProductId = default;
product.Category = default;
product.Supplier = default;
context.Products.Add(product);
await context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View("ProductEditor", ViewModelFactory.Create(product, Categories, Suppliers)));
}
public MassReplacerViewModel(IQueryDispatcher queryDispatcher, ICommandDispatcher commandDispatcher, ViewModelFactory factory, IMessagesService messagesService)
{
_queryDispatcher = queryDispatcher;
_commandDispatcher = commandDispatcher;
_messagesService = messagesService;
State = new ReplacerState();
SearchViewModel = factory.Create <SearchViewModel>();
PerformReplaceCommand = new RelayCommand(ExecutePerformCommand, CanExecutePerformCommand);
ApplyReverseReplaceSearchStateCommand = new RelayCommand(() =>
SearchViewModel.State.ApplyReverseReplaceCriteria(State), () => _transactionSetters.Any(x => x.CanExecute()));
_transactionSetters = new ISetter <Model.Transaction>[]
{
TextSetterCommand.Create(State.TitleSelector, SearchViewModel.State.TitleFilter),
TextSetterCommand.Create(State.NoteSelector, SearchViewModel.State.NoteFilter),
TextSetterCommand.Create(State.PositionTitleSelector, SearchViewModel.State.PositionTitleFilter),
DateSetterCommand.Create(State.BookDateSetter),
SingleSetterCommand.Create(State.CategoriesSelector),
SingleSetterCommand.Create(State.UserStocksSelector),
SingleSetterCommand.Create(State.ExternalStocksSelector),
SingleSetterCommand.Create(State.TypesSelector),
MultiSetterCommand.Create(State.TagsSelector)
};
_positionSetter = _transactionSetters.OfType <ISetter <Model.Position> >().ToArray();
MassReplacerSaveCommand = new RelayCommand <string>(name =>
{
State.Name = name;
State.SearchState = SearchViewModel.State;
var state = Mapper.Map <MassReplacerState>(State);
_commandDispatcher.Execute(new UpsertReplacerStateCommand(state));
var mapped = Mapper.Map <ReplacerState>(state);
Patterns.Remove(mapped);
Patterns.Add(mapped);
}, name => !string.IsNullOrWhiteSpace(name));
MassReplacerLoadCommand = new RelayCommand <BaseObservableObject>(selected =>
{
var state = selected as ReplacerState;
ApplyState(state);
}, selected => selected != null);
ClearMassReplacerStateCommand = new RelayCommand(() => State.Clear());
var patterns = _queryDispatcher.Execute <ReplacerStateQuery, MassReplacerState[]>(new ReplacerStateQuery())
.OrderBy(x => x.Name);
Patterns = new ObservableCollection <BaseObservableObject>(Mapper.Map <ReplacerState[]>(patterns));
}
public void Compare_SameValues_AreEqual()
{
var other = new FileMetadata
{
Length = _lessThan.Length,
LastWriteTimeUtc = _lessThan.LastWriteTimeUtc,
RelativePathHash = _lessThan.RelativePathHash,
};
var vm = ViewModelFactory.Create(_lessThan, _lessThan);
Assert.AreEqual(0, vm.RelPathComparison);
Assert.AreEqual(0, vm.LastWriteComparison);
Assert.AreEqual(0, vm.SizeComparison);
}
public IActionResult List()
{
ViewBag.Description = "This page is render from MVC view!";
var viewModel = new List <VmCustomer>();
using (var custService = new CustomerService(DbContextFactory.Create()))
{
var custs = custService.GetAll().ToList();
foreach (var cust in custs)
{
var custVm = ViewModelFactory.Create <Angular2.Mvc.DAL.Models.DAO.Customer, VmCustomer>(cust);
viewModel.Add(custVm);
}
}
return(View(viewModel));
}
/// <summary>
/// Instantiates a new instance of a view controller.
/// </summary>
/// <param name="parameter">An optional parameter that is passed to the view model.</param>
/// <returns>A new view controller.</returns>
/// <remarks>
/// This is a little complex due to a circular dependency between the view model, navigation, and view controller.
/// (VM -- depends on --> Navigation -- depends on --> VC -- depends on --> VM).
/// </remarks>
public UIViewController <TViewModel> InstantiateViewController <TViewModel>(object parameter)
where TViewModel : ViewModel
{
Type viewControllerType = this.viewControllerTypes.GetViewControllerType <TViewModel>();
UIStoryboard storyboard = this.GetStoryboard(viewControllerType);
UIViewController <TViewModel> viewController =
storyboard != null
? this.InstantiateViewController <TViewModel>(viewControllerType, storyboard)
: this.InstantiateViewController <TViewModel>(viewControllerType);
TViewModel viewModel = ViewModelFactory.Create <TViewModel>(this.applicationHost, new Navigation(this, viewController), parameter);
viewController.Initialize(this, viewModel);
return(viewController);
}
private Model Create(Model root)
{
var derived = ViewModelFactory <Model> .Create();
INotifyPropertyChanged nc = (INotifyPropertyChanged)derived;
var config = new MapperConfiguration(cfg => cfg.CreateMap(root.GetType(), derived.GetType()));
var mapper = config.CreateMapper();
// or
var vm = (Model)mapper.Map(root, root.GetType(), derived.GetType());
foreach (var i in root.NestedItems)
{
vm.NestedItems.Add(i);
}
return(vm);
}
public SubtypingViewModel(SubtypingProperty property, ViewModelFactory factory)
: base(property)
{
Instance = Property.Model.Where(x => x != null)
.Select(x => factory.Create(x, true))
.ToReactiveProperty();
EditCommand = property.Model.Select(x => x != null)
.ToReactiveCommand();
EditCommand.Where(x => Instance.Value != null).Subscribe(x =>
{
ShowDetailSubject.OnNext(Instance.Value);
});
Instance.Subscribe(x => ShowDetailSubject.OnNext(null));
OnChanged = Instance.Where(x => x != null)
.SelectMany(x => x.OnChanged)
.Merge(Instance.Select(x => Unit.Default));
}
public IActionResult Edit([FromRoute] int?id)
{
base._logger.Debug($"Edit Id = {id.ToString()}");
ViewBag.Title = "Customer - Edit";
using (var custService = new CustomerService(DbContextFactory.Create()))
{
var entity = custService.Get(x => x.Id.Equals(id)).FirstOrDefault();
if (entity != null)
{
var viewModel = ViewModelFactory.Create <Angular2.Mvc.DAL.Models.DAO.Customer, VmCustomer>(entity);
return(View(viewModel));
}
else
{
return(View(new VmCustomer()));
//return RedirectToAction("Index", controllerName: "CustomerMvc");
}
}
}
public async Task ReadSetupExecuteTest()
{
var vm = ViewModelFactory.Create <TargetsViewModel>();
await vm.LoadTargets();
Assert.AreEqual(2, vm.Targets.Count);
Assert.AreEqual(3, vm.Targets.SelectMany(t => t.Tests).Count());
int sortOrder = 1;
foreach (var target in vm.Targets)
{
var test = target.Tests.First();
test.Include = true;
test.SortOrder = sortOrder;
sortOrder++;
}
Assert.AreEqual(2, vm.Tests.Count);
await vm.ExecuteTests.Execute();
Assert.AreEqual(2, vm.Tests.Select(t => t.Result).Where(r => r != null).Count());
}
public TModel GetModel()
{
if (_model == null)
{
lock (this)
{
if (_model == null)
{
if (typeof(TModel).IsInterface)
{
_model = ActivatorUtilities.GetServiceOrCreateInstance <TModel>(_serviceProvider);
}
else
{
_model = ViewModelFactory <TModel> .Create(_serviceProvider);
}
}
}
}
return(_model);
}
public void The_factory_should_handle_an_array_of_value_objects()
{
//arrange+
var model = new Model {
StringArray = new[] { "foo", "bar", "wow", "this", "is" }
};
var factory = new ViewModelFactory <Model>(CreateHelper(model),
MvcContrib.UI.InputBuilder.InputBuilder.Conventions.ToArray(),
new DefaultNameConvention(), MvcContrib.UI.InputBuilder.InputBuilder.TypeConventions.ToArray());
//act
PropertyViewModel inputModelProperty = factory.Create(m => m.StringArray);
//assert
Assert.AreEqual(inputModelProperty.Type, typeof(String[]));
Assert.AreEqual(inputModelProperty.Name, "StringArray");
Assert.AreEqual(inputModelProperty.HasExample(), false);
Assert.AreEqual(inputModelProperty.PropertyIsRequired, false);
Assert.AreEqual(inputModelProperty.PartialName, "Array");
Assert.AreEqual(inputModelProperty.Layout, "Array");
}
public void The_factory_should_call_the_conventions()
{
//arrange+
var model = new Model {
StringProp = "foo"
};
var factory = new ViewModelFactory <Model>(CreateHelper(model),
MvcContrib.UI.InputBuilder.InputBuilder.Conventions.ToArray(),
new DefaultNameConvention(), null);
//act
PropertyViewModel inputModelProperty = factory.Create(m => m.StringProp);
//assert
Assert.AreEqual(inputModelProperty.Type, typeof(String));
Assert.AreEqual(inputModelProperty.Name, "StringProp");
Assert.AreEqual(inputModelProperty.PartialName, "String");
Assert.AreEqual(inputModelProperty.HasExample(), true);
Assert.AreEqual(inputModelProperty.Example, "example");
Assert.AreEqual(inputModelProperty.PropertyIsRequired, true);
}
public MainViewModel()
{
Editor.Value = new Editor(this);
Masters = Editor.Value.Project.Where(x => x != null)
.SelectMany(x => x.Root)
.Where(x => x != null)
.Select(x => x.Structure.Properties)
.Select(x =>
{
var factory = new ViewModelFactory(Editor.Value.Project.Value.Factory);
return(x.Select(y => factory.Create(y, true)).ToArray());
})
.ToReactiveProperty();
Title = Editor.SelectMany(x => x.Title)
.ToReactiveProperty();
SaveCommand = Editor.SelectMany(x => x.CanSave)
.ToReactiveCommand();
SaveAsCommand = Editor.SelectMany(x => x.CanSave)
.ToReactiveCommand();
ProjectSettingCommand = Editor.Value.Project
.Select(x => x != null)
.ToReactiveCommand();
SubscribeCommands();
Masters.Where(xs => xs != null).Subscribe(xs =>
{
Observable.Merge(xs.Select(x => x.OnChanged))
.PublishTask(x => Editor.Value.ModifyAsync(), e => ShowError(e, "エラー"));
});
Editor.Value.OnSettingChanged
.PublishTask(x => Editor.Value.ModifyAsync(), e => ShowError(e, "エラー"));
Masters.Where(x => x != null)
.SelectMany(x => Observable.Merge(x.Select(y => y.OnError)))
.Subscribe(err => ShowError(err, "エラー"));
}
