protected Lapse CreateLapse()
{
try
{
Lapse lapse = new Lapse();
lapse.Name = textboxLapse.Value;
lapse.InitialDate = Convert.ToDateTime(dateInitialDate.Value);
lapse.FinalDate = Convert.ToDateTime(dateFinalDate.Value);
if (hiddenStatusValue.Value.Equals(string.Empty))
{
buttonStyle.buttonStyleRed(buttonErrors, "Please, input the status of the lapse.");
return(null);
}
else
{
if (hiddenStatusValue.Value.Equals("true"))
{
lapse.Status = true;
}
else if
(hiddenStatusValue.Value.Equals("false"))
{
lapse.Status = false;
}
}
return(lapse);
}
catch (FormatException)
{
buttonStyle.buttonStyleWhite(buttonErrors, "Invalid data, please check it or contact with us.");
return(null);
}
}
public ScheduledTaskBuilder EveryStartingAt(Lapse interval, DateTime utcStartingAt)
{
Type = ScheduledTask.TypeEveryStartingAt;
Interval = interval;
StartingAt = utcStartingAt;
Due = utcStartingAt;
return(this);
}
public void LambdaShouldBeCalledOnlyUponSubscription()
{
var lapse = Lapse.Create(disposable => _value = 1);
Assert.That(_value, Is.EqualTo(0));
lapse.Subscribe(_ => { });
Assert.That(_value, Is.EqualTo(1));
}
public ScheduledTaskBuilder Every(Lapse interval, int repeatTimes)
{
if (repeatTimes < 0)
{
throw new ArgumentException("repeatTimes must not be negative");
}
Repeated = repeatTimes;
return(Every(interval));
}
public void InsertLapse(Lapse lapse)
{
connection = ManageDatabaseConnection("Open");
using (SqlCommand insert = new SqlCommand(@"InsertLapse", connection))
{
insert.CommandType = CommandType.StoredProcedure;
insert.Parameters.Add("@Name", SqlDbType.VarChar).Value = lapse.Name;
insert.Parameters.Add("@InitialDate", SqlDbType.Date).Value = lapse.InitialDate;
insert.Parameters.Add("@FinalDate", SqlDbType.Date).Value = lapse.FinalDate;
insert.Parameters.Add("@Status", SqlDbType.Bit).Value = lapse.Status;
insert.ExecuteNonQuery();
}
connection = ManageDatabaseConnection("Close");
}
public void ToString_should_return_the_correct_string()
{
var instant = Instant.FromUtc(2020, 01, 26, 22, 25, 00);
var fakeClock = new FakeClock(instant);
var sut = new ScheduledTaskBuilder(fakeClock);
Assert.That(sut.WithJobData("blah").Now().CreateTask().ToString(), Is.EqualTo("now"));
Assert.That(sut.WithJobData("blah").At(new DateTime(2020, 01, 24)).CreateTask().ToString(), Is.EqualTo("at|2020-01-24T00:00:00"));
Assert.That(sut.WithJobData("blah").At("2020-01-24T00:00:00").CreateTask().ToString(), Is.EqualTo("at|2020-01-24T00:00:00"));
Assert.That(sut.WithJobData("blah").Every(Lapse.Days(3)).CreateTask().ToString(), Is.EqualTo("every|3d"));
Assert.That(sut.WithJobData("blah").Every(Lapse.Seconds(10), 5).CreateTask().ToString(), Is.EqualTo("every|10ss|x5"));
Assert.That(sut.WithJobData("blah").After(Lapse.Hours(2)).CreateTask().ToString(), Is.EqualTo("after|2hh"));
Assert.That(sut.WithJobData("blah").EveryStartingAt(Lapse.Days(3), "2020-01-24T09:30:00").CreateTask().ToString(), Is.EqualTo("everyStartingAt|3d|2020-01-24T09:30:00"));
Assert.That(sut.WithJobData("blah").EveryStartingAt(Lapse.Days(3), DateTime.Parse("2020-01-24T09:30:00")).CreateTask().ToString(), Is.EqualTo("everyStartingAt|3d|2020-01-24T09:30:00"));
}
public ScheduledTask FromString(string scheduleString, object jobData)
{
if (string.IsNullOrEmpty(scheduleString))
{
throw new ArgumentNullException("scheduleString must not be null or empty");
}
var parts = scheduleString.Split(ScheduledTask.PartSeperator);
if (parts.Length == 0)
{
throw new ArgumentException("scheduleString is not a valid SimpleSchedule string, it should consist of parts separated by the pipe symbol '|'.");
}
switch (parts[0])
{
case ScheduledTask.TypeNow:
return(Now().WithJobData(jobData).CreateTask());
case ScheduledTask.TypeAt:
var runAt = DateTime.Parse(parts[1]);
return(At(runAt).WithJobData(jobData).CreateTask());
case ScheduledTask.TypeAfter:
var afterInterval = Lapse.Parse(parts[1]);
return(After(afterInterval).WithJobData(jobData).CreateTask());
case ScheduledTask.TypeEvery:
var everyInterval = Lapse.Parse(parts[1]);
var repeatTimes = 0;
if (parts.Length > 2)
{
repeatTimes = Lapse.ParseRepeatTimes(parts[2]);
}
return(Every(everyInterval, repeatTimes).WithJobData(jobData).CreateTask());
case ScheduledTask.TypeEveryStartingAt:
var everyStartingAtInterval = Lapse.Parse(parts[1]);
var startingAtPart = parts[2];
return(EveryStartingAt(everyStartingAtInterval, startingAtPart).WithJobData(jobData).CreateTask());
default:
throw new ArgumentException("scheduleString is not a valid SimpleSchedule string, it should start with 'now', 'at', 'after' or 'every'.");
}
}
public Lapse SendLapse(DataTable dataTableLapse)
{
if (dataTableLapse.Rows.Count > 0)
{
Lapse lapse = new Lapse();
lapse.Id = Convert.ToInt32(dataTableLapse.Rows[0]["Id"]);
lapse.Name = dataTableLapse.Rows[0]["Name"].ToString();
lapse.InitialDate = Convert.ToDateTime(dataTableLapse.Rows[0]["InitialDate"]);
lapse.FinalDate = Convert.ToDateTime(dataTableLapse.Rows[0]["FinalDate"]);
lapse.Status = Convert.ToBoolean(dataTableLapse.Rows[0]["Status"]);
return(lapse);
}
else
{
return(null);
}
}
protected Enrollment CreateEnrollment()
{
Lapse lapse = new Lapse();
Enrollment enrollment = new Enrollment();
lapse = lapseData.SendLapse(lapseData.DataTableLapseOn());
enrollment.UserName = Session["User-UserName"].ToString();
enrollment.Lapse = lapse;
if (lapse == null)
{
return(null);
}
else
{
return(enrollment);
}
}
protected void UpdateLapse(Lapse lapse)
{
if (lapse != null)
{
switch (lapseRules.UpdateLapse(lapse))
{
case 0:
textboxLapse.Value = "";
buttonStyle.buttonStyleBlue(buttonErrors, "Lapse updated successful.");
break;
case 1:
buttonStyle.buttonStyleWhite(buttonErrors, "Lapse name field is empty.");
break;
case 2:
buttonStyle.buttonStyleRed(buttonErrors, "An error ocurred creating the lapse, please check data or contact we us.");
break;
case 3:
buttonStyle.buttonStyleRed(buttonErrors, "Lapse initial date is not set.");
break;
case 4:
buttonStyle.buttonStyleRed(buttonErrors, "Lapse final date is not set.");
break;
case 5:
buttonStyle.buttonStyleRed(buttonErrors, "Lapse status is not set.");
break;
case 6:
buttonStyle.buttonStyleRed(buttonErrors, "Lapse initial date can't be highter than final date.");
break;
case 7:
buttonStyle.buttonStyleRed(buttonErrors, "Lapse initial date can't be less than today.");
break;
}
}
}
public int UpdateLapse(Lapse lapse)
{
try
{
if (lapse.Name.Equals(string.Empty))
{
return(1);
}
else if (lapse.InitialDate.Equals(string.Empty))
{
return(3);
}
else if (lapse.FinalDate.Equals(string.Empty))
{
return(4);
}
else if (lapse.Status.Equals(string.Empty))
{
return(5);
}
else if (lapse.InitialDate > lapse.FinalDate)
{
return(6);
}
else if (lapse.InitialDate < DateTime.Today)
{
return(7);
}
else
{
lapseData.UpdateLapse(lapse);
return(0);
}
}
catch (SqlException)
{
return(2);
}
}
public ScheduledTaskBuilder Every(Lapse interval)
{
Type = ScheduledTask.TypeEvery;
Interval = interval;
return(this);
}
public ScheduledTaskBuilder After(Lapse interval)
{
Type = ScheduledTask.TypeAfter;
Interval = interval;
return(this);
}
public ScheduledTaskBuilder EveryStartingAt(Lapse interval, string utcStartingAt)
{
var utcStartingAtDateTime = DateTime.Parse(utcStartingAt);
return(EveryStartingAt(interval, utcStartingAtDateTime));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
// Add some tasks to the repository
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData("* run task now!").Now());
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData("* run task after 10 seconds").After(Lapse.Seconds(30)));
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData("* run task at a specified DateTime").At(DateTime.UtcNow.AddSeconds(20)));
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData("* run task every 5 seconds for 3 times").Every(Lapse.Seconds(5), 3));
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData("* run task every 20 seconds starting at now + 1mm").EveryStartingAt(Lapse.Seconds(20), DateTime.UtcNow.AddMinutes(1)).CreateTask());
var payload = new SpecificTaskPayload()
{
SomethingSpecific = "Bob"
};
_taskRepository.AddScheduledTask(_taskBuilderFactory.CreateBuilder().WithJobData(payload).Now().CreateTask());
}
