protected override void OnInitialize()
{
base.OnInitialize();
ProductInfo = new ProductInfo(this, CurrentLine.OfType <BaseOffer>());
OrderWarning = new InlineEditWarning(UiScheduler, Manager);
//если это отправленный заказ редактор не должен работать
var currentOrderLine = new NotifyValue <OrderLine>();
if (IsCurrentOrder)
{
currentOrderLine = CurrentLine.Select(v => (OrderLine)v).ToValue();
currentOrderLine.Subscribe(v => CurrentLine.Value = v);
}
editor = new Editor(OrderWarning, Manager, currentOrderLine, Lines.Cast <IList>().ToValue());
OnlyWarningVisible = new NotifyValue <bool>(User.IsPreprocessOrders && IsCurrentOrder);
CurrentLine.OfType <BaseOffer>()
.Throttle(Consts.LoadOrderHistoryTimeout, Scheduler)
.Select(x => RxQuery(s => BaseOfferViewModel.LoadOrderHistory(s, Cache, Settings.Value, x, Address)))
.Switch()
.Subscribe(HistoryOrders, CloseCancellation.Token);
FilterItems.Select(p => p.Changed()).Merge().Throttle(Consts.FilterUpdateTimeout, UiScheduler)
.Select(_ => Filter())
.Subscribe(Lines, CloseCancellation.Token);
}
private IList <IOrderLine> Filter()
{
var selected = FilterItems.Where(p => p.IsSelected).Select(p => p.Item.Item1).ToArray();
if (selected.Count() != FilterItems.Count())
{
var ids = new List <uint>();
var lines = Source.OfType <OrderLine>();
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)).OrderBy(l => l.ProducerSynonym).LinkTo(Source));
}
return(Source);
}
public static void PlayVoice(FilterItems Filter, Item Item)
{
string NameToRead = Item.ItemActor.x004_Name;
if (Item.ItemQuality == ItemQuality.Legendary)
{
try
{
UniqueItem Legendary = UniqueItemsController.TryGet(Item.SNOItem.ActorName.ToLower());
NameToRead = (Item.AncientItem) ? "Ancient" + Legendary.ItemName : Legendary.ItemName;
}
catch
{
// Unknown legendary...
}
}
System.Threading.Thread Thread = new System.Threading.Thread(() =>
{
using (SpeechSynthesizer synthesizer = new SpeechSynthesizer())
{
synthesizer.Volume = 100;
synthesizer.Rate = 0;
synthesizer.SetOutputToDefaultAudioDevice();
synthesizer.Speak(NameToRead);
}
});
Thread.Start();
}
public void CreateFilter()
{
//_root.SubMenuContainerSelectorContainer.Visibility = Visibility.Visible;
int ID = Config.Get <FKFilters>().Filters.Count + 1;
try
{
Config.Get <FKFilters>().Filters.Add(new FilterItems
{
AttributesFilter = new HashSet <int>(Enum.GetValues(typeof(Controller.Pickit.Attributes.ItemType)).Cast <int>().ToArray()),
Enabled = true,
ID = ID,
Name = "My Filter " + ID,
Quality = Controller.Enums.ItemQuality.Legendary,
SoundId = 0,
OverlayIngame = true
});
Item = Config.Get <FKFilters>().Filters.Last();
SetFilters();
_root.DrawSubMenu();
//_root.LoadPage(new General(this), null);
}
catch (Exception e)
{
MessageBox.Show(e.ToString());
}
}
public void RemoveFilterItem(string propertyName)
{
if (FilterItems != null)
{
FilterItems = FilterItems.Where(m => m.PropertyName != propertyName).ToList();
}
}
public IHttpActionResult GetItemByClient(BaseCondition <RoomResult> condition, int HotelId)
{
ApiResult <HotelResult> rs = hotelDAL.GetItemByClient(HotelId);
if (condition == null)
{
condition = new BaseCondition <RoomResult>()
{
PageIndex = 1,
PageSize = 10,
};
}
;
condition.FilterRules = new List <FilterItems>();
FilterItems FilterItems = new FilterItems
{
field = "R.HotelId",
op = "=",
value = HotelId.ToString()
};
condition.FilterRules.Add(FilterItems);
ApiResult <RoomResult> ListRoom = roomDAL.GetPaging(condition);
if (ListRoom.Succeeded)
{
rs.Data.ListRoom = ListRoom.DataList;
rs.TotalRecords = ListRoom.TotalRecords;
}
if (!rs.Succeeded)
{
return(Content(HttpStatusCode.BadRequest, rs));
}
return(Ok(rs));
}
private bool IsReverse(IReadOnlyDictionary <string, string> param, FilterItem filterItem)
{
if (filterItem.Name == FilterItems.StartDate().Name)
{
return(true);
}
return(false);
}
public void Dispose()
{
FilterItems.Clear();
foreach (var ownedFilterItem in m_ownedFilterItems)
{
ownedFilterItem.Dispose();
}
m_ownedFilterItems.Clear();
}
public void DeleteFilter()
{
int ID = Item.ID;
Config.Get <FKFilters>().Filters.Remove(Item);
Item = Config.Get <FKFilters>().Filters.Find(x => x.ID == ID - 1);
SetFilters();
_root.DrawSubMenu();
//_root.LoadPage(new General(this), null);
}
private static void ProcessFilterItems(FilterItems fis, XmlWriter xmlw)
{
xmlw.WriteStartElement("FilterItems");
xmlw.WriteAttributeString("Count", fis.Count.ToStringSafe());
foreach (FilterItem fi in fis)
{
ProcessFilterItem(fi, xmlw);
}
xmlw.WriteEndElement();
}
public string GetFilterItemValue(string propertyName)
{
if (FilterItems == null)
{
return(string.Empty);
}
var filterItem = FilterItems.FirstOrDefault(m => m.PropertyName == propertyName);
return(filterItem != null ? filterItem.PropertyValue : string.Empty);
}
private void _Set(FilterItems item)
{
try{
Item = Config.Get <FKFilters>().Filters.Single(x => x.ID == item.ID && x.Name == item.Name);
_root.LoadPage(_root.Page, null);
_root.xSelected.Content = Item.Name;
}
catch {
MessageBox.Show("Couldn't not change active filter, please check your config file");
}
}
public void RecordRemoved(IDataRecord record)
{
if (record == GraphData)
{
return;
}
List <GraphItemViewModel> removeList = new List <GraphItemViewModel>();
var filterItem = record as FilterItem;
if (filterItem != null)
{
var node = filterItem.Node;
if (node != null)
{
foreach (var item in GraphItems)
{
if (item.DataObject == node)
{
removeList.Add(item);
removeList.AddRange(item.Connectors.OfType <GraphItemViewModel>());
}
}
}
if (FilterItems.ContainsKey(filterItem.NodeId))
{
FilterItems.Remove(filterItem.NodeId);
}
}
else
{
for (int index = 0; index < GraphItems.Count; index++)
{
var item = GraphItems[index];
if (item.DataObject == record)
{
removeList.Add(item);
removeList.AddRange(item.Connectors.OfType <GraphItemViewModel>());
}
item.RecordRemoved(record);
}
}
foreach (var remove in removeList)
{
GraphItems.Remove(remove);
}
if (removeList.Count > 0)
{
RefreshConnectors();
}
}
private static void ProcessFilterItems(FilterItems fis, Utf8JsonWriter jsonw)
{
jsonw.WritePropertyName("FilterItems");
jsonw.WriteStartObject();
jsonw.WriteString("Count", fis.Count.ToStringSafe());
jsonw.WritePropertyName("Items");
jsonw.WriteStartArray();
foreach (FilterItem fi in fis)
{
ProcessFilterItem(fi, jsonw);
}
jsonw.WriteEndArray();
jsonw.WriteEndObject();
}
public IHttpActionResult GetPaging(BaseCondition <RoomResult> condition)
{
List <FilterItems> FilterRules = condition.FilterRules;
List <SortItems> SortRules = condition.SortRules;
if (FilterRules != null && FilterRules.Count > 0)
{
foreach (var item in FilterRules.Select((value, i) => new { i, value }))
{
FilterItems e = item.value;
int Index = item.i;
if (e.field == "HotelName")
{
condition.FilterRules[Index].field = "H.Name";
}
else
{
condition.FilterRules[Index].field = "R." + e.field;
}
}
}
if (SortRules != null && SortRules.Count > 0)
{
foreach (var item in SortRules.Select((value, i) => new { i, value }))
{
SortItems e = item.value;
int Index = item.i;
if (e.field == "HotelName")
{
condition.FilterRules[Index].field = "H.Name";
}
else
{
condition.FilterRules[Index].field = "R." + e.field;
}
}
}
var req = roomDAL.GetPaging(condition);
if (req.Succeeded)
{
return(Ok(req));
}
else
{
return(Content(HttpStatusCode.BadRequest, req));
}
}
private void ConfigureFilters()
{
HasFilter(new CommonFilterConfiguration(FilterItems.RegionOrCluster()));
HasFilter(new CommonFilterConfiguration(FilterItems.Country()));
HasFilter(new CommonFilterConfiguration(FilterItems.Products()));
HasFilter(new CommonFilterConfiguration(FilterItems.SubProducts()));
HasFilter(new CommonFilterConfiguration(FilterItems.Segment()));
HasFilter(new CommonFilterConfiguration(FilterItems.Forms()));
HasFilter(new CommonFilterConfiguration(FilterItems.KPI()));
HasFilter(new CommonFilterConfiguration(FilterItems.UnitOrValue()));
HasFilter(new OnOffFilterConfiguration(FilterItems.TimePeriod()));
HasFilter(new CommonFilterConfiguration(FilterItems.StartDate()));
HasFilter(new CommonFilterConfiguration(FilterItems.EndDate()));
}
public void SetState(object sender)
{
FilterItems Item = (FilterItems)((Image)sender).Tag;
FilterItems Real = null;
if (Config.Get <FKFilters>().Filters.Exists(x => x.ID == Item.ID))
{
Real = Config.Get <FKFilters>().Filters.Find(x => x.ID == Item.ID);
}
bool NewState = Item.Enabled ? false : true;
Item.Enabled = NewState;
Real.Enabled = NewState;
((Image)sender).Source = Extensions.FKImage(NewState ? "checked" : "_checked");
}
public void Execute()
{
var apple = new Product("Apple", Color.Green, Size.Small);
var ball = new Product("Ball", Color.Green, Size.Small);
var tree = new Product("Tree", Color.Green, Size.Large);
var cooperS = new Product("Mini-Cooper S", Color.Red, Size.Large);
Product[] products = { apple, tree, cooperS, ball };
var filterItems = new FilterItems();
Console.WriteLine("Green products:");
foreach (var product in filterItems.Filter(products, new ColorSpecification(Color.Green)))
{
Console.WriteLine($" - {product.Name} is green");
}
Console.WriteLine();
Console.WriteLine("Green and small products");
foreach (var product in filterItems.Filter(products,
new GreenAndSmallSpecification(
new ColorSpecification(Color.Green),
new SizeSpecification(Size.Small))))
{
Console.WriteLine($" - {product.Name} is green and small");
}
Console.WriteLine();
Console.WriteLine("Green cars");
var carFilter = new FilterCars();
var bentley = new Car("Bentley", Color.Green);
var shevyCamaro = new Car("Shevy Camaro", Color.Green);
var astonMartin = new Car("Aston Martin", Color.Black);
Car[] cars = { bentley, shevyCamaro, astonMartin };
foreach (var car in carFilter.Filter(cars, new CarColorSpecification(Color.Green)))
{
Console.WriteLine($" - {car.Name} is a green car");
}
Console.ReadLine();
}
public async Task <SearchResponse <T> > CreateResponse <T>(IQueryable <T> query, IEnumerable <IFilterItemStrategy <T> > filterItemStrategies)
{
if (FilterItems != null)
{
var predicate = await FilterItems.GetPredicate(filterItemStrategies);
if (predicate != null)
{
query = query.Where(predicate);
}
}
var response = new SearchResponse <T>();
query = await PaginateQuery(query, response);
response.Items = await query.ToListAsync();
return(response);
}
public override void ComposeFilters(IEnumerable <User> users)
{
var batches = users
.SelectMany(u => u.UserCourses.Distinct(new UserCourseComparer()))
.Select(u => u.Batch);
var currUser = users.SingleOrDefault(u => u.UserId == UserSession.CurrentUserId);
if (currUser != null && currUser.UserCourses.Any())
{
var tempShowAll = ShowAll;
ShowAll = true;
ComposeFilterItems(batches);
var batch = currUser.UserCourses[0].Batch;
var bactchInt = int.Parse(batch);
var batch3 = (bactchInt + 2).ToString();
var batch1 = (bactchInt + 1).ToString();
var batch2 = (bactchInt - 1).ToString();
FilterItems = FilterItems
.OrderByDescending(f => f.ValueText == batch2)
.OrderByDescending(f => f.ValueText == batch3)
.OrderByDescending(f => f.ValueText == batch1)
.OrderByDescending(f => f.ValueText == batch)
.ToList();
if (!tempShowAll)
{
var finalquery = FilterItems.Take(_dispFilterCnt);
var checkedSkiped = FilterItems.Skip(_dispFilterCnt)
.Where(l => l.IsChecked);
finalquery = finalquery.Concat(checkedSkiped);
FilterItems = finalquery.ToList();
}
ShowAll = tempShowAll;
MasterFilters = FilterItems;
}
else
{
ComposeFilterItems(batches);
}
}
public static void Play(FilterItems Filter, int MultiboxID = -1)
{
// if (Filter.Sound.Exists(x => x.ProcessID == MultiboxID))
// Play(Filter.Sound.Find(x => x.ProcessID == MultiboxID).URI);
}
public void AddRange(List <FilterItemModel> filterItems)
{
FilterItems.AddRange(filterItems);
}
internal ImmutableList <SqlFilterItemCallback> AddItem(SqlFilterItemCallback item) => FilterItems.Count == 0 ? FilterItems : FilterItems.Add(item);
public FilterModel(List <FilterItemModel> filterItems)
{
FilterItems.AddRange(filterItems);
}
public void Add(FilterItemModel filterItem)
{
FilterItems.Add(filterItem);
}
public FilterModel(FilterItemModel filterItem)
{
FilterItems.Add(filterItem);
}
public void Remove(FilterItems Item)
{
System.Windows.MessageBox.Show(Item.Name);
}
public FilterTypeViewComponent(FagElGamousContext context, FilterItems ft)
{
_context = context;
_filtered = ft;
}
public IEnumerable <Item> GetWithFilter([FromQuery] FilterItems filter)
{
return(items.Where(i => i.Quantity >= filter.LowQuantity && i.Quantity <= filter.HighQuantity));
}
public Expression <Func <T, bool> > GetExpression <T>() where T : class
{
ParameterExpression param = Expression.Parameter(typeof(T), "arg");
if (FilterItems?.Count > 0)
{
List <Expression> expList = new List <Expression>();
FilterItems.ToList().ForEach(listItens =>
{
if (listItens.Itens.Count > 0)
{
List <Expression> expListItem = new List <Expression>();
listItens.Itens.ForEach(item =>
{
Expression name = null;
if (item.Field.Contains("."))
{
string[] splits = item.Field.Split('.');
name = param;
foreach (string part in splits)
{
name = Expression.Property(name, part);
}
}
else
{
name = Expression.Property(param, item.Field);
}
Type type = name.Type;
Expression value = null;
value = GetValueConstant(item.ValueOne, type);
MethodInfo toLower = typeof(string).GetMethod("ToLower", Type.EmptyTypes);
Expression expLower = null;
if (!type.FullName.ToLower().Contains("guid") &&
!type.FullName.ToLower().Contains("bool") &&
!type.FullName.ToLower().Contains("int") &&
!type.FullName.ToLower().Contains("decimal") &&
!type.FullName.ToLower().Contains("datetime") &&
!type.GetTypeInfo().IsEnum)
{
expLower = Expression.Call(name, toLower);
}
Expression clausule = null;
switch (item.Clausule)
{
case "Contains":
clausule = Expression.Call(expLower, type.GetMethod(item.Clausule, new[] { type }), value);
break;
case "StartsWith":
clausule = Expression.Call(expLower, type.GetMethod(item.Clausule, new[] { type }), value);
break;
case "EndsWith":
clausule = Expression.Call(expLower, type.GetMethod(item.Clausule, new[] { type }), value);
break;
case "GreaterThanOrEqual":
clausule = Expression.GreaterThanOrEqual(name, value);
break;
case "LessThanOrEqual":
clausule = Expression.LessThanOrEqual(name, value);
break;
case "Equal":
clausule = Expression.Equal(expLower ?? name, value);
break;
case "NotEqual":
clausule = Expression.NotEqual(expLower ?? name, value);
break;
case "Between":
Expression valueTwo = GetValueConstant(item.ValueTwo, type);
BinaryExpression expL = Expression.GreaterThanOrEqual(name, value);
BinaryExpression expR = Expression.LessThanOrEqual(name, valueTwo);
clausule = Expression.And(expL, expR);
break;
default:
throw new Exception("Invalid Clausule");
}
if (expLower != null)
{
BinaryExpression expL = Expression.NotEqual(name, Expression.Constant(null));
clausule = Expression.AndAlso(expL, clausule);
}
expListItem.Add(clausule);
});
Expression expItem = null;
expListItem.ForEach(e =>
{
if (expItem == null)
{
expItem = e;
}
else
{
expItem = Expression.Or(e, expItem);
}
});
if (expItem != null)
{
expList.Add(expItem);
}
}
});
Expression exp = null;
if (expList.Count > 0)
{
foreach (Expression e in expList)
{
if (exp == null)
{
exp = e;
}
else
{
exp = Expression.And(e, exp);
}
}
}
if (exp != null)
{
return(Expression.Lambda <Func <T, bool> >(exp, param));
}
else
{
exp = Expression.Equal(param, param);
return(Expression.Lambda <Func <T, bool> >(exp, param));
}
}
else
{
BinaryExpression exp = Expression.Equal(param, param);
return(Expression.Lambda <Func <T, bool> >(exp, param));
}
}
