Пример #1
0
        internal static void ToSearchControl(UserQueryEntity uq, SearchControl searchControl)
        {
            var filters = uq.WithoutFilters ? searchControl.FilterOptions.ToList() :
                          searchControl.FilterOptions.Where(f => f.Frozen).Concat(uq.Filters.Select(qf => new FilterOption
            {
                ColumnName = qf.Token.Token.FullKey(),
                Operation  = qf.Operation,
                Value      = Signum.Entities.UserAssets.FilterValueConverter.Parse(qf.ValueString, qf.Token.Token.Type, qf.Operation.IsList())
            })).ToList();

            var columns = uq.Columns.Select(qc => new ColumnOption
            {
                ColumnName  = qc.Token.Token.FullKey(),
                DisplayName = qc.DisplayName.DefaultText(null)
            }).ToList();

            var orders = uq.Orders.Select(of => new OrderOption
            {
                ColumnName = of.Token.Token.FullKey(),
                OrderType  = of.OrderType,
            }).ToList();

            var pagination = uq.GetPagination() ?? Finder.GetQuerySettings(searchControl.QueryName).Pagination ?? FindOptions.DefaultPagination;

            searchControl.Reinitialize(filters, columns, uq.ColumnsMode, orders, pagination);
        }
Пример #2
0
    public static QueryRequest ToQueryRequestValue(this UserQueryEntity userQuery, QueryToken?valueToken = null)
    {
        var qn = userQuery.Query.ToQueryName();

        if (valueToken == null)
        {
            var qd = QueryLogic.Queries.QueryDescription(qn);
            valueToken = QueryUtils.Parse("Count", qd, SubTokensOptions.CanAggregate);
        }

        var qr = new QueryRequest()
        {
            QueryName    = qn,
            GroupResults = userQuery.GroupResults || valueToken is AggregateToken,
        };

        qr.Filters = userQuery.Filters.ToFilterList();
        qr.Columns = new List <Column> {
            new Column(valueToken, null)
        };
        qr.Orders = valueToken is AggregateToken ? new List <Order>() : userQuery.Orders.Select(qo => new Order(qo.Token.Token, qo.OrderType)).ToList();

        qr.Pagination = userQuery.GetPagination() ?? new Pagination.All();

        return(qr);
    }
Пример #3
0
        private static void OnUserQueryChanged(DependencyObject s, UserQueryEntity uc)
        {
            UserQueryPermission.ViewUserQuery.Authorize();

            var currentEntity = UserAssetsClient.GetCurrentEntity(s);

            if (s is CountSearchControl csc)
            {
                csc.QueryName = QueryClient.GetQueryName(uc.Query.Key);
                using (currentEntity == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity))
                    UserQueryClient.ToCountSearchControl(uc, csc);
                csc.Search();
                return;
            }

            if (s is SearchControl sc && sc.ShowHeader == false)
            {
                sc.QueryName = QueryClient.GetQueryName(uc.Query.Key);
                using (currentEntity == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity))
                    UserQueryClient.ToSearchControl(uc, sc);
                sc.Search();
                return;
            }

            return;
        }
Пример #4
0
        internal static void ToCountSearchControl(UserQueryEntity uq, CountSearchControl countSearchControl)
        {
            var filters = uq.WithoutFilters ? countSearchControl.FilterOptions.ToList() :
                          countSearchControl.FilterOptions.Where(f => f.Frozen).Concat(uq.Filters.Select(qf => new FilterOption
            {
                ColumnName = qf.Token.Token.FullKey(),
                Operation  = qf.Operation,
                Value      = Signum.Entities.UserAssets.FilterValueConverter.Parse(qf.ValueString, qf.Token.Token.Type, qf.Operation.IsList())
            })).ToList();

            var columns = uq.Columns.Select(qc => new ColumnOption
            {
                ColumnName  = qc.Token.Token.FullKey(),
                DisplayName = qc.DisplayName.DefaultText(null)
            }).ToList();

            var orders = uq.Orders.Select(of => new OrderOption
            {
                ColumnName = of.Token.Token.FullKey(),
                OrderType  = of.OrderType,
            }).ToList();

            countSearchControl.Reinitialize(filters, columns, uq.ColumnsMode, orders);
            countSearchControl.Text       = uq.DisplayName + ": {0}";
            countSearchControl.LinkClick += (object sender, EventArgs e) =>
            {
                Finder.Explore(new ExploreOptions(countSearchControl.QueryName)
                {
                    InitializeSearchControl = sc => UserQueryClient.SetUserQuery(sc, uq)
                });
            };
        }
