public void Build(ISchema schema)
{
var inventoryQueryField = new FieldType
{
Name = "inventory",
Arguments = new QueryArguments(new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id", Description = "id of the inventory"
}),
Type = typeof(InventoryType),
Resolver = new AsyncFieldResolver <Inventory>(context =>
{
return(Task.FromResult(new Inventory {
ProductId = "1", FulfillmentCenterId = "center1"
}));
})
};
schema.Query.AddField(inventoryQueryField);
var saveInventoryField = FieldBuilder.Create <Inventory, Inventory>(typeof(InventoryType))
.Name("saveInventory")
.Argument <NonNullGraphType <InputUpdateInventoryType> >("inventory")
.Resolve(context =>
{
var inventory = context.GetArgument <Inventory>("inventory");
//TODO: Insert mutation logic here
return(inventory);
}).FieldType;
schema.Mutation.AddField(saveInventoryField);
}
/// <summary>
/// Adds a new field to the complex graph type and returns a builder for this newly added field that is linked to a property of the source object.
/// <br/><br/>
/// Note: this method uses dynamic compilation and therefore allocates a relatively large amount of
/// memory in managed heap, ~1KB. Do not use this method in cases with limited memory requirements.
/// </summary>
/// <typeparam name="TProperty">The return type of the field.</typeparam>
/// <param name="name">The name of this field.</param>
/// <param name="expression">The property of the source object represented within an expression.</param>
/// <param name="nullable">Indicates if this field should be nullable or not. Ignored when <paramref name="type"/> is specified.</param>
/// <param name="type">The graph type of the field; if <see langword="null"/> then will be inferred from the specified expression via registered schema mappings.</param>
public virtual FieldBuilder <TSourceType, TProperty> Field <TProperty>(
string name,
Expression <Func <TSourceType, TProperty> > expression,
bool nullable = false,
Type?type = null)
{
try
{
if (type == null)
{
type = typeof(TProperty).GetGraphTypeFromType(nullable, this is IInputObjectGraphType ? TypeMappingMode.InputType : TypeMappingMode.OutputType);
}
}
catch (ArgumentOutOfRangeException exp)
{
throw new ArgumentException($"The GraphQL type for field '{Name ?? GetType().Name}.{name}' could not be derived implicitly from expression '{expression}'.", exp);
}
var builder = FieldBuilder.Create <TSourceType, TProperty>(type)
.Name(name)
.Resolve(new ExpressionFieldResolver <TSourceType, TProperty>(expression))
.Description(expression.DescriptionOf())
.DeprecationReason(expression.DeprecationReasonOf())
.DefaultValue(expression.DefaultValueOf());
if (expression.Body is MemberExpression expr)
{
builder.FieldType.Metadata[ORIGINAL_EXPRESSION_PROPERTY_NAME] = expr.Member.Name;
}
AddField(builder.FieldType);
return(builder);
}
private static Builders.FieldBuilder <IDictionary <string, object>, TReturn> EfFieldFromContext <TDbContext, TSource, TReturn>(this IEfGraph <TDbContext, TSource> graph, string name, Func <ResolveEfFieldContext <TDbContext, TSource>, LambdaExpression> expression, bool nullable = false, Type graphType = null) where TDbContext : DbContext where TSource : class
{
//obtain the type
try
{
if (graphType == null)
{
graphType = typeof(TReturn).GetGraphTypeFromType(nullable);
}
}
catch (ArgumentOutOfRangeException exp)
{
throw new ArgumentException(
$"The GraphQL type for Field: '{name}' on parent type: '{graph.Name ?? graph.GetType().Name}' could not be derived implicitly. \n",
exp
);
}
var builder = FieldBuilder.Create <IDictionary <string, object>, TReturn>(graphType)
.Name(name)
.Resolve(EfGraphResolver)
//.Description(expression.DescriptionOf())
//.DeprecationReason(expression.DeprecationReasonOf())
//.DefaultValue(expression.DefaultValueOf())
;
builder.FieldType.SetExpressionMetadata <TDbContext, TSource>(expression);
graph.AddField(builder.FieldType);
return(builder);
}
public FieldBuilder <TSourceType, object> Field <TGraphType>()
{
var builder = FieldBuilder.Create <TSourceType, object>(typeof(TGraphType));
AddField(builder.FieldType);
return(builder);
}
public FieldBuilder <TSourceType, TProperty> Field <TProperty>(
string name,
Expression <Func <TSourceType, TProperty> > expression,
bool nullable = false,
Type type = null)
{
try
{
if (type == null)
{
type = typeof(TProperty).GetGraphTypeFromType(nullable);
}
}
catch (ArgumentOutOfRangeException exp)
{
throw new ArgumentException(
$"The GraphQL type for Field: '{name}' on parent type: '{Name ?? GetType().Name}' could not be derived implicitly. \n",
exp
);
}
var builder = FieldBuilder.Create <TSourceType, TProperty>(type)
.Resolve(new ExpressionFieldResolver <TSourceType, TProperty>(expression))
.Name(name);
AddField(builder.FieldType);
return(builder);
}
public FieldBuilder <TGraphType, object, TGraphType> Field <TGraphType>()
where TGraphType : GraphType
{
var builder = FieldBuilder.Create <TGraphType>();
_fields.Add(builder.FieldType);
return(builder);
}
/// <summary>
/// Adds a new field to the complex graph type and returns a builder for this newly added field.
/// </summary>
/// <typeparam name="TGraphType">The graph type of the field.</typeparam>
/// <typeparam name="TReturnType">The return type of the field resolver.</typeparam>
/// <param name="name">The name of the field.</param>
public virtual FieldBuilder <TSourceType, TReturnType> Field <TGraphType, TReturnType>(string name = "default")
{
var builder = FieldBuilder.Create <TSourceType, TReturnType>(typeof(TGraphType))
.Name(name);
AddField(builder.FieldType);
return(builder);
}
public void Create_name_for_enumerable_primitives_test()
{
var ctx = new TestBuildContext();
var output = FieldBuilder.Create(typeof(int[]), "test", ctx);
output.CreateNames();
output.CreateNames();
ctx.Names.Count.Should().BeGreaterOrEqualTo(1);
ctx.Names.Keys.Should().Contain("_value");
}
public void Create_name_for_primitives_test()
{
var ctx = new TestBuildContext();
var output = FieldBuilder.Create(typeof(int), "test", ctx);
output.CreateNames();
output.CreateNames();
ctx.Names.Count.Should().Be(1);
ctx.Names.Keys.Should().Contain("test");
}
public void Create_name_for_complex_test()
{
var ctx = new TestBuildContext();
var output = FieldBuilder.Create(typeof(TestEntity), "test", ctx);
output.CreateNames();
output.CreateNames();
ctx.Names.Count.Should().BeGreaterOrEqualTo(7);
ctx.Names.Keys.Should().Contain("test_Age");
ctx.Names.Keys.Should().Contain("test_Address_City");
ctx.Names.Keys.Should().Contain("_value");
}
public void Set_value_for_primitive_test()
{
var ctx = new TestBuildContext();
var output = FieldBuilder.Create(typeof(string), "test", ctx);
output.CreateNames();
output.SetValue("test value");
ctx.Names["test"].Should().Be("test value");
output.SetValue(2);
ctx.Names["test"].Should().Be(2);
}
public FieldBuilder <TSourceType, TProperty> Field <TProperty>(
string name,
Expression <Func <TSourceType, TProperty> > expression,
bool nullable = false,
Type type = null)
{
type = type ?? typeof(TProperty).GetGraphTypeFromType(nullable);
var builder = FieldBuilder.Create <TSourceType, TProperty>(type)
.Resolve(new ExpressionFieldResolver <TSourceType, TProperty>(expression))
.Name(name);
AddField(builder.FieldType);
return(builder);
}
public void Set_value_for_complex_test()
{
var ctx = new TestBuildContext();
var output = FieldBuilder.Create(typeof(TestEntity), "test", ctx);
output.CreateNames();
output.SetValue(new TestEntity("test name", "test role", 36, new [] { 23, 42 })
{
Address = new Address("RUS", "SPB", "Nevskiy")
});
ctx.Names["test_Name"].Should().Be("test name");
ctx.Names["test_Role"].Should().Be("test role");
ctx.Names["test_Age"].Should().Be(36);
ctx.Names["test_Address_City"].Should().Be("SPB");
}
public FieldBuilder Field(string type, string name) => FieldBuilder.Create(this, type, name);
public void Passing_enumerable_primitive_should_create_HorizontalRangeBuilder()
{
var output = FieldBuilder.Create(typeof(DateTime[]), "test", new TestBuildContext());
output.Should().BeOfType <HorizontalRangeBuilder>();
}
public void Passing_enumerable_complex_should_create_VerticalRangeBuilder()
{
var output = FieldBuilder.Create(typeof(Address[]), "test", new TestBuildContext());
output.Should().BeOfType <VerticalRangeBuilder>();
}
public void Passing_complex_should_create_ComplexFieldBuilder(object value)
{
var output = FieldBuilder.Create(value.GetType(), "test", new TestBuildContext());
output.Should().BeOfType <ComplexFieldBuilder>();
}
public void Build(ISchema schema)
{
_ = schema.Query.AddField(new FieldType
{
Name = "order",
Arguments = new QueryArguments(
new QueryArgument <StringGraphType> {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "number"
},
new QueryArgument <StringGraphType> {
Name = "cultureName", Description = "Culture name (\"en-US\")"
}),
Type = GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var request = new GetOrderQuery
{
Number = context.GetArgument <string>("number"),
OrderId = context.GetArgument <string>("id"),
CultureName = context.GetArgument <string>(nameof(Currency.CultureName))
};
var orderAggregate = await _mediator.Send(request);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), orderAggregate.Order, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
var allCurrencies = await _currencyService.GetAllCurrenciesAsync();
//Store all currencies in the user context for future resolve in the schema types
context.SetCurrencies(allCurrencies, request.CultureName);
//store order aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(orderAggregate);
return(orderAggregate);
})
});
var orderConnectionBuilder = GraphTypeExtenstionHelper.CreateConnection <CustomerOrderType, object>()
.Name("orders")
.Argument <StringGraphType>("filter", "This parameter applies a filter to the query results")
.Argument <StringGraphType>("sort", "The sort expression")
.Argument <StringGraphType>("cultureName", "Culture name (\"en-US\")")
.Argument <StringGraphType>("userId", "")
.Unidirectional()
.PageSize(20);
orderConnectionBuilder.ResolveAsync(async context => await ResolveOrdersConnectionAsync(_mediator, context));
schema.Query.AddField(orderConnectionBuilder.FieldType);
var paymentsConnectionBuilder = GraphTypeExtenstionHelper.CreateConnection <PaymentInType, object>()
.Name("payments")
.Argument <StringGraphType>("filter", "This parameter applies a filter to the query results")
.Argument <StringGraphType>("sort", "The sort expression")
.Argument <StringGraphType>("cultureName", "Culture name (\"en-US\")")
.Argument <NonNullGraphType <StringGraphType> >("userId", "")
.Unidirectional()
.PageSize(20);
paymentsConnectionBuilder.ResolveAsync(async context => await ResolvePaymentsConnectionAsync(_mediator, context));
schema.Query.AddField(paymentsConnectionBuilder.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, CustomerOrderAggregate>(typeof(CustomerOrderType))
.Name("createOrderFromCart")
.Argument <NonNullGraphType <InputCreateOrderFromCartType> >(_commandName)
.ResolveAsync(async context =>
{
var response = await _mediator.Send(context.GetArgument <CreateOrderFromCartCommand>(_commandName));
context.SetExpandedObjectGraph(response);
return(response);
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, bool>(typeof(BooleanGraphType))
.Name("changeOrderStatus")
.Argument <NonNullGraphType <InputChangeOrderStatusType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <ChangeOrderStatusCommand>(_commandName);
var order = await _customerOrderService.GetByIdAsync(command.OrderId);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), order, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, bool>(typeof(BooleanGraphType))
.Name("confirmOrderPayment")
.Argument <NonNullGraphType <InputConfirmOrderPaymentType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <ConfirmOrderPaymentCommand>(_commandName);
var order = await _customerOrderService.GetByIdAsync(command.Payment.OrderId);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), order, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, bool>(typeof(BooleanGraphType))
.Name("cancelOrderPayment")
.Argument <NonNullGraphType <InputCancelOrderPaymentType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <CancelOrderPaymentCommand>(_commandName);
var order = await _customerOrderService.GetByIdAsync(command.Payment.OrderId);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), order, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
return(await _mediator.Send(command));
})
.FieldType);
}
public void Build(ISchema schema)
{
//Queries
//We can't use the fluent syntax for new types registration provided by dotnet graphql here, because we have the strict requirement for underlying types extensions
//and must use GraphTypeExtenstionHelper to resolve the effective type on execution time
var cartField = new FieldType
{
Name = "cart",
Arguments = new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "storeId", Description = "Store Id"
},
new QueryArgument <StringGraphType> {
Name = "userId", Description = "User Id"
},
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "currencyCode", Description = "Currency code (\"USD\")"
},
new QueryArgument <StringGraphType> {
Name = "cultureName", Description = "Culture name (\"en-Us\")"
},
new QueryArgument <StringGraphType> {
Name = "cartName", Description = "Cart name"
},
new QueryArgument <StringGraphType> {
Name = "type", Description = "Cart type"
}),
Type = GraphTypeExtenstionHelper.GetActualType <CartType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var getCartQuery = context.GetCartQuery <GetCartQuery>();
getCartQuery.IncludeFields = context.SubFields.Values.GetAllNodesPaths().ToArray();
context.CopyArgumentsToUserContext();
var cartAggregate = await _mediator.Send(getCartQuery);
if (cartAggregate == null)
{
var createCartCommand = new CreateCartCommand(getCartQuery.StoreId, getCartQuery.CartType, getCartQuery.CartName, getCartQuery.UserId, getCartQuery.CurrencyCode, getCartQuery.CultureName);
cartAggregate = await _mediator.Send(createCartCommand);
}
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
};
schema.Query.AddField(cartField);
var orderConnectionBuilder = GraphTypeExtenstionHelper.CreateConnection <CartType, object>()
.Name("carts")
.Argument <StringGraphType>("storeId", "")
.Argument <StringGraphType>("userId", "")
.Argument <StringGraphType>("currencyCode", "")
.Argument <StringGraphType>("cultureName", "")
.Argument <StringGraphType>("cartType", "")
.Argument <StringGraphType>("filter", "This parameter applies a filter to the query results")
.Argument <StringGraphType>("sort", "The sort expression")
.Unidirectional()
.PageSize(20);
orderConnectionBuilder.ResolveAsync(async context => await ResolveConnectionAsync(_mediator, context));
schema.Query.AddField(orderConnectionBuilder.FieldType);
//Mutations
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputAddItemType!){ addItem(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "productId": "9cbd8f316e254a679ba34a900fccb076",
/// "quantity": 1
/// }
/// }
/// }
/// </example>
var addItemField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("addItem")
.Argument <NonNullGraphType <InputAddItemType> >(_commandName)
//TODO: Write the unit-tests for successfully mapping input variable to the command
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <AddCartItemCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
.FieldType;
schema.Mutation.AddField(addItemField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputClearCartType!){ clearCart(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart"
/// }
/// }
/// }
/// </example>
var clearCartField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("clearCart")
.Argument <NonNullGraphType <InputClearCartType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <ClearCartCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(clearCartField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputChangeCommentType!){ changeComment(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "comment": "Hi, Virto!"
/// }
/// }
/// }
/// </example>
var changeCommentField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("changeComment")
.Argument <InputChangeCommentType>(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <ChangeCommentCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
.FieldType;
schema.Mutation.AddField(changeCommentField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputChangeCartItemPriceType!){ changeCartItemPrice(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "lineItemId": "9cbd8f316e254a679ba34a900fccb076",
/// "price": 777
/// }
/// }
/// }
/// </example>
var changeCartItemPriceField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("changeCartItemPrice")
.Argument <NonNullGraphType <InputChangeCartItemPriceType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <ChangeCartItemPriceCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(changeCartItemPriceField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputChangeCartItemQuantityType!){ changeCartItemQuantity(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "lineItemId": "9cbd8f316e254a679ba34a900fccb076",
/// "quantity": 777
/// }
/// }
/// }
/// </example>
var changeCartItemQuantityField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("changeCartItemQuantity")
.Argument <NonNullGraphType <InputChangeCartItemQuantityType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <ChangeCartItemQuantityCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(changeCartItemQuantityField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputChangeCartItemCommentType!){ changeCartItemComment(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "lineItemId": "9cbd8f316e254a679ba34a900fccb076",
/// "comment": "verynicecomment"
/// }
/// }
/// }
/// </example>
var changeCartItemCommentField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("changeCartItemComment")
.Argument <InputChangeCartItemCommentType>(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <ChangeCartItemCommentCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(changeCartItemCommentField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputRemoveItemType!){ removeCartItem(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "lineItemId": "9cbd8f316e254a679ba34a900fccb076"
/// }
/// }
/// }
/// </example>
var removeCartItemField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("removeCartItem")
.Argument <NonNullGraphType <InputRemoveItemType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <RemoveCartItemCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(removeCartItemField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputAddCouponType!){ addCoupon(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "couponCode": "verynicecouponcode"
/// }
/// }
/// }
/// </example>
var addCouponField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("addCoupon")
.Argument <NonNullGraphType <InputAddCouponType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <AddCouponCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(addCouponField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputRemoveCouponType!){ removeCoupon(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "couponCode": "verynicecouponcode"
/// }
/// }
/// }
/// </example>
var removeCouponField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("removeCoupon")
.Argument <NonNullGraphType <InputRemoveCouponType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <RemoveCouponCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(removeCouponField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputRemoveShipmentType!){ removeShipment(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "shipmentId": "7777-7777-7777-7777"
/// }
/// }
/// }
/// </example>
var removeShipmentField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("removeShipment")
.Argument <NonNullGraphType <InputRemoveShipmentType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <RemoveShipmentCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(removeShipmentField);
//TODO: add shipment model to example
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputAddOrUpdateCartShipmentType!){ addOrUpdateCartShipment(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "shipment": { }
/// }
/// }
/// }
/// </example>
var addOrUpdateCartShipmentField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("addOrUpdateCartShipment")
.Argument <NonNullGraphType <InputAddOrUpdateCartShipmentType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <AddOrUpdateCartShipmentCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(addOrUpdateCartShipmentField);
//TODO: add payment model to example
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputAddOrUpdateCartPaymentType!){ addOrUpdateCartPayment(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "payment": { }
/// }
/// }
/// }
/// </example>
var addOrUpdateCartPaymentField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("addOrUpdateCartPayment")
.Argument <NonNullGraphType <InputAddOrUpdateCartPaymentType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <AddOrUpdateCartPaymentCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(addOrUpdateCartPaymentField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputValidateCouponType!){ validateCoupon(command: $command) }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "coupon": {
/// "code":"verynicecodeforvalidation"
/// }
/// }
/// }
/// }
/// </example>
var validateCouponField = FieldBuilder.Create <CartAggregate, bool>(typeof(BooleanGraphType))
.Name("validateCoupon")
.Argument <NonNullGraphType <InputValidateCouponType> >(_commandName)
.ResolveAsync(async context => await _mediator.Send(context.GetArgument <ValidateCouponCommand>(_commandName)))
.FieldType;
schema.Mutation.AddField(validateCouponField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:MergeCartType!){ mergeCart(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "secondCartId": "7777-7777-7777-7777"
/// }
/// }
/// }
/// </example>
var margeCartField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("mergeCart")
.Argument <NonNullGraphType <InputMergeCartType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetCartCommand <MergeCartCommand>());
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
}).FieldType;
schema.Mutation.AddField(margeCartField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputRemoveCartType!){ removeCart(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "cartId": "7777-7777-7777-7777"
/// }
/// }
/// }
/// </example>
var removeCartField = FieldBuilder.Create <CartAggregate, bool>(typeof(BooleanGraphType))
.Name("removeCart")
.Argument <NonNullGraphType <InputRemoveCartType> >(_commandName)
.ResolveAsync(async context => await _mediator.Send(context.GetArgument <RemoveCartCommand>(_commandName)))
.FieldType;
schema.Mutation.AddField(removeCartField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputClearShipmentsType!){ clearShipments(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "cartId": "7777-7777-7777-7777"
/// }
/// }
/// }
/// </example>
var clearShipmentsField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("clearShipments")
.Argument <NonNullGraphType <InputClearShipmentsType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetArgument <ClearShipmentsCommand>(_commandName));
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
.FieldType;
schema.Mutation.AddField(clearShipmentsField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputClearPaymentsType!){ clearPayments(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "cartId": "7777-7777-7777-7777"
/// }
/// }
/// }
/// </example>
var clearPaymentsField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("clearPayments")
.Argument <NonNullGraphType <InputClearPaymentsType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetArgument <ClearPaymentsCommand>(_commandName));
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
.FieldType;
schema.Mutation.AddField(clearPaymentsField);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputAddOrUpdateCartAddressType!){ addOrUpdateCartAddress(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "storeId": "Electronics",
/// "cartName": "default",
/// "userId": "b57d06db-1638-4d37-9734-fd01a9bc59aa",
/// "language": "en-US",
/// "currency": "USD",
/// "cartType": "cart",
/// "address": {
/// "line1":"st street 1"
/// }
/// }
/// }
/// }
/// </example>
var addOrUpdateCartAddress = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("addOrUpdateCartAddress")
.Argument <NonNullGraphType <InputAddOrUpdateCartAddressType> >(_commandName)
.ResolveAsync(async context =>
{
//TODO: Need to refactor later to prevent ugly code duplication
//We need to add cartAggregate to the context to be able use it on nested cart types resolvers (e.g for currency)
var cartAggregate = await _mediator.Send(context.GetArgument <AddOrUpdateCartAddressCommand>(_commandName));
//store cart aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(cartAggregate);
return(cartAggregate);
})
.FieldType;
schema.Mutation.AddField(addOrUpdateCartAddress);
/// <example>
/// This is an example JSON request for a mutation
/// {
/// "query": "mutation ($command:InputRemoveCartAddressType!){ removeCartAddress(command: $command) { total { formatedAmount } } }",
/// "variables": {
/// "command": {
/// "cartId": "7777-7777-7777-7777",
/// "addressId": "111"
/// }
/// }
/// }
/// </example>
var removeCartAddressField = FieldBuilder.Create <CartAggregate, CartAggregate>(typeof(CartType))
.Name("removeCartAddress")
.Argument <NonNullGraphType <InputRemoveCartAddressType> >(_commandName)
.ResolveAsync(async context => await _mediator.Send(context.GetArgument <RemoveCartAddressCommand>(_commandName)))
.FieldType;
schema.Mutation.AddField(removeCartAddressField);
}
public void Build(ISchema schema)
{
ValueConverter.Register <ExpOrderAddress, Optional <ExpOrderAddress> >(x => new Optional <ExpOrderAddress>(x));
_ = schema.Query.AddField(new FieldType
{
Name = "order",
Arguments = AbstractTypeFactory <OrderQueryArguments> .TryCreateInstance(),
Type = GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var request = context.ExtractQuery <GetOrderQuery>();
context.CopyArgumentsToUserContext();
var orderAggregate = await _mediator.Send(request);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), orderAggregate.Order, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new AuthorizationError($"Access denied");
}
var allCurrencies = await _currencyService.GetAllCurrenciesAsync();
//Store all currencies in the user context for future resolve in the schema types
context.SetCurrencies(allCurrencies, request.CultureName);
//store order aggregate in the user context for future usage in the graph types resolvers
context.SetExpandedObjectGraph(orderAggregate);
return(orderAggregate);
})
});
var orderConnectionBuilder = GraphTypeExtenstionHelper
.CreateConnection <CustomerOrderType, object>()
.Name("orders")
.PageSize(20)
.Arguments();
orderConnectionBuilder.ResolveAsync(async context => await ResolveOrdersConnectionAsync(_mediator, context));
schema.Query.AddField(orderConnectionBuilder.FieldType);
var paymentsConnectionBuilder = GraphTypeExtenstionHelper
.CreateConnection <PaymentInType, object>()
.Name("payments")
.PageSize(20)
.Arguments();
paymentsConnectionBuilder.ResolveAsync(async context => await ResolvePaymentsConnectionAsync(_mediator, context));
schema.Query.AddField(paymentsConnectionBuilder.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("createOrderFromCart")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputCreateOrderFromCartType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <CreateOrderFromCartCommand>();
var response = (CustomerOrderAggregate)await _mediator.Send(context.GetArgument(type, _commandName));
context.SetExpandedObjectGraph(response);
return(response);
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, bool>(typeof(BooleanGraphType))
.Name("changeOrderStatus")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputChangeOrderStatusType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <ChangeOrderStatusCommand>();
var command = (ChangeOrderStatusCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, ProcessPaymentRequestResult>(typeof(ProcessPaymentRequestResultType))
.Name("processOrderPayment")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputProcessOrderPaymentType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <ProcessOrderPaymentCommand>();
var command = (ProcessOrderPaymentCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.DeprecationReason("Obsolete. Use 'initializePayment' mutation")
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, InitializePaymentResult>(typeof(InitializePaymentResultType))
.Name("initializePayment")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputInitializePaymentType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <InitializePaymentCommand>();
var command = (InitializePaymentCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, AuthorizePaymentResult>(typeof(AuthorizePaymentResultType))
.Name("authorizePayment")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputAuthorizePaymentType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <AuthorizePaymentCommand>();
var command = (AuthorizePaymentCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <CustomerOrderAggregate, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("updateOrderDynamicProperties")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputUpdateOrderDynamicPropertiesType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <UpdateOrderDynamicPropertiesCommand>();
var command = (UpdateOrderDynamicPropertiesCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <CustomerOrderAggregate, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("updateOrderItemDynamicProperties")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputUpdateOrderItemDynamicPropertiesType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <UpdateOrderItemDynamicPropertiesCommand>();
var command = (UpdateOrderItemDynamicPropertiesCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <CustomerOrderAggregate, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("updateOrderPaymentDynamicProperties")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputUpdateOrderPaymentDynamicPropertiesType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <UpdateOrderPaymentDynamicPropertiesCommand>();
var command = (UpdateOrderPaymentDynamicPropertiesCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <CustomerOrderAggregate, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("updateOrderShipmentDynamicProperties")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputUpdateOrderShipmentDynamicPropertiesType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <UpdateOrderShipmentDynamicPropertiesCommand>();
var command = (UpdateOrderShipmentDynamicPropertiesCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <CustomerOrderAggregate, CustomerOrderAggregate>(GraphTypeExtenstionHelper.GetActualType <CustomerOrderType>())
.Name("addOrUpdateOrderPayment")
.Argument(GraphTypeExtenstionHelper.GetActualComplexType <NonNullGraphType <InputAddOrUpdateOrderPaymentType> >(), _commandName)
.ResolveAsync(async context =>
{
var type = GenericTypeHelper.GetActualType <AddOrUpdateOrderPaymentCommand>();
var command = (AddOrUpdateOrderPaymentCommand)context.GetArgument(type, _commandName);
await CheckAuthAsync(context, command.OrderId);
var response = await _mediator.Send(command);
context.SetExpandedObjectGraph(response);
return(response);
})
.FieldType);
}
public void Passing_primitive_should_create_PrimitiveFieldBuilder(object value)
{
var output = FieldBuilder.Create(value.GetType(), "test", new TestBuildContext());
output.Should().BeOfType <PrimitiveFieldBuilder>();
}
public void Build(ISchema schema)
{
schema.Query.AddField(new FieldType
{
Name = "me",
Type = GraphTypeExtenstionHelper.GetActualType <UserType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var userName = ((GraphQLUserContext)context.UserContext).User?.Identity.Name;
if (!string.IsNullOrEmpty(userName))
{
var result = await _mediator.Send(new GetUserQuery
{
UserName = userName
});
return(result);
}
return(AnonymousUser.Instance);
})
});
//Queries
#region organization query
/* organization query with contacts connection filtering:
* {
* organization(id: "689a72757c754bef97cde51afc663430"){
* id contacts(first:10, after: "0", searchPhrase: null){
* totalCount items {id firstName}
* }
* }
* }
*/
#endregion
schema.Query.AddField(new FieldType
{
Name = "organization",
Arguments = new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "userId"
}
),
Type = GraphTypeExtenstionHelper.GetActualType <OrganizationType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var organizationId = context.GetArgument <string>("id");
var query = new GetOrganizationByIdQuery(organizationId);
var organizationAggregate = await _mediator.Send(query);
await CheckAuthAsync(context.GetCurrentUserId(), organizationAggregate);
//store organization aggregate in the user context for future usage in the graph types resolvers
context.UserContext.Add("organizationAggregate", organizationAggregate);
return(organizationAggregate);
})
});
#region contact query
/// <example>
#pragma warning disable S125 // Sections of code should not be commented out
/*
* {
* contact(id: "51311ae5-371c-453b-9394-e6d352f1cea7"){
* firstName memberType organizationIds organizations { id businessCategory description emails groups memberType name outerId ownerId parentId phones seoObjectType }
* addresses { line1 phone }
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
/// </example>
#endregion
schema.Query.AddField(new FieldType
{
Name = "contact",
Arguments = new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "userId"
}
),
Type = GraphTypeExtenstionHelper.GetActualType <ContactType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var query = new GetContactByIdQuery(context.GetArgument <string>("id"));
var contactAggregate = await _mediator.Send(query);
await CheckAuthAsync(context.GetCurrentUserId(), contactAggregate);
//store organization aggregate in the user context for future usage in the graph types resolvers
context.UserContext.Add("contactAggregate", contactAggregate);
return(contactAggregate);
})
});
#region updateAddressMutation
/// sample code for updating addresses:
#pragma warning disable S125 // Sections of code should not be commented out
/*
* mutation updateAddresses($command: InputUpdateContactAddressType!){
* contact: updateAddresses(command: $command)
* {
* firstName lastName
* addresses { key city countryCode countryName email firstName lastName line1 line2 middleName name phone postalCode regionId regionName zip }
* }
* }
* query variables:
* {
* "command": {
* "contactId": "acc3b262-a21e-45f9-a612-b4b1530d27ef",
* "addresses": [{"addressType": "Shipping", "name": "string", "countryCode": "string", "countryName": "string", "city": "string", "postalCode": "string", "line1": "string", "regionId": "string", "regionName": "string", "firstName": "string", "lastName": "string", "phone": "string", "email": "string", "regionId": "string"
* }]
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Mutation.AddField(FieldBuilder.Create <ContactAggregate, ContactAggregate>(typeof(ContactType))
.Name("updateAddresses")
.Argument <NonNullGraphType <InputUpdateContactAddressType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdateContactAddressesCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <OrganizationAggregate, OrganizationAggregate>(typeof(OrganizationType))
.Name("updateOrganization")
.Argument <NonNullGraphType <InputUpdateOrganizationType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdateOrganizationCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command, CustomerModule.Core.ModuleConstants.Security.Permissions.Update);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <OrganizationAggregate, OrganizationAggregate>(typeof(OrganizationType))
.Name("createOrganization")
.Argument <NonNullGraphType <InputCreateOrganizationType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <CreateOrganizationCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <ContactAggregate, ContactAggregate>(typeof(ContactType))
.Name("createContact")
.Argument <NonNullGraphType <InputCreateContactType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <CreateContactCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <ContactAggregate, ContactAggregate>(typeof(ContactType))
.Name("updateContact")
.Argument <NonNullGraphType <InputUpdateContactType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdateContactCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <ContactAggregate, bool>(typeof(BooleanGraphType))
.Name("deleteContact")
.Argument <NonNullGraphType <InputDeleteContactType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <DeleteContactCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command, CustomerModule.Core.ModuleConstants.Security.Permissions.Delete);
return(await _mediator.Send(command));
})
.FieldType);
_ = schema.Mutation.AddField(FieldBuilder.Create <object, IdentityResult>(typeof(IdentityResultType))
.Name("updatePersonalData")
.Argument <NonNullGraphType <InputUpdatePersonalDataType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdatePersonalDataCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
// Security API fields
#region user query
#pragma warning disable S125 // Sections of code should not be commented out
/*
* {
* user(id: "1eb2fa8ac6574541afdb525833dadb46"){
* userName isAdministrator roles { name } userType memberId storeId
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Query.AddField(new FieldType
{
Name = "user",
Arguments = new QueryArguments(
new QueryArgument <StringGraphType> {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "userName"
},
new QueryArgument <StringGraphType> {
Name = "email"
},
new QueryArgument <StringGraphType> {
Name = "loginProvider"
},
new QueryArgument <StringGraphType> {
Name = "providerKey"
}),
Type = GraphTypeExtenstionHelper.GetActualType <UserType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var user = await _mediator.Send(new GetUserQuery(
id: context.GetArgument <string>("id"),
userName: context.GetArgument <string>("userName"),
email: context.GetArgument <string>("email"),
loginProvider: context.GetArgument <string>("loginProvider"),
providerKey: context.GetArgument <string>("providerKey")));
await CheckAuthAsync(context.GetCurrentUserId(), user);
return(user);
})
});
#region role query
#pragma warning disable S125 // Sections of code should not be commented out
/*
* {
* getRole(roleName: "Use api"){
* permissions
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Query.AddField(new FieldType
{
Name = "role",
Arguments = new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "roleName"
}
),
Type = GraphTypeExtenstionHelper.GetActualType <RoleType>(),
Resolver = new AsyncFieldResolver <object>(async context =>
{
var result = await _mediator.Send(new GetRoleQuery(context.GetArgument <string>("roleName")));
return(result);
})
});
#region create user
#pragma warning disable S125 // Sections of code should not be commented out
/*
* mutation ($command: InputCreateUserType!){
* createUser(command: $command){ succeeded errors { code }}
* }
* Query variables:
* {
* "command": {
* "createdBy": "eXp1", "email": "*****@*****.**", "password":"******", "userName": "******", "userType": "Customer"
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Mutation.AddField(FieldBuilder.Create <object, IdentityResult>(typeof(IdentityResultType))
.Name("createUser")
.Argument <NonNullGraphType <InputCreateUserType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <CreateUserCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
#region update user
#pragma warning disable S125 // Sections of code should not be commented out
/*
* mutation ($command: InputUpdateUserType!){
* updateUser(command: $command){ succeeded errors { description } }
* }
* Query variables:
* {
* "command":{
* "isAdministrator": false,
* "userType": "Customer",
* "roles": [],
* "id": "b5d28a83-c296-4212-b89e-046fca3866be",
* "userName": "******",
* "email": "*****@*****.**"
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Mutation.AddField(FieldBuilder.Create <object, IdentityResult>(typeof(IdentityResultType))
.Name("updateUser")
.Argument <NonNullGraphType <InputUpdateUserType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdateUserCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command);
return(await _mediator.Send(command));
})
.FieldType);
#region delete user
#pragma warning disable S125 // Sections of code should not be commented out
/*
* mutation ($command: InputDeleteUserType!){
* deleteUser(command: $command){ succeeded errors { description } }
* }
* Query variables:
* {
* "command": {
* "userNames": ["admin", "*****@*****.**"]
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Mutation.AddField(FieldBuilder.Create <object, IdentityResult>(typeof(IdentityResultType))
.Name("deleteUsers")
.Argument <NonNullGraphType <InputDeleteUserType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <DeleteUserCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command, PlatformConstants.Security.Permissions.SecurityDelete);
return(await _mediator.Send(command));
})
.FieldType);
#region update role query
#pragma warning disable S125 // Sections of code should not be commented out
/*
* mutation ($command: InputUpdateRoleType!){
* updateRole(command: $command){ succeeded errors { description } }
* }
* Query variables:
* {
* "command":{
* "id": "graphtest", "name": "graphtest", "permissions": [
* { "name": "order:read", "assignedScopes": [{"scope": "{{userId}}", "type": "OnlyOrderResponsibleScope" }] }
* ]
* }
* }
*/
#pragma warning restore S125 // Sections of code should not be commented out
#endregion
_ = schema.Mutation.AddField(FieldBuilder.Create <object, IdentityResult>(typeof(IdentityResultType))
.Name("updateRole")
.Argument <NonNullGraphType <InputUpdateRoleType> >(_commandName)
.ResolveAsync(async context =>
{
var command = context.GetArgument <UpdateRoleCommand>(_commandName);
await CheckAuthAsync(context.GetCurrentUserId(), command, PlatformConstants.Security.Permissions.SecurityUpdate);
return(await _mediator.Send(command));
})
.FieldType);
}