public Failed(MutationRequest request, string resource, TInput input, string exception)
{
Request = request.ToString();
ResourceType = resource;
Input = input;
Exception = exception;
}
public static async Task <T> PostAsync <T>(string endpoint, MutationRequest request, string section, CancellationToken?token = null)
{
var gqlClient = new GraphQLClient(endpoint, new GraphQLClientOptions {
MediaType = new MediaTypeHeaderValue("application/json")
});
try
{
var gqlRequest = new GraphQLRequest
{
Query = request.Query,
Variables = request.Variables
};
var gqlResponse = await gqlClient.PostAsync(gqlRequest, token ?? CancellationToken.None);
if (gqlResponse.Errors?.Length > 0)
{
throw new GraphQLException(gqlResponse.Errors[0]);
}
var result = gqlResponse.GetDataFieldAs <T>(section);
return(result);
}
finally
{
gqlClient.Dispose();
}
}
public Rejected(MutationRequest request, string resource, TInput input, string reason)
{
Request = request.ToString();
ResourceType = resource;
Input = input;
Reason = reason;
}
public void TrackRequest <TResource, TInput>(MutationRequest request, string id)
{
_telemetry.TrackEvent(request.ToString(), new Dictionary <string, string>
{
["resource"] = typeof(TResource).Name,
["input"] = typeof(TInput).Name,
["resource_id"] = id,
["correlation_id"] = CorrelationId
});
}
public void TrackException <TResource, TInput>(MutationRequest request, string id, Exception ex)
{
_telemetry.TrackException(ex, new Dictionary <string, string>
{
["resource"] = typeof(TResource).Name,
["input"] = typeof(TInput).Name,
["resource_id"] = id,
["correlation_id"] = CorrelationId
});
}
private void SetQuery()
{
var bookReview = new BookReview
{
BookISBN = "0544272994",
Review = "This is a mutation test"
};
_request = new MutationRequest <BookReviewMutationResponse>("createReview", "review", bookReview);
Query = _request.Query;
}
protected virtual async Task <IActionResult> ProcessRequest <TInput>(
string id, MutationRequest type, TInput input,
Func <TState, Result, IActionResult> responseFunc,
CancellationToken cancellationToken)
{
IRestfulGrain <TState> grain = GetGrain(id);
var result = await grain.Execute(new CustomRequest <TResource, TInput>(type, input));
return(responseFunc(await grain.Get(), result));
}
private async Task HandleException <TResource, TInput>(MutationRequest request, TInput input, Exception ex)
{
var failure = new Failed <TInput>(request, typeof(TResource).Name, input, ex.Message);
_logger.LogError(30001, ex, "Exception in event handling");
_telemetry.TrackException <TResource, TInput>(request, GrainId(), ex);
await Persist(new List <EventDto>()
{ new EventDto()
{
Name = $"Failed:{typeof(TInput).Name}", Event = failure
} });
}
private async Task <Result> Handle <TResource, TInput>(MutationRequest request, TInput input)
{
_telemetry.TrackRequest <TResource, TInput>(request, GrainId());
if (!CreateRequest(request, input) && !State.Exists && !ImplicitCreateAllowed())
{
return(NotFound <TResource, TInput>());
}
try
{
var events = await HandleEvent <T, TResource, TInput>(request, input);
var success = !events.Any(e => e is Rejected <TInput>);
return(success ? Result.Ok(events) : Result.Nok(events));
}
catch (Exception ex)
{
await HandleException <TResource, TInput>(request, input, ex);
throw;
}
}
/// <summary>
/// Maps TResult schema into a GraphQL mutation result
/// </summary>
/// <typeparam name="TResult">Represents the class mapping the result from the server</typeparam>
/// <param name="mutationName">The name of the mutation on the server</param>
/// <param name="variables">The variables to be passed to the mutation</param>
/// <returns>A mutation request instance</returns>
public static MutationRequest BuildMutation <TResult>(string mutationName, IList <MutationParameters> variables)
{
var result = new MutationRequest();
var paramsTypes = new List <string>();
var paramsValues = new List <string>();
foreach (var parameter in variables)
{
paramsTypes.Add($@" ${parameter.Name}: {parameter.Type} ");
paramsValues.Add($@" {parameter.Name}: ${parameter.Name} ");
var expandoDictionary = result.Variables as IDictionary <string, object>;
expandoDictionary.Add(parameter.Name, parameter.Content);
}
string strParamsTypes = string.Join(", ", paramsTypes);
string strParamsValues = string.Join(", ", paramsValues);
string resultSchema = BuildQuerySchema <TResult>();
result.Query = $@"mutation ( { strParamsTypes } ) {{ { mutationName } ( { strParamsValues } ) { resultSchema } }}";
return(result);
}
public CustomRequest(MutationRequest request, TInput input)
{
Request = request;
Input = input;
}
public static MethodInfo SelfMethod(this Type grainType, MutationRequest request)
{
static bool match(MethodInfo mi, Type grainType, MutationRequest request) => mi.Name.ToUpperInvariant() == request.ToString().ToUpperInvariant() && mi.IsPublic && ReturnTypeMatches(mi) && !mi.GetParameters().Any();
public async Task <BookReviewMutationResponse> CreateReview(MutationRequest <BookReviewMutationResponse> mutationRequest)
{
var review = await _webApiClient.SendMutationAsync(mutationRequest);
return(review);
}
private async Task <IEnumerable <object> > HandleEvent <TOwner, TResource, TInput>(MutationRequest request, TInput input)
{
if (ModelVersion() == -1)
{
throw new InvalidOperationException("Event restore failed");
}
var reception = new Received <TInput>(request, typeof(TResource).Name, input);
await Persist(new EventDto()
{
Name = $"Received:{typeof(TInput).Name}", Event = reception
});
if (!State.Exists && !CreateRequest(request, input))
{
if (ModelVersion() == 1)
{
if (ImplicitCreateAllowed())
{
IEnumerable <object> created = IsPostDefined()
? (await Dispatch <T, T>(MutationRequest.POST, default))
: DefaultCreationEvent();
await Persist <TResource, TInput>(created);
}
}
else
{
await Upgrade();
}
}
IEnumerable <object> events = await Dispatch <TResource, TInput>(request, input);
List <object> handleEvent = events.ToList();
await Persist <TResource, TInput>(handleEvent);
return(handleEvent);
}
protected virtual Task <IActionResult> ProcessRequest <TInput>(
string id, MutationRequest type, TInput input,
CancellationToken cancellationToken) => ProcessRequest(id, type, input, Respond, cancellationToken);
public virtual Task <IEnumerable <object> > Invoke <TResource, TInput>(T resourceOwner, MutationRequest request, TInput input)
{
private async Task <IEnumerable <object> > Dispatch <TResource, TInput>(MutationRequest request, TInput input)
{
return(await _dispatcher.Invoke <TResource, TInput>(State.Value, request, input));
}
private bool CreateRequest(MutationRequest request, object input)
{
return(request == MutationRequest.POST && input is T);
}
public Ignored(MutationRequest request, string resource, TInput input)
{
Request = request.ToString();
ResourceType = resource;
Input = input;
}
