private void GenerateReportAsync(OpenLogFileViewModel viewModel)
{
logFileRptGeneratorService.InitializeReport();
viewModel.OverallProgress = 0;
viewModel.IsGeneratingReport = true;
//var sourceQueue = Source.Queue<LogRptDto>(int.MaxValue, OverflowStrategy.Fail)
// .SelectAsyncUnordered(int.MaxValue, l => logFileRptGeneratorService.GetCheckInforInUseOuts(l, viewModel.LogFiles))
// .To(Sink.ActorRef<Tuple<bool, LogRptDto>>(logFilesExcelProviderActor, logFileRptGeneratorService.GetReportRows()))
// .Run(Context.Materializer());
var g = RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var source = Source.From(viewModel.LogFiles);
var sink = Sink.ActorRef <Tuple <bool, LogRptDto> >(logFilesExcelProviderActor, logFileRptGeneratorService.GetReportRows());
var parsing = Flow.Create <LogFile>()
.Select(x =>
{
viewModel.OverallProgress++;
var parseTask = logFilesParsingService.ParseLogFileEventsAsync(x);
parseTask.ContinueWith(t => denialsRptGeneratorService.Aggregate(t.Result));
return(parseTask.Result);
}).WatchTermination((_, o) => { o.ContinueWith(t => getCheckInsActor.Tell(viewModel)); return(_); });
//.WatchTermination((_,u)=>u.PipeTo(getCheckInsActor));
//TODO: create new actor to run getCheckIns ===^
//Akka.Done
//Akka.Actor.Status.Failure;
var reportGen = Flow.Create <LogFile>()
.SelectAsyncUnordered(int.MaxValue, logFileRptGeneratorService.GenerateReport)
.Recover(exception =>
{
throw exception;
})
.SelectMany(x => x);
//var getCheckIns = Flow.Create<LogRptDto>()
// .SelectAsyncUnordered(int.MaxValue, x => getCheckInsActor.Tell(x))
//var getCheckIns = Flow.Create<LogRptDto>()
// .SelectAsyncUnordered(int.MaxValue, l => logFileRptGeneratorService.GetCheckInforInUseOuts(l, viewModel.LogFiles));
b.From(source).Via(parsing).Via(reportGen).To(Sink.ForEach <LogRptDto>(l => getCheckInsActor.Tell(l)));//.Via(getCheckIns).To(sink);
return(ClosedShape.Instance);
}));
g.Run(Context.Materializer());
}
public OpenLogFileCoordinatorActor(OpenLogFileViewModel viewModel)
{
ProgressTellerActor = Context.ActorOf(Props.Create(() => new ProgressTellerActor(viewModel)),
ActorPaths.ProgressTellerActor.Name);
LogFileReportGeneratorActor = Context.ActorOf(Context.DI().Props <LogFileReportGeneratorActor>(),
ActorPaths.LogFileReportGeneratorActor.Name);
Receive <string>(message => {
if (message == "start")
{
LogFileReportGeneratorActor.Tell(viewModel);
}
else if (message == "done")
{
viewModel.IsGeneratingReport = false;
}
});
}
public GetCheckInsActor(ILogFileRptGeneratorService logFileRptGeneratorService)
{
logFilesExcelProviderActor = Context.ActorOf(Context.DI().Props <LogFilesExcelProviderActor>(),
ActorPaths.logFilesExcelProviderActor.Name);
var sourceQueue = Source.Queue <LogRptDto>(0, OverflowStrategy.Backpressure)
.Recover(ex => throw ex)
.SelectAsyncUnordered(int.MaxValue, l => logFileRptGeneratorService.GetCheckInforInUseOuts(l, vm.LogFiles))
.ToMaterialized(Sink.ActorRef <Tuple <bool, LogRptDto> >(logFilesExcelProviderActor, logFileRptGeneratorService.GetReportRows()), Keep.Left)
.Run(Context.Materializer());
Receive <OpenLogFileViewModel>(vmodel =>
{
vm = vmodel;
Stash.UnstashAll();
BecomeStacked(() =>
{
Receive <LogRptDto>(l => sourceQueue.OfferAsync(l));
});
});
ReceiveAny(_ => Stash.Stash());
this.logFileRptGeneratorService = logFileRptGeneratorService;
}
public ProgressTellerActor(OpenLogFileViewModel viewModel)
{
Receive <bool>(isGeneratingRpt => viewModel.IsGeneratingReport = true);
Receive <int>(OverallProgress => viewModel.OverallProgress = OverallProgress);
}
