public ItemRunner(ISideRunner masterRunner, TMasterItem masterItem, string masterItemName, string masterItemTag)
{
MasterRunner = masterRunner;
MasterItem = masterItem;
MasterItemName = masterItemName;
MasterItemTag = masterItemTag;
}
public ItemSideRunner(ISideRunner side, string name, TKey key, TSideItem sideItem, string sideItemName)
{
Side = side;
Name = name;
Key = key;
SideItem = sideItem;
SideItemName = sideItemName;
}
internal static ISideRunner SearchMasterSubSide(this ISideRunner me, ISideRunner masterSide)
{
var masterTypes = masterSide.GetAllItemsType();
if (me.Comparator.GetItemTypes().Item1 == me.GetItemType())
{
return new[] { masterSide }
}
public ItemRunner(ISideRunner masterRunner, TMasterItem masterItem, string masterName)
{
MasterRunner = masterRunner;
MasterItem = masterItem;
MasterName = masterName;
}
internal static Type GetItemType(this ISideRunner me)
{
return(me.GetType().GetTypeInfo().GenericTypeArguments[1]);
}
public ICollection <IComparatorResultInternal> CompareSides(ISideRunner sideA, ISideRunner sideB, bool runInverted, IPrinter printer)
{
return(printer.Indent($"Comparing sides '{sideA?.Definition.Name}' == '{sideB?.Definition.Name}' {(runInverted ? "INVERTED" : "")}", () =>
{
var res = new List <IComparatorResultInternal>();
Dictionary <TKey, Tuple <LoadedItem, LoadedItem> > dic = new Dictionary <TKey, Tuple <LoadedItem, LoadedItem> >();
if (sideA?.Entries != null)
{
foreach (var item in sideA?.Entries)
{
var tup = new Tuple <LoadedItem, LoadedItem>(item, new LoadedItem
{
Item = null,
//Sides = sideB.SubSides?.Select(side =>
//{
// var clon = side.Clone();
// clon.Source = null;
// clon.Definition.Name = $"{clon.Definition.Name} ({sideA.GetItemName(item.Item)})";
// return clon;
//}).ToList() ?? Enumerable.Empty<ISideRunner>().ToList()
Sides = Enumerable.Empty <ISideRunner>().ToList()
});
if (sideB?.SubSides != null)
{
foreach (var subSide in (runInverted ? sideA : sideB).SubSides)
{
var clon = subSide.Clone();
clon.Source = null;
//clon.Definition.Name = $"{clon.Definition.Name} ({sideA.GetItemName(item.Item)})";
clon.Definition.Name = $"{clon.Definition.Name.Replace("%sourceName%", sideA.GetItemName(item.Item))}";
var sides = runInverted ? tup.Item1.Sides : tup.Item2.Sides;
if (!sides.Any(s => s.Definition.Name == clon.Definition.Name))
{
printer.WriteLine($"Creating side-clon '{clon.Definition.Name}-{clon.Definition.IsMaster}' with source '{sideA.GetItemName(item.Item)}'");
if (runInverted)
{
tup.Item1.Sides.Add(clon);
}
else
{
tup.Item2.Sides.Add(clon);
}
}
}
}
dic.Add(definition.OnSelectKeyA.Invoke((TItemA)item.Item), tup);
}
}
if (sideB?.Entries != null)
{
foreach (var item in sideB?.Entries)
{
var key = definition.OnSelectKeyB.Invoke((TItemB)item.Item);
if (dic.ContainsKey(key))
{
dic[key] = new Tuple <LoadedItem, LoadedItem>(dic[key].Item1, item);
}
else
{
var tup = new Tuple <LoadedItem, LoadedItem>(new LoadedItem
{
Item = null,
//Sides = sideA.SubSides
Sides = Enumerable.Empty <ISideRunner>().ToList()
}, item);
if (sideA?.SubSides != null)
{
foreach (var subSide in (runInverted ? sideA : sideB).SubSides)
{
var clon = subSide.Clone();
clon.Source = null;
clon.Definition.Name = $"{clon.Definition.Name} ({sideB.GetItemName(item.Item)})";
printer.WriteLine($"Creating side-clon '{clon.Definition.Name}-{clon.Definition.IsMaster}' with source '{sideB.GetItemName(item.Item)}'");
if (runInverted)
{
tup.Item1.Sides.Add(clon);
}
else
{
tup.Item2.Sides.Add(clon);
}
}
}
dic.Add(key, tup);
}
}
}
foreach (var tup in dic.Values)
{
var r = CompareItems(tup.Item1, tup.Item2, runInverted, printer);//tup.Item2.Sides.Any(s => s.Definition.IsMaster));
if (r != null)
{
res.Add(r);
}
}
return res;
}));
}
internal async Task <WorkPreview> PreviewAsync(IPrinter printer)
{
void PrintSide(ISideRunner si)
{
printer.Foreach($"Side '{si.Definition.Name}' {(si.Definition.IsMaster ? "(MASTER)" : "")}:", si.SubSides, s => PrintSide(s));
}
using (printer.Indent($"Work '{Definition.Name}'"))
{
// Get master side
var masters = Sides.Where(s => s.Definition.IsMaster);
if (masters.Count() != 1)
{
throw new ArgumentException($"One, and only one '{nameof(ISide)}' must be the master side");
}
MasterSide = masters.Single();
// Determine what sides are sub-sides of others
void PopulateSubSides(ISideRunner side)
{
side.SubSides = Sides.Where(s => s.GetSourceType() == side.GetItemType()).ToList();
foreach (var s in side.SubSides)
{
if (side.Definition.IsMaster)
{
s.Definition.IsMaster = true;
}
PopulateSubSides(s);
}
}
var rootSides = Sides.Where(s => !Sides.Any(s2 => s2.GetItemType() == s.GetSourceType())).OrderByDescending(s => s.Definition.IsMaster).ThenBy(s => s.Definition.Name).ToList();
foreach (var side in rootSides)
{
PopulateSubSides(side);
}
printer.Foreach("Sides tree:", rootSides, side =>
{
PrintSide(side);
});
// Search for comparators for any side with master side
void SearchComparator(ISideRunner side)
{
var cc = Comparators.Where(c =>
{
var mts = MasterSide.GetAllItemsType();
var st = side.GetItemType();
var ct = c.GetItemTypes();
return((mts.Contains(ct.Item1) && ct.Item2 == st) || (mts.Contains(ct.Item2) && ct.Item1 == st));
}).Cast <IComparatorRunner>();
if (cc.Count() != 1)
{
throw new ArgumentException($"One, and only one '{nameof(ISide)}' must be added for master side '{MasterSide.Definition.Name}' and each side");
}
side.Comparator = cc.Single();
printer.WriteLine($"Comparator for side '{side.Definition.Name}' is '{side.Comparator.GetItemTypes().Item1.Name}' <> '{side.Comparator.GetItemTypes().Item2.Name}'");
foreach (var subSide in side.SubSides)
{
Sides.Where(s => s.GetSourceType() == subSide.GetItemType());
SearchComparator(subSide);
}
}
// Iterate non master sides to search for a comparator for they
printer.Foreach("Comparators: ", rootSides.Where(s => !s.Definition.IsMaster), side => SearchComparator(side));
// Load sides
using (printer.Indent($"Loading sides {(Definition.LoadSidesInParallel ? "in parallel" : "sequentially")} ..."))
{
if (Definition.LoadSidesInParallel)
{
await Task.WhenAll(rootSides.Select(s => s.Load()));
}
else
{
await TaskManager.StartNew(async() =>
{
foreach (var side in rootSides)
{
await side.Load();
}
});
}
}
// Comparing sides
printer.Foreach("Comparing each side with master side ...", rootSides.Where(s => !s.Definition.IsMaster), sid => {
if (sid.Comparator.GetItemTypes().Item1 == MasterSide.GetItemType())
{
// Master is A in this comparer
sid.Results = sid.Comparator.CompareSides(MasterSide, sid, false, printer);
}
else
{
// Master is B in this comparer
sid.Results = sid.Comparator.CompareSides(sid, MasterSide, true, printer);
}
});
printer.WriteLine("Analyzing results ...");
ICollection <IItemRunner> AnalyzeResults(ICollection <ISideRunner> sides)
{
var res = new List <IItemRunner>();
// Group side results by item key and populate with sides results
foreach (var gro in sides
.SelectMany(side => side.Results.Select(result => new
{
Key = result.Key,
MasterRunner = side.SearchMasterSubSide(MasterSide),
MasterItemType = side.SearchMasterSubSide(MasterSide).GetItemType(),
MasterItem = result.MasterItem,
MasterItemName = side.SearchMasterSubSide(MasterSide).GetItemName(result.MasterItem),
MasterItemTag = side.SearchMasterSubSide(MasterSide).GetItemTag(result.MasterItem),
//SideId = side.Id,
Side = side,
SideItemType = side.GetItemType(),
SideItem = result.SideItem,
SideItemName = side.GetItemName(result.SideItem),
SideItemTag = side.GetItemTag(result.SideItem),
SideName = side.Definition.Name,
SideSubSides = result.SubSides,
Properties = result.Properties.ToArray()
}))
.GroupBy(r => r.Key))
{
// Create item
var fir = gro.First(); // Use first element to get master info, all items in this group has the same master item
var itemType = typeof(ItemRunner <>).MakeGenericType(fir.MasterItemType);
var item = (IItemRunner)Activator.CreateInstance(itemType, fir.MasterRunner, fir.MasterItem, fir.MasterItemName, fir.MasterItemTag);
foreach (var i in gro)
{
// Create side
var sideItemType = typeof(ItemSideRunner <,>).MakeGenericType(i.SideItemType, i.Key.GetType());
var sideItem = (IItemSideRunner)Activator.CreateInstance(sideItemType, i.Side, i.SideName, i.Key, i.SideItem, i.SideItemName, i.SideItemTag);
foreach (var pro in i.Properties)
{
((IList <IPropertyRunner>)sideItem.Properties).Add(pro);
}
sideItem.SubItems = AnalyzeResults(i.SideSubSides);
// Add side to item
((IList <IItemSideRunner>)item.SideRunners).Add(sideItem);
}
// Add item to work
res.Add(item);
}
return(res);
}
foreach (var item in AnalyzeResults(rootSides.Where(side => !side.Definition.IsMaster).ToList()))
{
Items.Add(item);
}
// Create preview response
printer.WriteLine("Creating preview result ...");
var preWork = new WorkPreview(Definition.Id);
preWork.Name = Definition.Name;
preWork.MasterSideName = MasterSide.Definition.Name;
var preItems = new List <ItemPreview>();
foreach (var item in Items)
{
var preItem = new ItemPreview(preWork, item.Id);
preItem.MasterItemExist = item.MasterItem != null;
preItem.MasterItemName = item.MasterItemName;
preItem.MasterItemTag = item.MasterItemTag;
preItem.SingularMasterTypeName = MasterSide.Definition.SingularItemTypeName;
preItem.PluralMasterTypeName = MasterSide.Definition.PluralItemTypeName;
preItem.MasterTypeIsMale = MasterSide.Definition.ItemTypeIsMale;
var preSides = new List <ItemSidePreview>();
foreach (var side in item.SideRunners)
{
var preSide = new ItemSidePreview(preItem, side.Side.Id);
preSide.Key = side.Key.ToString();
preSide.SideAllowInsert = side.Side.Definition.AllowInsert;
preSide.SideAllowDelete = side.Side.Definition.AllowDelete;
preSide.SideAllowUpdate = side.Side.Definition.AllowUpdate;
preSide.SideItemExist = side.SideItem != null;
preSide.SideItemName = side.SideItemName;
preSide.SideItemTag = side.SideItemTag;
preSide.SingularSideTypeName = side.Side.Definition.SingularItemTypeName;
preSide.PluralSideTypeName = side.Side.Definition.PluralItemTypeName;
preSide.ItemTypeIsMale = side.Side.Definition.ItemTypeIsMale;
preSide.SideName = side.Name;
foreach (var pro in side.Properties)
{
var prePro = new PropertyPreview(preSide);
prePro.MasterValue = pro.MasterNamingFunction(pro.MasterValue);
prePro.SideValue = pro.SideNamingFunction(pro.SideValue);
prePro.PropertyName = pro.PropertyName;
preSide.Properties.Add(prePro);
}
ICollection <ItemRelationPreview> ProcessSubItems(object parent, ICollection <IItemRunner> items)
{
var res = new List <ItemRelationPreview>();
foreach (var i in items)
{
ItemRelationPreview rel;
if (parent is ItemSidePreview)
{
rel = new ItemRelationPreview(parent as ItemSidePreview, i.Id);
}
else
{
rel = new ItemRelationPreview(parent as ItemRelationPreview, i.Id);
}
rel.SideAllowInsert = i.SideRunners.Single().Side.Definition.AllowInsert;
rel.SideAllowDelete = i.SideRunners.Single().Side.Definition.AllowDelete;
rel.SideAllowUpdate = i.SideRunners.Single().Side.Definition.AllowUpdate;
rel.MasterItemExist = i.MasterItem != null;
rel.MasterItemName = i.MasterItemName;
rel.MasterItemTag = i.MasterItemTag;
rel.SingularMasterTypeName = i.MasterRunner.Definition.SingularItemTypeName;
rel.PluralMasterTypeName = i.MasterRunner.Definition.PluralItemTypeName;
rel.SingularSideTypeName = i.SideRunners.Single().Side.Definition.SingularItemTypeName;
rel.PluralSideTypeName = i.SideRunners.Single().Side.Definition.PluralItemTypeName;
var subSide = i.SideRunners.Single();
rel.Key = subSide.Key.ToString();
rel.SideItemExist = subSide.SideItem != null;
rel.SideItemName = subSide.SideItemName;
rel.SideItemTag = subSide.SideItemTag;
rel.SideName = subSide.Name;
foreach (var pro in subSide.Properties)
{
var prePro = new PropertyPreview(rel);
prePro.MasterValue = pro.MasterNamingFunction(pro.MasterValue);
prePro.SideValue = pro.SideNamingFunction(pro.SideValue);
prePro.PropertyName = pro.PropertyName;
rel.Properties.Add(prePro);
}
rel.Relations = ProcessSubItems(rel, subSide.SubItems);
res.Add(rel);
}
return(res);
}
preSide.Relations = ProcessSubItems(preSide, side.SubItems);
preSides.Add(preSide);
}
preItem.Sides = preSides;
preItems.Add(preItem);
}
preWork.Items = preItems;
// Check result and suggest an action
printer.WriteLine("Determining default actions ...");
foreach (var item in preWork.Items)
{
foreach (var side in item.Sides)
{
if (!item.MasterItemExist && side.SideAllowDelete)
{
side.Action = SynchronizationAction.Delete;
}
else if (!side.SideItemExist && side.SideAllowInsert)
{
side.Action = SynchronizationAction.Insert;
}
else if (side.Properties.Count() > 0 && side.SideAllowUpdate)
{
side.Action = SynchronizationAction.Update;
}
void ProcessRelations(ICollection <ItemRelationPreview> relations)
{
foreach (var rel in relations)
{
if (!rel.MasterItemExist && rel.SideAllowDelete)
{
rel.Action = SynchronizationAction.Delete;
}
else if (!rel.SideItemExist && rel.SideAllowInsert)
{
rel.Action = SynchronizationAction.Insert;
}
else if (rel.Properties.Count() > 0 && rel.SideAllowUpdate)
{
rel.Action = SynchronizationAction.Update;
}
ProcessRelations(rel.Relations);
}
}
ProcessRelations(side.Relations);
}
}
return(preWork);
}
//return printer.IndentAsync($"Work '{Definition.Name}'", async () =>
//{
// // Get master side
// var masters = Sides.Where(s => s.Definition.IsMaster);
// if (masters.Count() != 1) throw new ArgumentException($"One, and only one '{nameof(ISide)}' must be the master side");
// MasterSide = masters.Single();
// // Determine what sides are sub-sides of others
// void PopulateSubSides(ISideRunner side)
// {
// side.SubSides = Sides.Where(s => s.GetSourceType() == side.GetItemType()).ToList();
// foreach (var s in side.SubSides)
// {
// if (side.Definition.IsMaster) s.Definition.IsMaster = true;
// PopulateSubSides(s);
// }
// }
// var rootSides = Sides.Where(s => !Sides.Any(s2 => s2.GetItemType() == s.GetSourceType())).OrderByDescending(s => s.Definition.IsMaster).ThenBy(s => s.Definition.Name).ToList();
// foreach (var side in rootSides)
// PopulateSubSides(side);
// printer.Foreach("Sides tree:", rootSides, side =>
// {
// PrintSide(side);
// });
// // Search for comparators for any side with master side
// void SearchComparator(ISideRunner side)
// {
// var cc = Comparators.Where(c =>
// {
// var mts = MasterSide.GetAllItemsType();
// var st = side.GetItemType();
// var ct = c.GetItemTypes();
// return (mts.Contains(ct.Item1) && ct.Item2 == st) || (mts.Contains(ct.Item2) && ct.Item1 == st);
// }).Cast<IComparatorRunner>();
// if (cc.Count() != 1) throw new ArgumentException($"One, and only one '{nameof(ISide)}' must be added for master side '{MasterSide.Definition.Name}' and each side");
// side.Comparator = cc.Single();
// printer.WriteLine($"Comparator for side '{side.Definition.Name}' is '{side.Comparator.GetItemTypes().Item1.Name}' <> '{side.Comparator.GetItemTypes().Item2.Name}'");
// foreach (var subSide in side.SubSides)
// {
// Sides.Where(s => s.GetSourceType() == subSide.GetItemType());
// SearchComparator(subSide);
// }
// }
// // Iterate non master sides to search for a comparator for they
// printer.Foreach("Comparators: ", rootSides.Where(s => !s.Definition.IsMaster), side => SearchComparator(side));
// // Load sides
// await printer.IndentAsync($"Loading sides {(Definition.LoadSidesInParallel ? "in parallel" : "sequentially")} ...", () =>
// {
// if (Definition.LoadSidesInParallel)
// {
// return Task.WhenAll(rootSides.Select(s => s.Load()));
// }else
// {
// return TaskManager.StartNew(async () =>
// {
// foreach (var side in rootSides)
// {
// await side.Load();
// }
// });
// }
// });
// // Comparing sides
// printer.Foreach("Comparing each side with master side ...", rootSides.Where(s => !s.Definition.IsMaster), sid=> {
// if (sid.Comparator.GetItemTypes().Item1 == MasterSide.GetItemType())
// {
// // Master is A in this comparer
// sid.Results = sid.Comparator.CompareSides(MasterSide, sid, false, printer);
// }
// else
// {
// // Master is B in this comparer
// sid.Results = sid.Comparator.CompareSides(sid, MasterSide, true, printer);
// }
// });
// printer.WriteLine("Analyzing results ...");
// ICollection<IItemRunner> AnalyzeResults(ICollection<ISideRunner> sides)
// {
// var res = new List<IItemRunner>();
// // Group side results by item key and populate with sides results
// foreach (var gro in sides
// .SelectMany(side => side.Results.Select(result => new
// {
// Key = result.Key,
// MasterRunner = side.SearchMasterSubSide(MasterSide),
// MasterItemType = side.SearchMasterSubSide(MasterSide).GetItemType(),
// MasterItem = result.MasterItem,
// MasterItemName = side.SearchMasterSubSide(MasterSide).GetItemName(result.MasterItem),
// MasterItemTag = side.SearchMasterSubSide(MasterSide).GetItemTag(result.MasterItem),
// //SideId = side.Id,
// Side = side,
// SideItemType = side.GetItemType(),
// SideItem = result.SideItem,
// SideItemName = side.GetItemName(result.SideItem),
// SideItemTag = side.GetItemTag(result.SideItem),
// SideName = side.Definition.Name,
// SideSubSides = result.SubSides,
// Properties = result.Properties.ToArray()
// }))
// .GroupBy(r => r.Key))
// {
// // Create item
// var fir = gro.First(); // Use first element to get master info, all items in this group has the same master item
// var itemType = typeof(ItemRunner<>).MakeGenericType(fir.MasterItemType);
// var item = (IItemRunner)Activator.CreateInstance(itemType, fir.MasterRunner, fir.MasterItem, fir.MasterItemName, fir.MasterItemTag);
// foreach (var i in gro)
// {
// // Create side
// var sideItemType = typeof(ItemSideRunner<,>).MakeGenericType(i.SideItemType, i.Key.GetType());
// var sideItem = (IItemSideRunner)Activator.CreateInstance(sideItemType, i.Side, i.SideName, i.Key, i.SideItem, i.SideItemName, i.SideItemTag);
// foreach (var pro in i.Properties)
// ((IList<IPropertyRunner>)sideItem.Properties).Add(pro);
// sideItem.SubItems = AnalyzeResults(i.SideSubSides);
// // Add side to item
// ((IList<IItemSideRunner>)item.SideRunners).Add(sideItem);
// }
// // Add item to work
// res.Add(item);
// }
// return res;
// }
// foreach (var item in AnalyzeResults(rootSides.Where(side => !side.Definition.IsMaster).ToList())) Items.Add(item);
// // Create preview response
// printer.WriteLine("Creating preview result ...");
// var preWork = new WorkPreview(Definition.Id);
// preWork.Name = Definition.Name;
// preWork.MasterSideName = MasterSide.Definition.Name;
// var preItems = new List<ItemPreview>();
// foreach (var item in Items)
// {
// var preItem = new ItemPreview(preWork, item.Id);
// preItem.MasterItemExist = item.MasterItem != null;
// preItem.MasterItemName = item.MasterItemName;
// preItem.MasterItemTag = item.MasterItemTag;
// preItem.SingularMasterTypeName = MasterSide.Definition.SingularItemTypeName;
// preItem.PluralMasterTypeName = MasterSide.Definition.PluralItemTypeName;
// preItem.MasterTypeIsMale = MasterSide.Definition.ItemTypeIsMale;
// var preSides = new List<ItemSidePreview>();
// foreach (var side in item.SideRunners)
// {
// var preSide = new ItemSidePreview(preItem, side.Side.Id);
// preSide.Key = side.Key.ToString();
// preSide.SideAllowInsert = side.Side.Definition.AllowInsert;
// preSide.SideAllowDelete = side.Side.Definition.AllowDelete;
// preSide.SideAllowUpdate = side.Side.Definition.AllowUpdate;
// preSide.SideItemExist = side.SideItem != null;
// preSide.SideItemName = side.SideItemName;
// preSide.SideItemTag = side.SideItemTag;
// preSide.SingularSideTypeName = side.Side.Definition.SingularItemTypeName;
// preSide.PluralSideTypeName = side.Side.Definition.PluralItemTypeName;
// preSide.ItemTypeIsMale = side.Side.Definition.ItemTypeIsMale;
// preSide.SideName = side.Name;
// foreach (var pro in side.Properties)
// {
// var prePro = new PropertyPreview(preSide);
// prePro.MasterValue = pro.MasterNamingFunction(pro.MasterValue);
// prePro.SideValue = pro.SideNamingFunction(pro.SideValue);
// prePro.PropertyName = pro.PropertyName;
// preSide.Properties.Add(prePro);
// }
// ICollection<ItemRelationPreview> ProcessSubItems(object parent, ICollection<IItemRunner> items)
// {
// var res = new List<ItemRelationPreview>();
// foreach (var i in items)
// {
// ItemRelationPreview rel;
// if (parent is ItemSidePreview)
// rel = new ItemRelationPreview(parent as ItemSidePreview, i.Id);
// else
// rel = new ItemRelationPreview(parent as ItemRelationPreview, i.Id);
// rel.SideAllowInsert = i.SideRunners.Single().Side.Definition.AllowInsert;
// rel.SideAllowDelete = i.SideRunners.Single().Side.Definition.AllowDelete;
// rel.SideAllowUpdate = i.SideRunners.Single().Side.Definition.AllowUpdate;
// rel.MasterItemExist = i.MasterItem != null;
// rel.MasterItemName = i.MasterItemName;
// rel.MasterItemTag = i.MasterItemTag;
// rel.SingularMasterTypeName = i.MasterRunner.Definition.SingularItemTypeName;
// rel.PluralMasterTypeName = i.MasterRunner.Definition.PluralItemTypeName;
// rel.SingularSideTypeName = i.SideRunners.Single().Side.Definition.SingularItemTypeName;
// rel.PluralSideTypeName = i.SideRunners.Single().Side.Definition.PluralItemTypeName;
// var subSide = i.SideRunners.Single();
// rel.Key = subSide.Key.ToString();
// rel.SideItemExist = subSide.SideItem != null;
// rel.SideItemName = subSide.SideItemName;
// rel.SideItemTag = subSide.SideItemTag;
// rel.SideName = subSide.Name;
// foreach (var pro in subSide.Properties)
// {
// var prePro = new PropertyPreview(rel);
// prePro.MasterValue = pro.MasterNamingFunction(pro.MasterValue);
// prePro.SideValue = pro.SideNamingFunction(pro.SideValue);
// prePro.PropertyName = pro.PropertyName;
// rel.Properties.Add(prePro);
// }
// rel.Relations = ProcessSubItems(rel, subSide.SubItems);
// res.Add(rel);
// }
// return res;
// }
// preSide.Relations = ProcessSubItems(preSide, side.SubItems);
// preSides.Add(preSide);
// }
// preItem.Sides = preSides;
// preItems.Add(preItem);
// }
// preWork.Items = preItems;
// // Check result and suggest an action
// printer.WriteLine("Determining default actions ...");
// foreach (var item in preWork.Items)
// {
// foreach (var side in item.Sides)
// {
// if (!item.MasterItemExist && side.SideAllowDelete)
// side.Action = SynchronizationAction.Delete;
// else if (!side.SideItemExist && side.SideAllowInsert)
// side.Action = SynchronizationAction.Insert;
// else if (side.Properties.Count() > 0 && side.SideAllowUpdate)
// side.Action = SynchronizationAction.Update;
// void ProcessRelations(ICollection<ItemRelationPreview> relations)
// {
// foreach (var rel in relations)
// {
// if (!rel.MasterItemExist && rel.SideAllowDelete)
// rel.Action = SynchronizationAction.Delete;
// else if (!rel.SideItemExist && rel.SideAllowInsert)
// rel.Action = SynchronizationAction.Insert;
// else if (rel.Properties.Count() > 0 && rel.SideAllowUpdate)
// rel.Action = SynchronizationAction.Update;
// ProcessRelations(rel.Relations);
// }
// }
// ProcessRelations(side.Relations);
// }
// }
// return preWork;
//});
}
