private static string FilterAndRecomputeAfterSave(KeepSynchronizedOnChangedItemsInfo info, string uniqueName)
        {
            string recomputeCall;

            if (FilterIsEnumerableGuid(info.UpdateOnChange.FilterType))
            {
                recomputeCall =
                    @"_domRepository.{1}.{2}.{5}(filteredNew.Union(filterKeepSynchronizedOnChangedItems{0}Old).ToList());";
            }
            else if (info.UpdateOnChange.FilterType == "Rhetos.Dom.DefaultConcepts.FilterSubtype")
            {
                recomputeCall =
                    @"_domRepository.{1}.{2}.{5}(new Rhetos.Dom.DefaultConcepts.FilterSubtype
                    {{
                        Ids = filteredNew.Ids.Union(filterKeepSynchronizedOnChangedItems{0}Old.Ids).ToList(),
                        Subtype = filteredNew.Subtype,
                        ImplementationName = filteredNew.ImplementationName
                    }});";
            }
            else if (info.UpdateOnChange.FilterType == "FilterAll" || info.UpdateOnChange.FilterType == "Rhetos.Dom.DefaultConcepts.FilterAll")
            {
                recomputeCall =
                    @"_domRepository.{1}.{2}.{5}(new Rhetos.Dom.DefaultConcepts.FilterAll());";
            }
            else
            {
                recomputeCall =
                    @"_domRepository.{1}.{2}.{5}(filterKeepSynchronizedOnChangedItems{0}Old);
                    _domRepository.{1}.{2}.{5}(filteredNew);";
            }

            return(string.Format(
                       OverrideRecomputeTag(info) + @"
                {{
                    var filteredNew = filterLoadKeepSynchronizedOnChangedItems{0}(inserted.Concat(updated));
                    " + recomputeCall + @"
                }}

                ",
                       uniqueName,
                       info.KeepSynchronized.EntityComputedFrom.Target.Module.Name,
                       info.KeepSynchronized.EntityComputedFrom.Target.Name,
                       info.UpdateOnChange.DependsOn.Module.Name,
                       info.UpdateOnChange.DependsOn.Name,
                       EntityComputedFromCodeGenerator.RecomputeFunctionName(info.KeepSynchronized.EntityComputedFrom)));
        }
        private static string FilterAndRecomputeAfterSave(KeepSynchronizedOnChangedItemsInfo info, string filterType, string uniqueName)
        {
            string recomputeMethodName =
                info.KeepSynchronized.EntityComputedFrom.Target.Module.Name
                + "." + info.KeepSynchronized.EntityComputedFrom.Target.Name
                + "." + EntityComputedFromCodeGenerator.RecomputeFunctionName(info.KeepSynchronized.EntityComputedFrom);

            return
                ($@"{OverrideRecomputeTag(info)}
                {{
                    var filteredNew = filterLoadKeepSynchronizedOnChangedItems{uniqueName}(inserted.Concat(updated));
                    {filterType} optimizedFilter;
                    if (KeepSynchronizedHelper.OptimizeFiltersUnion(filteredNew, filterKeepSynchronizedOnChangedItems{uniqueName}Old, out optimizedFilter))
                        _domRepository.{recomputeMethodName}(optimizedFilter);
                    else
                    {{
                        _domRepository.{recomputeMethodName}(filterKeepSynchronizedOnChangedItems{uniqueName}Old);
                        _domRepository.{recomputeMethodName}(filteredNew);
                    }}
                }}

                ");
        }
 public static string OverrideRecomputeTag(KeepSynchronizedOnChangedItemsInfo info)
 {
     return(string.Format("/*OverrideRecompute {0}.{1}*/",
                          info.KeepSynchronized.GetKey(),
                          info.UpdateOnChange.GetAlternativeKey()));
 }