protected override void OnInitialize()
{
base.OnInitialize();
Begin.Merge(End).Skip(2).CatchSubscribe(_ => Update(), CloseCancellation);
IsSentSelected.Merge(IsDeletedSelected).Merge(IsCurrentSelected)
.Where(_ => IsCurrentSelected ^ IsSentSelected.Value ^ IsDeletedSelected.Value)
.CatchSubscribe(_ => Update(), CloseCancellation);
}
protected override void OnInitialize()
{
base.OnInitialize();
OnlyWarningVisible = IsCurrentSelected.Select(v => v && User.IsPreprocessOrders).ToValue();
ProductInfo = new ProductInfo(this, CurrentLine);
ProductInfo2 = new ProductInfo(this, SelectedSentLine);
AddressSelector.Init();
AddressSelector.FilterChanged
.Merge(Prices.Select(p => p.Changed()).Merge().Throttle(Consts.FilterUpdateTimeout, UiScheduler))
.Merge(DbReloadToken)
.Merge(OrdersReloadToken)
.Merge(FilterItems.Select(p => p.Changed()).Merge().Throttle(Consts.FilterUpdateTimeout, UiScheduler))
.Where(_ => IsCurrentSelected && Session != null)
.Select(_ =>
{
var orders = AddressSelector.GetActiveFilter().SelectMany(o => o.Orders)
.Where(x => Prices.Where(y => y.IsSelected).Select(y => y.Item.Id).Contains(x.Price.Id)).ToList();
var activeOrders = orders.Where(x => !x.Frozen).ToList();
var lines = activeOrders.SelectMany(o => o.Lines)
.OrderBy(l => l.Id)
.ToObservableCollection();
lines.Each(l => {
l.Settings = Settings;
l.Order.CalculateStyle(Address);
if (l.Order.IsAddressExists())
{
l.CalculateRetailCost(Settings.Value.Markups, Shell?.SpecialMarkupProducts.Value, User);
}
});
// #48323 Присутствует в замороженных заказах
var productInFrozenOrders = orders.Where(x => x.Frozen).SelectMany(x => x.Lines)
.Select(x => x.ProductId).Distinct().ToList();
lines.Where(x => productInFrozenOrders.Contains(x.ProductId))
.Each(x => x.InFrozenOrders = true);
var selected = FilterItems.Where(p => p.IsSelected).Select(p => p.Item.Item1).ToArray();
if (selected.Count() != FilterItems.Count())
{
var ids = new List <uint>();
if (selected.Contains("InFrozenOrders"))
{
ids.AddRange(lines.Where(x => x.InFrozenOrders).Select(x => x.Id));
}
if (selected.Contains("IsMinCost"))
{
ids.AddRange(lines.Where(x => x.IsMinCost).Select(x => x.Id));
}
if (selected.Contains("IsNotMinCost"))
{
ids.AddRange(lines.Where(x => !x.IsMinCost).Select(x => x.Id));
}
if (selected.Contains("OnlyWarning"))
{
ids.AddRange(lines.Where(x => x.SendResult != LineResultStatus.OK).Select(x => x.Id));
}
return(lines.Where(x => ids.Contains(x.Id)).ToObservableCollection());
}
return(lines);
})
.Subscribe(Lines, CloseCancellation.Token);
IsSentSelected.Where(v => v)
.Select(v => (object)v)
.Merge(Begin.Select(d => (object)d))
.Merge(End.Select(d => (object)d))
.Merge(Prices.Select(p => p.Changed()).Merge().Throttle(Consts.FilterUpdateTimeout, UiScheduler))
.Merge(AddressSelector.FilterChanged)
.Merge(DbReloadToken)
.Do(_ => { IsLoading.Value = true; })
//защита от множества запросов
.Throttle(TimeSpan.FromMilliseconds(30), Scheduler)
.Where(_ => IsSentSelected)
.Select(_ => RxQuery(s => {
var begin = Begin.Value;
var end = End.Value.AddDays(1);
var addressIds = AddressSelector.GetActiveFilter().Select(a => a.Id).ToArray();
var query = s.Query <SentOrderLine>()
.Fetch(l => l.Order)
.ThenFetch(o => o.Address)
.Fetch(o => o.Order)
.ThenFetch(o => o.Price)
.Where(l => l.Order.SentOn > begin && l.Order.SentOn < end)
.Where(l => addressIds.Contains(l.Order.Address.Id));
query = Util.Filter(query, l => l.Order.Price.Id, Prices);
var lines = query.OrderBy(l => l.ProductSynonym)
.ThenBy(l => l.ProductSynonym)
.Take(1000)
.ToList();
if (Settings.Value.HighlightUnmatchedOrderLines)
{
var lookup = MatchedWaybills.GetLookUp(s, lines);
lines.Each(l => l.Order.CalculateStyle(Address));
lines.Each(l => l.Configure(User, lookup));
}
else
{
lines.Each(l => l.Order.CalculateStyle(Address));
lines.Each(l => l.Configure(User));
}
return(lines);
}))
.Switch()
.Do(_ => IsLoading.Value = false)
.Subscribe(SentLines, CloseCancellation.Token);
CurrentLine
.Throttle(Consts.ScrollLoadTimeout, UiScheduler)
.Merge(DbReloadToken)
.Subscribe(_ => UpdateAsync(), CloseCancellation.Token);
CurrentLine
.Throttle(Consts.LoadOrderHistoryTimeout, Scheduler)
.SelectMany(x => Env.RxQuery(s => LoadOrderHistory(s, Cache, Settings.Value, x, ActualAddress)))
.Subscribe(HistoryOrders, CloseCancellation.Token);
}
public OrdersViewModel()
{
DisplayName = "Заказы";
InitFields();
AddressSelector = new AddressSelector(this);
SelectedOrders = new List <Order>();
SelectedSentOrders = new List <SentOrder>();
SelectedDeletedOrders = new List <DeletedOrder>();
deletedOrders = new ReactiveCollection <DeletedOrder>();
OnCloseDisposable.Add(this.ObservableForProperty(m => (object)m.CurrentOrder)
.Merge(this.ObservableForProperty(m => (object)m.IsCurrentSelected.Value))
.Subscribe(_ => {
SetAddressesToMove();
NotifyOfPropertyChange(nameof(CanDelete));
NotifyOfPropertyChange(nameof(CanFreeze));
NotifyOfPropertyChange(nameof(CanUnfreeze));
NotifyOfPropertyChange(nameof(CanReorder));
NotifyOfPropertyChange(nameof(CanMove));
}));
OnCloseDisposable.Add(IsSentSelected
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(RestoreOrderVisible));
NotifyOfPropertyChange(nameof(CanReorder));
NotifyOfPropertyChange(nameof(EditableOrder));
}));
OnCloseDisposable.Add(IsCurrentSelected
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(FreezeVisible));
NotifyOfPropertyChange(nameof(UnfreezeVisible));
NotifyOfPropertyChange(nameof(MoveVisible));
NotifyOfPropertyChange(nameof(EditableOrder));
}));
OnCloseDisposable.Add(IsDeletedSelected
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(UnDeleteVisible));
NotifyOfPropertyChange(nameof(ReorderVisible));
}));
OnCloseDisposable.Add(this.ObservableForProperty(m => m.CurrentDeletedOrder)
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(CanDelete));
NotifyOfPropertyChange(nameof(CanUnDelete));
}));
OnCloseDisposable.Add(this.ObservableForProperty(m => m.CurrentSentOrder)
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(CanDelete));
NotifyOfPropertyChange(nameof(CanRestoreOrder));
NotifyOfPropertyChange(nameof(CanReorder));
}));
OnCloseDisposable.Add(this.ObservableForProperty(m => m.CurrentOrder.Frozen)
.Subscribe(_ => {
NotifyOfPropertyChange(nameof(CanFreeze));
NotifyOfPropertyChange(nameof(CanUnfreeze));
}));
var ordersChanged = this.ObservableForProperty(m => m.Orders);
var update = ordersChanged
.SelectMany(e => e.Value.ItemChanged.Cast <Object>().Merge(e.Value.Changed));
var observable = ordersChanged.Cast <object>()
.Merge(update)
.Throttle(Consts.RefreshOrderStatTimeout, UiScheduler)
.Select(e => new Stat(Address));
OnCloseDisposable.Add(Bus.RegisterMessageSource(observable));
IsCurrentSelected
.Select(v => v ? "Orders" : "SentOrders")
.Subscribe(ExcelExporter.ActiveProperty);
PrintMenuItems = new ObservableCollection <MenuItem>();
IsView = true;
}
public OrderLinesViewModel()
{
DisplayName = "Сводный заказ";
InitFields();
Lines = new NotifyValue <ObservableCollection <OrderLine> >(new ObservableCollection <OrderLine>());
SentLines = new NotifyValue <List <SentOrderLine> >(new List <SentOrderLine>());
IsCurrentSelected = new NotifyValue <bool>(true);
Begin = new NotifyValue <DateTime>(DateTime.Today.AddMonths(-3).FirstDayOfMonth());
End = new NotifyValue <DateTime>(DateTime.Today);
AddressSelector = new AddressSelector(this);
FilterItems = new List <Selectable <Tuple <string, string> > >();
FilterItems.Add(new Selectable <Tuple <string, string> >(Tuple.Create("InFrozenOrders", "Позиции присутствуют в замороженных заказах")));
FilterItems.Add(new Selectable <Tuple <string, string> >(Tuple.Create("IsMinCost", "Позиции по мин.ценам")));
FilterItems.Add(new Selectable <Tuple <string, string> >(Tuple.Create("IsNotMinCost", "Позиции не по мин.ценам")));
FilterItems.Add(new Selectable <Tuple <string, string> >(Tuple.Create("OnlyWarning", "Только позиции с корректировкой")));
CanDelete = CurrentLine.CombineLatest(IsCurrentSelected, (l, s) => l != null && s).ToValue();
BeginEnabled = IsSentSelected.ToValue();
EndEnabled = IsSentSelected.ToValue();
IsCurrentSelected.Subscribe(_ => NotifyOfPropertyChange(nameof(CanPrint)));
IsCurrentSelected.Subscribe(_ => NotifyOfPropertyChange(nameof(CanExport)));
Sum = new NotifyValue <decimal>(() => {
if (IsCurrentSelected)
{
return(Lines.Value.Sum(l => l.MixedSum));
}
return(SentLines.Value.Sum(l => l.MixedSum));
}, SentLines, Lines, IsCurrentSelected);
OrderWarning = new InlineEditWarning(UiScheduler, Manager);
QuickSearch = new QuickSearch <OrderLine>(UiScheduler,
s => Lines.Value.FirstOrDefault(l => l.ProductSynonym.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0),
CurrentLine);
QuickSearch2 = new QuickSearch <SentOrderLine>(UiScheduler,
s => SentLines.Value.FirstOrDefault(l => l.ProductSynonym.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0),
SelectedSentLine);
Editor = new Editor(OrderWarning, Manager, CurrentLine, Lines.Cast <IList>().ToValue());
var currentLinesChanged = this.ObservableForProperty(m => m.CurrentLine.Value.Count)
.Throttle(Consts.RefreshOrderStatTimeout, UiScheduler)
.Select(e => new Stat(Address));
OnCloseDisposable.Add(Bus.RegisterMessageSource(currentLinesChanged));
OnCloseDisposable.Add(currentLinesChanged.Subscribe(_ => Sum.Recalculate()));
Settings.Subscribe(_ => CalculateOrderLine());
if (Session != null)
{
Prices = Session.Query <Price>().OrderBy(p => p.Name).ToList()
.Select(p => new Selectable <Price>(p))
.ToList();
}
else
{
Prices = new List <Selectable <Price> >();
}
MatchedWaybills = new MatchedWaybills(this, SelectedSentLine, IsSentSelected);
IsCurrentSelected
.Select(v => v ? "Lines" : "SentLines")
.Subscribe(ExcelExporter.ActiveProperty);
Observable.Merge(IsCurrentSelected.Select(x => (object)x), Lines, SentLines, currentLinesChanged)
.Select(_ => {
if (IsCurrentSelected)
{
return(Lines.Value?.Count ?? 0);
}
return(SentLines.Value?.Count ?? 0);
})
.Subscribe(LinesCount);
IsLoading = new NotifyValue <bool>();
IsCurrentSelected.Where(v => v)
.Select(_ => false)
.Subscribe(IsLoading);
SessionValue(Begin, GetType().Name + ".Begin");
SessionValue(End, GetType().Name + ".End");
SessionValue(IsSentSelected, GetType().Name + ".IsSentSelected");
Persist(IsExpanded, "IsExpanded");
PrintMenuItems = new ObservableCollection <MenuItem>();
IsView = true;
}
