public static void Initialize(Device device) { m_HWQueries = new List<Query>(); m_HWQueriesDescs = new List<String>(); m_QueriesStack = new Stack<int>(); m_DisjointQueries = new List<Query>(); m_CorrespondingQueryEnds = new List<int>(); m_PendingFrames = new Queue<PendingFrameQueries>(); QueryDescription queryDesc = new QueryDescription(QueryType.Timestamp, QueryFlags.None); for (int i = 0; i < MAX_HW_QUERIES; ++i ) { m_HWQueries.Add(new Query(device, queryDesc)); m_HWQueriesDescs.Add(""); m_CorrespondingQueryEnds.Add(0); } queryDesc = new QueryDescription(QueryType.TimestampDisjoint, QueryFlags.None); for (int i = 0; i < MAX_HW_DISJOINT_QUERIES; ++i) { m_DisjointQueries.Add(new Query(device, queryDesc)); } }
public DX11OcclusionQuery(DX11RenderContext context) { this.context = context; QueryDescription qd = new QueryDescription(); qd.Flags = QueryFlags.None; qd.Type = QueryType.Occlusion; this.query = new Query(context.Device, qd); }
public DX11PipelineQuery(DX11RenderContext context) { this.context = context; QueryDescription qd = new QueryDescription(); qd.Flags = QueryFlags.None; qd.Type = QueryType.PipelineStatistics; this.query = new Query(context.Device, qd); }
public DX11StreamOutQuery(DX11RenderContext context) { this.context = context; QueryDescription qd = new QueryDescription(); qd.Flags = QueryFlags.None; qd.Type = QueryType.StreamOutputStatistics; this.query = new Query(context.Device, qd); }
private void PlatformConstruct() { //if (graphicsDevice._d3dDevice.FeatureLevel == SharpDX.Direct3D.FeatureLevel.Level_9_1) // throw new NotSupportedException("The Reach profile does not support occlusion queries."); var queryDescription = new QueryDescription { Flags = QueryFlags.None, Type = QueryType.Occlusion }; _query = new Query(GraphicsDevice._d3dDevice, queryDescription); }
internal void LazyInit(QueryType type) { if(m_query == null) { Debug.Assert(!m_type.HasValue); m_type = type; var desc = new QueryDescription(); desc.Type = type; m_query = new Query(MyRender11.Device, desc); } }
/// @brief This method forces an initialization of the query descriptions to base (non limiting) queries public void ForceInit() { m_queryDescriptions = new QueryDescription[5]; QueryDescription desc = new QueryDescription(NodeType.Depth); m_queryDescriptions[0] = desc; desc = new QueryDescription(NodeType.Image); m_queryDescriptions[1] = desc; desc = new QueryDescription(NodeType.User); m_queryDescriptions[2] = desc; desc = new QueryDescription(NodeType.Hands); m_queryDescriptions[3] = desc; desc = new QueryDescription(NodeType.Gesture); m_queryDescriptions[4] = desc; }
public DX11TimeStampQuery(DX11RenderContext context) { this.context = context; QueryDescription qd = new QueryDescription(); qd.Type = QueryType.Timestamp; qd.Flags = QueryFlags.None; this.tstart = new Query(context.Device, qd); this.tend = new Query(context.Device,qd); QueryDescription qdd = new QueryDescription(); qdd.Type = QueryType.TimestampDisjoint; qdd.Flags = QueryFlags.None; this.tsdis = new Query(context.Device, qdd); }
public void StartProfile(String name) { // set the name of the profiling Name = name; QueryDescription desc = new QueryDescription(); desc.Flags = QueryFlags.None; desc.Type = QueryType.TimestampDisjoint; DisjointQuery = new Query(Engine.g_device, desc); desc.Flags = QueryFlags.None; desc.Type = QueryType.Timestamp; TimestampStartQuery = new Query(Engine.g_device, desc); TimestampEndQuery = new Query(Engine.g_device, desc); // Start a disjoint query first Engine.g_device.ImmediateContext.Begin(DisjointQuery); // Insert the start timestamp Engine.g_device.ImmediateContext.Begin(TimestampStartQuery); QueryStarted = true; }
public static byte[] CreateReport(this WordTemplateEntity template, ModifiableEntity model = null, ISystemWordTemplate systemWordTemplate = null, bool avoidConversion = false) { WordTemplatePermission.GenerateReport.AssertAuthorized(); Entity entity = null; if (template.SystemWordTemplate != null) { if (systemWordTemplate == null) { systemWordTemplate = SystemWordTemplateLogic.CreateDefaultSystemWordTemplate(template.SystemWordTemplate, model); } else if (template.SystemWordTemplate.ToType() != systemWordTemplate.GetType()) { throw new ArgumentException("systemWordTemplate should be a {0} instead of {1}".FormatWith(template.SystemWordTemplate.FullClassName, systemWordTemplate.GetType().FullName)); } } else { entity = model as Entity ?? throw new InvalidOperationException("Model should be an Entity"); } using (template.DisableAuthorization ? ExecutionMode.Global() : null) using (CultureInfoUtils.ChangeBothCultures(template.Culture.ToCultureInfo())) { QueryDescription qd = DynamicQueryManager.Current.QueryDescription(template.Query.ToQueryName()); var array = template.ProcessOpenXmlPackage(document => { Dump(document, "0.Original.txt"); var parser = new TemplateParser(document, qd, template.SystemWordTemplate.ToType(), template); parser.ParseDocument(); Dump(document, "1.Match.txt"); parser.CreateNodes(); Dump(document, "2.BaseNode.txt"); parser.AssertClean(); if (parser.Errors.Any()) { throw new InvalidOperationException("Error in template {0}:\r\n".FormatWith(template) + parser.Errors.ToString(e => e.Message, "\r\n")); } var renderer = new TemplateRenderer(document, qd, entity, template.Culture.ToCultureInfo(), systemWordTemplate, template); renderer.MakeQuery(); renderer.RenderNodes(); Dump(document, "3.Replaced.txt"); renderer.AssertClean(); FixDocument(document); Dump(document, "4.Fixed.txt"); if (template.WordTransformer != null) { Transformers.GetOrThrow(template.WordTransformer)(new WordContext { Template = template, Entity = entity, SystemWordTemplate = systemWordTemplate }, document); } }); if (!avoidConversion && template.WordConverter != null) { array = Converters.GetOrThrow(template.WordConverter)(new WordContext { Template = template, Entity = entity, SystemWordTemplate = systemWordTemplate }, array); } return(array); } }
public static List <OrderOption> ExtractOrderOptions(HttpContextBase httpContext, QueryDescription qd, bool canAggregate = false) { List <OrderOption> result = new List <OrderOption>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["orders"]; if (!field.HasText()) { return(result); } var matches = OrderRegex.Matches(field).Cast <Match>(); return(matches.Select(m => { var tokenCapture = m.Groups["token"].Value; OrderType orderType = tokenCapture.StartsWith("-") ? OrderType.Descending : OrderType.Ascending; string token = orderType == OrderType.Ascending ? tokenCapture : tokenCapture.Substring(1, tokenCapture.Length - 1); return new OrderOption { ColumnName = token, Token = QueryUtils.Parse(token, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)), OrderType = orderType }; }).ToList()); }
public static List <ColumnOption> ExtractColumnsOptions(HttpContextBase httpContext, QueryDescription qd, bool canAggregate = false) { List <ColumnOption> result = new List <ColumnOption>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["columns"]; if (!field.HasText()) { return(result); } var matches = ColumnRegex.Matches(field).Cast <Match>(); return(matches.Select(m => { var colName = m.Groups["token"].Value; var token = QueryUtils.Parse(colName, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); return new ColumnOption { Token = token, ColumnName = colName, DisplayName = m.Groups["name"].Success ? DecodeValue(m.Groups["name"].Value) : null }; }).ToList()); }
public static List <Column> MergeColumns(IEnumerable <ColumnOption> columns, ColumnOptionsMode mode, QueryDescription qd) { switch (mode) { case ColumnOptionsMode.Add: return(qd.Columns.Where(cd => !cd.IsEntity).Select(cd => new Column(cd, qd.QueryName)).Concat( columns.Select(co => co.ToColumn())).ToList()); case ColumnOptionsMode.Remove: return(qd.Columns.Where(cd => !cd.IsEntity && !columns.Any(co => co.ColumnName == cd.Name)).Select(cd => new Column(cd, qd.QueryName)).ToList()); case ColumnOptionsMode.Replace: return(columns.Select(co => co.ToColumn()).ToList()); default: throw new InvalidOperationException("{0} is not a valid ColumnOptionMode".FormatWith(mode)); } }
/// <summary> /// Constructs a new <see cref = "T:SharpDX.Direct3D10.Predicate" /> based on the specified description. /// </summary> /// <param name = "device">The device with which to associate the state object.</param> /// <param name = "description">The query description.</param> /// <returns>The newly created object.</returns> public Predicate(Device device, QueryDescription description) : base(IntPtr.Zero) { device.CreatePredicate(description, this); }
public Column ToColumn(QueryDescription qd, bool canAggregate) { var queryToken = QueryUtils.Parse(token, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); return(new Column(queryToken, displayName ?? queryToken.NiceName())); }
public StorageDbReader ExecuteQuery(QueryDescription query) { return(_collector.Api.CreateReader(query.QueryScript)); }
static bool TryParseRemember(Replacements replacements, string tokenString, QueryDescription qd, SubTokensOptions options, out QueryToken?result) { string[] parts = tokenString.Split('.'); result = null; for (int i = 0; i < parts.Length; i++) { string part = parts[i]; QueryToken?newResult = QueryUtils.SubToken(result, qd, options, part); if (newResult != null) { result = newResult; } else { if (i == 0) { var entity = QueryUtils.SubToken(result, qd, options, "Entity"); QueryToken?newSubResult = QueryUtils.SubToken(entity, qd, options, part); if (newSubResult != null) { result = newSubResult; continue; } } if (Replacements.AutoReplacement != null) { Replacements.Selection?sel = Replacements.AutoReplacement(new Replacements.AutoReplacementContext( replacementKey: "QueryToken", oldValue: part, newValues: result.SubTokens(qd, options).Select(a => a.Key).ToList())); if (sel != null && sel.Value.NewValue != null) { newResult = QueryUtils.SubToken(result, qd, options, sel.Value.NewValue); if (newResult != null) { result = newResult; continue; } } } string key = result == null?QueryKey(qd.QueryName) : TypeKey(result.Type); Dictionary <string, string>?dic = replacements.TryGetC(key); if (dic == null) { return(false); } string remainging = parts.Skip(i).ToString("."); string?old = dic.Keys.OrderByDescending(a => a.Length).FirstOrDefault(s => remainging.StartsWith(s)); if (old == null) { return(false); } var subParts = dic[old].Let(s => s.HasText() ? s.Split('.') : new string[0]); for (int j = 0; j < subParts.Length; j++) { string subPart = subParts[j]; QueryToken?subNewResult = QueryUtils.SubToken(result, qd, options, subPart); if (subNewResult == null) { return(false); } result = subNewResult; } i += (old == "" ? 0 : old.Split('.').Length) - 1; } } return(true); }
public Order ToOrder(QueryDescription qd, bool canAggregate) { return(new Order(QueryUtils.Parse(this.token, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)), orderType)); }
public static FixTokenResult FixToken(Replacements replacements, string original, out QueryToken?token, QueryDescription qd, SubTokensOptions options, string?remainingText, bool allowRemoveToken, bool allowReGenerate) { string[] parts = original.Split('.'); if (TryParseRemember(replacements, original, qd, options, out QueryToken? current)) { if (current !.FullKey() != original) { SafeConsole.WriteColor(ConsoleColor.DarkRed, " " + original); Console.Write(" -> "); SafeConsole.WriteColor(ConsoleColor.DarkGreen, current.FullKey()); } Console.WriteLine(remainingText); token = current; return(FixTokenResult.Fix); } while (true) { var tempToken = current !; var result = SelectInteractive(ref tempToken, qd, options, remainingText, allowRemoveToken, allowReGenerate); current = tempToken; switch (result) { case UserAssetTokenAction.DeleteEntity: SafeConsole.WriteLineColor(ConsoleColor.Red, "Entity deleted"); token = null; return(FixTokenResult.DeleteEntity); case UserAssetTokenAction.ReGenerateEntity: if (!allowReGenerate) { throw new InvalidOperationException("Unexpected ReGenerate"); } SafeConsole.WriteLineColor(ConsoleColor.Magenta, "Entity Re-Generated"); token = null; return(FixTokenResult.ReGenerateEntity); case UserAssetTokenAction.RemoveToken: if (!allowRemoveToken) { throw new InvalidOperationException("Unexpected RemoveToken"); } Console.SetCursorPosition(0, Console.CursorTop - 1); SafeConsole.WriteColor(ConsoleColor.DarkRed, " " + original); SafeConsole.WriteColor(ConsoleColor.DarkRed, " (token removed)"); Console.WriteLine(remainingText); token = null; return(FixTokenResult.RemoveToken); case UserAssetTokenAction.SkipEntity: SafeConsole.WriteLineColor(ConsoleColor.DarkYellow, "Entity skipped"); token = null; return(FixTokenResult.SkipEntity); case UserAssetTokenAction.Confirm: Remember(replacements, original, current); Console.SetCursorPosition(0, Console.CursorTop - 1); SafeConsole.WriteColor(ConsoleColor.DarkRed, " " + original); Console.Write(" -> "); SafeConsole.WriteColor(ConsoleColor.DarkGreen, current.FullKey()); Console.WriteLine(remainingText); token = current; return(FixTokenResult.Fix); } } }
static UserAssetTokenAction?SelectInteractive(ref QueryToken token, QueryDescription qd, SubTokensOptions options, string?remainingText, bool allowRemoveToken, bool allowReGenerate) { var top = Console.CursorTop; try { if (Console.Out == null) { throw new InvalidOperationException("Unable to ask for renames to synchronize query tokens without interactive Console. Please use your Terminal application."); } var subTokens = token.SubTokens(qd, options).OrderBy(a => a.Parent != null).ThenByDescending(a => a.Priority).ThenBy(a => a.Key).ToList(); int startingIndex = 0; SafeConsole.WriteColor(ConsoleColor.Cyan, " " + token?.FullKey()); if (remainingText.HasText()) { Console.Write(" " + remainingText); } Console.WriteLine(); bool isRoot = token == null; retry: int maxElements = Console.LargestWindowHeight - 11; subTokens.Skip(startingIndex).Take(maxElements) .Select((s, i) => "- {1,2}: {2} ".FormatWith(i + " ", i + startingIndex, ((isRoot && s.Parent != null) ? "-" : "") + s.Key)).ToConsole(); Console.WriteLine(); int remaining = subTokens.Count - startingIndex - maxElements; if (remaining > 0) { SafeConsole.WriteLineColor(ConsoleColor.White, "- +: Show more values ({0} remaining)", remaining); } if (token != null) { SafeConsole.WriteLineColor(ConsoleColor.White, "- b: Back"); SafeConsole.WriteLineColor(ConsoleColor.Green, "- c: Confirm"); } SafeConsole.WriteLineColor(ConsoleColor.Yellow, "- s: Skip entity"); if (allowRemoveToken) { SafeConsole.WriteLineColor(ConsoleColor.DarkRed, "- r: Remove token"); } if (allowReGenerate) { SafeConsole.WriteLineColor(ConsoleColor.Magenta, "- g: Generate from default template"); } SafeConsole.WriteLineColor(ConsoleColor.Red, "- d: Delete entity"); while (true) { string answer = Console.ReadLine() !; if (answer == null) { throw new InvalidOperationException("Impossible to synchronize interactively without Console"); } answer = answer.ToLower(); if (answer == "+" && remaining > 0) { startingIndex += maxElements; goto retry; } if (answer == "s") { return(UserAssetTokenAction.SkipEntity); } if (answer == "r" && allowRemoveToken) { return(UserAssetTokenAction.RemoveToken); } if (answer == "d") { return(UserAssetTokenAction.DeleteEntity); } if (answer == "g") { return(UserAssetTokenAction.ReGenerateEntity); } if (token != null) { if (answer == "c") { return(UserAssetTokenAction.Confirm); } if (answer == "b") { token = token.Parent !; return(null); } } if (int.TryParse(answer, out int option)) { token = subTokens[option]; return(null); } Console.WriteLine("Error"); } } finally { Clean(top, Console.CursorTop); } }
public static FixTokenResult FixToken(Replacements replacements, ref QueryTokenEmbedded token, QueryDescription qd, SubTokensOptions options, string?remainingText, bool allowRemoveToken, bool allowReCreate) { var t = token; using (DelayedConsole.Delay(() => { SafeConsole.WriteColor(t.ParseException == null ? ConsoleColor.Gray : ConsoleColor.Red, " " + t.TokenString); Console.WriteLine(" " + remainingText); })) { if (token.ParseException == null) { return(FixTokenResult.Nothing); } DelayedConsole.Flush(); FixTokenResult result = FixToken(replacements, token.TokenString, out QueryToken? resultToken, qd, options, remainingText, allowRemoveToken, allowReCreate); if (result == FixTokenResult.Fix) { token = new QueryTokenEmbedded(resultToken !); } return(result); } }
public void ParseData(Entity context, QueryDescription description, SubTokensOptions options) { Token.ParseData(context, description, options); SummaryToken?.ParseData(context, description, options | SubTokensOptions.CanAggregate); }
public JObject ToJS(string prefix) { JObject op = new JObject() { { "prefix", prefix } }; if (FilterOptions.Any()) { QueryDescription queryDescription = DynamicQueryManager.Current.QueryDescription(QueryName); FilterOption.SetFilterTokens(this.FilterOptions, queryDescription, false); } if (QueryName != null) { op.Add("webQueryName", Finder.ResolveWebQueryName(QueryName)); } if (SearchOnLoad == true) { op.Add("searchOnLoad", true); } if (!Navigate) { op.Add("navigate", false); } if (!Create) { op.Add("create", false); } if (!AllowSelection) { op.Add("allowSelection", false); } if (!SelectedItemsContextMenu) { op.Add("selectedItemsContextMenu", false); } if (!AllowChangeColumns) { op.Add("allowChangeColumns", false); } if (!AllowOrder) { op.Add("allowOrder", false); } if (!showHeader) { op.Add("showHeader", false); } if (!showFilters) { op.Add("showFilters", false); } if (!showFilterButton) { op.Add("showFilterButton", false); } if (!showFooter) { op.Add("showFooter", false); } if (!showContextMenu) { op.Add("showContextMenu", false); } if (FilterOptions.Any()) { op.Add("filters", new JArray(filterOptions.Select(f => f.ToJS()))); } if (OrderOptions.Any()) { op.Add("orders", new JArray(OrderOptions.Select(oo => oo.ToJS()))); } if (ColumnOptions.Any()) { op.Add("columns", new JArray(ColumnOptions.Select(co => co.ToJS()))); } if (ColumnOptionsMode != Entities.DynamicQuery.ColumnOptionsMode.Add) { op.Add("columnMode", ColumnOptionsMode.ToString()); } if (Pagination != null) { op.Add("pagination", Pagination.GetMode().ToString()); int?elems = Pagination.GetElementsPerPage(); if (elems != null) { op.Add("elems", elems.Value.ToString()); } } return(op); }
public T ExecuteScalar <T>(QueryDescription query, ObjectBinder objectBinder) { throw new NotImplementedException(); }
internal Column ToColumn(QueryDescription qd) { var queryToken = QueryUtils.Parse(token, qd, SubTokensOptions.CanElement); return(new Column(queryToken, displayName ?? queryToken.NiceName())); }
public override IEnumerable Query(QueryDescription queryDescription, out IEnumerable<ValidationResult> validationErrors, out int totalCount) { Thread.Sleep(queryLatency); return base.Query(queryDescription, out validationErrors, out totalCount); }
public override List <Filter> GetFilters(QueryDescription qd) { return(this.Entity.Filters); }
/// <summary> /// Constructs a new <see cref = "T:SharpDX.Direct3D11.Query" /> based on the specified description. /// </summary> /// <param name = "device">The device with which to associate the state object.</param> /// <param name = "description">The query description.</param> /// <returns>The newly created object.</returns> public Query(Device device, QueryDescription description) : base(IntPtr.Zero) { device.CreateQuery(description, this); }
public override List <Order> GetOrders(QueryDescription queryDescription) { return(this.Entity.Orders); }
public override System.Collections.IEnumerable Query(QueryDescription queryDescription, out IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> validationErrors, out int totalCount) { System.Threading.Thread.Sleep(queryLatency); return base.Query(queryDescription, out validationErrors, out totalCount); }
public virtual List <Order> GetOrders(QueryDescription queryDescription) { return(new List <Order>()); }
public override System.Collections.IEnumerable Query(QueryDescription queryDescription, out IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> validationErrors, out int totalCount) { System.Threading.Thread.Sleep(queryLatency); return(base.Query(queryDescription, out validationErrors, out totalCount)); }
public HiveQueryCacheKey(QueryDescription queryDescription) : this(queryDescription.From, queryDescription.ResultFilters, queryDescription.Criteria, queryDescription.ExcludeOrphans, queryDescription.SortClauses.ToArray())//, queryDescription.Criteria as FieldPredicateExpression) { }
public static List <FilterOption> ExtractFilterOptions(HttpContextBase httpContext, QueryDescription qd, bool canAggregate = false) { List <FilterOption> result = new List <FilterOption>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["filters"]; if (!field.HasText()) { return(result); } var matches = FilterRegex.Matches(field).Cast <Match>(); return(matches.Select(m => { string name = m.Groups["token"].Value; var token = QueryUtils.Parse(name, qd, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); return new FilterOption { ColumnName = name, Token = token, Operation = EnumExtensions.ToEnum <FilterOperation>(m.Groups["op"].Value), Value = Convert(DecodeValue(m.Groups["value"].Value), token.Type), //Frozen = frozen, }; }).ToList()); }
/// <summary> /// Constructs a new <see cref = "T:SharpDX.Direct3D11.Predicate" /> based on the specified description. /// </summary> /// <param name = "device">The device with which to associate the state object.</param> /// <param name = "description">The query description.</param> /// <returns>The newly created object.</returns> public Predicate(Device device, QueryDescription description) : base(IntPtr.Zero) { device.CreatePredicate(description, this); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { FindOptions fo = new FindOptions(); NameValueCollection parameters = controllerContext.HttpContext.Request.Params; if (parameters.AllKeys.Any(name => !name.HasText())) { throw new Exception("Incorrect URL: " + controllerContext.HttpContext.Request.Url.ToString()); } object rawValue = bindingContext.ValueProvider.GetValue("webQueryName")?.RawValue; if (rawValue == null) { return(null); } string webQueryName = rawValue.GetType() == typeof(string[]) ? ((string[])rawValue)[0]: (string)rawValue; if (!webQueryName.HasText()) { throw new InvalidOperationException("webQueryName not provided"); } fo.QueryName = Finder.ResolveQueryName(webQueryName); QueryDescription queryDescription = DynamicQueryManager.Current.QueryDescription(fo.QueryName); fo.FilterOptions = ExtractFilterOptions(controllerContext.HttpContext, queryDescription); fo.OrderOptions = ExtractOrderOptions(controllerContext.HttpContext, queryDescription); fo.ColumnOptions = ExtractColumnsOptions(controllerContext.HttpContext, queryDescription); if (parameters.AllKeys.Contains("allowSelection")) { bool aux; if (bool.TryParse(parameters["allowSelection"], out aux)) { fo.AllowSelection = aux; } } if (parameters.AllKeys.Contains("allowChangeColumns")) { fo.AllowChangeColumns = bool.Parse(parameters["allowChangeColumns"]); } if (parameters.AllKeys.Contains("allowOrder")) { fo.AllowOrder = bool.Parse(parameters["allowOrder"]); } if (parameters.AllKeys.Contains("showHeader")) { fo.ShowHeader = bool.Parse(parameters["showHeader"]); } if (parameters.AllKeys.Contains("showFilters")) { fo.ShowFilters = bool.Parse(parameters["showFilters"]); } if (parameters.AllKeys.Contains("showFilterButton")) { fo.ShowFilterButton = bool.Parse(parameters["showFilterButton"]); } if (parameters.AllKeys.Contains("showFooter")) { fo.ShowFooter = bool.Parse(parameters["showFooter"]); } if (parameters.AllKeys.Contains("showContextMenu")) { fo.ShowContextMenu = bool.Parse(parameters["showContextMenu"]); } if (parameters.AllKeys.Contains("columnMode")) { fo.ColumnOptionsMode = parameters["columnMode"].ToEnum <ColumnOptionsMode>(); } if (parameters.AllKeys.Contains("create")) { fo.Create = bool.Parse(parameters["create"]); } if (parameters.AllKeys.Contains("navigate")) { fo.Navigate = bool.Parse(parameters["navigate"]); } if (parameters.AllKeys.Contains("pagination")) { switch (parameters["pagination"].ToEnum <PaginationMode>()) { case PaginationMode.All: fo.Pagination = new Pagination.All(); break; case PaginationMode.Firsts: fo.Pagination = new Pagination.Firsts(int.Parse(parameters["elems"])); break; case PaginationMode.Paginate: fo.Pagination = new Pagination.Paginate(int.Parse(parameters["elems"]), parameters.AllKeys.Contains("page") ? parameters["page"].ToInt() ?? 1 : 1); break; default: break; } } if (parameters.AllKeys.Contains("searchOnLoad")) { fo.SearchOnLoad = bool.Parse(parameters["searchOnLoad"]); } return(fo); }
public HiveQueryResultEventArgs(object result, QueryDescription query, AbstractScopedCache scopedCache) : this(Enumerable.Repeat(result, 1).ToArray(), query, scopedCache) { }
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()); var options = uq.GroupResults ? (SubTokensOptions.CanElement | SubTokensOptions.CanAggregate) : SubTokensOptions.CanElement; 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, options | SubTokensOptions.CanAnyAll, "{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, options, 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, options, 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;
public Query(QueryDescription queryDesc) { QueryDescription = queryDesc; }
internal static SqlPreCommand SynchronizeWordTemplate(Replacements replacements, WordTemplateEntity template, StringDistance sd) { try { if (template.Template == null || !replacements.Interactive) { return(null); } var queryName = QueryLogic.ToQueryName(template.Query.Key); QueryDescription qd = DynamicQueryManager.Current.QueryDescription(queryName); Console.Clear(); SafeConsole.WriteLineColor(ConsoleColor.White, "WordTemplate: " + template.Name); Console.WriteLine(" Query: " + template.Query.Key); var file = template.Template.Retrieve(); try { SyncronizationContext sc = new SyncronizationContext { ModelType = template.SystemWordTemplate.ToType(), QueryDescription = qd, Replacements = replacements, StringDistance = sd, HasChanges = false, Variables = new ScopedDictionary <string, ValueProviderBase>(null), }; var bytes = template.ProcessOpenXmlPackage(document => { Dump(document, "0.Original.txt"); var parser = new TemplateParser(document, qd, template.SystemWordTemplate.ToType(), template); parser.ParseDocument(); Dump(document, "1.Match.txt"); parser.CreateNodes(); Dump(document, "2.BaseNode.txt"); parser.AssertClean(); foreach (var root in document.AllRootElements()) { foreach (var node in root.Descendants <BaseNode>().ToList()) { node.Synchronize(sc); } } if (sc.HasChanges) { Dump(document, "3.Synchronized.txt"); var variables = new ScopedDictionary <string, ValueProviderBase>(null); foreach (var root in document.AllRootElements()) { foreach (var node in root.Descendants <BaseNode>().ToList()) { node.RenderTemplate(variables); } } Dump(document, "4.Rendered.txt"); } }); if (!sc.HasChanges) { return(null); } file.AllowChange = true; file.BinaryFile = bytes; using (replacements.WithReplacedDatabaseName()) return(Schema.Current.Table <FileEntity>().UpdateSqlSync(file, comment: "WordTemplate: " + template.Name)); } catch (TemplateSyncException ex) { if (ex.Result == FixTokenResult.SkipEntity) { return(null); } if (ex.Result == FixTokenResult.DeleteEntity) { return(SqlPreCommandConcat.Combine(Spacing.Simple, Schema.Current.Table <WordTemplateEntity>().DeleteSqlSync(template), Schema.Current.Table <FileEntity>().DeleteSqlSync(file))); } if (ex.Result == FixTokenResult.ReGenerateEntity) { return(Regenerate(template, replacements)); } throw new InvalidOperationException("Unexcpected {0}".FormatWith(ex.Result)); } finally { Console.Clear(); } } catch (Exception e) { return(new SqlPreCommandSimple("-- Exception in {0}: \r\n{1}".FormatWith(template.BaseToString(), e.Message.Indent(2, '-')))); } }
public void ServiceContext_CurrentOperation() { DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(ServiceContext_CurrentOperation_DomainService)); ServiceContext_CurrentOperation_DomainService ds; IEnumerable<ValidationResult> validationErrors; // Execute a query. ds = new ServiceContext_CurrentOperation_DomainService(DomainOperationType.Query); DomainOperationEntry queryOp = dsd.GetQueryMethod("GetEntities"); Assert.IsNotNull(queryOp); QueryDescription desc = new QueryDescription(queryOp); int totalCount; ds.Query(desc, out validationErrors, out totalCount); Assert.AreEqual(queryOp, ServiceContext_CurrentOperation_DomainService.LastOperation); Assert.IsNull(ds.Context.Operation); // Invoke an operation. ds = new ServiceContext_CurrentOperation_DomainService(DomainOperationType.Invoke); DomainOperationEntry invokeOp = dsd.GetInvokeOperation("Echo"); Assert.IsNotNull(invokeOp); ds.Invoke(new InvokeDescription(invokeOp, null), out validationErrors); Assert.AreEqual(invokeOp, ServiceContext_CurrentOperation_DomainService.LastOperation); Assert.IsNull(ds.Context.Operation); // Invoke an insert operation. ds = new ServiceContext_CurrentOperation_DomainService(DomainOperationType.Submit); DomainOperationEntry insertOp = dsd.GetSubmitMethod(typeof(ServiceContext_CurrentOperation_Entity), DomainOperation.Insert); Assert.IsNotNull(insertOp); ds.Submit(new ChangeSet(new ChangeSetEntry[] { new ChangeSetEntry() { Entity = new ServiceContext_CurrentOperation_Entity() { Key = 1 }, Operation = DomainOperation.Insert } })); Assert.AreEqual(insertOp, ServiceContext_CurrentOperation_DomainService.LastOperation); Assert.IsNull(ds.Context.Operation); }
/// @brief Utility function to create a query from the description /// /// @param desc the query description /// @return The result query protected virtual Query CreateQueryFromDesc(ref QueryDescription desc) { Query ret = new Query(); if (desc.m_vendorName != null && desc.m_vendorName.CompareTo("") != 0) { ret.SetVendor(desc.m_vendorName); } if (desc.m_nodeName != null && desc.m_nodeName.CompareTo("") != 0) { ret.SetName(desc.m_nodeName); } if (desc.RequiresMinVersion()) { ret.SetMinVersion(desc.GetMinVersion()); } if (desc.RequiresMinVersion()) { ret.SetMaxVersion(desc.GetMaxVersion()); } return ret; }
public void TestDomainService_QueryDirect() { TestDomainServices.LTS.Catalog provider = ServerTestHelper.CreateInitializedDomainService<TestDomainServices.LTS.Catalog>(DomainOperationType.Query); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(provider.GetType()); DomainOperationEntry method = serviceDescription.DomainOperationEntries.Where(p => p.Operation == DomainOperation.Query).First(p => p.Name == "GetProductsByCategory"); QueryDescription qd = new QueryDescription(method, new object[] { 1 }); int totalCount; IEnumerable<ValidationResult> validationErrors; IEnumerable result = provider.Query(qd, out validationErrors, out totalCount); int count = result.Cast<DataTests.AdventureWorks.LTS.Product>().Count(); Assert.AreEqual(32, count); // verify that we can use the same provider to execute another query qd = new QueryDescription(method, new object[] { 2 }); result = provider.Query(qd, out validationErrors, out totalCount); count = result.Cast<DataTests.AdventureWorks.LTS.Product>().Count(); Assert.AreEqual(43, count); }
internal static SqlPreCommand?ProcessEmailTemplate(Replacements replacements, Table table, EmailTemplateEntity et, StringDistance sd) { Console.Write("."); try { var queryName = QueryLogic.ToQueryName(et.Query.Key); QueryDescription qd = QueryLogic.Queries.QueryDescription(queryName); using (DelayedConsole.Delay(() => SafeConsole.WriteLineColor(ConsoleColor.White, "EmailTemplate: " + et.Name))) using (DelayedConsole.Delay(() => Console.WriteLine(" Query: " + et.Query.Key))) { if (et.From != null && et.From.Token != null) { QueryTokenEmbedded token = et.From.Token; switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " From", allowRemoveToken: false, allowReCreate: et.Model != null)) { case FixTokenResult.Nothing: break; case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et, e => e.Name == et.Name)); case FixTokenResult.SkipEntity: return(null); case FixTokenResult.Fix: et.From.Token = token; break; case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table)); default: break; } } if (et.Recipients.Any(a => a.Token != null)) { using (DelayedConsole.Delay(() => Console.WriteLine(" Recipients:"))) { foreach (var item in et.Recipients.Where(a => a.Token != null).ToList()) { QueryTokenEmbedded token = item.Token !; switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " Recipient", allowRemoveToken: false, allowReCreate: et.Model != null)) { case FixTokenResult.Nothing: break; case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et, e => e.Name == et.Name)); case FixTokenResult.RemoveToken: et.Recipients.Remove(item); break; case FixTokenResult.SkipEntity: return(null); case FixTokenResult.Fix: item.Token = token; break; case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table)); default: break; } } } } try { foreach (var item in et.Messages) { SynchronizationContext sc = new SynchronizationContext(replacements, sd, qd, et.Model?.ToType()); item.Subject = TextTemplateParser.Synchronize(item.Subject, sc); item.Text = TextTemplateParser.Synchronize(item.Text, sc); } using (replacements.WithReplacedDatabaseName()) return(table.UpdateSqlSync(et, e => e.Name == et.Name, includeCollections: true, comment: "EmailTemplate: " + et.Name)); } catch (TemplateSyncException ex) { if (ex.Result == FixTokenResult.SkipEntity) { return(null); } if (ex.Result == FixTokenResult.DeleteEntity) { return(table.DeleteSqlSync(et, e => e.Name == et.Name)); } if (ex.Result == FixTokenResult.ReGenerateEntity) { return(Regenerate(et, replacements, table)); } throw new UnexpectedValueException(ex.Result); } } } catch (Exception e) { return(new SqlPreCommandSimple("-- Exception on {0}. {1}\r\n{2}".FormatWith(et.BaseToString(), e.GetType().Name, e.Message.Indent(2, '-')))); } }
internal MyOcclusionQuery() { var desc = new QueryDescription(); desc.Type = QueryType.Occlusion; m_query = new Query(MyRender11.Device, desc); }
public override void ModifyQueryDescription(QueryDescription queryDescription) { var constant = Parameter as ConstantExpression; queryDescription.From.RevisionStatusType = (RevisionStatusType)(constant.Value); }
public FillAttachmentTokenContext(QueryDescription queryDescription, List <QueryToken> queryTokens) { QueryDescription = queryDescription; QueryTokens = queryTokens; }
public override void ModifyQueryDescription(QueryDescription queryDescription) { var constant = Parameter as ConstantExpression; //queryDescription.From.RequiredEntityIds = (IEnumerable<HiveId>)(constant.Value); }
public void ParseData(Entity context, QueryDescription description, SubTokensOptions options) { Token.ParseData(context, description, options); }
public HiveQueryResultEventArgs(IEnumerable<object> results, QueryDescription query, AbstractScopedCache scopedCache) { Results = results; ScopedCache = scopedCache; QueryDescription = query; }
public void ParseData(ModifiableEntity context, QueryDescription description, SubTokensOptions options) { token?.ParseData(context, description, options); }
public void DomainService_InvalidOperationType() { TestDomainServices.EF.Northwind nw = new TestDomainServices.EF.Northwind(); DomainServiceContext dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Submit); nw.Initialize(dsc); IEnumerable<ValidationResult> validationResults = null; int totalCount; DomainServiceDescription dsd = DomainServiceDescription.GetDescription(typeof(TestDomainServices.EF.Northwind)); DomainOperationEntry entry = dsd.DomainOperationEntries.First(p => p.Operation == DomainOperation.Query); QueryDescription qd = new QueryDescription(entry); ExceptionHelper.ExpectException<InvalidOperationException>(delegate { nw.Query(qd, out validationResults, out totalCount); }, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Query)); InvokeDescription id = new InvokeDescription(entry, null); ExceptionHelper.ExpectException<InvalidOperationException>(delegate { nw.Invoke(id, out validationResults); }, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Submit, DomainOperationType.Invoke)); nw = new TestDomainServices.EF.Northwind(); dsc = new DomainServiceContext(new MockDataService(new MockUser("mathew") { IsAuthenticated = true }), DomainOperationType.Query); nw.Initialize(dsc); ChangeSet cs = new ChangeSet(new ChangeSetEntry[] { new ChangeSetEntry() { Entity = new ServiceContext_CurrentOperation_Entity() { Key = 1 }, Operation = DomainOperation.Insert } }); ExceptionHelper.ExpectException<InvalidOperationException>(delegate { nw.Submit(cs); }, string.Format(Resource.DomainService_InvalidOperationType, DomainOperationType.Query, DomainOperationType.Submit)); }
public static (ColumnOptionsMode mode, MList <QueryColumnEmbedded> columns) SmartColumns(List <Column> current, QueryDescription qd) { var ideal = (from cd in qd.Columns where !cd.IsEntity select cd).ToList(); foreach (var item in current) { if (item.Token.NiceName() == item.DisplayName) { item.DisplayName = null; } } if (current.Count < ideal.Count) { List <Column> toRemove = new List <Column>(); int j = 0; for (int i = 0; i < ideal.Count; i++) { if (j < current.Count && current[j].Similar(ideal[i])) { j++; } else { toRemove.Add(new Column(ideal[i], qd.QueryName)); } } if (toRemove.Count + current.Count == ideal.Count) { return(mode : ColumnOptionsMode.Remove, columns : toRemove.Select(c => new QueryColumnEmbedded { Token = new QueryTokenEmbedded(c.Token) }).ToMList()); } } else { if (current.Zip(ideal).All(t => t.First.Similar(t.Second))) { return(mode : ColumnOptionsMode.Add, columns : current.Skip(ideal.Count).Select(c => new QueryColumnEmbedded { Token = new QueryTokenEmbedded(c.Token), DisplayName = c.DisplayName }).ToMList()); } } return(mode : ColumnOptionsMode.Replace, columns : current.Select(c => new QueryColumnEmbedded { Token = new QueryTokenEmbedded(c.Token), DisplayName = c.DisplayName }).ToMList()); }
public void ServerValidation_Query() { TestDomainServices.TestProvider_Scenarios service = ServerTestHelper.CreateInitializedDomainService<TestDomainServices.TestProvider_Scenarios>(DomainOperationType.Query); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(service.GetType()); DomainOperationEntry method = serviceDescription.DomainOperationEntries.Single(p => p.Name == "QueryWithParamValidation"); QueryDescription qd = new QueryDescription(method, new object[] { -1, "ABC" }); int totalCount; IEnumerable<ValidationResult> validationErrors; service.Query(qd, out validationErrors, out totalCount); Assert.IsNotNull(validationErrors); Assert.AreEqual(2, validationErrors.Count()); ValidationResult error = validationErrors.ElementAt(0); Assert.AreEqual("The field a must be between 0 and 10.", error.ErrorMessage); Assert.AreEqual("a", error.MemberNames.Single()); error = validationErrors.ElementAt(1); Assert.AreEqual("The field b must be a string with a maximum length of 2.", error.ErrorMessage); Assert.AreEqual("b", error.MemberNames.Single()); }
public void TestDomainService_QueryDirect_Throws() { MockDomainService_SelectThrows provider = ServerTestHelper.CreateInitializedDomainService<MockDomainService_SelectThrows>(DomainOperationType.Query); DomainServiceDescription serviceDescription = DomainServiceDescription.GetDescription(provider.GetType()); DomainOperationEntry method = serviceDescription.DomainOperationEntries.First(p => p.Name == "GetEntities" && p.Operation == DomainOperation.Query); QueryDescription qd = new QueryDescription(method, new object[0]); int totalCount; IEnumerable<ValidationResult> validationErrors; ExceptionHelper.ExpectException<Exception>(delegate { try { provider.Query(qd, out validationErrors, out totalCount); } catch (TargetInvocationException ex) { throw ex.InnerException; } }, "Test"); }
private void PresentFrame11(bool renderToTexture) { // Update the screen if (!renderToTexture) { FadeFrame(); NetControl.WaitForNetworkSync(); RenderContext11.Present(Properties.Settings.Default.FrameSync); if (flush) { RenderContext11.devContext.Flush(); var qd = new QueryDescription(); qd.Type = QueryType.Event; query = new Query(RenderContext11.Device, qd); RenderContext11.devContext.End(query); var result = false; var retVal = false; while (!result && !retVal) { var ds = RenderContext11.devContext.GetData(query); result = ds.ReadBoolean(); ds.Close(); ds.Dispose(); } query.Dispose(); } } }