Пример #5
0
        static void UserQueryLogic_Retrieved(UserQueryEntity userQuery)
        {
            object           queryName   = QueryLogic.ToQueryName(userQuery.Query.Key);
            QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);

            userQuery.ParseData(description);
        }
Пример #6
0
        public static FindOptions ToFindOptions(this UserQueryEntity userQuery)
        {
            object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);

            var result = new FindOptions(queryName);

            result.ApplyUserQuery(userQuery);
            return(result);
        }
Пример #7
0
        void UserQuery_Loaded(object sender, RoutedEventArgs e)
        {
            if (QueryDescription == null)
            {
                UserQueryEntity uq = (UserQueryEntity)DataContext;

                QueryDescription = DynamicQueryServer.GetQueryDescription(QueryClient.GetQueryName(uq.Query.Key));
            }

            tbCurrentEntity.Text = UserQueryMessage.Use0ToFilterCurrentEntity.NiceToString().FormatWith(CurrentEntityConverter.CurrentEntityKey);
        }
Пример #8
0
        public static MvcHtmlString SearchControl(this HtmlHelper helper, UserQueryEntity userQuery, FindOptions findOptions, Context context, Action <SearchControl> searchControl = null)
        {
            if (findOptions == null)
            {
                throw new ArgumentNullException("findOptions");
            }

            findOptions.ApplyUserQuery(userQuery);

            return(helper.SearchControl(findOptions, context, searchControl));
        }
Пример #9
0
        public override void OnSelected(UserQueryOmniboxResult result, Window window)
        {
            UserQueryEntity uq = result.UserQuery.RetrieveAndForget();

            var query = QueryClient.GetQueryName(uq.Query.Key);

            Finder.Explore(new ExploreOptions(query)
            {
                InitializeSearchControl = sc => UserQueryClient.SetUserQuery(sc, uq)
            });
        }
Пример #10
0
        static void UserQueryLogic_Retrieved(UserQueryEntity userQuery, PostRetrievingContext ctx)
        {
            object?queryName = userQuery.Query.ToQueryNameCatch();

            if (queryName == null)
            {
                return;
            }

            QueryDescription description = QueryLogic.Queries.QueryDescription(queryName);

            userQuery.ParseData(description);
        }
Пример #11
0
        internal static void Explore(UserQueryEntity userQuery, Entity currentEntity)
        {
            var query = QueryClient.GetQueryName(userQuery.Query.Key);

            Finder.Explore(new ExploreOptions(query)
            {
                InitializeSearchControl = sc =>
                {
                    using (userQuery.EntityType == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity))
                        UserQueryClient.SetUserQuery(sc, userQuery);
                }
            });
        }
Пример #12
0
    static List <Column> MergeColumns(UserQueryEntity uq)
    {
        QueryDescription qd = QueryLogic.Queries.QueryDescription(uq.Query.ToQueryName());

        var result = uq.ColumnsMode switch
        {
            ColumnOptionsMode.Add => qd.Columns.Where(cd => !cd.IsEntity).Select(cd => new Column(cd, qd.QueryName)).Concat(uq.Columns.Select(co => ToColumn(co))).ToList(),
            ColumnOptionsMode.Remove => qd.Columns.Where(cd => !cd.IsEntity && !uq.Columns.Any(co => co.Token.TokenString == cd.Name)).Select(cd => new Column(cd, qd.QueryName)).ToList(),
            ColumnOptionsMode.Replace => uq.Columns.Select(co => ToColumn(co)).ToList(),
            _ => throw new InvalidOperationException("{0} is not a valid ColumnOptionMode".FormatWith(uq.ColumnsMode))
        };

        return(result);
    }
