public AddReminderModel(ReminderItem reminderItem)
{
Date = reminderItem.Date;
Message = reminderItem.Message;
ContactId = reminderItem.ContactId;
Status = reminderItem.Status;
}
private async IAsyncEnumerable <ReminderItem> ReadRemindersAsync(SqlCommand command)
{
await using var reader = await command.ExecuteReaderAsync();
if (!reader.HasRows)
{
yield break;
}
var id = reader.GetOrdinal("Id");
var dateTime = reader.GetOrdinal("DateTime");
var status = reader.GetOrdinal("Status");
var message = reader.GetOrdinal("Message");
var contactId = reader.GetOrdinal("ContactId");
while (await reader.ReadAsync())
{
var reminder = new ReminderItem(
reader.GetGuid(id),
(ReminderItemStatus)reader.GetInt32(status),
reader.GetDateTimeOffset(dateTime),
reader.GetString(message),
reader.GetString(contactId)
);
yield return(reminder);
}
}
public ActionSucceededEventArgs(ReminderItem reminderItem)
{
Id = reminderItem.Id;
Date = reminderItem.Date;
Message = reminderItem.Message;
ContactId = reminderItem.ContactId;
}
public ReminderItemAddModel(ReminderItem reminderItem)
{
ContactId = reminderItem.ContactId;
Message = reminderItem.Message;
Date = reminderItem.Date;
Status = reminderItem.Status;
}
public void Update_Updates_All_Properties_Of_ReminderItem_With_Given_Id_If_It_Exists()
{
var original = new ReminderItem
{
Id = Guid.Parse("00000000-0000-0000-0000-111111111111"),
Date = DateTimeOffset.Parse("2001-01-01 01:01:01+0000"),
Message = "Awaiting",
ContactId = "1",
Status = ReminderItemStatus.Awaiting
};
var updated = new ReminderItem
{
Id = Guid.Parse("00000000-0000-0000-0000-111111111111"),
Date = DateTimeOffset.Parse("2002-02-02 02:02:02+0000"),
Message = "ReadyToSend",
ContactId = "2",
Status = ReminderItemStatus.ReadyToSend
};
var storage = new InMemoryReminderStorage();
storage.Add(original);
storage.Update(updated);
var actual = storage.Get(Guid.Parse("00000000-0000-0000-0000-111111111111"));
Assert.IsNotNull(actual);
Assert.AreEqual(updated.Id, actual.Id);
Assert.AreEqual(updated.Date, actual.Date);
Assert.AreEqual(updated.Message, actual.Message);
Assert.AreEqual(updated.ContactId, actual.ContactId);
Assert.AreEqual(updated.Status, actual.Status);
}
public void Method_Get_By_Status_Should_Return_List_Of_Items_If_They_Exists()
{
// prepare test data
var expectedItem1 = new ReminderItem(DateTimeOffset.Now, "message 1", "ABCD123");
var expectedItem2 = new ReminderItem(DateTimeOffset.Now, "message 2", "ABCD123");
var expectedItem3 = new ReminderItem(DateTimeOffset.Now, "message 3", "ABCD123");
var expectedItem4 = new ReminderItem(DateTimeOffset.Now, "message 4", "ABCD123");
var storage = new InMemoryReminderStorage();
expectedItem2.Status = ReminderItemStatus.Ready;
expectedItem3.Status = ReminderItemStatus.Ready;
expectedItem4.Status = ReminderItemStatus.Failed;
storage.Reminders.Add(expectedItem1.Id, expectedItem1);
storage.Reminders.Add(expectedItem2.Id, expectedItem2);
storage.Reminders.Add(expectedItem3.Id, expectedItem3);
storage.Reminders.Add(expectedItem4.Id, expectedItem4);
// do test
var actualItemList = storage.Get(ReminderItemStatus.Ready);
// check results
Assert.IsNotNull(actualItemList);
Assert.AreEqual(2, actualItemList.Count);
Assert.IsTrue(actualItemList.Contains(expectedItem2));
Assert.IsTrue(actualItemList.Contains(expectedItem3));
}
public ReminderItem Get(Guid id)
{
using (var sqlConnection = GetOpenedSqlConnection())
{
var reminder = new ReminderItem();
var sqlCommand = sqlConnection.CreateCommand();
sqlCommand.CommandType = System.Data.CommandType.Text;
sqlCommand.CommandText = $"SELECT * FROM dbo.ReminderItems WHERE Id = '{id}'";
using (var sqlDataReader = sqlCommand.ExecuteReader())
{
if (sqlDataReader.Read())
{
var guid = sqlDataReader.GetGuid(0);
var date = sqlDataReader.GetDateTimeOffset(1);
var contactId = sqlDataReader.GetString(2);
var message = sqlDataReader.GetString(3);
var status = sqlDataReader.GetByte(4);
reminder.Id = guid;
reminder.Date = date;
reminder.ContactId = contactId;
reminder.Message = message;
reminder.Status = (ReminderItemStatus)status;
}
return(reminder);
}
}
}
private void ReceiverOnMessageReceived(
object sender, MessageReceivedEventArgs e)
{
var o = MessageParser.Parse(e.Message);
if (o == null)
{
ParsingFailed?.Invoke(
this,
new ParsingFailedEventArgs(e.ContactId, e.Message));
return;
}
var item = new ReminderItem(o.Date, o.Message, e.ContactId, ReminderItemStatus.Awaiting);
try
{
_storage.Add(item);
AddingSucceeded?.Invoke(
this,
new AddingSucceededEventArgs(new AddReminderModel(item)));
}
catch (Exception exception)
{
AddingFailed?.Invoke(
this,
new AddingFailedEventArgs(new AddReminderModel(item), exception));
}
}
public void Awaiting_Item_Changes_Status_To_ReadyToSend_After_Checking_Period()
{
//preparing
var storage = new InMemoryReminderStorage();
var sender = new TelegramReminderSender("1467408776:AAGSGszyTCYYCTWTKu4PL_it029uC8X8hbs");
var receiver = new TelegramReminderReceiver("1467408776:AAGSGszyTCYYCTWTKu4PL_it029uC8X8hbs");
using var domain = new ReminderDomain(storage, receiver, sender, TimeSpan.FromMilliseconds(50), TimeSpan.FromMilliseconds(50));
var item = new ReminderItem(DateTimeOffset.Now, "Hello World!", "TestContact"); //addReminderModel
//domain.AddReminder(item); //Model was here
// run
domain.Run();
//Check the result
System.Threading.Thread.Sleep(50);
var actualItem = storage.Get(item.Id);
Assert.IsNotNull(actualItem);
Assert.AreEqual(ReminderItemStatus.ReadyToSend, actualItem.Status);
}
public void Method_Get_should_return_list_of_reminders_by_status()
{
var storage = new InMemoryReminderStorage();
ReminderItem item = new ReminderItem(
DateTimeOffset.Parse("2019-01-01T00:00:00+00:00"),
"test message",
"ABCD123"
)
{
Status = ReminderItemStatus.Ready
};
storage.Add(item);
ReminderItem item2 = new ReminderItem(
DateTimeOffset.Parse("2019-01-02T00:00:00+00:00"),
"test message2",
"ABCD456"
)
{
Status = ReminderItemStatus.Ready
};
storage.Add(item2);
ReminderItem item3 = new ReminderItem(
DateTimeOffset.Parse("2019-01-02T00:00:00+00:00"),
"test message2",
"ABCD456"
)
{
Status = ReminderItemStatus.Failed
};
storage.Add(item3);
//do
List <ReminderItem> resReady = storage.Get(ReminderItemStatus.Ready);
List <ReminderItem> resFailed = storage.Get(ReminderItemStatus.Failed);
List <ReminderItem> resAwating = storage.Get(ReminderItemStatus.Awating);
List <ReminderItem> resSent = storage.Get(ReminderItemStatus.Sent);
//
foreach (ReminderItem ri in resReady)
{
Assert.AreEqual(ri.Status, ReminderItemStatus.Ready);
}
foreach (ReminderItem ri in resFailed)
{
Assert.AreEqual(ri.Status, ReminderItemStatus.Failed);
}
Assert.AreEqual(resReady.Count, 2);
Assert.AreEqual(resFailed.Count, 1);
Assert.AreEqual(resAwating.Count, 0);
Assert.AreEqual(resSent.Count, 0);
}
public ReminderItem Get(Guid id)
{
using (var sqlConnection = GetOpenedSqlConnection())
{
var cmd = sqlConnection.CreateCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "dbo.GetReminderItemById";
cmd.Parameters.AddWithValue("@reminderId", id);
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (!reader.HasRows || !reader.Read())
{
return(null);
}
int idColumnIndex = reader.GetOrdinal("Id");
int contactIdColumnIndex = reader.GetOrdinal("ContactId");
int dateColumntIndex = reader.GetOrdinal("TargetDate");
int messageColumntIndex = reader.GetOrdinal("Message");
int statusIdColumntIndex = reader.GetOrdinal("StatusId");
var result = new ReminderItem();
result.Id = reader.GetGuid(idColumnIndex);
result.ContactId = reader.GetString(contactIdColumnIndex);
result.Date = reader.GetDateTimeOffset(dateColumntIndex);
result.Message = reader.GetString(messageColumntIndex);
result.Status = (ReminderItemStatus)reader.GetByte(statusIdColumntIndex);
return(result);
}
}
}
public void UpdateReminderItem(ReminderItem reminderItem)
{
reminderItem.AccountId = AccountId;
reminderItem.Date = Date;
reminderItem.Message = Message;
reminderItem.Status = Status;
}
public ReminderItemUpdateModel(ReminderItem reminderItem)
{
AccountId = reminderItem.AccountId;
Date = reminderItem.Date;
Message = reminderItem.Message;
Status = reminderItem.Status;
}
private async Task OnReminderFailedAsync(ReminderItem reminder)
{
reminder.MarkFailed();
await _storage.UpdateAsync(reminder);
ReminderFailed?.Invoke(this, new ReminderEventArgs(reminder));
}
public IActionResult Create([FromBody] CreateReminderItemViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = new ReminderItem(
model.Id ?? Guid.NewGuid(),
model.Title,
model.Message,
model.DateTimeUtc.GetValueOrDefault(),
new User(
model.UserLogin,
model.UserChatId),
model.Status ?? ReminderItemStatus.Created
);
try
{
_storage.Add(item);
return(Ok(new ReminderItemViewModel(item)));
}
catch (ArgumentException)
{
return(Conflict());
}
}
private List <ReminderItem> ExecuteReader(SqlCommand command)
{
using var reader = command.ExecuteReader();
var items = new List <ReminderItem>();
var id = reader.GetOrdinal("Id");
var contact = reader.GetOrdinal("Login");
var message = reader.GetOrdinal("Message");
var datetime = reader.GetOrdinal("DatetimeUtc");
var status = reader.GetOrdinal("StatusId");
while (reader.Read())
{
var item = new ReminderItem(
reader.GetGuid(id),
reader.GetString(contact),
reader.GetString(message),
reader.GetDateTimeOffset(datetime),
(ReminderItemStatus)reader.GetByte(status)
);
items.Add(item);
}
return(items);
}
public IActionResult Update(Guid id, [FromBody] UpdateReminderItemViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var target = _storage.Find(id);
var item = new ReminderItem(
target.Id,
model.Title,
model.Message,
model.DateTimeUtc.GetValueOrDefault(),
target.User,
model.Status);
_storage.Update(item);
return(Ok(new ReminderItemViewModel(item)));
}
catch (ArgumentNullException)
{
return(BadRequest());
}
catch (ArgumentException)
{
return(NotFound());
}
}
private void Receiver_MessageReceived(object sender, Receiver.Core.MessageReceivedEventArgs e)
{
MessageReceivedInvoke(e.ContactId, e.Message);
ParsedMessage parsedMessage;
try
{
parsedMessage = MessageParser.Parse(e.Message);
MessageParsingSucceddedInvoke(e.ContactId, parsedMessage.Date, parsedMessage.Message);
}
catch (Exception ex)
{
MessageParsingFailedInvoke(e.ContactId, e.Message, ex);
return;
}
var item = new ReminderItem(
parsedMessage.Date,
parsedMessage.Message,
e.ContactId);
try
{
_storage.Add(item);
AddingToStorageSucceddedInvoke(item);
}
catch (Exception ex)
{
AddingToStorageFailedInvoke(item, ex);
}
}
private void ReminderReceiver_MessageReceived(
object sender,
MessageReceivedEventArgs e)
{
var parsedMessage = MessageParser.Parse(e.Message);
if (parsedMessage != null)
{
var reminder = new ReminderItem
{
ContactId = e.ContactId,
Message = parsedMessage.Message,
Date = parsedMessage.Date,
Status = ReminderItemStatus.Awaiting
};
_storage.Add(reminder);
AddingSuccedded?.Invoke(
this,
new AddingSuccededEventArgs(
new AddReminderModel(
reminder.ContactId,
reminder.Message,
reminder.Date)));
}
}
public void Add(ReminderItem reminderItem)
{
if (!_storage.ContainsValue(reminderItem))
_storage.Add(reminderItem.Id, reminderItem);
else
throw new Exception("already exists");
}
public void When_Send_OK_SendingSucceeded_Event_Raised()
{
var item = new ReminderItem {
Date = DateTimeOffset.Now
};
var storage = new InMemoryReminderStorage();
storage.Add(item);
var senderMock = new Mock <IReminderSender>();
var receiverMock = new Mock <IReminderReceiver>();
using var domain = new ReminderDomain(
storage,
senderMock.Object /* IReminderSender */,
receiverMock.Object /* IReminderReceiver */,
TimeSpan.FromMilliseconds(50),
TimeSpan.FromMilliseconds(50));
bool eventHandlerCalled = false;
domain.SendingSucceeded += (s, e) =>
{
eventHandlerCalled = true;
};
domain.Run();
Thread.Sleep(150);
Assert.IsTrue(eventHandlerCalled);
}
public void Update(ReminderItem reminderItem)
{
if (_storage.ContainsValue(reminderItem) && reminderItem.ItemStatus == ReminderItemStatus.Awaiting)
_storage[reminderItem.Id] = reminderItem;
else
throw new Exception("too late or doesnt exist");
}
public void CalculateNextReminderDate_Should_Return_Null_For_Active_Not_Null_DateGoal_Less_Or_Equal_compareWithDate(
string stringDateGoal, string stringCompareWithDate)
{
// prepare test data
DateTimeOffset.TryParseExact(stringDateGoal,
"dd.MM.yyyy HH:mm:ss.fff zzz",
CultureInfo.InvariantCulture.DateTimeFormat,
DateTimeStyles.None,
out DateTimeOffset dateGoal);
DateTimeOffset.TryParseExact(stringCompareWithDate,
"dd.MM.yyyy HH:mm:ss.fff zzz",
CultureInfo.InvariantCulture.DateTimeFormat,
DateTimeStyles.None,
out DateTimeOffset compareWithDate);
// do the test
DateTimeOffset?actual = ReminderItem.CalculateNextReminderDate(true,
FrequencyTypes.None,
null,
dateGoal,
compareWithDate);
// check the results
Assert.Null(actual);
}
public void AddMethodToStorage()
{
//prepare data
DateTimeOffset date = DateTimeOffset.Parse(
"2019-01-01T00:00:00");
const string contactId = "123qw";
const string message = "Позвони маме";
ReminderItem ri = new ReminderItem
(
date,
message,
contactId
);
InMemoryReminderStorage Storage = new InMemoryReminderStorage();
//do test
Storage.Add(ri);
//check result
//в хранилище есть нужная запись
Assert.IsTrue(Storage.Reminders.ContainsKey(ri.Id));
Assert.AreEqual(contactId, Storage.Reminders[ri.Id].ContactId);
Assert.AreEqual(date, Storage.Reminders[ri.Id].Date);
Assert.AreEqual(message, Storage.Reminders[ri.Id].Message);
Assert.AreEqual(ReminderItemStatus.Awating, Storage.Reminders[ri.Id].Status);
}
public void Get_Returns_Just_Added_Item()
{
Guid guid = Guid.NewGuid();
DateTimeOffset date = DateTimeOffset.Now;
string message = "TEST MESSAGE";
string contactId = "TEST ID 123";
ReminderItemStatus status = ReminderItemStatus.Failed;
var expected = new ReminderItem(guid, date, message, contactId, status);
var storage = new InMemoryReminderStorage();
// test action
storage.Add(expected);
var actual = storage.Get(guid);
// check results
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Date, actual.Date);
Assert.AreEqual(expected.ContactId, actual.ContactId);
Assert.AreEqual(expected.Message, actual.Message);
Assert.AreEqual(expected.Status, actual.Status);
}
public void GetMethodFromStorage()
{
//prepare data
DateTimeOffset date = DateTimeOffset.Parse("2019-01-01T00:00:00");
const string contactId = "1f23qw";
const string message = "Позвони папе";
ReminderItem ri = new ReminderItem
(
date,
message,
contactId
);
InMemoryReminderStorage Storage = new InMemoryReminderStorage();
Storage.Reminders.Add(ri.Id, ri);
//do test
ReminderItem item = Storage.Get(ri.Id);
ReminderItem item2 = Storage.Get(Guid.Empty);
//check result
//null если нет такого guid в хранилище
Assert.IsNull(item2);
//в хранилище то что надо
Assert.AreEqual(date, item.Date);
Assert.AreEqual(contactId, item.ContactId);
Assert.AreEqual(message, item.Message);
}
public ReminderItemCreateModel(ReminderItem reminderItem)
{
Date = reminderItem.Date;
ContactId = reminderItem.ContactId;
Message = reminderItem.Message;
Status = reminderItem.Status;
}
private void OnReceiverMessageReceived(object sender, MessageReceivedEventArgs e)
{
ReminderItem reminderItem = null;
try
{
MessageParser.Parse(
e.Message,
out DateTimeOffset date,
out string replyMessage);
reminderItem = new ReminderItem(
date,
replyMessage,
e.ContactId,
ReminderItemStatus.Awaiting);
}
catch (Exception exception)
{
_sender.Send(e.ContactId, "Invalid input string format, try again!");
}
if (reminderItem == null)
{
return;
}
try
{
_storage.Add(reminderItem);
OnAddingSucceeded(this, new AddingSucceededEventArgs(reminderItem));
}
catch (Exception exception)
{
OnAddingFailed(this, new AddingFailedEventArgs(reminderItem, exception));
}
}
public ReminderItem Get(Guid id)
{
using (var connection = GetOpenedSqlConnection())
{
var command = connection.CreateCommand();
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "dbo.GetReminderItemById";
command.Parameters.AddWithValue("@reminderId", id);
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows || !reader.Read())
{
return(null);
}
var result = new ReminderItem();
result.Id = id;
result.ContactId = reader.GetString(reader.GetOrdinal("ContactId"));
result.Date = reader.GetDateTimeOffset(reader.GetOrdinal("TargetDate"));
result.Message = reader.GetString(reader.GetOrdinal("Message"));
result.Status = (ReminderItemStatus)reader.GetByte(reader.GetOrdinal("StatusId"));
return(result);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Telegram Bot Application!");
var storage = new InMemoryReminderStorage();
var domain = new ReminderDomain(storage);
IWebProxy proxy = new HttpToSocks5Proxy("proxy.golyakov.net", 1080);
string token = "874002335:AAHCWlQVHGvM6if784HJ0rHTfcUg7SbSR5s";
var sender = new TelegramReminderSender(token, proxy);
var receiver = new TelegramReminderReceiver(token, proxy);
receiver.MessageReceived += (s, e) =>
{
Console.WriteLine($"Message from contact '{e.ContactId}' with text '{e.Message}'");
//add new reminderitem to the storage
var parsedMessage = MessageParser.Parse(e.Message);
var item = new ReminderItem(parsedMessage.Date, parsedMessage.Message, e.ContactId);
storage.Add(item);
};
receiver.Run();
domain.SendReminder = (ReminderItem ri) =>
{
sender.Send(ri.ContactId, ri.Message);
};
domain.Run();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
}
