public bool SaveEventTransaction(EventTransaction transaction)
{
try
{
var query = "insert into finance.ExpensesTransaction (EventDatesID,TransferedAmount,TransactionDate,TransactionID,ExpenseRecipientID,CreatedBy,CreatedDate,notes) " +
"values (@EventDatesID,@TransferedAmount,@TransactionDate,@TransactionID,@ExpenseRecipientID,@CreatedBy,@CreatedDate,@notes)";
var cmd = dbmanager.GetSqlCommand();
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@EventDatesID", transaction.EventDatesID);
cmd.Parameters.AddWithValue("@TransferedAmount", transaction.TransferedAmount);
cmd.Parameters.AddWithValue("@BalanceAmount", transaction.BalanceAmount);
cmd.Parameters.AddWithValue("@TransactionDate", transaction.TransactionDate);
cmd.Parameters.AddWithValue("@TransactionID", transaction.TransactionID);
if (transaction.ExpenseRecipientID == 0)
{
cmd.Parameters.AddWithValue("@ExpenseRecipientID", DBNull.Value);
}
else
{
cmd.Parameters.AddWithValue("@ExpenseRecipientID", transaction.ExpenseRecipientID);
}
cmd.Parameters.AddWithValue("@CreatedBy", "Admin");
cmd.Parameters.AddWithValue("@CreatedDate", DateTime.Now);
cmd.Parameters.AddWithValue("@notes", (transaction.notes) ?? "");
var rows = dbmanager.ExecuteNonQuery(cmd);
return(rows >= 1);
}
catch (Exception ex)
{
throw ex;
}
}
public void SendEventsToConsumerGetsSentToRepositoryAndPublisher()
{
_repository = new Mock <IEventRepository>();
_repository.Setup(c => c.WriteEvents(It.IsAny <List <EventTransaction> >()))
.Returns(() => true);
_publisher = new Mock <IEventPublisher>();
_publisher.Setup(c => c.Publish(It.IsAny <EventTransaction>()))
.Returns(() => true);
var eventStore = new EventStore(_repository.Object, _publisher.Object);
var eventTransaction = new EventTransaction
{
Events = new[] {
new Event {
AggregateId = _aggregateId,
SerializedEvent = Encoding.UTF8.GetBytes("some data"),
EventType = "Event type"
}
}
};
eventStore.Process(eventTransaction).Wait();
_repository.Verify(c => c.WriteEvents(It.IsAny <List <EventTransaction> >()), Times.AtLeastOnce());
_publisher.Verify(c => c.Publish(It.IsAny <EventTransaction>()), Times.AtLeastOnce());
eventStore.Dispose();
}
public void SerializeSimpleEvent()
{
Guid aggreagateId = Guid.Parse("{39B880B6-1490-441C-A402-F580DC124C61}");
int serialNumber = 1;
byte[] @event = BitConverter.GetBytes(5);
var events = new EventTransaction
{
Events = new []
{
new Event
{
AggregateId = aggreagateId,
SerialId = serialNumber,
SerializedEvent = @event
}
}
};
var serializer = new ProtobufEventsSerializer();
byte[] result = serializer.Serialize(events);
var publishedEvents = serializer.DeserializeEventTransaction(result);
var publishedEvent = publishedEvents.Events[0];
Assert.Equal(aggreagateId, publishedEvents.Events[0].AggregateId);
Assert.Equal(serialNumber, publishedEvent.SerialId);
Assert.Equal(@event, publishedEvent.SerializedEvent);
}
public bool SaveEventTransaction(EventTransaction transaction)
{
try
{
return(DAL.SaveEventTransaction(transaction));
}
catch (Exception ex)
{
throw ex;
}
}
public string SaveTransaction(EventTransaction transaction)
{
try
{
var result = dbStore.SaveEventTransaction(transaction);
return((result) ? "saved successfully" : "something went wrong");
}
catch (Exception ex)
{
throw ex;
}
}
private void Form1_Load(object sender, EventArgs e)
{
EventBD = new EventTransaction(50, 50, 60, 330, this);
ThemeBD = new ThematicTransaction(50, 50, 60, 330, this);
CongratulationBD = new CongratulationTransaction(50, 50, 300, 330, this);
//Fill ListofEvents
ListofEvents = Event.Fill();
//Fill ListOfThematics
ListofThematics = Theme.Fill();
//Fill ListOfCongratulations
ListOfCongratulations = Congratulation.Fill();
//First select when form has alreadde loaded
EventBD.Select(ListofEvents, EventBD);
}
public void SendEventWithMissingValuesThrowsException(Event @event)
{
_repository = new Mock <IEventRepository>();
_publisher = new Mock <IEventPublisher>();
var eventStore = new EventStore(_repository.Object, _publisher.Object);
var transaction = new EventTransaction
{
Events = new[] { @event }
};
var task = eventStore.Process(transaction);
Assert.IsType <InvalidOperationException>(task.Exception.InnerException);
}
private bool TryPublish(EventTransaction transaction)
{
bool success = false;
int retriesLeft = 5;
var eventTransactions = new List <EventTransaction>();
while (!success && retriesLeft > 0)
{
success = _publisher.Publish(transaction);
retriesLeft--;
}
return(success);
}
public bool Publish(EventTransaction eventTransactions)
{
try
{
byte[] message = Serializer.Serialize(eventTransactions);
_channel.BasicPublish(exchange: _configuration.ExchangeName,
routingKey: "",
basicProperties: null,
body: message);
}
catch (Exception)
{
return(false);
}
return(true);
}
public Task <bool> Process(EventTransaction eventTransaction)
{
var tcs = new TaskCompletionSource <bool>();
var transactionTask = new TransactionTask(eventTransaction, tcs);
if (eventTransaction.Events.Any(c => c.AggregateId == Guid.Empty || string.IsNullOrWhiteSpace(c.EventType) || c.SerializedEvent == null || !c.SerializedEvent.Any()))
{
tcs.SetException(new InvalidOperationException("AggregateId, EventType and SerializedEvent can not be empty"));
}
//trys to add for ten millisecond. Not sure what is a good timeout here, but at least it wont block indefinitely
if (!_writerQueue.TryAdd(transactionTask, 10))
{
tcs.SetException(new TimeoutException("Timed out while waiting to add to persistence queue"));
}
return(tcs.Task);
}
public void SerializeTwoEvents()
{
Guid aggreagateId1 = Guid.Parse("{08B175B5-1BE8-4667-96AD-73F7F1BECA5A}");
int serialNumber1 = 1;
int serialNumber2 = 2;
byte[] event1 = BitConverter.GetBytes(5);
byte[] event2 = BitConverter.GetBytes(7);
var events = new EventTransaction
{
Events = new[]
{
new Event
{
AggregateId = aggreagateId1,
SerialId = serialNumber1,
SerializedEvent = event1
},
new Event
{
AggregateId = aggreagateId1,
SerialId = serialNumber2,
SerializedEvent = event2
}
}
};
var serializer = new ProtobufEventsSerializer();
byte[] result = serializer.Serialize(events);
var publishedEvents = serializer.DeserializeEventTransaction(result);
var publishedEvent = publishedEvents.Events[0];
Assert.Equal(aggreagateId1, publishedEvents.Events[0].AggregateId);
Assert.Equal(serialNumber1, publishedEvent.SerialId);
Assert.Equal(event1, publishedEvent.SerializedEvent);
publishedEvent = publishedEvents.Events[1];
Assert.Equal(serialNumber2, publishedEvent.SerialId);
Assert.Equal(event2, publishedEvent.SerializedEvent);
}
public bool Publish(EventTransaction eventTransaction)
{
return(true);
}
public TransactionTask(EventTransaction transaction, TaskCompletionSource <bool> tcs)
{
Transaction = transaction;
_tcs = tcs;
}
public byte[] Serialize(EventTransaction eventTransaction)
{
return(Serialize <EventTransaction>(eventTransaction));
}
public void Enqueue(EventTransaction transaction)
{
_publisherQueue.Add(transaction);
}
