public async Task <IResultGenericWrapper <ResultRoulette> > CloseRouletteAsync(string rouletteId)
{
Roulette roulette = await _repository.GetRouletteByIdAsync(rouletteId : rouletteId);
IResultWrapper isRouletteValid = IsRouletteValidToClose(roulette);
if (isRouletteValid.Error)
{
return(new ResultGenericWrapper <ResultRoulette>(error: isRouletteValid.Error, message: isRouletteValid.Message));
}
UpdateStatusRouletteAsync(roulette: roulette, status: StatusRoulette.Closed);
return(GetResultBetsToRoulette(roulette));
}
public async Task <IResultWrapper> PlaceBetAsync(string rouletteId, Bet bet)
{
Roulette roulette = await _repository.GetRouletteByIdAsync(rouletteId : rouletteId);
IResultWrapper isRouletteValid = IsRouletteValidToPlaceBet(roulette: roulette);
if (isRouletteValid.Error)
{
return(isRouletteValid);
}
IResultWrapper isBetValid = IsValidBet(bet: bet);
if (isBetValid.Error)
{
return(isBetValid);
}
AddBetToRoulette(roulette, bet);
return(new ResultWrapper(error: false));
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceMethodInvoker"/> class.
/// </summary>
/// <param name="behaviorInvoker">The service behavior invoker.</param>
/// <param name="parameterValueProvider">The parameter value provider.</param>
/// <param name="resultWrapper">The service method result wrapper.</param>
public ServiceMethodInvoker(IServiceBehaviorInvoker behaviorInvoker, IParameterValueProvider parameterValueProvider, IResultWrapper resultWrapper)
{
if (behaviorInvoker == null)
{
throw new ArgumentNullException("behaviorInvoker");
}
if (parameterValueProvider == null)
{
throw new ArgumentNullException("parameterValueProvider");
}
if (resultWrapper == null)
{
throw new ArgumentNullException("resultWrapper");
}
m_behaviorInvoker = behaviorInvoker;
m_parameterValueProvider = parameterValueProvider;
m_resultWrapper = resultWrapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="RootRouteHandler"/> class.
/// </summary>
/// <param name="serviceContext">The service context.</param>
/// <param name="contentNegotiator">The content negotiator.</param>
/// <param name="resultWrapper">The service method result wrapper.</param>
public RootRouteHandler(IServiceContext serviceContext, IContentNegotiator contentNegotiator, IResultWrapper resultWrapper)
{
if (serviceContext == null)
{
throw new ArgumentNullException("serviceContext");
}
if (contentNegotiator == null)
{
throw new ArgumentNullException("contentNegotiator");
}
if (resultWrapper == null)
{
throw new ArgumentNullException("resultWrapper");
}
m_serviceContext = serviceContext;
m_contentNegotiator = contentNegotiator;
m_resultWrapper = resultWrapper;
}
private async Task <JsonRpcResponse> ExecuteAsync(JsonRpcRequest request, string methodName, MethodInfo method)
{
var expectedParameters = method.GetParameters();
var providedParameters = request.Params;
if (_logger.IsInfo)
{
_logger.Info($"Executing JSON RPC call {methodName} with params {string.Join(',', providedParameters)}");
}
int missingParamsCount = expectedParameters.Length - (providedParameters?.Length ?? 0) + providedParameters?.Count(string.IsNullOrWhiteSpace) ?? 0;
if (missingParamsCount != 0)
{
bool incorrectParametersCount = missingParamsCount != 0;
if (missingParamsCount > 0)
{
incorrectParametersCount = false;
for (int i = 0; i < missingParamsCount; i++)
{
if (!expectedParameters[expectedParameters.Length - missingParamsCount + i].IsOptional)
{
incorrectParametersCount = true;
break;
}
}
}
if (incorrectParametersCount)
{
return(GetErrorResponse(ErrorType.InvalidParams, $"Incorrect parameters count, expected: {expectedParameters.Length}, actual: {expectedParameters.Length - missingParamsCount}", request.Id, methodName));
}
}
//prepare parameters
object[] parameters = null;
if (expectedParameters.Length > 0)
{
parameters = DeserializeParameters(expectedParameters, providedParameters, missingParamsCount);
if (parameters == null)
{
if (_logger.IsError)
{
_logger.Error($"Incorrect JSON RPC parameters when calling {methodName}: {string.Join(", ", providedParameters)}");
}
return(GetErrorResponse(ErrorType.InvalidParams, "Incorrect parameters", request.Id, methodName));
}
}
//execute method
IResultWrapper resultWrapper = null;
IModule module = _rpcModuleProvider.Rent(methodName);
try
{
var invocationResult = method.Invoke(module, parameters);
if (invocationResult is IResultWrapper wrapper)
{
resultWrapper = wrapper;
}
else if (invocationResult is Task task)
{
await task;
resultWrapper = task.GetType().GetProperty("Result").GetValue(task) as IResultWrapper;
}
}
finally
{
_rpcModuleProvider.Return(methodName, module);
}
if (resultWrapper is null)
{
string errorMessage = $"Method {methodName} execution result does not implement IResultWrapper";
if (_logger.IsError)
{
_logger.Error(errorMessage);
}
return(GetErrorResponse(ErrorType.InternalError, errorMessage, request.Id, methodName));
}
Result result = resultWrapper.GetResult();
if (result == null || result.ResultType == ResultType.Failure)
{
if (_logger.IsError)
{
_logger.Error($"Error during method: {methodName} execution: {result?.Error ?? "no result"}");
}
return(GetErrorResponse(resultWrapper.GetErrorType(), resultWrapper.GetResult().Error, request.Id, methodName, resultWrapper.GetData()));
}
return(GetSuccessResponse(resultWrapper.GetData(), request.Id));
}
