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)); }