Пример #13
0
        public static UserQueryEntity ParseAndSave(this UserQueryEntity userQuery)
        {
            if (!userQuery.IsNew || userQuery.queryName == null)
            {
                throw new InvalidOperationException("userQuery should be new and have queryName");
            }

            userQuery.Query = QueryLogic.GetQueryEntity(userQuery.queryName);

            QueryDescription description = QueryLogic.Queries.QueryDescription(userQuery.queryName);

            userQuery.ParseData(description);

            return(userQuery.Execute(UserQueryOperation.Save));
        }
Пример #14
0
        public static QueryRequest ToQueryRequest(this UserQueryEntity userQuery)
        {
            var qr = new QueryRequest()
            {
                QueryName    = userQuery.Query.ToQueryName(),
                GroupResults = userQuery.GroupResults,
            };

            qr.Filters = userQuery.Filters.ToFilterList();
            qr.Columns = MergeColumns(userQuery);
            qr.Orders  = userQuery.Orders.Select(qo => new Order(qo.Token.Token, qo.OrderType)).ToList();

            qr.Pagination = userQuery.GetPagination() ?? new Pagination.All();

            return(qr);
        }
Пример #15
0
        static List <Column> MergeColumns(UserQueryEntity uq)
        {
            QueryDescription qd = DynamicQueryManager.Current.QueryDescription(uq.Query.ToQueryName());

            switch (uq.ColumnsMode)
            {
            case ColumnOptionsMode.Add:
                return(qd.Columns.Where(cd => !cd.IsEntity).Select(cd => new Column(cd, qd.QueryName)).Concat(uq.Columns.Select(co => ToColumn(co))).ToList());

            case ColumnOptionsMode.Remove:
                return(qd.Columns.Where(cd => !cd.IsEntity && !uq.Columns.Any(co => co.Token.TokenString == cd.Name)).Select(cd => new Column(cd, qd.QueryName)).ToList());

            case ColumnOptionsMode.Replace:
                return(uq.Columns.Select(co => ToColumn(co)).ToList());

            default:
                throw new InvalidOperationException("{0} is not a valid ColumnOptionMode".FormatWith(uq.ColumnsMode));
            }
        }
Пример #16
0
        static void UserQueryLogic_Retrieved(UserQueryEntity userQuery)
        {
            object queryName;

            try
            {
                queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
            }
            catch (KeyNotFoundException ex) when(StartParameters.IgnoredCodeErrors != null)
            {
                StartParameters.IgnoredCodeErrors.Add(ex);

                return;
            }

            QueryDescription description = QueryLogic.Queries.QueryDescription(queryName);

            userQuery.ParseData(description);
        }
Пример #17
0
        public static QueryRequest ToQueryRequest(this UserQueryEntity userQuery)
        {
            var qr = new QueryRequest()
            {
                QueryName = userQuery.Query.ToQueryName()
            };

            if (!userQuery.WithoutFilters)
            {
                qr.Filters = userQuery.Filters.Select(qf =>
                                                      new Filter(qf.Token.Token, qf.Operation, FilterValueConverter.Parse(qf.ValueString, qf.Token.Token.Type, qf.Operation.IsList()))).ToList();
            }

            qr.Columns = MergeColumns(userQuery);
            qr.Orders  = userQuery.Orders.Select(qo => new Order(qo.Token.Token, qo.OrderType)).ToList();

            qr.Pagination = userQuery.GetPagination() ?? new Pagination.All();

            return(qr);
        }
Пример #18
0
        public ActionResult View(Lite <UserQueryEntity> lite, FindOptions findOptions, Lite <Entity> currentEntity)
        {
            UserQueryPermission.ViewUserQuery.AssertAuthorized();

            UserQueryEntity uq = UserQueryLogic.RetrieveUserQuery(lite);

            using (uq.EntityType == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity.Retrieve()))
            {
                if (findOptions == null)
                {
                    findOptions = uq.ToFindOptions();
                }
                else
                {
                    findOptions.ApplyUserQuery(uq);
                }
            }

            return(Finder.SearchPage(this, findOptions));
        }
