private void CheckFurtherFusions(List <Card> hand)
{
var temp = new ObservableCollection <Combination>();
foreach (var item in AvailableCombinations)
{
foreach (var card in hand)
{
var test = Associations.Where(e => e.FirstCard == item.FusionResult && hand.Contains(e.FirstCard));
}
//var yolo = Associations.Where(j => hand.Any(o => o == j.FirstCard));
var tes1t = Associations.Where(e => e.FirstCard.Name == item.FusionResult.Name && hand.Exists(p => p.Name == e.SecondCard.Name)).ToList();
if (tes1t != null)
{
temp = new ObservableCollection <Combination>(temp.Concat(tes1t));
}
var testing = Associations.Where(n => n.FirstCard.Name == hand.Find(e => e.Name == n.FirstCard.Name).Name&& n.SecondCard.Name == item.FusionResult.Name); //
//if(Associations.Where(e => e.FirstCard == item.FusionResult) != null && Associations.Where(a => a.SecondCard == item.SecondCard) != null)
if (Associations.Exists(n => n.SecondCard == item.FirstCard && n.FirstCard == item.FusionResult))
{
var test = Associations.Where(n => n.SecondCard == item.SecondCard && n.FirstCard == item.FusionResult).FirstOrDefault();
temp.Add(Associations.Where(n => n.SecondCard == item.SecondCard && n.FirstCard == item.FusionResult).FirstOrDefault());
}
}
AvailableCombinations = new ObservableCollection <Combination>(AvailableCombinations.Concat(temp));
}
public dataModel.Item[] GetItemByIds(string[] itemIds, coreModel.ItemResponseGroup respGroup = coreModel.ItemResponseGroup.ItemLarge)
{
if (!itemIds.Any())
{
return(new dataModel.Item[] { });
}
//Used breaking query EF performance concept https://msdn.microsoft.com/en-us/data/hh949853.aspx#8
var retVal = Items.Include(x => x.Catalog).Include(x => x.Category).Include(x => x.Images).Where(x => itemIds.Contains(x.Id)).ToArray();
if ((respGroup & coreModel.ItemResponseGroup.Categories) == coreModel.ItemResponseGroup.Categories)
{
var relations = CategoryItemRelations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if ((respGroup & coreModel.ItemResponseGroup.ItemProperties) == coreModel.ItemResponseGroup.ItemProperties)
{
var propertyValues = ItemPropertyValues.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if ((respGroup & coreModel.ItemResponseGroup.ItemAssets) == coreModel.ItemResponseGroup.ItemAssets)
{
var assets = Assets.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if ((respGroup & coreModel.ItemResponseGroup.ItemEditorialReviews) == coreModel.ItemResponseGroup.ItemEditorialReviews)
{
var editorialReviews = EditorialReviews.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if ((respGroup & coreModel.ItemResponseGroup.ItemAssociations) == coreModel.ItemResponseGroup.ItemAssociations)
{
var associations = Associations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if ((respGroup & coreModel.ItemResponseGroup.Variations) == coreModel.ItemResponseGroup.Variations)
{
var variationIds = Items.Where(x => itemIds.Contains(x.ParentId)).Select(x => x.Id).ToArray();
var variations = GetItemByIds(variationIds, respGroup);
}
//Load parents
var parentIds = retVal.Where(x => x.Parent == null && x.ParentId != null).Select(x => x.ParentId).ToArray();
var parents = GetItemByIds(parentIds, respGroup);
return(retVal);
}
private void _RegisterType(Type root, params Type[] related)
{
//+ Validate types.
if (root.IsInterface || related.Count(a => a.IsInterface) > 0)
{
throw new NotSupportedException("Interfaces can not be serialized");
}
// Add missing associations
lock (Associations)
{
// root types
IEnumerable <Type> r = new List <Type>(related);
// related children
foreach (Type t in related)
{
r = r.Union(from z in t.GetTypes(
(c, d) => d.IsSubclassOf(c) &&
!d.IsAbstract &&
!d.IsGenericTypeDefinition
, Assemblies.Values.ToArray())
select z);
}
var x = from i in r.Distinct()
join j in Associations.Where(a => a.Key.Item1 == root.FullName)
on i.FullName equals j.Key.Item2 into outer
from k in outer.DefaultIfEmpty()
where k.Key == null
select new
{
k = new Tuple <string, string>(root.FullName, i.FullName),
v = i
};
foreach (var i in x)
{
Associations.Add(i.k, i.v);
}
}
}
public dataModel.Item[] GetItemByIds(string[] itemIds, coreModel.ItemResponseGroup respGroup = coreModel.ItemResponseGroup.ItemLarge)
{
if (itemIds == null)
{
throw new ArgumentNullException("itemIds");
}
if (!itemIds.Any())
{
return(new dataModel.Item[] { });
}
// Use breaking query EF performance concept https://msdn.microsoft.com/en-us/data/hh949853.aspx#8
var retVal = Items.Include(x => x.Images).Where(x => itemIds.Contains(x.Id)).ToArray();
var propertyValues = PropertyValues.Where(x => itemIds.Contains(x.ItemId)).ToArray();
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Outlines))
{
respGroup |= coreModel.ItemResponseGroup.Links;
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Links))
{
var relations = CategoryItemRelations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemAssets))
{
var assets = Assets.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemEditorialReviews))
{
var editorialReviews = EditorialReviews.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Variations))
{
// TODO: Call GetItemByIds for variations recursively (need to measure performance and data amount first)
var variationIds = Items.Where(x => itemIds.Contains(x.ParentId)).Select(x => x.Id).ToArray();
// Always load info, images and property values for variations
var variations = Items.Include(x => x.Images).Where(x => variationIds.Contains(x.Id)).ToArray();
var variationPropertyValues = PropertyValues.Where(x => variationIds.Contains(x.ItemId)).ToArray();
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemAssets))
{
var variationAssets = Assets.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemEditorialReviews))
{
var variationEditorialReviews = EditorialReviews.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemAssociations))
{
var assosiations = Associations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
var assosiatedProductIds = assosiations.Where(x => x.AssociatedItemId != null)
.Select(x => x.AssociatedItemId).Distinct().ToArray();
var assosiatedItems = GetItemByIds(assosiatedProductIds, coreModel.ItemResponseGroup.ItemInfo | coreModel.ItemResponseGroup.ItemAssets);
}
// Load parents
var parentIds = retVal.Where(x => x.Parent == null && x.ParentId != null).Select(x => x.ParentId).ToArray();
var parents = GetItemByIds(parentIds, respGroup);
return(retVal);
}
public dataModel.Item[] GetItemByIds(string[] itemIds, coreModel.ItemResponseGroup respGroup = coreModel.ItemResponseGroup.ItemLarge)
{
if (itemIds == null)
{
throw new ArgumentNullException("itemIds");
}
if (!itemIds.Any())
{
return(new dataModel.Item[] { });
}
// Use breaking query EF performance concept https://msdn.microsoft.com/en-us/data/hh949853.aspx#8
var retVal = Items.Include(x => x.Images).Where(x => itemIds.Contains(x.Id)).ToArray();
var propertyValues = PropertyValues.Where(x => itemIds.Contains(x.ItemId)).ToArray();
// Load product catalogs separately
var catalogIds = retVal.Select(x => x.CatalogId).Distinct().ToArray();
var catalogs = Catalogs.Include(x => x.CatalogLanguages).Where(x => catalogIds.Contains(x.Id)).ToArray();
// Load product categories separately
var categoryIds = retVal.Select(x => x.CategoryId).Where(x => !string.IsNullOrEmpty(x)).Distinct().ToArray();
var categoriesReponseGroup = coreModel.CategoryResponseGroup.WithParents;
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Outlines))
{
categoriesReponseGroup |= coreModel.CategoryResponseGroup.WithLinks | coreModel.CategoryResponseGroup.WithParents;
respGroup |= coreModel.ItemResponseGroup.Links;
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemProperties))
{
// Load categories with all properties for property inheritance
categoriesReponseGroup |= coreModel.CategoryResponseGroup.WithProperties;
}
var categories = GetCategoriesByIds(categoryIds, categoriesReponseGroup);
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Links))
{
var relations = CategoryItemRelations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
var allForeignCatalogsIds = relations.Where(x => x.CategoryId == null && x.CatalogId != null)
.Select(x => x.CatalogId).Distinct().ToArray();
var allForeginCategoriesIds = relations.Where(x => x.CategoryId != null)
.Select(x => x.CategoryId).Distinct().ToArray();
if (!allForeginCategoriesIds.IsNullOrEmpty())
{
var linkedCategories = GetCategoriesByIds(allForeginCategoriesIds.ToArray(), coreModel.CategoryResponseGroup.WithLinks | coreModel.CategoryResponseGroup.WithParents);
}
if (!allForeignCatalogsIds.IsNullOrEmpty())
{
var linkedCatalogs = Catalogs.Include(x => x.CatalogLanguages).Where(x => allForeignCatalogsIds.Contains(x.Id)).ToArray();
}
}
// Load all properties meta information and data for inheritance from parent categories and catalog
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemProperties))
{
// Load catalogs with properties for products not belongs to any category (EF auto populated all Catalog nav properties for all objects)
foreach (var catalogId in retVal.Where(x => x.CategoryId == null).Select(x => x.CatalogId))
{
var catalog = GetCatalogById(catalogId);
}
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemAssets))
{
var assets = Assets.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemEditorialReviews))
{
var editorialReviews = EditorialReviews.Where(x => itemIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.Variations))
{
var variationIds = Items.Where(x => itemIds.Contains(x.ParentId)).Select(x => x.Id).ToArray();
// For variations load only info and images
var variations = Items.Include(x => x.Images).Include(x => x.Assets).Where(x => variationIds.Contains(x.Id)).ToArray();
// Load variations property values separately
var variationPropertyValues = PropertyValues.Where(x => variationIds.Contains(x.ItemId)).ToArray();
}
if (respGroup.HasFlag(coreModel.ItemResponseGroup.ItemAssociations))
{
var assosiations = Associations.Where(x => itemIds.Contains(x.ItemId)).ToArray();
var assosiatedCategoriesIds = assosiations.Where(x => x.AssociatedCategoryId != null)
.Select(x => x.AssociatedCategoryId).Distinct().ToArray();
var assosiatedProductIds = assosiations.Where(x => x.AssociatedItemId != null)
.Select(x => x.AssociatedItemId).Distinct().ToArray();
var assosiatedCategories = GetCategoriesByIds(assosiatedCategoriesIds, coreModel.CategoryResponseGroup.Info | coreModel.CategoryResponseGroup.WithImages);
var assosiatedItems = GetItemByIds(assosiatedProductIds, coreModel.ItemResponseGroup.ItemInfo | coreModel.ItemResponseGroup.ItemAssets);
}
// Load parents
var parentIds = retVal.Where(x => x.Parent == null && x.ParentId != null).Select(x => x.ParentId).ToArray();
var parents = GetItemByIds(parentIds, respGroup);
return(retVal);
}
public IEnumerable <ApplicationRelationshipDefinition> CollectionRelationships()
{
IEnumerable <ApplicationRelationshipDefinition> applicationAssociations = Associations.Where(a => a.Collection);
IEnumerable <ApplicationRelationshipDefinition> applicationCompositions = Compositions.Where(a => a.Collection);
return(applicationAssociations.Union(applicationCompositions));
}