public TransformalizeResponse Run(TransformalizeRequest request)
{
var moduleVersion = _extensionManager.GetExtension("Transformalize.Orchard").Version;
var logger = new TransformalizeLogger(request.Part.Title(), request.Part.LogLevel, Logger, OrchardVersion, moduleVersion);
var processes = new List <Process>();
//transitioning to using TflRoot instead of string configuration
if (request.Root != null)
{
processes.AddRange(ProcessFactory.Create(request.Root, logger, request.Options));
}
else //legacy
{
processes.AddRange(ProcessFactory.Create(request.Configuration, logger, request.Options, request.Query));
}
for (var i = 0; i < processes.Count; i++)
{
var process = processes[i];
CreateInputOperation(process, request);
process.ExecuteScaler();
}
return(new TransformalizeResponse()
{
Processes = processes.ToArray(),
Log = logger.Dump().ToList()
});
}
public async Task <ActionResult> TransformalizeParameters(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Format = "xml"
};
var item = await _commonService.Validate(request);
string arrangement;
if (item.ContentItem.Has("TransformalizeTaskPart"))
{
arrangement = item.ContentItem.Content.TransformalizeTaskPart.Arrangement.Arrangement.Value;
}
else
{
arrangement = item.ContentItem.Content.TransformalizeReportPart.Arrangement.Arrangement.Value;
}
var process = new Process(_modifier.Modify(arrangement, item.ContentItem.Id, _parameterService.GetParameters()));
process.Connections.Clear();
if (item.Fails())
{
return(item.ActionResult);
}
return(new ContentResult()
{
Content = process.Serialize(), ContentType = request.ContentType
});
}
protected ApiResponse Run(
ApiRequest request,
TransformalizeRequest transformalizeRequest
)
{
var errorNumber = 500;
try {
errorNumber++;
var tflResponse = _transformalize.Run(transformalizeRequest);
errorNumber++;
return(new ApiResponse(
request,
transformalizeRequest.Configuration,
tflResponse
));
} catch (Exception ex) {
request.Status = errorNumber;
request.Message = ex.Message;
return(new ApiResponse(
request,
transformalizeRequest.Configuration,
new TransformalizeResponse()
));
}
}
public ActionResult Execute(int id)
{
Response.AddHeader("Access-Control-Allow-Origin", "*");
ConfigurationPart part;
ApiRequest request;
var query = _transformalize.GetQuery();
foreach (var rejection in _apiService.Rejections(id, out request, out part))
{
return(rejection.ContentResult(
query["format"],
query["flavor"]
));
}
request.RequestType = ApiRequestType.Execute;
_transformalize.InitializeFiles(part, query);
// ready
var processes = new TransformalizeResponse();
var transformalizeRequest = new TransformalizeRequest(part, query, null, Logger);
try {
processes = _transformalize.Run(transformalizeRequest);
} catch (Exception ex) {
request.Status = 500;
request.Message = ex.Message + " " + WebUtility.HtmlEncode(ex.StackTrace);
}
return(new ApiResponse(request, transformalizeRequest.Configuration, processes).ContentResult(
transformalizeRequest.Query["format"].ToString(),
transformalizeRequest.Query["flavor"].ToString()
));
}
public async Task <TransformalizeResponse <ContentPart> > Validate(TransformalizeRequest request)
{
var response = new TransformalizeResponse <ContentPart>(request.Format)
{
ContentItem = await GetByIdOrAliasAsync(request.ContentItemId)
};
if (response.ContentItem == null)
{
SetupNotFoundResponse(request, response);
return(response);
}
if (request.Secure && !CanAccess(response.ContentItem))
{
SetupPermissionsResponse(request, response);
return(response);
}
response.Process = LoadForSchema(response.ContentItem, request.Format);
if (response.Process.Status != 200)
{
SetupLoadErrorResponse(request, response);
return(response);
}
response.Valid = true;
return(response);
}
public async Task <ActionResult> Index(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Mode = "calendar"
};
var calendar = await _reportService.Validate(request);
if (calendar.Fails())
{
return(calendar.ActionResult);
}
await _reportService.RunAsync(calendar.Process);
if (calendar.Process.Status != 200)
{
return(View("Log", new LogViewModel(_logger.Log, calendar.Process, calendar.ContentItem)));
}
return(View(new ReportViewModel(calendar.Process, calendar.ContentItem, contentItemId)
{
Settings = _settings.Settings
}));
}
public async Task <ActionResult> StreamJson(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Mode = "stream"
};
var stream = await _reportService.Validate(request);
if (stream.Fails())
{
return(stream.ActionResult);
}
var o = stream.Process.GetOutputConnection();
o.Stream = true;
o.Provider = "json";
o.File = _slugService.Slugify(stream.ContentItem.As <TitlePart>().Title) + ".json";
Response.ContentType = "application/json";
Response.Headers.Add("content-disposition", "attachment; filename=" + o.File);
await _reportService.RunAsync(stream.Process);
return(new EmptyResult());
}
public ActionResult Load(int id)
{
Response.AddHeader("Access-Control-Allow-Origin", "*");
ConfigurationPart part;
ApiRequest request;
foreach (var rejection in _apiService.Rejections(id, out request, out part))
{
return(rejection.ContentResult(_query["format"], _query["flavor"]));
}
request.RequestType = ApiRequestType.Execute;
var root = new TflRoot(part.Configuration, _query);
TransformConfigurationForLoad(root);
var errors = root.Errors();
if (errors.Any())
{
request.Status = 500;
request.Message = string.Join(Environment.NewLine, errors);
return(new ApiResponse(request, root.ToString(), new TransformalizeResponse()).ContentResult(_query["format"], _query["flavor"]));
}
var transformalizeRequest = new TransformalizeRequest(part, _query, null, Logger, root);
return(Run(request, transformalizeRequest)
.ContentResult(_query["format"], _query["flavor"]));
}
public async Task <ActionResult> Index(string contentItemId, string format = "xml")
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Format = format
};
var task = await _schemaService.Validate(request);
if (task.Fails())
{
return(task.ActionResult);
}
var process = await _schemaService.GetSchemaAsync(task.Process);
if (format == null)
{
return(View("Log", new LogViewModel(_logger.Log, process, task.ContentItem)));
}
else
{
task.Process.Log.AddRange(_logger.Log);
task.Process.Connections.Clear();
return(new ContentResult()
{
Content = process.Serialize(), ContentType = request.ContentType
});
}
}
public async Task <ActionResult> Index(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Mode = "map"
};
var map = await _reportService.Validate(request);
if (map.Fails())
{
return(map.ActionResult);
}
if (string.IsNullOrEmpty(_settings.Settings.MapBoxToken))
{
_logger.Warn(() => $"User {request.User} requested map without mapbox token {request.ContentItemId}.");
map.Process.Status = 404;
map.Process.Message = "MapBox Token Not Found";
return(View("Log", new LogViewModel(_logger.Log, map.Process, map.ContentItem)));
}
await _reportService.RunAsync(map.Process);
if (map.Process.Status != 200)
{
return(View("Log", new LogViewModel(_logger.Log, map.Process, map.ContentItem)));
}
return(View(new ReportViewModel(map.Process, map.ContentItem, contentItemId)
{
Settings = _settings.Settings
}));
}
public async Task <ActionResult> Run(string contentItemId, string format = null)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Format = format,
InternalParameters = Common.GetFileParameters(Request)
};
var task = await _taskService.Validate(request);
if (task.Fails())
{
return(task.ActionResult);
}
await _taskService.RunAsync(task.Process);
if (format == null)
{
return(View("Log", new LogViewModel(_logger.Log, task.Process, task.ContentItem)));
}
else
{
task.Process.Log.AddRange(_logger.Log);
task.Process.Connections.Clear();
return(new ContentResult()
{
Content = task.Process.Serialize(), ContentType = request.ContentType
});
}
}
public async Task <ActionResult> StreamGeoJson(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Mode = "stream"
};
var stream = await _reportService.Validate(request);
if (stream.Fails())
{
return(stream.ActionResult);
}
var o = stream.Process.GetOutputConnection();
o.Stream = true;
o.Provider = "geojson";
o.File = _slugService.Slugify(stream.ContentItem.As <TitlePart>().Title) + ".geo.json";
// todo: these will have to be put in report part
var suppress = new HashSet <string>()
{
stream.Part.BulkActionValueField.Text, stream.Part.MapColorField.Text, stream.Part.MapDescriptionField.Text
};
var coordinates = new HashSet <string>()
{
stream.Part.MapLatitudeField.Text, stream.Part.MapLongitudeField.Text
};
foreach (var entity in stream.Process.Entities)
{
foreach (var field in entity.GetAllFields())
{
if (suppress.Contains(field.Alias))
{
field.Output = false;
field.Property = false;
field.Alias += "Suppressed";
}
else if (coordinates.Contains(field.Alias))
{
field.Property = field.Export == "true";
}
else
{
field.Property = field.Property || field.Output && field.Export == "defer" || field.Export == "true";
}
}
}
Response.ContentType = "application/vnd.geo+json";
Response.Headers.Add("content-disposition", "attachment; filename=" + o.File);
await _reportService.RunAsync(stream.Process);
return(new EmptyResult());
}
public void SetupNotFoundResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response)
{
_logger.Warn(() => $"User {request.User} requested missing content item {request.ContentItemId}.");
response.Process.Status = 404;
response.Process.Message = "Not Found";
if (request.Format == null)
{
response.ActionResult = LogResult(response);
}
else
{
response.ActionResult = ContentResult(request, response);
}
}
public void SetupLoadErrorResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response)
{
// process already has a non 200 status
_logger.Warn(() => $"User {request.User} received error trying to load {response.ContentItem.DisplayText}.");
if (request.Format == null)
{
response.ActionResult = LogResult(response);
}
else
{
response.Process.Connections.Clear();
response.Process.Log.AddRange(_logger.Log);
response.ActionResult = ContentResult(request, response);
}
}
public ActionResult Save(int id)
{
Response.AddHeader("Access-Control-Allow-Origin", "*");
ConfigurationPart part;
ApiRequest request;
foreach (var rejection in _apiService.Rejections(id, out request, out part))
{
return(rejection.ContentResult(_query["format"], _query["flavor"]));
}
request.RequestType = ApiRequestType.Execute;
_query.Add("data", Request.Form["data"]);
var transformalizeRequest = new TransformalizeRequest(part, _query, null, Logger);
return(Run(request, transformalizeRequest).ContentResult(_query["format"], _query["flavor"]));
}
public void SetupPermissionsResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response)
{
_logger.Warn(() => $"User {request.User} may not access {response.ContentItem.DisplayText}.");
response.Process = new Transformalize.Configuration.Process()
{
Name = "401", Status = 401, Message = "Unauthorized"
};
if (request.Format == null)
{
response.ActionResult = LogResult(response);
}
else
{
response.ActionResult = ContentResult(request, response);
}
}
public void SetupCustomErrorResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response, string error)
{
response.Process.Status = 500;
response.Process.Message = error;
_logger.Warn(() => $"User {request.User} received error trying to load {response.ContentItem.DisplayText}.");
if (request.Format == null)
{
response.ActionResult = LogResult(response);
}
else
{
response.Process.Connections.Clear();
response.Process.Log.AddRange(_logger.Log);
response.ActionResult = ContentResult(request, response);
}
}
public async Task <ActionResult> Stream(string contentItemId)
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Mode = "stream-calendar"
};
var map = await _reportService.Validate(request);
if (map.Fails())
{
return(map.ActionResult);
}
Response.ContentType = "application/json";
await _reportService.RunAsync(map.Process);
return(new EmptyResult());
}
public ActionResult MetaData(int id)
{
Response.AddHeader("Access-Control-Allow-Origin", "*");
ConfigurationPart part;
ApiRequest request;
var query = _transformalize.GetQuery();
foreach (var rejection in _apiService.Rejections(id, out request, out part))
{
return(rejection.ContentResult(
query["format"],
query["flavor"]
));
}
request.RequestType = ApiRequestType.MetaData;
var transformalizeRequest = new TransformalizeRequest(part, query, null, Logger);
var logger = new TransformalizeLogger(transformalizeRequest.Part.Title(), part.LogLevel, Logger, OrchardVersion, _moduleVersion);
var errors = transformalizeRequest.Root.Errors();
if (errors.Any())
{
var bad = new TransformalizeResponse();
request.Status = 501;
request.Message = "Configuration Problem" + errors.Length.Plural();
bad.Log.AddRange(errors.Select(p => new[] { DateTime.Now.ToString(CultureInfo.InvariantCulture), "error", ".", ".", p }));
return(new ApiResponse(request, "<tfl></tfl>", bad).ContentResult(
query["format"],
query["flavor"]
));
}
var metaData = new MetaDataWriter(ProcessFactory.CreateSingle(transformalizeRequest.Root.Processes[0], logger, new Options {
Mode = "metadata"
})).Write();
return(new ApiResponse(request, metaData).ContentResult(
query["format"],
query["flavor"]
));
}
public void SetupWrongTypeResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response)
{
response.Process.Status = 422;
response.Process.Message = Common.InvalidContentTypeMessage;
_logger.Warn(() => $"User {request.User} requested {response.ContentItem.ContentType} from the report service.");
if (request.Format == null)
{
response.ActionResult = LogResult(response);
}
else
{
response.Process.Connections.Clear();
response.ActionResult = new ContentResult {
Content = response.Process.Serialize(), ContentType = request.ContentType
};
}
}
public async Task <ActionResult> Run(string contentItemId, string format = "json")
{
var request = new TransformalizeRequest(contentItemId, HttpContext.User.Identity.Name)
{
Format = format
};
var report = await _reportService.Validate(request);
if (report.Fails())
{
return(report.ActionResult);
}
await _reportService.RunAsync(report.Process);
report.Process.Connections.Clear();
return(new ContentResult()
{
Content = report.Process.Serialize(), ContentType = request.ContentType
});
}
public void SetupInvalidParametersResponse <T>(TransformalizeRequest request, TransformalizeResponse <T> response)
{
response.Process.Status = 422;
response.Process.Message = Common.InvalidParametersMessage;
if (request.Format == null)
{
foreach (var parameter in response.Process.Parameters.Where(p => !p.Valid))
{
foreach (var message in parameter.Message.Split('|'))
{
_logger.Warn(() => message.Replace("{", "{{").Replace("}", "}}"));
}
}
response.ActionResult = LogResult(response);
}
else
{
response.Process.Connections.Clear();
response.Process.Log.AddRange(_logger.Log);
response.ActionResult = ContentResult(request, response);
}
}
private ExecuteViewModel Run(TransformalizeRequest request)
{
var model = new ExecuteViewModel {
DisplayLog = request.Part.DisplayLog
};
if (request.Part.TryCatch)
{
try {
model.TransformalizeResponse = _transformalize.Run(request);
} catch (Exception ex) {
model.DisplayLog = true;
model.TransformalizeResponse.Log.Add(new[] { DateTime.Now.ToString(), "error", "orchard", ".", ex.Message });
model.TransformalizeResponse.Log.Add(new[] { DateTime.Now.ToString(), "debug", "orchard", ".", ex.StackTrace });
Logger.Error(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
else
{
model.TransformalizeResponse = _transformalize.Run(request);
}
return(model);
}
public async Task <TransformalizeResponse <ContentPart> > Validate(TransformalizeRequest request)
{
var response = new TransformalizeResponse <ContentPart>(request.Format)
{
ContentItem = await GetByIdOrAliasAsync(request.ContentItemId)
};
if (response.ContentItem == null)
{
SetupNotFoundResponse(request, response);
return(response);
}
if (request.Secure && !CanAccess(response.ContentItem))
{
SetupPermissionsResponse(request, response);
return(response);
}
// part and process left null
response.Valid = true;
return(response);
}
public void SetupPermissionsResponse <TPart>(TransformalizeRequest request, TransformalizeResponse <TPart> response)
{
_arrangementService.SetupPermissionsResponse(request, response);
}
public void SetupInvalidParametersResponse <TPart>(TransformalizeRequest request, TransformalizeResponse <TPart> response)
{
_arrangementService.SetupInvalidParametersResponse(request, response);
}
public async Task <TransformalizeResponse <TransformalizeTaskPart> > Validate(TransformalizeRequest request)
{
var response = new TransformalizeResponse <TransformalizeTaskPart>(request.Format)
{
ContentItem = await GetByIdOrAliasAsync(request.ContentItemId)
};
if (response.ContentItem == null)
{
SetupNotFoundResponse(request, response);
return(response);
}
if (request.Secure && !CanAccess(response.ContentItem))
{
SetupPermissionsResponse(request, response);
return(response);
}
response.Part = response.ContentItem.As <TransformalizeTaskPart>();
if (response.Part == null)
{
SetupWrongTypeResponse(request, response);
return(response);
}
response.Process = LoadForTask(response.ContentItem, request.InternalParameters, request.Format);
if (response.Process.Status != 200)
{
SetupLoadErrorResponse(request, response);
return(response);
}
if (request.ValidateParameters && !response.Process.Parameters.All(p => p.Valid))
{
SetupInvalidParametersResponse(request, response);
return(response);
}
response.Valid = true;
return(response);
}
public void SetupCustomErrorResponse <TPart>(TransformalizeRequest request, TransformalizeResponse <TPart> response, string error)
{
_arrangementService.SetupCustomErrorResponse(request, response, error);
}
public void SetupWrongTypeResponse <T1>(TransformalizeRequest request, TransformalizeResponse <T1> response)
{
_arrangementService.SetupWrongTypeResponse(request, response);
}
public void SetupLoadErrorResponse <TPart>(TransformalizeRequest request, TransformalizeResponse <TPart> response)
{
_arrangementService.SetupLoadErrorResponse(request, response);
}