Пример #19
0
        public override void Execute()
        {
            WriteLiteral("\r\n");


            #line 8 "..\..\Dashboard\Views\SearchControlPart.cshtml"
            using (var tc = Html.TypeContext <UserQueryPartEntity>())
            {
                UserQueryEntity uq        = tc.Value.UserQuery;
                object          queryName = Finder.Manager.QuerySettings.Keys.FirstEx(k => QueryUtils.GetKey(k) == uq.Query.Key);

                FindOptions fo = new FindOptions(queryName)
                {
                    ShowHeader     = false,
                    ShowFooter     = false,
                    AllowSelection = tc.Value.RenderMode == UserQueryPartRenderMode.SearchControl,
                    SearchOnLoad   = true,
                };



            #line default
            #line hidden

            #line 21 "..\..\Dashboard\Views\SearchControlPart.cshtml"
                Write(Html.SearchControl(uq, fo, new Context(null, Model.Prefix), sc => sc.AvoidFullScreenButton = true));


            #line default
            #line hidden

            #line 21 "..\..\Dashboard\Views\SearchControlPart.cshtml"
                ;
            }

            #line default
            #line hidden
        }
Пример #20
0
        public static void ApplyUserQuery(this FindOptions findOptions, UserQueryEntity userQuery)
        {
            if (!userQuery.WithoutFilters)
            {
                findOptions.FilterOptions.RemoveAll(fo => !fo.Frozen);

                findOptions.FilterOptions.AddRange(userQuery.Filters.Select(qf => new FilterOption
                {
                    Token      = qf.Token.Token,
                    ColumnName = qf.Token.TokenString,
                    Operation  = qf.Operation,
                    Value      = FilterValueConverter.Parse(qf.ValueString, qf.Token.Token.Type, qf.Operation.IsList()),
                }));
            }

            findOptions.ColumnOptionsMode = userQuery.ColumnsMode;

            findOptions.ColumnOptions.Clear();
            findOptions.ColumnOptions.AddRange(userQuery.Columns.Select(qc => new ColumnOption
            {
                Token       = qc.Token.Token,
                ColumnName  = qc.Token.TokenString,
                DisplayName = qc.DisplayName.DefaultText(null),
            }));

            findOptions.OrderOptions.Clear();
            findOptions.OrderOptions.AddRange(userQuery.Orders.Select(qo => new OrderOption
            {
                Token      = qo.Token.Token,
                ColumnName = qo.Token.TokenString,
                OrderType  = qo.OrderType
            }));

            findOptions.Pagination       = userQuery.GetPagination();
            findOptions.ShowFilterButton = userQuery.ShowFilterButton;
            findOptions.SearchOnLoad     = userQuery.SearchOnLoad;
        }
