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());
}
/// <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 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();
}
}
}
