コード例 #1
0
        private static async Task <ICollection <Tuple <ICollection <ItemRelationPreview>, IItemSideRunner> > > ProcessWork(ICollection <ItemPreview> items, WorkRunner runner, SynchronizationAction action)
        {
            ICollection <Tuple <ICollection <ItemRelationPreview>, IItemSideRunner> > levels = new List <Tuple <ICollection <ItemRelationPreview>, IItemSideRunner> >();

            foreach (var item in items)
            {
                var runItem = runner.Items.Single(i => i.Id == item.Id);

                foreach (var side in item.Sides)
                {
                    var runSide     = runner.Sides.Single(s => s.Id == side.Id);
                    var runItemSide = runItem.SideRunners.Single(s => s.Side.Id == side.Id);
                    var map         = new Func <IItemRunner, IItemSideRunner, object>((i, s) =>
                    {
                        if (runSide.Comparator.GetItemTypes().Item1 == runner.MasterSide.GetItemType())
                        {
                            // Master is A in this comparator
                            if (item.MasterItemExist)
                            {
                                return(runSide.Comparator.MapAToB(i.MasterItem, s.SideItem));
                            }
                        }
                        else
                        {
                            // Master is B in this comparator
                            if (item.MasterItemExist)
                            {
                                return(runSide.Comparator.MapBToA(i.MasterItem, s.SideItem));
                            }
                        }
                        return(null);
                    });

                    if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Insert)
                    {
                        var newItem = map(runItem, runItemSide);
                        await runSide.InsertAsync(newItem);

                        foreach (var subItem in runItemSide.SubItems)
                        {
                            subItem.SideRunners.First().Side.Source = newItem;
                        }
                    }
                    else if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Update)
                    {
                        var newItem = map(runItem, runItemSide);
                        await runSide.UpdateAsync(newItem);

                        foreach (var subItem in runItemSide.SubItems)
                        {
                            subItem.SideRunners.First().Side.Source = newItem;
                        }
                    }
                    else if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Delete)
                    {
                        await runSide.DeleteAsync(runItemSide.SideItem);
                    }
                    levels.Add(new Tuple <ICollection <ItemRelationPreview>, IItemSideRunner>(side.Relations, runItemSide));
                }
            }
            return(levels);
        }
コード例 #2
0
ファイル: SessionRunner.cs プロジェクト: Devidence7/Fuxion
        ProcessWork(ICollection <ItemPreview> items, WorkRunner runner, SynchronizationAction action)
        {
            var levels         = new List <(ICollection <ItemRelationPreview>, IItemSideRunner)>();
            var processActions = new List <Func <Task> >();

            foreach (var item in items)
            {
                var runItem = runner.Items.Single(i => i.Id == item.Id);
                foreach (var side in item.Sides)
                {
                    var runSide     = runner.Sides.Single(s => s.Id == side.Id);
                    var runItemSide = runItem.SideRunners.Single(s => s.Side.Id == side.Id);
                    // ----
                    processActions.Add(new Func <Task>(async() =>
                    {
                        var map = new Func <IItemRunner, IItemSideRunner, object>((i, s) =>
                        {
                            if (runSide.Comparator.GetItemTypes().typeA == runner.MasterSide.GetItemType())
                            {
                                // Master is A in this comparator
                                if (item.MasterItemExist)
                                {
                                    return(runSide.Comparator.MapAToB(i.MasterItem, s.SideItem));
                                }
                            }
                            else
                            {
                                // Master is B in this comparator
                                if (item.MasterItemExist)
                                {
                                    return(runSide.Comparator.MapBToA(i.MasterItem, s.SideItem));
                                }
                            }
                            return(null);
                        });

                        if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Insert)
                        {
                            var newItem = map(runItem, runItemSide);
                            await runSide.InsertAsync(newItem);
                            foreach (var subItem in runItemSide.SubItems)
                            {
                                subItem.SideRunners.First().Side.Source = newItem;
                            }
                        }
                        else if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Update)
                        {
                            var newItem = map(runItem, runItemSide);
                            await runSide.UpdateAsync(newItem);
                            foreach (var subItem in runItemSide.SubItems)
                            {
                                subItem.SideRunners.First().Side.Source = newItem;
                            }
                        }
                        else if (side.IsEnabled && side.Action == action && side.Action == SynchronizationAction.Delete)
                        {
                            await runSide.DeleteAsync(runItemSide.SideItem);
                        }
                    }));
                    // ----
                    levels.Add((side.Relations, runItemSide));
                }
            }
            return(levels, processActions.Transform(acts =>
                                                    new Func <Task>(async() =>
            {
                foreach (var act in acts)
                {
                    await act();
                }
            })));
        }