public override ActionTaskResult Process(ActionContext context)
{
var productIds = _freezeService.GetUnfrozenProductIds();
if (productIds.Any())
{
int productContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.PRODUCTS_CONTENT_ID));
var publishContext = new ActionContext
{
BackendSid = context.BackendSid,
CustomerCode = context.CustomerCode,
ContentId = productContentId,
ContentItemIds = productIds,
Parameters = context.Parameters,
UserId = context.UserId,
UserName = context.UserName,
};
/*
* string actionAdapter = null;
* context.Parameters.TryGetValue(AdapterKey, out actionAdapter);
* var publishAction = _getAction(PublishAction, actionAdapter);
* publishAction.Process(publishContext);
*/
var dataForQueue = new ActionData
{
ActionContext = publishContext,
Description = null,
IconUrl = null
};
string data = ActionData.Serialize(dataForQueue);
_taskService.AddTask(PublishAction, data, publishContext.UserId, publishContext.UserName, TaskStrings.Unfreezing);
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ProductsUnfreezed),
Extra = string.Join(", ", productIds)
}));
}
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.NoProductsToUnfreeze),
}));
}
public virtual ActionTaskResult Process(ActionContext context)
{
if (ProcessInstantly(context))
{
return(ProcessTask(context));
}
else
{
RegisterTask(context);
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ActionEnqueued),
}));
}
}
public override ActionTaskResult Process(ActionContext context)
{
bool canProcess = false;
lock (Locker)
{
if (!IsProcessing)
{
IsProcessing = true;
canProcess = true;
}
}
if (canProcess)
{
try
{
int chunkSize = GetValue(context, "UpdateChunkSize", DefaultChunkSize);
int maxDegreeOfParallelism = GetValue(context, "MaxDegreeOfParallelism", DefaultMaxDegreeOfParallelism);
var report = _validationService.ValidateAndUpdate(chunkSize, maxDegreeOfParallelism, TaskContext);
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ValidationResult),
Parameters = new object[]
{
report.TotalProductsCount,
report.UpdatedProductsCount,
report.ValidatedProductsCount,
report.InvalidProductsCount,
report.ValidationErrorsCount
}
}));
}
finally
{
IsProcessing = false;
}
}
return(ActionTaskResult.Error(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ActionRunning),
Parameters = new object[] { GetType().Name }
}));
}
public override ActionTaskResult Process(ActionContext context)
{
var ids = new Queue <int>(context.ContentItemIds);
var sw = new Stopwatch();
var interval = GetInterval(context);
var taskIds = new List <int>();
sw.Start();
while (ids.Count > 0 && sw.ElapsedMilliseconds <= interval)
{
int id = ids.Dequeue();
context.ContentItemIds = new[] { id };
try
{
ProcessTask(context);
}
catch (ProductException)
{
taskIds.Add(id);
}
}
sw.Stop();
taskIds.AddRange(ids);
if (taskIds.Count > 0)
{
context.ContentItemIds = taskIds.ToArray();
RegisterTask(context);
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ActionEnqueued),
}));
}
else
{
return(null);
}
}
public async Task ImportAsync(ITaskExecutionContext executionContext, string language, string state, Dictionary <string, IProductStore> stores)
{
if (executionContext.IsCancellationRequested)
{
executionContext.IsCancelled = true;
return;
}
var url = _configuration.GetReindexUrl(language, state);
_logger.LogInformation("Starting import...");
var ids = await GetIds(url);
_logger.LogInformation($"Product list received. Length: {ids.Length}. Splitting products into chunks by {_options.ChunkSize}...");
var chunks = ids.Chunk(_options.ChunkSize).ToArray();
var index = 1;
float progress = 0;
foreach (var chunk in chunks)
{
if (executionContext.IsCancellationRequested)
{
executionContext.IsCancelled = true;
return;
}
var enumerable = chunk as int[] ?? chunk.ToArray();
_logger.LogInformation($"Chunk {index} with ids ({string.Join(",", enumerable)}) requested...");
var dataTasks = enumerable.Select(n => GetProductById(url, n));
ProductPostProcessorData[] data;
try
{
data = await Task.WhenAll(dataTasks);
}
catch (Exception ex)
{
string message = $"An error occurs while receiving products for chunk {index}";
_logger.LogError(ex, message);
executionContext.Result = ActionTaskResult.Error(message);
throw;
}
_logger.LogInformation($"Products from chunk {index} received. Starting bulk import...");
var result = await _manager.BulkCreateAsync(data, language, state, stores);
if (result.Succeeded)
{
_logger.LogInformation($"Bulk import for chunk {index} succeeded.");
index++;
}
else
{
string message = $"Cannot proceed bulk import for chunk {index}: {result}";
_logger.LogError(message);
executionContext.Result = ActionTaskResult.Error(message);
throw result.GetException();
}
progress += (float)100 / chunks.Length;
executionContext.SetProgress((byte)progress);
}
executionContext.Result = ActionTaskResult.Success("Import completed");
}
public override ActionTaskResult Process(ActionContext context)
{
int marketingProductContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.MARKETING_PRODUCT_CONTENT_ID));
int[] productIds = context.ContentId == marketingProductContentId
? Helpers.GetProductIdsFromMarketingProducts(context.ContentItemIds, _articleService, _settingsService)
: context.ContentItemIds;
if (productIds == null || productIds.Length == 0)
{
if (context.ContentId == marketingProductContentId)
{
throw new Exception("Unable to process all marketing products. Please, select specific ones");
}
productIds = Helpers.GetAllProductIds(int.Parse(context.Parameters["site_id"]), context.ContentId, _provider.GetCustomer());
}
object percentLocker = new object();
float percentPerProduct = (float)100 / productIds.Length;
float currentPercent = 0;
const byte tasksCount = 15;
const int minBundleSize = 15;
int bundleSize = Math.Max(productIds.Length / tasksCount, minBundleSize);
var sectionedProductIds = productIds.Section(bundleSize).ToArray();
var tasks = sectionedProductIds
.Select(x => Task.Factory.StartNew(
productIdsInSection =>
{
var productRelevanceService = ObjectFactoryBase.Resolve <IProductRelevanceService>();
var productService = ObjectFactoryBase.Resolve <IProductService>();
foreach (int productId in (IList <int>)productIdsInSection)
{
foreach (var isLive in new[] { true, false })
{
var product = productService.GetProductById(productId, isLive);
var relevanceItems = productRelevanceService.GetProductRelevance(product, isLive, true);
foreach (var relevanceItem in relevanceItems)
{
var consumerMonitoringService = _consumerMonitoringServiceFunc(true, relevanceItem.Culture);
if (consumerMonitoringService != null)
{
consumerMonitoringService.InsertOrUpdateProductRelevanceStatus(productId, relevanceItem.Relevance, isLive);
}
if (TaskContext.IsCancellationRequested)
{
TaskContext.IsCancelled = true;
return;
}
}
}
if (TaskContext.IsCancellationRequested)
{
TaskContext.IsCancelled = true;
return;
}
lock (percentLocker)
{
currentPercent += percentPerProduct;
}
TaskContext.SetProgress((byte)currentPercent);
}
},
x,
TaskCreationOptions.LongRunning))
.ToArray();
Task.WaitAll(tasks);
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.StatusesUpdated),
Parameters = new object[] { productIds.Length }
}));
}
public override ActionTaskResult Process(ActionContext context)
{
bool canProcess = false;
lock (Locker)
{
if (!IsProcessing)
{
IsProcessing = true;
canProcess = true;
}
}
if (canProcess)
{
try
{
if (!int.TryParse(_settingsService.GetSetting(SettingsTitles.PRODUCTVERSION_CHUNK_SIZE), out int chunkSize))
{
chunkSize = DefaultChunkSize;
}
if (!int.TryParse(_settingsService.GetSetting(SettingsTitles.PRODUCTVERSION_TIMEOUT), out int timeout))
{
timeout = DefaultTimeout;
}
if (!int.TryParse(_settingsService.GetSetting(SettingsTitles.PRODUCTVERSION_CLEANUP_INTERVAL), out int cleanupInterval))
{
throw new Exception($"Setting {SettingsTitles.PRODUCTVERSION_CLEANUP_INTERVAL} is not provided or incorrect");
}
var date = DateTime.Now.AddDays(-cleanupInterval);
var expectedTotalCount = GetVersionsCount(date);
int processedCount = 0;
int currentCount = 0;
byte progress = 0;
Logger.Info($"Start CleanProductVersionAction cleanupInterval={cleanupInterval}, chunkSize={chunkSize}, expectedTotalCount={expectedTotalCount}");
do
{
currentCount = CleanVersions(date, chunkSize, timeout);
processedCount += currentCount;
Logger.Info($"Clean {currentCount} product versions");
progress = expectedTotalCount == 0 ? (byte)100 : Math.Min((byte)(processedCount * 100 / expectedTotalCount), (byte)100);
TaskContext.SetProgress(progress);
if (TaskContext.IsCancellationRequested)
{
TaskContext.IsCancelled = true;
break;
}
}while (currentCount > 0);
Logger.Info($"End CleanProductVersionAction processedCount={processedCount}");
return(ActionTaskResult.Success(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.VersionsCleaned),
Parameters = new object[] { processedCount, date, chunkSize }
}));
}
finally
{
IsProcessing = false;
}
}
return(ActionTaskResult.Error(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ActionRunning),
Parameters = new object[] { GetType().Name }
}));
}