Пример #21
0
        static SqlPreCommand ProcessUserQuery(Replacements replacements, Table table, UserQueryEntity uq)
        {
            try
            {
                Console.Clear();

                SafeConsole.WriteLineColor(ConsoleColor.White, "UserQuery: " + uq.DisplayName);
                Console.WriteLine(" Query: " + uq.Query.Key);

                if (uq.Filters.Any(a => a.Token.ParseException != null) ||
                    uq.Columns.Any(a => a.Token != null && a.Token.ParseException != null) ||
                    uq.Orders.Any(a => a.Token.ParseException != null))
                {
                    QueryDescription qd = DynamicQueryManager.Current.QueryDescription(uq.Query.ToQueryName());

                    if (uq.Filters.Any())
                    {
                        Console.WriteLine(" Filters:");
                        foreach (var item in uq.Filters.ToList())
                        {
                            QueryTokenEmbedded token = item.Token;
                            switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement, "{0} {1}".FormatWith(item.Operation, item.ValueString), allowRemoveToken: true, allowReCreate: false))
                            {
                            case FixTokenResult.Nothing: break;

                            case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uq));

                            case FixTokenResult.RemoveToken: uq.Filters.Remove(item); break;

                            case FixTokenResult.SkipEntity: return(null);

                            case FixTokenResult.Fix: item.Token = token; break;

                            default: break;
                            }
                        }
                    }

                    if (uq.Columns.Any())
                    {
                        Console.WriteLine(" Columns:");
                        foreach (var item in uq.Columns.ToList())
                        {
                            QueryTokenEmbedded token = item.Token;
                            switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, item.DisplayName.HasText() ? "'{0}'".FormatWith(item.DisplayName) : null, allowRemoveToken: true, allowReCreate: false))
                            {
                            case FixTokenResult.Nothing: break;

                            case FixTokenResult.DeleteEntity:; return(table.DeleteSqlSync(uq));

                            case FixTokenResult.RemoveToken: uq.Columns.Remove(item); break;

                            case FixTokenResult.SkipEntity: return(null);

                            case FixTokenResult.Fix: item.Token = token; break;

                            default: break;
                            }
                        }
                    }

                    if (uq.Orders.Any())
                    {
                        Console.WriteLine(" Orders:");
                        foreach (var item in uq.Orders.ToList())
                        {
                            QueryTokenEmbedded token = item.Token;
                            switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, item.OrderType.ToString(), allowRemoveToken: true, allowReCreate: false))
                            {
                            case FixTokenResult.Nothing: break;

                            case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uq));

                            case FixTokenResult.RemoveToken: uq.Orders.Remove(item); break;

                            case FixTokenResult.SkipEntity: return(null);

                            case FixTokenResult.Fix: item.Token = token; break;

                            default: break;
                            }
                        }
                    }
                }

                foreach (var item in uq.Filters.ToList())
                {
retry:
                    string val = item.ValueString;
                    switch (QueryTokenSynchronizer.FixValue(replacements, item.Token.Token.Type, ref val, allowRemoveToken: true, isList: item.Operation.IsList()))
                    {
                    case FixTokenResult.Nothing: break;

                    case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uq));

                    case FixTokenResult.RemoveToken: uq.Filters.Remove(item); break;

                    case FixTokenResult.SkipEntity: return(null);

                    case FixTokenResult.Fix: item.ValueString = val; goto retry;
                    }
                }

                if (uq.WithoutFilters)
                {
                    uq.Filters.Clear();
                }

                if (!uq.ShouldHaveElements && uq.ElementsPerPage.HasValue)
                {
                    uq.ElementsPerPage = null;
                }

                if (uq.ShouldHaveElements && !uq.ElementsPerPage.HasValue)
                {
                    uq.ElementsPerPage = 20;
                }

                Console.Clear();

                using (replacements.WithReplacedDatabaseName())
                    return(table.UpdateSqlSync(uq, includeCollections: true));
            }
            catch (Exception e)
            {
                return(new SqlPreCommandSimple("-- Exception in {0}: {1}".FormatWith(uq.BaseToString(), e.Message)));
            }
        }
