private QuerySchema Register(Type type, Type modelType, Type projectionType, Type queryHandlerType, Type resultType, Type[] streamPartitioners,
Type[] queryPartitioners)
{
QuerySchema qs = new QuerySchema(type, modelType, projectionType, queryHandlerType, resultType, ServiceConventions.GetCategoryFromNamespaceFunc(queryHandlerType.Namespace),
streamPartitioners,
queryPartitioners);
_querySchema.Add(qs);
_queryTypeIndex.Add(type, qs);
return(qs);
}
private ObjectGraphType CreateSchema(OperationType operationType, IGraphType graphType, ISchema root)
{
ObjectGraphType schema;
switch (operationType)
{
case OperationType.Query:
{
schema = new QuerySchema();
break;
}
case OperationType.Mutation:
{
schema = new MutationSchema();
break;
}
default:
{
schema = new SubscruptionSchema();
break;
}
}
foreach (var field in graphType.Fields.Values)
{
var fieldType = new FieldType
{
Name = field.Name,
ResolvedType = Convert(field.GraphType, false, root)
};
if (field.Arguments.Any())
{
fieldType.Arguments = new QueryArguments();
}
foreach (var argument in field.Arguments.Values)
{
var argumentType = Convert(argument.GraphType, operationType == OperationType.Mutation, root);
root?.RegisterType(argumentType);
var queryArgument = new QueryArgument(argumentType)
{
Name = argument.Name
};
fieldType.Arguments.Add(queryArgument);
}
schema.AddField(fieldType);
}
return(schema);
}
private QuerySchema CreateSchema()
{
var querySchema = new QuerySchema();
var allParts = ((IGraphQLSchemaCollection)this._serviceProvider.GetService(typeof(IGraphQLSchemaCollection))).Items;
foreach (var part in allParts)
{
var queryPart = this._serviceProvider.GetService(part);
queryPart.GetType().InvokeMember("SetQueries", BindingFlags.InvokeMethod, null, queryPart, new object[] { querySchema });
}
//((IAdvogadoQuery)this._serviceProvider.GetService(typeof(IAdvogadoQuery))).SetQueries(querySchema);
//((IUnidadeQuery)this._serviceProvider.GetService(typeof(IUnidadeQuery))).SetQueries(querySchema);
return(querySchema);
}
private QuerySchema CreateSchema()
{
var querySchema = new QuerySchema();
if (!this._memoryCache.TryGetValue("Schema", out querySchema))
{
querySchema = new QuerySchema();
var allParts = ((IGraphQLSchemaCollection)this._serviceProvider.GetService(typeof(IGraphQLSchemaCollection))).Items;
foreach (var part in allParts)
{
var queryPart = this._serviceProvider.GetService(part);
queryPart.GetType().InvokeMember("SetQueries", BindingFlags.InvokeMethod, null, queryPart, new object[] { querySchema });
}
this._memoryCache.CreateEntry("Schema")
.SetValue(querySchema)
.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(60);
//this._memoryCache.Set("Schema",
// ,
// new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(60)));
}
return(querySchema);
}
/// <summary>
/// Generates the constructor for the generated class.
/// </summary>
/// <param name="classSchema">A description of a Type.</param>
public SchemaSelect(ClassSchema classSchema)
{
// /// <summary>
// /// Creates a FluidTrade.Sandbox.WorkingOrder.WorkingOrder.
// /// </summary>
// public Sandbox.WorkingOrderRow Select(FluidTrade.Sandbox.WorkingOrderRow workingOrderRow)
// {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("Creates a {0}.", classSchema.Type), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.ReturnType = new CodeTypeReference(classSchema.Type);
this.Name = "Select";
foreach (ArgumentSchema argumentSchema in classSchema.Constructor.Arguments)
{
this.Parameters.Add(new CodeParameterDeclarationExpression(argumentSchema.Type, argumentSchema.Name));
}
// this.key = workingOrderRow;
foreach (SnippetSchema snippetSchema in classSchema.Constructor.Snippets)
{
if (snippetSchema is SetterSchema)
{
SetterSchema setterSchema = snippetSchema as SetterSchema;
string[] statementList = setterSchema.Value.Split(';');
for (int index = 0; index < statementList.Length - 1; index++)
{
this.Statements.Add(new CodeSnippetStatement(statementList[index] + ';'));
}
this.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), setterSchema.Property),
new CodeSnippetExpression(statementList[statementList.Length - 1])));
}
else
{
string[] statementList = snippetSchema.Value.Split(';');
for (int index = 0; index < statementList.Length; index++)
{
this.Statements.Add(new CodeSnippetStatement(statementList[index] + ';'));
}
}
}
// This will run through each of the members of the class an initialize the complex data types. If the element allows
// only one occurance of an element, then a single object is created. If the element allows many, then a list is
// created. Basic data types are not constructred here.
foreach (PropertySchema propertySchema in classSchema.Properties)
{
// For scalar properties, the property is created and then populated using the setters.
if (propertySchema.MaxOccurs == 1)
{
// this.askPrice = new FluidTrade.Sandbox.WorkingOrder.AskPrice();
CodeFieldReferenceExpression fieldExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
CommonConversion.ToCamelCase(propertySchema.Name));
// this.askPrice.isEnabled = workingOrderRow.StatusCode != FluidTrade.Sandbox.Status.Filled;
// this.askPrice.price = workingOrderRow.PriceRow.AskPrice;
foreach (SnippetSchema snippetSchema in propertySchema.Snippets)
{
if (snippetSchema is SetterSchema)
{
SetterSchema setterSchema = snippetSchema as SetterSchema;
string[] statementList = setterSchema.Value.Split(';');
for (int index = 0; index < statementList.Length - 1; index++)
{
this.Statements.Add(new CodeSnippetStatement(statementList[index] + ';'));
}
this.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(fieldExpression, CommonConversion.ToCamelCase(setterSchema.Property)),
new CodeSnippetExpression(statementList[statementList.Length - 1])));
}
else
{
string[] statementList = snippetSchema.Value.Split(';');
for (int index = 0; index < statementList.Length; index++)
{
this.Statements.Add(new CodeSnippetStatement(statementList[index] + ';'));
}
}
}
}
// Vectors are populated using the LINQ libraries to select, filter, sort and transform the source data.
if (propertySchema.MaxOccurs == Decimal.MaxValue)
{
// The index is used as an indicator to set the destination property instead of creating an intermediate
// step. The general idea is to set up a series of queries that will select, sort, filter and otherwise
// transform the source data into a format that relects the users' preferences.
for (int queryIndex = 0; queryIndex < propertySchema.Queries.Count; queryIndex++)
{
// This schema will generate a step that transforms the source data.
QuerySchema querySchema = propertySchema.Queries[queryIndex];
// The results will either be stored in an intermediate variable or the property that the ultimate
// destination for this data. The source of the data is computed independently of the destination and
// stored here until a decision about where the results are held is made.
CodeExpression initializationExpression = null;
// Transform the 'Where' particle into a CodeDOM expression.
if (querySchema is WhereSchema)
{
// System.Linq.Enumerable.Where<Sandbox.WorkingOrderRow>(DataModel.WorkingOrder, FluidTrade.Sandbox.WorkingOrderHeader.WorkingOrderHeader.prefilter.Filter);
WhereSchema whereSchema = querySchema as WhereSchema;
initializationExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Linq.Enumerable"),
string.Format("Where<{0}>", whereSchema.SourceType),
new CodeVariableReferenceExpression(whereSchema.Source),
new CodePropertyReferenceExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(),
CommonConversion.ToCamelCase(whereSchema.Predicate)),
"Filter"));
}
// Transform the 'Select' particle into a CodeDOM expression.
if (querySchema is SelectSchema)
{
// System.Linq.Enumerable.Select<Sandbox.WorkingOrderRow, FluidTrade.Sandbox.WorkingOrder.WorkingOrder>(a811c4058ea3a4d79af050b1d46fcda0d, FluidTrade.Sandbox.WorkingOrder.WorkingOrder.Select);
SelectSchema selectSchema = querySchema as SelectSchema;
initializationExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Linq.Enumerable"),
string.Format("Select<{0}, {1}>", selectSchema.SourceType, selectSchema.ResultType),
new CodeVariableReferenceExpression(selectSchema.Source),
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), CommonConversion.ToCamelCase(selectSchema.Selector)));
}
// Transform the 'OrderBy' particle into a CodeDOM expression.
if (querySchema is OrderBySchema)
{
// System.Linq.Enumerable.OrderBy<Sandbox.WorkingOrder.WorkingOrder, FluidTrade.Sandbox.WorkingOrder.WorkingOrder>(n65cf68c24b3e423da4e8bb4ade1c20cc, FluidTrade.Sandbox.WorkingOrder.WorkingOrder.SelectSelf, FluidTrade.Sandbox.WorkingOrderHeader.WorkingOrderHeader.comparer);
OrderBySchema orderBySchema = querySchema as OrderBySchema;
initializationExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Linq.Enumerable"),
string.Format("OrderBy<{0}, {1}>", orderBySchema.SourceType, orderBySchema.KeyType),
new CodeVariableReferenceExpression(orderBySchema.Source),
new CodeVariableReferenceExpression(orderBySchema.KeySelector),
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), CommonConversion.ToCamelCase(orderBySchema.Comparer)));
}
// System.Collections.Generic.IEnumerable<Sandbox.WorkingOrder.WorkingOrder> list0 = System.Linq.Enumerable.Where<Sandbox.WorkingOrder.WorkingOrder>(y22c1b202d41f47a19511dce0cbc80e65, FluidTrade.Sandbox.WorkingOrderHeader.WorkingOrderHeader.filter.Filter);
this.Statements.Add(new CodeVariableDeclarationStatement(
new CodeTypeReference(string.Format("System.Collections.Generic.IEnumerable<{0}>", querySchema.ResultType)),
querySchema.Name,
initializationExpression));
// The last query particle will populate the property. All the others are stored in intermediate variables.
if (queryIndex == propertySchema.Queries.Count - 1)
{
// this.workingOrderList = System.Linq.Enumerable.ToArray<Sandbox.WorkingOrder.WorkingOrder>(foobar);
this.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
CommonConversion.ToCamelCase(propertySchema.Name)),
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(System.Linq.Enumerable)),
"ToArray",
new CodeVariableReferenceExpression(querySchema.Name))));
}
}
}
}
// return this;
this.Statements.Add(new CodeMethodReturnStatement(new CodeThisReferenceExpression()));
}
