public void Apply(ConventionContext context, MemberInfo member)
{
context.Application.OnParsingComplete(_ =>
{
if (_.ShowHelp())
{
return;
}
var solution = context.GetStringValue(nameof(NewSubcommand.Solution));
var fileSystemService = context.Application.GetService <IFileSystemService>();
IOperationResponse <string> response = solution.IsNotProvidedByUser()
? fileSystemService.GetSolutionPath(InitDirectory)
: fileSystemService.GetSolutionPath(solution);
if (context.ModelAccessor?.GetModel() is NewSubcommand model && model != null)
{
if (!response.IsSuccessful && response.Message.Exists())
{
model.SetResolvedSolutionErrorMessage(response.Message);
}
model?.SetResolvedSolution(response?.Payload ?? string.Empty);
var solutionValidator = context.GetValidator <SolutionValidator>();
solutionValidator.Validate(model !);
}
});
}
public void WriteResponse(IOperation operation, IOperationResponse response)
{
_transport.SendOperation(OperationCode.HandleResponse, new Dictionary <byte, object>
{
[(byte)OperationParameterCode.OperationId] = _map.GetMappedOperation(operation.GetType()).Id,
[(byte)OperationParameterCode.OperationResponseData] = _serializer.WriteObject(response.GetType(), response)
});
}
private ObjectResult BuildObjectResult <THandlerResponse>(IOperationResponse <THandlerResponse> response)
where THandlerResponse : class, IHandlerResponse
{
return(new ObjectResult(response)
{
StatusCode = (int)response.StatusCode
});
}
public void WriteResponse(IOperation operation, IOperationResponse response)
{
_transport.SendOperation(OperationCode.HandleResponse, new Dictionary<byte, object>
{
[(byte) OperationParameterCode.OperationId] = _map.GetMappedOperation(operation.GetType()).Id,
[(byte) OperationParameterCode.OperationResponseData] = _serializer.WriteObject(response.GetType(), response)
});
}
protected T Return <T>(IOperationResponse <T> response)
where T : class
{
if (!response.IsOk)
{
throw new MyPegasusFactoryException <T>(response.Message);
}
return(response.Payload);
}
public void Apply(ConventionContext context, MemberInfo member)
{
context.Application.OnParsingComplete(_ =>
{
if (_.ShowHelp())
{
return;
}
var project = context.GetStringValue(nameof(InfoSubcommand.Project));
var fileSystemService = context.Application.GetService <IFileSystemService>();
IOperationResponse <IEnumerable <string> > response = project.IsNotProvidedByUser()
? fileSystemService.GetNSeedProjectPaths(InitDirectory)
: fileSystemService.GetNSeedProjectPaths(project);
if (context.ModelAccessor?.GetModel() is InfoSubcommand model && model != null)
{
if (response.IsSuccessful)
{
var dependencyGraphService = context.Application.GetService <IDependencyGraphService>();
var projectPaths = response !.Payload;
foreach (var path in projectPaths !)
{
var frameworkResponse = dependencyGraphService.GetProjectFramework(path);
if (frameworkResponse.IsSuccessful && frameworkResponse.Payload !.IsDefined)
{
var resolvedProject = new Project(path, frameworkResponse.Payload);
var verifier = GetSeedBucketVerifier(frameworkResponse.Payload);
var verifyResponse = verifier.Verify(resolvedProject);
if (!verifyResponse.IsSuccessful)
{
resolvedProject.ErrorMessage = verifyResponse.Message;
}
model.SetResolvedProject(resolvedProject);
}
}
}
}
ISeedBucketVerifier GetSeedBucketVerifier(IFramework framework)
{
var seedBucketVerifierDiReolver = context.Application.GetService <Func <FrameworkType, ISeedBucketVerifier> >();
return(seedBucketVerifierDiReolver(framework.Type));
}
});
}
public void Setup()
{
var createCustomerResponse = Task.Run(async() => await
Customer.CreateAsync("Bosko",
"Kovacevic",
"*****@*****.**",
DateTimeOffset.Parse("03/11/1983")
).ConfigureAwait(false)).Result;
_customer = createCustomerResponse.Payload;
_response = _customer.SetEmail(NewEmailAddress);
}
public void Setup()
{
var createCustomerResponse = Task.Run(async() => await
Customer.CreateAsync("Bosko",
"Kovacevic",
OriginalEmailAddress,
DateTimeOffset.Parse("03/11/1983")
).ConfigureAwait(false)).Result;
_customer = createCustomerResponse.Payload;
_response = _customer.SetEmail("SomeInvalidEmail");
}
/// <summary>
/// Processes the response.
/// </summary>
/// <param name="response">The response.</param>
public void ProcessResponse <TLocalised>(IOperationResponse response)
where TLocalised : struct, IComparable, IFormattable
{
if (!response.IsSuccess() &&
!ProcessError <CommonLocalised>(response) &&
!ProcessError <TLocalised>(response))
{
//Emitter.Publish(response.Exception.StackTrace);
//Emitter.Publish(response.Exception.Message);
Emitter.Publish(response.Message);
}
}
public bool ProcessError <TLocalised>(IOperationResponse response)
where TLocalised : struct, IComparable, IFormattable
{
if (FromSet <TLocalised> .GetNames().Any(x => Format.ComparesWith(x, response.Message)))
{
var candidate = FromSet <TLocalised> .Get(response.Message);
Emitter.Publish(candidate);
return(true);
}
return(false);
}
public void Complete(TResponse response)
{
if (IsCompleted)
{
throw new InvalidOperationException($"Failed to complete operation '{GetType()}', the operation may only be completed once");
}
foreach (var callback in _callbacks)
{
callback(response);
}
Response = response;
IsCompleted = true;
}
public void RegisterOperation(string trackId, IOperationRequest request, IOperationResponse response, DateTime date)
{
var journalFound = _journal.TryGetValue(trackId, out var journalOperations);
if (!journalFound)
{
journalOperations = new List <JournalOperation>();
}
var calculation = $"{request.GetFormatedRequest()} = {response.GetFormatedResponse()}";
var operation = new JournalOperation
{
Operation = request.GetOperationName(),
Calculation = calculation,
Date = date
};
journalOperations.Add(operation);
_journal.TryAdd(trackId, journalOperations);
}
public void HandleResponse(IOperationResponse response)
{
var promise = _activeOperations.RetrieveAndRemoveOperation(response.PromiseId);
typeof(OperationPromise <>).MakeGenericType(response.GetType()).GetMethod("Complete").Invoke(promise, new object[] { response });
}
public OperationAction(IOperationRequest <T> operationRequest, IOperationResponse <U> operationResponse, IOperationContext <V> operationContext)
{
this.operationRequest = operationRequest;
this.operationResponse = operationResponse;
this.operationContext = operationContext;
}
public StatusCodeMismatchException(IOperationResponse response, Type expectedType)
{
Response = response;
ExpectedType = expectedType;
}
protected void WhenRequestIsHandled() => Response = Handler.Handle();
public Operation(RedisSocket socket, IOperationRequest request, IOperationResponse <T> response)
{
this.socket = socket;
this.request = request;
this.response = response;
}
public void HandleResponse(IOperationResponse response)
{
var promise = _activeOperations.RetrieveAndRemoveOperation(response.PromiseId);
typeof (OperationPromise<>).MakeGenericType(response.GetType()).GetMethod("Complete").Invoke(promise, new object[] {response});
}
protected void WhenRequestIsHandled() => Response = Task.Run(async() => await Handler.ExecuteHandlerAsync(Request)).Result;
public void WriteResponse(IOperation operation, IOperationResponse response)
{
_writtenResponses.Add(response);
}
public void WriteResponse(IOperation operation, IOperationResponse response)
{
_writtenResponses.Add(response);
}
/// <summary>
/// Creates the message.
/// </summary>
/// <param name="lastState">if set to <c>true</c> [last state].</param>
/// <returns>a last operation state message</returns>
public ICarryLastOperationState CreateMessage(IOperationResponse lastState)
{
return(new OperationStateMessage {
Payload = lastState
});
}
