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);
}
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);
}
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;
}
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)
});
};
}
static void UserQueryLogic_Retrieved(UserQueryEntity userQuery)
{
object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);
userQuery.ParseData(description);
}
public static FindOptions ToFindOptions(this UserQueryEntity userQuery)
{
object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
var result = new FindOptions(queryName);
result.ApplyUserQuery(userQuery);
return(result);
}
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);
}
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));
}
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)
});
}
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);
}
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);
}
});
}
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);
}
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));
}
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);
}
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));
}
}
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);
}
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);
}
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));
}
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
}
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;
}
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)));
}
}
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);
}
public static void SetUserQuery(DependencyObject obj, UserQueryEntity value)
{
obj.SetValue(UserQueryProperty, value);
}
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));
}
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;
