private void ConvertToExport(Process process, PipelineConfigurationPart part, IDictionary <string, string> parameters)
{
var fileName = _slugService.Slugify(part.Title()) + ".csv";
var o = process.Output();
o.Provider = "file";
o.Delimiter = ",";
o.File = fileName;
parameters["page"] = "0";
foreach (var entity in process.Entities)
{
entity.Page = 0;
foreach (var field in entity.GetAllFields())
{
field.T = "";
if (field.Output && field.Raw && field.Transforms.Any())
{
var lastTransform = field.Transforms.Last();
if (lastTransform.Method.In("tag", "razor"))
{
var firstParameter = lastTransform.Parameters.First();
field.Transforms.Remove(lastTransform);
field.T = "copy(" + firstParameter.Field + ")";
}
}
}
}
}
protected override void Load(ContainerBuilder builder)
{
if (_process == null)
{
return;
}
if (!_process.Enabled)
{
return;
}
builder.Register <IProcessController>(ctx => {
var pipelines = new List <IPipeline>();
// entity-level pipelines
foreach (var entity in _process.Entities)
{
var pipeline = ctx.ResolveNamed <IPipeline>(entity.Key);
pipelines.Add(pipeline);
if (entity.Delete && _process.Mode != "init")
{
pipeline.Register(ctx.ResolveNamed <IEntityDeleteHandler>(entity.Key));
}
}
// process-level pipeline for process level calculated fields
if (ctx.IsRegistered <IPipeline>())
{
pipelines.Add(ctx.Resolve <IPipeline>());
}
var outputConnection = _process.Output();
var context = ctx.Resolve <IContext>();
var controller = new ProcessController(pipelines, context);
// output initialization
if (_process.Mode == "init")
{
var output = ctx.ResolveNamed <OutputContext>(outputConnection.Key);
switch (outputConnection.Provider)
{
case "mysql":
case "postgresql":
case "sqlite":
case "sqlserver":
case "elasticsearch":
case "lucene":
controller.PreActions.Add(ctx.Resolve <IInitializer>());
break;
default:
output.Warn("The {0} provider does not support initialization.", outputConnection.Provider);
break;
}
}
// input validation
if (_process.Mode == "init")
{
var providers = _process.Connections.Select(c => c.Provider).Distinct();
foreach (var provider in providers)
{
switch (provider)
{
case "solr":
foreach (var cn in _process.Connections.Where(c => c.Provider == "solr"))
{
var connection = cn;
foreach (var entity in _process.Entities.Where(e => e.Connection == connection.Name))
{
controller.PreActions.Add(ctx.ResolveNamed <IInputValidator>(entity.Key));
}
}
break;
}
}
}
// templates
foreach (var template in _process.Templates.Where(t => t.Enabled).Where(t => t.Actions.Any(a => a.GetModes().Any(m => m == _process.Mode))))
{
controller.PreActions.Add(new RenderTemplateAction(template, ctx.ResolveNamed <ITemplateEngine>(template.Key)));
foreach (var action in template.Actions.Where(a => a.GetModes().Any(m => m == _process.Mode || m == "*")))
{
if (action.Before)
{
controller.PreActions.Add(ctx.ResolveNamed <IAction>(action.Key));
}
if (action.After)
{
controller.PostActions.Add(ctx.ResolveNamed <IAction>(action.Key));
}
}
}
// actions
foreach (var action in _process.Actions.Where(a => a.GetModes().Any(m => m == _process.Mode || m == "*")))
{
if (action.Before)
{
controller.PreActions.Add(ctx.ResolveNamed <IAction>(action.Key));
}
if (action.After)
{
controller.PostActions.Add(ctx.ResolveNamed <IAction>(action.Key));
}
}
foreach (var map in _process.Maps.Where(m => !string.IsNullOrEmpty(m.Query)))
{
controller.PreActions.Add(new MapReaderAction(context, map, ctx.ResolveNamed <IMapReader>(map.Name)));
}
return(controller);
}).As <IProcessController>();
}
public ActionResult Report(int id)
{
var timer = new Stopwatch();
timer.Start();
var process = new Process {
Name = "Report"
}.WithDefaults();
var part = _orchardServices.ContentManager.Get(id).As <PipelineConfigurationPart>();
if (part == null)
{
process.Name = "Not Found";
}
else
{
if (_orchardServices.Authorizer.Authorize(Permissions.ViewContent, part))
{
process = _processService.Resolve(part.EditorMode, part.EditorMode);
var parameters = Common.GetParameters(Request, _secureFileService, _orchardServices);
if (part.NeedsInputFile && Convert.ToInt32(parameters[Common.InputFileIdName]) == 0)
{
_orchardServices.Notifier.Add(NotifyType.Error, T("This transformalize expects a file."));
process.Name = "File Not Found";
}
process.Load(part.Configuration, parameters);
var provider = process.Output().Provider;
if (provider.In("internal", "file"))
{
// change process for export purposes
var output = Request["output"] ?? "page";
if (part.Reportable && output != "page")
{
ConvertToExport(process, part, parameters);
process.Load(process.Serialize(), parameters);
Response.AddHeader("content-disposition", "attachment; filename=" + process.Output().File);
Response.ContentType = "application/csv";
}
if (Request["sort"] != null)
{
_sortService.AddSortToEntity(process.Entities.First(), Request["sort"]);
}
if (process.Errors().Any())
{
foreach (var error in process.Errors())
{
_orchardServices.Notifier.Add(NotifyType.Error, T(error));
}
}
else
{
if (process.Entities.Any(e => !e.Fields.Any(f => f.Input)))
{
_orchardServices.WorkContext.Resolve <ISchemaHelper>().Help(process);
}
if (!process.Errors().Any())
{
Common.PageHelper(process, parameters);
var runner = _orchardServices.WorkContext.Resolve <IRunTimeExecute>();
try {
runner.Execute(process);
process.Status = 200;
process.Message = "Ok";
process.Request = "Run";
process.Time = timer.ElapsedMilliseconds;
if (process.Output().Provider == "file")
{
Response.Flush();
Response.End();
}
} catch (Exception ex) {
Logger.Error(ex, ex.Message);
_orchardServices.Notifier.Error(T(ex.Message));
}
}
}
}
}
else
{
_orchardServices.Notifier.Warning(T("Output must be set to internal for reporting."));
}
}
return(View(new ReportViewModel(process, part)));
}
public void Execute(Process process)
{
process.Mode = _mode;
// Since we're in a Console app, and honor output format
if (process.Output().Provider.In("internal", "console"))
{
process.Output().Provider = "console";
process.Output().Format = _format;
}
var logger = new NLogPipelineLogger(SlugifyTransform.Slugify(_cfg));
if (!string.IsNullOrEmpty(process.MaxMemory))
{
var context = new PipelineContext(logger, process);
var timer = new Stopwatch();
timer.Start();
GC.Collect();
GC.WaitForPendingFinalizers();
timer.Stop();
context.Info($"Collected free memory. Time taken: {timer.Elapsed}.");
var currentBytes = System.Diagnostics.Process.GetCurrentProcess().WorkingSet64.Bytes();
var maxMemory = ByteSize.Parse(process.MaxMemory);
if (maxMemory.CompareTo(currentBytes) < 0)
{
context.Error($"Process exceeded {maxMemory.Megabytes.ToString("#.0")} Mb. Current memory is {currentBytes.Megabytes.ToString("#.0")} Mb!");
Environment.Exit(1);
}
else
{
context.Info($"The process is using {currentBytes.Megabytes.ToString("#.0")} Mb of it's max {maxMemory.Megabytes.ToString("#.0")} Mb allowed.");
}
}
var builder = new ContainerBuilder();
builder.RegisterInstance(logger).As <IPipelineLogger>().SingleInstance();
builder.RegisterCallback(new RootModule(process.Shorthand).Configure);
builder.RegisterCallback(new ContextModule(process).Configure);
// providers
builder.RegisterCallback(new AdoModule(process).Configure);
builder.RegisterCallback(new LuceneModule(process).Configure);
builder.RegisterCallback(new SolrModule(process).Configure);
builder.RegisterCallback(new ElasticModule(process).Configure);
builder.RegisterCallback(new InternalModule(process).Configure);
builder.RegisterCallback(new FileModule(process).Configure);
builder.RegisterCallback(new FolderModule(process).Configure);
builder.RegisterCallback(new DirectoryModule(process).Configure);
builder.RegisterCallback(new ExcelModule(process).Configure);
builder.RegisterCallback(new WebModule(process).Configure);
builder.RegisterCallback(new MapModule(process).Configure);
builder.RegisterCallback(new TemplateModule(process).Configure);
builder.RegisterCallback(new ActionModule(process).Configure);
builder.RegisterCallback(new EntityPipelineModule(process).Configure);
builder.RegisterCallback(new ProcessPipelineModule(process).Configure);
builder.RegisterCallback(new ProcessControlModule(process).Configure);
using (var scope = builder.Build().BeginLifetimeScope()) {
try {
scope.Resolve <IProcessController>().Execute();
} catch (Exception ex) {
scope.Resolve <IContext>().Error(ex.Message);
}
}
}