Пример #22
0
        public static MenuItem Construct(SearchControl sc)
        {
            List <Lite <UserQueryEntity> > userQueries = null;
            UserQueryEntity current = null;

            MenuItem miResult = new MenuItem
            {
                Icon = ExtensionsImageLoader.GetImageSortName("favorite.png").ToSmallImage()
            };

            MenuItem edit   = null;
            MenuItem remove = null;

            Action updatecurrent = () =>
            {
                miResult.Header = new TextBlock
                {
                    Inlines =
                    {
                        new Run(
                            current == null ? UserQueryMessage.MyQueries.NiceToString() : current.DisplayName),
                        userQueries.IsNullOrEmpty() ? (Inline) new Run():  new Bold(new Run(" (" + userQueries.Count + ")"))
                    }
                };

                foreach (var item in miResult.Items.OfType <MenuItem>().Where(mi => mi.IsCheckable))
                {
                    item.IsChecked = ((Lite <UserQueryEntity>)item.Tag).RefersTo(current);
                }

                bool isEnabled = current != null && !Navigator.IsReadOnly(current);

                if (edit != null)
                {
                    edit.IsEnabled = isEnabled;
                }

                if (remove != null)
                {
                    remove.IsEnabled = isEnabled;
                }
            };

            Action initialize = null;

            RoutedEventHandler new_Clicked = (object sender, RoutedEventArgs e) =>
            {
                e.Handled = true;

                sc.FocusSearch(); //Commit RealValue bindings

                UserQueryEntity userQuery = UserQueryClient.FromSearchControl(sc);

                var disp = Dispatcher.CurrentDispatcher;
                Navigator.Navigate(userQuery, new NavigateOptions
                {
                    View = () => new UserQuery {
                        QueryDescription = sc.Description
                    },
                    Closed = (s, args) =>
                    {
                        disp.Invoke(() =>
                        {
                            initialize();

                            if (userQuery.IdOrNull != null)
                            {
                                current = userQuery;
                            }

                            updatecurrent();
                        });
                    }
                });
            };

            RoutedEventHandler edit_Clicked = (object sender, RoutedEventArgs e) =>
            {
                e.Handled = true;

                var d = Dispatcher.CurrentDispatcher;
                Navigator.Navigate(current.ToLite().Retrieve(), new NavigateOptions
                {
                    View = () => new UserQuery {
                        QueryDescription = sc.Description
                    },
                    Closed = (s, args) =>
                    {
                        d.Invoke(() =>
                        {
                            initialize();
                            updatecurrent();
                        });
                    }
                });
            };

            RoutedEventHandler remove_Clicked = (object sender, RoutedEventArgs e) =>
            {
                e.Handled = true;

                if (MessageBox.Show(UserQueryMessage.AreYouSureToRemove0.NiceToString().FormatWith(current), UserQueryMessage.RemoveUserQuery.NiceToString(),
                                    MessageBoxButton.YesNo, MessageBoxImage.Exclamation, MessageBoxResult.No) == MessageBoxResult.Yes)
                {
                    current.ToLite().DeleteLite(UserQueryOperation.Delete);

                    initialize();

                    updatecurrent();
                }
            };

            RoutedEventHandler menuItem_Clicked = (object sender, RoutedEventArgs e) =>
            {
                e.Handled = true;

                if (e.OriginalSource is MenuItem b)
                {
                    Lite <UserQueryEntity> userQuery = (Lite <UserQueryEntity>)b.Tag;

                    var uq = Server.Return((IUserQueryServer s) => s.RetrieveUserQuery(userQuery));

                    UserQueryClient.ToSearchControl(uq, sc);

                    current = uq;

                    updatecurrent();

                    sc.Search();
                }
            };

            initialize = () =>
            {
                miResult.Items.Clear();

                userQueries = Server.Return((IUserQueryServer s) => s.GetUserQueries(sc.QueryName));

                if (current != null && !userQueries.Contains(current.ToLite()))
                {
                    current = null;
                }

                if (userQueries.Count > 0)
                {
                    foreach (Lite <UserQueryEntity> report in userQueries.OrderBy(a => a.ToString()))
                    {
                        MenuItem mi = new MenuItem()
                        {
                            IsCheckable = true,
                            Header      = report.ToString(),
                            Tag         = report,
                        };
                        mi.Click += menuItem_Clicked;
                        miResult.Items.Add(mi);
                    }
                }

                if (Navigator.IsNavigable(typeof(UserQueryEntity), isSearch: true))
                {
                    miResult.Items.Add(new Separator());

                    if (Navigator.IsCreable(typeof(UserQueryEntity), true))
                    {
                        miResult.Items.Add(new MenuItem()
                        {
                            Header = EntityControlMessage.Create.NiceToString(),
                            Icon   = ExtensionsImageLoader.GetImageSortName("add.png").ToSmallImage()
                        }.Handle(MenuItem.ClickEvent, new_Clicked));
                    }

                    miResult.Items.Add(edit = new MenuItem()
                    {
                        Header = UserQueryMessage.Edit.NiceToString(),
                        Icon   = ExtensionsImageLoader.GetImageSortName("edit.png").ToSmallImage()
                    }.Handle(MenuItem.ClickEvent, edit_Clicked));

                    miResult.Items.Add(remove = new MenuItem()
                    {
                        Header = EntityControlMessage.Remove.NiceToString(),
                        Icon   = ExtensionsImageLoader.GetImageSortName("remove.png").ToSmallImage()
                    }.Handle(MenuItem.ClickEvent, remove_Clicked));
                }
            };

            initialize();

            var autoSet = UserQueryClient.GetUserQuery(sc);

            if (autoSet != null)
            {
                UserQueryClient.ToSearchControl(autoSet, sc);
                current = autoSet;

                updatecurrent();

                sc.Search();
            }
            else
            {
                updatecurrent();
            }

            return(miResult);
        }
