public static async Task <ProjectionResultsRecord <Get_League_Summary_Definition_Return> > RunLeagueSummaryInformationProjectionActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
#region Logging
if (null != log)
{
log.LogInformation($"GetLeagueSummaryCreateQueryRequestActivity started - instance {context.InstanceId} ");
}
#endregion
ProjectionRequest projectionRequest = context.GetInput <ProjectionRequest>();
if (null != projectionRequest)
{
return(await ProcessLeagueSummaryInformationProjection(projectionRequest.ProjectionName,
projectionRequest.AggregateInstanceUniqueIdentifier,
log));
}
else
{
#region Logging
if (null != log)
{
log.LogInformation($"Unable to read projection request {context.InstanceId} ");
}
#endregion
}
return(null);
}
//protected virtual IActionResult Portfolio(Guid guid)
//{
// var baseValidation = GetBasicValidation(guid, "GetPortfolio");
// if (baseValidation.Return != null)
// return baseValidation.Return;
// List<Portfolio> portfolios;
// try
// {
// portfolios = PortfolioServices.ListPortfolio(baseValidation.Email);
// }
// catch (ArgumentException ex)
// {
// return BadRequest(new { error = ex.Message });
// }
// return Ok(portfolios.Select(p =>
// new
// {
// id = p.Id,
// risk = p.Risk,
// projectionValue = p.Projection.ProjectionValue,
// pessimisticValue = p.Projection.PessimisticProjection,
// optimisticValue = p.Projection.OptimisticProjection,
// advisor = new
// {
// id = p.AdvisorId,
// name = p.Advisor.Name,
// price = p.Advisor.Detail.Price,
// description = p.Advisor.Detail.Description,
// period = p.Advisor.Detail.Period,
// enabled = p.Advisor.Detail.Enabled
// },
// distribution = p.Projection.Distribution.Select(d => new
// {
// asset = new
// {
// id = d.Asset.Id,
// name = d.Asset.Name,
// code = d.Asset.Code
// },
// percent = d.Percent
// })
// }));
//}
//protected virtual IActionResult AdvisorUpdate(Guid guid, int advisorId, AdvisorDetailRequest advisorDetailRequest)
//{
// if (advisorDetailRequest == null)
// return BadRequest();
// var baseValidation = GetBasicValidation(guid, "AdvisorUpdate");
// if (baseValidation.Return != null)
// return baseValidation.Return;
// try
// {
// AdvisorServices.UpdateAdvisor(baseValidation.Email, advisorId, advisorDetailRequest.Description,
// advisorDetailRequest.Period, advisorDetailRequest.Price, advisorDetailRequest.Enabled);
// }
// catch (ArgumentException ex)
// {
// return BadRequest(new { error = ex.Message });
// }
// return Ok();
//}
//protected virtual IActionResult Portfolio(Guid guid, PortfolioRequest portfolioRequest)
//{
// if (portfolioRequest == null || portfolioRequest.Distribution == null || portfolioRequest.Distribution.Count == 0)
// return BadRequest();
// var baseValidation = GetBasicValidation(guid, "PostPortfolio");
// if (baseValidation.Return != null)
// return baseValidation.Return;
// Portfolio portfolio;
// try
// {
// portfolio = PortfolioServices.CreatePortfolio(baseValidation.Email, portfolioRequest.AdvisorId, portfolioRequest.Risk,
// portfolioRequest.ProjectionValue, portfolioRequest.OptimisticProjection, portfolioRequest.PessimisticProjection,
// portfolioRequest.Distribution.ToDictionary(c => c.AssetId, c => c.Percentage));
// }
// catch (ArgumentException ex)
// {
// return BadRequest(new { error = ex.Message });
// }
// return Ok(new { id = portfolio.Id });
//}
protected virtual IActionResult Projection(Guid guid, int portfolioId, ProjectionRequest projectionRequest)
{
return(new StatusCodeResult(405));
if (projectionRequest == null || projectionRequest.Distribution == null || projectionRequest.Distribution.Count == 0)
{
return(BadRequest());
}
var baseValidation = GetBasicValidation(guid, "PostProjection");
if (baseValidation.Return != null)
{
return(baseValidation.Return);
}
try
{
PortfolioServices.CreateProjection(baseValidation.Email, portfolioId, projectionRequest.ProjectionValue,
projectionRequest.Risk, projectionRequest.OptimisticProjection, projectionRequest.PessimisticProjection,
projectionRequest.Distribution.ToDictionary(c => c.AssetId, c => c.Percentage));
}
catch (ArgumentException ex)
{
return(BadRequest(new { error = ex.Message }));
}
return(Ok());
}
private static bool IsProjectionRequestValid(ProjectionRequest request)
{
if (null == request)
{
return(false);
}
else
{
if (string.IsNullOrWhiteSpace(request.DomainName))
{
// Domain name is mandatory
return(false);
}
if (string.IsNullOrWhiteSpace(request.AggregateTypeName))
{
return(false);
}
if (string.IsNullOrWhiteSpace(request.AggregateInstanceUniqueIdentifier))
{
return(false);
}
if (string.IsNullOrWhiteSpace(request.ProjectionName))
{
return(false);
}
}
return(true);
}
public static async Task <ProjectionResultsRecord <object> > RunProjectionActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
ProjectionRequest request = context.GetInput <ProjectionRequest>();
return(await RunProjection(request, log));
}
public static async Task <HttpResponseMessage> RunProjectionRun(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequestMessage req,
ILogger log)
{
#region Logging
if (null != log)
{
log.LogDebug("Function triggered HTTP in RunProjection");
}
#endregion
string parentRequestName;
string projectionName;
string domainName;
string aggregateTypeName;
string entityUniqueIdentifier;
Nullable <DateTime> asOfDate = null;
// Get the parameters from the query
parentRequestName = req.GetQueryNameValuePairsExt()[@"ParentRequestName"];
projectionName = req.GetQueryNameValuePairsExt()[@"ProjectionName"];
domainName = req.GetQueryNameValuePairsExt()[@"DomainName"];
aggregateTypeName = req.GetQueryNameValuePairsExt()[@"AggregateTypeName"];
entityUniqueIdentifier = req.GetQueryNameValuePairsExt()[@"EntityUniqueIdentifier"];
string asOfDateString = req.GetQueryNameValuePairsExt()[@"AsOfDate"];
DateTime asOfDateValue;
if (DateTime.TryParse(asOfDateString, out asOfDateValue))
{
asOfDate = asOfDateValue;
}
ProjectionRequest request = new ProjectionRequest()
{
ParentRequestName = parentRequestName,
ProjectionName = projectionName,
DomainName = domainName,
AggregateTypeName = aggregateTypeName,
AggregateInstanceUniqueIdentifier = entityUniqueIdentifier,
AsOfDate = asOfDate
};
ProjectionResultsRecord <object> response = await RunProjection(request, log);
if (null != response)
{
return(req.CreateResponse(HttpStatusCode.OK, response,
new System.Net.Http.Formatting.JsonMediaTypeFormatter()));
}
else
{
return(req.CreateResponse(HttpStatusCode.BadRequest,
$"No projection response for {request }"));
}
}
/// <inheritdoc/>
public Task <IProjectionResult> Project(ProjectionCurrentState state, CommittedEvent @event, PartitionId partitionId, string failureReason, uint retryCount, ExecutionContext executionContext, CancellationToken cancellationToken)
{
var request = new ProjectionRequest
{
RetryProcessingState = new RetryProcessingState {
FailureReason = failureReason, RetryCount = retryCount
}
};
return(Process(state, @event, partitionId, request, executionContext, cancellationToken));
}
public static async Task <ActivityResponse> LogQueryProjectionInFlightActivity(
[ActivityTrigger] DurableActivityContext context,
ILogger log)
{
// TODO: Pass this as a parameter
CQRSAzure.EventSourcing.IWriteContext writeContext = null;
ActivityResponse resp = new ActivityResponse()
{
FunctionName = "LogQueryProjectionInFlightActivity"
};
ProjectionRequest projectionRequest = context.GetInput <ProjectionRequest>();
if (null != projectionRequest)
{
await QueryLogRecord.LogProjectionStarted(
projectionRequest.CorrelationIdentifier,
projectionRequest.ParentRequestName,
projectionRequest.ProjectionName,
projectionRequest.DomainName,
projectionRequest.AggregateTypeName,
projectionRequest.AggregateInstanceUniqueIdentifier,
projectionRequest.AsOfDate,
projectionRequest.CorrelationIdentifier.ToString(),
writeContext
);
resp.Message = $"Started running projection query {projectionRequest.CorrelationIdentifier} : {projectionRequest}) ";
}
else
{
resp.Message = "Unable to get projection request from context";
resp.FatalError = true;
}
return(resp);
}
public void ProjectionRequest_RouwndTrip_Test()
{
string expected = "The long run leagues";
string actual = "Not set";
ProjectionRequest testObj = new ProjectionRequest()
{
ParentRequestName = "Get League Details",
DomainName = "Leagues",
AggregateTypeName = "League",
AggregateInstanceUniqueIdentifier = "The long run leagues",
AsOfDate = null,
ProjectionName = "League Detail Information",
CorrelationIdentifier = Guid.NewGuid()
};
actual = testObj.AggregateInstanceUniqueIdentifier;
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Run the specified projection and return the results to the caller function
/// </summary>
private static async Task <ProjectionResultsRecord <object> > RunProjection(ProjectionRequest request,
ILogger log)
{
if (null != request)
{
if (!IsProjectionRequestValid(request))
{
#region Logging
if (null != log)
{
log.LogError($"Invalid projection request {request}");
}
#endregion
return(new ProjectionResultsRecord <object>()
{
Error = true,
StatusMessage = $"Invalid projection request {request}",
DomainName = request.DomainName,
AggregateTypeName = request.AggregateTypeName,
EntityUniqueIdentifier = request.AggregateInstanceUniqueIdentifier,
CurrentAsOfDate = request.AsOfDate.GetValueOrDefault(DateTime.UtcNow),
CorrelationIdentifier = request.CorrelationIdentifier,
ParentRequestName = request.ParentRequestName,
Result = null
});
}
Projection projectionEvents = new Projection(request.DomainName,
request.AggregateTypeName,
request.AggregateInstanceUniqueIdentifier,
request.ProjectionName);
if (null != projectionEvents)
{
CQRSAzure.EventSourcing.ProjectionBaseUntyped projectionToRun = null;
// Get an instance of the projection we want to run....
projectionToRun = Projection.CreateProjectionInstance(request.ProjectionName);
if (null != projectionToRun)
{
IProjectionResponse projectionResponse = await projectionEvents.ProcessAsync(projectionToRun);
if (null != projectionResponse)
{
// make a response object
IEnumerable <object> projectionResultObjects = Projection.GetProjectionResults(projectionToRun.CurrentValues);
object results = null;
if (null != projectionResultObjects)
{
if (projectionResultObjects.Count() == 1)
{
results = projectionResultObjects.FirstOrDefault();
}
else
{
results = projectionResultObjects;
}
}
return(new ProjectionResultsRecord <object>()
{
Error = false,
StatusMessage = $"Successfully returned projection request details for {request}",
DomainName = request.DomainName,
AggregateTypeName = request.AggregateTypeName,
EntityUniqueIdentifier = request.AggregateInstanceUniqueIdentifier,
CurrentAsOfDate = projectionResponse.AsOfDate.GetValueOrDefault(DateTime.UtcNow),
CorrelationIdentifier = request.CorrelationIdentifier,
ParentRequestName = request.ParentRequestName,
Result = results
});
}
else
{
#region Logging
if (null != log)
{
log.LogWarning($"Unable to read projection request details from {request } ");
}
#endregion
return(new ProjectionResultsRecord <object>()
{
Error = true,
StatusMessage = $"Unable to read projection request details from {request }",
DomainName = request.DomainName,
AggregateTypeName = request.AggregateTypeName,
EntityUniqueIdentifier = request.AggregateInstanceUniqueIdentifier,
CurrentAsOfDate = request.AsOfDate.GetValueOrDefault(DateTime.UtcNow),
CorrelationIdentifier = request.CorrelationIdentifier,
ParentRequestName = request.ParentRequestName,
Result = null
});
}
}
else
{
#region Logging
if (null != log)
{
log.LogError($"Unable to create projection instance details {request.ProjectionName } ");
}
#endregion
return(new ProjectionResultsRecord <object>()
{
Error = true,
StatusMessage = $"Unable to create projection instance details {request.ProjectionName }",
DomainName = request.DomainName,
AggregateTypeName = request.AggregateTypeName,
EntityUniqueIdentifier = request.AggregateInstanceUniqueIdentifier,
CurrentAsOfDate = request.AsOfDate.GetValueOrDefault(DateTime.UtcNow),
CorrelationIdentifier = request.CorrelationIdentifier,
ParentRequestName = request.ParentRequestName,
Result = null
});
}
}
}
else
{
#region Logging
if (null != log)
{
log.LogWarning($"Unable to read projection request details from {request } ");
}
#endregion
}
// No results
return(new ProjectionResultsRecord <object>()
{
Error = true,
StatusMessage = $"No results found for {request}",
DomainName = request.DomainName,
AggregateTypeName = request.AggregateTypeName,
EntityUniqueIdentifier = request.AggregateInstanceUniqueIdentifier,
CurrentAsOfDate = request.AsOfDate.GetValueOrDefault(DateTime.UtcNow),
CorrelationIdentifier = request.CorrelationIdentifier,
ParentRequestName = request.ParentRequestName,
Result = null
});
}
public static async Task <ActivityResponse> QueryProjectionProcessorOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context,
Microsoft.Extensions.Logging.ILogger log)
{
ActivityResponse response = new ActivityResponse()
{
FunctionName = "QueryProjectionProcessorOrchestrator"
};
Query_Projections_Projection_Request request = context.GetInput <Query_Projections_Projection_Request>();
if (null != request)
{
Guid UniqueIdentifierGuid;
if (!Guid.TryParse(request.UniqueIdentifier, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(request.CallbackOrchestrationIdentifier, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(context.ParentInstanceId, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(context.InstanceId, out UniqueIdentifierGuid))
{
UniqueIdentifierGuid = Guid.NewGuid();
}
}
}
}
// get all the projection requests for the query
List <Query_Projections_Projection_Return> allProjections = await context.CallActivityWithRetryAsync <List <Query_Projections_Projection_Return> >("GetQueryProjectionsStatusProjectionActivity",
DomainSettings.QueryRetryOptions(),
request);
if (null != allProjections)
{
#region Logging
if (null != log)
{
log.LogInformation($"Query {request.QueryName}.{request.UniqueIdentifier} has {allProjections.Count} projections total ");
}
#endregion
// Run them - This should be done by fan-out/fan-in
List <Task <ProjectionResultsRecord <object> > > allProjectionTasks = new List <Task <ProjectionResultsRecord <object> > >();
// run all the outstanding projections in parallel
foreach (Query_Projections_Projection_Return projectionRequest in allProjections)
{
if (projectionRequest.ProjectionState == Query_Projections_Projection_Return.QueryProjectionState.Queued)
{
ProjectionRequest projRequest = new ProjectionRequest()
{
ParentRequestName = request.QueryName,
CorrelationIdentifier = UniqueIdentifierGuid,
DomainName = projectionRequest.Projection.DomainName,
AggregateTypeName = projectionRequest.Projection.AggregateTypeName,
AggregateInstanceUniqueIdentifier = projectionRequest.Projection.InstanceKey,
AsOfDate = request.AsOfDate,
ProjectionName = projectionRequest.Projection.ProjectionTypeName
};
if (null != projRequest)
{
context.SetCustomStatus(projRequest);
}
// mark it as in-flight
response = await context.CallActivityWithRetryAsync <ActivityResponse>("LogQueryProjectionInFlightActivity",
DomainSettings.QueryRetryOptions(),
projRequest);
if (null != response)
{
context.SetCustomStatus(response);
}
}
}
// Now start them running using a fan-out/fan in pattern
foreach (Query_Projections_Projection_Return projectionRequest in allProjections)
{
if (projectionRequest.ProjectionState == Query_Projections_Projection_Return.QueryProjectionState.Queued)
{
ProjectionRequest projRequest = new ProjectionRequest()
{
ParentRequestName = request.QueryName,
CorrelationIdentifier = UniqueIdentifierGuid,
DomainName = projectionRequest.Projection.DomainName,
AggregateTypeName = projectionRequest.Projection.AggregateTypeName,
AggregateInstanceUniqueIdentifier = projectionRequest.Projection.InstanceKey,
AsOfDate = request.AsOfDate,
ProjectionName = projectionRequest.Projection.ProjectionTypeName
};
// and start running it...
allProjectionTasks.Add(context.CallActivityWithRetryAsync <ProjectionResultsRecord <object> >("RunProjectionActivity",
DomainSettings.QueryRetryOptions(),
projRequest));
}
}
// Run the projections in parallel...
await Task.WhenAll(allProjectionTasks);
// and save their results to the query
foreach (var returnValue in allProjectionTasks)
{
ProjectionResultsRecord <object> result = returnValue.Result;
if (null != result)
{
if (!result.Error)
{
response = await context.CallActivityWithRetryAsync <ActivityResponse>("LogQueryProjectionResultActivity",
DomainSettings.QueryRetryOptions(),
result);
}
else
{
#region Logging
if (null != log)
{
log.LogError($"Error running projection {result.ProjectionName} - {result.StatusMessage} ");
}
#endregion
response.Message = $"Error running projection {result.ProjectionName} - {result.StatusMessage} ";
}
if (null != response)
{
context.SetCustomStatus(response);
}
}
else
{
#region Logging
if (null != log)
{
log.LogError($"Projection {returnValue.Id} did not return any values : {returnValue.Exception}");
}
#endregion
}
}
}
// when all done - trigger the calling orchestration to come out of hibernation
if (!string.IsNullOrWhiteSpace(request.CallbackOrchestrationIdentifier))
{
}
}
else
{
response.Message = $"Unable to read projection request data from context {context.InstanceId}";
response.FatalError = true;
}
return(response);
}
public static async Task <ActivityResponse> GetLeagueSummaryQueryProjectionProcessOrchestrator
([OrchestrationTrigger] DurableOrchestrationContext context,
Microsoft.Extensions.Logging.ILogger log)
{
ActivityResponse resp = new ActivityResponse()
{
FunctionName = "GetLeagueSummaryQueryProjectionProcessOrchestrator"
};
// Get the query definition form the context...
QueryRequest <Get_League_Summary_Definition> queryRequest = context.GetInput <QueryRequest <Get_League_Summary_Definition> >();
if (null != queryRequest)
{
// Get all the outstanding projection requests
Query_Projections_Projection_Request projectionQueryRequest = new Query_Projections_Projection_Request()
{
UniqueIdentifier = queryRequest.QueryUniqueIdentifier.ToString(),
QueryName = queryRequest.QueryName
};
List <Query_Projections_Projection_Return> allProjections = await context.CallActivityAsync <List <Query_Projections_Projection_Return> >("GetQueryProjectionsStatusProjectionActivity", projectionQueryRequest);
if (null != allProjections)
{
// This should be done by fan-out/fan-in
List <Task <ProjectionResultsRecord <Get_League_Summary_Definition_Return> > > allProjectionTasks = new List <Task <ProjectionResultsRecord <Get_League_Summary_Definition_Return> > >();
// run all the outstanding projections in parallel
foreach (Query_Projections_Projection_Return projectionRequest in allProjections)
{
if (projectionRequest.ProjectionState == Query_Projections_Projection_Return.QueryProjectionState.Queued)
{
ProjectionRequest projRequest = new ProjectionRequest()
{
ParentRequestName = queryRequest.QueryName,
CorrelationIdentifier = queryRequest.QueryUniqueIdentifier,
DomainName = "Leagues",
AggregateTypeName = "League",
AggregateInstanceUniqueIdentifier = projectionRequest.Projection.InstanceKey,
AsOfDate = null,
ProjectionName = projectionRequest.Projection.ProjectionTypeName
};
// mark it as in-flight
resp = await context.CallActivityAsync <ActivityResponse>("LogQueryProjectionInFlightActivity", projRequest);
if (null != resp)
{
context.SetCustomStatus(resp);
}
// and start running it...
allProjectionTasks.Add(context.CallActivityAsync <ProjectionResultsRecord <Get_League_Summary_Definition_Return> >("RunLeagueSummaryInformationProjectionActivity", projRequest));
}
}
#region Logging
if (null != log)
{
log.LogInformation($"Running {allProjectionTasks.Count } projections in parallel");
}
#endregion
// and persist their results to the query
context.SetCustomStatus($"Running {allProjectionTasks.Count } projections in parallel");
await Task.WhenAll(allProjectionTasks);
#region Logging
if (null != log)
{
log.LogInformation($"Completed running {allProjectionTasks.Count } projections in parallel");
}
#endregion
foreach (var returnValue in allProjectionTasks)
{
ProjectionResultsRecord <Get_League_Summary_Definition_Return> projectionResponse = returnValue.Result;
// add in the extra details
projectionResponse.CorrelationIdentifier = queryRequest.QueryUniqueIdentifier;
projectionResponse.ParentRequestName = queryRequest.QueryName;
// log the result...
resp = await context.CallActivityAsync <ActivityResponse>("LogQueryProjectionResultActivity", projectionResponse);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
}
}
}
return(resp);
}
async Task <IProjectionResult> Process(ProjectionCurrentState state, CommittedEvent @event, PartitionId partitionId, ProjectionRequest request, ExecutionContext executionContext, CancellationToken token)
{
request.Event = new Contracts.StreamEvent
{
Event = @event.ToProtobuf(),
PartitionId = partitionId.Value,
ScopeId = Definition.Scope.ToProtobuf(),
};
request.CurrentState = state.ToProtobuf();
var response = await _dispatcher.Call(request, executionContext, token).ConfigureAwait(false);
return(response switch
{
{ Failure : null, ResponseCase : ProjectionResponse.ResponseOneofCase.Replace } => new ProjectionReplaceResult(response.Replace.State),
public new IActionResult Projection([FromQuery] Guid guid, [FromQuery] int portfolioId, [FromBody] ProjectionRequest projectionRequest)
{
return(base.Projection(guid, portfolioId, projectionRequest));
}
// Updates an existing Projection
public Projection Put(ProjectionRequest request)
{
ProjectionDataWorker pdw = new ProjectionDataWorker(Db);
return(pdw.UpdateProjection(request.Projection));
}
// Creates a new Projection
public int Post(ProjectionRequest request)
{
ProjectionDataWorker pdw = new ProjectionDataWorker(Db);
return(pdw.AddProjection(request.Projection));
}
