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

using DigitalData.Modules.Logging;
using ECM.JobRunner.Common.JobRunnerReference;
using System.Threading.Channels;

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

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

        public async Task<List<Common.JobRunnerReference.JobDefinition>> GetJobs()
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp != null && resp.OK)
            {
                return resp.JobDefinitions.ToList();
            }
            else
            {
                return new();
            }
        }

        public async Task<List<Common.JobRunnerReference.JobType>> GetJobTypes()
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp != null && resp.OK)
            {
                return resp.JobTypes.ToList();
            }
            else
            {
                return new();
            }
        }

        public async Task<Common.JobRunnerReference.JobDefinition?> GetJob(int pJobId)
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp != null && resp.OK)
            {
                return resp.JobDefinitions.
                    Where(j => j.Id == pJobId).
                    FirstOrDefault();
            }
            else
            {
                return null;
            }
        }

        public async Task<bool> UpdateJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest { 
                Job = job, 
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Update 
            });

            if (resp != null && resp.OK)
            {
                return true;
            } 
            else
            {
                return false;
            }        
        }

        public async Task<bool> CreateJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest
            {
                Job = job,
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Create
            });

            if (resp != null && resp.OK)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> DeleteJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest
            {
                Job = job,
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Delete
            });

            if (resp != null && resp.OK)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public DateTime GetNextExecutionTime(string pCronExpression)
        {
            Quartz.CronExpression expression = new(pCronExpression);

            if (expression != null)
            {
                var next = expression.GetNextValidTimeAfter(DateTimeOffset.Now);

                if (next != null)
                {
                    return ((DateTimeOffset)next).DateTime;
                }
                else
                {
                    return DateTime.MinValue;
                }
            }
            else
            {
                return DateTime.MinValue;
            }
        }
    }
}