Пример #23
0
 public static void SetUserQuery(DependencyObject obj, UserQueryEntity value)
 {
     obj.SetValue(UserQueryProperty, value);
 }
Пример #24
0
        public static MvcHtmlString SearchControl(this HtmlHelper helper, UserQueryEntity userQuery, Context context, Action <SearchControl> searchControl = null)
        {
            FindOptions findOptions = userQuery.ToFindOptions();

            return(helper.SearchControl(userQuery, findOptions, context, searchControl));
        }
Пример #25
0
        static SqlPreCommand?ProcessUserQuery(Replacements replacements, Table table, UserQueryEntity uq)
        {
            Console.Write(".");
            try
            {
                using (DelayedConsole.Delay(() => SafeConsole.WriteLineColor(ConsoleColor.White, "UserQuery: " + uq.DisplayName)))
                    using (DelayedConsole.Delay(() => Console.WriteLine(" Query: " + uq.Query.Key)))
                    {
                        if (uq.Filters.Any(a => a.Token?.ParseException != null) ||
                            uq.Columns.Any(a => a.Token?.ParseException != null) ||
                            uq.Orders.Any(a => a.Token.ParseException != null))
                        {
                            QueryDescription qd = QueryLogic.Queries.QueryDescription(uq.Query.ToQueryName());

                            if (uq.Filters.Any())
                            {
                                using (DelayedConsole.Delay(() => Console.WriteLine(" Filters:")))
                                {
                                    foreach (var item in uq.Filters.ToList())
                                    {
                                        if (item.Token == null)
                                        {
                                            continue;
                                        }

                                        QueryTokenEmbedded token = item.Token;
                                        switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement, "{0} {1}".FormatWith(item.Operation, item.ValueString), allowRemoveToken: true, allowReCreate: false))
                                        {
                                        case FixTokenResult.Nothing: break;

                                        case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uq, u => u.Guid == uq.Guid));

                                        case FixTokenResult.RemoveToken: uq.Filters.Remove(item); break;

                                        case FixTokenResult.SkipEntity: return(null);

                                        case FixTokenResult.Fix: item.Token = token; break;

                                        default: break;
                                        }
                                    }
                                }
                            }

                            if (uq.Columns.Any())
                            {
                                using (DelayedConsole.Delay(() => Console.WriteLine(" Columns:")))
                                {
                                    foreach (var item in uq.Columns.ToList())
                                    {
                                        QueryTokenEmbedded token = item.Token;
                                        switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, item.DisplayName.HasText() ? "'{0}'".FormatWith(item.DisplayName) : null, allowRemoveToken: true, allowReCreate: false))
                                        {
                                        case FixTokenResult.Nothing: break;

                                        case FixTokenResult.DeleteEntity:; return(table.DeleteSqlSync(uq, u => u.Guid == uq.Guid));

                                        case FixTokenResult.RemoveToken: uq.Columns.Remove(item); break;

                                        case FixTokenResult.SkipEntity: return(null);

                                        case FixTokenResult.Fix: item.Token = token; break;

                                        default: break;
                                        }
                                    }
                                }
                            }

                            if (uq.Orders.Any())
                            {
                                using (DelayedConsole.Delay(() => Console.WriteLine(" Orders:")))
                                {
                                    foreach (var item in uq.Orders.ToList())
                                    {
                                        QueryTokenEmbedded token = item.Token;
                                        switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, item.OrderType.ToString(), allowRemoveToken: true, allowReCreate: false))
                                        {
                                        case FixTokenResult.Nothing: break;

                                        case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uq, u => u.Guid == uq.Guid));

                                        case FixTokenResult.RemoveToken: uq.Orders.Remove(item); break;

                                        case FixTokenResult.SkipEntity: return(null);

                                        case FixTokenResult.Fix: item.Token = token; break;

                                        default: break;
                                        }
                                    }
                                }
                            }
                        }

                        foreach (var item in uq.Filters.Where(f => !f.IsGroup).ToList())
                        {
retry:
                            string?val = item.ValueString;
                            switch (QueryTokenSynchronizer.FixValue(replacements, item.Token !.Token.Type, ref val, allowRemoveToken: true, isList: item.Operation.Value.IsList()))
                            {
                            case FixTokenResult.Nothing: break;