private void SetCurrent(UserChartEntity uc)
{
CurrentUserChart = uc;
this.ChartWindow.Request = CurrentUserChart.ToRequest();
this.ChartWindow.GenerateChart();
}
public ActionResult ViewUserChart(Lite <UserChartEntity> lite, Lite <Entity> currentEntity)
{
UserChartEntity uc = UserChartLogic.RetrieveUserChart(lite);
ChartRequest request = (uc.EntityType == null ? null : CurrentEntityConverter.SetCurrentEntity(currentEntity.Retrieve()))
.Using(_ => uc.ToRequest());
return(OpenChartRequest(request, uc.ToLite()));
}
public static JObject ToChartBuilder(this UserChartEntity userChart, UrlHelper url, string prefix)
{
return(new JObject
{
{ "prefix", prefix },
{ "webQueryName", Finder.ResolveWebQueryName(userChart.QueryName) },
{ "updateChartBuilderUrl", url.Action <ChartController>(cc => cc.UpdateChartBuilder(prefix)) }
});
}
void UserChart_Loaded(object sender, RoutedEventArgs e)
{
if (QueryDescription == null)
{
UserChartEntity uq = (UserChartEntity)DataContext;
QueryDescription = DynamicQueryServer.GetQueryDescription(QueryClient.GetQueryName(uq.Query.Key));
}
chartBuilder.Description = QueryDescription;
tbCurrentEntity.Text = UserQueryMessage.Use0ToFilterCurrentEntity.NiceToString().FormatWith(CurrentEntityConverter.CurrentEntityKey);
}
static void ChartLogic_Retrieved(UserChartEntity userQuery)
{
object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);
foreach (var item in userQuery.Columns)
{
item.parentChart = userQuery;
}
userQuery.ParseData(description);
}
public static void Start()
{
if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod()))
{
TypeClient.Start();
QueryClient.Start();
Navigator.AddSettings(new List <EntitySettings>()
{
new EntitySettings <UserChartEntity> {
View = e => new UserChart(), Icon = ExtensionsImageLoader.GetImageSortName("chartIcon.png")
},
new EntitySettings <ChartScriptEntity> {
View = e => new ChartScript(), Icon = ExtensionsImageLoader.GetImageSortName("chartScript.png")
},
});
UserAssetsClient.Start();
UserAssetsClient.RegisterExportAssertLink <UserChartEntity>();
SearchControl.GetMenuItems += SearchControl_GetCustomMenuItems;
UserChartEntity.SetConverters(query => QueryClient.GetQueryName(query.Key), queryname => QueryClient.GetQuery(queryname));
string processName = Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName);
var main = Registry.CurrentUser
.CreateSubKey("Software")
.CreateSubKey("Microsoft")
.CreateSubKey("Internet Explorer")
.CreateSubKey("Main")
.CreateSubKey("FeatureControl")
.CreateSubKey("FEATURE_BROWSER_EMULATION");
main.SetValue(processName, 9999, RegistryValueKind.DWord);
Constructor.Register <UserChartEntity>(ctx =>
{
MessageBox.Show(Window.GetWindow(ctx.Element),
ChartMessage._0CanOnlyBeCreatedFromTheChartWindow.NiceToString().FormatWith(typeof(UserChartEntity).NicePluralName()),
ChartMessage.CreateNew.NiceToString(),
MessageBoxButton.OK, MessageBoxImage.Information);
return(null);
});
LinksClient.RegisterEntityLinks <Entity>((entity, ctrl) =>
Server.Return((IChartServer us) => us.GetUserChartsEntity(entity.EntityType))
.Select(cp => new UserChartQuickLink(cp, entity)).ToArray());
}
}
public static UserChartEntity ParseData(this UserChartEntity userChart)
{
if (!userChart.IsNew || userChart.queryName == null)
{
throw new InvalidOperationException("userChart should be new and have queryName");
}
userChart.Query = QueryLogic.GetQueryEntity(userChart.queryName);
QueryDescription description = QueryLogic.Queries.QueryDescription(userChart.queryName);
userChart.ParseData(description);
return(userChart);
}
private void UpdateCurrent(UserChartEntity current)
{
Header = new TextBlock
{
Inlines =
{
new Run(
current == null ? typeof(UserChartEntity).NicePluralName() : current.DisplayName),
UserCharts == null || UserCharts.Count == 0 ? (Inline) new Run(): new Bold(new Run(" (" + UserCharts.Count + ")"))
}
};
foreach (var item in this.Items.OfType <MenuItem>().Where(mi => mi.IsCheckable))
{
item.IsChecked = ((Lite <UserChartEntity>)item.Tag).RefersTo(current);
}
}
static void ChartLogic_Retrieved(UserChartEntity userChart, PostRetrievingContext ctx)
{
object?queryName = userChart.Query.ToQueryNameCatch();
if (queryName == null)
{
return;
}
QueryDescription description = QueryLogic.Queries.QueryDescription(queryName);
foreach (var item in userChart.Columns)
{
item.parentChart = userChart;
}
userChart.ParseData(description);
}
internal static ChartRequestModel ToChartRequest(UserChartEntity userChart)
{
var cr = new ChartRequestModel(userChart.Query.ToQueryName())
{
ChartScript = userChart.ChartScript,
Filters = userChart.Filters.ToFilterList(),
Parameters = userChart.Parameters.ToMList(),
};
cr.Columns.ZipForeach(userChart.Columns, (a, b) =>
{
a.Token = b.Token == null ? null : new QueryTokenEmbedded(b.Token.Token);
a.DisplayName = b.DisplayName;
a.OrderByIndex = b.OrderByIndex;
a.OrderByType = b.OrderByType;
});
return(cr);
}
private void New_Clicked(object sender, RoutedEventArgs e)
{
e.Handled = true;
UserChartEntity userChart = ChartRequest.ToUserChart();
userChart = Navigator.View(userChart, new ViewOptions
{
AllowErrors = AllowErrors.No,
View = new UserChart {
QueryDescription = Description
}
});
Initialize();
if (userChart != null)
{
CurrentUserChart = userChart;
}
}
internal static void View(UserChartEntity uc, Entity currentEntity)
{
if (uc.EntityType != null)
{
if (currentEntity == null)
{
var entity = Finder.Find(new FindOptions(Server.GetType(uc.EntityType.ToString())));
if (entity == null)
{
return;
}
currentEntity = entity.Retrieve();
}
}
var query = QueryClient.GetQueryName(uc.Query.Key);
OpenChartRequest(new ChartRequest(query), uc, currentEntity);
}
internal static ChartRequest ToChartRequest(UserChartEntity userChart)
{
var cr = new ChartRequest(userChart.Query.ToQueryName())
{
ChartScript = userChart.ChartScript,
Filters = userChart.Filters.Select(qf =>
new Filter(qf.Token.Token, qf.Operation, FilterValueConverter.Parse(qf.ValueString, qf.Token.Token.Type, qf.Operation.IsList())))
.ToList(),
GroupResults = userChart.GroupResults,
Orders = userChart.Orders.Select(qo => new Order(qo.Token.Token, qo.OrderType)).ToList(),
Parameters = userChart.Parameters.ToMList(),
};
cr.Columns.ZipForeach(userChart.Columns, (a, b) =>
{
a.Token = b.Token == null ? null : new QueryTokenEmbedded(b.Token.Token);
a.DisplayName = b.DisplayName;
});
return(cr);
}
internal static void OpenChartRequest(ChartRequest chartRequest, UserChartEntity uc, Entity currentEntity)
{
Navigator.OpenIndependentWindow(() =>
{
var crw = new ChartRequestWindow()
{
DataContext = chartRequest,
Title = ChartMessage.ChartOf0.NiceToString().FormatWith(QueryUtils.GetNiceName(chartRequest.QueryName)),
Icon = Finder.Manager.GetFindIcon(chartRequest.QueryName, false) ?? ExtensionsImageLoader.GetImageSortName("chartIcon.png")
};
if (uc != null)
{
SetUserChart(crw, uc);
}
if (currentEntity != null)
{
UserAssetsClient.SetCurrentEntity(crw, currentEntity);
}
return(crw);
});
}
static void ChartLogic_Retrieved(UserChartEntity userChart)
{
object queryName;
try
{
queryName = QueryLogic.ToQueryName(userChart.Query.Key);
}
catch (KeyNotFoundException ex) when(StartParameters.IgnoredCodeErrors != null)
{
StartParameters.IgnoredCodeErrors.Add(ex);
return;
}
QueryDescription description = QueryLogic.Queries.QueryDescription(queryName);
foreach (var item in userChart.Columns)
{
item.parentChart = userChart;
}
userChart.ParseData(description);
}
public override void OnSelected(UserChartOmniboxResult result, Window window)
{
UserChartEntity uc = result.UserChart.RetrieveAndForget();
ChartClient.View(uc, null);
}
static SqlPreCommand?ProcessUserChart(Replacements replacements, Table table, UserChartEntity uc)
{
Console.Write(".");
using (DelayedConsole.Delay(() => SafeConsole.WriteLineColor(ConsoleColor.White, "UserChart: " + uc.DisplayName)))
using (DelayedConsole.Delay(() => Console.WriteLine(" ChartScript: " + uc.ChartScript.ToString())))
using (DelayedConsole.Delay(() => Console.WriteLine(" Query: " + uc.Query.Key)))
{
try
{
if (uc.Filters.Any(a => a.Token?.ParseException != null) ||
uc.Columns.Any(a => a.Token?.ParseException != null))
{
QueryDescription qd = QueryLogic.Queries.QueryDescription(uc.Query.ToQueryName());
if (uc.Filters.Any())
{
using (DelayedConsole.Delay(() => Console.WriteLine(" Filters:")))
{
foreach (var item in uc.Filters.ToList())
{
if (item.Token != null)
{
QueryTokenEmbedded token = item.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | SubTokensOptions.CanAggregate, "{0} {1}".FormatWith(item.Operation, item.ValueString), allowRemoveToken: true, allowReCreate: false))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc, u => u.Guid == uc.Guid));
case FixTokenResult.RemoveToken: uc.Filters.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
default: break;
}
}
}
}
}
if (uc.Columns.Any())
{
using (DelayedConsole.Delay(() => Console.WriteLine(" Columns:")))
{
foreach (var item in uc.Columns.ToList())
{
if (item.Token == null)
{
continue;
}
QueryTokenEmbedded token = item.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement | SubTokensOptions.CanAggregate, item.ScriptColumn.DisplayName, allowRemoveToken: item.ScriptColumn.IsOptional, allowReCreate: false))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc, u => u.Guid == uc.Guid));
case FixTokenResult.RemoveToken: item.Token = null; break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
default: break;
}
}
}
}
}
foreach (var item in uc.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;
public static void SetUserChart(DependencyObject obj, UserChartEntity value)
{
obj.SetValue(UserChartProperty, value);
}
public override void Execute()
{
WriteLiteral("\r\n\r\n");
#line 11 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(Html.ScriptCss("~/Chart/Content/Chart.css"));
#line default
#line hidden
WriteLiteral("\r\n\r\n");
#line 13 "..\..\Dashboard\Views\UserChartPart.cshtml"
using (var tc = Html.TypeContext <UserChartPartEntity>())
{
UserChartEntity uc = tc.Value.UserChart;
ChartRequest request = uc.ToRequest();
using (var crc = new TypeContext <ChartRequest>(request, tc.Prefix))
{
#line default
#line hidden
WriteLiteral(" <div");
WriteAttribute("id", Tuple.Create(" id=\"", 541), Tuple.Create("\"", 576)
#line 20 "..\..\Dashboard\Views\UserChartPart.cshtml"
, Tuple.Create(Tuple.Create("", 546), Tuple.Create <System.Object, System.Int32>(crc.Compose("sfChartControl")
#line default
#line hidden
, 546), false)
);
WriteLiteral(" class=\"sf-chart-control SF-control-container\"");
WriteLiteral(">\r\n <div");
WriteLiteral(" style=\"display: none\"");
WriteLiteral(">\r\n");
WriteLiteral(" ");
#line 22 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(Html.HiddenRuntimeInfo(crc));
#line default
#line hidden
WriteLiteral("\r\n");
WriteLiteral(" ");
#line 23 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(Html.Hidden(crc.Compose("sfOrders"), request.Orders.IsNullOrEmpty() ? "" :
(request.Orders.ToString(oo => (oo.OrderType == OrderType.Ascending ? "" : "-") + oo.Token.FullKey(), ";") + ";")));
#line default
#line hidden
WriteLiteral("\r\n");
#line 25 "..\..\Dashboard\Views\UserChartPart.cshtml"
#line default
#line hidden
#line 25 "..\..\Dashboard\Views\UserChartPart.cshtml"
ViewData[ViewDataKeys.QueryDescription] = DynamicQueryManager.Current.QueryDescription(request.QueryName);
ViewData[ViewDataKeys.FilterOptions] = request.Filters.Select(f => new FilterOption {
Token = f.Token, Operation = f.Operation, Value = f.Value
}).ToList();
#line default
#line hidden
WriteLiteral("\r\n");
WriteLiteral(" ");
#line 29 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(Html.Partial(Finder.Manager.FilterBuilderView, crc));
#line default
#line hidden
WriteLiteral("\r\n <div");
WriteAttribute("id", Tuple.Create(" id=\"", 1325), Tuple.Create("\"", 1369)
#line 30 "..\..\Dashboard\Views\UserChartPart.cshtml"
, Tuple.Create(Tuple.Create("", 1330), Tuple.Create <System.Object, System.Int32>(crc.Compose("sfChartBuilderContainer")
#line default
#line hidden
, 1330), false)
);
WriteLiteral(" class=\"SF-control-container\"");
WriteLiteral(">\r\n");
WriteLiteral(" ");
#line 31 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(Html.Partial(ChartClient.ChartBuilderView, crc));
#line default
#line hidden
WriteLiteral("\r\n </div>\r\n <script");
WriteLiteral(" type=\"text/javascript\"");
WriteLiteral(">\r\n require([\"");
#line 34 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(ChartClient.Module);
#line default
#line hidden
WriteLiteral("\"], function (Chart) {\r\n var options = ");
#line 35 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(MvcHtmlString.Create(uc.ToRequest().ToChartRequest(Url, tc.Prefix, tc.Value.ShowData ? ChartRequestMode.data: ChartRequestMode.chart).ToString()));
#line default
#line hidden
WriteLiteral(";\r\n new Chart.ChartRequest(options);\r\n });\r\n " +
" </script>\r\n </div> \r\n <div");
WriteAttribute("id", Tuple.Create(" id=\"", 1919), Tuple.Create("\"", 1952)
#line 40 "..\..\Dashboard\Views\UserChartPart.cshtml"
, Tuple.Create(Tuple.Create("", 1924), Tuple.Create <System.Object, System.Int32>(Model.Compose("divResults")
#line default
#line hidden
, 1924), false)
);
WriteLiteral(" class=\"sf-search-results-container\"");
WriteLiteral(">\r\n");
WriteLiteral(" ");
#line 41 "..\..\Dashboard\Views\UserChartPart.cshtml"
Write(JavascriptMessage.searchForResults.NiceToString());
#line default
#line hidden
WriteLiteral("\r\n </div>\r\n </div>\r\n");
#line 44 "..\..\Dashboard\Views\UserChartPart.cshtml"
}
}
#line default
#line hidden
}
public static void Start(HttpConfiguration config)
{
UserAssetServer.Start(config);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
CustomizeChartRequest();
PropertyConverter.GetPropertyConverters(typeof(ChartScriptParameterEmbedded)).Add("enumValues", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var csp = (ChartScriptParameterEmbedded)ctx.Entity;
if (csp.Type == ChartParameterType.Enum)
{
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, csp.GetEnumValues().Select(a => new { name = a.Name, typeFilter = a.TypeFilter }).ToList());
}
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
EntityJsonConverter.AfterDeserilization.Register((ChartRequest cr) =>
{
if (cr.ChartScript != null)
{
cr.ChartScript.SynchronizeColumns(cr);
}
if (cr.QueryName != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(cr.QueryName);
if (cr.Columns != null)
{
foreach (var c in cr.Columns)
{
c.ParseData(cr, qd, SubTokensOptions.CanElement | (c.IsGroupKey == false ? SubTokensOptions.CanAggregate : 0));
}
}
}
});
EntityJsonConverter.AfterDeserilization.Register((UserChartEntity uc) =>
{
if (uc.ChartScript != null)
{
uc.ChartScript.SynchronizeColumns(uc);
}
if (uc.Query != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(uc.Query.ToQueryName());
uc.ParseData(qd);
}
});
UserChartEntity.SetConverters(
query => QueryLogic.ToQueryName(query.Key),
queryName => QueryLogic.GetQueryEntity(queryName));
EntityPackTS.AddExtension += ep =>
{
if (ep.entity.IsNew || !ChartPermission.ViewCharting.IsAuthorized())
{
return;
}
var userCharts = UserChartLogic.GetUserChartsEntity(ep.entity.GetType());
if (userCharts.Any())
{
ep.Extension.Add("userCharts", userCharts);
}
};
}
public static void Start()
{
if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod()))
{
QueryClient.Start();
UserAssetsClient.Start();
UserAssetsClient.RegisterExportAssertLink <UserChartEntity>();
LinksClient.RegisterEntityLinks <UserChartEntity>((lite, ctx) => new[]
{
new QuickLinkAction(ChartMessage.Preview, RouteHelper.New().Action <ChartController>(cc => cc.ViewUserChart(lite, null)))
{
IsVisible = ChartPermission.ViewCharting.IsAuthorized()
}
});
Func <SubTokensOptions, Mapping <QueryTokenEmbedded> > qtMapping = ops => ctx =>
{
string tokenStr = UserAssetsHelper.GetTokenString(ctx);
string queryKey = ctx.Parent.Parent.Parent.Inputs[TypeContextUtilities.Compose("Query", "Key")];
object queryName = QueryLogic.ToQueryName(queryKey);
var chart = ((UserChartEntity)ctx.Parent.Parent.Parent.UntypedValue);
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(queryName);
return(new QueryTokenEmbedded(QueryUtils.Parse(tokenStr, qd, ops | (chart.GroupResults ? SubTokensOptions.CanAggregate : 0))));
};
Navigator.AddSettings(new List <EntitySettings>
{
new EntitySettings <UserChartEntity> {
PartialViewName = _ => ChartClient.ViewPrefix.FormatWith("UserChart"), IsCreable = EntityWhen.Never
}
});
Navigator.EntitySettings <UserChartEntity>().MappingMain = Navigator.EntitySettings <UserChartEntity>().MappingLine =
new EntityMapping <UserChartEntity>(true)
.SetProperty(cb => cb.Columns, new ChartClient.MListCorrelatedOrDefaultMapping <ChartColumnEmbedded>(ChartClient.MappingChartColumn))
.SetProperty(cr => cr.Filters, new MListMapping <QueryFilterEmbedded>
{
ElementMapping = new EntityMapping <QueryFilterEmbedded>(false)
.CreateProperty(a => a.Operation)
.CreateProperty(a => a.ValueString)
.SetProperty(a => a.Token, qtMapping(SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement))
})
.SetProperty(cr => cr.Orders, new MListMapping <QueryOrderEmbedded>
{
ElementMapping = new EntityMapping <QueryOrderEmbedded>(false)
.CreateProperty(a => a.OrderType)
.SetProperty(a => a.Token, qtMapping(SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement))
})
.SetProperty(cb => cb.Parameters, new MListDictionaryMapping <ChartParameterEmbedded, string>(p => p.Name)
{
OnlyIfPossible = true
});
RouteTable.Routes.MapRoute(null, "UC/{webQueryName}/{lite}",
new { controller = "Chart", action = "ViewUserChart" });
UserChartEntity.SetConverters(query => QueryLogic.ToQueryName(query.Key), queryName =>
QueryLogic.GetQueryEntity(queryName));
OperationClient.AddSetting(new EntityOperationSettings <UserChartEntity>(UserChartOperation.Delete)
{
Click = ctx => ChartClient.Module["deleteUserChart"](ctx.Options(), Finder.FindRoute(((UserChartEntity)ctx.Entity).Query.ToQueryName())),
});
LinksClient.RegisterEntityLinks <Entity>((entity, ctrl) =>
{
if (!ChartPermission.ViewCharting.IsAuthorized())
{
return(null);
}
return(UserChartLogic.GetUserChartsEntity(entity.EntityType)
.Select(cp => new UserChartQuickLink(cp, entity)).ToArray());
});
}
}
static SqlPreCommand ProcessUserChart(Replacements replacements, Table table, UserChartEntity uc)
{
try
{
Console.Clear();
SafeConsole.WriteLineColor(ConsoleColor.White, "UserChart: " + uc.DisplayName);
Console.WriteLine(" ChartScript: " + uc.ChartScript.ToString());
Console.WriteLine(" Query: " + uc.Query.Key);
if (uc.Filters.Any(a => a.Token.ParseException != null) ||
uc.Columns.Any(a => a.Token != null && a.Token.ParseException != null) ||
uc.Orders.Any(a => a.Token.ParseException != null))
{
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(uc.Query.ToQueryName());
SubTokensOptions canAggregate = uc.GroupResults ? SubTokensOptions.CanAggregate : 0;
if (uc.Filters.Any())
{
Console.WriteLine(" Filters:");
foreach (var item in uc.Filters.ToList())
{
QueryTokenEmbedded token = item.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | canAggregate, "{0} {1}".FormatWith(item.Operation, item.ValueString), allowRemoveToken: true, allowReCreate: false))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc));
case FixTokenResult.RemoveToken: uc.Filters.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
default: break;
}
}
}
if (uc.Columns.Any())
{
Console.WriteLine(" Columns:");
foreach (var item in uc.Columns.ToList())
{
QueryTokenEmbedded token = item.Token;
if (item.Token == null)
{
continue;
}
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement | canAggregate, item.ScriptColumn.DisplayName, allowRemoveToken: item.ScriptColumn.IsOptional, allowReCreate: false))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc));
case FixTokenResult.RemoveToken: item.Token = null; break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
default: break;
}
}
}
if (uc.Orders.Any())
{
Console.WriteLine(" Orders:");
foreach (var item in uc.Orders.ToList())
{
QueryTokenEmbedded token = item.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement | canAggregate, item.OrderType.ToString(), allowRemoveToken: true, allowReCreate: false))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc));
case FixTokenResult.RemoveToken: uc.Orders.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
default: break;
}
}
}
}
foreach (var item in uc.Filters.ToList())
{
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(uc));
case FixTokenResult.RemoveToken: uc.Filters.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.ValueString = val; break;
}
}
foreach (var item in uc.Columns)
{
uc.FixParameters(item);
}
foreach (var item in uc.Parameters)
{
string val = item.Value;
retry:
switch (FixParameter(item, ref val))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(uc));
case FixTokenResult.RemoveToken: uc.Parameters.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: { item.Value = val; goto retry; }
}
}
try
{
return(table.UpdateSqlSync(uc, includeCollections: true));
}
catch (Exception e)
{
Console.WriteLine("Integrity Error:");
SafeConsole.WriteLineColor(ConsoleColor.DarkRed, e.Message);
while (true)
{
SafeConsole.WriteLineColor(ConsoleColor.Yellow, "- s: Skip entity");
SafeConsole.WriteLineColor(ConsoleColor.Red, "- d: Delete entity");
string answer = Console.ReadLine();
if (answer == null)
{
throw new InvalidOperationException("Impossible to synchronize interactively without Console");
}
answer = answer.ToLower();
if (answer == "s")
{
return(null);
}
if (answer == "d")
{
return(table.DeleteSqlSync(uc));
}
}
}
}
catch (Exception e)
{
return(new SqlPreCommandSimple("-- Exception in {0}: {1}".FormatWith(uc.BaseToString(), e.Message)));
}
finally
{
Console.Clear();
}
}
public static void Start(IApplicationBuilder app)
{
UserAssetServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
CustomizeChartRequest();
SignumServer.WebEntityJsonConverterFactory.AfterDeserilization.Register((ChartRequestModel cr) =>
{
if (cr.ChartScript != null)
{
cr.GetChartScript().SynchronizeColumns(cr, null);
}
if (cr.QueryName != null)
{
var qd = QueryLogic.Queries.QueryDescription(cr.QueryName);
if (cr.Columns != null)
{
foreach (var c in cr.Columns)
{
c.ParseData(cr, qd, SubTokensOptions.CanElement | SubTokensOptions.CanAggregate);
}
}
}
});
SignumServer.WebEntityJsonConverterFactory.AfterDeserilization.Register((UserChartEntity uc) =>
{
if (uc.ChartScript != null)
{
uc.GetChartScript().SynchronizeColumns(uc, null);
}
if (uc.Query != null)
{
var qd = QueryLogic.Queries.QueryDescription(uc.Query.ToQueryName());
uc.ParseData(qd);
}
});
UserChartEntity.SetConverters(
query => QueryLogic.ToQueryName(query.Key),
queryName => QueryLogic.GetQueryEntity(queryName));
EntityPackTS.AddExtension += ep =>
{
if (ep.entity.IsNew || !ChartPermission.ViewCharting.IsAuthorized() || TypeAuthLogic.GetAllowed(typeof(UserChartEntity)).MaxDB() == TypeAllowedBasic.None)
{
return;
}
var userCharts = UserChartLogic.GetUserChartsEntity(ep.entity.GetType());
if (userCharts.Any())
{
ep.extension.Add("userCharts", userCharts);
}
};
}
