public static IDisposable ListenAddedMessage <TEntity, TConvertEntity>(
this IMessageBus messageBus,
IObservable <IList <TConvertEntity> > observable,
Action <TConvertEntity> action = null)
{
var disposable = new DisposableObject();
IList <TConvertEntity> collection = null;
disposable.Add(observable.Subscribe(result => collection = result));
disposable.Add(
ListenAddedMessage <TEntity>(
messageBus,
entity =>
{
var newValue = entity.MapTo <TConvertEntity>();
if (collection != null)
{
collection.Insert(0, newValue);
}
if (action != null)
{
action(newValue);
}
}));
return(disposable);
}
public static IDisposable Binding <TFilter, TObject>(
this AutoCompleteBox acb,
IFilterViewModel <TFilter, TObject> filterViewModel,
Action <IFilterViewModel <TFilter, TObject>, string> action = null,
Action <bool> busy = null,
int startWith = 1)
{
var disposableObject = new DisposableObject();
var searchTextEntered = acb.WhenAny(x => x.SearchText, x => x.Value)
.Do(_ => filterViewModel.Abort())
.Throttle(TimeSpan.FromSeconds(1))
.Where(text => !string.IsNullOrWhiteSpace(text))
.Where(text => text.Length >= startWith)
.ObserveOnUiSafeScheduler()
.Do(text =>
{
if (action != null)
{
action(filterViewModel, string.Concat(text, "*"));
}
});
disposableObject.Add(
searchTextEntered.Subscribe(
_ =>
{
if (filterViewModel.Result != null)
{
filterViewModel.Result.Clear();
}
filterViewModel.InvokeCommand.Execute(null);
}));
var loadCompleted = filterViewModel.WhenAny(x => x.Result, x => x.Value)
.Where(x => x != null && x.Count > 0);
disposableObject.Add(loadCompleted.ObserveOnUiSafeScheduler().Subscribe(
result =>
{
acb.ItemsSource = result;
if (acb.IsKeyboardFocusWithin)
{
acb.IsDropDownOpen = true;
}
}));
if (busy != null)
{
disposableObject.Add(filterViewModel.WhenAnyValue(x => x.IsBusy).Subscribe(busy));
}
return(disposableObject);
}
private void InterceptableObjectLoaded(object sender, RoutedEventArgs e)
{
var target = (PostingOfInventoryAtTheWarehouseView)sender;
target.Loaded -= InterceptableObjectLoaded;
InitSetting();
RowDefinition rowDefinition = target.RootContentGrid.RowDefinitions[0];
_disposable.Add(TrackRowDefinition(rowDefinition));
_disposable.Add(IsExpanded(target.ExpanderFilter));
}
public AttachedDocumentViewModel(
IScreen screen,
IRoutableViewModelManager viewModelManager,
IUnitOfWorkFactory unitOfWorkFactory,
IGetCatalogAccess getCatalogAccess)
{
HostScreen = screen;
_viewModelManager = viewModelManager;
_unitOfWorkFactory = unitOfWorkFactory;
_getAccess = getCatalogAccess;
CatalogAccess.LoadForEntity(typeof(AttachedDocument), TypeActionInSystem.TheStandardAddition);
_disposableObject.Add(this.Binding());
}
private object GetViewModel([NotNull] Type viewModelType, IObservable <Unit> _destroyObservable = null)
{
Contract.Requires(viewModelType != null);
Contract.Ensures(Contract.Result <object>() != null);
if (viewModelType.GetInterface("IDisposable") == null)
{
var viewModel = _dependencyResolver.GetService(viewModelType);
if (viewModel == null)
{
throw new InvalidOperationException(
"(RoutableViewModelManager.Get<>) Not resolve {0}".StringFormat(viewModelType));
}
return(viewModel);
}
var exportFactoryInstantiatorType = typeof(ExportFactoryInstantiator <>).MakeGenericType(viewModelType);
dynamic exportFactoryInstantiator = _dependencyResolver.GetService(exportFactoryInstantiatorType);
if (exportFactoryInstantiator == null)
{
throw new InvalidOperationException(
"(RoutableViewModelManager.Get<>) Not resolve {0}".StringFormat(viewModelType));
}
var disposable = new DisposableObject();
Action disposeAction = () =>
{
exportFactoryInstantiator.DisposeOnDemand();
disposable.Dispose();
};
if (_destroyObservable != null)
{
disposable.Add(_destroyObservable.Subscribe(_ => disposeAction()));
}
else
{
disposable.Add(
_screen.Router.NavigationStack.ItemsRemoved.Where(
viewModel => object.ReferenceEquals(viewModel, exportFactoryInstantiator.Instance))
.Subscribe(viewModel => disposeAction()));
}
var resolvedViewModel = exportFactoryInstantiator.Instance;
return(resolvedViewModel);
}
public override void Intercept(IPlanReceiptOrderViewModel interceptableObject)
{
lock (_locker) {
_weakReference = new WeakReference(interceptableObject);
_disposableObject.Dispose();
_disposableObject.Add(Listen());
}
}
public void SetSetting(ColorSetting setting)
{
_colorSetting = setting;
Color = setting.Accent;
Theme = setting.Theme;
_disposableObject.Dispose();
_disposableObject.Add(this.Binding());
}
public DocumentManagerViewModel(
IRoutableViewModelManager routableViewModelManager,
IValidatorFactory validatorFactory)
{
_routableViewModelManager = routableViewModelManager;
_validator = validatorFactory.GetValidator <CertificateQualityAttachedDocument>();
_disposableObject.Add(Binding());
ApplyInsertCommand = CreateApplyCommand();
}
public override void Intercept(IActSelectionOfProbeViewModel interceptableObject)
{
lock (_locker)
{
_weakReference = new WeakReference(interceptableObject);
_disposableObject.Dispose();
_disposableObject.Add(this.Listen());
}
}
public override void Intercept(IPlanCertificateViewModel interceptableObject)
{
lock (_locker)
{
_weakReference = new WeakReference(interceptableObject);
_disposableObject.Dispose();
_disposableObject.Add(this.Listen());
}
}
public static IDisposable ListenUpdatedMessage <TEntity, TConvertType>(
this IMessageBus messageBus,
IObservable <IList <TConvertType> > observable,
Action <TConvertType> action = null)
where TConvertType : IHasUid <long>
{
var disposable = new DisposableObject();
IList <TConvertType> collection = null;
disposable.Add(observable.Subscribe(result => collection = result));
disposable.Add(
ListenUpdatedMessage <TEntity>(
messageBus,
entity =>
{
if (collection == null)
{
return;
}
var newLiteDto = entity.MapTo <TConvertType>();
var oldLiteDto = collection.FirstOrDefault(x => x.Rn == newLiteDto.Rn);
int index = collection.IndexOf(oldLiteDto);
collection.Remove(oldLiteDto);
collection.Insert(index, newLiteDto);
if (action != null)
{
action(newLiteDto);
}
}));
return(disposable);
}
public PermissionMaterialViewModel(
IScreen screen,
IMessenger messenger,
IMessageBus messageBus,
IUnitOfWorkFactory unitOfWorkFactory,
IFilterViewModelFactory filterViewModelFactory,
IRoutableViewModelManager routableViewModelManager
)
{
HostScreen = screen;
_messageBus = messageBus;
_unitOfWorkFactory = unitOfWorkFactory;
_filterViewModelFactory = filterViewModelFactory;
_routableViewModelManager = routableViewModelManager;
_disposables.Add(ListenMessage().Concat(Binding()));
PermissionMaterialFilterViewModel.InvokeCommand.Execute(null);
}
public void Init(IBindableView view)
{
var disposableObject = new DisposableObject();
disposableObject.Add(view.Binding());
IDisposable disposable = Disposable.Empty;
disposable = view.DisposableNotification().Subscribe(
_ =>
{
disposable.Dispose();
disposableObject.Dispose();
DisposableObject obj;
_dictionary.TryRemove(view, out obj);
});
_dictionary.TryAdd(view, disposableObject);
}
private void ReBind()
{
_disposableObject.Dispose();
_disposableObject.Add(Binding());
}
