public void PauseMessageSetsSchedulePauseFlag_Data()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "2")
};
var data = new ScheduledSmsData
{
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
var scheduleId = Guid.NewGuid();
var pauseScheduledMessageIndefinitely = new PauseScheduledMessageIndefinitely(scheduleId);
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = data; })
.WhenReceivesMessageFrom("place")
.ExpectSendLocal <ScheduleStatusChanged>(s =>
{
return(s.Status == MessageStatus.Paused &&
s.ScheduleId == pauseScheduledMessageIndefinitely.ScheduleMessageId &&
s.RequestTimeUtc == pauseScheduledMessageIndefinitely.MessageRequestTimeUtc);
})
.When(s => s.Handle(pauseScheduledMessageIndefinitely));
Assert.IsTrue(data.SchedulingPaused);
}
public void TimeoutSendingPausedNoAction_Data()
{
var bus = MockRepository.GenerateStrictMock <IBus>();
var dataId = Guid.NewGuid();
var originalMessage = new ScheduleSmsForSendingLater {
SmsData = new SmsData("3443", "message"), SmsMetaData = new SmsMetaData {
Tags = new List <string> {
"a", "b"
}, Topic = "topic"
}
};
var data = new ScheduledSmsData {
Id = dataId, OriginalMessage = originalMessage, SchedulingPaused = true
};
var scheduleSms = new ScheduleSms {
Bus = bus, Data = data
};
var timeoutMessage = new ScheduleSmsTimeout();
scheduleSms.Timeout(timeoutMessage);
bus.VerifyAllExpectations();
}
public void Handle(ScheduleSmsForSendingLater scheduleSmsForSendingLater)
{
Data.OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater);
Data.OriginalMessage = scheduleSmsForSendingLater;
Data.ScheduleMessageId = scheduleSmsForSendingLater.ScheduleMessageId == Guid.NewGuid() ? Data.Id : scheduleSmsForSendingLater.ScheduleMessageId;
Data.RequestingCoordinatorId = scheduleSmsForSendingLater.CorrelationId;
Data.TimeoutCounter = 0;
var timeout = new DateTime(scheduleSmsForSendingLater.SendMessageAtUtc.Ticks, DateTimeKind.Utc);
RequestUtcTimeout(timeout, new ScheduleSmsTimeout {
TimeoutCounter = 0
});
Bus.SendLocal(new ScheduleCreated
{
CorrelationId = scheduleSmsForSendingLater.CorrelationId,
ScheduleId = Data.ScheduleMessageId,
ScheduleTimeUtc = scheduleSmsForSendingLater.SendMessageAtUtc,
SmsData = scheduleSmsForSendingLater.SmsData,
SmsMetaData = scheduleSmsForSendingLater.SmsMetaData
});
Bus.Publish(new SmsScheduled
{
ScheduleMessageId = Data.ScheduleMessageId,
CoordinatorId = scheduleSmsForSendingLater.CorrelationId,
SmsData = scheduleSmsForSendingLater.SmsData,
SmsMetaData = scheduleSmsForSendingLater.SmsMetaData,
ScheduleSendingTimeUtc = scheduleSmsForSendingLater.SendMessageAtUtc
});
}
public void ReschedulePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(), SendMessageAtUtc = DateTime.Now
};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
Test.Initialize();
var rescheduleMessage = new RescheduleScheduledMessageWithNewTime(scheduleMessageId, new DateTime(2040, 4, 4, 4, 4, 4, DateTimeKind.Utc));
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, span) => span == rescheduleMessage.NewScheduleTimeUtc)
.ExpectPublish <MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
Assert.IsFalse(scheduledSmsData.SchedulingPaused);
}
public void TimeoutPromptsMessageSending_Data()
{
var bus = MockRepository.GenerateMock <IBus>();
var sendOneMessageNow = new SendOneMessageNow();
bus.Expect(b => b.Send(Arg <SendOneMessageNow> .Is.NotNull))
.WhenCalled(i => sendOneMessageNow = (SendOneMessageNow)((i.Arguments[0])));
var dataId = Guid.NewGuid();
var originalMessage = new ScheduleSmsForSendingLater {
SmsData = new SmsData("3443", "message"), SmsMetaData = new SmsMetaData {
Tags = new List <string> {
"a", "b"
}, Topic = "topic"
}
};
var data = new ScheduledSmsData {
Id = dataId, OriginalMessage = originalMessage
};
var scheduleSms = new ScheduleSms {
Bus = bus, Data = data
};
var timeoutMessage = new ScheduleSmsTimeout();
scheduleSms.Timeout(timeoutMessage);
Assert.That(sendOneMessageNow.SmsData, Is.EqualTo(data.OriginalMessage.SmsData));
Assert.That(sendOneMessageNow.SmsMetaData, Is.EqualTo(data.OriginalMessage.SmsMetaData));
Assert.That(sendOneMessageNow.CorrelationId, Is.EqualTo(data.Id));
bus.VerifyAllExpectations();
}
public void ResumePausedSchedule_Data()
{
var sagaId = Guid.NewGuid();
var scheduleMessageId = Guid.NewGuid();
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData(), SendMessageAtUtc = DateTime.Now
};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
ScheduleMessageId = scheduleMessageId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = scheduleSmsForSendingLater,
OriginalMessageData = new OriginalMessageData(scheduleSmsForSendingLater)
};
Test.Initialize();
var rescheduleMessage = new ResumeScheduledMessageWithOffset(scheduleMessageId, new TimeSpan(0, 1, 0, 0));
var rescheduledTime = scheduledSmsData.OriginalMessage.SendMessageAtUtc.Add(rescheduleMessage.Offset);
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, span) => span == rescheduledTime)
.ExpectPublish <MessageRescheduled>()
.When(s => s.Handle(rescheduleMessage));
}
public void ScheduleSmsForSendingLaterButIsPaused()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()
};
var sagaId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = "one",
OriginalMessage = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData()
}
};
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.ExpectSendLocal <ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectPublish <MessageSchedulePaused>()
.ExpectSendLocal <ScheduleStatusChanged>(s => s.Status == MessageStatus.Paused)
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)))
.ExpectNotSend <SendOneMessageNow>(now => false)
.WhenSagaTimesOut();
}
public void ScheduleSmsForSendingLater()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), ScheduleMessageId = Guid.NewGuid()
};
var sagaId = Guid.NewGuid();
var messageSent = new MessageSuccessfullyDelivered {
ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2")
};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData()
}
};
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.ExpectSendLocal <ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend <SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish <ScheduledSmsSent>()
.ExpectSendLocal <ScheduleSucceeded>(s => { return(s.ConfirmationData == messageSent.ConfirmationData && s.ScheduleId == scheduleSmsForSendingLater.ScheduleMessageId); })
.When(s => s.Handle(messageSent))
.AssertSagaCompletionIs(true);
}
public void ScheduleSmsForSendingLaterButFails()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), ScheduleMessageId = Guid.NewGuid()
};
var sagaId = Guid.NewGuid();
var messageFailed = new MessageFailedSending {
SmsData = new SmsData("1", "2"), SmsFailed = new SmsFailed(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty)
};
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater {
SmsData = new SmsData("1", "msg"), SmsMetaData = new SmsMetaData()
}
};
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc)
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectSend <SendOneMessageNow>()
.WhenSagaTimesOut()
.ExpectPublish <ScheduledSmsFailed>()
.ExpectSendLocal <ScheduleFailed>()
.When(s => s.Handle(messageFailed))
.AssertSagaCompletionIs(true);
}
public OriginalMessageData(ScheduleSmsForSendingLater requestMessage)
{
RequestingCoordinatorId = requestMessage.CorrelationId;
Username = requestMessage.Username;
Number = requestMessage.SmsData.Mobile;
Message = requestMessage.SmsData.Message;
Topic = requestMessage.SmsMetaData.Topic;
Tags = requestMessage.SmsMetaData.Tags;
ConfirmationEmail = requestMessage.ConfirmationEmail;
OriginalRequestSendTime = requestMessage.SendMessageAtUtc;
}
public void OriginalMessageGetsSavedToSaga_Data()
{
var data = new ScheduledSmsData();
var originalMessage = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now
};
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = data; })
.WhenReceivesMessageFrom("address")
.ExpectPublish <SmsScheduled>(m => m.CoordinatorId == data.Id && m.ScheduleMessageId == originalMessage.ScheduleMessageId)
.When(s => s.Handle(originalMessage));
Assert.That(data.OriginalMessage, Is.EqualTo(originalMessage));
}
public void ScheduleSmsForSendingLaterButIsPausedThenResumedOutOfOrderAndSent()
{
var scheduleSmsForSendingLater = new ScheduleSmsForSendingLater {
SendMessageAtUtc = DateTime.Now.AddDays(1), SmsData = new SmsData("1", "2"), ScheduleMessageId = Guid.NewGuid()
};
var sagaId = Guid.NewGuid();
var scheduledSmsData = new ScheduledSmsData
{
Id = sagaId,
Originator = "place",
OriginalMessageId = Guid.NewGuid().ToString(),
OriginalMessage = new ScheduleSmsForSendingLater
{
SmsData = new SmsData("1", "msg"),
SmsMetaData = new SmsMetaData()
}
};
Test.Initialize();
Test.Saga <ScheduleSms>()
.WithExternalDependencies(a => { a.Data = scheduledSmsData; })
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, timeout) => timeout == scheduleSmsForSendingLater.SendMessageAtUtc && state.TimeoutCounter == 0)
.ExpectSendLocal <ScheduleCreated>()
.When(s => s.Handle(scheduleSmsForSendingLater))
.ExpectTimeoutToBeSetAt <ScheduleSmsTimeout>((state, timeout) => state.TimeoutCounter == 1)
.ExpectPublish <MessageRescheduled>()
.ExpectSendLocal <ScheduleStatusChanged>(s => s.Status == MessageStatus.Scheduled)
.When(s => s.Handle(new ResumeScheduledMessageWithOffset(Guid.Empty, new TimeSpan())
{
MessageRequestTimeUtc = DateTime.Now
}))
.When(s => s.Handle(new PauseScheduledMessageIndefinitely(Guid.Empty)
{
MessageRequestTimeUtc = DateTime.Now.AddMinutes(-10)
}))
.ExpectSend <SendOneMessageNow>()
.When(s => s.Timeout(new ScheduleSmsTimeout {
TimeoutCounter = 1
}))
.ExpectPublish <ScheduledSmsSent>()
.ExpectSendLocal <ScheduleSucceeded>()
.When(s => s.Handle(new MessageSuccessfullyDelivered {
ConfirmationData = new SmsConfirmationData("a", DateTime.Now, 3), SmsData = new SmsData("1", "2")
}))
.AssertSagaCompletionIs(true);
}
public void Handle(SendAllMessagesAtOnce message)
{
// TODO: make a timeout for this then just send the messsages directly to the sms actioner
Data.CoordinatorId = message.CoordinatorId == Guid.Empty ? Data.Id : message.CoordinatorId;
Data.OriginalScheduleStartTime = message.SendTimeUtc;
Data.EmailAddresses = message.ConfirmationEmails;
Data.UserOlsenTimeZone = message.UserOlsenTimeZone;
Data.Topic = message.MetaData.Topic;
var messageList = new List <ScheduleSmsForSendingLater>();
for (int i = 0; i < message.Messages.Count; i++)
{
var smsData = new SmsData(message.Messages[i].Mobile, message.Messages[i].Message);
var smsForSendingLater = new ScheduleSmsForSendingLater(message.SendTimeUtc, smsData, message.MetaData, Data.CoordinatorId, message.Username)
{
CorrelationId = Data.CoordinatorId
};
messageList.Add(smsForSendingLater);
}
messageList.ForEach(m => Bus.Send(m));
//Bus.Send(messageList.ToArray());
var coordinatorCreated = new CoordinatorCreated
{
CoordinatorId = Data.CoordinatorId,
ScheduledMessages = messageList.Select(m => new MessageSchedule {
Number = m.SmsData.Mobile, ScheduledTimeUtc = m.SendMessageAtUtc, ScheduleMessageId = m.ScheduleMessageId
}).ToList(),
CreationDateUtc = DateTime.UtcNow,
MetaData = message.MetaData,
ConfirmationEmailAddresses = message.ConfirmationEmails,
UserOlsenTimeZone = message.UserOlsenTimeZone,
MessageBody = message.Messages.First().Message,
MessageCount = message.Messages.Count
};
RequestUtcTimeout <CoordinatorTimeout>(message.SendTimeUtc.AddMinutes(2));
Bus.Publish(coordinatorCreated);
Bus.SendLocal(new CoordinatorCreatedEmail(coordinatorCreated));
RavenScheduleDocuments.SaveCoordinator(coordinatorCreated);
RavenScheduleDocuments.SaveSchedules(messageList, Data.CoordinatorId);
}
public void Handle(TrickleSmsOverCalculatedIntervalsBetweenSetDates message)
{
Data.CoordinatorId = message.CoordinatorId == Guid.Empty ? Data.Id : message.CoordinatorId;
Data.OriginalScheduleStartTime = message.StartTimeUtc;
Data.EmailAddresses = message.ConfirmationEmails;
Data.UserOlsenTimeZone = message.UserOlsenTimeZone;
Data.Topic = message.MetaData.Topic;
var messageTiming = TimingManager.CalculateTiming(message.StartTimeUtc, message.Duration, message.Messages.Count);
var lastScheduledMessageTime = message.StartTimeUtc.Add(message.Duration);
var messageList = new List <ScheduleSmsForSendingLater>();
for (int i = 0; i < message.Messages.Count; i++)
{
var smsData = new SmsData(message.Messages[i].Mobile, message.Messages[i].Message);
var smsForSendingLater = new ScheduleSmsForSendingLater(messageTiming[i], smsData, message.MetaData, Data.CoordinatorId, message.Username);
messageList.Add(smsForSendingLater);
}
messageList.ForEach(m => Bus.Send(m));
//Bus.Send(messageList.ToArray());
var coordinatorCreated = new CoordinatorCreated
{
CoordinatorId = Data.CoordinatorId,
ScheduledMessages = messageList.Select(m => new MessageSchedule {
Number = m.SmsData.Mobile, ScheduledTimeUtc = m.SendMessageAtUtc, ScheduleMessageId = m.ScheduleMessageId
}).ToList(),
CreationDateUtc = DateTime.UtcNow,
MetaData = message.MetaData,
ConfirmationEmailAddresses = message.ConfirmationEmails,
UserOlsenTimeZone = message.UserOlsenTimeZone,
MessageBody = message.Messages.First().Message,
MessageCount = message.Messages.Count
};
RavenScheduleDocuments.SaveCoordinator(coordinatorCreated);
RavenScheduleDocuments.SaveSchedules(messageList, Data.CoordinatorId);
RequestUtcTimeout <CoordinatorTimeout>(lastScheduledMessageTime.AddMinutes(2));
Bus.Publish(coordinatorCreated);
Bus.SendLocal(new CoordinatorCreatedEmail(coordinatorCreated));
}
// public void Handle(TrickleSmsWithDefinedTimeBetweenEachMessage message)
// {
// Data.CoordinatorId = message.CoordinatorId == Guid.Empty ? Data.Id : message.CoordinatorId;
// Data.OriginalScheduleStartTime = message.StartTimeUtc;
// Data.EmailAddresses = message.ConfirmationEmails;
// Data.UserOlsenTimeZone = message.UserOlsenTimeZone;
// Data.Topic = message.MetaData.Topic;
// var messageList = new List<ScheduleSmsForSendingLater>();
// DateTime lastScheduledMessageTime = DateTime.Now;
// for(int i = 0; i < message.Messages.Count; i++)
// {
// var extraTime = TimeSpan.FromTicks(message.TimeSpacing.Ticks*i);
// lastScheduledMessageTime = message.StartTimeUtc.Add(extraTime);
// var smsData = new SmsData(message.Messages[i].Mobile, message.Messages[i].Message);
// var smsForSendingLater = new ScheduleSmsForSendingLater(message.StartTimeUtc.Add(extraTime), smsData, message.MetaData, Data.CoordinatorId, message.Username)
// {
// CorrelationId = Data.CoordinatorId
// };
// messageList.Add(smsForSendingLater);
// }
// messageList.ForEach(m => Bus.Send(m));
// //Bus.Send(messageList.ToArray());
// var coordinatorCreated = new CoordinatorCreated
// {
// CoordinatorId = Data.CoordinatorId,
// ScheduledMessages = messageList.Select(m => new MessageSchedule { Number = m.SmsData.Mobile, ScheduledTimeUtc = m.SendMessageAtUtc, ScheduleMessageId = m.ScheduleMessageId }).ToList(),
// CreationDateUtc = DateTime.UtcNow,
// MetaData = message.MetaData,
// ConfirmationEmailAddresses = message.ConfirmationEmails,
// UserOlsenTimeZone = message.UserOlsenTimeZone,
// MessageBody = message.Messages.First().Message,
// MessageCount = message.Messages.Count
// };
// Bus.Publish(coordinatorCreated);
// Bus.SendLocal(new CoordinatorCreatedEmail(coordinatorCreated));
// RequestUtcTimeout<CoordinatorTimeout>(lastScheduledMessageTime.AddMinutes(2));
//
// RavenScheduleDocuments.SaveCoordinator(coordinatorCreated);
// RavenScheduleDocuments.SaveSchedules(messageList, Data.CoordinatorId);
// }
public void Handle(TrickleSmsAndEmailBetweenSetTimes message)
{
Data.CoordinatorId = message.CoordinatorId == Guid.Empty ? Data.Id : message.CoordinatorId;
Data.OriginalScheduleStartTime = message.StartTimeUtc;
Data.EmailAddresses = message.ConfirmationEmails;
Data.UserOlsenTimeZone = message.UserOlsenTimeZone;
Data.Topic = message.MetaData.Topic;
Data.Username = message.Username;
var smsAndEmailCoordinatorData = RavenScheduleDocuments.GetSmsAndEmailCoordinatorData(message.SmsAndEmailDataId);
if (smsAndEmailCoordinatorData == null)
{
throw new NotImplementedException("Need the data!");
}
var messageTiming = TimingManager.CalculateTiming(message.StartTimeUtc, message.Duration, smsAndEmailCoordinatorData.CustomerContacts.Count);
var lastScheduledMessageTime = DateTime.Now.AddTicks(message.Duration.Ticks);
var messageList = new List <object>();
var smsList = new List <ScheduleSmsForSendingLater>();
var emailList = new List <ScheduleEmailForSendingLater>();
for (int i = 0; i < smsAndEmailCoordinatorData.CustomerContacts.Count; i++)
{
if (smsAndEmailCoordinatorData.CustomerContacts[i].SmsCustomer())
{
var smsData = new SmsData(smsAndEmailCoordinatorData.CustomerContacts[i].MobileNumber, message.SmsMessage);
var smsForSendingLater = new ScheduleSmsForSendingLater(messageTiming[i], smsData, message.MetaData, Data.CoordinatorId, message.Username)
{
CorrelationId = Data.CoordinatorId
};
messageList.Add(smsForSendingLater);
smsList.Add(smsForSendingLater);
}
if (smsAndEmailCoordinatorData.CustomerContacts[i].EmailCustomer())
{
var emailData = new EmailData(message.EmailData, smsAndEmailCoordinatorData.CustomerContacts[i].EmailAddress);
var emailForSendingLater = new ScheduleEmailForSendingLater(messageTiming[i], emailData, message.MetaData, Data.CoordinatorId, message.Username)
{
CorrelationId = Data.CoordinatorId
};
messageList.Add(emailForSendingLater);
emailList.Add(emailForSendingLater);
}
}
messageList.ForEach(m => Bus.Send("smsscheduler", m));
var coordinatorCreated = new CoordinatorCreatedWithEmailAndSms
{
CoordinatorId = Data.CoordinatorId,
CreationDateUtc = DateTime.UtcNow,
MetaData = message.MetaData,
ConfirmationEmailAddresses = message.ConfirmationEmails,
UserOlsenTimeZone = message.UserOlsenTimeZone,
SmsMessage = message.SmsMessage,
SmsCount = smsAndEmailCoordinatorData.CustomerContacts.Count(c => c.SmsCustomer()),
EmailCount = smsAndEmailCoordinatorData.CustomerContacts.Count(c => c.EmailCustomer()),
EmailData = message.EmailData,
UserName = message.Username
};
RequestUtcTimeout <CoordinatorTimeout>(lastScheduledMessageTime.AddMinutes(2));
Bus.Publish(coordinatorCreated);
// TODO: Send email message
//Bus.SendLocal(new CoordinatorCreatedEmail(coordinatorCreated));
RavenScheduleDocuments.SaveCoordinator(coordinatorCreated);
RavenScheduleDocuments.SaveSchedules(messageList, Data.CoordinatorId);
}
public override object OnPost(Schedule request)
{
var response = new ResponseStatus {
Errors = new List <ResponseError>()
};
if (request.ScheduledTimeUtc == DateTime.MinValue)
{
response.Errors.Add(new ResponseError {
Message = "Start time must be set"
});
}
if (request.ScheduledTimeUtc < DateTime.Now.ToUniversalTime())
{
response.Errors.Add(new ResponseError {
Message = "Start time must not be in the past"
});
}
if (string.IsNullOrWhiteSpace(request.MessageBody))
{
response.Errors.Add(new ResponseError {
Message = "Sms message required"
});
}
else if (request.MessageBody.Length > 160)
{
response.Errors.Add(new ResponseError {
Message = "Sms message exceeds 160 character length"
});
}
if (request.Number == null)
{
response.Errors.Add(new ResponseError {
Message = "Number required"
});
}
if (response.Errors.Count > 0)
{
return new SmsScheduleResponse {
ResponseStatus = response
}
}
;
var scheduleMessage = new ScheduleSmsForSendingLater
{
SendMessageAtUtc = request.ScheduledTimeUtc.ToUniversalTime(),
SmsData = new SmsData(request.Number, request.MessageBody),
SmsMetaData = new SmsMetaData {
Tags = request.Tags, Topic = request.Topic
},
ScheduleMessageId = Guid.NewGuid()
};
Bus.Send(scheduleMessage);
return(new SmsScheduleResponse {
RequestId = scheduleMessage.ScheduleMessageId
});
}
}
public void Handle(ScheduleSmsForSendingLater scheduleSmsForSendingLater)
{
RequestUtcTimeout <ScheduleSmsTimeout>(scheduleSmsForSendingLater.SendMessageAt);
}
