/// <summary>
/// Handles the specified query.
/// </summary>
/// <param name="query">The query.</param>
/// <returns></returns>
public IReceivedMessageInternal Handle(ReceiveMessageQuery <IDbConnection, IDbTransaction> query)
{
if (!_databaseExists.Exists(_connectionInformation.ConnectionString))
{
return(null);
}
using (var connection = _dbFactory.CreateConnection(_connectionInformation.ConnectionString, false))
{
connection.Open();
using (var transaction = _dbFactory.CreateTransaction(connection).BeginTransaction())
{
using (var selectCommand = connection.CreateCommand())
{
selectCommand.Transaction = transaction;
CommandString commandString =
GetDeQueueCommand(_tableNameHelper.MetaDataName, _tableNameHelper.QueueName,
_tableNameHelper.StatusName, query.Routes);
_buildDequeueCommand.BuildCommand(selectCommand, commandString, _options.Value, query.Routes);
using (var reader = selectCommand.ExecuteReader())
{
return(_messageDeQueue.HandleMessage(connection, transaction, reader, commandString));
}
}
}
}
}
public void BuildCommand(SqlCommand selectCommand, ReceiveMessageQuery query)
{
selectCommand.Transaction = query.Transaction;
if (query.MessageId != null && query.MessageId.HasValue)
{
selectCommand.CommandText =
_createDequeueStatement.GetDeQueueCommand(true, query.Routes);
selectCommand.Parameters.Add("@QueueID", SqlDbType.BigInt);
selectCommand.Parameters["@QueueID"].Value = query.MessageId.Id.Value;
}
else
{
selectCommand.CommandText =
_createDequeueStatement.GetDeQueueCommand(false, query.Routes);
}
if (_options.Value.EnableRoute && query.Routes != null && query.Routes.Count > 0)
{
var routeCounter = 1;
foreach (var route in query.Routes)
{
selectCommand.Parameters.Add("@Route" + routeCounter.ToString(), SqlDbType.VarChar);
selectCommand.Parameters["@Route" + routeCounter.ToString()].Value = route;
routeCounter++;
}
}
}
public void Create_Default()
{
var context = Substitute.For <IMessageContext>();
var test = new ReceiveMessageQuery(context);
Assert.Equal(context, test.MessageContext);
}
public void Create_Null_Routes_Ok()
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
var messageid = fixture.Create<IMessageId>();
var test = new ReceiveMessageQuery(messageid, null);
Assert.NotNull(test.MessageId);
}
public void Create_Default()
{
var context = Substitute.For<IMessageContext>();
var id = Substitute.For<IMessageId>();
var test = new ReceiveMessageQuery(context,id);
Assert.Equal(id, test.MessageId);
Assert.Equal(context, test.MessageContext);
}
public void Create_Null_Transaction_Ok()
{
using (var conn = new SqlConnection())
{
var test = new ReceiveMessageQuery(conn, null, null, null);
Assert.NotNull(test.Connection);
Assert.Null(test.Transaction);
}
}
/// <summary>
/// Handles the specified query.
/// </summary>
/// <param name="query">The query.</param>
/// <returns></returns>
public IReceivedMessageInternal Handle(ReceiveMessageQuery <SqlConnection, SqlTransaction> query)
{
using (var selectCommand = query.Connection.CreateCommand())
{
_buildDequeueCommand.BuildCommand(selectCommand, query);
using (var reader = selectCommand.ExecuteReader())
{
return(_readMessage.Read(reader));
}
}
}
public void BuildCommand(SqlCommand selectCommand, ReceiveMessageQuery <SqlConnection, SqlTransaction> query)
{
BuildCommandInternal(selectCommand, query.Transaction, query.Routes);
}
/// <inheritdoc />
public IReceivedMessageInternal Handle(ReceiveMessageQuery <NpgsqlConnection, NpgsqlTransaction> query)
{
using (var selectCommand = query.Connection.CreateCommand())
{
selectCommand.Transaction = query.Transaction;
selectCommand.CommandText =
ReceiveMessage.GetDeQueueCommand(_commandCache, _tableNameHelper, _options.Value,
query.Routes);
selectCommand.Parameters.Add("@CurrentDate", NpgsqlDbType.Bigint);
selectCommand.Parameters["@CurrentDate"].Value = _getTime.GetCurrentUtcDate().Ticks;
if (_options.Value.EnableRoute && query.Routes != null && query.Routes.Count > 0)
{
var routeCounter = 1;
foreach (var route in query.Routes)
{
selectCommand.Parameters.Add("@Route" + routeCounter, NpgsqlDbType.Varchar);
selectCommand.Parameters["@Route" + routeCounter].Value = route;
routeCounter++;
}
}
using (var reader = selectCommand.ExecuteReader())
{
if (!reader.Read())
{
return(null);
}
//load up the message from the DB
long id = 0;
var correlationId = Guid.Empty;
byte[] headerPayload = null;
byte[] messagePayload = null;
try
{
id = (long)reader["queueid"];
correlationId = (Guid)reader["CorrelationID"];
headerPayload = (byte[])reader["Headers"];
messagePayload = (byte[])reader["body"];
var headers =
_serialization.InternalSerializer
.ConvertBytesTo <IDictionary <string, object> >(headerPayload);
var messageGraph =
(MessageInterceptorsGraph)headers[_headers.StandardHeaders.MessageInterceptorGraph.Name];
var message = _serialization.Serializer
.BytesToMessage <MessageBody>(messagePayload, messageGraph, headers).Body;
var newMessage = _messageFactory.Create(message, headers);
return(_receivedMessageFactory.Create(newMessage,
new MessageQueueId <long>(id),
new MessageCorrelationId <Guid>(correlationId)));
}
catch (Exception error)
{
//at this point, the record has been de-queued, but it can't be processed.
throw new PoisonMessageException(
"An error has occurred trying to re-assemble a message de-queued from the server ", error,
new MessageQueueId <long>(id), new MessageCorrelationId <Guid>(correlationId), messagePayload,
headerPayload);
}
}
}
}
public void Create_Null_MessageID_Ok()
{
var test = new ReceiveMessageQuery(null, new List<string>());
Assert.Null(test.MessageId);
}
public void Create_Null_Constructor_Ok_For_ID()
{
var test = new ReceiveMessageQuery(Substitute.For<IMessageContext>(), null);
Assert.Null(test.MessageId);
}
public async Task <IEnumerable <Message> > Handle(ReceiveMessageQuery query) => await query.Execute(_awsSqsClient);
public void Create_Null_Constructor_Ok_For_ID()
{
var test = new ReceiveMessageQuery(Substitute.For <IMessageContext>(), null);
Assert.Null(test.MessageId);
}
