Find Next Recurring Date Based on a Schedule

Question

Let's say I need to find out when the next scheduled date is when I know that the schedule was based off a start date of 8/1/2014, it's supposed to run every 7 days and the current date is 8/10/2014. I should get back a date of 8/14/2014. I eventually want to make this code work for every X hours, days, and weeks, bur right now I'm just testing with days. I have the following code I'm using to calculate the next run time, but I get it to work for one date and then it fails for another. FYI, I'm using the option to specify the current date for testing purposes. What am I doing wrong?

public class ScheduleComputer
{
    public DateTime GetNextRunTime(ScheduleRequest request)
    {
        var daysSinceBase = ((int)((request.CurrentDate - request.BaseDate).TotalDays)) + 1;
        var partialIntervalsSinceBaseDate = daysSinceBase % request.Interval;
        var fullIntervalsSinceBaseDate = daysSinceBase / request.Interval;
        var daysToNextRun = 0;
        if (partialIntervalsSinceBaseDate > 0)
        {
            daysToNextRun = (request.Interval - partialIntervalsSinceBaseDate) + 1;
        }
        var nextRunDate = request.BaseDate.AddDays((fullIntervalsSinceBaseDate * request.Interval) + daysToNextRun - 1);
        return nextRunDate;
    }
}

public class ScheduleRequest
{
    private readonly DateTime _currentDate;

    public ScheduleRequest()
    {
        _currentDate = DateTime.Now;
    }

    public ScheduleRequest(DateTime currentDate)
    {
        _currentDate = currentDate;
    }

    public DateTime CurrentDate
    {
        get { return _currentDate; }
    }

    public DateTime BaseDate { get; set; }
    public Schedule Schedule { get; set; }
    public int Interval { get; set; }
}

public enum Schedule
{
    Hourly,
    Daily,
    Weekly
}

And here are my unit tests

[TestFixture]
public class ScheduleComputerTests
{
    private ScheduleComputer _scheduleComputer;

    [SetUp]
    public void SetUp()
    {
        _scheduleComputer = new ScheduleComputer();
    }

    [Test]
    public void ThisTestPassesAndItShould()
    {
        var scheduleRequest = new ScheduleRequest(currentDate: DateTime.Parse("8/14/2014"))
        {
            BaseDate = DateTime.Parse("8/1/2014"),
            Schedule = Schedule.Daily,
            Interval = 7
        };
        var result = _scheduleComputer.GetNextRunTime(scheduleRequest);
        Assert.AreEqual(DateTime.Parse("8/14/2014"), result);
    }

    [Test]
    public void ThisTestFailsAndItShouldNot()
    {
        var scheduleRequest = new ScheduleRequest(currentDate: DateTime.Parse("8/2/2014"))
        {
            BaseDate = DateTime.Parse("8/1/2014"),
            Schedule = Schedule.Daily,
            Interval = 7
        };
        var result = _scheduleComputer.GetNextRunTime(scheduleRequest);
        Assert.AreEqual(DateTime.Parse("8/7/2014"), result);
    }

FYI, I saw the post here, but I can't seem to tailor it to my needs.

--- UPDATE 1 ---

Here is my updated code. I know I've made it verbose with variables so I can understand the logic better (hopefully that doesn't impact performance much). I also added logic to deal with different periods (hours, days, weeks) and added extension methods to make the code somewhat cleaner. However, this code seems to be working perfectly for hours and days, but is failing on weeks. Somewhere I'm not multiplying or dividing by 7 properly.

public class ScheduleComputer
{
    public DateTime GetNextRunTime(ScheduleRequest request)
    {
        var timeBetwenCurrentAndBase = request.CurrentDate - request.BaseDate;
        var totalPeriodsBetwenCurrentAndBase = timeBetwenCurrentAndBase.TotalPeriods(request.Schedule);
        var fractionalIntervals = totalPeriodsBetwenCurrentAndBase % request.Interval;
        var partialIntervalsLeft = request.Interval - fractionalIntervals;
        if (request.Schedule != Schedule.Hourly) partialIntervalsLeft = partialIntervalsLeft - 1;
        var nextRunTime = request.CurrentDate.AddPeriods(partialIntervalsLeft, request.Schedule);
        return nextRunTime;
    }
}

