ECMJobRunner/ECM.JobRunner.Web/Data/DashboardService.cs

using DigitalData.Modules.Logging;
using DigitalData.Modules.Messaging.WCF;
using ECM.JobRunner.Common;

namespace ECM.JobRunner.Web.Data
{
    public class DashboardService
    {
        private readonly Common.JobRunnerReference.IEDMIServiceChannel channel;
        private Logger logger;

        private System.Timers.Timer pollingTimer = new();

        public event EventHandler<DashboardResponse> DataUpdated;

        public DashboardService(LoggingService Logging, WcfService Wcf)
        {
            logger = Logging.LogConfig.GetLogger();
            channel = Wcf.Channel;

            pollingTimer.Elapsed += PollingTimer_Elapsed;
            pollingTimer.Interval = 1000;
            pollingTimer.Start();
        }

        protected virtual void OnDataUpdated(DashboardResponse e)
        {
            EventHandler<DashboardResponse> handler = DataUpdated;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private async void PollingTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {          
            OnDataUpdated(await GetData());
        }   

        public async Task<DashboardResponse> GetData()
        {
            DateTime heartbeat = await GetHeartbeat();
            List<Common.JobRunnerReference.HistoryItem> jobHistory = await GetHistoryItems();
            List<Common.JobRunnerReference.StatusItem> jobStatus = await GetStatusItems();

            return new DashboardResponse()
            {
                heartbeat = heartbeat,
                jobHistory = jobHistory.OrderByDescending(e => e.CreatedAt).Take(10).ToList(),
                jobStatus = jobStatus.OrderByDescending(e => e.StartTime).Take(10).ToList()
            };
        } 

        private async Task<DateTime> GetHeartbeat()
        {
            return await channel.GetHeartbeatAsync();
        }

        private async Task<List<Common.JobRunnerReference.HistoryItem>> GetHistoryItems()
        {
            try
            {
                var oResponse = await channel.GetJobStatusAsync();

                if (oResponse.OK)
                {
                    return oResponse.HistoryItems.ToList();
                }
                else
                {
                    return new();
                }
            }
            catch (Exception e)
            {
                logger.Error(e);
                return new();
            }
              
        }

        private async Task<List<Common.JobRunnerReference.StatusItem>> GetStatusItems()
        {
            try
            {
                var oResponse = await channel.GetJobStatusAsync();

                if (oResponse.OK)
                {
                    return oResponse.StatusItems.ToList();
                }
                else
                {
                    return new();
                }
            }
            catch (Exception e)
            {
                logger.Error(e);
                return new();
            }

        }
    }
}