public async Task <IActionResult> Produce(DeleteOperationRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
public async Task <IActionResult> Delete([FromRoute] DeleteOperationFromRoute route,
[FromQuery] DeleteOperationFromQuery query,
[FromHeader] DeleteOperationFromHeader header)
{
var request = new DeleteOperationRequest(route, query, header);
var result = await _apiResult.Produce(request);
return(result);
}
public DeleteOperationCommand Map(DeleteOperationRequest request)
{
var id = new Guid(request.RouteId);
var version = ToVersion(request.HeaderIfMatch);
var result = new DeleteOperationCommand(id, version);
return(result);
}
/// <summary>Snippet for DeleteOperation</summary>
public void DeleteOperationRequestObject()
{
// Snippet: DeleteOperation(DeleteOperationRequest, CallSettings)
// Create client
OperationsClient operationsClient = OperationsClient.Create();
// Initialize request argument(s)
DeleteOperationRequest request = new DeleteOperationRequest {
Name = "",
};
// Make the request
operationsClient.DeleteOperation(request);
// End snippet
}
/// <summary>Snippet for DeleteOperationAsync</summary>
public async Task DeleteOperationAsync_RequestObject()
{
// Snippet: DeleteOperationAsync(DeleteOperationRequest,CallSettings)
// Create client
OperationsClient operationsClient = await OperationsClient.CreateAsync();
// Initialize request argument(s)
DeleteOperationRequest request = new DeleteOperationRequest
{
Name = "",
};
// Make the request
await operationsClient.DeleteOperationAsync(request);
// End snippet
}
public void DeleteOperation()
{
moq::Mock <Operations.OperationsClient> mockGrpcClient = new moq::Mock <Operations.OperationsClient>(moq::MockBehavior.Strict);
DeleteOperationRequest request = new DeleteOperationRequest
{
Name = "name1c9368b0",
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteOperation(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
client.DeleteOperation(request.Name);
mockGrpcClient.VerifyAll();
}
public async Task DeleteOperationAsync2()
{
Mock <Operations.OperationsClient> mockGrpcClient = new Mock <Operations.OperationsClient>(MockBehavior.Strict);
DeleteOperationRequest request = new DeleteOperationRequest
{
Name = "name3373707",
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteOperationAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
await client.DeleteOperationAsync(request);
mockGrpcClient.VerifyAll();
}
public void DeleteOperation2()
{
Mock <Operations.OperationsClient> mockGrpcClient = new Mock <Operations.OperationsClient>(MockBehavior.Strict);
DeleteOperationRequest request = new DeleteOperationRequest
{
Name = "name3373707",
};
Empty expectedResponse = new Empty();
mockGrpcClient.Setup(x => x.DeleteOperation(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
client.DeleteOperation(request);
mockGrpcClient.VerifyAll();
}
public DeleteOperationResponse DeleteOperation(DeleteOperationRequest request)
{
var checkId = DataContext.KeyOperationConfigs.FirstOrDefault(x => x.Id == request.Id);
if (checkId != null)
{
DataContext.KeyOperationConfigs.Attach(checkId);
DataContext.KeyOperationConfigs.Remove(checkId);
DataContext.SaveChanges();
}
return(new DeleteOperationResponse
{
IsSuccess = true,
Message = "Operation has been deleted successfully"
});
}
public async stt::Task DeleteOperationAsync()
{
moq::Mock <Operations.OperationsClient> mockGrpcClient = new moq::Mock <Operations.OperationsClient>(moq::MockBehavior.Strict);
DeleteOperationRequest request = new DeleteOperationRequest
{
Name = "name1c9368b0",
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteOperationAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
OperationsClient client = new OperationsClientImpl(mockGrpcClient.Object, null);
await client.DeleteOperationAsync(request.Name, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
await client.DeleteOperationAsync(request.Name, st::CancellationToken.None);
mockGrpcClient.VerifyAll();
}
public async Task<IActionResult> Process(DeleteOperationRequest request, IValidatorActionResult validatorActionResult)
{
IActionResult actionResult;
if (validatorActionResult.Result == null)
{
var call = _cqsMapper.Map(request);
var result = await _mediator.Send(call);
actionResult = result.IsFailure ? _apiResponse.Fail(result)
: _apiResponse.Deleted();
}
else
{
actionResult = validatorActionResult.Result;
}
return actionResult;
}
public override async Task <Empty> DeleteOperation(DeleteOperationRequest request, ServerCallContext context)
{
var playerIdentity = AuthHeaders.ExtractPlayerId(context);
if (!string.Equals(request.Name, playerIdentity))
{
throw new RpcException(new Status(StatusCode.PermissionDenied,
"Deleting another player's operation is forbidden."));
}
Log.Information($"Requested cancellation for the party of player identifier {request.Name}.");
using (var memClient = _memoryStoreClientManager.GetClient())
{
var party = await GetPartyOfMember(memClient, request.Name);
if (party == null)
{
throw new RpcException(new Status(StatusCode.NotFound,
"The player making this call is not a member of any party"));
}
if (party.LeaderPlayerId != request.Name)
{
throw new RpcException(new Status(StatusCode.PermissionDenied,
"Only the leader can delete a matchmaking join request"));
}
try
{
var partyJoinRequest = await memClient.GetAsync <PartyJoinRequest>(party.Id) ??
throw new EntryNotFoundException(party.Id);
var toDelete = new List <Entry> {
partyJoinRequest
};
foreach (var(member, _) in partyJoinRequest.Party.MemberIdToPit)
{
toDelete.Add(await memClient.GetAsync <PlayerJoinRequest>(member) ??
throw new EntryNotFoundException(member));
}
party.CurrentPhase = PartyDataModel.Phase.Forming;
using (var tx = memClient.CreateTransaction())
{
tx.UpdateAll(party.Yield());
tx.RemoveAllFromQueue(partyJoinRequest.Yield());
tx.DeleteAll(toDelete);
}
Reporter.CancelOperationInc();
return(new Empty());
}
catch (EntryNotFoundException exception)
{
Log.Warning($"Delete for {request.Name} failed.");
if (exception.Id.Contains(party.Id))
{
Reporter.CancelOperationNotFoundInc();
throw new RpcException(new Status(StatusCode.NotFound,
"requested party is not in matchmaking"));
}
throw new RpcException(new Status(StatusCode.Internal,
$"could not find join request for player {exception.Id}"));
}
catch (TransactionAbortedException)
{
Reporter.TransactionAbortedInc("DeleteOperation");
Log.Warning("Transaction for operation deletion was aborted");
throw new RpcException(new Status(StatusCode.Unavailable,
"deletion aborted due to concurrent modification; safe to retry"));
}
}
}