public static class ScheduleComputerExtensions
{
    public static double TotalPeriods(this TimeSpan timeBetwenCurrentAndBase, Schedule schedule)
    {
        switch (schedule)
        {
            case Schedule.Hourly: return timeBetwenCurrentAndBase.TotalHours;
            case Schedule.Daily: return timeBetwenCurrentAndBase.TotalDays;
            case Schedule.Weekly: return timeBetwenCurrentAndBase.TotalDays * 7;
            default: throw new ApplicationException("Invalid Schedule Provided");
        }
    }

    public static DateTime AddPeriods(this DateTime dateTime, double partialIntervalsLeft, Schedule schedule)
    {
        switch (schedule)
        {
            case Schedule.Hourly: return dateTime.AddHours(partialIntervalsLeft);
            case Schedule.Daily: return dateTime.AddDays(partialIntervalsLeft);
            case Schedule.Weekly: return dateTime.AddDays(partialIntervalsLeft * 7);
            default: throw new ApplicationException("Invalid Schedule Provided");
        }
    }
}

Answer 1

Try replacing your GetNextRunTime with this

public DateTime GetNextRunTime(ScheduleRequest request)
{
    double days = (request.Interval - ((request.CurrentDate - request.BaseDate).TotalDays % request.Interval));
    return request.CurrentDate.AddDays(days-1);
}

That should give you the correct dates.

EDIT: Let's break it down in hopes of helping you figure out the logic.

diff = (request.CurrentDate - request.BaseDate).TotalDays this gives you the number of days between the BaseDate and CurrentDate. Note that the number of days DOES NOT INCLUDE the day for BaseDate. So the different between 8/7/14 and 8/1/14 is 6 days.

daysSinceLast = diff % request.Interval this gives you the number of days that have past since the last interval hit, so if the last interval hit on 8/1/14 and it is now 8/7/14 then the result would be 6 % 7 = 6; 6 days have past since the last scheduled interval (not including the last interval date). This is the most important part of the calculation; It keeps the number of days, no matter how many have passed within the interval, so for example, if 100 days have passed since the BaseDate and the interval is 7: 100 % 7 = 2 which means that 2 days have passed since the last interval triggered, there is no need to actually know the last date it was triggered. All you need is the BaseDate and CurrentDate. You could use this logic to find the date of the last triggered interval, just subtract the number of days from the CurrentDate.

daysUntil = request.Interval - daysSinceLast This gives you the number of days until the next scheduled interval. 7 - 6 = 1 day until the next scheduled interval

1 day in this scenario is not correct and the result will never be correct because the calculation of TimeSpan differences does not include the day for BaseDate, so you need to subtract 1 from the daysUntil nextDate = request.CurrentDate.AddDays(daysUntil - 1)

Adding the number of remaining days (minus 1 for the base date) to the current date gives you the required value. Does this help at all?

UPDATE In light of your testing, I see that the problem is on both of our ends. My calculation was incorrect and you were multiplying by 7 when you needed to divide by 7. Either way, the result was still wrong. Try this instead.

• Remove your extension class completely
• Modify your GetNextRunTime with the below code
• Modify your ScheduleRequest and Schedule class/enum with the below code

GetNextRunTime

public DateTime GetNextRunTime(ScheduleRequest request)
{
    double diffMillis = (request.CurrentDate - request.BaseDate).TotalMilliseconds;
    double modMillis = (diffMillis % request.IntervalMillis);
    double timeLeft = (request.IntervalMillis - modMillis);

    ulong adjust = (request.Schedule == Schedule.Daily) ? (ulong)Schedule.Daily : 0;

    return request.CurrentDate.AddMilliseconds(timeLeft - adjust);
}

ScheduleRequest

public class ScheduleRequest
{
    private readonly DateTime _currentDate;

    public ScheduleRequest()
    {
        _currentDate = DateTime.Now;
    }

    public ScheduleRequest(DateTime currentDate)
    {
        _currentDate = currentDate;
    }

    public DateTime CurrentDate
    {
        get { return _currentDate; }
    }

    public DateTime BaseDate { get; set; }

    public Schedule Schedule { get; set; }

    public double IntervalMillis { get { return (double)this.Schedule * this.Interval; } }

    public int Interval { get; set; }
}

Schedule

public enum Schedule : ulong
{
    Hourly = 3600000,
    Daily = 86400000,
    Weekly = 604800000
}

This should work correctly for all dates, intervals and schedules. EDIT: corrected adjust value