private static async Task CreateQueue()
{
try
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new Exception("Namespace name is empty!");
}
var token = await GetToken();
var creds = new TokenCredentials(token);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = appOptions.SubscriptionId,
};
var queueParams = new SBQueue
{
EnablePartitioning = true
};
Console.WriteLine("Creating queue...");
await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, QueueName, queueParams);
Console.WriteLine("Created queue successfully.");
}
catch (Exception e)
{
Console.WriteLine("Could not create a queue...");
Console.WriteLine(e.Message);
throw e;
}
}
private static async Task CriarQueueSeNaoExistir()
{
try
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new Exception("Namespace nao existe!");
}
var token = await GetToken();
var creds = new TokenCredentials(token);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = appOptions.SubscriptionId,
};
var queueParams = new SBQueue
{
EnablePartitioning = true
};
await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, queueName, queueParams);
}
catch (Exception e)
{
throw new Exception("Nao foi possivel criar fila a queue...");
}
}
/// <summary>
/// Creates a Service Bus scope associated with a queue instance, intended to be used in the context
/// of a single test and disposed when the test has completed.
/// </summary>
///
/// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the queue that is created.</param>
/// <param name="enableSession">When <c>true</c>, a session will be enabled on the queue that is created.</param>
/// <param name="forceQueueCreation">When <c>true</c>, forces creation of a new queue even if an environmental override was specified to use an existing one.</param>
/// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param>
///
/// <returns>The requested Service Bus <see cref="QueueScope" />.</returns>
///
/// <remarks>
/// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceQueueCreation" /> flag
/// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" /> and
/// <paramref name="enableSession" /> parameters are also ignored.
/// </remarks>
///
public static async Task <QueueScope> CreateWithQueue(bool enablePartitioning,
bool enableSession,
bool forceQueueCreation = false,
TimeSpan?lockDuration = default,
string overrideNamespace = default,
[CallerMemberName] string caller = "")
{
// Create a new queue specific to the scope being created.
caller = (caller.Length < 16) ? caller : caller.Substring(0, 15);
var azureSubscription = ServiceBusTestEnvironment.Instance.SubscriptionId;
var resourceGroup = ServiceBusTestEnvironment.Instance.ResourceGroup;
var serviceBusNamespace = overrideNamespace ?? ServiceBusTestEnvironment.Instance.ServiceBusNamespace;
var token = await AcquireManagementTokenAsync().ConfigureAwait(false);
string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }";
using (var client = new ServiceBusManagementClient(ResourceManagerUri, new TokenCredentials(token))
{
SubscriptionId = azureSubscription
})
{
var queueParameters = new SBQueue(enablePartitioning: enablePartitioning, requiresSession: enableSession, maxSizeInMegabytes: 1024, lockDuration: lockDuration);
var queue = await CreateRetryPolicy <SBQueue>().ExecuteAsync(() => client.Queues.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), queueParameters)).ConfigureAwait(false);
return(new QueueScope(serviceBusNamespace, queue.Name, true));
}
}
public QueueAttributes(SBQueue quResource)
{
if (quResource != null)
{
Name = quResource.Name;
LockDuration = XmlConvert.ToString((TimeSpan)quResource.LockDuration);
AccessedAt = quResource.AccessedAt;
AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)quResource.AutoDeleteOnIdle);
CreatedAt = quResource.CreatedAt;
DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)quResource.DefaultMessageTimeToLive);
DuplicateDetectionHistoryTimeWindow = XmlConvert.ToString((TimeSpan)quResource.DuplicateDetectionHistoryTimeWindow);
DeadLetteringOnMessageExpiration = quResource.DeadLetteringOnMessageExpiration;
EnableExpress = quResource.EnableExpress;
EnablePartitioning = quResource.EnablePartitioning;
MaxDeliveryCount = quResource.MaxDeliveryCount;
MaxSizeInMegabytes = quResource.MaxSizeInMegabytes;
MessageCount = quResource.MessageCount;
CountDetails = quResource.CountDetails;
RequiresDuplicateDetection = quResource.RequiresDuplicateDetection;
RequiresSession = quResource.RequiresSession;
SizeInBytes = quResource.SizeInBytes;
Status = quResource.Status;
UpdatedAt = quResource.UpdatedAt;
#pragma warning disable 612, 618
IsAnonymousAccessible = false;
SupportOrdering = false;
EnableBatchedOperations = false;
EntityAvailabilityStatus = "Available";
#pragma warning restore 612, 618
}
}
public QueueAttributes(SBQueue quResource)
{
if (quResource != null)
{
Name = quResource.Name;
LockDuration = XmlConvert.ToString((TimeSpan)quResource.LockDuration);
AccessedAt = quResource.AccessedAt;
AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)quResource.AutoDeleteOnIdle);
CreatedAt = quResource.CreatedAt;
DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)quResource.DefaultMessageTimeToLive);
DuplicateDetectionHistoryTimeWindow = XmlConvert.ToString((TimeSpan)quResource.DuplicateDetectionHistoryTimeWindow);
DeadLetteringOnMessageExpiration = quResource.DeadLetteringOnMessageExpiration;
EnableExpress = quResource.EnableExpress;
EnablePartitioning = quResource.EnablePartitioning;
MaxDeliveryCount = quResource.MaxDeliveryCount;
MaxSizeInMegabytes = quResource.MaxSizeInMegabytes;
MessageCount = quResource.MessageCount;
CountDetails = quResource.CountDetails;
RequiresDuplicateDetection = quResource.RequiresDuplicateDetection;
RequiresSession = quResource.RequiresSession;
SizeInBytes = quResource.SizeInBytes;
Status = quResource.Status;
UpdatedAt = quResource.UpdatedAt;
}
}
/// <summary>
/// Creates a Service Bus scope associated with a queue instance, intended to be used in the context
/// of a single test and disposed when the test has completed.
/// </summary>
///
/// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the queue that is created.</param>
/// <param name="enableSession">When <c>true</c>, a session will be enabled on the queue that is created.</param>
/// <param name="forceQueueCreation">When <c>true</c>, forces creation of a new queue even if an environmental override was specified to use an existing one.</param>
/// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param>
///
/// <returns>The requested Service Bus <see cref="QueueScope" />.</returns>
///
/// <remarks>
/// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceQueueCreation" /> flag
/// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" /> and
/// <paramref name="enableSession" /> parameters are also ignored.
/// </remarks>
///
public static async Task <QueueScope> CreateWithQueue(bool enablePartitioning,
bool enableSession,
bool forceQueueCreation = false,
[CallerMemberName] string caller = "")
{
// If there was an override and the force flag is not set for creation, then build a scope
// for the specified queue.
if ((!string.IsNullOrEmpty(TestEnvironment.OverrideQueueName)) && (!forceQueueCreation))
{
return(new QueueScope(TestEnvironment.ServiceBusNamespace, TestEnvironment.OverrideQueueName, false));
}
// Create a new queue specific to the scope being created.
caller = (caller.Length < 16) ? caller : caller.Substring(0, 15);
var azureSubscription = TestEnvironment.ServiceBusAzureSubscription;
var resourceGroup = TestEnvironment.ServiceBusResourceGroup;
var serviceBusNamespace = TestEnvironment.ServiceBusNamespace;
var token = await AquireManagementTokenAsync().ConfigureAwait(false);
string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }";
using (var client = new ServiceBusManagementClient(new TokenCredentials(token))
{
SubscriptionId = azureSubscription
})
{
var queueParameters = new SBQueue(enablePartitioning: enablePartitioning, requiresSession: enableSession, maxSizeInMegabytes: 1024);
var queue = await CreateRetryPolicy <SBQueue>().ExecuteAsync(() => client.Queues.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), queueParameters)).ConfigureAwait(false);
return(new QueueScope(serviceBusNamespace, queue.Name, true));
}
}
public PSQueueAttributes CreateUpdateQueue(string resourceGroupName, string namespaceName, string queueName, PSQueueAttributes queue)
{
SBQueue parameters = new SBQueue();
if (queue.LockDuration != null)
{
parameters.LockDuration = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.LockDuration);
}
if (queue.AutoDeleteOnIdle != null)
{
parameters.AutoDeleteOnIdle = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.AutoDeleteOnIdle);
}
if (queue.DefaultMessageTimeToLive != null)
{
parameters.DefaultMessageTimeToLive = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.DefaultMessageTimeToLive);
}
if (queue.DuplicateDetectionHistoryTimeWindow != null)
{
parameters.DuplicateDetectionHistoryTimeWindow = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(queue.DuplicateDetectionHistoryTimeWindow);
}
if (queue.DeadLetteringOnMessageExpiration.HasValue)
{
parameters.DeadLetteringOnMessageExpiration = queue.DeadLetteringOnMessageExpiration;
}
if (queue.EnableExpress.HasValue)
{
parameters.EnableExpress = queue.EnableExpress;
}
if (queue.EnablePartitioning.HasValue)
{
parameters.EnablePartitioning = queue.EnablePartitioning;
}
if (queue.MaxDeliveryCount.HasValue)
{
parameters.MaxDeliveryCount = queue.MaxDeliveryCount;
}
if (queue.MaxSizeInMegabytes.HasValue)
{
parameters.MaxSizeInMegabytes = queue.MaxSizeInMegabytes;
}
if (queue.RequiresDuplicateDetection.HasValue)
{
parameters.RequiresDuplicateDetection = queue.RequiresDuplicateDetection;
}
if (queue.RequiresSession.HasValue)
{
parameters.RequiresSession = queue.RequiresSession;
}
if (queue.Status.HasValue)
{
parameters.Status = queue.Status;
}
SBQueue response = Client.Queues.CreateOrUpdate(resourceGroupName, namespaceName, queueName, parameters);
return(new PSQueueAttributes(response));
}
public PSQueueAttributes UpdateQueue(string resourceGroupName, string namespaceName, string queueName, string location, bool enableExpress, bool isAnonymousAccessible)
{
SBQueue parameters = new SBQueue()
{
EnableExpress = enableExpress
};
var response = Client.Queues.CreateOrUpdate(resourceGroupName, namespaceName, queueName, parameters);
return(new PSQueueAttributes(response));
}
internal async Task CreateQueueAsync(string name)
{
var pars = new SBQueue()
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(30)
};
await _client.Queues.CreateOrUpdateAsync(
_identifier.ResourceGroupName,
_identifier.Name,
name,
pars);
}
private static async Task CreateQueue()
{
try
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new Exception("Namespace name is empty!");
}
var token = await GetToken();
var creds = new TokenCredentials(token);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = appOptions.SubscriptionId,
};
var queueParams = new SBQueue
{
EnablePartitioning = false,
DeadLetteringOnMessageExpiration = true,
MaxSizeInMegabytes = 1024
};
Console.WriteLine("Creating queue...");
foreach (var fila in appOptions.Queues)
{
try
{
await sbClient.Queues.CreateOrUpdateAsync(resourceGroupName, namespaceName, fila, queueParams);
//var queueExists = await sbClient.Queues.GetAsync(resourceGroupName, namespaceName, QueueName);
Console.WriteLine("Created queue successfully.");
}
catch (Exception e)
{
Console.WriteLine("Could not create a queue...");
}
}
}
catch (Exception e)
{
Console.WriteLine("Could not create a queue...");
Console.WriteLine(e.Message);
throw e;
}
}
public async Task CreateQueue(string queueName)
{
try
{
using (var sbClient = await GetServiceManagementClient())
{
var queueParams = new SBQueue
{
EnablePartitioning = true,
RequiresSession = true
};
await sbClient.Queues.CreateOrUpdateAsync(appOptions.ResourceGroupName, appOptions.NamespaceName, queueName, queueParams);
}
}
catch (Exception e)
{
throw e;
}
}
private async Task EnsureQueue()
{
var context = new AuthenticationContext($"https://login.microsoftonline.com/{_tenantId}");
var token = await context.AcquireTokenAsync("https://management.azure.com/", new ClientCredential(_clientId, _clientSecret));
var creds = new TokenCredentials(token.AccessToken);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = _subscriptionId
};
var queueParams = new SBQueue()
{
LockDuration = _lockDurationInSeconds,
MaxDeliveryCount = _maxDeliveryCount,
EnableExpress = _enableExpress,
EnableBatchedOperations = _enableBatchOperations
};
await sbClient.Queues.CreateOrUpdateAsync(_resourceGroup, _namespaceName, _queueName, queueParams);
}
/// <summary>
/// Creates or updates a Service Bus queue. This operation is idempotent.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639395.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='queueName'>
/// The queue name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create or update a queue resource.
/// </param>
public static SBQueue CreateOrUpdate(this IQueuesOperations operations, string resourceGroupName, string namespaceName, string queueName, SBQueue parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, namespaceName, queueName, parameters).GetAwaiter().GetResult());
}
public PSQueueAttributes GetQueue(string resourceGroupName, string namespaceName, string queueName)
{
SBQueue response = Client.Queues.Get(resourceGroupName, namespaceName, queueName);
return(new PSQueueAttributes(response));
}
public void QueuesCreateGetUpdateDelete()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create Namespace
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Sku = new SBSku
{
Name = SkuName.Standard,
Tier = SkuTier.Standard
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Create Queue
var queueName = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix);
var createQueueResponse = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName,
new SBQueue()
{
EnableExpress = true, EnableBatchedOperations = true
});
Assert.NotNull(createQueueResponse);
Assert.Equal(createQueueResponse.Name, queueName);
Assert.True(createQueueResponse.EnableExpress);
// Get the created Queue
var getQueueResponse = ServiceBusManagementClient.Queues.Get(resourceGroup, namespaceName, queueName);
Assert.NotNull(getQueueResponse);
Assert.Equal(EntityStatus.Active, getQueueResponse.Status);
Assert.Equal(getQueueResponse.Name, queueName);
// Get all Queues
var getQueueListAllResponse = ServiceBusManagementClient.Queues.ListByNamespace(resourceGroup, namespaceName);
Assert.NotNull(getQueueListAllResponse);
Assert.True(getQueueListAllResponse.Count() >= 1);
Assert.True(getQueueListAllResponse.All(ns => ns.Id.Contains(resourceGroup)));
// Create Queue1
var queueName1 = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix);
var createQueueResponse1 = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName1,
new SBQueue()
{
EnableExpress = true
});
// Update Queue.
var updateQueuesParameter = new SBQueue()
{
EnableExpress = true,
MaxDeliveryCount = 5,
MaxSizeInMegabytes = 1024,
ForwardTo = queueName1,
ForwardDeadLetteredMessagesTo = queueName1
};
var updateQueueResponse = ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName, updateQueuesParameter);
Assert.NotNull(updateQueueResponse);
Assert.True(updateQueueResponse.EnableExpress);
Assert.Equal(updateQueueResponse.ForwardTo, queueName1);
Assert.Equal(updateQueueResponse.ForwardDeadLetteredMessagesTo, queueName1);
// Delete Created Queue
ServiceBusManagementClient.Queues.Delete(resourceGroup, namespaceName, queueName);
//Delete Namespace Async
ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroup, namespaceName, null, new CancellationToken()).ConfigureAwait(false);
}
}
private SBQueue CreateQueueDescription()
{
var qd = new SBQueue(_options.Name)
{
LockDuration = _options.WorkItemTimeout,
MaxDeliveryCount = _options.Retries + 1
};
if (_options.AutoDeleteOnIdle.HasValue)
{
qd.AutoDeleteOnIdle = _options.AutoDeleteOnIdle.Value;
}
if (_options.DefaultMessageTimeToLive.HasValue)
{
qd.DefaultMessageTimeToLive = _options.DefaultMessageTimeToLive.Value;
}
if (_options.DuplicateDetectionHistoryTimeWindow.HasValue)
{
qd.DuplicateDetectionHistoryTimeWindow = _options.DuplicateDetectionHistoryTimeWindow.Value;
}
// todo : https://github.com/Azure/azure-service-bus/issues/88
//if (_options.EnableBatchedOperations.HasValue)
// qd.EnableBatchedOperations = _options.EnableBatchedOperations.Value;
if (_options.EnableDeadLetteringOnMessageExpiration.HasValue)
{
qd.DeadLetteringOnMessageExpiration = _options.EnableDeadLetteringOnMessageExpiration.Value;
}
if (_options.EnableExpress.HasValue)
{
qd.EnableExpress = _options.EnableExpress.Value;
}
if (_options.EnablePartitioning.HasValue)
{
qd.EnablePartitioning = _options.EnablePartitioning.Value;
}
//if (!String.IsNullOrEmpty(_options.ForwardDeadLetteredMessagesTo))
// qd.ForwardDeadLetteredMessagesTo = _options.ForwardDeadLetteredMessagesTo;
//if (!String.IsNullOrEmpty(_options.ForwardTo))
// qd.ForwardTo = _options.ForwardTo;
//if (_options.IsAnonymousAccessible.HasValue)
//qd.IsAnonymousAccessible = _options.IsAnonymousAccessible.Value;
if (_options.MaxSizeInMegabytes.HasValue)
{
qd.MaxSizeInMegabytes = Convert.ToInt32(_options.MaxSizeInMegabytes.Value);
}
if (_options.RequiresDuplicateDetection.HasValue)
{
qd.RequiresDuplicateDetection = _options.RequiresDuplicateDetection.Value;
}
if (_options.RequiresSession.HasValue)
{
qd.RequiresSession = _options.RequiresSession.Value;
}
if (_options.Status.HasValue)
{
qd.Status = _options.Status.Value;
}
//if (_options.SupportOrdering.HasValue)
// qd.SupportOrdering = _options.SupportOrdering.Value;
//if (!String.IsNullOrEmpty(_options.UserMetadata))
// qd.UserMetadata = _options.UserMetadata;
return(qd);
}
/// <summary>
/// Creates or updates a Service Bus queue. This operation is idempotent.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639395.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='queueName'>
/// The queue name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create or update a queue resource.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <SBQueue> CreateOrUpdateAsync(this IQueuesOperations operations, string resourceGroupName, string namespaceName, string queueName, SBQueue parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, namespaceName, queueName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <IActionResult> Post([FromBody] Order order)
{
bool listenForResponse = Boolean.TryParse(Request.Headers["ImplementAsyncRequestResponseMessaging"], out listenForResponse);
var topicClient = new TopicClient(_appSettings.ServiceBusConnectionString, _appSettings.OrderTopicName);
try
{
if (order == null)
{
return(BadRequest());
}
var message = new Message(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(order)));
message.MessageId = Guid.NewGuid().ToString();
if (listenForResponse)
{
var responseSessionID = order.Id.ToString();
var tenantId = _appSettings.TenantId;
var clientId = _appSettings.ClientId;
var clientSecret = _appSettings.ClientSecret;
var context = new AuthenticationContext($"https://login.microsoftonline.com/{tenantId}");
var result = await context.AcquireTokenAsync(
"https://management.core.windows.net/",
new ClientCredential(clientId, clientSecret));
var creds = new TokenCredentials(result.AccessToken);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = _appSettings.SubscriptionId
};
var queueParams = new SBQueue()
{
DeadLetteringOnMessageExpiration = true,
RequiresSession = true,
DefaultMessageTimeToLive = TimeSpan.FromMilliseconds(20000)
};
await sbClient.Queues.CreateOrUpdateAsync(_appSettings.ResourceGroupName, _appSettings.ServiceBusNamespace,
responseSessionID, queueParams);
var sessionClient = new SessionClient(_appSettings.ServiceBusConnectionString, responseSessionID);
var session = await sessionClient.AcceptMessageSessionAsync(responseSessionID);
await topicClient.SendAsync(message);
var responseMessage = await session.ReceiveAsync();
if (responseMessage != null)
{
var orderResponse = JsonConvert.DeserializeObject <OrderResponse>(Encoding.UTF8.GetString(responseMessage.Body));
await session.CompleteAsync(responseMessage.SystemProperties.LockToken);
await sbClient.Queues.DeleteAsync(_appSettings.ResourceGroupName, _appSettings.ServiceBusNamespace, responseSessionID);
await sessionClient.CloseAsync();
return(new JsonResult(orderResponse));
}
}
await topicClient.SendAsync(message);
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500));
}
finally
{
await topicClient.CloseAsync();
}
}
