public static async Task <Query_Summary_Projection_Return> GetQueryStatusInformationProjectionActivity(
            [ActivityTrigger] DurableActivityContext context,
            ILogger log
            )
        {
            Query_Summary_Projection_Request queryInfo = context.GetInput <Query_Summary_Projection_Request>();

            #region Logging
            if (null != log)
            {
                log.LogInformation($"GetQueryStatusInformationProjectionActivity called for query : {queryInfo.QueryName } - ID: {queryInfo.UniqueIdentifier }");
            }
            #endregion

            return(await ProcessQueryStatusInformationProjection(queryInfo.QueryName,
                                                                 queryInfo.UniqueIdentifier,
                                                                 log));
        }
Beispiel #2
0
        public static async Task <List <Query_Summary_Projection_Return> > GetAllQueryStatusByNameOrchestrator(
            [OrchestrationTrigger] DurableOrchestrationContext context,
            Microsoft.Extensions.Logging.ILogger log)
        {
            string   queryName = string.Empty;
            DateTime?asOfDate  = null;

            GetAllQueryStatusByNameRun_Request payload = context.GetInput <GetAllQueryStatusByNameRun_Request>();

            if (null != payload)
            {
                queryName = payload.QueryName;
                asOfDate  = payload.AsOfDate;
            }

            List <Query_Summary_Projection_Return> ret = new List <Query_Summary_Projection_Return>();

            // get every query id of the given name...

            #region Logging
            if (null != log)
            {
                log.LogInformation($"Creating identifier group processor for {queryName }");
            }
            #endregion
            context.SetCustomStatus($"Creating identifier group processor for {queryName }");

            AllQueriesIdentifierGroup_Request groupRequest = new AllQueriesIdentifierGroup_Request()
            {
                QueryName = queryName,
                AsOfDate  = asOfDate
            };

            IEnumerable <string> allQueryIds = await context.CallActivityWithRetryAsync <IEnumerable <string> >("GetAllQueriesIdentifierGroupActivity",
                                                                                                                DomainSettings.QueryRetryOptions(),
                                                                                                                groupRequest);


            if (null != allQueryIds)
            {
                // This should be done by fan-out/fan-in
                List <Task <Query_Summary_Projection_Return> > allTasks = new List <Task <Query_Summary_Projection_Return> >();

                foreach (string queryId in allQueryIds)
                {
                    #region Logging
                    if (null != log)
                    {
                        log.LogInformation($"Queueing {queryId}");
                    }
                    #endregion
                    context.SetCustomStatus($"Queueing {queryId}");

                    // add each to the list...
                    Query_Summary_Projection_Request request = new Query_Summary_Projection_Request()
                    {
                        QueryName        = queryName,
                        UniqueIdentifier = queryId
                    };

                    allTasks.Add(context.CallActivityWithRetryAsync <Query_Summary_Projection_Return>("GetQueryStatusInformationProjectionActivity",
                                                                                                      DomainSettings.QueryRetryOptions(),
                                                                                                      request));
                }

                #region Logging
                if (null != log)
                {
                    log.LogInformation($"Running {allTasks.Count } projections in parallel");
                }
                #endregion
                context.SetCustomStatus($"Running {allTasks.Count } projections in parallel");

                await Task.WhenAll(allTasks);

                foreach (var returnValue in allTasks)
                {
                    ret.Add(returnValue.Result);
                }
            }

            #region Logging
            if (null != log)
            {
                log.LogInformation($"Completed {ret.Count } projections in parallel for {queryName}");
            }
            #endregion
            return(ret);
        }