protected ActionResult Error(ActionException exception)
{
if (exception.InnerExceptions.Any())
{
var sb = new StringBuilder(TaskStrings.ProductsNotProcessed);
foreach (var ex in exception.InnerExceptions.OfType <ProductException>())
{
sb.AppendLine();
var exText = ex.Message;
var rm = new ResourceManager(typeof(TaskStrings));
var result = ActionTaskResult.FromString(exText);
var resource = rm.GetString(exText);
if (result != null)
{
exText = result.ToString();
}
else if (resource != null && resource.Contains("{0}"))
{
exText = string.Format(resource, ex.ProductId);
}
else
{
exText = $"{ex.ProductId}: {exText}";
if (ex.InnerException != null)
{
exText += ". " + ex.InnerException.Message;
}
}
sb.AppendFormat(exText);
}
return(Error(sb.ToString()));
}
else
{
return(Error(exception.Message));
}
}
public override ActionTaskResult Process(ActionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (context.ContentItemIds == null || context.ContentItemIds.Length == 0)
{
throw new ArgumentException("ContentItemIds cant be empty", "context.ContentItemIds");
}
UserId = context.UserId;
UserName = context.UserName;
OnStartProcess();
var exceptions = new List <ProductException>();
int index = 0;
foreach (int id in context.ContentItemIds)
{
if (TaskContext.IsCancellationRequested)
{
TaskContext.IsCancelled = true;
break;
}
try
{
using (var transaction = CreateTransaction())
{
ProcessProduct(id, context.Parameters ?? new Dictionary <string, string>());
transaction.Commit();
}
byte progress = (byte)(++index * 100 / context.ContentItemIds.Length);
TaskContext.SetProgress(progress);
}
catch (ProductException pex)
{
var logLevel = pex.IsError ? LogLevel.Error : LogLevel.Info;
var builder = Logger.Log(logLevel).Message(LoggerMessage + id);
var result = ActionTaskResult.FromString(pex.Message);
var msg = ResourceManager.GetString(pex.Message);
if (result != null)
{
builder.Property("taskResult", result.ToString());
}
else if (msg != null)
{
builder.Property("taskResult", string.Format(msg, id));
}
else
{
builder.Exception(pex);
}
builder.Write();
exceptions.Add(pex);
}
catch (AggregateException aex)
{
foreach (var iex in aex.InnerExceptions)
{
var ipex = iex as ProductException;
if (ipex == null)
{
ipex = new ProductException(id, nameof(TaskStrings.ActionErrorMessage), iex);
}
Logger.Error().Message(LoggerMessage + id).Exception(ipex).Write();
exceptions.Add(ipex);
}
}
catch (Exception ex)
{
Logger.Error().Message(LoggerMessage + id).Exception(ex).Write();
exceptions.Add(new ProductException(id, nameof(TaskStrings.ServerError), ex));
}
}
try
{
OnEndProcess();
}
catch (Exception ex)
{
exceptions.Add(new ProductException(0, "OnEndProcess error", ex));
}
if (exceptions.Any())
{
throw new ActionException(TaskStrings.ActionErrorMessage, exceptions, context);
}
return(null);
}
public void Run(string data, ITaskExecutionContext executionContext)
{
TaskContext = executionContext;
ActionData = ActionData.Deserialize(data);
var context = ActionData.ActionContext;
ActionTaskResult processResult = new ActionTaskResult();
IEnumerable <IGrouping <string, int> > errors = null;
var ids = context.ContentItemIds;
try
{
Logger.Info()
.Message("{action} has been started", GetType().Name)
.Property("taskId", TaskContext.TaskId)
.Property("context", context)
.Write();
HttpContextUserProvider.ForcedUserId = context.UserId;
processResult = Process(context) ?? new ActionTaskResult();
HttpContextUserProvider.ForcedUserId = 0;
}
catch (ActionException ex)
{
var failedIds = ex.InnerExceptions.OfType <ProductException>().Select(x => x.ProductId);
processResult.FailedIds = processResult.FailedIds.Union(failedIds).ToArray();
errors = ex.InnerExceptions
.OfType <ProductException>()
.GroupBy(
e => e.InnerException == null ? e.Message : e.Message + " : " + e.InnerException.Message,
e => e.ProductId
);
}
if (!executionContext.IsCancelled)
{
ids = ids.Except(processResult.FailedIds).ToArray();
if (ids.Any())
{
processResult.IsSuccess = true;
var idsStr = string.Join(", ", ids);
processResult.Messages.Add(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = nameof(TaskStrings.ArticlesProcessed),
Parameters = new object[] { idsStr }
});
}
if (errors != null)
{
foreach (var err in errors)
{
var result = ActionTaskResult.FromString(err.Key);
if (result != null)
{
if (result.Messages != null && result.Messages.Any())
{
processResult.Messages.AddRange(result.Messages);
}
}
else
{
processResult.Messages.Add(new ActionTaskResultMessage()
{
ResourceClass = nameof(TaskStrings),
ResourceName = err.Key,
Parameters = new object[] { String.Join(",", err) }
});
}
}
}
}
executionContext.Result = processResult.GetMergedResult();
}