public void BulkUpdateSerializesCorrectly()
{
var source = new BulkActionRequest(BulkActionType.Update)
{
Document = new { doc = new { field = "value" } }
};
var result = JsonConvert.SerializeObject(source);
Assert.Equal("{\"update\":{}}\n{\"doc\":{\"field\":\"value\"}}\n", result);
}
public void EmptyBulkActionSerializesCorrectly()
{
var source = new BulkActionRequest(BulkActionType.Index)
{
Document = new { field = "value" }
};
var result = JsonConvert.SerializeObject(source);
Assert.Equal("{\"index\":{}}\n{\"field\":\"value\"}\n", result);
}
public void FullBulkActionSerializesCorrectly()
{
var source = new BulkActionRequest(BulkActionType.Index)
{
ID = "1",
Index = "sample",
Type = "_doc",
Document = new { field = "value" }
};
var result = JsonConvert.SerializeObject(source);
Assert.Equal("{\"index\":{\"_id\":\"1\",\"_index\":\"sample\",\"_type\":\"_doc\"}}\n{\"field\":\"value\"}\n", result);
}
public Task BulkActionHmrc_HmrcSettingsAsync(int businessId, BulkActionRequest model, CancellationToken cancellationToken = default)
{
return(ApiRequestAsync($"/admin/business/{businessId}/bulkaction/hmrc", model, Method.POST, cancellationToken));
}
public void BulkActionHmrc_HmrcSettings(int businessId, BulkActionRequest model)
{
ApiRequest($"/admin/business/{businessId}/bulkaction/hmrc", model, Method.POST);
}
public async Task <ActionResult> Create(BulkActionRequest request)
{
var userName = HttpContext.User.Identity.Name;
var report = await _reportService.Validate(new TransformalizeRequest(request.ContentItemId, userName));
if (report.Fails())
{
return(report.ActionResult);
}
var referrer = Request.Headers.ContainsKey("Referer") ? Request.Headers["Referer"].ToString() : Url.Action("Index", "Report", new { request.ContentItemId });
// confirm we have an action registered in the report
if (report.Process.Actions.Any(a => a.Name == request.ActionName))
{
var bulkAction = await _taskService.Validate(new TransformalizeRequest(request.ActionName, userName) { Secure = false });
if (bulkAction.Fails() && bulkAction.Process.Message != Common.InvalidParametersMessage)
{
return(bulkAction.ActionResult);
}
var taskNames = _settingsService.GetBulkActionTaskNames(report.Part);
#region batch creation
var user = await _userService.GetUserAsync(userName) as User;
var createParameters = new Dictionary <string, string> {
{ Common.TaskReferrer, referrer },
{ Common.TaskContentItemId, bulkAction.ContentItem.ContentItemId },
{ Common.ReportContentItemId, report.ContentItem.ContentItemId },
{ "UserId", user.Id.ToString() },
{ "UserName", user.UserName },
{ "UserEmail", user.Email },
{ "ReportId", report.ContentItem.Id.ToString() },
{ "ReportContentItemVersionId", report.ContentItem.ContentItemVersionId },
{ "ReportTitle", report.ContentItem.DisplayText },
{ "TaskId", bulkAction.ContentItem.ContentItemId },
{ "TaskContentItemVersionId", bulkAction.ContentItem.ContentItemVersionId },
{ "TaskTitle", bulkAction.ContentItem.DisplayText },
{ "Description", report.Process.Actions.First(a => a.Name == request.ActionName).Description }
};
var create = await _taskService.Validate(new TransformalizeRequest(taskNames.Create, userName) { Secure = false, InternalParameters = createParameters });
if (create.Fails())
{
return(create.ActionResult);
}
await _taskService.RunAsync(create.Process);
if (create.Process.Status != 200)
{
_logger.Warn(() => $"User {userName} received error running action {taskNames.Create}.");
return(View("Log", new LogViewModel(_logger.Log, create.Process, create.ContentItem)));
}
var entity = create.Process.Entities.FirstOrDefault();
if (entity == null)
{
_logger.Error(() => $"The {taskNames.Create} task is missing an entity. It needs an entity with at least one row that returns one row of data (e.g. the BatchId).");
return(View("Log", new LogViewModel(_logger.Log, create.Process, create.ContentItem)));
}
if (!entity.Rows.Any())
{
_logger.Error(() => $"The {taskNames.Create} task didn't produce a row (e.g. a single row with a BatchId need to associate the batch values with this batch).");
return(View("Log", new LogViewModel(_logger.Log, create.Process, create.ContentItem)));
}
#endregion
#region batch writing
var writeParameters = new Dictionary <string, string> {
{ Common.TaskReferrer, referrer },
{ Common.TaskContentItemId, bulkAction.ContentItem.ContentItemId },
{ Common.ReportContentItemId, report.ContentItem.ContentItemId }
};
foreach (var field in entity.GetAllOutputFields())
{
writeParameters[field.Alias] = entity.Rows[0][field.Alias].ToString();
}
var write = await _taskService.Validate(new TransformalizeRequest(taskNames.Write, userName) { Secure = false, InternalParameters = writeParameters });
if (write.Fails())
{
return(write.ActionResult);
}
// potential memory problem (could be solved by merging report and batch write into one process)
var writeEntity = write.Process.Entities.First();
var batchValueField = writeEntity.Fields.LastOrDefault(f => f.Input && f.Output);
if (batchValueField == null)
{
_logger.Error(() => $"Could not identify batch value field in {taskNames.Write}.");
return(View("Log", new LogViewModel(_logger.Log, write.Process, write.ContentItem)));
}
if (request.ActionCount == 0)
{
var batchProcess = _reportService.LoadForBatch(report.ContentItem);
await _taskService.RunAsync(batchProcess);
foreach (var batchRow in batchProcess.Entities.First().Rows)
{
var row = new Transformalize.Impl.CfgRow(new[] { batchValueField.Alias });
row[batchValueField.Alias] = batchRow[report.Part.BulkActionValueField.Text];
writeEntity.Rows.Add(row);
}
}
else
{
foreach (var batchValue in request.Records)
{
var row = new Transformalize.Impl.CfgRow(new[] { batchValueField.Alias });
row[batchValueField.Alias] = batchValue;
writeEntity.Rows.Add(row);
}
}
await _taskService.RunAsync(write.Process);
#endregion
return(RedirectToAction("Review", ParametersToRouteValues(writeParameters)));
}
else
{
_logger.Warn(() => $"User {userName} called missing action {request.ActionName} in {report.ContentItem.DisplayText}.");
}
return(View("Log", new LogViewModel(_logger.Log, report.Process, report.ContentItem)));
}
