private static async Task <object> CompleteUnionValueAsync(
IExecutorContext executorContext,
ObjectType actualType,
IReadOnlyCollection <GraphQLFieldSelection> fields,
object value,
NodePath path,
UnionType unionType)
{
if (!unionType.IsPossible(actualType))
{
throw new CompleteValueException(
"Cannot complete value as union. " +
$"Actual type {actualType.Name} is not possible for {unionType.Name}",
path,
fields.First());
}
var subSelectionSet = SelectionSets.MergeSelectionSets(fields);
var data = await SelectionSets.ExecuteSelectionSetAsync(
executorContext,
subSelectionSet,
actualType,
value,
path).ConfigureAwait(false);
return(data);
}
private static async Task <ExecutionResult> ExecuteSubscriptionEventAsync(
IExecutorContext context,
OperationDefinition subscription,
IReadOnlyDictionary <string, object?> coercedVariableValues,
object evnt,
Func <Exception, ExecutionError> formatError)
{
var subscriptionType = context.Schema.Subscription;
var selectionSet = subscription.SelectionSet;
var path = new NodePath();
var data = await SelectionSets.ExecuteSelectionSetAsync(
context,
selectionSet,
subscriptionType,
evnt,
path).ConfigureAwait(false);
var result = new ExecutionResult
{
Errors = context.FieldErrors.Select(formatError).ToList(),
Data = data?.ToDictionary(kv => kv.Key, kv => kv.Value)
};
return(result);
}
public static async Task <ExecutionResult> ExecuteMutationAsync(
QueryContext context)
{
var(schema, _, operation, initialValue, coercedVariableValues) = context;
var executionContext = context.BuildExecutorContext(new SerialExecutionStrategy());
var path = new NodePath();
var mutationType = schema.Mutation;
if (mutationType == null)
{
throw new QueryExecutionException(
"Schema does not support mutations. Mutation type is null.",
path);
}
var selectionSet = operation.SelectionSet;
var data = await SelectionSets.ExecuteSelectionSetAsync(
executionContext,
selectionSet,
mutationType,
initialValue,
path).ConfigureAwait(false);
return(new ExecutionResult
{
Errors = executionContext
.FieldErrors
.Select(context.FormatError).ToList(),
Data = data?.ToDictionary(kv => kv.Key, kv => kv.Value)
});
}
private static async Task <object> CompleteInterfaceValueAsync(
IExecutorContext executorContext,
ObjectType actualType,
IReadOnlyCollection <GraphQLFieldSelection> fields,
object value,
NodePath path,
InterfaceType interfaceType)
{
if (!actualType.Implements(interfaceType))
{
throw new CompleteValueException(
"Cannot complete value as interface. " +
$"Actual type {actualType.Name} does not implement {interfaceType.Name}",
path,
fields.First());
}
var subSelectionSet = SelectionSets.MergeSelectionSets(fields);
var data = await SelectionSets.ExecuteSelectionSetAsync(
executorContext,
subSelectionSet,
actualType,
value,
path).ConfigureAwait(false);
return(data);
}
void assignToSelection()
{
SelectionSetVM newSet = new SelectionSetVM(_selectedMaterialIndex);
foreach (var filter in Filters)
{
foreach (var item in filter.FilterItems)
{
if (item.IsSelected)
{
newSet.SelectedFilterValues.Add(new FilterSelection(filter.Name, item.Name));
}
}
}
foreach (var elem in Elements)
{
if (elem.Include)
{
newSet.ElementsIdsToInclude.Add(elem.UniqueID);
}
if (elem.Exclude)
{
newSet.ElementsIdsToExclude.Add(elem.UniqueID);
}
}
SelectionSets.Add(newSet);
processSelectionSet(newSet);
UpdateAll();
}
private static async Task <object> CompleteObjectValueAsync(IExecutorContext executorContext, List <GraphQLFieldSelection> fields, object value,
Dictionary <string, object> coercedVariableValues, NodePath path, ObjectType fieldObjectType)
{
var subSelectionSet = SelectionSets.MergeSelectionSets(fields);
var data = await SelectionSets.ExecuteSelectionSetAsync(
executorContext,
subSelectionSet,
fieldObjectType,
value,
coercedVariableValues,
path).ConfigureAwait(false);
return(data);
}
public GenSelectionSet CreateSelectionSet(IGraphType graphType, INode node)
{
if (graphType == null)
{
return(null);
}
var selectionSet = new GenSelectionSet {
Namespace = this, Name = graphType.Name, GraphType = graphType, Node = node
};
if (!selectionSet.MapsToBuildInType)
{
SelectionSets.Add(selectionSet);
}
return(selectionSet);
}
/// <summary>
/// For each subscription operation definition subscription in the document
/// Let subscriptionType be the root Subscription type in schema.
/// Let selectionSet be the top level selection set on subscription.
/// Let variableValues be the empty set.
/// Let groupedFieldSet be the result of CollectFields(subscriptionType, selectionSet, variableValues).
/// groupedFieldSet must have exactly one entry.
/// </summary>
public static CombineRule R5231SingleRootField()
{
return((context, rule) =>
{
rule.EnterDocument += document =>
{
var subscriptions = document.Definitions
.OfType <GraphQLOperationDefinition>()
.Where(op => op.Operation == OperationType.Subscription)
.ToList();
if (!subscriptions.Any())
{
return;
}
var schema = context.Schema;
//todo(pekka): should this report error?
if (schema.Subscription == null)
{
return;
}
var subscriptionType = schema.Subscription;
foreach (var subscription in subscriptions)
{
var selectionSet = subscription.SelectionSet;
var variableValues = new Dictionary <string, object>();
var groupedFieldSet = SelectionSets.CollectFields(
schema,
context.Document,
subscriptionType,
selectionSet,
variableValues);
if (groupedFieldSet.Count != 1)
{
context.Error(
ValidationErrorCodes.R5231SingleRootField,
"Subscription operations must have exactly one root field.",
subscription);
}
}
};
});
}
private static async Task <object> CompleteObjectValueAsync(
IExecutorContext executorContext,
IReadOnlyCollection <GraphQLFieldSelection> fields,
object value,
NodePath path,
ObjectType fieldObjectType)
{
var subSelectionSet = SelectionSets.MergeSelectionSets(fields);
var data = await SelectionSets.ExecuteSelectionSetAsync(
executorContext,
subSelectionSet,
fieldObjectType,
value,
path).ConfigureAwait(false);
return(data);
}
void deleteSelected()
{
var itemsToRemove = SelectionSets.Where(a => a.IsSelected).ToList();
foreach (var item in itemsToRemove)
{
SelectionSets.Remove(item);
}
foreach (var elem in Elements)
{
elem.Material = Materials[0].GWPMaterial;
}
foreach (var set in SelectionSets)
{
processSelectionSet(set);
}
}
public static async Task <ExecutionResult> ExecuteQueryAsync(
QueryContext context)
{
var(schema, _, operation, initialValue, coercedVariableValues) = context;
var queryType = schema.Query;
var path = new NodePath();
if (queryType == null)
{
throw new QueryExecutionException(
"Schema does not support queries. Query type is null.",
path);
}
var selectionSet = operation.SelectionSet;
var executionContext = context.BuildExecutorContext(new ParallelExecutionStrategy());
IDictionary <string, object?>?data;
try
{
data = await SelectionSets.ExecuteSelectionSetAsync(
executionContext,
selectionSet,
queryType,
initialValue,
path).ConfigureAwait(false);
}
catch (QueryExecutionException e)
{
executionContext.AddError(e);
data = null;
}
return(new ExecutionResult
{
Errors = executionContext
.FieldErrors
.Select(context.FormatError)
.ToList(),
Data = data?.ToDictionary(kv => kv.Key, kv => kv.Value)
});
}
public static async Task <ISubscriberResult> CreateSourceEventStreamAsync(
IExecutorContext context,
OperationDefinition subscription,
IReadOnlyDictionary <string, object?> coercedVariableValues,
object initialValue,
CancellationToken cancellationToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (subscription == null)
{
throw new ArgumentNullException(nameof(subscription));
}
if (coercedVariableValues == null)
{
throw new ArgumentNullException(nameof(coercedVariableValues));
}
cancellationToken.ThrowIfCancellationRequested();
var schema = context.Schema;
var subscriptionType = schema.Subscription;
var groupedFieldSet = SelectionSets.CollectFields(
context.Schema,
context.Document,
subscriptionType,
subscription.SelectionSet,
coercedVariableValues
);
var fields = groupedFieldSet.Values.First();
var fieldName = fields.First().Name;
var fieldSelection = fields.First();
var coercedArgumentValues = ArgumentCoercion.CoerceArgumentValues(
schema,
subscriptionType,
fieldSelection,
coercedVariableValues);
var field = schema.GetField(subscriptionType.Name, fieldName);
var path = new NodePath();
var resolveContext = new ResolverContext(
subscriptionType,
initialValue,
field,
fieldSelection,
fields,
coercedArgumentValues,
path,
context);
var subscriber = schema.GetSubscriber(subscriptionType.Name, fieldName);
if (subscriber == null)
{
throw new QueryExecutionException(
$"Could not subscribe. Field '{subscriptionType}:{fieldName}' does not have subscriber",
path);
}
var subscribeResult = await subscriber(resolveContext, cancellationToken)
.ConfigureAwait(false);
return(subscribeResult);
}
public GenSelectionSet FindSelectionSet(string name) => SelectionSets.Find(t => t.Name == name);
