public async Task <IActionResult> ImportSellableItemFromContentHub([FromBody] JObject request)
{
InitializeEnvironment();
try
{
if (!request.ContainsKey("EntityId") || request["EntityId"] == null)
{
return((IActionResult) new BadRequestObjectResult((object)request));
}
string entityId = request["EntityId"].ToString();
var command = Command <ImportSellableItemFromContentHubCommand>();
var mappingPolicy = CurrentContext.GetPolicy <SellableItemMappingPolicy>();
var argument = new ImportCatalogEntityArgument(mappingPolicy, typeof(SellableItem))
{
ContentHubEntityId = entityId
};
var result = await command.Process(CurrentContext, argument);
return(result != null ? new ObjectResult(result) : new NotFoundObjectResult("Error importing SellableItem data"));
}
catch (Exception ex)
{
return(new ObjectResult(ex));
}
}
private async Task <ImportCatalogEntityArgument> TryProcessCategory(string sourceId, string sourceEntityType, MappingConfiguration mappingConfiguration, CommerceContext context)
{
var argument = new ImportCatalogEntityArgument(mappingConfiguration, typeof(SellableItem))
{
ContentHubEntityId = sourceId,
SourceEntityType = sourceEntityType
};
return(await _importCategoryFromContentHubCommand.Process(context, argument).ConfigureAwait(false));
}
public async Task <IActionResult> ImportCategoryFromContentHub([FromBody] JObject request)
{
await InitializeEnvironment().ConfigureAwait(false);
try
{
if (!request.ContainsKey("EntityId") || request["EntityId"] == null)
{
return((IActionResult) new BadRequestObjectResult((object)request));
}
string entityId = request["EntityId"].ToString();
string entityType = null;
if (Request?.Headers != null && Request.Headers.ContainsKey("EntityType"))
{
entityType = Request.Headers["EntityType"];
}
if (string.IsNullOrEmpty(entityType))
{
throw new ArgumentNullException($"Error syncing Entity with EntityId={entityId}. entityType header value must be set.");
}
string instanceName = null;
if (Request?.Headers != null && Request.Headers.ContainsKey("InstanceName"))
{
instanceName = Request.Headers["InstanceName"];
}
if (string.IsNullOrEmpty(instanceName))
{
throw new ArgumentNullException($"Error syncing Entity with EntityId={entityId}. InstanceName header value must be set.");
}
var command = Command <ImportCategoryFromContentHubCommand>();
var mappingPolicy = CurrentContext.GetPolicy <CategoryMappingPolicy>();
var mappingConfiguration = mappingPolicy?.MappingConfigurations?.FirstOrDefault(c => c.EntityType.Equals(entityType, StringComparison.OrdinalIgnoreCase) &&
c.SourceName.Equals(instanceName, StringComparison.OrdinalIgnoreCase));
if (mappingConfiguration != null)
{
var argument = new ImportCatalogEntityArgument(mappingConfiguration, typeof(SellableItem))
{
ContentHubEntityId = entityId,
SourceEntityType = entityType
};
var result = await command.Process(CurrentContext, argument);
return(result != null ? new ObjectResult(result) : new NotFoundObjectResult("Error importing SellableItem data"));
}
return(new NotFoundObjectResult("No suitable mapping configuration found"));
}
catch (Exception ex)
{
return(new ObjectResult(ex));
}
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
var messageString = Encoding.UTF8.GetString(message.Body);
_logger.LogInformation($"Received Message: {messageString}");
if (message != null &&
message.UserProperties.ContainsKey("target_id") &&
message.UserProperties.ContainsKey("target_definition") &&
message.UserProperties.ContainsKey("target_definition"))
{
var targetId = (string)message.UserProperties["target_id"];
var targetDefinition = (string)message.UserProperties["target_definition"];
var instanceName = (string)message.UserProperties["instance_name"];
if (!string.IsNullOrEmpty(targetId) && !string.IsNullOrEmpty(targetDefinition) && !string.IsNullOrEmpty(instanceName))
{
var context = GetCommerceContext();
var environment = await _getEnvironmentCommand.Process(context, "HabitatAuthoring").ConfigureAwait(false);
context.PipelineContextOptions.CommerceContext.Environment = environment;
var mappingPolicy = context.GetPolicy <SellableItemMappingPolicy>();
var mappingConfiguration = mappingPolicy?.MappingConfigurations?.FirstOrDefault(c => c.EntityType.Equals(targetDefinition, StringComparison.OrdinalIgnoreCase) &&
c.SourceName.Equals(instanceName, StringComparison.OrdinalIgnoreCase));
ImportCatalogEntityArgument result = null;
if (mappingConfiguration != null)
{
result = await TryProcessSellableItem(targetId, targetDefinition, mappingConfiguration, context).ConfigureAwait(false);
}
else
{
var categoryMappingPolicy = context.GetPolicy <CategoryMappingPolicy>();
mappingConfiguration = categoryMappingPolicy?.MappingConfigurations?.FirstOrDefault(c => c.EntityType.Equals(targetDefinition, StringComparison.OrdinalIgnoreCase) &&
c.SourceName.Equals(instanceName, StringComparison.OrdinalIgnoreCase));
result = await TryProcessCategory(targetId, targetDefinition, mappingConfiguration, context).ConfigureAwait(false);
}
if (result == null)
{
_logger.LogError($"Cannot process Service Bus message. Mapping configuration not found for EntityType=={targetDefinition} and SourceName=={instanceName}");
}
}
}
else
{
_logger.LogError($"Cannot process Service Bus message. UserProperties: {string.Join(Environment.NewLine, message.UserProperties)}. Message: {messageString}");
}
await _queueClient.CompleteAsync(message.SystemProperties.LockToken);
}
public async Task <IActionResult> ImportSellableItem([FromBody] JObject request)
{
InitializeEnvironment();
try
{
var command = Command <ImportSellableItemCommand>();
var mappingPolicy = CurrentContext.GetPolicy <SellableItemMappingPolicy>();
var argument = new ImportCatalogEntityArgument(request, mappingPolicy, typeof(SellableItem));
var result = await command.Process(CurrentContext, argument);
return(result != null ? new ObjectResult(result) : new NotFoundObjectResult("Error importing SellableItem data"));
}
catch (Exception ex)
{
return(new ObjectResult(ex));
}
}
public async Task <IActionResult> ProcessAzureQueue([FromBody] JObject request)
{
InitializeEnvironment();
try
{
var subClient = SubscriptionClient.CreateFromConnectionString(_connectionString, _topicName, _subscriptionName);
subClient.OnMessage(m =>
{
Log.Information($"Processing Azure Queue message: {m.GetBody<string>()}");
});
var messages = subClient.ReceiveBatch(_maxMessagesCount);
if (messages != null && messages.Count() > 0)
{
var command = Command <ImportSellableItemFromContentHubCommand>();
var mappingPolicy = CurrentContext.GetPolicy <SellableItemMappingPolicy>();
foreach (var message in messages)
{
//Check entity type and match it to policy settings
if (message != null && message.Properties.ContainsKey("target_id"))
{
var argument = new ImportCatalogEntityArgument(mappingPolicy, typeof(SellableItem))
{
ContentHubEntityId = (string)message.Properties["target_id"]
};
var result = await command.Process(CurrentContext, argument).ConfigureAwait(false);
//TODO: complete on success, define failure(s) handling
message.Complete();
}
}
}
//TODO: return meaningful message(s)
return(new ObjectResult(true));
//return result != null ? new ObjectResult(result) : new NotFoundObjectResult("Error importing SellableItem data");
}
catch (Exception ex)
{
Log.Error(ex, "Error processing Azure queue message(s)");
return(new ObjectResult(ex));
}
}
public async Task <ImportCatalogEntityArgument> Process(CommerceContext commerceContext, ImportCatalogEntityArgument args)
{
using (var activity = CommandActivity.Start(commerceContext, this))
{
var result = await this._pipeline.Run(args, new CommercePipelineExecutionContextOptions(commerceContext));
return(result);
}
}