public async Task CallsMessageQueuePublish()
{
await _sqlEventStore.SaveAsync(_eventList);
A.CallTo(() => _dapper.ExecuteAsync(_writeDbConnection, A <string> ._, A <EventDto> ._, CommandType.StoredProcedure, _transaction)).MustHaveHappened();
A.CallTo(() => _messageQueue.PublishAsync(_serializedEvent, "12345", A <string> ._))
.MustHaveHappened();
A.CallTo(() => _transaction.Commit()).MustHaveHappened();
}
public async Task AddStatAsync(bool isMutant)
{
int humans = 0;
int mutants = 0;
try
{
using (var connection = new SqlConnection(ConnectionString))
{
string sqlQueryGet = "select count_human_dna , count_mutant_dna from Stats";
Stats data = await _dapperWrapper.QuerySingle <Stats>(connection, sqlQueryGet);
if (data == null || data.Id == null)
{
string insertQuery = "INSERT INTO Stats (Id, count_human_dna, count_mutant_dna)" +
" VALUES ('00000000-0000-0000-0000-000000000000', 0, 0)";
await _dapperWrapper.ExecuteAsync(connection, insertQuery);
}
else
{
humans = data.count_human_dna;
mutants = data.count_mutant_dna;
}
if (isMutant == true)
{
mutants++;
}
else
{
humans++;
}
var dictionary = new Dictionary <string, object>
{
{ "@humans", humans },
{ "@mutants", mutants },
};
string updateQuery = "UPDATE Stats SET count_human_dna = @humans, " +
"count_mutant_dna = @mutants WHERE Id = '00000000-0000-0000-0000-000000000000'";
await _dapperWrapper.ExecuteAsync(connection, updateQuery, dictionary);
}
}
catch (Exception e)
{
throw e;
}
}
private async Task CreateOrdersTable()
{
var sql = @"CREATE TABLE IF NOT EXISTS Orders(
Order_id INT PRIMARY KEY,
Buyer_name VARCHAR(128),
Date_ordered DATETIME,
Seller_name VARCHAR(128),
Status VARCHAR(128),
Store_name VARCHAR(128),
Total_count INT,
Unique_count INT
)";
await _dapperWrapper.ExecuteAsync(sql);
}
public async Task <bool> AddAsync(Dna dna)
{
try
{
var dictionary = new Dictionary <string, object>
{
{ "@DnaSecuence", dna.DnaSecuence },
{ "@IsMutant", dna.IsMutant },
};
using (var connection = new SqlConnection(ConnectionString))
{
string sqlQuery = @"INSERT INTO [dbo].[Dna]
(ID, [DnaSecuence],[IsMutant])
VALUES(NEWID(), @DnaSecuence , @IsMutant)";
int rowsAffected = await _dapperWrapper.ExecuteAsync(
connection, sqlQuery, dictionary);
}
}
catch (Exception e)
{
throw e;
}
return(true);
}
public async Task CreateTables()
{
var sql = @"CREATE TABLE IF NOT EXISTS Users(
Username VARCHAR(20),
Password VARCHAR(20),
ConsumerKey VARCHAR(50),
ConsumerSecret VARCHAR(50),
TokenValue VARCHAR(50),
TokenSecret VARCHAR(50)
)";
await _dapperWrapper.ExecuteAsync(sql);
}
public async Task ClearDatabase()
{
var sql = @"DELETE FROM Costs;
DELETE FROM Payments;
DELETE FROM OrderItems;
DELETE FROM Items;
DELETE FROM Orders;";
await _dapperWrapper.ExecuteAsync(sql);
}
public async Task <(bool result, string error)> Register(User user)
{
var validationResult = await _validator.ValidateAsync(user);
if (!validationResult.IsValid)
{
return(false, validationResult.Errors.First().ErrorMessage);
}
var sql = @"INSERT INTO Users
VALUES(@Username, @Password, @ConsumerKey, @ConsumerSecret, @TokenValue, @TokenSecret)";
await _dapperWrapper.ExecuteAsync(sql, new { user.Username, user.Password, user.ConsumerKey, user.ConsumerSecret, user.TokenValue, user.TokenSecret });
return(true, string.Empty);
}
public async Task SaveAsync(IEnumerable <IEvent> events)
{
foreach (var @event in events)
{
var eventData = JsonConvert.SerializeObject(@event, JsonSerializerSettings);
var eventType = @event.GetType().Name;
var dto = new EventDto
{
AggregateId = @event.Id,
AggregateType = @event.AggregateType,
ApplicationName = _settings.ApplicationName,
Version = @event.Version,
TimeStamp = @event.TimeStamp,
EventType = eventType,
EventData = eventData
};
using (var conn = _sqlConnectionFactory.GetWriteConnection())
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
await _dapper.ExecuteAsync(conn, _settings.SaveSql, dto, _settings.CommandType, trans).ConfigureAwait(false);
await _messageQueue.PublishAsync(eventData, @event.Id, eventType).ConfigureAwait(false);
trans.Commit();
}
catch (Exception)
{
trans.Rollback();
throw;
}
}
}
}
}
public virtual async Task <int> AddRangeAsync <T>(IEnumerable <T> entities, string[] ignoreParameters = null)
{
var query = $"INSERT INTO {typeof(T).Name} ({_dbHelper.ConstructColumsForInsert<T>(ignoreParameters)}) VALUES ({_dbHelper.ConstructParamsForInsert<T>(ignoreParameters)});";
return(await _dapper.ExecuteAsync(_dbconnection, query, entities, _openTransaction));
}